step_run.go

package tart

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"net"
	"os"
	"os/exec"
	"regexp"
	"strings"
	"time"

	"github.com/apparentlymart/go-cidr/cidr"
	"github.com/hashicorp/packer-plugin-sdk/bootcommand"
	"github.com/hashicorp/packer-plugin-sdk/multistep"
	packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
	"github.com/hashicorp/packer-plugin-sdk/template/interpolate"
	"github.com/mitchellh/go-vnc"
)

var ErrFailedToDetectHostIP = errors.New("failed to detect host IP")

var vncRegexp = regexp.MustCompile("vnc://.*:(.*)@(.*):([0-9]{1,5})")

type stepRun struct{}

type bootCommandTemplateData struct {
	HTTPIP   string
	HTTPPort int
}

func (s *stepRun) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
	config := state.Get("config").(*Config)
	ui := state.Get("ui").(packersdk.Ui)

	ui.Say("Starting the virtual machine...")
	runArgs := []string{"run", config.VMName}
	if config.Headless {
		runArgs = append(runArgs, "--no-graphics")
	} else {
		runArgs = append(runArgs, "--graphics")
	}
	if !config.DisableVNC {
		runArgs = append(runArgs, "--vnc-experimental")
	}
	if config.Recovery {
		runArgs = append(runArgs, "--recovery")
	}
	if config.Rosetta != "" {
		runArgs = append(runArgs, fmt.Sprintf("--rosetta=%s", config.Rosetta))
	}
	for _, iso := range config.FromISO {
		runArgs = append(runArgs, fmt.Sprintf("--disk=%s:ro", iso))
	}
	if len(config.RunExtraArgs) > 0 {
		runArgs = append(runArgs, config.RunExtraArgs...)
	}
	cmd := exec.CommandContext(ctx, tartCommand, runArgs...)
	stdout := bytes.NewBufferString("")
	cmd.Stdout = stdout
	cmd.Stderr = uiWriter{ui: ui}

	// Prevent the Tart from opening the Screen Sharing
	// window connected to the VNC server we're starting
	if !config.DisableVNC {
		cmd.Env = cmd.Environ()
		cmd.Env = append(cmd.Env, "CI=true")
	}

	if err := cmd.Start(); err != nil {
		err = fmt.Errorf("Error starting VM: %s", err)
		state.Put("error", err)
		ui.Error(err.Error())
		return multistep.ActionHalt
	}

	state.Put("tart-cmd", cmd)

	ui.Say("Successfully started the virtual machine...")

	// Handle VM termination during boot commands or provisioning,
	// in which case we want to cancel the build instead of hanging
	// around in the packer plugin until timeout.
	go func() {
		err := cmd.Wait()
		cancelBuild, ok := state.Get("cancel-build").(context.CancelFunc)
		if !ok {
			return // Don't treat our own cleanup as a failure
		}
		select {
		case <-ctx.Done():
			return
		default:
			if err != nil {
				// Termination via e.g. kill -9
				ui.Error(fmt.Sprintf("VM terminated with error: %s", err))
				cancelBuild()
			} else if strings.Contains(stdout.String(), "Stopping VM...") {
				// User initiated termination by quitting Tart,
				// for example via Cmd+Q or closing the window.
				ui.Error("VM terminated by user action")
				cancelBuild()
			} else if strings.Contains(stdout.String(), //nolint:staticcheck
				"guest has stopped the virtual machine") {
				// Boot commands or provisioning initiated termination,
				// for example by issuing 'shutdown -t now', or via UI,
				// and then issued a wait, to let the OS fully shut down
				// on its own, instead of the packer plugin tearing down
				// the VM after boot commands were done, in which case
				// we assume the user knows what they are doing.
			}
		}
	}()

	needsVNCSession := !config.DisableVNC && (len(config.BootCommand) > 0 || config.VNCRecordingDir != "")
	var vncSession *vncSession
	if needsVNCSession {
		vncConnection, ok := connectToTartVNC(ctx, state, ui, stdout)
		if !ok {
			return multistep.ActionHalt
		}
		state.Put("vnc-connection", vncConnection)
		vncSession = vncConnection.session

		if config.VNCRecordingDir != "" {
			if !startVNCRecording(ctx, state, config, ui, vncSession) {
				return multistep.ActionHalt
			}
		}
	}

	if len(config.BootCommand) > 0 && !config.DisableVNC {
		vncDriver := newCustomDriver(vncSession, config, ctx)
		if !typeBootCommandOverVNC(ctx, state, config, ui, vncDriver) {
			return multistep.ActionHalt
		}
	}

	return multistep.ActionContinue
}

