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
|
package integration
import (
"errors"
"fmt"
"io/fs"
"net"
"os"
"os/exec"
"path/filepath"
"syscall"
"time"
testUtils "github.com/containers/podman/v4/test/utils"
podmanUtils "github.com/containers/podman/v4/utils"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
. "github.com/onsi/gomega/gexec"
)
var _ = Describe("Systemd activate", func() {
var tempDir string
var err error
var podmanTest *PodmanTestIntegration
var activate string
BeforeEach(func() {
tempDir, err = testUtils.CreateTempDirInTempDir()
if err != nil {
fmt.Fprintf(os.Stderr, "%v\n", err)
os.Exit(1)
}
podmanTest = PodmanTestCreate(tempDir)
podmanTest.Setup()
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())
}
})
AfterEach(func() {
podmanTest.Cleanup()
processTestResult(CurrentGinkgoTestDescription())
})
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())
activateSession := testUtils.StartSystemExec(activate, []string{
fmt.Sprintf("--listen=%s:%d", host, port),
podmanTest.PodmanBinary,
"--root=" + filepath.Join(tempDir, "server_root"),
"system", "service",
"--time=0",
})
Expect(activateSession.Exited).ShouldNot(Receive(), "Failed to start podman service")
// Curried functions for specialized podman calls
podmanRemote := func(args ...string) *testUtils.PodmanSession {
args = append([]string{"--url", fmt.Sprintf("tcp://%s:%d", host, port)}, args...)
return testUtils.SystemExec(podmanTest.RemotePodmanBinary, args)
}
podman := func(args ...string) *testUtils.PodmanSession {
args = append([]string{"--root", filepath.Join(tempDir, "server_root")}, args...)
return testUtils.SystemExec(podmanTest.PodmanBinary, args)
}
containerName := "top_" + testUtils.RandomString(8)
apiSession := podmanRemote(
"create", "--tty", "--name", containerName, "--entrypoint", "top",
"quay.io/libpod/alpine_labels:latest",
)
Expect(apiSession).Should(Exit(0))
apiSession = podmanRemote("start", containerName)
Expect(apiSession).Should(Exit(0))
apiSession = podmanRemote("inspect", "--format={{.State.Running}}", containerName)
Expect(apiSession).Should(Exit(0))
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(Exit(0))
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 := fmt.Sprintf("%s:%d", host, port)
// start systemd activation with datagram socket
activateSession := testUtils.StartSystemExec(activate, []string{
"--datagram", "--listen", addr,
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"))
})
})
|
