fix: lazy SSH connection to host in testdevice

Previously, newHost dialed SSH immediately at device initialization,
causing failures when the host OS hadn't finished booting yet or when
running BMC-only suites that don't need host access.

Now the SSH connection is established on first use via ExecuteCommandLine.

Signed-off-by: llogen <christoph.lange@blindspot.software>

Author: llogen

pkg/bmc/bmc.go

@@ -0,0 +1,60 @@
+package bmc
+
+import (
+	"fmt"
+
+	"github.com/9elements/bmc-test-go/pkg/configuration"
+	"github.com/stmcginnis/gofish"
+)
+
+type BMC struct {
+	con            BMCConnection
+	redfishService *gofish.Service
+}
+
+func makeGofishConfig(config *configuration.Config) gofish.ClientConfig {
+	return gofish.ClientConfig{
+		Endpoint: "https://" + config.BMCHost,
+		Username: config.BMCUser,
+		Password: config.BMCPassword,
+		Insecure: true,
+	}
+}
+
+func NewBMC(execEnv string, cfg *configuration.Config) (*BMC, error) {
+	ret := &BMC{}
+	switch execEnv {
+	case "local":
+		ret.con = &LocalConn{}
+	case "remote":
+		hostport := fmt.Sprintf("%s:%s", cfg.BMCHost, cfg.SSHPort)
+		remoteConn, err := NewRemoteConn(hostport, cfg.BMCUser, cfg.BMCPassword)
+		if err != nil {
+			return nil, err
+		}
+		ret.con = remoteConn
+	default:
+		return nil, fmt.Errorf("unknown connection type: %s", execEnv)
+	}
+
+	conn, err := gofish.Connect(makeGofishConfig(cfg))
+	if err != nil {
+		return nil, err
+	}
+
+	ret.redfishService = conn.Service
+
+	return ret, nil
+}
+
+func (b *BMC) Close() error {
+	return b.con.Close()
+}
+
+func (b *BMC) ExecuteCommandLine(cmd string, args ...string) ([]byte, error) {
+	return b.con.ExecuteCmdline(cmd, args...)
+}
+
+func (b *BMC) RedfishService() *gofish.Service {
+	return b.redfishService
+}

pkg/bmc/interface.go

@@ -0,0 +1,6 @@
+package bmc
+
+type BMCConnection interface {
+	Close() error
+	ExecuteCmdline(cmd string, args ...string) ([]byte, error)
+}

pkg/bmc/localconn.go

@@ -0,0 +1,18 @@
+package bmc
+
+import "os/exec"
+
+type LocalConn struct{}
+
+func (l *LocalConn) ExecuteCmdline(cmd string, args ...string) ([]byte, error) {
+	command := exec.Command(cmd, args...)
+	resp, err := command.Output()
+	if err != nil {
+		return resp, err
+	}
+	return resp, nil
+}
+
+func (l *LocalConn) Close() error {
+	return nil
+}

pkg/bmc/remoteconn.go

@@ -0,0 +1,63 @@
+package bmc
+
+import (
+	"fmt"
+	"io"
+	"log"
+
+	"golang.org/x/crypto/ssh"
+)
+
+type RemoteConn struct {
+	IP       string
+	User     string
+	Password string
+	client   *ssh.Client
+}
+
+func NewRemoteConn(ip string, user string, password string) (*RemoteConn, error) {
+	sshConfig := &ssh.ClientConfig{
+		User: user,
+		Auth: []ssh.AuthMethod{ssh.Password(password)},
+	}
+	sshConfig.HostKeyCallback = ssh.InsecureIgnoreHostKey()
+
+	client, err := ssh.Dial("tcp", ip, sshConfig)
+	if err != nil {
+		return nil, err
+	}
+
+	return &RemoteConn{
+		IP:       ip,
+		User:     user,
+		Password: password,
+		client:   client,
+	}, nil
+}
+
+func (r *RemoteConn) Close() error {
+	return r.client.Close()
+}
+
+func (r *RemoteConn) ExecuteCmdline(cmd string, args ...string) ([]byte, error) {
+	session, err := r.client.NewSession()
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		if err := session.Close(); err != nil && err != io.EOF {
+			log.Print(err)
+		}
+	}()
+
+	cmdsArgs := cmd
+	for _, arg := range args {
+		cmdsArgs += fmt.Sprintf(" %s", arg)
+	}
+
+	resp, err := session.CombinedOutput(cmdsArgs)
+	if err != nil {
+		return resp, err
+	}
+	return resp, nil
+}

pkg/testdevice/host.go

@@ -9,8 +9,10 @@ import (
 )
 
 type Host struct {
-	Name string
-	RemoteConn
+	Name       string
+	hostport   string
+	sshConfig  *ssh.ClientConfig
+	remoteConn *RemoteConn
 }
 
 func newHost(sshPrivKeyPath string, hostCfg configuration.Host) (*Host, error) {
@@ -38,25 +40,39 @@ func newHost(sshPrivKeyPath string, hostCfg configuration.Host) (*Host, error) {
 		}
 	}
 
-	hostport := fmt.Sprintf("%s:%s", hostCfg.IP, hostCfg.SSHPort)
-	client, err := ssh.Dial("tcp", hostport, sshConfig)
+	return &Host{
+		Name:      hostCfg.Name,
+		hostport:  fmt.Sprintf("%s:%s", hostCfg.IP, hostCfg.SSHPort),
+		sshConfig: sshConfig,
+	}, nil
+}
+
+func (h *Host) connect() error {
+	if h.remoteConn != nil {
+		return nil
+	}
+	client, err := ssh.Dial("tcp", h.hostport, h.sshConfig)
 	if err != nil {
-		return nil, err
+		return err
 	}
-
-	con := RemoteConn{
-		IP:       hostCfg.IP,
-		User:     hostCfg.Username,
-		Password: "",
-		client:   client,
+	h.remoteConn = &RemoteConn{
+		IP:     h.hostport,
+		User:   h.sshConfig.User,
+		client: client,
 	}
-	return &Host{Name: hostCfg.Name, RemoteConn: con}, nil
+	return nil
 }
 
 func (h *Host) Close() error {
-	return h.RemoteConn.Close()
+	if h.remoteConn == nil {
+		return nil
+	}
+	return h.remoteConn.Close()
 }
 
 func (h *Host) ExecuteCommandLine(cmd string, args ...string) ([]byte, error) {
-	return h.RemoteConn.ExecuteCmdline(cmd, args...)
+	if err := h.connect(); err != nil {
+		return nil, err
+	}
+	return h.remoteConn.ExecuteCmdline(cmd, args...)
 }