| package main |
| |
| import ( |
| "bufio" |
| "fmt" |
| "io" |
| "os/exec" |
| "runtime" |
| "strings" |
| "sync" |
| "time" |
| |
| "github.com/docker/docker/integration-cli/cli" |
| "github.com/go-check/check" |
| "github.com/gotestyourself/gotestyourself/icmd" |
| ) |
| |
| const attachWait = 5 * time.Second |
| |
| func (s *DockerSuite) TestAttachMultipleAndRestart(c *check.C) { |
| endGroup := &sync.WaitGroup{} |
| startGroup := &sync.WaitGroup{} |
| endGroup.Add(3) |
| startGroup.Add(3) |
| |
| cli.DockerCmd(c, "run", "--name", "attacher", "-d", "busybox", "/bin/sh", "-c", "while true; do sleep 1; echo hello; done") |
| cli.WaitRun(c, "attacher") |
| |
| startDone := make(chan struct{}) |
| endDone := make(chan struct{}) |
| |
| go func() { |
| endGroup.Wait() |
| close(endDone) |
| }() |
| |
| go func() { |
| startGroup.Wait() |
| close(startDone) |
| }() |
| |
| for i := 0; i < 3; i++ { |
| go func() { |
| cmd := exec.Command(dockerBinary, "attach", "attacher") |
| |
| defer func() { |
| cmd.Wait() |
| endGroup.Done() |
| }() |
| |
| out, err := cmd.StdoutPipe() |
| if err != nil { |
| c.Fatal(err) |
| } |
| defer out.Close() |
| |
| if err := cmd.Start(); err != nil { |
| c.Fatal(err) |
| } |
| |
| buf := make([]byte, 1024) |
| |
| if _, err := out.Read(buf); err != nil && err != io.EOF { |
| c.Fatal(err) |
| } |
| |
| startGroup.Done() |
| |
| if !strings.Contains(string(buf), "hello") { |
| c.Fatalf("unexpected output %s expected hello\n", string(buf)) |
| } |
| }() |
| } |
| |
| select { |
| case <-startDone: |
| case <-time.After(attachWait): |
| c.Fatalf("Attaches did not initialize properly") |
| } |
| |
| cli.DockerCmd(c, "kill", "attacher") |
| |
| select { |
| case <-endDone: |
| case <-time.After(attachWait): |
| c.Fatalf("Attaches did not finish properly") |
| } |
| } |
| |
| func (s *DockerSuite) TestAttachTTYWithoutStdin(c *check.C) { |
| // TODO @jhowardmsft. Figure out how to get this running again reliable on Windows. |
| // It works by accident at the moment. Sometimes. I've gone back to v1.13.0 and see the same. |
| // On Windows, docker run -d -ti busybox causes the container to exit immediately. |
| // Obviously a year back when I updated the test, that was not the case. However, |
| // with this, and the test racing with the tear-down which panic's, sometimes CI |
| // will just fail and `MISS` all the other tests. For now, disabling it. Will |
| // open an issue to track re-enabling this and root-causing the problem. |
| testRequires(c, DaemonIsLinux) |
| out, _ := dockerCmd(c, "run", "-d", "-ti", "busybox") |
| |
| id := strings.TrimSpace(out) |
| c.Assert(waitRun(id), check.IsNil) |
| |
| done := make(chan error) |
| go func() { |
| defer close(done) |
| |
| cmd := exec.Command(dockerBinary, "attach", id) |
| if _, err := cmd.StdinPipe(); err != nil { |
| done <- err |
| return |
| } |
| |
| expected := "the input device is not a TTY" |
| if runtime.GOOS == "windows" { |
| expected += ". If you are using mintty, try prefixing the command with 'winpty'" |
| } |
| if out, _, err := runCommandWithOutput(cmd); err == nil { |
| done <- fmt.Errorf("attach should have failed") |
| return |
| } else if !strings.Contains(out, expected) { |
| done <- fmt.Errorf("attach failed with error %q: expected %q", out, expected) |
| return |
| } |
| }() |
| |
| select { |
| case err := <-done: |
| c.Assert(err, check.IsNil) |
| case <-time.After(attachWait): |
| c.Fatal("attach is running but should have failed") |
| } |
| } |
| |
| func (s *DockerSuite) TestAttachDisconnect(c *check.C) { |
| testRequires(c, DaemonIsLinux) |
| out, _ := dockerCmd(c, "run", "-di", "busybox", "/bin/cat") |
| id := strings.TrimSpace(out) |
| |
| cmd := exec.Command(dockerBinary, "attach", id) |
| stdin, err := cmd.StdinPipe() |
| if err != nil { |
| c.Fatal(err) |
| } |
| defer stdin.Close() |
| stdout, err := cmd.StdoutPipe() |
| c.Assert(err, check.IsNil) |
| defer stdout.Close() |
| c.Assert(cmd.Start(), check.IsNil) |
| defer func() { |
| cmd.Process.Kill() |
| cmd.Wait() |
| }() |
| |
| _, err = stdin.Write([]byte("hello\n")) |
| c.Assert(err, check.IsNil) |
| out, err = bufio.NewReader(stdout).ReadString('\n') |
| c.Assert(err, check.IsNil) |
| c.Assert(strings.TrimSpace(out), check.Equals, "hello") |
| |
| c.Assert(stdin.Close(), check.IsNil) |
| |
| // Expect container to still be running after stdin is closed |
| running := inspectField(c, id, "State.Running") |
| c.Assert(running, check.Equals, "true") |
| } |
| |
| func (s *DockerSuite) TestAttachPausedContainer(c *check.C) { |
| testRequires(c, IsPausable) |
| runSleepingContainer(c, "-d", "--name=test") |
| dockerCmd(c, "pause", "test") |
| |
| result := dockerCmdWithResult("attach", "test") |
| result.Assert(c, icmd.Expected{ |
| Error: "exit status 1", |
| ExitCode: 1, |
| Err: "You cannot attach to a paused container, unpause it first", |
| }) |
| } |