docker_api_attach_test.go 8.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252
  1. package main
  2. import (
  3. "bufio"
  4. "bytes"
  5. "context"
  6. "fmt"
  7. "io"
  8. "net"
  9. "net/http"
  10. "net/http/httputil"
  11. "strings"
  12. "time"
  13. "github.com/docker/docker/api/types"
  14. "github.com/docker/docker/client"
  15. "github.com/docker/docker/integration-cli/checker"
  16. "github.com/docker/docker/integration-cli/request"
  17. "github.com/docker/docker/pkg/stdcopy"
  18. "github.com/go-check/check"
  19. "golang.org/x/net/websocket"
  20. )
  21. func (s *DockerSuite) TestGetContainersAttachWebsocket(c *check.C) {
  22. testRequires(c, DaemonIsLinux)
  23. out, _ := dockerCmd(c, "run", "-dit", "busybox", "cat")
  24. rwc, err := request.SockConn(time.Duration(10*time.Second), daemonHost())
  25. c.Assert(err, checker.IsNil)
  26. cleanedContainerID := strings.TrimSpace(out)
  27. config, err := websocket.NewConfig(
  28. "/containers/"+cleanedContainerID+"/attach/ws?stream=1&stdin=1&stdout=1&stderr=1",
  29. "http://localhost",
  30. )
  31. c.Assert(err, checker.IsNil)
  32. ws, err := websocket.NewClient(config, rwc)
  33. c.Assert(err, checker.IsNil)
  34. defer ws.Close()
  35. expected := []byte("hello")
  36. actual := make([]byte, len(expected))
  37. outChan := make(chan error)
  38. go func() {
  39. _, err := io.ReadFull(ws, actual)
  40. outChan <- err
  41. close(outChan)
  42. }()
  43. inChan := make(chan error)
  44. go func() {
  45. _, err := ws.Write(expected)
  46. inChan <- err
  47. close(inChan)
  48. }()
  49. select {
  50. case err := <-inChan:
  51. c.Assert(err, checker.IsNil)
  52. case <-time.After(5 * time.Second):
  53. c.Fatal("Timeout writing to ws")
  54. }
  55. select {
  56. case err := <-outChan:
  57. c.Assert(err, checker.IsNil)
  58. case <-time.After(5 * time.Second):
  59. c.Fatal("Timeout reading from ws")
  60. }
  61. c.Assert(actual, checker.DeepEquals, expected, check.Commentf("Websocket didn't return the expected data"))
  62. }
  63. // regression gh14320
  64. func (s *DockerSuite) TestPostContainersAttachContainerNotFound(c *check.C) {
  65. resp, _, err := request.Post("/containers/doesnotexist/attach")
  66. c.Assert(err, checker.IsNil)
  67. // connection will shutdown, err should be "persistent connection closed"
  68. c.Assert(resp.StatusCode, checker.Equals, http.StatusNotFound)
  69. content, err := request.ReadBody(resp.Body)
  70. c.Assert(err, checker.IsNil)
  71. expected := "No such container: doesnotexist\r\n"
  72. c.Assert(string(content), checker.Equals, expected)
  73. }
  74. func (s *DockerSuite) TestGetContainersWsAttachContainerNotFound(c *check.C) {
  75. res, body, err := request.Get("/containers/doesnotexist/attach/ws")
  76. c.Assert(res.StatusCode, checker.Equals, http.StatusNotFound)
  77. c.Assert(err, checker.IsNil)
  78. b, err := request.ReadBody(body)
  79. c.Assert(err, checker.IsNil)
  80. expected := "No such container: doesnotexist"
  81. c.Assert(getErrorMessage(c, b), checker.Contains, expected)
  82. }
  83. func (s *DockerSuite) TestPostContainersAttach(c *check.C) {
  84. testRequires(c, DaemonIsLinux)
  85. expectSuccess := func(conn net.Conn, br *bufio.Reader, stream string, tty bool) {
  86. defer conn.Close()
  87. expected := []byte("success")
  88. _, err := conn.Write(expected)
  89. c.Assert(err, checker.IsNil)
  90. conn.SetReadDeadline(time.Now().Add(time.Second))
  91. lenHeader := 0
  92. if !tty {
  93. lenHeader = 8
  94. }
  95. actual := make([]byte, len(expected)+lenHeader)
  96. _, err = io.ReadFull(br, actual)
  97. c.Assert(err, checker.IsNil)
  98. if !tty {
  99. fdMap := map[string]byte{
  100. "stdin": 0,
  101. "stdout": 1,
  102. "stderr": 2,
  103. }
  104. c.Assert(actual[0], checker.Equals, fdMap[stream])
  105. }
  106. c.Assert(actual[lenHeader:], checker.DeepEquals, expected, check.Commentf("Attach didn't return the expected data from %s", stream))
  107. }
  108. expectTimeout := func(conn net.Conn, br *bufio.Reader, stream string) {
  109. defer conn.Close()
  110. _, err := conn.Write([]byte{'t'})
  111. c.Assert(err, checker.IsNil)
  112. conn.SetReadDeadline(time.Now().Add(time.Second))
  113. actual := make([]byte, 1)
  114. _, err = io.ReadFull(br, actual)
  115. opErr, ok := err.(*net.OpError)
  116. c.Assert(ok, checker.Equals, true, check.Commentf("Error is expected to be *net.OpError, got %v", err))
  117. c.Assert(opErr.Timeout(), checker.Equals, true, check.Commentf("Read from %s is expected to timeout", stream))
  118. }
  119. // Create a container that only emits stdout.
  120. cid, _ := dockerCmd(c, "run", "-di", "busybox", "cat")
  121. cid = strings.TrimSpace(cid)
  122. // Attach to the container's stdout stream.
  123. conn, br, err := sockRequestHijack("POST", "/containers/"+cid+"/attach?stream=1&stdin=1&stdout=1", nil, "text/plain", daemonHost())
  124. c.Assert(err, checker.IsNil)
  125. // Check if the data from stdout can be received.
  126. expectSuccess(conn, br, "stdout", false)
  127. // Attach to the container's stderr stream.
  128. conn, br, err = sockRequestHijack("POST", "/containers/"+cid+"/attach?stream=1&stdin=1&stderr=1", nil, "text/plain", daemonHost())
  129. c.Assert(err, checker.IsNil)
  130. // Since the container only emits stdout, attaching to stderr should return nothing.
  131. expectTimeout(conn, br, "stdout")
  132. // Test the similar functions of the stderr stream.
  133. cid, _ = dockerCmd(c, "run", "-di", "busybox", "/bin/sh", "-c", "cat >&2")
  134. cid = strings.TrimSpace(cid)
  135. conn, br, err = sockRequestHijack("POST", "/containers/"+cid+"/attach?stream=1&stdin=1&stderr=1", nil, "text/plain", daemonHost())
  136. c.Assert(err, checker.IsNil)
  137. expectSuccess(conn, br, "stderr", false)
  138. conn, br, err = sockRequestHijack("POST", "/containers/"+cid+"/attach?stream=1&stdin=1&stdout=1", nil, "text/plain", daemonHost())
  139. c.Assert(err, checker.IsNil)
  140. expectTimeout(conn, br, "stderr")
  141. // Test with tty.
  142. cid, _ = dockerCmd(c, "run", "-dit", "busybox", "/bin/sh", "-c", "cat >&2")
  143. cid = strings.TrimSpace(cid)
  144. // Attach to stdout only.
  145. conn, br, err = sockRequestHijack("POST", "/containers/"+cid+"/attach?stream=1&stdin=1&stdout=1", nil, "text/plain", daemonHost())
  146. c.Assert(err, checker.IsNil)
  147. expectSuccess(conn, br, "stdout", true)
  148. // Attach without stdout stream.
  149. conn, br, err = sockRequestHijack("POST", "/containers/"+cid+"/attach?stream=1&stdin=1&stderr=1", nil, "text/plain", daemonHost())
  150. c.Assert(err, checker.IsNil)
  151. // Nothing should be received because both the stdout and stderr of the container will be
  152. // sent to the client as stdout when tty is enabled.
  153. expectTimeout(conn, br, "stdout")
  154. // Test the client API
  155. // Make sure we don't see "hello" if Logs is false
  156. client, err := client.NewEnvClient()
  157. c.Assert(err, checker.IsNil)
  158. defer client.Close()
  159. cid, _ = dockerCmd(c, "run", "-di", "busybox", "/bin/sh", "-c", "echo hello; cat")
  160. cid = strings.TrimSpace(cid)
  161. attachOpts := types.ContainerAttachOptions{
  162. Stream: true,
  163. Stdin: true,
  164. Stdout: true,
  165. }
  166. resp, err := client.ContainerAttach(context.Background(), cid, attachOpts)
  167. c.Assert(err, checker.IsNil)
  168. expectSuccess(resp.Conn, resp.Reader, "stdout", false)
  169. // Make sure we do see "hello" if Logs is true
  170. attachOpts.Logs = true
  171. resp, err = client.ContainerAttach(context.Background(), cid, attachOpts)
  172. c.Assert(err, checker.IsNil)
  173. defer resp.Conn.Close()
  174. resp.Conn.SetReadDeadline(time.Now().Add(time.Second))
  175. _, err = resp.Conn.Write([]byte("success"))
  176. c.Assert(err, checker.IsNil)
  177. actualStdout := new(bytes.Buffer)
  178. actualStderr := new(bytes.Buffer)
  179. stdcopy.StdCopy(actualStdout, actualStderr, resp.Reader)
  180. c.Assert(actualStdout.Bytes(), checker.DeepEquals, []byte("hello\nsuccess"), check.Commentf("Attach didn't return the expected data from stdout"))
  181. }
  182. // SockRequestHijack creates a connection to specified host (with method, contenttype, …) and returns a hijacked connection
  183. // and the output as a `bufio.Reader`
  184. func sockRequestHijack(method, endpoint string, data io.Reader, ct string, daemon string, modifiers ...func(*http.Request)) (net.Conn, *bufio.Reader, error) {
  185. req, client, err := newRequestClient(method, endpoint, data, ct, daemon, modifiers...)
  186. if err != nil {
  187. return nil, nil, err
  188. }
  189. client.Do(req)
  190. conn, br := client.Hijack()
  191. return conn, br, nil
  192. }
  193. // FIXME(vdemeester) httputil.ClientConn is deprecated, use http.Client instead (closer to actual client)
  194. // Deprecated: Use New instead of NewRequestClient
  195. // Deprecated: use request.Do (or Get, Delete, Post) instead
  196. func newRequestClient(method, endpoint string, data io.Reader, ct, daemon string, modifiers ...func(*http.Request)) (*http.Request, *httputil.ClientConn, error) {
  197. c, err := request.SockConn(time.Duration(10*time.Second), daemon)
  198. if err != nil {
  199. return nil, nil, fmt.Errorf("could not dial docker daemon: %v", err)
  200. }
  201. client := httputil.NewClientConn(c, nil)
  202. req, err := http.NewRequest(method, endpoint, data)
  203. if err != nil {
  204. client.Close()
  205. return nil, nil, fmt.Errorf("could not create new request: %v", err)
  206. }
  207. for _, opt := range modifiers {
  208. opt(req)
  209. }
  210. if ct != "" {
  211. req.Header.Set("Content-Type", ct)
  212. }
  213. return req, client, nil
  214. }