github.com/docker/engine@v22.0.0-20211208180946-d456264580cf+incompatible/integration-cli/docker_cli_events_unix_test.go (about) 1 //go:build !windows 2 // +build !windows 3 4 package main 5 6 import ( 7 "bufio" 8 "bytes" 9 "fmt" 10 "os" 11 "os/exec" 12 "strings" 13 "testing" 14 "time" 15 "unicode" 16 17 "github.com/creack/pty" 18 "github.com/docker/docker/integration-cli/cli/build" 19 "golang.org/x/sys/unix" 20 "gotest.tools/v3/assert" 21 is "gotest.tools/v3/assert/cmp" 22 ) 23 24 // #5979 25 func (s *DockerSuite) TestEventsRedirectStdout(c *testing.T) { 26 since := daemonUnixTime(c) 27 dockerCmd(c, "run", "busybox", "true") 28 29 file, err := os.CreateTemp("", "") 30 assert.NilError(c, err, "could not create temp file") 31 defer os.Remove(file.Name()) 32 33 command := fmt.Sprintf("%s events --since=%s --until=%s > %s", dockerBinary, since, daemonUnixTime(c), file.Name()) 34 _, tty, err := pty.Open() 35 assert.NilError(c, err, "Could not open pty") 36 cmd := exec.Command("sh", "-c", command) 37 cmd.Stdin = tty 38 cmd.Stdout = tty 39 cmd.Stderr = tty 40 assert.NilError(c, cmd.Run(), "run err for command %q", command) 41 42 scanner := bufio.NewScanner(file) 43 for scanner.Scan() { 44 for _, ch := range scanner.Text() { 45 assert.Check(c, unicode.IsControl(ch) == false, "found control character %v", []byte(string(ch))) 46 } 47 } 48 assert.NilError(c, scanner.Err(), "Scan err for command %q", command) 49 } 50 51 func (s *DockerSuite) TestEventsOOMDisableFalse(c *testing.T) { 52 testRequires(c, DaemonIsLinux, oomControl, memoryLimitSupport, swapMemorySupport, NotPpc64le) 53 54 errChan := make(chan error, 1) 55 go func() { 56 defer close(errChan) 57 out, exitCode, _ := dockerCmdWithError("run", "--name", "oomFalse", "-m", "10MB", "busybox", "sh", "-c", "x=a; while true; do x=$x$x$x$x; done") 58 if expected := 137; exitCode != expected { 59 errChan <- fmt.Errorf("wrong exit code for OOM container: expected %d, got %d (output: %q)", expected, exitCode, out) 60 } 61 }() 62 select { 63 case err := <-errChan: 64 assert.NilError(c, err) 65 case <-time.After(30 * time.Second): 66 c.Fatal("Timeout waiting for container to die on OOM") 67 } 68 69 out, _ := dockerCmd(c, "events", "--since=0", "-f", "container=oomFalse", "--until", daemonUnixTime(c)) 70 events := strings.Split(strings.TrimSuffix(out, "\n"), "\n") 71 nEvents := len(events) 72 73 assert.Assert(c, nEvents >= 5) 74 assert.Equal(c, parseEventAction(c, events[nEvents-5]), "create") 75 assert.Equal(c, parseEventAction(c, events[nEvents-4]), "attach") 76 assert.Equal(c, parseEventAction(c, events[nEvents-3]), "start") 77 assert.Equal(c, parseEventAction(c, events[nEvents-2]), "oom") 78 assert.Equal(c, parseEventAction(c, events[nEvents-1]), "die") 79 } 80 81 func (s *DockerSuite) TestEventsOOMDisableTrue(c *testing.T) { 82 testRequires(c, DaemonIsLinux, oomControl, memoryLimitSupport, NotArm, swapMemorySupport, NotPpc64le) 83 84 errChan := make(chan error, 1) 85 observer, err := newEventObserver(c) 86 assert.NilError(c, err) 87 err = observer.Start() 88 assert.NilError(c, err) 89 defer observer.Stop() 90 91 go func() { 92 defer close(errChan) 93 out, exitCode, _ := dockerCmdWithError("run", "--oom-kill-disable=true", "--name", "oomTrue", "-m", "10MB", "busybox", "sh", "-c", "x=a; while true; do x=$x$x$x$x; done") 94 if expected := 137; exitCode != expected { 95 errChan <- fmt.Errorf("wrong exit code for OOM container: expected %d, got %d (output: %q)", expected, exitCode, out) 96 } 97 }() 98 99 assert.NilError(c, waitRun("oomTrue")) 100 defer dockerCmdWithResult("kill", "oomTrue") 101 containerID := inspectField(c, "oomTrue", "Id") 102 103 testActions := map[string]chan bool{ 104 "oom": make(chan bool), 105 } 106 107 matcher := matchEventLine(containerID, "container", testActions) 108 processor := processEventMatch(testActions) 109 go observer.Match(matcher, processor) 110 111 select { 112 case <-time.After(20 * time.Second): 113 observer.CheckEventError(c, containerID, "oom", matcher) 114 case <-testActions["oom"]: 115 // ignore, done 116 case errRun := <-errChan: 117 if errRun != nil { 118 c.Fatalf("%v", errRun) 119 } else { 120 c.Fatalf("container should be still running but it's not") 121 } 122 } 123 124 status := inspectField(c, "oomTrue", "State.Status") 125 assert.Equal(c, strings.TrimSpace(status), "running", "container should be still running") 126 } 127 128 // #18453 129 func (s *DockerSuite) TestEventsContainerFilterByName(c *testing.T) { 130 testRequires(c, DaemonIsLinux) 131 cOut, _ := dockerCmd(c, "run", "--name=foo", "-d", "busybox", "top") 132 c1 := strings.TrimSpace(cOut) 133 waitRun("foo") 134 cOut, _ = dockerCmd(c, "run", "--name=bar", "-d", "busybox", "top") 135 c2 := strings.TrimSpace(cOut) 136 waitRun("bar") 137 out, _ := dockerCmd(c, "events", "-f", "container=foo", "--since=0", "--until", daemonUnixTime(c)) 138 assert.Assert(c, strings.Contains(out, c1), out) 139 assert.Assert(c, !strings.Contains(out, c2), out) 140 } 141 142 // #18453 143 func (s *DockerSuite) TestEventsContainerFilterBeforeCreate(c *testing.T) { 144 testRequires(c, DaemonIsLinux) 145 buf := &bytes.Buffer{} 146 cmd := exec.Command(dockerBinary, "events", "-f", "container=foo", "--since=0") 147 cmd.Stdout = buf 148 assert.NilError(c, cmd.Start()) 149 defer cmd.Wait() 150 defer cmd.Process.Kill() 151 152 // Sleep for a second to make sure we are testing the case where events are listened before container starts. 153 time.Sleep(time.Second) 154 id, _ := dockerCmd(c, "run", "--name=foo", "-d", "busybox", "top") 155 cID := strings.TrimSpace(id) 156 for i := 0; ; i++ { 157 out := buf.String() 158 if strings.Contains(out, cID) { 159 break 160 } 161 if i > 30 { 162 c.Fatalf("Missing event of container (foo, %v), got %q", cID, out) 163 } 164 time.Sleep(500 * time.Millisecond) 165 } 166 } 167 168 func (s *DockerSuite) TestVolumeEvents(c *testing.T) { 169 testRequires(c, DaemonIsLinux) 170 171 since := daemonUnixTime(c) 172 173 // Observe create/mount volume actions 174 dockerCmd(c, "volume", "create", "test-event-volume-local") 175 dockerCmd(c, "run", "--name", "test-volume-container", "--volume", "test-event-volume-local:/foo", "-d", "busybox", "true") 176 waitRun("test-volume-container") 177 178 // Observe unmount/destroy volume actions 179 dockerCmd(c, "rm", "-f", "test-volume-container") 180 dockerCmd(c, "volume", "rm", "test-event-volume-local") 181 182 until := daemonUnixTime(c) 183 out, _ := dockerCmd(c, "events", "--since", since, "--until", until) 184 events := strings.Split(strings.TrimSpace(out), "\n") 185 assert.Assert(c, len(events) > 3) 186 187 volumeEvents := eventActionsByIDAndType(c, events, "test-event-volume-local", "volume") 188 assert.Equal(c, len(volumeEvents), 4) 189 assert.Equal(c, volumeEvents[0], "create") 190 assert.Equal(c, volumeEvents[1], "mount") 191 assert.Equal(c, volumeEvents[2], "unmount") 192 assert.Equal(c, volumeEvents[3], "destroy") 193 } 194 195 func (s *DockerSuite) TestNetworkEvents(c *testing.T) { 196 testRequires(c, DaemonIsLinux) 197 198 since := daemonUnixTime(c) 199 200 // Observe create/connect network actions 201 dockerCmd(c, "network", "create", "test-event-network-local") 202 dockerCmd(c, "run", "--name", "test-network-container", "--net", "test-event-network-local", "-d", "busybox", "true") 203 waitRun("test-network-container") 204 205 // Observe disconnect/destroy network actions 206 dockerCmd(c, "rm", "-f", "test-network-container") 207 dockerCmd(c, "network", "rm", "test-event-network-local") 208 209 until := daemonUnixTime(c) 210 out, _ := dockerCmd(c, "events", "--since", since, "--until", until) 211 events := strings.Split(strings.TrimSpace(out), "\n") 212 assert.Assert(c, len(events) > 4) 213 214 netEvents := eventActionsByIDAndType(c, events, "test-event-network-local", "network") 215 assert.Equal(c, len(netEvents), 4) 216 assert.Equal(c, netEvents[0], "create") 217 assert.Equal(c, netEvents[1], "connect") 218 assert.Equal(c, netEvents[2], "disconnect") 219 assert.Equal(c, netEvents[3], "destroy") 220 } 221 222 func (s *DockerSuite) TestEventsContainerWithMultiNetwork(c *testing.T) { 223 testRequires(c, DaemonIsLinux) 224 225 // Observe create/connect network actions 226 dockerCmd(c, "network", "create", "test-event-network-local-1") 227 dockerCmd(c, "network", "create", "test-event-network-local-2") 228 dockerCmd(c, "run", "--name", "test-network-container", "--net", "test-event-network-local-1", "-td", "busybox", "sh") 229 waitRun("test-network-container") 230 dockerCmd(c, "network", "connect", "test-event-network-local-2", "test-network-container") 231 232 since := daemonUnixTime(c) 233 234 dockerCmd(c, "stop", "-t", "1", "test-network-container") 235 236 until := daemonUnixTime(c) 237 out, _ := dockerCmd(c, "events", "--since", since, "--until", until, "-f", "type=network") 238 netEvents := strings.Split(strings.TrimSpace(out), "\n") 239 240 // received two network disconnect events 241 assert.Equal(c, len(netEvents), 2) 242 assert.Assert(c, strings.Contains(netEvents[0], "disconnect")) 243 assert.Assert(c, strings.Contains(netEvents[1], "disconnect")) 244 245 // both networks appeared in the network event output 246 assert.Assert(c, strings.Contains(out, "test-event-network-local-1")) 247 assert.Assert(c, strings.Contains(out, "test-event-network-local-2")) 248 } 249 250 func (s *DockerSuite) TestEventsStreaming(c *testing.T) { 251 testRequires(c, DaemonIsLinux) 252 253 observer, err := newEventObserver(c) 254 assert.NilError(c, err) 255 err = observer.Start() 256 assert.NilError(c, err) 257 defer observer.Stop() 258 259 out, _ := dockerCmd(c, "run", "-d", "busybox:latest", "true") 260 containerID := strings.TrimSpace(out) 261 262 testActions := map[string]chan bool{ 263 "create": make(chan bool, 1), 264 "start": make(chan bool, 1), 265 "die": make(chan bool, 1), 266 "destroy": make(chan bool, 1), 267 } 268 269 matcher := matchEventLine(containerID, "container", testActions) 270 processor := processEventMatch(testActions) 271 go observer.Match(matcher, processor) 272 273 select { 274 case <-time.After(5 * time.Second): 275 observer.CheckEventError(c, containerID, "create", matcher) 276 case <-testActions["create"]: 277 // ignore, done 278 } 279 280 select { 281 case <-time.After(5 * time.Second): 282 observer.CheckEventError(c, containerID, "start", matcher) 283 case <-testActions["start"]: 284 // ignore, done 285 } 286 287 select { 288 case <-time.After(5 * time.Second): 289 observer.CheckEventError(c, containerID, "die", matcher) 290 case <-testActions["die"]: 291 // ignore, done 292 } 293 294 dockerCmd(c, "rm", containerID) 295 296 select { 297 case <-time.After(5 * time.Second): 298 observer.CheckEventError(c, containerID, "destroy", matcher) 299 case <-testActions["destroy"]: 300 // ignore, done 301 } 302 } 303 304 func (s *DockerSuite) TestEventsImageUntagDelete(c *testing.T) { 305 testRequires(c, DaemonIsLinux) 306 307 observer, err := newEventObserver(c) 308 assert.NilError(c, err) 309 err = observer.Start() 310 assert.NilError(c, err) 311 defer observer.Stop() 312 313 name := "testimageevents" 314 buildImageSuccessfully(c, name, build.WithDockerfile(`FROM scratch 315 MAINTAINER "docker"`)) 316 imageID := getIDByName(c, name) 317 assert.NilError(c, deleteImages(name)) 318 319 testActions := map[string]chan bool{ 320 "untag": make(chan bool, 1), 321 "delete": make(chan bool, 1), 322 } 323 324 matcher := matchEventLine(imageID, "image", testActions) 325 processor := processEventMatch(testActions) 326 go observer.Match(matcher, processor) 327 328 select { 329 case <-time.After(10 * time.Second): 330 observer.CheckEventError(c, imageID, "untag", matcher) 331 case <-testActions["untag"]: 332 // ignore, done 333 } 334 335 select { 336 case <-time.After(10 * time.Second): 337 observer.CheckEventError(c, imageID, "delete", matcher) 338 case <-testActions["delete"]: 339 // ignore, done 340 } 341 } 342 343 func (s *DockerSuite) TestEventsFilterVolumeAndNetworkType(c *testing.T) { 344 testRequires(c, DaemonIsLinux) 345 346 since := daemonUnixTime(c) 347 348 dockerCmd(c, "network", "create", "test-event-network-type") 349 dockerCmd(c, "volume", "create", "test-event-volume-type") 350 351 out, _ := dockerCmd(c, "events", "--filter", "type=volume", "--filter", "type=network", "--since", since, "--until", daemonUnixTime(c)) 352 events := strings.Split(strings.TrimSpace(out), "\n") 353 assert.Assert(c, len(events) >= 2, out) 354 355 networkActions := eventActionsByIDAndType(c, events, "test-event-network-type", "network") 356 volumeActions := eventActionsByIDAndType(c, events, "test-event-volume-type", "volume") 357 358 assert.Equal(c, volumeActions[0], "create") 359 assert.Equal(c, networkActions[0], "create") 360 } 361 362 func (s *DockerSuite) TestEventsFilterVolumeID(c *testing.T) { 363 testRequires(c, DaemonIsLinux) 364 365 since := daemonUnixTime(c) 366 367 dockerCmd(c, "volume", "create", "test-event-volume-id") 368 out, _ := dockerCmd(c, "events", "--filter", "volume=test-event-volume-id", "--since", since, "--until", daemonUnixTime(c)) 369 events := strings.Split(strings.TrimSpace(out), "\n") 370 assert.Equal(c, len(events), 1) 371 372 assert.Equal(c, len(events), 1) 373 assert.Assert(c, strings.Contains(events[0], "test-event-volume-id")) 374 assert.Assert(c, strings.Contains(events[0], "driver=local")) 375 } 376 377 func (s *DockerSuite) TestEventsFilterNetworkID(c *testing.T) { 378 testRequires(c, DaemonIsLinux) 379 380 since := daemonUnixTime(c) 381 382 dockerCmd(c, "network", "create", "test-event-network-local") 383 out, _ := dockerCmd(c, "events", "--filter", "network=test-event-network-local", "--since", since, "--until", daemonUnixTime(c)) 384 events := strings.Split(strings.TrimSpace(out), "\n") 385 assert.Equal(c, len(events), 1) 386 assert.Assert(c, strings.Contains(events[0], "test-event-network-local")) 387 assert.Assert(c, strings.Contains(events[0], "type=bridge")) 388 } 389 390 func (s *DockerDaemonSuite) TestDaemonEvents(c *testing.T) { 391 392 // daemon config file 393 configFilePath := "test.json" 394 defer os.Remove(configFilePath) 395 396 daemonConfig := `{"labels":["foo=bar"]}` 397 err := os.WriteFile(configFilePath, []byte(daemonConfig), 0644) 398 assert.NilError(c, err) 399 s.d.Start(c, "--config-file="+configFilePath) 400 401 info := s.d.Info(c) 402 403 daemonConfig = `{"max-concurrent-downloads":1,"labels":["bar=foo"], "shutdown-timeout": 10}` 404 err = os.WriteFile(configFilePath, []byte(daemonConfig), 0644) 405 assert.NilError(c, err) 406 407 assert.NilError(c, s.d.Signal(unix.SIGHUP)) 408 time.Sleep(3 * time.Second) 409 410 out, err := s.d.Cmd("events", "--since=0", "--until", daemonUnixTime(c)) 411 assert.NilError(c, err) 412 413 // only check for values known (daemon ID/name) or explicitly set above, 414 // otherwise just check for names being present. 415 expectedSubstrings := []string{ 416 " daemon reload " + info.ID + " ", 417 "(allow-nondistributable-artifacts=[", 418 " cluster-advertise=, ", 419 " cluster-store=, ", 420 " cluster-store-opts=", 421 " debug=true, ", 422 " default-ipc-mode=", 423 " default-runtime=", 424 " default-shm-size=", 425 " insecure-registries=[", 426 " labels=[\"bar=foo\"], ", 427 " live-restore=", 428 " max-concurrent-downloads=1, ", 429 " max-concurrent-uploads=5, ", 430 " name=" + info.Name, 431 " registry-mirrors=[", 432 " runtimes=", 433 " shutdown-timeout=10)", 434 } 435 436 for _, s := range expectedSubstrings { 437 assert.Check(c, is.Contains(out, s)) 438 } 439 } 440 441 func (s *DockerDaemonSuite) TestDaemonEventsWithFilters(c *testing.T) { 442 443 // daemon config file 444 configFilePath := "test.json" 445 defer os.Remove(configFilePath) 446 447 daemonConfig := `{"labels":["foo=bar"]}` 448 err := os.WriteFile(configFilePath, []byte(daemonConfig), 0644) 449 assert.NilError(c, err) 450 s.d.Start(c, "--config-file="+configFilePath) 451 452 info := s.d.Info(c) 453 454 assert.NilError(c, s.d.Signal(unix.SIGHUP)) 455 time.Sleep(3 * time.Second) 456 457 out, err := s.d.Cmd("events", "--since=0", "--until", daemonUnixTime(c), "--filter", fmt.Sprintf("daemon=%s", info.ID)) 458 assert.NilError(c, err) 459 assert.Assert(c, strings.Contains(out, fmt.Sprintf("daemon reload %s", info.ID))) 460 461 out, err = s.d.Cmd("events", "--since=0", "--until", daemonUnixTime(c), "--filter", fmt.Sprintf("daemon=%s", info.ID)) 462 assert.NilError(c, err) 463 assert.Assert(c, strings.Contains(out, fmt.Sprintf("daemon reload %s", info.ID))) 464 465 out, err = s.d.Cmd("events", "--since=0", "--until", daemonUnixTime(c), "--filter", "daemon=foo") 466 assert.NilError(c, err) 467 assert.Assert(c, !strings.Contains(out, fmt.Sprintf("daemon reload %s", info.ID))) 468 469 out, err = s.d.Cmd("events", "--since=0", "--until", daemonUnixTime(c), "--filter", "type=daemon") 470 assert.NilError(c, err) 471 assert.Assert(c, strings.Contains(out, fmt.Sprintf("daemon reload %s", info.ID))) 472 473 out, err = s.d.Cmd("events", "--since=0", "--until", daemonUnixTime(c), "--filter", "type=container") 474 assert.NilError(c, err) 475 assert.Assert(c, !strings.Contains(out, fmt.Sprintf("daemon reload %s", info.ID))) 476 }