docker_cli_events_test.go 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767
  1. package main
  2. import (
  3. "bufio"
  4. "encoding/json"
  5. "fmt"
  6. "io"
  7. "io/ioutil"
  8. "os"
  9. "os/exec"
  10. "strings"
  11. "time"
  12. "github.com/docker/docker/api/types"
  13. eventtypes "github.com/docker/docker/api/types/events"
  14. "github.com/docker/docker/client"
  15. eventstestutils "github.com/docker/docker/daemon/events/testutils"
  16. "github.com/docker/docker/integration-cli/checker"
  17. "github.com/docker/docker/integration-cli/cli"
  18. "github.com/docker/docker/integration-cli/cli/build"
  19. "github.com/go-check/check"
  20. "github.com/gotestyourself/gotestyourself/icmd"
  21. "golang.org/x/net/context"
  22. )
  23. func (s *DockerSuite) TestEventsTimestampFormats(c *check.C) {
  24. name := "events-time-format-test"
  25. // Start stopwatch, generate an event
  26. start := daemonTime(c)
  27. time.Sleep(1100 * time.Millisecond) // so that first event occur in different second from since (just for the case)
  28. dockerCmd(c, "run", "--rm", "--name", name, "busybox", "true")
  29. time.Sleep(1100 * time.Millisecond) // so that until > since
  30. end := daemonTime(c)
  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.Since(t).String() }
  35. // --since=$start must contain only the 'untag' event
  36. for _, f := range []func(time.Time) string{unixTs, rfc3339, duration} {
  37. since, until := f(start), f(end)
  38. out, _ := dockerCmd(c, "events", "--since="+since, "--until="+until)
  39. events := strings.Split(out, "\n")
  40. events = events[:len(events)-1]
  41. nEvents := len(events)
  42. c.Assert(nEvents, checker.GreaterOrEqualThan, 5) //Missing expected event
  43. containerEvents := eventActionsByIDAndType(c, events, name, "container")
  44. c.Assert(containerEvents, checker.HasLen, 5, check.Commentf("events: %v", events))
  45. c.Assert(containerEvents[0], checker.Equals, "create", check.Commentf(out))
  46. c.Assert(containerEvents[1], checker.Equals, "attach", check.Commentf(out))
  47. c.Assert(containerEvents[2], checker.Equals, "start", check.Commentf(out))
  48. c.Assert(containerEvents[3], checker.Equals, "die", check.Commentf(out))
  49. c.Assert(containerEvents[4], checker.Equals, "destroy", check.Commentf(out))
  50. }
  51. }
  52. func (s *DockerSuite) TestEventsUntag(c *check.C) {
  53. image := "busybox"
  54. dockerCmd(c, "tag", image, "utest:tag1")
  55. dockerCmd(c, "tag", image, "utest:tag2")
  56. dockerCmd(c, "rmi", "utest:tag1")
  57. dockerCmd(c, "rmi", "utest:tag2")
  58. result := icmd.RunCmd(icmd.Cmd{
  59. Command: []string{dockerBinary, "events", "--since=1"},
  60. Timeout: time.Millisecond * 2500,
  61. })
  62. result.Assert(c, icmd.Expected{Timeout: true})
  63. events := strings.Split(result.Stdout(), "\n")
  64. nEvents := len(events)
  65. // The last element after the split above will be an empty string, so we
  66. // get the two elements before the last, which are the untags we're
  67. // looking for.
  68. for _, v := range events[nEvents-3 : nEvents-1] {
  69. c.Assert(v, checker.Contains, "untag", check.Commentf("event should be untag"))
  70. }
  71. }
  72. func (s *DockerSuite) TestEventsContainerEvents(c *check.C) {
  73. dockerCmd(c, "run", "--rm", "--name", "container-events-test", "busybox", "true")
  74. out, _ := dockerCmd(c, "events", "--until", daemonUnixTime(c))
  75. events := strings.Split(out, "\n")
  76. events = events[:len(events)-1]
  77. nEvents := len(events)
  78. c.Assert(nEvents, checker.GreaterOrEqualThan, 5) //Missing expected event
  79. containerEvents := eventActionsByIDAndType(c, events, "container-events-test", "container")
  80. c.Assert(containerEvents, checker.HasLen, 5, check.Commentf("events: %v", events))
  81. c.Assert(containerEvents[0], checker.Equals, "create", check.Commentf(out))
  82. c.Assert(containerEvents[1], checker.Equals, "attach", check.Commentf(out))
  83. c.Assert(containerEvents[2], checker.Equals, "start", check.Commentf(out))
  84. c.Assert(containerEvents[3], checker.Equals, "die", check.Commentf(out))
  85. c.Assert(containerEvents[4], checker.Equals, "destroy", check.Commentf(out))
  86. }
  87. func (s *DockerSuite) TestEventsContainerEventsAttrSort(c *check.C) {
  88. since := daemonUnixTime(c)
  89. dockerCmd(c, "run", "--rm", "--name", "container-events-test", "busybox", "true")
  90. out, _ := dockerCmd(c, "events", "--filter", "container=container-events-test", "--since", since, "--until", daemonUnixTime(c))
  91. events := strings.Split(out, "\n")
  92. nEvents := len(events)
  93. c.Assert(nEvents, checker.GreaterOrEqualThan, 3) //Missing expected event
  94. matchedEvents := 0
  95. for _, event := range events {
  96. matches := eventstestutils.ScanMap(event)
  97. if matches["eventType"] == "container" && matches["action"] == "create" {
  98. matchedEvents++
  99. c.Assert(out, checker.Contains, "(image=busybox, name=container-events-test)", check.Commentf("Event attributes not sorted"))
  100. } else if matches["eventType"] == "container" && matches["action"] == "start" {
  101. matchedEvents++
  102. c.Assert(out, checker.Contains, "(image=busybox, name=container-events-test)", check.Commentf("Event attributes not sorted"))
  103. }
  104. }
  105. c.Assert(matchedEvents, checker.Equals, 2, check.Commentf("missing events for container container-events-test:\n%s", out))
  106. }
  107. func (s *DockerSuite) TestEventsContainerEventsSinceUnixEpoch(c *check.C) {
  108. dockerCmd(c, "run", "--rm", "--name", "since-epoch-test", "busybox", "true")
  109. timeBeginning := time.Unix(0, 0).Format(time.RFC3339Nano)
  110. timeBeginning = strings.Replace(timeBeginning, "Z", ".000000000Z", -1)
  111. out, _ := dockerCmd(c, "events", "--since", timeBeginning, "--until", daemonUnixTime(c))
  112. events := strings.Split(out, "\n")
  113. events = events[:len(events)-1]
  114. nEvents := len(events)
  115. c.Assert(nEvents, checker.GreaterOrEqualThan, 5) //Missing expected event
  116. containerEvents := eventActionsByIDAndType(c, events, "since-epoch-test", "container")
  117. c.Assert(containerEvents, checker.HasLen, 5, check.Commentf("events: %v", events))
  118. c.Assert(containerEvents[0], checker.Equals, "create", check.Commentf(out))
  119. c.Assert(containerEvents[1], checker.Equals, "attach", check.Commentf(out))
  120. c.Assert(containerEvents[2], checker.Equals, "start", check.Commentf(out))
  121. c.Assert(containerEvents[3], checker.Equals, "die", check.Commentf(out))
  122. c.Assert(containerEvents[4], checker.Equals, "destroy", check.Commentf(out))
  123. }
  124. func (s *DockerSuite) TestEventsImageTag(c *check.C) {
  125. time.Sleep(1 * time.Second) // because API has seconds granularity
  126. since := daemonUnixTime(c)
  127. image := "testimageevents:tag"
  128. dockerCmd(c, "tag", "busybox", image)
  129. out, _ := dockerCmd(c, "events",
  130. "--since", since, "--until", daemonUnixTime(c))
  131. events := strings.Split(strings.TrimSpace(out), "\n")
  132. c.Assert(events, checker.HasLen, 1, check.Commentf("was expecting 1 event. out=%s", out))
  133. event := strings.TrimSpace(events[0])
  134. matches := eventstestutils.ScanMap(event)
  135. c.Assert(matchEventID(matches, image), checker.True, check.Commentf("matches: %v\nout:\n%s", matches, out))
  136. c.Assert(matches["action"], checker.Equals, "tag")
  137. }
  138. func (s *DockerSuite) TestEventsImagePull(c *check.C) {
  139. // TODO Windows: Enable this test once pull and reliable image names are available
  140. testRequires(c, DaemonIsLinux)
  141. since := daemonUnixTime(c)
  142. testRequires(c, Network)
  143. dockerCmd(c, "pull", "hello-world")
  144. out, _ := dockerCmd(c, "events",
  145. "--since", since, "--until", daemonUnixTime(c))
  146. events := strings.Split(strings.TrimSpace(out), "\n")
  147. event := strings.TrimSpace(events[len(events)-1])
  148. matches := eventstestutils.ScanMap(event)
  149. c.Assert(matches["id"], checker.Equals, "hello-world:latest")
  150. c.Assert(matches["action"], checker.Equals, "pull")
  151. }
  152. func (s *DockerSuite) TestEventsImageImport(c *check.C) {
  153. // TODO Windows CI. This should be portable once export/import are
  154. // more reliable (@swernli)
  155. testRequires(c, DaemonIsLinux)
  156. out, _ := dockerCmd(c, "run", "-d", "busybox", "true")
  157. cleanedContainerID := strings.TrimSpace(out)
  158. since := daemonUnixTime(c)
  159. out, err := RunCommandPipelineWithOutput(
  160. exec.Command(dockerBinary, "export", cleanedContainerID),
  161. exec.Command(dockerBinary, "import", "-"),
  162. )
  163. c.Assert(err, checker.IsNil, check.Commentf("import failed with output: %q", out))
  164. imageRef := strings.TrimSpace(out)
  165. out, _ = dockerCmd(c, "events", "--since", since, "--until", daemonUnixTime(c), "--filter", "event=import")
  166. events := strings.Split(strings.TrimSpace(out), "\n")
  167. c.Assert(events, checker.HasLen, 1)
  168. matches := eventstestutils.ScanMap(events[0])
  169. c.Assert(matches["id"], checker.Equals, imageRef, check.Commentf("matches: %v\nout:\n%s\n", matches, out))
  170. c.Assert(matches["action"], checker.Equals, "import", check.Commentf("matches: %v\nout:\n%s\n", matches, out))
  171. }
  172. func (s *DockerSuite) TestEventsImageLoad(c *check.C) {
  173. testRequires(c, DaemonIsLinux)
  174. myImageName := "footest:v1"
  175. dockerCmd(c, "tag", "busybox", myImageName)
  176. since := daemonUnixTime(c)
  177. out, _ := dockerCmd(c, "images", "-q", "--no-trunc", myImageName)
  178. longImageID := strings.TrimSpace(out)
  179. c.Assert(longImageID, checker.Not(check.Equals), "", check.Commentf("Id should not be empty"))
  180. dockerCmd(c, "save", "-o", "saveimg.tar", myImageName)
  181. dockerCmd(c, "rmi", myImageName)
  182. out, _ = dockerCmd(c, "images", "-q", myImageName)
  183. noImageID := strings.TrimSpace(out)
  184. c.Assert(noImageID, checker.Equals, "", check.Commentf("Should not have any image"))
  185. dockerCmd(c, "load", "-i", "saveimg.tar")
  186. result := icmd.RunCommand("rm", "-rf", "saveimg.tar")
  187. result.Assert(c, icmd.Success)
  188. out, _ = dockerCmd(c, "images", "-q", "--no-trunc", myImageName)
  189. imageID := strings.TrimSpace(out)
  190. c.Assert(imageID, checker.Equals, longImageID, check.Commentf("Should have same image id as before"))
  191. out, _ = dockerCmd(c, "events", "--since", since, "--until", daemonUnixTime(c), "--filter", "event=load")
  192. events := strings.Split(strings.TrimSpace(out), "\n")
  193. c.Assert(events, checker.HasLen, 1)
  194. matches := eventstestutils.ScanMap(events[0])
  195. c.Assert(matches["id"], checker.Equals, imageID, check.Commentf("matches: %v\nout:\n%s\n", matches, out))
  196. c.Assert(matches["action"], checker.Equals, "load", check.Commentf("matches: %v\nout:\n%s\n", matches, out))
  197. out, _ = dockerCmd(c, "events", "--since", since, "--until", daemonUnixTime(c), "--filter", "event=save")
  198. events = strings.Split(strings.TrimSpace(out), "\n")
  199. c.Assert(events, checker.HasLen, 1)
  200. matches = eventstestutils.ScanMap(events[0])
  201. c.Assert(matches["id"], checker.Equals, imageID, check.Commentf("matches: %v\nout:\n%s\n", matches, out))
  202. c.Assert(matches["action"], checker.Equals, "save", check.Commentf("matches: %v\nout:\n%s\n", matches, out))
  203. }
  204. func (s *DockerSuite) TestEventsPluginOps(c *check.C) {
  205. testRequires(c, DaemonIsLinux, IsAmd64, Network)
  206. since := daemonUnixTime(c)
  207. dockerCmd(c, "plugin", "install", pNameWithTag, "--grant-all-permissions")
  208. dockerCmd(c, "plugin", "disable", pNameWithTag)
  209. dockerCmd(c, "plugin", "remove", pNameWithTag)
  210. out, _ := dockerCmd(c, "events", "--since", since, "--until", daemonUnixTime(c))
  211. events := strings.Split(out, "\n")
  212. events = events[:len(events)-1]
  213. nEvents := len(events)
  214. c.Assert(nEvents, checker.GreaterOrEqualThan, 4)
  215. pluginEvents := eventActionsByIDAndType(c, events, pNameWithTag, "plugin")
  216. c.Assert(pluginEvents, checker.HasLen, 4, check.Commentf("events: %v", events))
  217. c.Assert(pluginEvents[0], checker.Equals, "pull", check.Commentf(out))
  218. c.Assert(pluginEvents[1], checker.Equals, "enable", check.Commentf(out))
  219. c.Assert(pluginEvents[2], checker.Equals, "disable", check.Commentf(out))
  220. c.Assert(pluginEvents[3], checker.Equals, "remove", check.Commentf(out))
  221. }
  222. func (s *DockerSuite) TestEventsFilters(c *check.C) {
  223. since := daemonUnixTime(c)
  224. dockerCmd(c, "run", "--rm", "busybox", "true")
  225. dockerCmd(c, "run", "--rm", "busybox", "true")
  226. out, _ := dockerCmd(c, "events", "--since", since, "--until", daemonUnixTime(c), "--filter", "event=die")
  227. parseEvents(c, out, "die")
  228. out, _ = dockerCmd(c, "events", "--since", since, "--until", daemonUnixTime(c), "--filter", "event=die", "--filter", "event=start")
  229. parseEvents(c, out, "die|start")
  230. // make sure we at least got 2 start events
  231. count := strings.Count(out, "start")
  232. c.Assert(strings.Count(out, "start"), checker.GreaterOrEqualThan, 2, check.Commentf("should have had 2 start events but had %d, out: %s", count, out))
  233. }
  234. func (s *DockerSuite) TestEventsFilterImageName(c *check.C) {
  235. since := daemonUnixTime(c)
  236. out, _ := dockerCmd(c, "run", "--name", "container_1", "-d", "busybox:latest", "true")
  237. container1 := strings.TrimSpace(out)
  238. out, _ = dockerCmd(c, "run", "--name", "container_2", "-d", "busybox", "true")
  239. container2 := strings.TrimSpace(out)
  240. name := "busybox"
  241. out, _ = dockerCmd(c, "events", "--since", since, "--until", daemonUnixTime(c), "--filter", fmt.Sprintf("image=%s", name))
  242. events := strings.Split(out, "\n")
  243. events = events[:len(events)-1]
  244. c.Assert(events, checker.Not(checker.HasLen), 0) //Expected events but found none for the image busybox:latest
  245. count1 := 0
  246. count2 := 0
  247. for _, e := range events {
  248. if strings.Contains(e, container1) {
  249. count1++
  250. } else if strings.Contains(e, container2) {
  251. count2++
  252. }
  253. }
  254. c.Assert(count1, checker.Not(checker.Equals), 0, check.Commentf("Expected event from container but got %d from %s", count1, container1))
  255. c.Assert(count2, checker.Not(checker.Equals), 0, check.Commentf("Expected event from container but got %d from %s", count2, container2))
  256. }
  257. func (s *DockerSuite) TestEventsFilterLabels(c *check.C) {
  258. since := daemonUnixTime(c)
  259. label := "io.docker.testing=foo"
  260. out, _ := dockerCmd(c, "run", "-d", "-l", label, "busybox:latest", "true")
  261. container1 := strings.TrimSpace(out)
  262. out, _ = dockerCmd(c, "run", "-d", "busybox", "true")
  263. container2 := strings.TrimSpace(out)
  264. out, _ = dockerCmd(
  265. c,
  266. "events",
  267. "--since", since,
  268. "--until", daemonUnixTime(c),
  269. "--filter", fmt.Sprintf("label=%s", label))
  270. events := strings.Split(strings.TrimSpace(out), "\n")
  271. c.Assert(len(events), checker.Equals, 3)
  272. for _, e := range events {
  273. c.Assert(e, checker.Contains, container1)
  274. c.Assert(e, checker.Not(checker.Contains), container2)
  275. }
  276. }
  277. func (s *DockerSuite) TestEventsFilterImageLabels(c *check.C) {
  278. since := daemonUnixTime(c)
  279. name := "labelfiltertest"
  280. label := "io.docker.testing=image"
  281. // Build a test image.
  282. buildImageSuccessfully(c, name, build.WithDockerfile(fmt.Sprintf(`
  283. FROM busybox:latest
  284. LABEL %s`, label)))
  285. dockerCmd(c, "tag", name, "labelfiltertest:tag1")
  286. dockerCmd(c, "tag", name, "labelfiltertest:tag2")
  287. dockerCmd(c, "tag", "busybox:latest", "labelfiltertest:tag3")
  288. out, _ := dockerCmd(
  289. c,
  290. "events",
  291. "--since", since,
  292. "--until", daemonUnixTime(c),
  293. "--filter", fmt.Sprintf("label=%s", label),
  294. "--filter", "type=image")
  295. events := strings.Split(strings.TrimSpace(out), "\n")
  296. // 2 events from the "docker tag" command, another one is from "docker build"
  297. c.Assert(events, checker.HasLen, 3, check.Commentf("Events == %s", events))
  298. for _, e := range events {
  299. c.Assert(e, checker.Contains, "labelfiltertest")
  300. }
  301. }
  302. func (s *DockerSuite) TestEventsFilterContainer(c *check.C) {
  303. since := daemonUnixTime(c)
  304. nameID := make(map[string]string)
  305. for _, name := range []string{"container_1", "container_2"} {
  306. dockerCmd(c, "run", "--name", name, "busybox", "true")
  307. id := inspectField(c, name, "Id")
  308. nameID[name] = id
  309. }
  310. until := daemonUnixTime(c)
  311. checkEvents := func(id string, events []string) error {
  312. if len(events) != 4 { // create, attach, start, die
  313. return fmt.Errorf("expected 4 events, got %v", events)
  314. }
  315. for _, event := range events {
  316. matches := eventstestutils.ScanMap(event)
  317. if !matchEventID(matches, id) {
  318. return fmt.Errorf("expected event for container id %s: %s - parsed container id: %s", id, event, matches["id"])
  319. }
  320. }
  321. return nil
  322. }
  323. for name, ID := range nameID {
  324. // filter by names
  325. out, _ := dockerCmd(c, "events", "--since", since, "--until", until, "--filter", "container="+name)
  326. events := strings.Split(strings.TrimSuffix(out, "\n"), "\n")
  327. c.Assert(checkEvents(ID, events), checker.IsNil)
  328. // filter by ID's
  329. out, _ = dockerCmd(c, "events", "--since", since, "--until", until, "--filter", "container="+ID)
  330. events = strings.Split(strings.TrimSuffix(out, "\n"), "\n")
  331. c.Assert(checkEvents(ID, events), checker.IsNil)
  332. }
  333. }
  334. func (s *DockerSuite) TestEventsCommit(c *check.C) {
  335. // Problematic on Windows as cannot commit a running container
  336. testRequires(c, DaemonIsLinux)
  337. out := runSleepingContainer(c)
  338. cID := strings.TrimSpace(out)
  339. cli.WaitRun(c, cID)
  340. cli.DockerCmd(c, "commit", "-m", "test", cID)
  341. cli.DockerCmd(c, "stop", cID)
  342. cli.WaitExited(c, cID, 5*time.Second)
  343. until := daemonUnixTime(c)
  344. out = cli.DockerCmd(c, "events", "-f", "container="+cID, "--until="+until).Combined()
  345. c.Assert(out, checker.Contains, "commit", check.Commentf("Missing 'commit' log event"))
  346. }
  347. func (s *DockerSuite) TestEventsCopy(c *check.C) {
  348. // Build a test image.
  349. buildImageSuccessfully(c, "cpimg", build.WithDockerfile(`
  350. FROM busybox
  351. RUN echo HI > /file`))
  352. id := getIDByName(c, "cpimg")
  353. // Create an empty test file.
  354. tempFile, err := ioutil.TempFile("", "test-events-copy-")
  355. c.Assert(err, checker.IsNil)
  356. defer os.Remove(tempFile.Name())
  357. c.Assert(tempFile.Close(), checker.IsNil)
  358. dockerCmd(c, "create", "--name=cptest", id)
  359. dockerCmd(c, "cp", "cptest:/file", tempFile.Name())
  360. until := daemonUnixTime(c)
  361. out, _ := dockerCmd(c, "events", "--since=0", "-f", "container=cptest", "--until="+until)
  362. c.Assert(out, checker.Contains, "archive-path", check.Commentf("Missing 'archive-path' log event\n"))
  363. dockerCmd(c, "cp", tempFile.Name(), "cptest:/filecopy")
  364. until = daemonUnixTime(c)
  365. out, _ = dockerCmd(c, "events", "-f", "container=cptest", "--until="+until)
  366. c.Assert(out, checker.Contains, "extract-to-dir", check.Commentf("Missing 'extract-to-dir' log event"))
  367. }
  368. func (s *DockerSuite) TestEventsResize(c *check.C) {
  369. out := runSleepingContainer(c, "-d")
  370. cID := strings.TrimSpace(out)
  371. c.Assert(waitRun(cID), checker.IsNil)
  372. cli, err := client.NewEnvClient()
  373. c.Assert(err, checker.IsNil)
  374. defer cli.Close()
  375. options := types.ResizeOptions{
  376. Height: 80,
  377. Width: 24,
  378. }
  379. err = cli.ContainerResize(context.Background(), cID, options)
  380. c.Assert(err, checker.IsNil)
  381. dockerCmd(c, "stop", cID)
  382. until := daemonUnixTime(c)
  383. out, _ = dockerCmd(c, "events", "-f", "container="+cID, "--until="+until)
  384. c.Assert(out, checker.Contains, "resize", check.Commentf("Missing 'resize' log event"))
  385. }
  386. func (s *DockerSuite) TestEventsAttach(c *check.C) {
  387. // TODO Windows CI: Figure out why this test fails intermittently (TP5).
  388. testRequires(c, DaemonIsLinux)
  389. out := cli.DockerCmd(c, "run", "-di", "busybox", "cat").Combined()
  390. cID := strings.TrimSpace(out)
  391. cli.WaitRun(c, cID)
  392. cmd := exec.Command(dockerBinary, "attach", cID)
  393. stdin, err := cmd.StdinPipe()
  394. c.Assert(err, checker.IsNil)
  395. defer stdin.Close()
  396. stdout, err := cmd.StdoutPipe()
  397. c.Assert(err, checker.IsNil)
  398. defer stdout.Close()
  399. c.Assert(cmd.Start(), checker.IsNil)
  400. defer func() {
  401. cmd.Process.Kill()
  402. cmd.Wait()
  403. }()
  404. // Make sure we're done attaching by writing/reading some stuff
  405. _, err = stdin.Write([]byte("hello\n"))
  406. c.Assert(err, checker.IsNil)
  407. out, err = bufio.NewReader(stdout).ReadString('\n')
  408. c.Assert(err, checker.IsNil)
  409. c.Assert(strings.TrimSpace(out), checker.Equals, "hello", check.Commentf("expected 'hello'"))
  410. c.Assert(stdin.Close(), checker.IsNil)
  411. cli.DockerCmd(c, "kill", cID)
  412. cli.WaitExited(c, cID, 5*time.Second)
  413. until := daemonUnixTime(c)
  414. out = cli.DockerCmd(c, "events", "-f", "container="+cID, "--until="+until).Combined()
  415. c.Assert(out, checker.Contains, "attach", check.Commentf("Missing 'attach' log event"))
  416. }
  417. func (s *DockerSuite) TestEventsRename(c *check.C) {
  418. out, _ := dockerCmd(c, "run", "--name", "oldName", "busybox", "true")
  419. cID := strings.TrimSpace(out)
  420. dockerCmd(c, "rename", "oldName", "newName")
  421. until := daemonUnixTime(c)
  422. // filter by the container id because the name in the event will be the new name.
  423. out, _ = dockerCmd(c, "events", "-f", "container="+cID, "--until", until)
  424. c.Assert(out, checker.Contains, "rename", check.Commentf("Missing 'rename' log event\n"))
  425. }
  426. func (s *DockerSuite) TestEventsTop(c *check.C) {
  427. // Problematic on Windows as Windows does not support top
  428. testRequires(c, DaemonIsLinux)
  429. out := runSleepingContainer(c, "-d")
  430. cID := strings.TrimSpace(out)
  431. c.Assert(waitRun(cID), checker.IsNil)
  432. dockerCmd(c, "top", cID)
  433. dockerCmd(c, "stop", cID)
  434. until := daemonUnixTime(c)
  435. out, _ = dockerCmd(c, "events", "-f", "container="+cID, "--until="+until)
  436. c.Assert(out, checker.Contains, " top", check.Commentf("Missing 'top' log event"))
  437. }
  438. // #14316
  439. func (s *DockerRegistrySuite) TestEventsImageFilterPush(c *check.C) {
  440. // Problematic to port for Windows CI during TP5 timeframe until
  441. // supporting push
  442. testRequires(c, DaemonIsLinux)
  443. testRequires(c, Network)
  444. repoName := fmt.Sprintf("%v/dockercli/testf", privateRegistryURL)
  445. out, _ := dockerCmd(c, "run", "-d", "busybox", "top")
  446. cID := strings.TrimSpace(out)
  447. c.Assert(waitRun(cID), checker.IsNil)
  448. dockerCmd(c, "commit", cID, repoName)
  449. dockerCmd(c, "stop", cID)
  450. dockerCmd(c, "push", repoName)
  451. until := daemonUnixTime(c)
  452. out, _ = dockerCmd(c, "events", "-f", "image="+repoName, "-f", "event=push", "--until", until)
  453. c.Assert(out, checker.Contains, repoName, check.Commentf("Missing 'push' log event for %s", repoName))
  454. }
  455. func (s *DockerSuite) TestEventsFilterType(c *check.C) {
  456. since := daemonUnixTime(c)
  457. name := "labelfiltertest"
  458. label := "io.docker.testing=image"
  459. // Build a test image.
  460. buildImageSuccessfully(c, name, build.WithDockerfile(fmt.Sprintf(`
  461. FROM busybox:latest
  462. LABEL %s`, label)))
  463. dockerCmd(c, "tag", name, "labelfiltertest:tag1")
  464. dockerCmd(c, "tag", name, "labelfiltertest:tag2")
  465. dockerCmd(c, "tag", "busybox:latest", "labelfiltertest:tag3")
  466. out, _ := dockerCmd(
  467. c,
  468. "events",
  469. "--since", since,
  470. "--until", daemonUnixTime(c),
  471. "--filter", fmt.Sprintf("label=%s", label),
  472. "--filter", "type=image")
  473. events := strings.Split(strings.TrimSpace(out), "\n")
  474. // 2 events from the "docker tag" command, another one is from "docker build"
  475. c.Assert(events, checker.HasLen, 3, check.Commentf("Events == %s", events))
  476. for _, e := range events {
  477. c.Assert(e, checker.Contains, "labelfiltertest")
  478. }
  479. out, _ = dockerCmd(
  480. c,
  481. "events",
  482. "--since", since,
  483. "--until", daemonUnixTime(c),
  484. "--filter", fmt.Sprintf("label=%s", label),
  485. "--filter", "type=container")
  486. events = strings.Split(strings.TrimSpace(out), "\n")
  487. // Events generated by the container that builds the image
  488. c.Assert(events, checker.HasLen, 3, check.Commentf("Events == %s", events))
  489. out, _ = dockerCmd(
  490. c,
  491. "events",
  492. "--since", since,
  493. "--until", daemonUnixTime(c),
  494. "--filter", "type=network")
  495. events = strings.Split(strings.TrimSpace(out), "\n")
  496. c.Assert(len(events), checker.GreaterOrEqualThan, 1, check.Commentf("Events == %s", events))
  497. }
  498. // #25798
  499. func (s *DockerSuite) TestEventsSpecialFiltersWithExecCreate(c *check.C) {
  500. since := daemonUnixTime(c)
  501. runSleepingContainer(c, "--name", "test-container", "-d")
  502. waitRun("test-container")
  503. dockerCmd(c, "exec", "test-container", "echo", "hello-world")
  504. out, _ := dockerCmd(
  505. c,
  506. "events",
  507. "--since", since,
  508. "--until", daemonUnixTime(c),
  509. "--filter",
  510. "event='exec_create: echo hello-world'",
  511. )
  512. events := strings.Split(strings.TrimSpace(out), "\n")
  513. c.Assert(len(events), checker.Equals, 1, check.Commentf(out))
  514. out, _ = dockerCmd(
  515. c,
  516. "events",
  517. "--since", since,
  518. "--until", daemonUnixTime(c),
  519. "--filter",
  520. "event=exec_create",
  521. )
  522. c.Assert(len(events), checker.Equals, 1, check.Commentf(out))
  523. }
  524. func (s *DockerSuite) TestEventsFilterImageInContainerAction(c *check.C) {
  525. since := daemonUnixTime(c)
  526. dockerCmd(c, "run", "--name", "test-container", "-d", "busybox", "true")
  527. waitRun("test-container")
  528. out, _ := dockerCmd(c, "events", "--filter", "image=busybox", "--since", since, "--until", daemonUnixTime(c))
  529. events := strings.Split(strings.TrimSpace(out), "\n")
  530. c.Assert(len(events), checker.GreaterThan, 1, check.Commentf(out))
  531. }
  532. func (s *DockerSuite) TestEventsContainerRestart(c *check.C) {
  533. dockerCmd(c, "run", "-d", "--name=testEvent", "--restart=on-failure:3", "busybox", "false")
  534. // wait until test2 is auto removed.
  535. waitTime := 10 * time.Second
  536. if testEnv.OSType == "windows" {
  537. // Windows takes longer...
  538. waitTime = 90 * time.Second
  539. }
  540. err := waitInspect("testEvent", "{{ .State.Restarting }} {{ .State.Running }}", "false false", waitTime)
  541. c.Assert(err, checker.IsNil)
  542. var (
  543. createCount int
  544. startCount int
  545. dieCount int
  546. )
  547. out, _ := dockerCmd(c, "events", "--since=0", "--until", daemonUnixTime(c), "-f", "container=testEvent")
  548. events := strings.Split(strings.TrimSpace(out), "\n")
  549. nEvents := len(events)
  550. c.Assert(nEvents, checker.GreaterOrEqualThan, 1) //Missing expected event
  551. actions := eventActionsByIDAndType(c, events, "testEvent", "container")
  552. for _, a := range actions {
  553. switch a {
  554. case "create":
  555. createCount++
  556. case "start":
  557. startCount++
  558. case "die":
  559. dieCount++
  560. }
  561. }
  562. c.Assert(createCount, checker.Equals, 1, check.Commentf("testEvent should be created 1 times: %v", actions))
  563. c.Assert(startCount, checker.Equals, 4, check.Commentf("testEvent should start 4 times: %v", actions))
  564. c.Assert(dieCount, checker.Equals, 4, check.Commentf("testEvent should die 4 times: %v", actions))
  565. }
  566. func (s *DockerSuite) TestEventsSinceInTheFuture(c *check.C) {
  567. dockerCmd(c, "run", "--name", "test-container", "-d", "busybox", "true")
  568. waitRun("test-container")
  569. since := daemonTime(c)
  570. until := since.Add(time.Duration(-24) * time.Hour)
  571. out, _, err := dockerCmdWithError("events", "--filter", "image=busybox", "--since", parseEventTime(since), "--until", parseEventTime(until))
  572. c.Assert(err, checker.NotNil)
  573. c.Assert(out, checker.Contains, "cannot be after `until`")
  574. }
  575. func (s *DockerSuite) TestEventsUntilInThePast(c *check.C) {
  576. since := daemonUnixTime(c)
  577. dockerCmd(c, "run", "--name", "test-container", "-d", "busybox", "true")
  578. waitRun("test-container")
  579. until := daemonUnixTime(c)
  580. dockerCmd(c, "run", "--name", "test-container2", "-d", "busybox", "true")
  581. waitRun("test-container2")
  582. out, _ := dockerCmd(c, "events", "--filter", "image=busybox", "--since", since, "--until", until)
  583. c.Assert(out, checker.Not(checker.Contains), "test-container2")
  584. c.Assert(out, checker.Contains, "test-container")
  585. }
  586. func (s *DockerSuite) TestEventsFormat(c *check.C) {
  587. since := daemonUnixTime(c)
  588. dockerCmd(c, "run", "--rm", "busybox", "true")
  589. dockerCmd(c, "run", "--rm", "busybox", "true")
  590. out, _ := dockerCmd(c, "events", "--since", since, "--until", daemonUnixTime(c), "--format", "{{json .}}")
  591. dec := json.NewDecoder(strings.NewReader(out))
  592. // make sure we got 2 start events
  593. startCount := 0
  594. for {
  595. var err error
  596. var ev eventtypes.Message
  597. if err = dec.Decode(&ev); err == io.EOF {
  598. break
  599. }
  600. c.Assert(err, checker.IsNil)
  601. if ev.Status == "start" {
  602. startCount++
  603. }
  604. }
  605. c.Assert(startCount, checker.Equals, 2, check.Commentf("should have had 2 start events but had %d, out: %s", startCount, out))
  606. }
  607. func (s *DockerSuite) TestEventsFormatBadFunc(c *check.C) {
  608. // make sure it fails immediately, without receiving any event
  609. result := dockerCmdWithResult("events", "--format", "{{badFuncString .}}")
  610. result.Assert(c, icmd.Expected{
  611. Error: "exit status 64",
  612. ExitCode: 64,
  613. Err: "Error parsing format: template: :1: function \"badFuncString\" not defined",
  614. })
  615. }
  616. func (s *DockerSuite) TestEventsFormatBadField(c *check.C) {
  617. // make sure it fails immediately, without receiving any event
  618. result := dockerCmdWithResult("events", "--format", "{{.badFieldString}}")
  619. result.Assert(c, icmd.Expected{
  620. Error: "exit status 64",
  621. ExitCode: 64,
  622. Err: "Error parsing format: template: :1:2: executing \"\" at <.badFieldString>: can't evaluate field badFieldString in type *events.Message",
  623. })
  624. }