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