| package docker |
| |
| import ( |
| "bufio" |
| "fmt" |
| "io" |
| "io/ioutil" |
| "os" |
| "path" |
| "regexp" |
| "strings" |
| "testing" |
| "time" |
| |
| "github.com/dotcloud/docker/api/client" |
| "github.com/dotcloud/docker/daemon" |
| "github.com/dotcloud/docker/engine" |
| "github.com/dotcloud/docker/image" |
| "github.com/dotcloud/docker/pkg/term" |
| "github.com/dotcloud/docker/utils" |
| ) |
| |
| func closeWrap(args ...io.Closer) error { |
| e := false |
| ret := fmt.Errorf("Error closing elements") |
| for _, c := range args { |
| if err := c.Close(); err != nil { |
| e = true |
| ret = fmt.Errorf("%s\n%s", ret, err) |
| } |
| } |
| if e { |
| return ret |
| } |
| return nil |
| } |
| |
| func setRaw(t *testing.T, c *daemon.Container) *term.State { |
| pty, err := c.GetPtyMaster() |
| if err != nil { |
| t.Fatal(err) |
| } |
| state, err := term.MakeRaw(pty.Fd()) |
| if err != nil { |
| t.Fatal(err) |
| } |
| return state |
| } |
| |
| func unsetRaw(t *testing.T, c *daemon.Container, state *term.State) { |
| pty, err := c.GetPtyMaster() |
| if err != nil { |
| t.Fatal(err) |
| } |
| term.RestoreTerminal(pty.Fd(), state) |
| } |
| |
| func waitContainerStart(t *testing.T, timeout time.Duration) *daemon.Container { |
| var container *daemon.Container |
| |
| setTimeout(t, "Waiting for the container to be started timed out", timeout, func() { |
| for { |
| l := globalDaemon.List() |
| if len(l) == 1 && l[0].State.IsRunning() { |
| container = l[0] |
| break |
| } |
| time.Sleep(10 * time.Millisecond) |
| } |
| }) |
| |
| if container == nil { |
| t.Fatal("An error occured while waiting for the container to start") |
| } |
| |
| return container |
| } |
| |
| func setTimeout(t *testing.T, msg string, d time.Duration, f func()) { |
| c := make(chan bool) |
| |
| // Make sure we are not too long |
| go func() { |
| time.Sleep(d) |
| c <- true |
| }() |
| go func() { |
| f() |
| c <- false |
| }() |
| if <-c && msg != "" { |
| t.Fatal(msg) |
| } |
| } |
| |
| func expectPipe(expected string, r io.Reader) error { |
| o, err := bufio.NewReader(r).ReadString('\n') |
| if err != nil { |
| return err |
| } |
| if strings.Trim(o, " \r\n") != expected { |
| return fmt.Errorf("Unexpected output. Expected [%s], received [%s]", expected, o) |
| } |
| return nil |
| } |
| |
| func assertPipe(input, output string, r io.Reader, w io.Writer, count int) error { |
| for i := 0; i < count; i++ { |
| if _, err := w.Write([]byte(input)); err != nil { |
| return err |
| } |
| if err := expectPipe(output, r); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| |
| // TestRunWorkdirExistsAndIsFile checks that if 'docker run -w' with existing file can be detected |
| func TestRunWorkdirExistsAndIsFile(t *testing.T) { |
| |
| cli := client.NewDockerCli(nil, nil, ioutil.Discard, testDaemonProto, testDaemonAddr, nil) |
| defer cleanup(globalEngine, t) |
| |
| c := make(chan struct{}) |
| go func() { |
| defer close(c) |
| if err := cli.CmdRun("-w", "/bin/cat", unitTestImageID, "pwd"); err == nil { |
| t.Fatal("should have failed to run when using /bin/cat as working dir.") |
| } |
| }() |
| |
| setTimeout(t, "CmdRun timed out", 5*time.Second, func() { |
| <-c |
| }) |
| } |
| |
| func TestRunExit(t *testing.T) { |
| stdin, stdinPipe := io.Pipe() |
| stdout, stdoutPipe := io.Pipe() |
| |
| cli := client.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr, nil) |
| defer cleanup(globalEngine, t) |
| |
| c1 := make(chan struct{}) |
| go func() { |
| cli.CmdRun("-i", unitTestImageID, "/bin/cat") |
| close(c1) |
| }() |
| |
| setTimeout(t, "Read/Write assertion timed out", 2*time.Second, func() { |
| if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 150); err != nil { |
| t.Fatal(err) |
| } |
| }) |
| |
| container := globalDaemon.List()[0] |
| |
| // Closing /bin/cat stdin, expect it to exit |
| if err := stdin.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", 10*time.Second, func() { |
| <-c1 |
| |
| go func() { |
| cli.CmdWait(container.ID) |
| }() |
| |
| if _, err := bufio.NewReader(stdout).ReadString('\n'); err != nil { |
| t.Fatal(err) |
| } |
| }) |
| |
| // 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) { |
| |
| stdin, stdinPipe := io.Pipe() |
| stdout, stdoutPipe := io.Pipe() |
| |
| cli := client.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr, nil) |
| defer cleanup(globalEngine, t) |
| |
| 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. |
| cli.CmdRun("-i", unitTestImageID, "/bin/cat") |
| close(c1) |
| }() |
| |
| setTimeout(t, "Read/Write assertion timed out", 2*time.Second, func() { |
| if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 150); 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 := globalDaemon.List()[0] |
| container.State.WaitStop(-1 * time.Second) |
| if container.State.IsRunning() { |
| t.Fatalf("/bin/cat is still running after closing stdin") |
| } |
| }) |
| } |
| |
| // Expected behaviour: the process stay alive when the client disconnects |
| // but the client detaches. |
| func TestRunDisconnectTty(t *testing.T) { |
| |
| stdin, stdinPipe := io.Pipe() |
| stdout, stdoutPipe := io.Pipe() |
| |
| cli := client.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr, nil) |
| defer cleanup(globalEngine, t) |
| |
| c1 := make(chan struct{}) |
| go func() { |
| defer close(c1) |
| // We're simulating a disconnect so the return value doesn't matter. What matters is the |
| // fact that CmdRun returns. |
| if err := cli.CmdRun("-i", "-t", unitTestImageID, "/bin/cat"); err != nil { |
| utils.Debugf("Error CmdRun: %s", err) |
| } |
| }() |
| |
| container := waitContainerStart(t, 10*time.Second) |
| |
| state := setRaw(t, container) |
| defer unsetRaw(t, container, state) |
| |
| // Client disconnect after run -i should keep stdin out in TTY mode |
| setTimeout(t, "Read/Write assertion timed out", 2*time.Second, func() { |
| if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 150); err != nil { |
| t.Fatal(err) |
| } |
| }) |
| |
| // Close pipes (simulate disconnect) |
| if err := closeWrap(stdin, stdinPipe, stdout, stdoutPipe); err != nil { |
| t.Fatal(err) |
| } |
| |
| // wait for CmdRun to return |
| setTimeout(t, "Waiting for CmdRun timed out", 5*time.Second, func() { |
| <-c1 |
| }) |
| |
| // In tty mode, we expect the process to stay alive even after client's stdin closes. |
| |
| // Give some time to monitor to do his thing |
| container.State.WaitStop(500 * time.Millisecond) |
| if !container.State.IsRunning() { |
| t.Fatalf("/bin/cat should still be running after closing stdin (tty mode)") |
| } |
| } |
| |
| // TestRunDetach checks attaching and detaching with the escape sequence. |
| func TestRunDetach(t *testing.T) { |
| |
| stdin, stdinPipe := io.Pipe() |
| stdout, stdoutPipe := io.Pipe() |
| |
| cli := client.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr, nil) |
| defer cleanup(globalEngine, t) |
| |
| ch := make(chan struct{}) |
| go func() { |
| defer close(ch) |
| cli.CmdRun("-i", "-t", unitTestImageID, "cat") |
| }() |
| |
| container := waitContainerStart(t, 10*time.Second) |
| |
| state := setRaw(t, container) |
| defer unsetRaw(t, container, state) |
| |
| setTimeout(t, "First read/write assertion timed out", 2*time.Second, func() { |
| if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 150); err != nil { |
| t.Fatal(err) |
| } |
| }) |
| |
| setTimeout(t, "Escape sequence timeout", 5*time.Second, func() { |
| stdinPipe.Write([]byte{16}) |
| time.Sleep(100 * time.Millisecond) |
| stdinPipe.Write([]byte{17}) |
| }) |
| |
| // wait for CmdRun to return |
| setTimeout(t, "Waiting for CmdRun timed out", 15*time.Second, func() { |
| <-ch |
| }) |
| closeWrap(stdin, stdinPipe, stdout, stdoutPipe) |
| |
| time.Sleep(500 * time.Millisecond) |
| if !container.State.IsRunning() { |
| t.Fatal("The detached container should be still running") |
| } |
| |
| setTimeout(t, "Waiting for container to die timed out", 20*time.Second, func() { |
| container.Kill() |
| }) |
| } |
| |
| // TestAttachDetach checks that attach in tty mode can be detached using the long container ID |
| func TestAttachDetach(t *testing.T) { |
| stdin, stdinPipe := io.Pipe() |
| stdout, stdoutPipe := io.Pipe() |
| |
| cli := client.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr, nil) |
| defer cleanup(globalEngine, t) |
| |
| ch := make(chan struct{}) |
| go func() { |
| defer close(ch) |
| if err := cli.CmdRun("-i", "-t", "-d", unitTestImageID, "cat"); err != nil { |
| t.Fatal(err) |
| } |
| }() |
| |
| container := waitContainerStart(t, 10*time.Second) |
| |
| setTimeout(t, "Reading container's id timed out", 10*time.Second, func() { |
| buf := make([]byte, 1024) |
| n, err := stdout.Read(buf) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if strings.Trim(string(buf[:n]), " \r\n") != container.ID { |
| t.Fatalf("Wrong ID received. Expect %s, received %s", container.ID, buf[:n]) |
| } |
| }) |
| setTimeout(t, "Starting container timed out", 10*time.Second, func() { |
| <-ch |
| }) |
| |
| state := setRaw(t, container) |
| defer unsetRaw(t, container, state) |
| |
| stdin, stdinPipe = io.Pipe() |
| stdout, stdoutPipe = io.Pipe() |
| cli = client.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr, nil) |
| |
| ch = make(chan struct{}) |
| go func() { |
| defer close(ch) |
| if err := cli.CmdAttach(container.ID); err != nil { |
| if err != io.ErrClosedPipe { |
| t.Fatal(err) |
| } |
| } |
| }() |
| |
| setTimeout(t, "First read/write assertion timed out", 2*time.Second, func() { |
| if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 150); err != nil { |
| if err != io.ErrClosedPipe { |
| t.Fatal(err) |
| } |
| } |
| }) |
| |
| setTimeout(t, "Escape sequence timeout", 5*time.Second, func() { |
| stdinPipe.Write([]byte{16}) |
| time.Sleep(100 * time.Millisecond) |
| stdinPipe.Write([]byte{17}) |
| }) |
| |
| // wait for CmdRun to return |
| setTimeout(t, "Waiting for CmdAttach timed out", 15*time.Second, func() { |
| <-ch |
| }) |
| |
| closeWrap(stdin, stdinPipe, stdout, stdoutPipe) |
| |
| time.Sleep(500 * time.Millisecond) |
| if !container.State.IsRunning() { |
| t.Fatal("The detached container should be still running") |
| } |
| |
| setTimeout(t, "Waiting for container to die timedout", 5*time.Second, func() { |
| container.Kill() |
| }) |
| } |
| |
| // TestAttachDetachTruncatedID checks that attach in tty mode can be detached |
| func TestAttachDetachTruncatedID(t *testing.T) { |
| stdin, stdinPipe := io.Pipe() |
| stdout, stdoutPipe := io.Pipe() |
| |
| cli := client.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr, nil) |
| defer cleanup(globalEngine, t) |
| |
| // Discard the CmdRun output |
| go stdout.Read(make([]byte, 1024)) |
| setTimeout(t, "Starting container timed out", 2*time.Second, func() { |
| if err := cli.CmdRun("-i", "-t", "-d", unitTestImageID, "cat"); err != nil { |
| t.Fatal(err) |
| } |
| }) |
| |
| container := waitContainerStart(t, 10*time.Second) |
| |
| state := setRaw(t, container) |
| defer unsetRaw(t, container, state) |
| |
| stdin, stdinPipe = io.Pipe() |
| stdout, stdoutPipe = io.Pipe() |
| cli = client.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr, nil) |
| |
| ch := make(chan struct{}) |
| go func() { |
| defer close(ch) |
| if err := cli.CmdAttach(utils.TruncateID(container.ID)); err != nil { |
| if err != io.ErrClosedPipe { |
| t.Fatal(err) |
| } |
| } |
| }() |
| |
| setTimeout(t, "First read/write assertion timed out", 2*time.Second, func() { |
| if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 150); err != nil { |
| if err != io.ErrClosedPipe { |
| t.Fatal(err) |
| } |
| } |
| }) |
| |
| setTimeout(t, "Escape sequence timeout", 5*time.Second, func() { |
| stdinPipe.Write([]byte{16}) |
| time.Sleep(100 * time.Millisecond) |
| stdinPipe.Write([]byte{17}) |
| }) |
| |
| // wait for CmdRun to return |
| setTimeout(t, "Waiting for CmdAttach timed out", 15*time.Second, func() { |
| <-ch |
| }) |
| closeWrap(stdin, stdinPipe, stdout, stdoutPipe) |
| |
| time.Sleep(500 * time.Millisecond) |
| if !container.State.IsRunning() { |
| t.Fatal("The detached container should be still running") |
| } |
| |
| setTimeout(t, "Waiting for container to die timedout", 5*time.Second, func() { |
| container.Kill() |
| }) |
| } |
| |
| // Expected behaviour, the process stays alive when the client disconnects |
| func TestAttachDisconnect(t *testing.T) { |
| stdin, stdinPipe := io.Pipe() |
| stdout, stdoutPipe := io.Pipe() |
| |
| cli := client.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr, nil) |
| defer cleanup(globalEngine, t) |
| |
| go func() { |
| // Start a process in daemon mode |
| if err := cli.CmdRun("-d", "-i", unitTestImageID, "/bin/cat"); err != nil { |
| utils.Debugf("Error CmdRun: %s", err) |
| } |
| }() |
| |
| setTimeout(t, "Waiting for CmdRun timed out", 10*time.Second, func() { |
| if _, err := bufio.NewReader(stdout).ReadString('\n'); err != nil { |
| t.Fatal(err) |
| } |
| }) |
| |
| setTimeout(t, "Waiting for the container to be started timed out", 10*time.Second, func() { |
| for { |
| l := globalDaemon.List() |
| if len(l) == 1 && l[0].State.IsRunning() { |
| break |
| } |
| time.Sleep(10 * time.Millisecond) |
| } |
| }) |
| |
| container := globalDaemon.List()[0] |
| |
| // 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. |
| cli.CmdAttach(container.ID) |
| close(c1) |
| }() |
| |
| setTimeout(t, "First read/write assertion timed out", 2*time.Second, func() { |
| if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 150); 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.State.WaitStop(500 * time.Millisecond) |
| if err == nil || !container.State.IsRunning() { |
| t.Fatalf("/bin/cat is not running after closing stdin") |
| } |
| |
| // Try to avoid the timeout in destroy. Best effort, don't check error |
| cStdin, _ := container.StdinPipe() |
| cStdin.Close() |
| container.State.WaitStop(-1 * time.Second) |
| } |
| |
| // Expected behaviour: container gets deleted automatically after exit |
| func TestRunAutoRemove(t *testing.T) { |
| t.Skip("Fixme. Skipping test for now, race condition") |
| stdout, stdoutPipe := io.Pipe() |
| cli := client.NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr, nil) |
| defer cleanup(globalEngine, t) |
| |
| c := make(chan struct{}) |
| go func() { |
| defer close(c) |
| if err := cli.CmdRun("--rm", unitTestImageID, "hostname"); err != nil { |
| t.Fatal(err) |
| } |
| }() |
| |
| var temporaryContainerID string |
| setTimeout(t, "Reading command output time out", 2*time.Second, func() { |
| cmdOutput, err := bufio.NewReader(stdout).ReadString('\n') |
| if err != nil { |
| t.Fatal(err) |
| } |
| temporaryContainerID = cmdOutput |
| if err := closeWrap(stdout, stdoutPipe); err != nil { |
| t.Fatal(err) |
| } |
| }) |
| |
| setTimeout(t, "CmdRun timed out", 10*time.Second, func() { |
| <-c |
| }) |
| |
| time.Sleep(500 * time.Millisecond) |
| |
| if len(globalDaemon.List()) > 0 { |
| t.Fatalf("failed to remove container automatically: container %s still exists", temporaryContainerID) |
| } |
| } |
| |
| // Expected behaviour: error out when attempting to bind mount non-existing source paths |
| func TestRunErrorBindNonExistingSource(t *testing.T) { |
| |
| cli := client.NewDockerCli(nil, nil, ioutil.Discard, testDaemonProto, testDaemonAddr, nil) |
| defer cleanup(globalEngine, t) |
| |
| c := make(chan struct{}) |
| go func() { |
| defer close(c) |
| // This check is made at runtime, can't be "unit tested" |
| if err := cli.CmdRun("-v", "/i/dont/exist:/tmp", unitTestImageID, "echo 'should fail'"); err == nil { |
| t.Fatal("should have failed to run when using /i/dont/exist as a source for the bind mount") |
| } |
| }() |
| |
| setTimeout(t, "CmdRun timed out", 5*time.Second, func() { |
| <-c |
| }) |
| } |
| |
| func TestImagesViz(t *testing.T) { |
| t.Skip("Image viz is deprecated") |
| stdout, stdoutPipe := io.Pipe() |
| |
| cli := client.NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr, nil) |
| defer cleanup(globalEngine, t) |
| |
| image := buildTestImages(t, globalEngine) |
| |
| c := make(chan struct{}) |
| go func() { |
| defer close(c) |
| if err := cli.CmdImages("--viz"); err != nil { |
| t.Fatal(err) |
| } |
| stdoutPipe.Close() |
| }() |
| |
| setTimeout(t, "Reading command output time out", 2*time.Second, func() { |
| cmdOutputBytes, err := ioutil.ReadAll(bufio.NewReader(stdout)) |
| if err != nil { |
| t.Fatal(err) |
| } |
| cmdOutput := string(cmdOutputBytes) |
| |
| regexpStrings := []string{ |
| "digraph docker {", |
| fmt.Sprintf("base -> \"%s\" \\[style=invis]", unitTestImageIDShort), |
| fmt.Sprintf("label=\"%s\\\\n%s:latest\"", unitTestImageIDShort, unitTestImageName), |
| fmt.Sprintf("label=\"%s\\\\n%s:%s\"", utils.TruncateID(image.ID), "test", "latest"), |
| "base \\[style=invisible]", |
| } |
| |
| compiledRegexps := []*regexp.Regexp{} |
| for _, regexpString := range regexpStrings { |
| regexp, err := regexp.Compile(regexpString) |
| if err != nil { |
| fmt.Println("Error in regex string: ", err) |
| return |
| } |
| compiledRegexps = append(compiledRegexps, regexp) |
| } |
| |
| for _, regexp := range compiledRegexps { |
| if !regexp.MatchString(cmdOutput) { |
| t.Fatalf("images --viz content '%s' did not match regexp '%s'", cmdOutput, regexp) |
| } |
| } |
| }) |
| } |
| |
| func TestImagesTree(t *testing.T) { |
| t.Skip("Image tree is deprecated") |
| stdout, stdoutPipe := io.Pipe() |
| |
| cli := client.NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr, nil) |
| defer cleanup(globalEngine, t) |
| |
| image := buildTestImages(t, globalEngine) |
| |
| c := make(chan struct{}) |
| go func() { |
| defer close(c) |
| if err := cli.CmdImages("--tree"); err != nil { |
| t.Fatal(err) |
| } |
| stdoutPipe.Close() |
| }() |
| |
| setTimeout(t, "Reading command output time out", 2*time.Second, func() { |
| cmdOutputBytes, err := ioutil.ReadAll(bufio.NewReader(stdout)) |
| if err != nil { |
| t.Fatal(err) |
| } |
| cmdOutput := string(cmdOutputBytes) |
| regexpStrings := []string{ |
| fmt.Sprintf("└─%s Virtual Size: \\d+.\\d+ MB Tags: %s:latest", unitTestImageIDShort, unitTestImageName), |
| "(?m) └─[0-9a-f]+.*", |
| "(?m) └─[0-9a-f]+.*", |
| "(?m) └─[0-9a-f]+.*", |
| fmt.Sprintf("(?m)^ └─%s Virtual Size: \\d+.\\d+ MB Tags: test:latest", utils.TruncateID(image.ID)), |
| } |
| |
| compiledRegexps := []*regexp.Regexp{} |
| for _, regexpString := range regexpStrings { |
| regexp, err := regexp.Compile(regexpString) |
| if err != nil { |
| fmt.Println("Error in regex string: ", err) |
| return |
| } |
| compiledRegexps = append(compiledRegexps, regexp) |
| } |
| |
| for _, regexp := range compiledRegexps { |
| if !regexp.MatchString(cmdOutput) { |
| t.Fatalf("images --tree content '%s' did not match regexp '%s'", cmdOutput, regexp) |
| } |
| } |
| }) |
| } |
| |
| func buildTestImages(t *testing.T, eng *engine.Engine) *image.Image { |
| |
| var testBuilder = testContextTemplate{ |
| ` |
| from {IMAGE} |
| run sh -c 'echo root:testpass > /tmp/passwd' |
| run mkdir -p /var/run/sshd |
| run [ "$(cat /tmp/passwd)" = "root:testpass" ] |
| run [ "$(ls -d /var/run/sshd)" = "/var/run/sshd" ] |
| `, |
| nil, |
| nil, |
| } |
| image, err := buildImage(testBuilder, t, eng, true) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if err := eng.Job("tag", image.ID, "test").Run(); err != nil { |
| t.Fatal(err) |
| } |
| |
| return image |
| } |
| |
| // #2098 - Docker cidFiles only contain short version of the containerId |
| //sudo docker run --cidfile /tmp/docker_test.cid ubuntu echo "test" |
| // TestRunCidFile tests that run --cidfile returns the longid |
| func TestRunCidFileCheckIDLength(t *testing.T) { |
| stdout, stdoutPipe := io.Pipe() |
| |
| tmpDir, err := ioutil.TempDir("", "TestRunCidFile") |
| if err != nil { |
| t.Fatal(err) |
| } |
| tmpCidFile := path.Join(tmpDir, "cid") |
| |
| cli := client.NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr, nil) |
| defer cleanup(globalEngine, t) |
| |
| c := make(chan struct{}) |
| go func() { |
| defer close(c) |
| if err := cli.CmdRun("--cidfile", tmpCidFile, unitTestImageID, "ls"); err != nil { |
| t.Fatal(err) |
| } |
| }() |
| |
| defer os.RemoveAll(tmpDir) |
| setTimeout(t, "Reading command output time out", 2*time.Second, func() { |
| cmdOutput, err := bufio.NewReader(stdout).ReadString('\n') |
| if err != nil { |
| t.Fatal(err) |
| } |
| if len(cmdOutput) < 1 { |
| t.Fatalf("'ls' should return something , not '%s'", cmdOutput) |
| } |
| //read the tmpCidFile |
| buffer, err := ioutil.ReadFile(tmpCidFile) |
| if err != nil { |
| t.Fatal(err) |
| } |
| id := string(buffer) |
| |
| if len(id) != len("2bf44ea18873287bd9ace8a4cb536a7cbe134bed67e805fdf2f58a57f69b320c") { |
| t.Fatalf("--cidfile should be a long id, not '%s'", id) |
| } |
| //test that its a valid cid? (though the container is gone..) |
| //remove the file and dir. |
| }) |
| |
| setTimeout(t, "CmdRun timed out", 5*time.Second, func() { |
| <-c |
| }) |
| |
| } |
| |
| // Ensure that CIDFile gets deleted if it's empty |
| // Perform this test by making `docker run` fail |
| func TestRunCidFileCleanupIfEmpty(t *testing.T) { |
| tmpDir, err := ioutil.TempDir("", "TestRunCidFile") |
| if err != nil { |
| t.Fatal(err) |
| } |
| tmpCidFile := path.Join(tmpDir, "cid") |
| |
| cli := client.NewDockerCli(nil, ioutil.Discard, ioutil.Discard, testDaemonProto, testDaemonAddr, nil) |
| defer cleanup(globalEngine, t) |
| |
| c := make(chan struct{}) |
| go func() { |
| defer close(c) |
| if err := cli.CmdRun("--cidfile", tmpCidFile, unitTestImageID); err == nil { |
| t.Fatal("running without a command should haveve failed") |
| } |
| if _, err := os.Stat(tmpCidFile); err == nil { |
| t.Fatalf("empty CIDFile '%s' should've been deleted", tmpCidFile) |
| } |
| }() |
| defer os.RemoveAll(tmpDir) |
| |
| setTimeout(t, "CmdRun timed out", 5*time.Second, func() { |
| <-c |
| }) |
| } |
| |
| func TestContainerOrphaning(t *testing.T) { |
| |
| // setup a temporary directory |
| tmpDir, err := ioutil.TempDir("", "project") |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer os.RemoveAll(tmpDir) |
| |
| // setup a CLI and server |
| cli := client.NewDockerCli(nil, ioutil.Discard, ioutil.Discard, testDaemonProto, testDaemonAddr, nil) |
| defer cleanup(globalEngine, t) |
| srv := mkServerFromEngine(globalEngine, t) |
| |
| // closure to build something |
| buildSomething := func(template string, image string) string { |
| dockerfile := path.Join(tmpDir, "Dockerfile") |
| replacer := strings.NewReplacer("{IMAGE}", unitTestImageID) |
| contents := replacer.Replace(template) |
| ioutil.WriteFile(dockerfile, []byte(contents), 0x777) |
| if err := cli.CmdBuild("-t", image, tmpDir); err != nil { |
| t.Fatal(err) |
| } |
| job := globalEngine.Job("image_get", image) |
| info, _ := job.Stdout.AddEnv() |
| if err := job.Run(); err != nil { |
| t.Fatal(err) |
| } |
| return info.Get("Id") |
| } |
| |
| // build an image |
| imageName := "orphan-test" |
| template1 := ` |
| from {IMAGE} |
| cmd ["/bin/echo", "holla"] |
| ` |
| img1 := buildSomething(template1, imageName) |
| |
| // create a container using the fist image |
| if err := cli.CmdRun(imageName); err != nil { |
| t.Fatal(err) |
| } |
| |
| // build a new image that splits lineage |
| template2 := ` |
| from {IMAGE} |
| cmd ["/bin/echo", "holla"] |
| expose 22 |
| ` |
| buildSomething(template2, imageName) |
| |
| // remove the second image by name |
| resp := engine.NewTable("", 0) |
| if err := srv.DeleteImage(imageName, resp, true, false, false); err == nil { |
| t.Fatal("Expected error, got none") |
| } |
| |
| // see if we deleted the first image (and orphaned the container) |
| for _, i := range resp.Data { |
| if img1 == i.Get("Deleted") { |
| t.Fatal("Orphaned image with container") |
| } |
| } |
| |
| } |