// TestRunHostname checks that 'docker run -h' correctly sets a custom hostname func TestRunHostname(t *testing.T) { runtime, err := newTestRuntime() if err != nil { t.Fatal(err) } defer nuke(runtime) srv := &Server{runtime: runtime} stdin, _ := io.Pipe() stdout, stdoutPipe := io.Pipe() c := make(chan struct{}) go func() { if err := srv.CmdRun(stdin, rcli.NewDockerLocalConn(stdoutPipe), "-h", "foobar", GetTestImage(runtime).Id, "hostname"); err != nil { t.Fatal(err) } close(c) }() cmdOutput, err := bufio.NewReader(stdout).ReadString('\n') if err != nil { t.Fatal(err) } if cmdOutput != "foobar\n" { t.Fatalf("'hostname' should display '%s', not '%s'", "foobar\n", cmdOutput) } setTimeout(t, "CmdRun timed out", 2*time.Second, func() { <-c cmdWait(srv, srv.runtime.List()[0]) }) }
func init() { // Hack to run sys init during unit testing if SelfPath() == "/sbin/init" { SysInit() return } if usr, err := user.Current(); err != nil { panic(err) } else if usr.Uid != "0" { panic("docker tests needs to be run as root") } // Make it our Store root runtime, err := NewRuntimeFromDirectory(unitTestStoreBase) if err != nil { panic(err) } // Create the "Server" srv := &Server{ runtime: runtime, } // Retrieve the Image if err := srv.CmdPull(os.Stdin, rcli.NewDockerLocalConn(os.Stdout), unitTestImageName); err != nil { panic(err) } }
// 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)") } }
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) } }
func runCommand(args []string) error { // FIXME: we want to use unix sockets here, but net.UnixConn doesn't expose // CloseWrite(), which we need to cleanly signal that stdin is closed without // closing the connection. // See http://code.google.com/p/go/issues/detail?id=3345 if conn, err := rcli.Call("tcp", "127.0.0.1:4242", args...); err == nil { options := conn.GetOptions() if options.RawTerminal && term.IsTerminal(int(os.Stdin.Fd())) && os.Getenv("NORAW") == "" { if oldState, err := rcli.SetRawTerminal(); err != nil { return err } else { defer rcli.RestoreTerminal(oldState) } } receiveStdout := docker.Go(func() error { _, err := io.Copy(os.Stdout, conn) return err }) sendStdin := docker.Go(func() error { _, err := io.Copy(conn, os.Stdin) if err := conn.CloseWrite(); err != nil { log.Printf("Couldn't send EOF: " + err.Error()) } return err }) if err := <-receiveStdout; err != nil { return err } if !term.IsTerminal(int(os.Stdin.Fd())) { if err := <-sendStdin; err != nil { return err } } } else { service, err := docker.NewServer() if err != nil { return err } dockerConn := rcli.NewDockerLocalConn(os.Stdout) defer dockerConn.Close() if err := rcli.LocalCall(service, os.Stdin, dockerConn, args...); err != nil { return err } } return nil }
// 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") } }) }
func init() { NO_MEMORY_LIMIT = os.Getenv("NO_MEMORY_LIMIT") == "1" // Hack to run sys init during unit testing if SelfPath() == "/sbin/init" { SysInit() return } if usr, err := user.Current(); err != nil { panic(err) } else if usr.Uid != "0" { panic("docker tests needs to be run as root") } // Create a temp directory root, err := ioutil.TempDir("", "docker-test") if err != nil { panic(err) } unitTestStoreBase = root // Make it our Store root runtime, err := NewRuntimeFromDirectory(root) if err != nil { panic(err) } // Create the "Server" srv := &Server{ runtime: runtime, } // Retrieve the Image if err := srv.CmdPull(os.Stdin, rcli.NewDockerLocalConn(os.Stdout), unitTestImageName); err != nil { panic(err) } }
// 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 := runtime.Create( &Config{ Image: GetTestImage(runtime).Id, 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() }
// TestAttachStdin checks attaching to stdin without stdout and stderr. // 'docker run -i -a stdin' should sends the client's stdin to the command, // then detach from it and print the container id. func TestRunAttachStdin(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() ch := make(chan struct{}) go func() { srv.CmdRun(stdin, rcli.NewDockerLocalConn(stdoutPipe), "-i", "-a", "stdin", GetTestImage(runtime).Id, "sh", "-c", "echo hello; cat") close(ch) }() // Send input to the command, close stdin setTimeout(t, "Write timed out", 2*time.Second, func() { if _, err := stdinPipe.Write([]byte("hi there\n")); err != nil { t.Fatal(err) } if err := stdinPipe.Close(); err != nil { t.Fatal(err) } }) container := runtime.List()[0] // Check output cmdOutput, err := bufio.NewReader(stdout).ReadString('\n') if err != nil { t.Fatal(err) } if cmdOutput != container.ShortId()+"\n" { t.Fatalf("Wrong output: should be '%s', not '%s'\n", container.ShortId()+"\n", cmdOutput) } // wait for CmdRun to return setTimeout(t, "Waiting for CmdRun timed out", 2*time.Second, func() { <-ch }) setTimeout(t, "Waiting for command to exit timed out", 2*time.Second, func() { container.Wait() }) // Check logs if cmdLogs, err := container.ReadLog("stdout"); err != nil { t.Fatal(err) } else { if output, err := ioutil.ReadAll(cmdLogs); err != nil { t.Fatal(err) } else { expectedLog := "hello\nhi there\n" if string(output) != expectedLog { t.Fatalf("Unexpected logs: should be '%s', not '%s'\n", expectedLog, output) } } } }