github.com/endocode/docker@v1.4.2-0.20160113120958-46eb4700391e/integration-cli/docker_cli_events_test.go (about) 1 package main 2 3 import ( 4 "bufio" 5 "fmt" 6 "io/ioutil" 7 "net/http" 8 "os" 9 "os/exec" 10 "strconv" 11 "strings" 12 "sync" 13 "time" 14 15 "github.com/docker/docker/pkg/integration/checker" 16 "github.com/go-check/check" 17 ) 18 19 func (s *DockerSuite) TestEventsTimestampFormats(c *check.C) { 20 testRequires(c, DaemonIsLinux) 21 image := "busybox" 22 23 // Start stopwatch, generate an event 24 time.Sleep(1 * time.Second) // so that we don't grab events from previous test occured in the same second 25 start := daemonTime(c) 26 dockerCmd(c, "tag", image, "timestamptest:1") 27 dockerCmd(c, "rmi", "timestamptest:1") 28 time.Sleep(1 * time.Second) // so that until > since 29 end := daemonTime(c) 30 31 // List of available time formats to --since 32 unixTs := func(t time.Time) string { return fmt.Sprintf("%v", t.Unix()) } 33 rfc3339 := func(t time.Time) string { return t.Format(time.RFC3339) } 34 duration := func(t time.Time) string { return time.Now().Sub(t).String() } 35 36 // --since=$start must contain only the 'untag' event 37 for _, f := range []func(time.Time) string{unixTs, rfc3339, duration} { 38 since, until := f(start), f(end) 39 out, _ := dockerCmd(c, "events", "--since="+since, "--until="+until) 40 events := strings.Split(strings.TrimSpace(out), "\n") 41 c.Assert(events, checker.HasLen, 2, check.Commentf("unexpected events, was expecting only 2 events tag/untag (since=%s, until=%s) out=%s", since, until, out)) 42 c.Assert(out, checker.Contains, "untag", check.Commentf("expected 'untag' event not found (since=%s, until=%s)", since, until)) 43 } 44 45 } 46 47 func (s *DockerSuite) TestEventsUntag(c *check.C) { 48 testRequires(c, DaemonIsLinux) 49 image := "busybox" 50 dockerCmd(c, "tag", image, "utest:tag1") 51 dockerCmd(c, "tag", image, "utest:tag2") 52 dockerCmd(c, "rmi", "utest:tag1") 53 dockerCmd(c, "rmi", "utest:tag2") 54 eventsCmd := exec.Command(dockerBinary, "events", "--since=1") 55 out, exitCode, _, err := runCommandWithOutputForDuration(eventsCmd, time.Duration(time.Millisecond*2500)) 56 c.Assert(err, checker.IsNil) 57 c.Assert(exitCode, checker.Equals, 0, check.Commentf("Failed to get events")) 58 events := strings.Split(out, "\n") 59 nEvents := len(events) 60 // The last element after the split above will be an empty string, so we 61 // get the two elements before the last, which are the untags we're 62 // looking for. 63 for _, v := range events[nEvents-3 : nEvents-1] { 64 c.Assert(v, checker.Contains, "untag", check.Commentf("event should be untag")) 65 } 66 } 67 68 func (s *DockerSuite) TestEventsContainerFailStartDie(c *check.C) { 69 out, _ := dockerCmd(c, "images", "-q") 70 image := strings.Split(out, "\n")[0] 71 _, _, err := dockerCmdWithError("run", "--name", "testeventdie", image, "blerg") 72 c.Assert(err, checker.NotNil, check.Commentf("Container run with command blerg should have failed, but it did not, out=%s", out)) 73 74 out, _ = dockerCmd(c, "events", "--since=0", fmt.Sprintf("--until=%d", daemonTime(c).Unix())) 75 events := strings.Split(strings.TrimSpace(out), "\n") 76 77 nEvents := len(events) 78 c.Assert(nEvents, checker.GreaterOrEqualThan, 1) //Missing expected event 79 80 actions := eventActionsByIDAndType(c, events, "testeventdie", "container") 81 82 var startEvent bool 83 var dieEvent bool 84 for _, a := range actions { 85 switch a { 86 case "start": 87 startEvent = true 88 case "die": 89 dieEvent = true 90 } 91 } 92 c.Assert(startEvent, checker.True, check.Commentf("Start event not found: %v\n%v", actions, events)) 93 c.Assert(dieEvent, checker.True, check.Commentf("Die event not found: %v\n%v", actions, events)) 94 } 95 96 func (s *DockerSuite) TestEventsLimit(c *check.C) { 97 testRequires(c, DaemonIsLinux) 98 var waitGroup sync.WaitGroup 99 errChan := make(chan error, 17) 100 101 args := []string{"run", "--rm", "busybox", "true"} 102 for i := 0; i < 17; i++ { 103 waitGroup.Add(1) 104 go func() { 105 defer waitGroup.Done() 106 errChan <- exec.Command(dockerBinary, args...).Run() 107 }() 108 } 109 110 waitGroup.Wait() 111 close(errChan) 112 113 for err := range errChan { 114 c.Assert(err, checker.IsNil, check.Commentf("%q failed with error", strings.Join(args, " "))) 115 } 116 117 out, _ := dockerCmd(c, "events", "--since=0", fmt.Sprintf("--until=%d", daemonTime(c).Unix())) 118 events := strings.Split(out, "\n") 119 nEvents := len(events) - 1 120 c.Assert(nEvents, checker.Equals, 64, check.Commentf("events should be limited to 64, but received %d", nEvents)) 121 } 122 123 func (s *DockerSuite) TestEventsContainerEvents(c *check.C) { 124 testRequires(c, DaemonIsLinux) 125 containerID, _ := dockerCmd(c, "run", "--rm", "--name", "container-events-test", "busybox", "true") 126 containerID = strings.TrimSpace(containerID) 127 128 out, _ := dockerCmd(c, "events", "--since=0", fmt.Sprintf("--until=%d", daemonTime(c).Unix())) 129 events := strings.Split(out, "\n") 130 events = events[:len(events)-1] 131 132 nEvents := len(events) 133 c.Assert(nEvents, checker.GreaterOrEqualThan, 5) //Missing expected event 134 containerEvents := eventActionsByIDAndType(c, events, "container-events-test", "container") 135 c.Assert(containerEvents, checker.HasLen, 5, check.Commentf("events: %v", events)) 136 137 c.Assert(containerEvents[0], checker.Equals, "create", check.Commentf(out)) 138 c.Assert(containerEvents[1], checker.Equals, "attach", check.Commentf(out)) 139 c.Assert(containerEvents[2], checker.Equals, "start", check.Commentf(out)) 140 c.Assert(containerEvents[3], checker.Equals, "die", check.Commentf(out)) 141 c.Assert(containerEvents[4], checker.Equals, "destroy", check.Commentf(out)) 142 } 143 144 func (s *DockerSuite) TestEventsContainerEventsSinceUnixEpoch(c *check.C) { 145 testRequires(c, DaemonIsLinux) 146 dockerCmd(c, "run", "--rm", "--name", "since-epoch-test", "busybox", "true") 147 timeBeginning := time.Unix(0, 0).Format(time.RFC3339Nano) 148 timeBeginning = strings.Replace(timeBeginning, "Z", ".000000000Z", -1) 149 out, _ := dockerCmd(c, "events", fmt.Sprintf("--since='%s'", timeBeginning), fmt.Sprintf("--until=%d", daemonTime(c).Unix())) 150 events := strings.Split(out, "\n") 151 events = events[:len(events)-1] 152 153 nEvents := len(events) 154 c.Assert(nEvents, checker.GreaterOrEqualThan, 5) //Missing expected event 155 containerEvents := eventActionsByIDAndType(c, events, "since-epoch-test", "container") 156 c.Assert(containerEvents, checker.HasLen, 5, check.Commentf("events: %v", events)) 157 158 c.Assert(containerEvents[0], checker.Equals, "create", check.Commentf(out)) 159 c.Assert(containerEvents[1], checker.Equals, "attach", check.Commentf(out)) 160 c.Assert(containerEvents[2], checker.Equals, "start", check.Commentf(out)) 161 c.Assert(containerEvents[3], checker.Equals, "die", check.Commentf(out)) 162 c.Assert(containerEvents[4], checker.Equals, "destroy", check.Commentf(out)) 163 } 164 165 func (s *DockerSuite) TestEventsImageTag(c *check.C) { 166 testRequires(c, DaemonIsLinux) 167 time.Sleep(1 * time.Second) // because API has seconds granularity 168 since := daemonTime(c).Unix() 169 image := "testimageevents:tag" 170 dockerCmd(c, "tag", "busybox", image) 171 172 out, _ := dockerCmd(c, "events", 173 fmt.Sprintf("--since=%d", since), 174 fmt.Sprintf("--until=%d", daemonTime(c).Unix())) 175 176 events := strings.Split(strings.TrimSpace(out), "\n") 177 c.Assert(events, checker.HasLen, 1, check.Commentf("was expecting 1 event. out=%s", out)) 178 event := strings.TrimSpace(events[0]) 179 180 matches := parseEventText(event) 181 c.Assert(matchEventID(matches, image), checker.True, check.Commentf("matches: %v\nout:\n%s", matches, out)) 182 c.Assert(matches["action"], checker.Equals, "tag") 183 } 184 185 func (s *DockerSuite) TestEventsImagePull(c *check.C) { 186 testRequires(c, DaemonIsLinux) 187 since := daemonTime(c).Unix() 188 testRequires(c, Network) 189 190 dockerCmd(c, "pull", "hello-world") 191 192 out, _ := dockerCmd(c, "events", 193 fmt.Sprintf("--since=%d", since), 194 fmt.Sprintf("--until=%d", daemonTime(c).Unix())) 195 196 events := strings.Split(strings.TrimSpace(out), "\n") 197 event := strings.TrimSpace(events[len(events)-1]) 198 matches := parseEventText(event) 199 c.Assert(matches["id"], checker.Equals, "hello-world:latest") 200 c.Assert(matches["action"], checker.Equals, "pull") 201 202 } 203 204 func (s *DockerSuite) TestEventsImageImport(c *check.C) { 205 testRequires(c, DaemonIsLinux) 206 207 out, _ := dockerCmd(c, "run", "-d", "busybox", "true") 208 cleanedContainerID := strings.TrimSpace(out) 209 210 since := daemonTime(c).Unix() 211 out, _, err := runCommandPipelineWithOutput( 212 exec.Command(dockerBinary, "export", cleanedContainerID), 213 exec.Command(dockerBinary, "import", "-"), 214 ) 215 c.Assert(err, checker.IsNil, check.Commentf("import failed with output: %q", out)) 216 imageRef := strings.TrimSpace(out) 217 218 out, _ = dockerCmd(c, "events", fmt.Sprintf("--since=%d", since), fmt.Sprintf("--until=%d", daemonTime(c).Unix()), "--filter", "event=import") 219 events := strings.Split(strings.TrimSpace(out), "\n") 220 c.Assert(events, checker.HasLen, 1) 221 matches := parseEventText(events[0]) 222 c.Assert(matches["id"], checker.Equals, imageRef, check.Commentf("matches: %v\nout:\n%s\n", matches, out)) 223 c.Assert(matches["action"], checker.Equals, "import", check.Commentf("matches: %v\nout:\n%s\n", matches, out)) 224 } 225 226 func (s *DockerSuite) TestEventsFilters(c *check.C) { 227 testRequires(c, DaemonIsLinux) 228 229 since := daemonTime(c).Unix() 230 dockerCmd(c, "run", "--rm", "busybox", "true") 231 dockerCmd(c, "run", "--rm", "busybox", "true") 232 out, _ := dockerCmd(c, "events", fmt.Sprintf("--since=%d", since), fmt.Sprintf("--until=%d", daemonTime(c).Unix()), "--filter", "event=die") 233 parseEvents(c, out, "die") 234 235 out, _ = dockerCmd(c, "events", fmt.Sprintf("--since=%d", since), fmt.Sprintf("--until=%d", daemonTime(c).Unix()), "--filter", "event=die", "--filter", "event=start") 236 parseEvents(c, out, "die|start") 237 238 // make sure we at least got 2 start events 239 count := strings.Count(out, "start") 240 c.Assert(strings.Count(out, "start"), checker.GreaterOrEqualThan, 2, check.Commentf("should have had 2 start events but had %d, out: %s", count, out)) 241 242 } 243 244 func (s *DockerSuite) TestEventsFilterImageName(c *check.C) { 245 testRequires(c, DaemonIsLinux) 246 since := daemonTime(c).Unix() 247 248 out, _ := dockerCmd(c, "run", "--name", "container_1", "-d", "busybox:latest", "true") 249 container1 := strings.TrimSpace(out) 250 251 out, _ = dockerCmd(c, "run", "--name", "container_2", "-d", "busybox", "true") 252 container2 := strings.TrimSpace(out) 253 254 name := "busybox" 255 out, _ = dockerCmd(c, "events", fmt.Sprintf("--since=%d", since), fmt.Sprintf("--until=%d", daemonTime(c).Unix()), "--filter", fmt.Sprintf("image=%s", name)) 256 events := strings.Split(out, "\n") 257 events = events[:len(events)-1] 258 c.Assert(events, checker.Not(checker.HasLen), 0) //Expected events but found none for the image busybox:latest 259 count1 := 0 260 count2 := 0 261 262 for _, e := range events { 263 if strings.Contains(e, container1) { 264 count1++ 265 } else if strings.Contains(e, container2) { 266 count2++ 267 } 268 } 269 c.Assert(count1, checker.Not(checker.Equals), 0, check.Commentf("Expected event from container but got %d from %s", count1, container1)) 270 c.Assert(count2, checker.Not(checker.Equals), 0, check.Commentf("Expected event from container but got %d from %s", count2, container2)) 271 272 } 273 274 func (s *DockerSuite) TestEventsFilterLabels(c *check.C) { 275 testRequires(c, DaemonIsLinux) 276 since := daemonTime(c).Unix() 277 label := "io.docker.testing=foo" 278 279 out, _ := dockerCmd(c, "run", "-d", "-l", label, "busybox:latest", "true") 280 container1 := strings.TrimSpace(out) 281 282 out, _ = dockerCmd(c, "run", "-d", "busybox", "true") 283 container2 := strings.TrimSpace(out) 284 285 out, _ = dockerCmd( 286 c, 287 "events", 288 fmt.Sprintf("--since=%d", since), 289 fmt.Sprintf("--until=%d", daemonTime(c).Unix()), 290 "--filter", fmt.Sprintf("label=%s", label)) 291 292 events := strings.Split(strings.TrimSpace(out), "\n") 293 c.Assert(len(events), checker.Equals, 3) 294 295 for _, e := range events { 296 c.Assert(e, checker.Contains, container1) 297 c.Assert(e, checker.Not(checker.Contains), container2) 298 } 299 } 300 301 func (s *DockerSuite) TestEventsFilterImageLabels(c *check.C) { 302 testRequires(c, DaemonIsLinux) 303 since := daemonTime(c).Unix() 304 name := "labelfiltertest" 305 label := "io.docker.testing=image" 306 307 // Build a test image. 308 _, err := buildImage(name, fmt.Sprintf(` 309 FROM busybox:latest 310 LABEL %s`, label), true) 311 c.Assert(err, checker.IsNil, check.Commentf("Couldn't create image")) 312 313 dockerCmd(c, "tag", name, "labelfiltertest:tag1") 314 dockerCmd(c, "tag", name, "labelfiltertest:tag2") 315 dockerCmd(c, "tag", "busybox:latest", "labelfiltertest:tag3") 316 317 out, _ := dockerCmd( 318 c, 319 "events", 320 fmt.Sprintf("--since=%d", since), 321 fmt.Sprintf("--until=%d", daemonTime(c).Unix()), 322 "--filter", fmt.Sprintf("label=%s", label), 323 "--filter", "type=image") 324 325 events := strings.Split(strings.TrimSpace(out), "\n") 326 327 // 2 events from the "docker tag" command, another one is from "docker build" 328 c.Assert(events, checker.HasLen, 3, check.Commentf("Events == %s", events)) 329 for _, e := range events { 330 c.Assert(e, checker.Contains, "labelfiltertest") 331 } 332 } 333 334 func (s *DockerSuite) TestEventsFilterContainer(c *check.C) { 335 testRequires(c, DaemonIsLinux) 336 since := fmt.Sprintf("%d", daemonTime(c).Unix()) 337 nameID := make(map[string]string) 338 339 for _, name := range []string{"container_1", "container_2"} { 340 dockerCmd(c, "run", "--name", name, "busybox", "true") 341 id, err := inspectField(name, "Id") 342 c.Assert(err, checker.IsNil) 343 nameID[name] = id 344 } 345 346 until := fmt.Sprintf("%d", daemonTime(c).Unix()) 347 348 checkEvents := func(id string, events []string) error { 349 if len(events) != 4 { // create, attach, start, die 350 return fmt.Errorf("expected 4 events, got %v", events) 351 } 352 for _, event := range events { 353 matches := parseEventText(event) 354 if !matchEventID(matches, id) { 355 return fmt.Errorf("expected event for container id %s: %s - parsed container id: %s", id, event, matches["id"]) 356 } 357 } 358 return nil 359 } 360 361 for name, ID := range nameID { 362 // filter by names 363 out, _ := dockerCmd(c, "events", "--since", since, "--until", until, "--filter", "container="+name) 364 events := strings.Split(strings.TrimSuffix(out, "\n"), "\n") 365 c.Assert(checkEvents(ID, events), checker.IsNil) 366 367 // filter by ID's 368 out, _ = dockerCmd(c, "events", "--since", since, "--until", until, "--filter", "container="+ID) 369 events = strings.Split(strings.TrimSuffix(out, "\n"), "\n") 370 c.Assert(checkEvents(ID, events), checker.IsNil) 371 } 372 } 373 374 func (s *DockerSuite) TestEventsCommit(c *check.C) { 375 testRequires(c, DaemonIsLinux) 376 since := daemonTime(c).Unix() 377 378 out, _ := dockerCmd(c, "run", "-d", "busybox", "top") 379 cID := strings.TrimSpace(out) 380 c.Assert(waitRun(cID), checker.IsNil) 381 382 dockerCmd(c, "commit", "-m", "test", cID) 383 dockerCmd(c, "stop", cID) 384 385 out, _ = dockerCmd(c, "events", "--since=0", "-f", "container="+cID, "--until="+strconv.Itoa(int(since))) 386 c.Assert(out, checker.Contains, "commit", check.Commentf("Missing 'commit' log event")) 387 } 388 389 func (s *DockerSuite) TestEventsCopy(c *check.C) { 390 testRequires(c, DaemonIsLinux) 391 since := daemonTime(c).Unix() 392 393 // Build a test image. 394 id, err := buildImage("cpimg", ` 395 FROM busybox 396 RUN echo HI > /tmp/file`, true) 397 c.Assert(err, checker.IsNil, check.Commentf("Couldn't create image")) 398 399 // Create an empty test file. 400 tempFile, err := ioutil.TempFile("", "test-events-copy-") 401 c.Assert(err, checker.IsNil) 402 defer os.Remove(tempFile.Name()) 403 404 c.Assert(tempFile.Close(), checker.IsNil) 405 406 dockerCmd(c, "create", "--name=cptest", id) 407 408 dockerCmd(c, "cp", "cptest:/tmp/file", tempFile.Name()) 409 410 out, _ := dockerCmd(c, "events", "--since=0", "-f", "container=cptest", "--until="+strconv.Itoa(int(since))) 411 c.Assert(out, checker.Contains, "archive-path", check.Commentf("Missing 'archive-path' log event\n")) 412 413 dockerCmd(c, "cp", tempFile.Name(), "cptest:/tmp/filecopy") 414 415 out, _ = dockerCmd(c, "events", "--since=0", "-f", "container=cptest", "--until="+strconv.Itoa(int(since))) 416 c.Assert(out, checker.Contains, "extract-to-dir", check.Commentf("Missing 'extract-to-dir' log event")) 417 } 418 419 func (s *DockerSuite) TestEventsResize(c *check.C) { 420 testRequires(c, DaemonIsLinux) 421 since := daemonTime(c).Unix() 422 423 out, _ := dockerCmd(c, "run", "-d", "busybox", "top") 424 cID := strings.TrimSpace(out) 425 c.Assert(waitRun(cID), checker.IsNil) 426 427 endpoint := "/containers/" + cID + "/resize?h=80&w=24" 428 status, _, err := sockRequest("POST", endpoint, nil) 429 c.Assert(status, checker.Equals, http.StatusOK) 430 c.Assert(err, checker.IsNil) 431 432 dockerCmd(c, "stop", cID) 433 434 out, _ = dockerCmd(c, "events", "--since=0", "-f", "container="+cID, "--until="+strconv.Itoa(int(since))) 435 c.Assert(out, checker.Contains, "resize", check.Commentf("Missing 'resize' log event")) 436 } 437 438 func (s *DockerSuite) TestEventsAttach(c *check.C) { 439 testRequires(c, DaemonIsLinux) 440 since := daemonTime(c).Unix() 441 442 out, _ := dockerCmd(c, "run", "-di", "busybox", "/bin/cat") 443 cID := strings.TrimSpace(out) 444 445 cmd := exec.Command(dockerBinary, "attach", cID) 446 stdin, err := cmd.StdinPipe() 447 c.Assert(err, checker.IsNil) 448 defer stdin.Close() 449 stdout, err := cmd.StdoutPipe() 450 c.Assert(err, checker.IsNil) 451 defer stdout.Close() 452 c.Assert(cmd.Start(), checker.IsNil) 453 defer cmd.Process.Kill() 454 455 // Make sure we're done attaching by writing/reading some stuff 456 _, err = stdin.Write([]byte("hello\n")) 457 c.Assert(err, checker.IsNil) 458 out, err = bufio.NewReader(stdout).ReadString('\n') 459 c.Assert(err, checker.IsNil) 460 c.Assert(strings.TrimSpace(out), checker.Equals, "hello", check.Commentf("expected 'hello'")) 461 462 c.Assert(stdin.Close(), checker.IsNil) 463 464 dockerCmd(c, "stop", cID) 465 466 out, _ = dockerCmd(c, "events", "--since=0", "-f", "container="+cID, "--until="+strconv.Itoa(int(since))) 467 c.Assert(out, checker.Contains, "attach", check.Commentf("Missing 'attach' log event")) 468 } 469 470 func (s *DockerSuite) TestEventsRename(c *check.C) { 471 testRequires(c, DaemonIsLinux) 472 since := daemonTime(c).Unix() 473 474 dockerCmd(c, "run", "--name", "oldName", "busybox", "true") 475 dockerCmd(c, "rename", "oldName", "newName") 476 477 out, _ := dockerCmd(c, "events", "--since=0", "-f", "container=newName", "--until="+strconv.Itoa(int(since))) 478 c.Assert(out, checker.Contains, "rename", check.Commentf("Missing 'rename' log event\n")) 479 } 480 481 func (s *DockerSuite) TestEventsTop(c *check.C) { 482 testRequires(c, DaemonIsLinux) 483 since := daemonTime(c).Unix() 484 485 out, _ := dockerCmd(c, "run", "-d", "busybox", "top") 486 cID := strings.TrimSpace(out) 487 c.Assert(waitRun(cID), checker.IsNil) 488 489 dockerCmd(c, "top", cID) 490 dockerCmd(c, "stop", cID) 491 492 out, _ = dockerCmd(c, "events", "--since=0", "-f", "container="+cID, "--until="+strconv.Itoa(int(since))) 493 c.Assert(out, checker.Contains, " top", check.Commentf("Missing 'top' log event")) 494 } 495 496 // #13753 497 func (s *DockerSuite) TestEventsDefaultEmpty(c *check.C) { 498 testRequires(c, DaemonIsLinux) 499 dockerCmd(c, "run", "busybox") 500 out, _ := dockerCmd(c, "events", fmt.Sprintf("--until=%d", daemonTime(c).Unix())) 501 c.Assert(strings.TrimSpace(out), checker.Equals, "") 502 } 503 504 // #14316 505 func (s *DockerRegistrySuite) TestEventsImageFilterPush(c *check.C) { 506 testRequires(c, DaemonIsLinux) 507 testRequires(c, Network) 508 since := daemonTime(c).Unix() 509 repoName := fmt.Sprintf("%v/dockercli/testf", privateRegistryURL) 510 511 out, _ := dockerCmd(c, "run", "-d", "busybox", "top") 512 cID := strings.TrimSpace(out) 513 c.Assert(waitRun(cID), checker.IsNil) 514 515 dockerCmd(c, "commit", cID, repoName) 516 dockerCmd(c, "stop", cID) 517 dockerCmd(c, "push", repoName) 518 519 out, _ = dockerCmd(c, "events", "--since=0", "-f", "image="+repoName, "-f", "event=push", "--until="+strconv.Itoa(int(since))) 520 c.Assert(out, checker.Contains, repoName, check.Commentf("Missing 'push' log event for %s", repoName)) 521 } 522 523 func (s *DockerSuite) TestEventsFilterType(c *check.C) { 524 testRequires(c, DaemonIsLinux) 525 since := daemonTime(c).Unix() 526 name := "labelfiltertest" 527 label := "io.docker.testing=image" 528 529 // Build a test image. 530 _, err := buildImage(name, fmt.Sprintf(` 531 FROM busybox:latest 532 LABEL %s`, label), true) 533 c.Assert(err, checker.IsNil, check.Commentf("Couldn't create image")) 534 535 dockerCmd(c, "tag", name, "labelfiltertest:tag1") 536 dockerCmd(c, "tag", name, "labelfiltertest:tag2") 537 dockerCmd(c, "tag", "busybox:latest", "labelfiltertest:tag3") 538 539 out, _ := dockerCmd( 540 c, 541 "events", 542 fmt.Sprintf("--since=%d", since), 543 fmt.Sprintf("--until=%d", daemonTime(c).Unix()), 544 "--filter", fmt.Sprintf("label=%s", label), 545 "--filter", "type=image") 546 547 events := strings.Split(strings.TrimSpace(out), "\n") 548 549 // 2 events from the "docker tag" command, another one is from "docker build" 550 c.Assert(events, checker.HasLen, 3, check.Commentf("Events == %s", events)) 551 for _, e := range events { 552 c.Assert(e, checker.Contains, "labelfiltertest") 553 } 554 555 out, _ = dockerCmd( 556 c, 557 "events", 558 fmt.Sprintf("--since=%d", since), 559 fmt.Sprintf("--until=%d", daemonTime(c).Unix()), 560 "--filter", fmt.Sprintf("label=%s", label), 561 "--filter", "type=container") 562 events = strings.Split(strings.TrimSpace(out), "\n") 563 564 // Events generated by the container that builds the image 565 c.Assert(events, checker.HasLen, 3, check.Commentf("Events == %s", events)) 566 567 out, _ = dockerCmd( 568 c, 569 "events", 570 fmt.Sprintf("--since=%d", since), 571 fmt.Sprintf("--until=%d", daemonTime(c).Unix()), 572 "--filter", "type=network") 573 events = strings.Split(strings.TrimSpace(out), "\n") 574 c.Assert(len(events), checker.GreaterOrEqualThan, 1, check.Commentf("Events == %s", events)) 575 } 576 577 func (s *DockerSuite) TestEventsFilterImageInContainerAction(c *check.C) { 578 testRequires(c, DaemonIsLinux) 579 580 since := daemonTime(c).Unix() 581 dockerCmd(c, "run", "--name", "test-container", "-d", "busybox", "true") 582 waitRun("test-container") 583 584 out, _ := dockerCmd(c, "events", "--filter", "image=busybox", fmt.Sprintf("--since=%d", since), fmt.Sprintf("--until=%d", daemonTime(c).Unix())) 585 events := strings.Split(strings.TrimSpace(out), "\n") 586 c.Assert(len(events), checker.GreaterThan, 1, check.Commentf(out)) 587 }