feat(deisctl): add -ssh-timeout command-line option

Author: mboersma

deisctl/backend/fleet/registry.go

@@ -10,6 +10,7 @@ import (
 	"github.com/coreos/fleet/client"
 	"github.com/coreos/fleet/etcd"
 	"github.com/coreos/fleet/machine"
+	"github.com/coreos/fleet/pkg"
 	"github.com/coreos/fleet/registry"
 	"github.com/coreos/fleet/ssh"
 )
@@ -28,6 +29,7 @@ var Flags = struct {
 	StrictHostKeyChecking bool
 	Tunnel                string
 	RequestTimeout        float64
+	SSHTimeout            float64
 }{}
 
 const (
@@ -68,9 +70,10 @@ func getFakeClient() (*registry.FakeRegistry, error) {
 
 func getRegistryClient() (client.API, error) {
 	var dial func(string, string) (net.Conn, error)
+	sshTimeout := time.Duration(Flags.SSHTimeout*1000) * time.Millisecond
 	tun := getTunnelFlag()
 	if tun != "" {
-		sshClient, err := ssh.NewSSHClient("core", tun, getChecker(), false)
+		sshClient, err := ssh.NewSSHClient("core", tun, getChecker(), false, sshTimeout)
 		if err != nil {
 			return nil, fmt.Errorf("failed initializing SSH client: %v", err)
 		}
@@ -84,27 +87,27 @@ func getRegistryClient() (client.API, error) {
 		}
 	}
 
-	tlsConfig, err := etcd.ReadTLSConfigFiles(Flags.EtcdCAFile, Flags.EtcdCertFile, Flags.EtcdKeyFile)
+	tlsConfig, err := pkg.ReadTLSConfigFiles(Flags.EtcdCAFile, Flags.EtcdCertFile, Flags.EtcdKeyFile)
 	if err != nil {
 		return nil, err
 	}
 
-	trans := http.Transport{
+	trans := &http.Transport{
 		Dial:            dial,
 		TLSClientConfig: tlsConfig,
 	}
 
 	timeout := time.Duration(Flags.RequestTimeout*1000) * time.Millisecond
 	machines := []string{Flags.Endpoint}
-	eClient, err := etcd.NewClient(machines, &trans, timeout)
+	eClient, err := etcd.NewClient(machines, trans, timeout)
 	if err != nil {
 		return nil, err
 	}
 
 	reg := registry.NewEtcdRegistry(eClient, Flags.EtcdKeyPrefix)
 
 	// if msg, ok := checkVersion(reg); !ok {
-	// 	fmt.Fprint(os.Stderr, msg)
+	// 	stderr(msg)
 	// }
 
 	return &client.RegistryClient{Registry: reg}, nil

deisctl/backend/fleet/ssh.go

@@ -6,6 +6,7 @@ import (
 	"os/exec"
 	"strings"
 	"syscall"
+	"time"
 
 	"github.com/coreos/fleet/machine"
 	"github.com/coreos/fleet/ssh"
@@ -25,7 +26,8 @@ func runCommand(cmd string, machID string) (retcode int) {
 		if err != nil || ms == nil {
 			fmt.Printf("Error getting machine IP: %v\n", err)
 		} else {
-			err, retcode = runRemoteCommand(cmd, ms.PublicIP)
+			sshTimeout := time.Duration(Flags.SSHTimeout*1000) * time.Millisecond
+			err, retcode = runRemoteCommand(cmd, ms.PublicIP, sshTimeout)
 			if err != nil {
 				fmt.Printf("Error running remote command: %v\n", err)
 			}
@@ -57,12 +59,12 @@ func runLocalCommand(cmd string) (error, int) {
 
 // runRemoteCommand runs the given command over SSH on the given IP, and returns
 // any error encountered and the exit status of the command
-func runRemoteCommand(cmd string, addr string) (err error, exit int) {
+func runRemoteCommand(cmd string, addr string, timeout time.Duration) (err error, exit int) {
 	var sshClient *ssh.SSHForwardingClient
 	if tun := getTunnelFlag(); tun != "" {
-		sshClient, err = ssh.NewTunnelledSSHClient("core", tun, addr, getChecker(), false)
+		sshClient, err = ssh.NewTunnelledSSHClient("core", tun, addr, getChecker(), false, timeout)
 	} else {
-		sshClient, err = ssh.NewSSHClient("core", addr, getChecker(), false)
+		sshClient, err = ssh.NewSSHClient("core", addr, getChecker(), false, timeout)
 	}
 	if err != nil {
 		return err, -1

deisctl/config/etcd.go

@@ -7,7 +7,7 @@ import (
 	"strings"
 	"time"
 
-	fleetEtcd "github.com/coreos/fleet/etcd"
+	"github.com/coreos/fleet/pkg"
 	"github.com/coreos/fleet/ssh"
 	"github.com/coreos/go-etcd/etcd"
 	"github.com/deis/deis/deisctl/backend/fleet"
@@ -52,9 +52,10 @@ func (c *etcdClient) Set(key string, value string) (string, error) {
 
 func getEtcdClient() (*etcdClient, error) {
 	var dial func(string, string) (net.Conn, error)
+	sshTimeout := time.Duration(fleet.Flags.SSHTimeout*1000) * time.Millisecond
 	tun := getTunnelFlag()
 	if tun != "" {
-		sshClient, err := ssh.NewSSHClient("core", tun, getChecker(), false)
+		sshClient, err := ssh.NewSSHClient("core", tun, getChecker(), false, sshTimeout)
 		if err != nil {
 			return nil, fmt.Errorf("failed initializing SSH client: %v", err)
 		}
@@ -68,7 +69,7 @@ func getEtcdClient() (*etcdClient, error) {
 		}
 	}
 
-	tlsConfig, err := fleetEtcd.ReadTLSConfigFiles(fleet.Flags.EtcdCAFile,
+	tlsConfig, err := pkg.ReadTLSConfigFiles(fleet.Flags.EtcdCAFile,
 		fleet.Flags.EtcdCertFile, fleet.Flags.EtcdKeyFile)
 	if err != nil {
 		return nil, err

deisctl/deisctl.go

@@ -52,6 +52,7 @@ Options:
   --etcd-keyfile=<path>       etcd key file authentication [default: ]
   --known-hosts-file=<path>   where to store remote fingerprints [default: ~/.ssh/known_hosts]
   --request-timeout=<secs>    seconds before a request is considered failed [default: 10.0]
+  --ssh-timeout=<secs>        seconds before SSH connection is considered failed [default: 10.0]
   --strict-host-key-checking  verify SSH host keys [default: true]
   --tunnel=<host>             SSH tunnel for communication with fleet and etcd [default: ]
   --version                   print the version of deisctl
@@ -134,9 +135,10 @@ func isGlobalArg(arg string) bool {
 		"--etcd-cafile=",
 		// "--experimental-api=",
 		"--known-hosts-file=",
-		"--strict-host-key-checking=",
 		"--request-timeout=",
-		"--tunnel",
+		"--ssh-timeout=",
+		"--strict-host-key-checking=",
+		"--tunnel=",
 	}
 	for _, p := range prefixes {
 		if strings.HasPrefix(arg, p) {
@@ -202,6 +204,8 @@ func setGlobalFlags(args map[string]interface{}, setTunnel bool) {
 	fleet.Flags.StrictHostKeyChecking = args["--strict-host-key-checking"].(bool)
 	timeout, _ := strconv.ParseFloat(args["--request-timeout"].(string), 64)
 	fleet.Flags.RequestTimeout = timeout
+	sshTimeout, _ := strconv.ParseFloat(args["--ssh-timeout"].(string), 64)
+	fleet.Flags.SSHTimeout = sshTimeout
 	if setTunnel == true {
 		tunnel := args["--tunnel"].(string)
 		if tunnel != "" {