Add update-connection to machine start and init

This allows users to set the associated machine's system connection to the system default when running `podman machine init --now` or `podman machine start`.  It also changes the default bbehavior of these commands in that the user will be prompted and asked if they would like to switch the system connection.  It also introduces a command line switch called `--update-connection`.  If the switch is unset, then the user will be prmpted.  If the command value is explicitly set to `false`, the user will not be prompted and the system connection will not be altered.  If the value is set to `true`, the system connection will be made the default and the user will not be prompted.

Signed-off-by: Brent Baude <[email protected]>

Author: baude

cmd/podman/machine/init.go

@@ -166,6 +166,9 @@ func init() {
 	providerFlagName := "provider"
 	flags.StringVar(&providerOverride, providerFlagName, "", "Override the default machine provider")
 	_ = initCmd.RegisterFlagCompletionFunc(providerFlagName, autocompleteMachineProvider)
+
+	setDefaultConnectionFlagName := "update-connection"
+	flags.BoolVarP(&setDefaultSystemConn, setDefaultConnectionFlagName, "u", false, "Set default system connection for this machine")
 }
 
 func initMachine(cmd *cobra.Command, args []string) error {
@@ -294,8 +297,11 @@ func initMachine(cmd *cobra.Command, args []string) error {
 	fmt.Println("Machine init complete")
 
 	if now {
-		return start(cmd, args)
+		if err := start(cmd, args); err != nil {
+			return err
+		}
 	}
+
 	extra := ""
 	if initOpts.Name != defaultMachineName {
 		extra = " " + initOpts.Name

cmd/podman/machine/start.go

@@ -23,7 +23,8 @@ var (
 		Example:           `podman machine start podman-machine-default`,
 		ValidArgsFunction: autocompleteMachine,
 	}
-	startOpts = machine.StartOptions{}
+	startOpts            = machine.StartOptions{}
+	setDefaultSystemConn bool
 )
 
 func init() {
@@ -38,15 +39,13 @@ func init() {
 
 	quietFlagName := "quiet"
 	flags.BoolVarP(&startOpts.Quiet, quietFlagName, "q", false, "Suppress machine starting status output")
-}
 
-func start(_ *cobra.Command, args []string) error {
-	var (
-		err error
-	)
+	setDefaultConnectionFlagName := "update-connection"
+	flags.BoolVarP(&setDefaultSystemConn, setDefaultConnectionFlagName, "u", false, "Set default system connection for this machine")
+}
 
+func start(cmd *cobra.Command, args []string) error {
 	startOpts.NoInfo = startOpts.Quiet || startOpts.NoInfo
-
 	vmName := defaultMachineName
 	if len(args) > 0 && len(args[0]) > 0 {
 		vmName = args[0]
@@ -61,10 +60,18 @@ func start(_ *cobra.Command, args []string) error {
 		fmt.Printf("Starting machine %q\n", vmName)
 	}
 
-	if err := shim.Start(mc, vmProvider, startOpts); err != nil {
+	shouldUpdate := processSystemConnUpdate(cmd, setDefaultSystemConn)
+	if err := shim.Start(mc, vmProvider, startOpts, shouldUpdate); err != nil {
 		return err
 	}
 	fmt.Printf("Machine %q started successfully\n", vmName)
 	newMachineEvent(events.Start, events.Event{Name: vmName})
 	return nil
 }
+
+func processSystemConnUpdate(cmd *cobra.Command, updateVal bool) *bool {
+	if !cmd.Flags().Changed("update-connection") {
+		return nil
+	}
+	return &updateVal
+}

docs/source/markdown/options/update-connection.md

@@ -0,0 +1,14 @@
+####> This option file is used in:
+####>   podman machine init, machine start
+####> If file is edited, make sure the changes
+####> are applicable to all of those.
+#### **--update-connection**, **-u**
+
+When used in conjunction with `podman machine init --now` or `podman machine start`, this option sets the
+associated machine system connection as the default. When using this option, a `-u-update-connection` will
+set the value to true.  To set this value to false, meaning no change and no prompting,
+use `--update-connection=false`.
+
+If the value is set to true, the machine connection will be set as the system default.
+If the value is set to false, the system default will be unchanged.
+If the option is not set, the user will be prompted and asked if it should be changed.

docs/source/markdown/podman-machine-init.1.md.in

@@ -127,6 +127,8 @@ as the host Windows operating system.
 
 @@option tls-verify
 
+@@option update-connection
+
 #### **--usb**=*bus=number,devnum=number* or *vendor=hexadecimal,product=hexadecimal*
 
 Assign a USB device from the host to the VM via USB passthrough.

docs/source/markdown/podman-machine-start.1.md renamed to docs/source/markdown/podman-machine-start.1.md.in

@@ -39,6 +39,8 @@ Suppress informational tips.
 
 Suppress machine starting status output.
 
+@@option update-connection
+
 ## EXAMPLES
 
 Start the specified podman machine.

pkg/machine/e2e/config_init_test.go

@@ -1,6 +1,7 @@
 package e2e_test
 
 import (
+	"fmt"
 	"strconv"
 	"strings"
 
@@ -23,6 +24,7 @@ type initMachine struct {
 	timezone           string
 	rootful            bool
 	volumes            []string
+	updateConnection   *bool
 	userModeNetworking bool
 	tlsVerify          *bool
 
@@ -78,6 +80,10 @@ func (i *initMachine) buildCmd(m *machineTestBuilder) []string {
 	if i.tlsVerify != nil {
 		cmd = append(cmd, "--tls-verify="+strconv.FormatBool(*i.tlsVerify))
 	}
+	if i.updateConnection != nil {
+		cmd = append(cmd, fmt.Sprintf("--update-connection=%s", strconv.FormatBool(*i.updateConnection)))
+	}
+
 	name := m.name
 	cmd = append(cmd, name)
 
@@ -175,6 +181,11 @@ func (i *initMachine) withTlsVerify(tlsVerify *bool) *initMachine {
 	return i
 }
 
+func (i *initMachine) withUpdateConnection(value *bool) *initMachine {
+	i.updateConnection = value
+	return i
+}
+
 func (i *initMachine) withUserModeNetworking(r bool) *initMachine { //nolint:unused,nolintlint
 	i.userModeNetworking = r
 	return i

pkg/machine/e2e/config_start_test.go

@@ -1,11 +1,17 @@
 package e2e_test
 
+import (
+	"fmt"
+	"strconv"
+)
+
 type startMachine struct {
 	/*
 		No command line args other than a machine vm name (also not required)
 	*/
-	quiet  bool
-	noInfo bool
+	quiet            bool
+	noInfo           bool
+	updateConnection *bool
 }
 
 func (s *startMachine) buildCmd(m *machineTestBuilder) []string {
@@ -19,6 +25,9 @@ func (s *startMachine) buildCmd(m *machineTestBuilder) []string {
 	if s.noInfo {
 		cmd = append(cmd, "--no-info")
 	}
+	if s.updateConnection != nil {
+		cmd = append(cmd, fmt.Sprintf("--update-connection=%s", strconv.FormatBool(*s.updateConnection)))
+	}
 	return cmd
 }
 
@@ -31,3 +40,12 @@ func (s *startMachine) withNoInfo() *startMachine {
 	s.noInfo = true
 	return s
 }
+
+func (s *startMachine) withUpdateConnection(value *bool) *startMachine {
+	s.updateConnection = value
+	return s
+}
+
+func ptrBool(v bool) *bool {
+	return &v
+}

pkg/machine/e2e/start_test.go

@@ -4,17 +4,18 @@ import (
 	"fmt"
 	"net"
 	"net/url"
+	"strconv"
 	"sync"
 	"time"
 
 	"github.com/containers/podman/v6/pkg/machine/define"
+	jsoniter "github.com/json-iterator/go"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	. "github.com/onsi/gomega/gexec"
 )
 
 var _ = Describe("podman machine start", func() {
-
 	It("start simple machine", func() {
 		i := new(initMachine)
 		session, err := mb.setCmd(i.withImage(mb.imagePath)).run()
@@ -67,6 +68,7 @@ var _ = Describe("podman machine start", func() {
 		session, err := machineTestBuilderInit.run()
 		Expect(err).ToNot(HaveOccurred())
 		Expect(session).To(Exit(0))
+
 		s := new(startMachine)
 		startSession, err := mb.setCmd(s).run()
 		Expect(err).ToNot(HaveOccurred())
@@ -184,7 +186,7 @@ var _ = Describe("podman machine start", func() {
 			defer GinkgoRecover()
 			defer wg.Done()
 			s := &startMachine{}
-			startSession1, err = mb.setName(machine1).setCmd(s).setTimeout(time.Minute * 10).run()
+			startSession1, err = mb.setName(machine1).setCmd(s.withUpdateConnection(ptrBool(false))).setTimeout(time.Minute * 10).run()
 			Expect(err).ToNot(HaveOccurred())
 		}()
 		go func() {
@@ -197,7 +199,7 @@ var _ = Describe("podman machine start", func() {
 			// second run.
 			nmb, err := newMB()
 			Expect(err).ToNot(HaveOccurred())
-			startSession2, err = nmb.setName(machine2).setCmd(s).setTimeout(time.Minute * 10).run()
+			startSession2, err = nmb.setName(machine2).setCmd(s.withUpdateConnection(ptrBool(false))).setTimeout(time.Minute * 10).run()
 			Expect(err).ToNot(HaveOccurred())
 		}()
 		wg.Wait()
@@ -218,6 +220,89 @@ var _ = Describe("podman machine start", func() {
 			Expect(startSession1.errorToString()).To(ContainSubstring("%s already starting or running: only one VM can be active at a time", machine2))
 		}
 	})
+
+	It("machine start with --update-connection", func() {
+		// Add a connection and verify it was set to the default
+		defConnName := "QA"
+		err := addSystemConnection(defConnName, true)
+		Expect(err).ToNot(HaveOccurred())
+
+		listings, err := getSystemConnectionsAsSysConns()
+		Expect(err).ToNot(HaveOccurred())
+		Expect(listings.IsDefault(defConnName)).To(BeTrue())
+
+		// Create a new machine
+		i := initMachine{}
+		machineName := randomString()
+		initSession, err := mb.setName(machineName).setCmd(i.withImage(mb.imagePath)).run()
+		Expect(err).ToNot(HaveOccurred())
+		Expect(initSession).To(Exit(0))
+
+		// Start the new machine with --update-connection=false
+		s := startMachine{}
+		startSession, err := mb.setName(machineName).setCmd(s.withUpdateConnection(ptrBool(false))).run()
+		Expect(err).ToNot(HaveOccurred())
+		Expect(startSession).To(Exit(0))
+
+		// We started the machine with --update-connection=false so it should not be default
+		listings, err = getSystemConnectionsAsSysConns()
+		Expect(err).ToNot(HaveOccurred())
+		Expect(listings.IsDefault(defConnName)).To(BeTrue())
+
+		// Stop the machine
+		halt := stopMachine{}
+		stopSession, err := mb.setName(machineName).setCmd(halt).run()
+		Expect(err).ToNot(HaveOccurred())
+		Expect(stopSession).To(Exit(0))
+
+		// Start the new machine with --update-connection
+		startSession, err = mb.setName(machineName).setCmd(s.withUpdateConnection(ptrBool(true))).run()
+		Expect(err).ToNot(HaveOccurred())
+		Expect(startSession).To(Exit(0))
+
+		// We set true so the new default connection should have changed
+		listings, err = getSystemConnectionsAsSysConns()
+		Expect(err).ToNot(HaveOccurred())
+		Expect(listings.IsDefault(machineName)).To(BeTrue())
+	})
+	It("machine init --now with --update-connection", func() {
+		// Add a connection and verify it was set to the default
+		defConnName := "QA"
+		err := addSystemConnection(defConnName, true)
+		Expect(err).ToNot(HaveOccurred())
+
+		listings, err := getSystemConnectionsAsSysConns()
+		Expect(err).ToNot(HaveOccurred())
+		Expect(listings.IsDefault(defConnName)).To(BeTrue())
+
+		// Create a new machine
+		i := initMachine{}
+		machineName1 := randomString()
+		initSession, err := mb.setName(machineName1).setCmd(i.withImage(mb.imagePath).withUpdateConnection(ptrBool(false)).withNow()).run()
+		Expect(err).ToNot(HaveOccurred())
+		Expect(initSession).To(Exit(0))
+
+		// We started the machine with --update-connection=false so it should not be default
+		listings, err = getSystemConnectionsAsSysConns()
+		Expect(err).ToNot(HaveOccurred())
+		Expect(listings.IsDefault(defConnName)).To(BeTrue())
+
+		// Stop the machine
+		halt := stopMachine{}
+		stopSession, err := mb.setName(machineName1).setCmd(halt).run()
+		Expect(err).ToNot(HaveOccurred())
+		Expect(stopSession).To(Exit(0))
+
+		// Create another machine
+		machineName2 := randomString()
+		initSession2, err := mb.setName(machineName2).setCmd(i.withImage(mb.imagePath).withUpdateConnection(ptrBool(true)).withNow()).run()
+		Expect(err).ToNot(HaveOccurred())
+		Expect(initSession2).To(Exit(0))
+
+		listings, err = getSystemConnectionsAsSysConns()
+		Expect(err).ToNot(HaveOccurred())
+		Expect(listings.IsDefault(machineName2)).To(BeTrue())
+	})
 })
 
 func mapToPort(uris []string) ([]string, error) {
@@ -238,3 +323,70 @@ func mapToPort(uris []string) ([]string, error) {
 	}
 	return ports, nil
 }
+
+func addSystemConnection(name string, setDefault bool) error {
+	addConn := []string{
+		"system", "connection", "add",
+		fmt.Sprintf("--default=%s", strconv.FormatBool(setDefault)),
+		"--identity", "~/.ssh/id_rsa",
+		name,
+		"ssh://[email protected]:2222/run/podman/podman.sock",
+	}
+	mb.cmd = addConn
+	addConnSession, err := mb.run()
+	if err != nil {
+		return err
+	}
+	if addConnSession.ExitCode() != 0 {
+		fmt.Println(addConnSession.outputToString())
+		return fmt.Errorf("error: %s", addConnSession.errorToString())
+	}
+	return nil
+}
+
+func systemConnectionLsToSysConns(output []byte) (SysConns, error) {
+	var conns SysConns
+	err := jsoniter.Unmarshal(output, &conns)
+	return conns, err
+}
+
+type SysConn struct {
+	Name      string
+	URI       string
+	Identity  string
+	IsMachine bool
+	Default   bool
+	ReadWrite bool
+}
+
+type SysConns []SysConn
+
+func (s SysConns) IsDefault(name string) bool {
+	for _, conn := range s {
+		if conn.Name == name {
+			return conn.Default
+		}
+	}
+	return false
+}
+
+func (s SysConns) GetDefault() (SysConn, error) {
+	for _, conn := range s {
+		if conn.Default {
+			return conn, nil
+		}
+	}
+	return SysConn{}, fmt.Errorf("no default connection found")
+}
+
+func getSystemConnectionsAsSysConns() (SysConns, error) {
+	connections := new(listSystemConnection)
+	connSession, err := mb.setCmd(connections.withFormat("json")).run()
+	if err != nil {
+		return nil, err
+	}
+	if connSession.ExitCode() != 0 {
+		return nil, fmt.Errorf("error: %s", connSession.errorToString())
+	}
+	return systemConnectionLsToSysConns(connSession.Out.Contents())
+}