type uiWriter struct {
	ui packersdk.Ui
}

func (u uiWriter) Write(p []byte) (n int, err error) {
	u.ui.Error(strings.TrimSpace(string(p)))
	return len(p), nil
}

type vncConnection struct {
	session *vncSession
	netConn net.Conn
}

func (c *vncConnection) Close() {
	c.session.vncClient.Close()
	_ = c.netConn.Close()
}

// Cleanup stops the VM.
func (s *stepRun) Cleanup(state multistep.StateBag) {
	config := state.Get("config").(*Config)
	ui := state.Get("ui").(packersdk.Ui)
	cmd := state.Get("tart-cmd").(*exec.Cmd)
	if cmd == nil || cmd.ProcessState != nil {
		cleanupVNCResources(state, ui)
		return // Nothing to shut down
	}

	// Avoid cancellation logic when we explicitly
	// shut down the VM.
	state.Put("cancel-build", nil)

	communicator := state.Get("communicator")
	if communicator != nil {
		ui.Say("Gracefully shutting down the VM...")
		shutdownCmd := packersdk.RemoteCmd{
			Command: fmt.Sprintf("echo %s | sudo -S -p '' shutdown -h now", config.CommunicatorConfig.Password()),
		}

		err := shutdownCmd.RunWithUi(context.Background(), communicator.(packersdk.Communicator), ui)
		if err != nil {
			ui.Say("Failed to gracefully shutdown VM...")
			ui.Error(err.Error())
		}
	} else {
		ui.Say("Shutting down the VM...")
		err := cmd.Process.Signal(os.Interrupt)
		if err != nil {
			ui.Say("Failed to shutdown VM...")
			ui.Error(err.Error())
		}
	}

	// Always wait, even if we didn't initiate shutdown,
	// so that we properly read and close stdout/stderr.
	ui.Say("Waiting for the tart process to exit...")
	_, _ = cmd.Process.Wait()

	cleanupVNCResources(state, ui)
}

func connectToTartVNC(
	ctx context.Context,
	state multistep.StateBag,
	ui packersdk.Ui,
	tartRunStdout *bytes.Buffer,
) (*vncConnection, bool) {
	ui.Say("Waiting for VNC server credentials from Tart...")

	vncCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
	defer cancel()

	var vncPassword string
	var vncHost string
	var vncPort string

	for {
		matches := vncRegexp.FindStringSubmatch(tartRunStdout.String())
		if len(matches) == 1+vncRegexp.NumSubexp() {
			vncPassword = matches[1]
			vncHost = matches[2]
			vncPort = matches[3]

			break
		}

		select {
		case <-vncCtx.Done():
			return nil, false
		case <-time.After(time.Second):
			// continue
		}
	}

	ui.Say("Retrieved VNC credentials, connecting...")
	ui.Sayf("If you want to view the screen of the VM, connect via VNC with the password \"%s\" to\n"+
		"vnc://%s:%s", vncPassword, vncHost, vncPort)

	dialer := net.Dialer{}
	netConn, err := dialer.DialContext(ctx, "tcp", fmt.Sprintf("%s:%s", vncHost, vncPort))
	if err != nil {
		err := fmt.Errorf("Failed to connect to Tart's VNC server: %s", err)
		state.Put("error", err)
		ui.Error(err.Error())

		return nil, false
	}

	serverMessageChannel := make(chan vnc.ServerMessage)
	vncClient, err := vnc.Client(netConn, &vnc.ClientConfig{
		Auth: []vnc.ClientAuth{
			&vnc.PasswordAuth{Password: vncPassword},
		},
		ServerMessageCh: serverMessageChannel,
	})
	if err != nil {
		err := fmt.Errorf("Failed to connect to Tart's VNC server: %s", err)
		state.Put("error", err)
		ui.Error(err.Error())

		_ = netConn.Close()
		return nil, false
	}

	ui.Say("Connected to VNC server!")

	err = vncClient.SetEncodings([]vnc.Encoding{
		&vnc.RawEncoding{},
		&DesktopSizePseudoEncoding{},
	})
	if err != nil {
		err := fmt.Errorf("Failed to set VNC encoding: %s", err)
		state.Put("error", err)
		ui.Error(err.Error())
		vncClient.Close()
		_ = netConn.Close()
		return nil, false
	}

	return &vncConnection{
		session: newVNCSession(vncClient, serverMessageChannel),
		netConn: netConn,
	}, true
}

