Merge pull request #120 from davrodpin/alias/cli-flags

Add flags to "start alias" command

Author: davrodpin

alias/alias.go

@@ -167,6 +167,13 @@ func (a Alias) ParseTunnelFlags() (*TunnelFlags, error) {
 	return tf, nil
 }
 
+// Merge overwrites certain Alias attributes based on the given TunnelFlags.
+func (a *Alias) Merge(tunnelFlags *TunnelFlags) {
+	a.Verbose = tunnelFlags.Verbose
+	a.Insecure = tunnelFlags.Insecure
+	a.Detach = tunnelFlags.Detach
+}
+
 func (a Alias) String() string {
 	return fmt.Sprintf("[verbose: %t, insecure: %t, detach: %t, source: %s, destination: %s, server: %s, key: %s, keep-alive-interval: %s, connection-retries: %d, wait-and-retry: %s, ssh-agent: %s, timeout: %s]",
 		a.Verbose,

alias/alias_test.go

@@ -10,6 +10,7 @@ import (
 	"strings"
 	"testing"
 	"text/template"
+	"time"
 
 	"github.com/davrodpin/mole/alias"
 )
@@ -241,6 +242,137 @@ func TestShowAll(t *testing.T) {
 	}
 }
 
+func TestAliasMerge(t *testing.T) {
+	keepAliveInterval, _ := time.ParseDuration("5s")
+
+	tests := []struct {
+		alias       alias.Alias
+		tunnelFlags *alias.TunnelFlags
+	}{
+		{
+			alias.Alias{
+				Verbose:           false,
+				Insecure:          false,
+				Detach:            false,
+				Source:            []string{"127.0.0.1:80"},
+				Destination:       []string{"172.17.0.100:8080"},
+				Server:            "[email protected]:22",
+				Key:               "path/to/key/1",
+				KeepAliveInterval: "3s",
+				ConnectionRetries: 3,
+				WaitAndRetry:      "10s",
+				SshAgent:          "path/to/sshagent",
+				Timeout:           "3s",
+			},
+			&alias.TunnelFlags{
+				Verbose:           true,
+				Insecure:          true,
+				Detach:            true,
+				Source:            alias.AddressInputList([]alias.AddressInput{alias.AddressInput{Host: "127.0.0.1", Port: "80"}}),
+				Destination:       alias.AddressInputList([]alias.AddressInput{alias.AddressInput{Host: "172.17.0.100", Port: "8080"}}),
+				Server:            alias.AddressInput{Host: "acme.com", Port: "22"},
+				Key:               "path/to/key/2",
+				KeepAliveInterval: keepAliveInterval,
+				ConnectionRetries: 10,
+			},
+		},
+	}
+
+	for id, test := range tests {
+		test.alias.Merge(test.tunnelFlags)
+
+		if test.alias.Verbose != test.tunnelFlags.Verbose {
+			t.Errorf("alias verbose doesn't match on test %d: expected: %t, value: %t", id, test.tunnelFlags.Verbose, test.alias.Verbose)
+		}
+
+		if test.alias.Insecure != test.tunnelFlags.Insecure {
+			t.Errorf("alias insecure doesn't match on test %d: expected: %t, value: %t", id, test.tunnelFlags.Insecure, test.alias.Insecure)
+		}
+
+		if test.alias.Detach != test.tunnelFlags.Detach {
+			t.Errorf("alias detach doesn't match on test %d: expected: %t, value: %t", id, test.tunnelFlags.Detach, test.alias.Detach)
+		}
+	}
+
+}
+
+func TestParseAlias(t *testing.T) {
+	kai, _ := time.ParseDuration("3s")
+	war, _ := time.ParseDuration("5s")
+	tim, _ := time.ParseDuration("1s")
+
+	flags := alias.TunnelFlags{
+		TunnelType:        "local",
+		Verbose:           false,
+		Insecure:          false,
+		Detach:            false,
+		Source:            alias.AddressInputList{alias.AddressInput{Host: "127.0.0.1", Port: "8080"}},
+		Destination:       alias.AddressInputList{alias.AddressInput{Host: "172.17.0.100", Port: "80"}},
+		Server:            alias.AddressInput{},
+		Key:               "path/to/key/1",
+		KeepAliveInterval: kai,
+		ConnectionRetries: 3,
+		WaitAndRetry:      war,
+		SshAgent:          "path/to/sshagent",
+		Timeout:           tim,
+	}
+
+	al := flags.ParseAlias("aliasName")
+
+	if flags.TunnelType != al.TunnelType {
+		t.Errorf("tunnelType does not match: expected: %s, value: %s", flags.TunnelType, al.TunnelType)
+	}
+
+	if flags.Verbose != al.Verbose {
+		t.Errorf("verbose does not match: expected: %t, value: %t", flags.Verbose, al.Verbose)
+	}
+
+	if flags.Insecure != al.Insecure {
+		t.Errorf("insecure does not match: expected: %t, value: %t", flags.Insecure, al.Insecure)
+	}
+
+	if flags.Detach != al.Detach {
+		t.Errorf("detach does not match: expected: %t, value: %t", flags.Detach, al.Detach)
+	}
+
+	if !reflect.DeepEqual(flags.Source.List(), al.Source) {
+		t.Errorf("source does not match: expected: %s, value: %s", flags.Source.List(), al.Source)
+	}
+
+	if !reflect.DeepEqual(flags.Destination.List(), al.Destination) {
+		t.Errorf("destination does not match: expected: %s, value: %s", flags.Destination.List(), al.Destination)
+	}
+
+	if flags.Server.String() != al.Server {
+		t.Errorf("server does not match: expected: %s, value: %s", flags.Server.String(), al.Server)
+	}
+
+	if flags.Key != al.Key {
+		t.Errorf("key does not match: expected: %s, value: %s", flags.Key, al.Key)
+	}
+
+	if flags.KeepAliveInterval.String() != al.KeepAliveInterval {
+		t.Errorf("keep alive interval does not match: expected: %s, value: %s", flags.KeepAliveInterval.String(), al.KeepAliveInterval)
+	}
+
+	if flags.ConnectionRetries != al.ConnectionRetries {
+		t.Errorf("connection retries does not match: expected: %d, value: %d", flags.ConnectionRetries, al.ConnectionRetries)
+	}
+
+	if flags.WaitAndRetry.String() != al.WaitAndRetry {
+		t.Errorf("wait and retry does not match: expected: %s, value: %s", flags.WaitAndRetry.String(), al.WaitAndRetry)
+	}
+
+	if flags.SshAgent != al.SshAgent {
+		t.Errorf("ssh agent does not match: expected: %s, value: %s", flags.SshAgent, al.SshAgent)
+	}
+
+	if flags.Timeout.String() != al.Timeout {
+		t.Errorf("timeout does not match: expected: %s, value: %s", flags.Timeout.String(), al.Timeout)
+	}
+
+}
+
 func addAlias() (*alias.Alias, error) {
 	a := &alias.Alias{
 		Name:              "alias",

cmd/root.go

@@ -63,23 +63,23 @@ provide 0 to never give up or a negative number to disable`)
 	return nil
 }
 
-func start(alias string, tunnelFlags *alias.TunnelFlags) {
+func start(id string, tunnelFlags *alias.TunnelFlags) {
 	if tunnelFlags.Detach {
 		var err error
 
-		if alias == "" {
+		if id == "" {
 			u, err := uuid.NewV4()
 			if err != nil {
 				log.Errorf("error could not generate uuid: %v", err)
 				os.Exit(1)
 			}
-			alias = u.String()[:8]
+			id = u.String()[:8]
 		}
 
-		err = startDaemonProcess(alias)
+		err = startDaemonProcess(id)
 		if err != nil {
 			log.WithFields(log.Fields{
-				"alias": alias,
+				"id": id,
 			}).Errorf("error starting ssh tunnel: %v", err)
 			os.Exit(1)
 		}
@@ -204,12 +204,7 @@ func startDaemonProcess(aliasName string) error {
 	return nil
 }
 
-func startWithAlias(aliasName string) error {
-	a, err := alias.Get(aliasName)
-	if err != nil {
-		return err
-	}
-
+func startFromAlias(aliasName string, a *alias.Alias) error {
 	f, err := a.ParseTunnelFlags()
 	if err != nil {
 		return err

cmd/start_alias.go

@@ -4,14 +4,19 @@ import (
 	"errors"
 	"os"
 
+	"github.com/davrodpin/mole/alias"
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 )
 
 var startAliasCmd = &cobra.Command{
 	Use:   "alias [name]",
 	Short: "Starts a ssh tunnel by alias",
-	Long:  "Starts a ssh tunnel by alias",
+	Long: `Starts a ssh tunnel by alias
+
+The flags provided through this command can be used to override the one with the
+same name stored in the alias.
+`,
 	Args: func(cmd *cobra.Command, args []string) error {
 		if len(args) < 1 {
 			return errors.New("alias name not provided")
@@ -22,14 +27,28 @@ var startAliasCmd = &cobra.Command{
 		return nil
 	},
 	Run: func(cmd *cobra.Command, arg []string) {
-		err := startWithAlias(aliasName)
+		var err error
+
+		a, err := alias.Get(aliasName)
+		if err != nil {
+			log.WithError(err).Errorf("failed to start tunnel from alias %s", aliasName)
+			os.Exit(1)
+		}
+
+		a.Merge(tunnelFlags)
+
+		err = startFromAlias(aliasName, a)
 		if err != nil {
-			log.Errorf("failed to start tunnel: %v", err)
+			log.WithError(err).Errorf("failed to start tunnel from alias %s", aliasName)
 			os.Exit(1)
 		}
 	},
 }
 
 func init() {
+	startAliasCmd.Flags().BoolVarP(&tunnelFlags.Verbose, "verbose", "v", false, "increase log verbosity")
+	startAliasCmd.Flags().BoolVarP(&tunnelFlags.Insecure, "insecure", "i", false, "skip host key validation when connecting to ssh server")
+	startAliasCmd.Flags().BoolVarP(&tunnelFlags.Detach, "detach", "x", false, "run process in background")
+
 	startCmd.AddCommand(startAliasCmd)
 }

cmd/start_local.go

@@ -29,7 +29,9 @@ Destination endpoints are adrresess that can be reached from the jump server.
 }
 
 func init() {
-	err := bindFlags(tunnelFlags, localCmd)
+	var err error
+
+	err = bindFlags(tunnelFlags, localCmd)
 	if err != nil {
 		log.WithError(err).Error("error parsing command line arguments")
 		os.Exit(1)