podman

1
package integration
2

3
import (
4
	"fmt"
5
	"os"
6
	"path/filepath"
7
	"strconv"
8
	"strings"
9

10
	. "github.com/containers/podman/v5/test/utils"
11
	. "github.com/onsi/ginkgo/v2"
12
	. "github.com/onsi/gomega"
13
	. "github.com/onsi/gomega/gexec"
14
)
15

16
var _ = Describe("Podman start", func() {
17

18
	It("podman start bogus container", func() {
19
		session := podmanTest.Podman([]string{"start", "123"})
20
		session.WaitWithDefaultTimeout()
21
		Expect(session).Should(Exit(125))
22
	})
23

24
	It("podman start single container by id", func() {
25
		session := podmanTest.Podman([]string{"create", ALPINE, "ls"})
26
		session.WaitWithDefaultTimeout()
27
		Expect(session).Should(ExitCleanly())
28
		cid := session.OutputToString()
29
		session = podmanTest.Podman([]string{"start", cid})
30
		session.WaitWithDefaultTimeout()
31
		Expect(session).Should(ExitCleanly())
32
	})
33

34
	It("podman start --rm removed on failure", func() {
35
		session := podmanTest.Podman([]string{"create", "--name=test", "--rm", ALPINE, "foo"})
36
		session.WaitWithDefaultTimeout()
37
		Expect(session).Should(ExitCleanly())
38
		session = podmanTest.Podman([]string{"start", "test"})
39
		session.WaitWithDefaultTimeout()
40
		Expect(session).Should(Exit(125))
41
		session = podmanTest.Podman([]string{"container", "exists", "test"})
42
		session.WaitWithDefaultTimeout()
43
		Expect(session).To(ExitWithError())
44
	})
45

46
	It("podman start --rm --attach removed on failure", func() {
47
		session := podmanTest.Podman([]string{"create", "--rm", ALPINE, "foo"})
48
		session.WaitWithDefaultTimeout()
49
		Expect(session).Should(ExitCleanly())
50
		cid := session.OutputToString()
51
		session = podmanTest.Podman([]string{"start", "--attach", cid})
52
		session.WaitWithDefaultTimeout()
53
		Expect(session).Should(Exit(125))
54
		session = podmanTest.Podman([]string{"container", "exists", cid})
55
		session.WaitWithDefaultTimeout()
56
		Expect(session).To(ExitWithError())
57
	})
58

59
	It("podman container start single container by id", func() {
60
		session := podmanTest.Podman([]string{"container", "create", ALPINE, "ls"})
61
		session.WaitWithDefaultTimeout()
62
		Expect(session).Should(ExitCleanly())
63
		cid := session.OutputToString()
64
		session = podmanTest.Podman([]string{"container", "start", cid})
65
		session.WaitWithDefaultTimeout()
66
		Expect(session).Should(ExitCleanly())
67
		Expect(session.OutputToString()).To(Equal(cid))
68
	})
69

70
	It("podman container start single container by short id", func() {
71
		session := podmanTest.Podman([]string{"container", "create", ALPINE, "ls"})
72
		session.WaitWithDefaultTimeout()
73
		Expect(session).Should(ExitCleanly())
74
		cid := session.OutputToString()
75
		shortID := cid[0:10]
76
		session = podmanTest.Podman([]string{"container", "start", shortID})
77
		session.WaitWithDefaultTimeout()
78
		Expect(session).Should(ExitCleanly())
79
		Expect(session.OutputToString()).To(Equal(shortID))
80
	})
81

82
	It("podman start single container by name", func() {
83
		name := "foobar99"
84
		session := podmanTest.Podman([]string{"create", "--name", name, ALPINE, "ls"})
85
		session.WaitWithDefaultTimeout()
86
		Expect(session).Should(ExitCleanly())
87
		session = podmanTest.Podman([]string{"start", name})
88
		session.WaitWithDefaultTimeout()
89
		Expect(session).Should(ExitCleanly())
90
		Expect(session.OutputToString()).To(Equal(name))
91
	})
92

93
	It("podman start single container with attach and test the signal", func() {
94
		session := podmanTest.Podman([]string{"create", "--entrypoint", "sh", ALPINE, "-c", "exit 1"})
95
		session.WaitWithDefaultTimeout()
96
		Expect(session).Should(ExitCleanly())
97
		cid := session.OutputToString()
98
		session = podmanTest.Podman([]string{"start", "--attach", cid})
99
		session.WaitWithDefaultTimeout()
100
		// It should forward the signal
101
		Expect(session).Should(Exit(1))
102
	})
103

104
	It("podman start multiple containers", func() {
105
		session := podmanTest.Podman([]string{"create", "--name", "foobar99", ALPINE, "ls"})
106
		session.WaitWithDefaultTimeout()
107
		cid1 := session.OutputToString()
108
		session2 := podmanTest.Podman([]string{"create", "--name", "foobar100", ALPINE, "ls"})
109
		session2.WaitWithDefaultTimeout()
110
		cid2 := session2.OutputToString()
111
		session = podmanTest.Podman([]string{"start", cid1, cid2})
112
		session.WaitWithDefaultTimeout()
113
		Expect(session).Should(ExitCleanly())
114
	})
115

116
	It("podman start multiple containers with bogus", func() {
117
		session := podmanTest.Podman([]string{"create", "--name", "foobar99", ALPINE, "ls"})
118
		session.WaitWithDefaultTimeout()
119
		cid1 := session.OutputToString()
120
		session = podmanTest.Podman([]string{"start", cid1, "doesnotexist"})
121
		session.WaitWithDefaultTimeout()
122
		Expect(session).Should(Exit(125))
123
	})
124

125
	It("podman multiple containers -- attach should fail", func() {
126
		session := podmanTest.Podman([]string{"create", "--name", "foobar1", ALPINE, "ls"})
127
		session.WaitWithDefaultTimeout()
128
		Expect(session).Should(ExitCleanly())
129
		session = podmanTest.Podman([]string{"create", "--name", "foobar2", ALPINE, "ls"})
130
		session.WaitWithDefaultTimeout()
131
		Expect(session).Should(ExitCleanly())
132
		session = podmanTest.Podman([]string{"start", "-a", "foobar1", "foobar2"})
133
		session.WaitWithDefaultTimeout()
134
		Expect(session).Should(Exit(125))
135
	})
136

137
	It("podman failed to start with --rm should delete the container", func() {
138
		session := podmanTest.Podman([]string{"create", "--name", "test1", "--rm", ALPINE, "foo"})
139
		session.WaitWithDefaultTimeout()
140
		Expect(session).Should(ExitCleanly())
141

142
		start := podmanTest.Podman([]string{"start", "test1"})
143
		start.WaitWithDefaultTimeout()
144

145
		wait := podmanTest.Podman([]string{"wait", "test1"})
146
		wait.WaitWithDefaultTimeout()
147
		Expect(wait).To(ExitWithError())
148

149
		Eventually(podmanTest.NumberOfContainers, defaultWaitTimeout, 3.0).Should(BeZero())
150
	})
151

152
	It("podman failed to start without --rm should NOT delete the container", func() {
153
		session := podmanTest.Podman([]string{"create", ALPINE, "foo"})
154
		session.WaitWithDefaultTimeout()
155
		Expect(session).Should(ExitCleanly())
156

157
		start := podmanTest.Podman([]string{"start", session.OutputToString()})
158
		start.WaitWithDefaultTimeout()
159
		Expect(start).To(ExitWithError())
160

161
		Eventually(podmanTest.NumberOfContainers, defaultWaitTimeout, 3.0).Should(Equal(1))
162
	})
163

164
	It("podman start --sig-proxy should not work without --attach", func() {
165
		session := podmanTest.Podman([]string{"create", ALPINE, "ls"})
166
		session.WaitWithDefaultTimeout()
167
		Expect(session).Should(ExitCleanly())
168

169
		session = podmanTest.Podman([]string{"start", "-l", "--sig-proxy"})
170
		session.WaitWithDefaultTimeout()
171
		Expect(session).Should(Exit(125))
172
	})
173

174
	It("podman start container with special pidfile", func() {
175
		SkipIfRemote("pidfile not handled by remote")
176
		pidfile := filepath.Join(tempdir, "pidfile")
177
		session := podmanTest.Podman([]string{"create", "--pidfile", pidfile, ALPINE, "ls"})
178
		session.WaitWithDefaultTimeout()
179
		Expect(session).Should(ExitCleanly())
180
		cid := session.OutputToString()
181

182
		session = podmanTest.Podman([]string{"start", cid})
183
		session.WaitWithDefaultTimeout()
184
		Expect(session).Should(ExitCleanly())
185
		readFirstLine := func(path string) string {
186
			content, err := os.ReadFile(path)
187
			Expect(err).ToNot(HaveOccurred())
188
			return strings.Split(string(content), "\n")[0]
189
		}
190
		containerPID := readFirstLine(pidfile)
191
		_, err = strconv.Atoi(containerPID) // Make sure it's a proper integer
192
		Expect(err).ToNot(HaveOccurred())
193
	})
194

195
	It("podman start container --filter", func() {
196
		session1 := podmanTest.Podman([]string{"container", "create", ALPINE})
197
		session1.WaitWithDefaultTimeout()
198
		Expect(session1).Should(ExitCleanly())
199
		cid1 := session1.OutputToString()
200

201
		session1 = podmanTest.Podman([]string{"container", "create", ALPINE})
202
		session1.WaitWithDefaultTimeout()
203
		Expect(session1).Should(ExitCleanly())
204
		cid2 := session1.OutputToString()
205

206
		session1 = podmanTest.Podman([]string{"container", "create", ALPINE})
207
		session1.WaitWithDefaultTimeout()
208
		Expect(session1).Should(ExitCleanly())
209
		cid3 := session1.OutputToString()
210
		shortCid3 := cid3[0:5]
211

212
		session1 = podmanTest.Podman([]string{"container", "create", "--label", "test=with,comma", ALPINE})
213
		session1.WaitWithDefaultTimeout()
214
		Expect(session1).Should(ExitCleanly())
215
		cid4 := session1.OutputToString()
216

217
		session1 = podmanTest.Podman([]string{"start", cid1, "-f", "status=running"})
218
		session1.WaitWithDefaultTimeout()
219
		Expect(session1).Should(ExitCleanly())
220
		Expect(session1.OutputToString()).To(BeEmpty())
221

222
		session1 = podmanTest.Podman([]string{"start", "--all", "--filter", fmt.Sprintf("id=%swrongid", shortCid3)})
223
		session1.WaitWithDefaultTimeout()
224
		Expect(session1).Should(ExitCleanly())
225
		Expect(session1.OutputToString()).To(BeEmpty())
226

227
		session1 = podmanTest.Podman([]string{"start", "--all", "--filter", fmt.Sprintf("id=%s", shortCid3)})
228
		session1.WaitWithDefaultTimeout()
229
		Expect(session1).Should(ExitCleanly())
230
		Expect(session1.OutputToString()).To(BeEquivalentTo(cid3))
231

232
		session1 = podmanTest.Podman([]string{"start", "--all", "--filter", "label=test=with,comma"})
233
		session1.WaitWithDefaultTimeout()
234
		Expect(session1).Should(ExitCleanly())
235
		Expect(session1.OutputToString()).To(BeEquivalentTo(cid4))
236

237
		session1 = podmanTest.Podman([]string{"start", "-f", fmt.Sprintf("id=%s", cid2)})
238
		session1.WaitWithDefaultTimeout()
239
		Expect(session1).Should(ExitCleanly())
240
		Expect(session1.OutputToString()).To(BeEquivalentTo(cid2))
241
	})
242

243
	It("podman start container does not set HOME to home of caller", func() {
244
		home, err := os.UserHomeDir()
245
		Expect(err).ToNot(HaveOccurred())
246
		session := podmanTest.Podman([]string{"create", "--userns", "keep-id", "--user", "bin:bin", "--volume", fmt.Sprintf("%s:%s:ro", home, home), ALPINE, "ls"})
247
		session.WaitWithDefaultTimeout()
248
		Expect(session).Should(ExitCleanly())
249
		cid := session.OutputToString()
250

251
		session = podmanTest.Podman([]string{"start", cid})
252
		session.WaitWithDefaultTimeout()
253
		Expect(session).Should(ExitCleanly())
254

255
		session = podmanTest.Podman([]string{"inspect", cid, "--format", "{{.Config.Env}}"})
256
		session.WaitWithDefaultTimeout()
257
		Expect(session).Should(ExitCleanly())
258
		env := session.OutputToString()
259
		Expect(env).To(ContainSubstring("HOME"))
260
		Expect(env).ToNot(ContainSubstring(fmt.Sprintf("HOME=%s", home)))
261

262
		session = podmanTest.Podman([]string{"restart", "-t", "-1", cid})
263
		session.WaitWithDefaultTimeout()
264
		Expect(session).Should(ExitCleanly())
265

266
		session = podmanTest.Podman([]string{"inspect", cid, "--format", "{{.Config.Env}}"})
267
		session.WaitWithDefaultTimeout()
268
		Expect(session).Should(ExitCleanly())
269
		env = session.OutputToString()
270
		Expect(env).To(ContainSubstring("HOME"))
271
		Expect(env).ToNot(ContainSubstring(fmt.Sprintf("HOME=%s", home)))
272
	})
273

274
	It("podman start container sets HOME to home of execUser", func() {
275
		session := podmanTest.Podman([]string{"create", "--userns", "keep-id", "--user", "bin:bin", ALPINE, "ls"})
276
		session.WaitWithDefaultTimeout()
277
		Expect(session).Should(ExitCleanly())
278
		cid := session.OutputToString()
279

280
		session = podmanTest.Podman([]string{"start", cid})
281
		session.WaitWithDefaultTimeout()
282
		Expect(session).Should(ExitCleanly())
283

284
		session = podmanTest.Podman([]string{"inspect", cid, "--format", "{{.Config.Env}}"})
285
		session.WaitWithDefaultTimeout()
286
		Expect(session).Should(ExitCleanly())
287
		env := session.OutputToString()
288
		Expect(env).To(ContainSubstring("HOME=/bin"))
289

290
		session = podmanTest.Podman([]string{"restart", cid})
291
		session.WaitWithDefaultTimeout()
292
		Expect(session).Should(ExitCleanly())
293

294
		session = podmanTest.Podman([]string{"inspect", cid, "--format", "{{.Config.Env}}"})
295
		session.WaitWithDefaultTimeout()
296
		Expect(session).Should(ExitCleanly())
297
		env = session.OutputToString()
298
		Expect(env).To(ContainSubstring("HOME=/bin"))
299
	})
300

301
	It("podman start container retains the HOME env if present", func() {
302
		session := podmanTest.Podman([]string{"create", "--userns", "keep-id", "--user", "bin:bin", "--env=HOME=/env/is/respected", ALPINE, "ls"})
303
		session.WaitWithDefaultTimeout()
304
		Expect(session).Should(ExitCleanly())
305
		cid := session.OutputToString()
306

307
		session = podmanTest.Podman([]string{"start", cid})
308
		session.WaitWithDefaultTimeout()
309
		Expect(session).Should(ExitCleanly())
310

311
		session = podmanTest.Podman([]string{"inspect", cid, "--format", "{{.Config.Env}}"})
312
		session.WaitWithDefaultTimeout()
313
		Expect(session).Should(ExitCleanly())
314
		env := session.OutputToString()
315
		Expect(env).To(ContainSubstring("HOME=/env/is/respected"))
316

317
		session = podmanTest.Podman([]string{"restart", cid})
318
		session.WaitWithDefaultTimeout()
319
		Expect(session).Should(ExitCleanly())
320

321
		session = podmanTest.Podman([]string{"inspect", cid, "--format", "{{.Config.Env}}"})
322
		session.WaitWithDefaultTimeout()
323
		Expect(session).Should(ExitCleanly())
324
		env = session.OutputToString()
325
		Expect(env).To(ContainSubstring("HOME=/env/is/respected"))
326
	})
327
})
328