| package docker |
| |
| import ( |
| "fmt" |
| "github.com/dotcloud/docker/runconfig" |
| "io" |
| "io/ioutil" |
| "os" |
| "path" |
| "strings" |
| "testing" |
| "time" |
| ) |
| |
| func TestKillDifferentUser(t *testing.T) { |
| daemon := mkDaemon(t) |
| defer nuke(daemon) |
| |
| container, _, err := daemon.Create(&runconfig.Config{ |
| Image: GetTestImage(daemon).ID, |
| Cmd: []string{"cat"}, |
| OpenStdin: true, |
| User: "daemon", |
| }, |
| "", |
| ) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer daemon.Destroy(container) |
| // FIXME @shykes: this seems redundant, but is very old, I'm leaving it in case |
| // there is a side effect I'm not seeing. |
| // defer container.stdin.Close() |
| |
| if container.State.IsRunning() { |
| t.Errorf("Container shouldn't be running") |
| } |
| if err := container.Start(); err != nil { |
| t.Fatal(err) |
| } |
| |
| setTimeout(t, "Waiting for the container to be started timed out", 2*time.Second, func() { |
| for !container.State.IsRunning() { |
| time.Sleep(10 * time.Millisecond) |
| } |
| }) |
| |
| setTimeout(t, "read/write assertion timed out", 2*time.Second, func() { |
| out, _ := container.StdoutPipe() |
| in, _ := container.StdinPipe() |
| if err := assertPipe("hello\n", "hello", out, in, 150); err != nil { |
| t.Fatal(err) |
| } |
| }) |
| |
| if err := container.Kill(); err != nil { |
| t.Fatal(err) |
| } |
| |
| if container.State.IsRunning() { |
| t.Errorf("Container shouldn't be running") |
| } |
| container.Wait() |
| if container.State.IsRunning() { |
| t.Errorf("Container shouldn't be running") |
| } |
| // Try stopping twice |
| if err := container.Kill(); err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| func TestRestart(t *testing.T) { |
| daemon := mkDaemon(t) |
| defer nuke(daemon) |
| container, _, err := daemon.Create(&runconfig.Config{ |
| Image: GetTestImage(daemon).ID, |
| Cmd: []string{"echo", "-n", "foobar"}, |
| }, |
| "", |
| ) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer daemon.Destroy(container) |
| output, err := container.Output() |
| if err != nil { |
| t.Fatal(err) |
| } |
| if string(output) != "foobar" { |
| t.Error(string(output)) |
| } |
| |
| // Run the container again and check the output |
| output, err = container.Output() |
| if err != nil { |
| t.Fatal(err) |
| } |
| if string(output) != "foobar" { |
| t.Error(string(output)) |
| } |
| } |
| |
| func TestRestartStdin(t *testing.T) { |
| daemon := mkDaemon(t) |
| defer nuke(daemon) |
| container, _, err := daemon.Create(&runconfig.Config{ |
| Image: GetTestImage(daemon).ID, |
| Cmd: []string{"cat"}, |
| |
| OpenStdin: true, |
| }, |
| "", |
| ) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer daemon.Destroy(container) |
| |
| stdin, err := container.StdinPipe() |
| if err != nil { |
| t.Fatal(err) |
| } |
| stdout, err := container.StdoutPipe() |
| if err != nil { |
| t.Fatal(err) |
| } |
| if err := container.Start(); err != nil { |
| t.Fatal(err) |
| } |
| if _, err := io.WriteString(stdin, "hello world"); err != nil { |
| t.Fatal(err) |
| } |
| if err := stdin.Close(); err != nil { |
| t.Fatal(err) |
| } |
| container.Wait() |
| output, err := ioutil.ReadAll(stdout) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if err := stdout.Close(); err != nil { |
| t.Fatal(err) |
| } |
| if string(output) != "hello world" { |
| t.Fatalf("Unexpected output. Expected %s, received: %s", "hello world", string(output)) |
| } |
| |
| // Restart and try again |
| stdin, err = container.StdinPipe() |
| if err != nil { |
| t.Fatal(err) |
| } |
| stdout, err = container.StdoutPipe() |
| if err != nil { |
| t.Fatal(err) |
| } |
| if err := container.Start(); err != nil { |
| t.Fatal(err) |
| } |
| if _, err := io.WriteString(stdin, "hello world #2"); err != nil { |
| t.Fatal(err) |
| } |
| if err := stdin.Close(); err != nil { |
| t.Fatal(err) |
| } |
| container.Wait() |
| output, err = ioutil.ReadAll(stdout) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if err := stdout.Close(); err != nil { |
| t.Fatal(err) |
| } |
| if string(output) != "hello world #2" { |
| t.Fatalf("Unexpected output. Expected %s, received: %s", "hello world #2", string(output)) |
| } |
| } |
| |
| func TestStdin(t *testing.T) { |
| daemon := mkDaemon(t) |
| defer nuke(daemon) |
| container, _, err := daemon.Create(&runconfig.Config{ |
| Image: GetTestImage(daemon).ID, |
| Cmd: []string{"cat"}, |
| |
| OpenStdin: true, |
| }, |
| "", |
| ) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer daemon.Destroy(container) |
| |
| stdin, err := container.StdinPipe() |
| if err != nil { |
| t.Fatal(err) |
| } |
| stdout, err := container.StdoutPipe() |
| if err != nil { |
| t.Fatal(err) |
| } |
| if err := container.Start(); err != nil { |
| t.Fatal(err) |
| } |
| defer stdin.Close() |
| defer stdout.Close() |
| if _, err := io.WriteString(stdin, "hello world"); err != nil { |
| t.Fatal(err) |
| } |
| if err := stdin.Close(); err != nil { |
| t.Fatal(err) |
| } |
| container.Wait() |
| output, err := ioutil.ReadAll(stdout) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if string(output) != "hello world" { |
| t.Fatalf("Unexpected output. Expected %s, received: %s", "hello world", string(output)) |
| } |
| } |
| |
| func TestTty(t *testing.T) { |
| daemon := mkDaemon(t) |
| defer nuke(daemon) |
| container, _, err := daemon.Create(&runconfig.Config{ |
| Image: GetTestImage(daemon).ID, |
| Cmd: []string{"cat"}, |
| |
| OpenStdin: true, |
| }, |
| "", |
| ) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer daemon.Destroy(container) |
| |
| stdin, err := container.StdinPipe() |
| if err != nil { |
| t.Fatal(err) |
| } |
| stdout, err := container.StdoutPipe() |
| if err != nil { |
| t.Fatal(err) |
| } |
| if err := container.Start(); err != nil { |
| t.Fatal(err) |
| } |
| defer stdin.Close() |
| defer stdout.Close() |
| if _, err := io.WriteString(stdin, "hello world"); err != nil { |
| t.Fatal(err) |
| } |
| if err := stdin.Close(); err != nil { |
| t.Fatal(err) |
| } |
| container.Wait() |
| output, err := ioutil.ReadAll(stdout) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if string(output) != "hello world" { |
| t.Fatalf("Unexpected output. Expected %s, received: %s", "hello world", string(output)) |
| } |
| } |
| |
| func TestEntrypoint(t *testing.T) { |
| daemon := mkDaemon(t) |
| defer nuke(daemon) |
| container, _, err := daemon.Create( |
| &runconfig.Config{ |
| Image: GetTestImage(daemon).ID, |
| Entrypoint: []string{"/bin/echo"}, |
| Cmd: []string{"-n", "foobar"}, |
| }, |
| "", |
| ) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer daemon.Destroy(container) |
| output, err := container.Output() |
| if err != nil { |
| t.Fatal(err) |
| } |
| if string(output) != "foobar" { |
| t.Error(string(output)) |
| } |
| } |
| |
| func TestEntrypointNoCmd(t *testing.T) { |
| daemon := mkDaemon(t) |
| defer nuke(daemon) |
| container, _, err := daemon.Create( |
| &runconfig.Config{ |
| Image: GetTestImage(daemon).ID, |
| Entrypoint: []string{"/bin/echo", "foobar"}, |
| }, |
| "", |
| ) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer daemon.Destroy(container) |
| output, err := container.Output() |
| if err != nil { |
| t.Fatal(err) |
| } |
| if strings.Trim(string(output), "\r\n") != "foobar" { |
| t.Error(string(output)) |
| } |
| } |
| |
| func BenchmarkRunSequential(b *testing.B) { |
| daemon := mkDaemon(b) |
| defer nuke(daemon) |
| for i := 0; i < b.N; i++ { |
| container, _, err := daemon.Create(&runconfig.Config{ |
| Image: GetTestImage(daemon).ID, |
| Cmd: []string{"echo", "-n", "foo"}, |
| }, |
| "", |
| ) |
| if err != nil { |
| b.Fatal(err) |
| } |
| defer daemon.Destroy(container) |
| output, err := container.Output() |
| if err != nil { |
| b.Fatal(err) |
| } |
| if string(output) != "foo" { |
| b.Fatalf("Unexpected output: %s", output) |
| } |
| if err := daemon.Destroy(container); err != nil { |
| b.Fatal(err) |
| } |
| } |
| } |
| |
| func BenchmarkRunParallel(b *testing.B) { |
| daemon := mkDaemon(b) |
| defer nuke(daemon) |
| |
| var tasks []chan error |
| |
| for i := 0; i < b.N; i++ { |
| complete := make(chan error) |
| tasks = append(tasks, complete) |
| go func(i int, complete chan error) { |
| container, _, err := daemon.Create(&runconfig.Config{ |
| Image: GetTestImage(daemon).ID, |
| Cmd: []string{"echo", "-n", "foo"}, |
| }, |
| "", |
| ) |
| if err != nil { |
| complete <- err |
| return |
| } |
| defer daemon.Destroy(container) |
| if err := container.Start(); err != nil { |
| complete <- err |
| return |
| } |
| if err := container.WaitTimeout(15 * time.Second); err != nil { |
| complete <- err |
| return |
| } |
| // if string(output) != "foo" { |
| // complete <- fmt.Errorf("Unexecpted output: %v", string(output)) |
| // } |
| if err := daemon.Destroy(container); err != nil { |
| complete <- err |
| return |
| } |
| complete <- nil |
| }(i, complete) |
| } |
| var errors []error |
| for _, task := range tasks { |
| err := <-task |
| if err != nil { |
| errors = append(errors, err) |
| } |
| } |
| if len(errors) > 0 { |
| b.Fatal(errors) |
| } |
| } |
| |
| func tempDir(t *testing.T) string { |
| tmpDir, err := ioutil.TempDir("", "docker-test-container") |
| if err != nil { |
| t.Fatal(err) |
| } |
| return tmpDir |
| } |
| |
| // Test for #1737 |
| func TestCopyVolumeUidGid(t *testing.T) { |
| eng := NewTestEngine(t) |
| r := mkDaemonFromEngine(eng, t) |
| defer r.Nuke() |
| |
| // Add directory not owned by root |
| container1, _, _ := mkContainer(r, []string{"_", "/bin/sh", "-c", "mkdir -p /hello && touch /hello/test && chown daemon.daemon /hello"}, t) |
| defer r.Destroy(container1) |
| |
| if container1.State.IsRunning() { |
| t.Errorf("Container shouldn't be running") |
| } |
| if err := container1.Run(); err != nil { |
| t.Fatal(err) |
| } |
| if container1.State.IsRunning() { |
| t.Errorf("Container shouldn't be running") |
| } |
| |
| img, err := r.Commit(container1, "", "", "unit test commited image", "", nil) |
| if err != nil { |
| t.Error(err) |
| } |
| |
| // Test that the uid and gid is copied from the image to the volume |
| tmpDir1 := tempDir(t) |
| defer os.RemoveAll(tmpDir1) |
| stdout1, _ := runContainer(eng, r, []string{"-v", "/hello", img.ID, "stat", "-c", "%U %G", "/hello"}, t) |
| if !strings.Contains(stdout1, "daemon daemon") { |
| t.Fatal("Container failed to transfer uid and gid to volume") |
| } |
| |
| container2, _, _ := mkContainer(r, []string{"_", "/bin/sh", "-c", "mkdir -p /hello && chown daemon.daemon /hello"}, t) |
| defer r.Destroy(container1) |
| |
| if container2.State.IsRunning() { |
| t.Errorf("Container shouldn't be running") |
| } |
| if err := container2.Run(); err != nil { |
| t.Fatal(err) |
| } |
| if container2.State.IsRunning() { |
| t.Errorf("Container shouldn't be running") |
| } |
| |
| img2, err := r.Commit(container2, "", "", "unit test commited image", "", nil) |
| if err != nil { |
| t.Error(err) |
| } |
| |
| // Test that the uid and gid is copied from the image to the volume |
| tmpDir2 := tempDir(t) |
| defer os.RemoveAll(tmpDir2) |
| stdout2, _ := runContainer(eng, r, []string{"-v", "/hello", img2.ID, "stat", "-c", "%U %G", "/hello"}, t) |
| if !strings.Contains(stdout2, "daemon daemon") { |
| t.Fatal("Container failed to transfer uid and gid to volume") |
| } |
| } |
| |
| // Test for #1582 |
| func TestCopyVolumeContent(t *testing.T) { |
| eng := NewTestEngine(t) |
| r := mkDaemonFromEngine(eng, t) |
| defer r.Nuke() |
| |
| // Put some content in a directory of a container and commit it |
| container1, _, _ := mkContainer(r, []string{"_", "/bin/sh", "-c", "mkdir -p /hello/local && echo hello > /hello/local/world"}, t) |
| defer r.Destroy(container1) |
| |
| if container1.State.IsRunning() { |
| t.Errorf("Container shouldn't be running") |
| } |
| if err := container1.Run(); err != nil { |
| t.Fatal(err) |
| } |
| if container1.State.IsRunning() { |
| t.Errorf("Container shouldn't be running") |
| } |
| |
| img, err := r.Commit(container1, "", "", "unit test commited image", "", nil) |
| if err != nil { |
| t.Error(err) |
| } |
| |
| // Test that the content is copied from the image to the volume |
| tmpDir1 := tempDir(t) |
| defer os.RemoveAll(tmpDir1) |
| stdout1, _ := runContainer(eng, r, []string{"-v", "/hello", img.ID, "find", "/hello"}, t) |
| if !(strings.Contains(stdout1, "/hello/local/world") && strings.Contains(stdout1, "/hello/local")) { |
| t.Fatal("Container failed to transfer content to volume") |
| } |
| } |
| |
| func TestBindMounts(t *testing.T) { |
| eng := NewTestEngine(t) |
| r := mkDaemonFromEngine(eng, t) |
| defer r.Nuke() |
| |
| tmpDir := tempDir(t) |
| defer os.RemoveAll(tmpDir) |
| writeFile(path.Join(tmpDir, "touch-me"), "", t) |
| |
| // Test reading from a read-only bind mount |
| stdout, _ := runContainer(eng, r, []string{"-v", fmt.Sprintf("%s:/tmp:ro", tmpDir), "_", "ls", "/tmp"}, t) |
| if !strings.Contains(stdout, "touch-me") { |
| t.Fatal("Container failed to read from bind mount") |
| } |
| |
| // test writing to bind mount |
| runContainer(eng, r, []string{"-v", fmt.Sprintf("%s:/tmp:rw", tmpDir), "_", "touch", "/tmp/holla"}, t) |
| readFile(path.Join(tmpDir, "holla"), t) // Will fail if the file doesn't exist |
| |
| // test mounting to an illegal destination directory |
| if _, err := runContainer(eng, r, []string{"-v", fmt.Sprintf("%s:.", tmpDir), "_", "ls", "."}, nil); err == nil { |
| t.Fatal("Container bind mounted illegal directory") |
| } |
| |
| // test mount a file |
| runContainer(eng, r, []string{"-v", fmt.Sprintf("%s/holla:/tmp/holla:rw", tmpDir), "_", "sh", "-c", "echo -n 'yotta' > /tmp/holla"}, t) |
| content := readFile(path.Join(tmpDir, "holla"), t) // Will fail if the file doesn't exist |
| if content != "yotta" { |
| t.Fatal("Container failed to write to bind mount file") |
| } |
| } |
| |
| // Test that restarting a container with a volume does not create a new volume on restart. Regression test for #819. |
| func TestRestartWithVolumes(t *testing.T) { |
| daemon := mkDaemon(t) |
| defer nuke(daemon) |
| |
| container, _, err := daemon.Create(&runconfig.Config{ |
| Image: GetTestImage(daemon).ID, |
| Cmd: []string{"echo", "-n", "foobar"}, |
| Volumes: map[string]struct{}{"/test": {}}, |
| }, |
| "", |
| ) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer daemon.Destroy(container) |
| |
| for key := range container.Config.Volumes { |
| if key != "/test" { |
| t.Fail() |
| } |
| } |
| |
| _, err = container.Output() |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| expected := container.Volumes["/test"] |
| if expected == "" { |
| t.Fail() |
| } |
| // Run the container again to verify the volume path persists |
| _, err = container.Output() |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| actual := container.Volumes["/test"] |
| if expected != actual { |
| t.Fatalf("Expected volume path: %s Actual path: %s", expected, actual) |
| } |
| } |