|
|
@@ -59,79 +59,6 @@ func assertPipe(input, output string, r io.Reader, w io.Writer, count int) error
|
|
|
return nil
|
|
|
}
|
|
|
|
|
|
-/*TODO
|
|
|
-func cmdImages(srv *Server, args ...string) (string, error) {
|
|
|
- stdout, stdoutPipe := io.Pipe()
|
|
|
-
|
|
|
- go func() {
|
|
|
- if err := srv.CmdImages(nil, stdoutPipe, args...); err != nil {
|
|
|
- return
|
|
|
- }
|
|
|
-
|
|
|
- // force the pipe closed, so that the code below gets an EOF
|
|
|
- stdoutPipe.Close()
|
|
|
- }()
|
|
|
-
|
|
|
- output, err := ioutil.ReadAll(stdout)
|
|
|
- if err != nil {
|
|
|
- return "", err
|
|
|
- }
|
|
|
-
|
|
|
- // Cleanup pipes
|
|
|
- return string(output), closeWrap(stdout, stdoutPipe)
|
|
|
-}
|
|
|
-
|
|
|
-// TestImages checks that 'docker images' displays information correctly
|
|
|
-func TestImages(t *testing.T) {
|
|
|
-
|
|
|
- runtime, err := newTestRuntime()
|
|
|
- if err != nil {
|
|
|
- t.Fatal(err)
|
|
|
- }
|
|
|
- defer nuke(runtime)
|
|
|
-
|
|
|
- srv := &Server{runtime: runtime}
|
|
|
-
|
|
|
- output, err := cmdImages(srv)
|
|
|
-
|
|
|
- if !strings.Contains(output, "REPOSITORY") {
|
|
|
- t.Fatal("'images' should have a header")
|
|
|
- }
|
|
|
- if !strings.Contains(output, "docker-ut") {
|
|
|
- t.Fatal("'images' should show the docker-ut image")
|
|
|
- }
|
|
|
- if !strings.Contains(output, "e9aa60c60128") {
|
|
|
- t.Fatal("'images' should show the docker-ut image id")
|
|
|
- }
|
|
|
-
|
|
|
- output, err = cmdImages(srv, "-q")
|
|
|
-
|
|
|
- if strings.Contains(output, "REPOSITORY") {
|
|
|
- t.Fatal("'images -q' should not have a header")
|
|
|
- }
|
|
|
- if strings.Contains(output, "docker-ut") {
|
|
|
- t.Fatal("'images' should not show the docker-ut image name")
|
|
|
- }
|
|
|
- if !strings.Contains(output, "e9aa60c60128") {
|
|
|
- t.Fatal("'images' should show the docker-ut image id")
|
|
|
- }
|
|
|
-
|
|
|
- output, err = cmdImages(srv, "-viz")
|
|
|
-
|
|
|
- if !strings.HasPrefix(output, "digraph docker {") {
|
|
|
- t.Fatal("'images -v' should start with the dot header")
|
|
|
- }
|
|
|
- if !strings.HasSuffix(output, "}\n") {
|
|
|
- t.Fatal("'images -v' should end with a '}'")
|
|
|
- }
|
|
|
- if !strings.Contains(output, "base -> \"e9aa60c60128\" [style=invis]") {
|
|
|
- t.Fatal("'images -v' should have the docker-ut image id node")
|
|
|
- }
|
|
|
-
|
|
|
- // todo: add checks for -a
|
|
|
-}
|
|
|
-
|
|
|
-*/
|
|
|
|
|
|
// TestRunHostname checks that 'docker run -h' correctly sets a custom hostname
|
|
|
func TestRunHostname(t *testing.T) {
|
|
|
@@ -164,163 +91,6 @@ func TestRunHostname(t *testing.T) {
|
|
|
|
|
|
}
|
|
|
|
|
|
-/*
|
|
|
-func TestRunExit(t *testing.T) {
|
|
|
- runtime, err := newTestRuntime()
|
|
|
- if err != nil {
|
|
|
- t.Fatal(err)
|
|
|
- }
|
|
|
- defer nuke(runtime)
|
|
|
-
|
|
|
- srv := &Server{runtime: runtime}
|
|
|
-
|
|
|
- stdin, stdinPipe := io.Pipe()
|
|
|
- stdout, stdoutPipe := io.Pipe()
|
|
|
- c1 := make(chan struct{})
|
|
|
- go func() {
|
|
|
- srv.CmdRun(stdin, rcli.NewDockerLocalConn(stdoutPipe), "-i", GetTestImage(runtime).Id, "/bin/cat")
|
|
|
- close(c1)
|
|
|
- }()
|
|
|
-
|
|
|
- setTimeout(t, "Read/Write assertion timed out", 2*time.Second, func() {
|
|
|
- if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 15); err != nil {
|
|
|
- t.Fatal(err)
|
|
|
- }
|
|
|
- })
|
|
|
-
|
|
|
- container := runtime.List()[0]
|
|
|
-
|
|
|
- // Closing /bin/cat stdin, expect it to exit
|
|
|
- p, err := container.StdinPipe()
|
|
|
- if err != nil {
|
|
|
- t.Fatal(err)
|
|
|
- }
|
|
|
- if err := p.Close(); err != nil {
|
|
|
- t.Fatal(err)
|
|
|
- }
|
|
|
-
|
|
|
- // as the process exited, CmdRun must finish and unblock. Wait for it
|
|
|
- setTimeout(t, "Waiting for CmdRun timed out", 2*time.Second, func() {
|
|
|
- <-c1
|
|
|
- cmdWait(srv, container)
|
|
|
- })
|
|
|
-
|
|
|
- // Make sure that the client has been disconnected
|
|
|
- setTimeout(t, "The client should have been disconnected once the remote process exited.", 2*time.Second, func() {
|
|
|
- // Expecting pipe i/o error, just check that read does not block
|
|
|
- stdin.Read([]byte{})
|
|
|
- })
|
|
|
-
|
|
|
- // Cleanup pipes
|
|
|
- if err := closeWrap(stdin, stdinPipe, stdout, stdoutPipe); err != nil {
|
|
|
- t.Fatal(err)
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-// Expected behaviour: the process dies when the client disconnects
|
|
|
-func TestRunDisconnect(t *testing.T) {
|
|
|
- runtime, err := newTestRuntime()
|
|
|
- if err != nil {
|
|
|
- t.Fatal(err)
|
|
|
- }
|
|
|
- defer nuke(runtime)
|
|
|
-
|
|
|
- srv := &Server{runtime: runtime}
|
|
|
-
|
|
|
- stdin, stdinPipe := io.Pipe()
|
|
|
- stdout, stdoutPipe := io.Pipe()
|
|
|
- c1 := make(chan struct{})
|
|
|
- go func() {
|
|
|
- // We're simulating a disconnect so the return value doesn't matter. What matters is the
|
|
|
- // fact that CmdRun returns.
|
|
|
- srv.CmdRun(stdin, rcli.NewDockerLocalConn(stdoutPipe), "-i", GetTestImage(runtime).Id, "/bin/cat")
|
|
|
- close(c1)
|
|
|
- }()
|
|
|
-
|
|
|
- setTimeout(t, "Read/Write assertion timed out", 2*time.Second, func() {
|
|
|
- if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 15); err != nil {
|
|
|
- t.Fatal(err)
|
|
|
- }
|
|
|
- })
|
|
|
-
|
|
|
- // Close pipes (simulate disconnect)
|
|
|
- if err := closeWrap(stdin, stdinPipe, stdout, stdoutPipe); err != nil {
|
|
|
- t.Fatal(err)
|
|
|
- }
|
|
|
-
|
|
|
- // as the pipes are close, we expect the process to die,
|
|
|
- // therefore CmdRun to unblock. Wait for CmdRun
|
|
|
- setTimeout(t, "Waiting for CmdRun timed out", 2*time.Second, func() {
|
|
|
- <-c1
|
|
|
- })
|
|
|
-
|
|
|
- // Client disconnect after run -i should cause stdin to be closed, which should
|
|
|
- // cause /bin/cat to exit.
|
|
|
- setTimeout(t, "Waiting for /bin/cat to exit timed out", 2*time.Second, func() {
|
|
|
- container := runtime.List()[0]
|
|
|
- container.Wait()
|
|
|
- if container.State.Running {
|
|
|
- t.Fatalf("/bin/cat is still running after closing stdin")
|
|
|
- }
|
|
|
- })
|
|
|
-}
|
|
|
-
|
|
|
-// Expected behaviour: the process dies when the client disconnects
|
|
|
-func TestRunDisconnectTty(t *testing.T) {
|
|
|
- runtime, err := newTestRuntime()
|
|
|
- if err != nil {
|
|
|
- t.Fatal(err)
|
|
|
- }
|
|
|
- defer nuke(runtime)
|
|
|
-
|
|
|
- srv := &Server{runtime: runtime}
|
|
|
-
|
|
|
- stdin, stdinPipe := io.Pipe()
|
|
|
- stdout, stdoutPipe := io.Pipe()
|
|
|
- c1 := make(chan struct{})
|
|
|
- go func() {
|
|
|
- // We're simulating a disconnect so the return value doesn't matter. What matters is the
|
|
|
- // fact that CmdRun returns.
|
|
|
- srv.CmdRun(stdin, rcli.NewDockerLocalConn(stdoutPipe), "-i", "-t", GetTestImage(runtime).Id, "/bin/cat")
|
|
|
- close(c1)
|
|
|
- }()
|
|
|
-
|
|
|
- setTimeout(t, "Waiting for the container to be started timed out", 2*time.Second, func() {
|
|
|
- for {
|
|
|
- // Client disconnect after run -i should keep stdin out in TTY mode
|
|
|
- l := runtime.List()
|
|
|
- if len(l) == 1 && l[0].State.Running {
|
|
|
- break
|
|
|
- }
|
|
|
-
|
|
|
- time.Sleep(10 * time.Millisecond)
|
|
|
- }
|
|
|
- })
|
|
|
-
|
|
|
- // Client disconnect after run -i should keep stdin out in TTY mode
|
|
|
- container := runtime.List()[0]
|
|
|
-
|
|
|
- setTimeout(t, "Read/Write assertion timed out", 2*time.Second, func() {
|
|
|
- if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 15); err != nil {
|
|
|
- t.Fatal(err)
|
|
|
- }
|
|
|
- })
|
|
|
-
|
|
|
- // Close pipes (simulate disconnect)
|
|
|
- if err := closeWrap(stdin, stdinPipe, stdout, stdoutPipe); err != nil {
|
|
|
- t.Fatal(err)
|
|
|
- }
|
|
|
-
|
|
|
- // In tty mode, we expect the process to stay alive even after client's stdin closes.
|
|
|
- // Do not wait for run to finish
|
|
|
-
|
|
|
- // Give some time to monitor to do his thing
|
|
|
- container.WaitTimeout(500 * time.Millisecond)
|
|
|
- if !container.State.Running {
|
|
|
- t.Fatalf("/bin/cat should still be running after closing stdin (tty mode)")
|
|
|
- }
|
|
|
-}
|
|
|
-*/
|
|
|
|
|
|
// TestAttachStdin checks attaching to stdin without stdout and stderr.
|
|
|
// 'docker run -i -a stdin' should sends the client's stdin to the command,
|
|
|
@@ -387,74 +157,3 @@ func TestRunAttachStdin(t *testing.T) {
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
-
|
|
|
-/*
|
|
|
-// Expected behaviour, the process stays alive when the client disconnects
|
|
|
-func TestAttachDisconnect(t *testing.T) {
|
|
|
- runtime, err := newTestRuntime()
|
|
|
- if err != nil {
|
|
|
- t.Fatal(err)
|
|
|
- }
|
|
|
- defer nuke(runtime)
|
|
|
-
|
|
|
- srv := &Server{runtime: runtime}
|
|
|
-
|
|
|
- container, err := NewBuilder(runtime).Create(
|
|
|
- &Config{
|
|
|
- Image: GetTestImage(runtime).Id,
|
|
|
- CpuShares: 1000,
|
|
|
- Memory: 33554432,
|
|
|
- Cmd: []string{"/bin/cat"},
|
|
|
- OpenStdin: true,
|
|
|
- },
|
|
|
- )
|
|
|
- if err != nil {
|
|
|
- t.Fatal(err)
|
|
|
- }
|
|
|
- defer runtime.Destroy(container)
|
|
|
-
|
|
|
- // Start the process
|
|
|
- if err := container.Start(); err != nil {
|
|
|
- t.Fatal(err)
|
|
|
- }
|
|
|
-
|
|
|
- stdin, stdinPipe := io.Pipe()
|
|
|
- stdout, stdoutPipe := io.Pipe()
|
|
|
-
|
|
|
- // Attach to it
|
|
|
- c1 := make(chan struct{})
|
|
|
- go func() {
|
|
|
- // We're simulating a disconnect so the return value doesn't matter. What matters is the
|
|
|
- // fact that CmdAttach returns.
|
|
|
- srv.CmdAttach(stdin, rcli.NewDockerLocalConn(stdoutPipe), container.Id)
|
|
|
- close(c1)
|
|
|
- }()
|
|
|
-
|
|
|
- setTimeout(t, "First read/write assertion timed out", 2*time.Second, func() {
|
|
|
- if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 15); err != nil {
|
|
|
- t.Fatal(err)
|
|
|
- }
|
|
|
- })
|
|
|
- // Close pipes (client disconnects)
|
|
|
- if err := closeWrap(stdin, stdinPipe, stdout, stdoutPipe); err != nil {
|
|
|
- t.Fatal(err)
|
|
|
- }
|
|
|
-
|
|
|
- // Wait for attach to finish, the client disconnected, therefore, Attach finished his job
|
|
|
- setTimeout(t, "Waiting for CmdAttach timed out", 2*time.Second, func() {
|
|
|
- <-c1
|
|
|
- })
|
|
|
-
|
|
|
- // We closed stdin, expect /bin/cat to still be running
|
|
|
- // Wait a little bit to make sure container.monitor() did his thing
|
|
|
- err = container.WaitTimeout(500 * time.Millisecond)
|
|
|
- if err == nil || !container.State.Running {
|
|
|
- t.Fatalf("/bin/cat is not running after closing stdin")
|
|
|
- }
|
|
|
-
|
|
|
- // Try to avoid the timeoout in destroy. Best effort, don't check error
|
|
|
- cStdin, _ := container.StdinPipe()
|
|
|
- cStdin.Close()
|
|
|
- container.Wait()
|
|
|
-}
|
|
|
-*/
|
Solomon Hykes