func startVNCRecording(
	ctx context.Context,
	state multistep.StateBag,
	config *Config,
	ui packersdk.Ui,
	session *vncSession,
) bool {
	recorder := newVNCRecorder(session, config.VNCRecordingDir, config.VNCRecordingInterval)
	if err := recorder.Prepare(); err != nil {
		state.Put("error", err)
		ui.Error(err.Error())
		return false
	}

	ui.Sayf("Recording VNC snapshots to %s every %s...",
		config.VNCRecordingDir, config.VNCRecordingInterval)

	handle := startVNCRecorder(ctx, recorder)
	state.Put("vnc-recorder", handle)

	go func() {
		<-handle.done
		if err := handle.Err(); err != nil {
			ui.Error(fmt.Sprintf("VNC recording failed: %s", err))
			state.Put("error", err)
			cancelBuild, ok := state.Get("cancel-build").(context.CancelFunc)
			if ok && cancelBuild != nil {
				cancelBuild()
			}
		}
	}()

	return true
}

func cleanupVNCResources(state multistep.StateBag, ui packersdk.Ui) {
	if rawRecorder, ok := state.GetOk("vnc-recorder"); ok {
		if err := rawRecorder.(*vncRecorderHandle).Stop(); err != nil {
			ui.Error(fmt.Sprintf("VNC recording failed: %s", err))
			state.Put("error", err)
		}
	}

	if rawConnection, ok := state.GetOk("vnc-connection"); ok {
		rawConnection.(*vncConnection).Close()
	}
}

