event_test.go 5.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188
  1. package system // import "github.com/docker/docker/integration/system"
  2. import (
  3. "context"
  4. "encoding/json"
  5. "errors"
  6. "io"
  7. "net/http"
  8. "net/url"
  9. "strconv"
  10. "testing"
  11. "time"
  12. "github.com/docker/docker/api/types"
  13. "github.com/docker/docker/api/types/events"
  14. "github.com/docker/docker/api/types/filters"
  15. "github.com/docker/docker/api/types/mount"
  16. "github.com/docker/docker/api/types/strslice"
  17. "github.com/docker/docker/api/types/volume"
  18. "github.com/docker/docker/integration/internal/container"
  19. "github.com/docker/docker/pkg/jsonmessage"
  20. "github.com/docker/docker/testutil/request"
  21. req "github.com/docker/docker/testutil/request"
  22. "gotest.tools/v3/assert"
  23. is "gotest.tools/v3/assert/cmp"
  24. "gotest.tools/v3/skip"
  25. )
  26. func TestEventsExecDie(t *testing.T) {
  27. skip.If(t, testEnv.DaemonInfo.OSType == "windows", "FIXME. Suspect may need to wait until container is running before exec")
  28. ctx := setupTest(t)
  29. client := testEnv.APIClient()
  30. cID := container.Run(ctx, t, client)
  31. id, err := client.ContainerExecCreate(ctx, cID,
  32. types.ExecConfig{
  33. Cmd: strslice.StrSlice([]string{"echo", "hello"}),
  34. },
  35. )
  36. assert.NilError(t, err)
  37. msg, errs := client.Events(ctx, types.EventsOptions{
  38. Filters: filters.NewArgs(
  39. filters.Arg("container", cID),
  40. filters.Arg("event", string(events.ActionExecDie)),
  41. ),
  42. })
  43. err = client.ContainerExecStart(ctx, id.ID,
  44. types.ExecStartCheck{
  45. Detach: true,
  46. Tty: false,
  47. },
  48. )
  49. assert.NilError(t, err)
  50. select {
  51. case m := <-msg:
  52. assert.Equal(t, m.Type, events.ContainerEventType)
  53. assert.Equal(t, m.Actor.ID, cID)
  54. assert.Equal(t, m.Action, events.ActionExecDie)
  55. assert.Equal(t, m.Actor.Attributes["execID"], id.ID)
  56. assert.Equal(t, m.Actor.Attributes["exitCode"], "0")
  57. case err = <-errs:
  58. assert.NilError(t, err)
  59. case <-time.After(time.Second * 3):
  60. t.Fatal("timeout hit")
  61. }
  62. }
  63. // Test case for #18888: Events messages have been switched from generic
  64. // `JSONMessage` to `events.Message` types. The switch does not break the
  65. // backward compatibility so old `JSONMessage` could still be used.
  66. // This test verifies that backward compatibility maintains.
  67. func TestEventsBackwardsCompatible(t *testing.T) {
  68. skip.If(t, testEnv.DaemonInfo.OSType == "windows", "Windows doesn't support back-compat messages")
  69. ctx := setupTest(t)
  70. client := testEnv.APIClient()
  71. since := request.DaemonTime(ctx, t, client, testEnv)
  72. ts := strconv.FormatInt(since.Unix(), 10)
  73. cID := container.Create(ctx, t, client)
  74. // In case there is no events, the API should have responded immediately (not blocking),
  75. // The test here makes sure the response time is less than 3 sec.
  76. expectedTime := time.Now().Add(3 * time.Second)
  77. emptyResp, emptyBody, err := req.Get(ctx, "/events")
  78. assert.NilError(t, err)
  79. defer emptyBody.Close()
  80. assert.Check(t, is.DeepEqual(http.StatusOK, emptyResp.StatusCode))
  81. assert.Check(t, time.Now().Before(expectedTime), "timeout waiting for events api to respond, should have responded immediately")
  82. // We also test to make sure the `events.Message` is compatible with `JSONMessage`
  83. q := url.Values{}
  84. q.Set("since", ts)
  85. _, body, err := req.Get(ctx, "/events?"+q.Encode())
  86. assert.NilError(t, err)
  87. defer body.Close()
  88. dec := json.NewDecoder(body)
  89. var containerCreateEvent *jsonmessage.JSONMessage
  90. for {
  91. var event jsonmessage.JSONMessage
  92. if err := dec.Decode(&event); err != nil {
  93. if err == io.EOF {
  94. break
  95. }
  96. assert.NilError(t, err)
  97. }
  98. if event.Status == "create" && event.ID == cID {
  99. containerCreateEvent = &event
  100. break
  101. }
  102. }
  103. assert.Check(t, containerCreateEvent != nil)
  104. assert.Check(t, is.Equal("create", containerCreateEvent.Status))
  105. assert.Check(t, is.Equal(cID, containerCreateEvent.ID))
  106. assert.Check(t, is.Equal("busybox", containerCreateEvent.From))
  107. }
  108. // TestEventsVolumeCreate verifies that volume create events are only fired
  109. // once: when creating the volume, and not when attaching to a container.
  110. func TestEventsVolumeCreate(t *testing.T) {
  111. skip.If(t, testEnv.DaemonInfo.OSType == "windows", "FIXME: Windows doesn't trigger the events? Could be a race")
  112. ctx := setupTest(t)
  113. ctx, cancel := context.WithCancel(ctx)
  114. defer cancel()
  115. client := testEnv.APIClient()
  116. since := request.DaemonUnixTime(ctx, t, client, testEnv)
  117. volName := t.Name()
  118. getEvents := func(messages <-chan events.Message, errs <-chan error) ([]events.Message, error) {
  119. var evts []events.Message
  120. for {
  121. select {
  122. case m := <-messages:
  123. evts = append(evts, m)
  124. case err := <-errs:
  125. if err == io.EOF {
  126. return evts, nil
  127. }
  128. return nil, err
  129. case <-time.After(time.Second * 3):
  130. return nil, errors.New("timeout hit")
  131. }
  132. }
  133. }
  134. _, err := client.VolumeCreate(ctx, volume.CreateOptions{Name: volName})
  135. assert.NilError(t, err)
  136. filter := filters.NewArgs(
  137. filters.Arg("type", "volume"),
  138. filters.Arg("event", "create"),
  139. filters.Arg("volume", volName),
  140. )
  141. messages, errs := client.Events(ctx, types.EventsOptions{
  142. Since: since,
  143. Until: request.DaemonUnixTime(ctx, t, client, testEnv),
  144. Filters: filter,
  145. })
  146. volEvents, err := getEvents(messages, errs)
  147. assert.NilError(t, err)
  148. assert.Equal(t, len(volEvents), 1, "expected volume create event when creating a volume")
  149. container.Create(ctx, t, client, container.WithMount(mount.Mount{
  150. Type: mount.TypeVolume,
  151. Source: volName,
  152. Target: "/tmp/foo",
  153. }))
  154. messages, errs = client.Events(ctx, types.EventsOptions{
  155. Since: since,
  156. Until: request.DaemonUnixTime(ctx, t, client, testEnv),
  157. Filters: filter,
  158. })
  159. volEvents, err = getEvents(messages, errs)
  160. assert.NilError(t, err)
  161. assert.Equal(t, len(volEvents), 1, "expected volume create event to be fired only once")
  162. }