1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
//go:build linux || freebsd
package integration
import (
"errors"
"io/fs"
"net"
"net/url"
"os"
"os/exec"
"path/filepath"
"strconv"
"syscall"
"time"
testUtils "github.com/containers/podman/v5/test/utils"
podmanUtils "github.com/containers/podman/v5/utils"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
. "github.com/onsi/gomega/gexec"
)
var _ = Describe("Systemd activate", func() {
var activate string
BeforeEach(func() {
SkipIfRemote("Testing stopped service requires both podman and podman-remote binaries")
activate, err = exec.LookPath("systemd-socket-activate")
if err != nil {
activate = "/usr/bin/systemd-socket-activate"
}
stat, err := os.Stat(activate)
switch {
case errors.Is(err, fs.ErrNotExist):
Skip(activate + " required for systemd activation tests")
case stat.Mode()&0111 == 0:
Skip("Unable to execute " + activate)
case err != nil:
Skip(err.Error())
}
})
It("stop podman.service", func() {
// systemd-socket-activate does not support DNS lookups
host := "127.0.0.1"
port, err := podmanUtils.GetRandomPort()
Expect(err).ToNot(HaveOccurred())
addr := net.JoinHostPort(host, strconv.Itoa(port))
podmanOptions := podmanTest.makeOptions(nil, testUtils.PodmanExecOptions{})
systemdArgs := []string{
"-E", "http_proxy", "-E", "https_proxy", "-E", "no_proxy",
"-E", "HTTP_PROXY", "-E", "HTTPS_PROXY", "-E", "NO_PROXY",
"-E", "XDG_RUNTIME_DIR", "-E", "CI_DESIRED_DATABASE",
"--listen", addr,
podmanTest.PodmanBinary}
systemdArgs = append(systemdArgs, podmanOptions...)
systemdArgs = append(systemdArgs, "system", "service", "--time=0")
activateSession := testUtils.StartSystemExec(activate, systemdArgs)
Expect(activateSession.Exited).ShouldNot(Receive(), "Failed to start podman service")
WaitForService(url.URL{Scheme: "tcp", Host: addr})
defer activateSession.Signal(syscall.SIGTERM)
// Create custom functions for running podman and
// podman-remote. This test is a rare exception where both
// binaries need to be run in parallel. Usually, the remote
// and non-remote details are hidden. Yet we use the
// `podmanOptions` above to make sure all settings (root,
// runroot, events, tmpdir, etc.) are used as in other e2e
// tests.
podmanRemote := func(args ...string) *testUtils.PodmanSession {
args = append([]string{"--url", "tcp://" + addr}, args...)
return testUtils.SystemExec(podmanTest.RemotePodmanBinary, args)
}
podman := func(args ...string) *testUtils.PodmanSession {
args = append(podmanOptions, args...)
return testUtils.SystemExec(podmanTest.PodmanBinary, args)
}
// regression check for https://github.com/containers/podman/issues/24152
session := podmanRemote("info", "--format", "{{.Host.RemoteSocket.Path}}--{{.Host.RemoteSocket.Exists}}")
Expect(session).Should(testUtils.ExitCleanly())
Expect(session.OutputToString()).To(Equal("tcp://" + addr + "--true"))
containerName := "top_" + testUtils.RandomString(8)
apiSession := podmanRemote(
"create", "--tty", "--name", containerName, "--entrypoint", "top",
ALPINE,
)
Expect(apiSession).Should(testUtils.ExitCleanly())
defer podman("rm", "-f", containerName)
apiSession = podmanRemote("start", containerName)
Expect(apiSession).Should(testUtils.ExitCleanly())
apiSession = podmanRemote("inspect", "--format={{.State.Running}}", containerName)
Expect(apiSession).Should(testUtils.ExitCleanly())
Expect(apiSession.OutputToString()).To(Equal("true"))
// Emulate 'systemd stop podman.service'
activateSession.Signal(syscall.SIGTERM)
time.Sleep(100 * time.Millisecond)
Eventually(activateSession).Should(Exit(0))
abiSession := podman("inspect", "--format={{.State.Running}}", containerName)
Expect(abiSession).To(testUtils.ExitCleanly())
Expect(abiSession.OutputToString()).To(Equal("true"))
})
It("invalid systemd file descriptor", func() {
host := "127.0.0.1"
port, err := podmanUtils.GetRandomPort()
Expect(err).ToNot(HaveOccurred())
addr := net.JoinHostPort(host, strconv.Itoa(port))
// start systemd activation with datagram socket
activateSession := testUtils.StartSystemExec(activate, []string{
"--datagram", "--listen", addr, "-E", "CI_DESIRED_DATABASE",
podmanTest.PodmanBinary,
"--root=" + filepath.Join(tempdir, "server_root"),
"system", "service",
"--time=0",
})
Expect(activateSession.Exited).ShouldNot(Receive(), "Failed to start podman service")
// we have to wait for systemd-socket-activate to become ready
time.Sleep(1 * time.Second)
// now dial the socket to start podman
conn, err := net.Dial("udp", addr)
Expect(err).ToNot(HaveOccurred())
defer conn.Close()
_, err = conn.Write([]byte("test"))
Expect(err).ToNot(HaveOccurred())
// wait for podman to exit
activateSession.Wait(10)
Expect(activateSession).To(Exit(125))
Expect(activateSession.ErrorToString()).To(ContainSubstring("Error: unexpected fd received from systemd: cannot listen on it"))
})
})
|
