mirror of
https://github.com/moby/moby.git
synced 2022-11-09 12:21:53 -05:00
Merge pull request #16920 from mountkin/fix-attach-test
fix the flaws in the test of the attach API
This commit is contained in:
Alexander Morozov
commit
4302c14a64
1 changed files with 85 additions and 147 deletions
|
|
@ -1,13 +1,14 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"bufio"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
"net/http/httputil"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/docker/docker/pkg/integration/checker"
|
||||
"github.com/go-check/check"
|
||||
"golang.org/x/net/websocket"
|
||||
)
|
||||
|
|
@ -17,23 +18,17 @@ func (s *DockerSuite) TestGetContainersAttachWebsocket(c *check.C) {
|
|||
out, _ := dockerCmd(c, "run", "-dit", "busybox", "cat")
|
||||
|
||||
rwc, err := sockConn(time.Duration(10 * time.Second))
|
||||
if err != nil {
|
||||
c.Fatal(err)
|
||||
}
|
||||
c.Assert(err, checker.IsNil)
|
||||
|
||||
cleanedContainerID := strings.TrimSpace(out)
|
||||
config, err := websocket.NewConfig(
|
||||
"/containers/"+cleanedContainerID+"/attach/ws?stream=1&stdin=1&stdout=1&stderr=1",
|
||||
"http://localhost",
|
||||
)
|
||||
if err != nil {
|
||||
c.Fatal(err)
|
||||
}
|
||||
c.Assert(err, checker.IsNil)
|
||||
|
||||
ws, err := websocket.NewClient(config, rwc)
|
||||
if err != nil {
|
||||
c.Fatal(err)
|
||||
}
|
||||
c.Assert(err, checker.IsNil)
|
||||
defer ws.Close()
|
||||
|
||||
expected := []byte("hello")
|
||||
|
|
@ -55,172 +50,115 @@ func (s *DockerSuite) TestGetContainersAttachWebsocket(c *check.C) {
|
|||
|
||||
select {
|
||||
case err := <-inChan:
|
||||
if err != nil {
|
||||
c.Fatal(err)
|
||||
}
|
||||
c.Assert(err, checker.IsNil)
|
||||
case <-time.After(5 * time.Second):
|
||||
c.Fatal("Timeout writing to ws")
|
||||
}
|
||||
|
||||
select {
|
||||
case err := <-outChan:
|
||||
if err != nil {
|
||||
c.Fatal(err)
|
||||
}
|
||||
c.Assert(err, checker.IsNil)
|
||||
case <-time.After(5 * time.Second):
|
||||
c.Fatal("Timeout reading from ws")
|
||||
}
|
||||
|
||||
if !bytes.Equal(expected, actual) {
|
||||
c.Fatal("Expected output on websocket to match input")
|
||||
}
|
||||
c.Assert(actual, checker.DeepEquals, expected, check.Commentf("Websocket didn't return the expected data"))
|
||||
}
|
||||
|
||||
// regression gh14320
|
||||
func (s *DockerSuite) TestPostContainersAttachContainerNotFound(c *check.C) {
|
||||
status, body, err := sockRequest("POST", "/containers/doesnotexist/attach", nil)
|
||||
c.Assert(status, check.Equals, http.StatusNotFound)
|
||||
c.Assert(err, check.IsNil)
|
||||
c.Assert(status, checker.Equals, http.StatusNotFound)
|
||||
c.Assert(err, checker.IsNil)
|
||||
expected := "no such id: doesnotexist\n"
|
||||
if !strings.Contains(string(body), expected) {
|
||||
c.Fatalf("Expected response body to contain %q", expected)
|
||||
}
|
||||
c.Assert(string(body), checker.Contains, expected)
|
||||
}
|
||||
|
||||
func (s *DockerSuite) TestGetContainersWsAttachContainerNotFound(c *check.C) {
|
||||
status, body, err := sockRequest("GET", "/containers/doesnotexist/attach/ws", nil)
|
||||
c.Assert(status, check.Equals, http.StatusNotFound)
|
||||
c.Assert(err, check.IsNil)
|
||||
c.Assert(status, checker.Equals, http.StatusNotFound)
|
||||
c.Assert(err, checker.IsNil)
|
||||
expected := "no such id: doesnotexist\n"
|
||||
if !strings.Contains(string(body), expected) {
|
||||
c.Fatalf("Expected response body to contain %q", expected)
|
||||
}
|
||||
c.Assert(string(body), checker.Contains, expected)
|
||||
}
|
||||
|
||||
func (s *DockerSuite) TestPostContainersAttach(c *check.C) {
|
||||
testRequires(c, DaemonIsLinux)
|
||||
out, _ := dockerCmd(c, "run", "-dit", "busybox", "cat")
|
||||
|
||||
r, w := io.Pipe()
|
||||
defer r.Close()
|
||||
defer w.Close()
|
||||
expectSuccess := func(conn net.Conn, br *bufio.Reader, stream string, tty bool) {
|
||||
defer conn.Close()
|
||||
expected := []byte("success")
|
||||
_, err := conn.Write(expected)
|
||||
c.Assert(err, checker.IsNil)
|
||||
|
||||
conn, err := sockConn(time.Duration(10 * time.Second))
|
||||
c.Assert(err, check.IsNil)
|
||||
|
||||
containerID := strings.TrimSpace(out)
|
||||
|
||||
req, err := http.NewRequest("POST", "/containers/"+containerID+"/attach?stream=1&stdin=1&stdout=1&stderr=1", bytes.NewReader([]byte{}))
|
||||
c.Assert(err, check.IsNil)
|
||||
|
||||
client := httputil.NewClientConn(conn, nil)
|
||||
defer client.Close()
|
||||
|
||||
// Do POST attach request
|
||||
resp, err := client.Do(req)
|
||||
c.Assert(resp.StatusCode, check.Equals, http.StatusOK)
|
||||
// If we check the err, we get a ErrPersistEOF = &http.ProtocolError{ErrorString: "persistent connection closed"}
|
||||
// This means that the remote requested this be the last request serviced, is this okay?
|
||||
|
||||
// Test read and write to the attached container
|
||||
expected := []byte("hello")
|
||||
actual := make([]byte, len(expected))
|
||||
|
||||
outChan := make(chan error)
|
||||
go func() {
|
||||
_, err := r.Read(actual)
|
||||
outChan <- err
|
||||
close(outChan)
|
||||
}()
|
||||
|
||||
inChan := make(chan error)
|
||||
go func() {
|
||||
_, err := w.Write(expected)
|
||||
inChan <- err
|
||||
close(inChan)
|
||||
}()
|
||||
|
||||
select {
|
||||
case err := <-inChan:
|
||||
c.Assert(err, check.IsNil)
|
||||
case <-time.After(5 * time.Second):
|
||||
c.Fatal("Timeout writing to stdout")
|
||||
conn.SetReadDeadline(time.Now().Add(time.Second))
|
||||
lenHeader := 0
|
||||
if !tty {
|
||||
lenHeader = 8
|
||||
}
|
||||
actual := make([]byte, len(expected)+lenHeader)
|
||||
_, err = io.ReadFull(br, actual)
|
||||
c.Assert(err, checker.IsNil)
|
||||
if !tty {
|
||||
fdMap := map[string]byte{
|
||||
"stdin": 0,
|
||||
"stdout": 1,
|
||||
"stderr": 2,
|
||||
}
|
||||
c.Assert(actual[0], checker.Equals, fdMap[stream])
|
||||
}
|
||||
c.Assert(actual[lenHeader:], checker.DeepEquals, expected, check.Commentf("Attach didn't return the expected data from %s", stream))
|
||||
}
|
||||
|
||||
select {
|
||||
case err := <-outChan:
|
||||
c.Assert(err, check.IsNil)
|
||||
case <-time.After(5 * time.Second):
|
||||
c.Fatal("Timeout reading from stdin")
|
||||
expectTimeout := func(conn net.Conn, br *bufio.Reader, stream string) {
|
||||
defer conn.Close()
|
||||
_, err := conn.Write([]byte{'t'})
|
||||
c.Assert(err, checker.IsNil)
|
||||
|
||||
conn.SetReadDeadline(time.Now().Add(time.Second))
|
||||
actual := make([]byte, 1)
|
||||
_, err = io.ReadFull(br, actual)
|
||||
opErr, ok := err.(*net.OpError)
|
||||
c.Assert(ok, checker.Equals, true, check.Commentf("Error is expected to be *net.OpError, got %v", err))
|
||||
c.Assert(opErr.Timeout(), checker.Equals, true, check.Commentf("Read from %s is expected to timeout", stream))
|
||||
}
|
||||
|
||||
if !bytes.Equal(expected, actual) {
|
||||
c.Fatal("Expected output to match input")
|
||||
}
|
||||
// Create a container that only emits stdout.
|
||||
cid, _ := dockerCmd(c, "run", "-di", "busybox", "cat")
|
||||
cid = strings.TrimSpace(cid)
|
||||
// Attach to the container's stdout stream.
|
||||
conn, br, err := sockRequestHijack("POST", "/containers/"+cid+"/attach?stream=1&stdin=1&stdout=1", nil, "text/plain")
|
||||
c.Assert(err, checker.IsNil)
|
||||
// Check if the data from stdout can be received.
|
||||
expectSuccess(conn, br, "stdout", false)
|
||||
// Attach to the container's stderr stream.
|
||||
conn, br, err = sockRequestHijack("POST", "/containers/"+cid+"/attach?stream=1&stdin=1&stderr=1", nil, "text/plain")
|
||||
c.Assert(err, checker.IsNil)
|
||||
// Since the container only emits stdout, attaching to stderr should return nothing.
|
||||
expectTimeout(conn, br, "stdout")
|
||||
|
||||
resp.Body.Close()
|
||||
}
|
||||
|
||||
func (s *DockerSuite) TestPostContainersAttachStderr(c *check.C) {
|
||||
testRequires(c, DaemonIsLinux)
|
||||
out, _ := dockerCmd(c, "run", "-dit", "busybox", "/bin/sh", "-c", "cat >&2")
|
||||
|
||||
r, w := io.Pipe()
|
||||
defer r.Close()
|
||||
defer w.Close()
|
||||
|
||||
conn, err := sockConn(time.Duration(10 * time.Second))
|
||||
c.Assert(err, check.IsNil)
|
||||
|
||||
containerID := strings.TrimSpace(out)
|
||||
|
||||
req, err := http.NewRequest("POST", "/containers/"+containerID+"/attach?stream=1&stdin=1&stdout=1&stderr=1", bytes.NewReader([]byte{}))
|
||||
c.Assert(err, check.IsNil)
|
||||
|
||||
client := httputil.NewClientConn(conn, nil)
|
||||
defer client.Close()
|
||||
|
||||
// Do POST attach request
|
||||
resp, err := client.Do(req)
|
||||
c.Assert(resp.StatusCode, check.Equals, http.StatusOK)
|
||||
// If we check the err, we get a ErrPersistEOF = &http.ProtocolError{ErrorString: "persistent connection closed"}
|
||||
// This means that the remote requested this be the last request serviced, is this okay?
|
||||
|
||||
// Test read and write to the attached container
|
||||
expected := []byte("hello")
|
||||
actual := make([]byte, len(expected))
|
||||
|
||||
outChan := make(chan error)
|
||||
go func() {
|
||||
_, err := r.Read(actual)
|
||||
outChan <- err
|
||||
close(outChan)
|
||||
}()
|
||||
|
||||
inChan := make(chan error)
|
||||
go func() {
|
||||
_, err := w.Write(expected)
|
||||
inChan <- err
|
||||
close(inChan)
|
||||
}()
|
||||
|
||||
select {
|
||||
case err := <-inChan:
|
||||
c.Assert(err, check.IsNil)
|
||||
case <-time.After(5 * time.Second):
|
||||
c.Fatal("Timeout writing to stdout")
|
||||
}
|
||||
|
||||
select {
|
||||
case err := <-outChan:
|
||||
c.Assert(err, check.IsNil)
|
||||
case <-time.After(5 * time.Second):
|
||||
c.Fatal("Timeout reading from stdin")
|
||||
}
|
||||
|
||||
if !bytes.Equal(expected, actual) {
|
||||
c.Fatal("Expected output to match input")
|
||||
}
|
||||
|
||||
resp.Body.Close()
|
||||
// Test the simlar functions of the stderr stream.
|
||||
cid, _ = dockerCmd(c, "run", "-di", "busybox", "/bin/sh", "-c", "cat >&2")
|
||||
cid = strings.TrimSpace(cid)
|
||||
conn, br, err = sockRequestHijack("POST", "/containers/"+cid+"/attach?stream=1&stdin=1&stderr=1", nil, "text/plain")
|
||||
c.Assert(err, checker.IsNil)
|
||||
expectSuccess(conn, br, "stderr", false)
|
||||
conn, br, err = sockRequestHijack("POST", "/containers/"+cid+"/attach?stream=1&stdin=1&stdout=1", nil, "text/plain")
|
||||
c.Assert(err, checker.IsNil)
|
||||
expectTimeout(conn, br, "stderr")
|
||||
|
||||
// Test with tty.
|
||||
cid, _ = dockerCmd(c, "run", "-dit", "busybox", "/bin/sh", "-c", "cat >&2")
|
||||
cid = strings.TrimSpace(cid)
|
||||
// Attach to stdout only.
|
||||
conn, br, err = sockRequestHijack("POST", "/containers/"+cid+"/attach?stream=1&stdin=1&stdout=1", nil, "text/plain")
|
||||
c.Assert(err, checker.IsNil)
|
||||
expectSuccess(conn, br, "stdout", true)
|
||||
|
||||
// Attach without stdout stream.
|
||||
conn, br, err = sockRequestHijack("POST", "/containers/"+cid+"/attach?stream=1&stdin=1&stderr=1", nil, "text/plain")
|
||||
c.Assert(err, checker.IsNil)
|
||||
// Nothing should be received because both the stdout and stderr of the container will be
|
||||
// sent to the client as stdout when tty is enabled.
|
||||
expectTimeout(conn, br, "stdout")
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue