Merge branch '91-simplify-dblab-cli' into 'master'

feat: simplify work with Database Lab CLI (port forwarding) (platform#91)

See merge request postgres-ai/database-lab!119

Author: agneum

cmd/cli/commands/client.go

@@ -6,6 +6,8 @@
 package commands
 
 import (
+	"net/url"
+
 	"github.com/urfave/cli/v2"
 
 	"gitlab.com/postgres-ai/database-lab/pkg/client/dblabapi"
@@ -17,12 +19,23 @@ const (
 	URLKey           = "url"
 	TokenKey         = "token"
 	InsecureKey      = "insecure"
+	FwServerURLKey   = "forwarding-server-url"
+	FwLocalPortKey   = "forwarding-local-port"
 )
 
 // ClientByCLIContext creates a new Database Lab API client.
 func ClientByCLIContext(cliCtx *cli.Context) (*dblabapi.Client, error) {
+	remoteURL, err := url.Parse(cliCtx.String(URLKey))
+	if err != nil {
+		return nil, err
+	}
+
+	if cliCtx.String(FwServerURLKey) != "" && cliCtx.String(FwLocalPortKey) != "" {
+		remoteURL.Host = BuildHostname(remoteURL.Hostname(), cliCtx.String(FwLocalPortKey))
+	}
+
 	options := dblabapi.Options{
-		Host:              cliCtx.String(URLKey),
+		Host:              remoteURL.String(),
 		VerificationToken: cliCtx.String(TokenKey),
 		Insecure:          cliCtx.Bool(InsecureKey),
 	}

cmd/cli/commands/clone/actions.go

@@ -8,12 +8,15 @@ package clone
 import (
 	"encoding/json"
 	"fmt"
+	"net/url"
 	"os"
+	"sync"
 
 	"github.com/urfave/cli/v2"
 
 	"gitlab.com/postgres-ai/database-lab/cmd/cli/commands"
 	"gitlab.com/postgres-ai/database-lab/pkg/client/dblabapi/types"
+	"gitlab.com/postgres-ai/database-lab/pkg/log"
 	"gitlab.com/postgres-ai/database-lab/pkg/models"
 	"gitlab.com/postgres-ai/database-lab/pkg/observer"
 )
@@ -249,3 +252,83 @@ func observeSummary() func(*cli.Context) error {
 		return nil
 	}
 }
+
+func forward(cliCtx *cli.Context) error {
+	remoteURL, err := url.Parse(cliCtx.String(commands.URLKey))
+	if err != nil {
+		return err
+	}
+
+	wg := &sync.WaitGroup{}
+
+	port, err := retrieveClonePort(cliCtx, wg, remoteURL.Host)
+	if err != nil {
+		return err
+	}
+
+	wg.Wait()
+
+	log.Dbg(fmt.Sprintf("The clone port has been retrieved: %s", port))
+
+	tunnel, err := commands.BuildTunnel(cliCtx, commands.BuildHostname(remoteURL.Hostname(), port))
+	if err != nil {
+		return err
+	}
+
+	if err := tunnel.Open(); err != nil {
+		return err
+	}
+
+	log.Msg(fmt.Sprintf("The clone is available by address: %s", tunnel.Endpoints.Local))
+
+	if err := tunnel.Listen(cliCtx.Context); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func retrieveClonePort(cliCtx *cli.Context, wg *sync.WaitGroup, remoteHost string) (string, error) {
+	tunnel, err := commands.BuildTunnel(cliCtx, remoteHost)
+	if err != nil {
+		return "", err
+	}
+
+	if err := tunnel.Open(); err != nil {
+		return "", err
+	}
+
+	const goroutineCount = 1
+
+	wg.Add(goroutineCount)
+
+	go func() {
+		defer wg.Done()
+
+		if err := tunnel.Listen(cliCtx.Context); err != nil {
+			log.Fatal(err)
+		}
+	}()
+
+	defer func() {
+		log.Dbg("Stop tunnel to DBLab")
+
+		if err := tunnel.Stop(); err != nil {
+			log.Err(err)
+		}
+	}()
+
+	log.Dbg("Retrieving clone port")
+
+	dblabClient, err := commands.ClientByCLIContext(cliCtx)
+	if err != nil {
+		return "", err
+	}
+
+	clone, err := dblabClient.GetClone(cliCtx.Context, cliCtx.Args().First())
+	if err != nil {
+		return "", err
+	}
+
+	return clone.DB.Port, nil
+}

cmd/cli/commands/clone/command_list.go

@@ -155,6 +155,22 @@ func CommandList() []*cli.Command {
 				Usage:  "[EXPERIMENTAL] summarize clone monitoring and check results",
 				Action: observeSummary(),
 			},
+			{
+				Name:  "port-forward",
+				Usage: "start port forwarding to clone",
+				Before: func(ctxCli *cli.Context) error {
+					if err := checkCloneIDBefore(ctxCli); err != nil {
+						return err
+					}
+
+					if err := commands.CheckForwardingServerURL(ctxCli); err != nil {
+						return err
+					}
+
+					return nil
+				},
+				Action: forward,
+			},
 		},
 	}}
 }