func typeBootCommandOverVNC(
	ctx context.Context,
	state multistep.StateBag,
	config *Config,
	ui packersdk.Ui,
	vncDriver *customDriver,
) bool {
	ui.Say("Typing boot commands over VNC...")

	if config.HTTPDir != "" || len(config.HTTPContent) != 0 {
		ui.Say("Detecting host IP...")

		hostIP, err := detectHostIP(ctx, config)
		if err != nil {
			err := fmt.Errorf("Failed to detect the host IP address: %v", err)
			state.Put("error", err)
			ui.Error(err.Error())

			return false
		}

		ui.Say(fmt.Sprintf("Host IP is assumed to be %s", hostIP))
		state.Put("http_ip", hostIP)

		// Should be already filled by the Packer's commonsteps.StepHTTPServer
		httpPort := state.Get("http_port").(int)

		config.ctx.Data = &bootCommandTemplateData{
			HTTPIP:   hostIP,
			HTTPPort: httpPort,
		}
	}

	if config.VNCConfig.BootWait > 0 {
		message := fmt.Sprintf("Waiting %v after the VM has booted...", config.VNCConfig.BootWait)
		ui.Say(message)
		time.Sleep(config.VNCConfig.BootWait)
	}

	message := fmt.Sprintf("Typing commands with key interval %v...", vncDriver.KeyInterval())
	ui.Say(message)

	command, err := interpolate.Render(config.VNCConfig.FlatBootCommand(), &config.ctx)
	if err != nil {
		err := fmt.Errorf("Failed to render the boot command: %s", err)
		state.Put("error", err)
		ui.Error(err.Error())

		return false
	}

	stringWaitRegex := regexp.MustCompile(`<wait\s*'(.+?)'>`)
	command = stringWaitRegex.ReplaceAllString(command,
		fmt.Sprintf(`%c${1}%c`, WaitForStringStart, WaitForStringEnd))

	stringClickRegex := regexp.MustCompile(`<click\s*'(.+?)'>`)
	command = stringClickRegex.ReplaceAllString(command,
		fmt.Sprintf(`%c${1}%c`, ClickStringStart, ClickStringEnd))

	// Waiting for https://github.com/hashicorp/packer-plugin-sdk/pull/293
	leftCommandRegex := regexp.MustCompile(`<leftCommand(On|Off)?>`)
	command = leftCommandRegex.ReplaceAllString(command,
		fmt.Sprintf(`<%c${1}>`, LeftCommand))
	rightCommandRegex := regexp.MustCompile(`<rightCommand(On|Off)?>`)
	command = rightCommandRegex.ReplaceAllString(command,
		fmt.Sprintf(`<%c${1}>`, RightCommand))
	leftOptionRegex := regexp.MustCompile(`<leftOption(On|Off)?>`)
	command = leftOptionRegex.ReplaceAllString(command,
		fmt.Sprintf(`<%c${1}>`, LeftOption))
	rightOptionRegex := regexp.MustCompile(`<rightOption(On|Off)?>`)
	command = rightOptionRegex.ReplaceAllString(command,
		fmt.Sprintf(`<%c${1}>`, RightOption))

	seq, err := bootcommand.GenerateExpressionSequence(command)
	if err != nil {
		err := fmt.Errorf("Failed to parse the boot command: %s", err)
		state.Put("error", err)
		ui.Error(err.Error())

		return false
	}

	if err := seq.Do(ctx, vncDriver); err != nil {
		err := fmt.Errorf("Failed to run the boot command: %s", err)
		state.Put("error", err)
		ui.Error(err.Error())

		return false
	}

	ui.Say("Done typing commands!")

	return true
}

func detectHostIP(ctx context.Context, config *Config) (string, error) {
	if config.HTTPAddress != "0.0.0.0" {
		return config.HTTPAddress, nil
	}

	vmIPRaw, err := TartMachineIP(ctx, config.VMName, config.IpExtraArgs)
	if err != nil {
		return "", fmt.Errorf("%w: while running \"tart ip\": %v",
			ErrFailedToDetectHostIP, err)
	}
	vmIP := net.ParseIP(vmIPRaw)

	// Find the interface that has this IP
	interfaces, err := net.Interfaces()
	if err != nil {
		return "", fmt.Errorf("%w: while retrieving interfaces: %v",
			ErrFailedToDetectHostIP, err)
	}

	for _, iface := range interfaces {
		addrs, err := iface.Addrs()
		if err != nil {
			return "", fmt.Errorf("%w: while retrieving interface addresses: %v",
				ErrFailedToDetectHostIP, err)
		}

		for _, addr := range addrs {
			_, net, err := net.ParseCIDR(addr.String())
			if err != nil {
				return "", fmt.Errorf("%w: while parsing interface CIDR: %v",
					ErrFailedToDetectHostIP, err)
			}

			if net.Contains(vmIP) {
				gatewayIP, err := cidr.Host(net, 1)
				if err != nil {
					return "", fmt.Errorf("%w: while calculating gateway IP: %v",
						ErrFailedToDetectHostIP, err)
				}

				return gatewayIP.String(), nil
			}
		}
	}

	return "", fmt.Errorf("%w: no suitable interface found", ErrFailedToDetectHostIP)
}