mirror of
https://github.com/containers/podman.git
synced 2026-07-10 15:25:00 -04:00
500 lines
17 KiB
Go
500 lines
17 KiB
Go
package e2e_test
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"net"
|
|
"net/url"
|
|
"os/exec"
|
|
"strconv"
|
|
"sync"
|
|
"syscall"
|
|
"time"
|
|
|
|
jsoniter "github.com/json-iterator/go"
|
|
. "github.com/onsi/ginkgo/v2"
|
|
. "github.com/onsi/gomega"
|
|
. "github.com/onsi/gomega/gexec"
|
|
"go.podman.io/podman/v6/pkg/machine/define"
|
|
)
|
|
|
|
var _ = Describe("podman machine start", func() {
|
|
It("start simple machine", func() {
|
|
i := new(initMachine)
|
|
session, err := mb.setCmd(i.withImage(mb.imagePath)).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(session).To(Exit(0))
|
|
s := new(startMachine)
|
|
startSession, err := mb.setCmd(s).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(startSession).To(Exit(0))
|
|
|
|
info, ec, err := mb.toQemuInspectInfo()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(ec).To(BeZero())
|
|
Expect(info[0].State).To(Equal(define.Running))
|
|
|
|
stop := new(stopMachine)
|
|
stopSession, err := mb.setCmd(stop).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(stopSession).To(Exit(0))
|
|
|
|
// suppress output
|
|
startSession, err = mb.setCmd(s.withNoInfo()).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(startSession).To(Exit(0))
|
|
Expect(startSession.outputToString()).ToNot(ContainSubstring("API forwarding"))
|
|
|
|
stopSession, err = mb.setCmd(stop).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(stopSession).To(Exit(0))
|
|
|
|
startSession, err = mb.setCmd(s.withQuiet()).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(startSession).To(Exit(0))
|
|
Expect(startSession.outputToStringSlice()).To(HaveLen(1))
|
|
})
|
|
|
|
It("bad start name", func() {
|
|
i := startMachine{}
|
|
reallyLongName := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
|
session, err := mb.setName(reallyLongName).setCmd(&i).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(session).To(Exit(125))
|
|
Expect(session.errorToString()).To(ContainSubstring("VM does not exist"))
|
|
})
|
|
|
|
It("start machine already started", func() {
|
|
name := randomString()
|
|
i := new(initMachine)
|
|
machineTestBuilderInit := mb.setName(name).setCmd(i.withImage(mb.imagePath))
|
|
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())
|
|
Expect(startSession).To(Exit(0))
|
|
|
|
info, ec, err := mb.toQemuInspectInfo()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(ec).To(BeZero())
|
|
Expect(info[0].State).To(Equal(define.Running))
|
|
|
|
startSession, err = mb.setCmd(s).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(startSession).To(Exit(125))
|
|
Expect(startSession.errorToString()).To(ContainSubstring(fmt.Sprintf("Error: unable to start %q: already running", machineTestBuilderInit.name)))
|
|
})
|
|
|
|
It("start machine with conflict on SSH port", func() {
|
|
i := new(initMachine)
|
|
session, err := mb.setCmd(i.withImage(mb.imagePath)).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(session).To(Exit(0))
|
|
|
|
inspect := new(inspectMachine)
|
|
inspectSession, err := mb.setCmd(inspect.withFormat("{{.SSHConfig.Port}}")).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(inspectSession).To(Exit(0))
|
|
inspectPort := inspectSession.outputToString()
|
|
|
|
connections := new(listSystemConnection)
|
|
connectionsSession, err := mb.setCmd(connections.withFormat("{{.URI}}")).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(connectionsSession).To(Exit(0))
|
|
connectionURLs := connectionsSession.outputToStringSlice()
|
|
connectionPorts, err := mapToPort(connectionURLs)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(connectionPorts).To(HaveEach(inspectPort))
|
|
|
|
// start a listener on the ssh port
|
|
listener, err := net.Listen("tcp", "127.0.0.1:"+inspectPort)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
defer listener.Close()
|
|
|
|
s := new(startMachine)
|
|
startSession, err := mb.setCmd(s).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(startSession).To(Exit(0))
|
|
Expect(startSession.errorToString()).To(ContainSubstring("detected port conflict on machine ssh port"))
|
|
|
|
inspect2 := new(inspectMachine)
|
|
inspectSession2, err := mb.setCmd(inspect2.withFormat("{{.SSHConfig.Port}}")).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(inspectSession2).To(Exit(0))
|
|
inspectPort2 := inspectSession2.outputToString()
|
|
Expect(inspectPort2).To(Not(Equal(inspectPort)))
|
|
|
|
connections2 := new(listSystemConnection)
|
|
connectionsSession2, err := mb.setCmd(connections2.withFormat("{{.URI}}")).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(connectionsSession2).To(Exit(0))
|
|
connectionURLs2 := connectionsSession2.outputToStringSlice()
|
|
connectionPorts2, err := mapToPort(connectionURLs2)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(connectionPorts2).To(HaveEach(inspectPort2))
|
|
})
|
|
|
|
It("start only starts specified machine", func() {
|
|
j := initMachine{}
|
|
dontstartme := randomString()
|
|
session2, err := mb.setName(dontstartme).setCmd(j.withFakeImage(mb)).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(session2).To(Exit(0))
|
|
|
|
i := initMachine{}
|
|
startme := randomString()
|
|
session, err := mb.setName(startme).setCmd(i.withImage(mb.imagePath)).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(session).To(Exit(0))
|
|
|
|
s := &startMachine{}
|
|
// Provide a buffer as stdin to simulate non-tty input (e.g., piped or redirected stdin)
|
|
// When stdin is not a tty, the command should not prompt for connection updates
|
|
stdinBuf := bytes.NewBufferString("n\n")
|
|
session3, err := mb.setName(startme).setCmd(s).setTimeout(time.Minute * 10).setStdin(stdinBuf).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(session3).Should(Exit(0))
|
|
// Verify that the prompt message did not appear (no prompting when stdin is not a tty)
|
|
combinedOutput := session3.outputToString() + session3.errorToString()
|
|
Expect(combinedOutput).ToNot(ContainSubstring("Set the default Podman connection to this machine"), "should not prompt when stdin is not a tty")
|
|
|
|
inspect := new(inspectMachine)
|
|
inspect = inspect.withFormat("{{.State}}")
|
|
inspectSession, err := mb.setName(startme).setCmd(inspect).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(inspectSession).To(Exit(0))
|
|
Expect(inspectSession.outputToString()).To(Equal(define.Running))
|
|
|
|
inspect2 := new(inspectMachine)
|
|
inspect2 = inspect2.withFormat("{{.State}}")
|
|
inspectSession2, err := mb.setName(dontstartme).setCmd(inspect2).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(inspectSession2).To(Exit(0))
|
|
Expect(inspectSession2.outputToString()).To(Not(Equal(define.Running)))
|
|
})
|
|
|
|
It("start two machines in parallel", func() {
|
|
i := initMachine{}
|
|
machine1 := "m1-" + randomString()
|
|
session, err := mb.setName(machine1).setCmd(i.withImage(mb.imagePath)).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(session).To(Exit(0))
|
|
|
|
machine2 := "m2-" + randomString()
|
|
session, err = mb.setName(machine2).setCmd(i.withImage(mb.imagePath)).run()
|
|
Expect(session).To(Exit(0))
|
|
|
|
var startSession1, startSession2 *machineSession
|
|
wg := sync.WaitGroup{}
|
|
wg.Add(2)
|
|
// now start two machine start process in parallel
|
|
go func() {
|
|
defer GinkgoRecover()
|
|
defer wg.Done()
|
|
s := &startMachine{}
|
|
startSession1, err = mb.setName(machine1).setCmd(s.withUpdateConnection(ptrBool(false))).setTimeout(time.Minute * 10).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
}()
|
|
go func() {
|
|
defer GinkgoRecover()
|
|
defer wg.Done()
|
|
s := &startMachine{}
|
|
// ok this is a hack and should not be needed but the way these test are setup they all
|
|
// share "mb" which stores the name that is used for the VM, thus running two parallel
|
|
// can overwrite the name from the other, work around that by creating a new mb for the
|
|
// second run.
|
|
nmb, err := newMB()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
startSession2, err = nmb.setName(machine2).setCmd(s.withUpdateConnection(ptrBool(false))).setTimeout(time.Minute * 10).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
}()
|
|
wg.Wait()
|
|
|
|
// WSL can start in parallel so just check both command exit 0 there
|
|
if testProvider.VMType() == define.WSLVirt {
|
|
Expect(startSession1).To(Exit(0))
|
|
Expect(startSession2).To(Exit(0))
|
|
return
|
|
}
|
|
// other providers have a check that only one VM can be running at any given time so make sure our check is race free
|
|
Expect(startSession1).To(Or(Exit(0), Exit(125)), "start command should succeed or fail with 125")
|
|
if startSession1.ExitCode() == 0 {
|
|
Expect(startSession2).To(Exit(125), "first start worked, second start must fail")
|
|
Expect(startSession2.errorToString()).To(ContainSubstring("%s already starting or running: only one VM can be active at a time", machine1))
|
|
} else {
|
|
Expect(startSession2).To(Exit(0), "first start failed, second start succeed")
|
|
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())
|
|
})
|
|
It("machine init --now with --import-native-ca with mounted data folder", func() {
|
|
// Create a new machine
|
|
i := initMachine{}
|
|
initCommand := i.withImage(mb.imagePath).withImportNativeCA(true).withNow()
|
|
m := randomString()
|
|
initSession, err := mb.setName(m).setCmd(initCommand).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(initSession).To(Exit(0))
|
|
|
|
// Verify that the file in the guest exist
|
|
certFilePath := "/etc/pki/ca-trust/source/anchors"
|
|
certFileName := "host-ca-certs.pem"
|
|
sshMachine := sshMachine{}
|
|
sshCertFile, err := mb.setName(m).setCmd(sshMachine.withSSHCommand([]string{"ls", certFilePath})).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(sshCertFile).To(Exit(0))
|
|
Expect(sshCertFile.outputToString()).To(Equal(certFileName))
|
|
})
|
|
It("machine init --now with --import-native-ca with SCP file transfer", func() {
|
|
skipIfVmtype(define.WSLVirt, "WSL doesn't allow handling volumes (the machine data folder is always mounted")
|
|
|
|
// Create a new machine
|
|
i := initMachine{}
|
|
initCommand := i.withImage(mb.imagePath).withImportNativeCA(true).withNow()
|
|
// Don't mount any volume to force the transfer the certificates file via SCP
|
|
initCommand = initCommand.withVolume("")
|
|
m := randomString()
|
|
initSession, err := mb.setName(m).setCmd(initCommand).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(initSession).To(Exit(0))
|
|
|
|
certFilePath := "/etc/pki/ca-trust/source/anchors"
|
|
certFileName := "host-ca-certs.pem"
|
|
sshMachine := sshMachine{}
|
|
sshCertFile, err := mb.setName(m).setCmd(sshMachine.withSSHCommand([]string{"ls", certFilePath})).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(sshCertFile).To(Exit(0))
|
|
Expect(sshCertFile.outputToString()).To(Equal(certFileName))
|
|
})
|
|
It("start interrupted by SIGTERM while waiting for VM start", func() {
|
|
if !isVmtype(define.AppleHvVirt) && !isVmtype(define.LibKrun) {
|
|
Skip("SIGTERM interruption is supported on macOS only")
|
|
}
|
|
// Use the provider binary to pgrep the VM process
|
|
var vmProcess string
|
|
switch testProvider.VMType() {
|
|
case define.AppleHvVirt:
|
|
vmProcess = "vfkit"
|
|
case define.LibKrun:
|
|
vmProcess = "krunkit"
|
|
default:
|
|
}
|
|
|
|
i := new(initMachine)
|
|
initSession, err := mb.setCmd(i.withImage(mb.imagePath)).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(initSession).To(Exit(0))
|
|
|
|
s := new(startMachine)
|
|
startSession, err := mb.setCmd(s).runWithoutWait()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
|
|
// Wait 45s for the VM process spawned by `podman machine start`
|
|
Eventually(func() error {
|
|
_, err := exec.Command("pgrep", vmProcess).Output()
|
|
return err
|
|
}, 45*time.Second, 500*time.Millisecond).Should(Succeed())
|
|
|
|
// Send a term signal now (podman machine start is waiting for
|
|
// the VM process readiness)
|
|
startSession.Signal(syscall.SIGTERM)
|
|
|
|
// Wait 30s for the podman machine start process to return (no deadlock)
|
|
Eventually(startSession, 30*time.Second).Should(Exit())
|
|
Expect(startSession.ExitCode()).ToNot(Equal(0))
|
|
|
|
// Wait 30s for the VM process to return (SIGTERM has been forwarded)
|
|
Eventually(func() error {
|
|
_, err := exec.Command("pgrep", vmProcess).Output()
|
|
return err
|
|
}, 30*time.Second, 500*time.Millisecond).ShouldNot(Succeed())
|
|
|
|
// Verify machine state is Stopped
|
|
inspect := new(inspectMachine)
|
|
inspectSession, err := mb.setCmd(inspect.withFormat("{{.State}}")).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(inspectSession).To(Exit(0))
|
|
Expect(inspectSession.outputToString()).To(Equal(define.Stopped))
|
|
|
|
// Verify no orphan gvproxy
|
|
_, err = pgrep("gvproxy")
|
|
Expect(err).To(HaveOccurred(), "gvproxy should not be running after SIGTERM cleanup")
|
|
|
|
// Restart without interrupting and confirm that completes without error
|
|
startSession, err = mb.setCmd(s).run()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(startSession).To(Exit(0))
|
|
})
|
|
})
|
|
|
|
func mapToPort(uris []string) ([]string, error) {
|
|
ports := []string{}
|
|
|
|
for _, uri := range uris {
|
|
u, err := url.Parse(uri)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
port := u.Port()
|
|
if port == "" {
|
|
return nil, fmt.Errorf("no port in URI: %s", uri)
|
|
}
|
|
|
|
ports = append(ports, port)
|
|
}
|
|
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://root@podman.test: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())
|
|
}
|