cmd/cli/commands/config/actions.go

@@ -16,6 +16,14 @@ import (
 	"gitlab.com/postgres-ai/database-lab/cmd/cli/commands"
 )
 
+// headers of a config list.
+const (
+	envHeader      = "ENV "
+	urlHeader      = "URL"
+	fwServerHeader = "Forwarding server URL"
+	fwPortHeader   = "Forwarding local port"
+)
+
 // createEnvironment creates a new CLI environment.
 func createEnvironment() func(*cli.Context) error {
 	return func(cliCtx *cli.Context) (err error) {
@@ -119,32 +127,54 @@ func list() func(*cli.Context) error {
 		}
 
 		environmentNames := make([]string, 0, len(cfg.Environments))
-		maxNameLength := 0
+		maxNameLen := 0
+		maxURLLen := len(urlHeader)
+		maxFwServerLen := len(fwServerHeader)
 
 		for environmentName := range cfg.Environments {
 			environmentNames = append(environmentNames, environmentName)
 
 			nameLength := len(environmentName)
-			if maxNameLength < nameLength {
-				maxNameLength = nameLength
+			if maxNameLen < nameLength {
+				maxNameLen = nameLength
+			}
+
+			urlLength := len(cfg.Environments[environmentName].URL)
+			if maxURLLen < urlLength {
+				maxURLLen = urlLength
+			}
+
+			urlFwLength := len(cfg.Environments[environmentName].Forwarding.ServerURL)
+			if maxFwServerLen < urlFwLength {
+				maxFwServerLen = urlFwLength
 			}
 		}
 
 		sort.Strings(environmentNames)
 
-		listOutput := buildListOutput(cfg, environmentNames, maxNameLength)
+		listOutput := buildListOutput(cfg, environmentNames, maxNameLen, maxURLLen, maxFwServerLen)
 
 		_, err = fmt.Fprintf(cliCtx.App.Writer, "Available CLI environments:\n%s", listOutput)
 
 		return commands.ToActionError(err)
 	}
 }
 
-func buildListOutput(cfg *CLIConfig, environmentNames []string, maxNameLength int) string {
+func buildListOutput(cfg *CLIConfig, environmentNames []string, maxNameLen, maxURLLen, maxFwLen int) string {
+	// TODO(akartasov): Draw as a table.
 	const outputAlign = 2
 
 	s := strings.Builder{}
 
+	s.WriteString(envHeader)
+	s.WriteString(strings.Repeat(" ", maxNameLen+outputAlign))
+	s.WriteString(urlHeader)
+	s.WriteString(strings.Repeat(" ", maxURLLen-len(urlHeader)+outputAlign))
+	s.WriteString(fwServerHeader)
+	s.WriteString(strings.Repeat(" ", maxFwLen-len(fwServerHeader)+outputAlign))
+	s.WriteString(fwPortHeader)
+	s.WriteString("\n")
+
 	for _, environmentName := range environmentNames {
 		if environmentName == cfg.CurrentEnvironment {
 			s.WriteString("[*] ")
@@ -153,8 +183,12 @@ func buildListOutput(cfg *CLIConfig, environmentNames []string, maxNameLength in
 		}
 
 		s.WriteString(environmentName)
-		s.WriteString(strings.Repeat(" ", maxNameLength-len(environmentName)+outputAlign))
+		s.WriteString(strings.Repeat(" ", maxNameLen-len(environmentName)+outputAlign))
 		s.WriteString(cfg.Environments[environmentName].URL)
+		s.WriteString(strings.Repeat(" ", maxURLLen-len(cfg.Environments[environmentName].URL)+outputAlign))
+		s.WriteString(cfg.Environments[environmentName].Forwarding.ServerURL)
+		s.WriteString(strings.Repeat(" ", maxFwLen-len(cfg.Environments[environmentName].Forwarding.ServerURL)+outputAlign))
+		s.WriteString(cfg.Environments[environmentName].Forwarding.LocalPort)
 		s.WriteString("\n")
 	}
 

cmd/cli/commands/config/command_list.go

@@ -37,6 +37,14 @@ func CommandList() []*cli.Command {
 							Name:  "insecure",
 							Usage: "allow insecure server connections when using SSL",
 						},
+						&cli.StringFlag{
+							Name:  "forwarding-server-url",
+							Usage: "forwarding server URL of Database Lab instance",
+						},
+						&cli.StringFlag{
+							Name:  "forwarding-local-port",
+							Usage: "local port for forwarding to the Database Lab instance",
+						},
 					},
 				},
 				{
@@ -57,6 +65,14 @@ func CommandList() []*cli.Command {
 							Name:  "insecure",
 							Usage: "allow insecure server connections when using SSL",
 						},
+						&cli.StringFlag{
+							Name:  "forwarding-server-url",
+							Usage: "forwarding server URL of Database Lab instance",
+						},
+						&cli.StringFlag{
+							Name:  "forwarding-local-port",
+							Usage: "local port for forwarding to the Database Lab instance",
+						},
 					},
 				},
 				{

cmd/cli/commands/config/environment.go

@@ -13,17 +13,23 @@ import (
 
 // CLIConfig defines a format of CLI configuration.
 type CLIConfig struct {
-	Version            string                 `yaml:"version" json:"version"`
 	CurrentEnvironment string                 `yaml:"current_environment" json:"current_environment"`
 	Environments       map[string]Environment `yaml:"environments" json:"environments"`
 }
 
 // Environment defines a format of environment configuration.
 type Environment struct {
-	EnvironmentID string `yaml:"-" json:"environment_id"`
-	URL           string `yaml:"url" json:"url"`
-	Token         string `yaml:"token" json:"token"`
-	Insecure      bool   `yaml:"insecure" json:"insecure"`
+	EnvironmentID string     `yaml:"-" json:"environment_id"`
+	URL           string     `yaml:"url" json:"url"`
+	Token         string     `yaml:"token" json:"token"`
+	Insecure      bool       `yaml:"insecure" json:"insecure"`
+	Forwarding    Forwarding `yaml:"forwarding" json:"forwarding"`
+}
+
+// Forwarding defines configuration for port forwarding.
+type Forwarding struct {
+	ServerURL string `yaml:"server_url" json:"server_url"`
+	LocalPort string `yaml:"local_port" json:"local_port"`
 }
 
 // AddEnvironmentToConfig adds a new environment to CLIConfig.
@@ -40,6 +46,10 @@ func AddEnvironmentToConfig(c *cli.Context, cfg *CLIConfig, environmentID string
 		URL:      c.String(commands.URLKey),
 		Token:    c.String(commands.TokenKey),
 		Insecure: c.Bool(commands.InsecureKey),
+		Forwarding: Forwarding{
+			ServerURL: c.String(commands.FwServerURLKey),
+			LocalPort: c.String(commands.FwLocalPortKey),
+		},
 	}
 
 	if cfg.Environments == nil {
@@ -81,6 +91,14 @@ func updateEnvironmentInConfig(c *cli.Context, cfg *CLIConfig, environmentID str
 		newEnvironment.Insecure = c.Bool(commands.InsecureKey)
 	}
 
+	if c.IsSet(commands.FwServerURLKey) {
+		newEnvironment.Forwarding.ServerURL = c.String(commands.FwServerURLKey)
+	}
+
+	if c.IsSet(commands.FwLocalPortKey) {
+		newEnvironment.Forwarding.LocalPort = c.String(commands.FwLocalPortKey)
+	}
+
 	if newEnvironment == environment {
 		return errors.New("config unchanged. Set different option values to update.") // nolint
 	}

cmd/cli/commands/initialization/actions.go renamed to cmd/cli/commands/global/actions.go

@@ -2,18 +2,20 @@
 2020 © Postgres.ai
 */
 
-// Package initialization provides commands for a CLI initialization.
-package initialization
+// Package global provides general commands for CLI usage.
+package global
 
 import (
 	"fmt"
+	"net/url"
 	"os"
 
 	"github.com/pkg/errors"
 	"github.com/urfave/cli/v2"
 
 	"gitlab.com/postgres-ai/database-lab/cmd/cli/commands"
 	"gitlab.com/postgres-ai/database-lab/cmd/cli/commands/config"
+	"gitlab.com/postgres-ai/database-lab/pkg/log"
 )
 
 func initCLI(c *cli.Context) error {
@@ -37,8 +39,6 @@ func initCLI(c *cli.Context) error {
 		}
 	}
 
-	cfg.Version = c.App.Version
-
 	environmentID := c.String(commands.EnvironmentIDKey)
 	if err := config.AddEnvironmentToConfig(c, cfg, environmentID); err != nil {
 		return err
@@ -53,3 +53,33 @@ func initCLI(c *cli.Context) error {
 
 	return err
 }
+
+func forward(cliCtx *cli.Context) error {
+	remoteURL, err := url.Parse(cliCtx.String(commands.URLKey))
+	if err != nil {
+		return err
+	}
+
+	tunnel, err := commands.BuildTunnel(cliCtx, remoteURL.Host)
+	if err != nil {
+		return err
+	}
+
+	if err := tunnel.Open(); err != nil {
+		return err
+	}
+
+	defer func() {
+		if stopErr := tunnel.Stop(); err == nil {
+			err = stopErr
+		}
+	}()
+
+	log.Msg(fmt.Sprintf("The connection is available by address: %s", tunnel.Endpoints.Local))
+
+	if err := tunnel.Listen(cliCtx.Context); err != nil {
+		return err
+	}
+
+	return nil
+}