| package main |
| |
| import ( |
| "bytes" |
| "encoding/json" |
| "io" |
| "os/exec" |
| "strings" |
| "testing" |
| "time" |
| |
| "github.com/docker/docker/api/types" |
| "github.com/docker/docker/vendor/src/code.google.com/p/go/src/pkg/archive/tar" |
| ) |
| |
| func TestContainerApiGetAll(t *testing.T) { |
| defer deleteAllContainers() |
| |
| startCount, err := getContainerCount() |
| if err != nil { |
| t.Fatalf("Cannot query container count: %v", err) |
| } |
| |
| name := "getall" |
| runCmd := exec.Command(dockerBinary, "run", "--name", name, "busybox", "true") |
| out, _, err := runCommandWithOutput(runCmd) |
| if err != nil { |
| t.Fatalf("Error on container creation: %v, output: %q", err, out) |
| } |
| |
| body, err := sockRequest("GET", "/containers/json?all=1", nil) |
| if err != nil { |
| t.Fatalf("GET all containers sockRequest failed: %v", err) |
| } |
| |
| var inspectJSON []struct { |
| Names []string |
| } |
| if err = json.Unmarshal(body, &inspectJSON); err != nil { |
| t.Fatalf("unable to unmarshal response body: %v", err) |
| } |
| |
| if len(inspectJSON) != startCount+1 { |
| t.Fatalf("Expected %d container(s), %d found (started with: %d)", startCount+1, len(inspectJSON), startCount) |
| } |
| |
| if actual := inspectJSON[0].Names[0]; actual != "/"+name { |
| t.Fatalf("Container Name mismatch. Expected: %q, received: %q\n", "/"+name, actual) |
| } |
| |
| logDone("container REST API - check GET json/all=1") |
| } |
| |
| func TestContainerApiGetExport(t *testing.T) { |
| defer deleteAllContainers() |
| |
| name := "exportcontainer" |
| runCmd := exec.Command(dockerBinary, "run", "--name", name, "busybox", "touch", "/test") |
| out, _, err := runCommandWithOutput(runCmd) |
| if err != nil { |
| t.Fatalf("Error on container creation: %v, output: %q", err, out) |
| } |
| |
| body, err := sockRequest("GET", "/containers/"+name+"/export", nil) |
| if err != nil { |
| t.Fatalf("GET containers/export sockRequest failed: %v", err) |
| } |
| |
| found := false |
| for tarReader := tar.NewReader(bytes.NewReader(body)); ; { |
| h, err := tarReader.Next() |
| if err != nil { |
| if err == io.EOF { |
| break |
| } |
| t.Fatal(err) |
| } |
| if h.Name == "test" { |
| found = true |
| break |
| } |
| } |
| |
| if !found { |
| t.Fatalf("The created test file has not been found in the exported image") |
| } |
| |
| logDone("container REST API - check GET containers/export") |
| } |
| |
| func TestContainerApiGetChanges(t *testing.T) { |
| defer deleteAllContainers() |
| |
| name := "changescontainer" |
| runCmd := exec.Command(dockerBinary, "run", "--name", name, "busybox", "rm", "/etc/passwd") |
| out, _, err := runCommandWithOutput(runCmd) |
| if err != nil { |
| t.Fatalf("Error on container creation: %v, output: %q", err, out) |
| } |
| |
| body, err := sockRequest("GET", "/containers/"+name+"/changes", nil) |
| if err != nil { |
| t.Fatalf("GET containers/changes sockRequest failed: %v", err) |
| } |
| |
| changes := []struct { |
| Kind int |
| Path string |
| }{} |
| if err = json.Unmarshal(body, &changes); err != nil { |
| t.Fatalf("unable to unmarshal response body: %v", err) |
| } |
| |
| // Check the changelog for removal of /etc/passwd |
| success := false |
| for _, elem := range changes { |
| if elem.Path == "/etc/passwd" && elem.Kind == 2 { |
| success = true |
| } |
| } |
| if !success { |
| t.Fatalf("/etc/passwd has been removed but is not present in the diff") |
| } |
| |
| logDone("container REST API - check GET containers/changes") |
| } |
| |
| func TestContainerApiStartVolumeBinds(t *testing.T) { |
| defer deleteAllContainers() |
| name := "testing" |
| config := map[string]interface{}{ |
| "Image": "busybox", |
| "Volumes": map[string]struct{}{"/tmp": {}}, |
| } |
| |
| if _, err := sockRequest("POST", "/containers/create?name="+name, config); err != nil && !strings.Contains(err.Error(), "201 Created") { |
| t.Fatal(err) |
| } |
| |
| bindPath := randomUnixTmpDirPath("test") |
| config = map[string]interface{}{ |
| "Binds": []string{bindPath + ":/tmp"}, |
| } |
| if _, err := sockRequest("POST", "/containers/"+name+"/start", config); err != nil && !strings.Contains(err.Error(), "204 No Content") { |
| t.Fatal(err) |
| } |
| |
| pth, err := inspectFieldMap(name, "Volumes", "/tmp") |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if pth != bindPath { |
| t.Fatalf("expected volume host path to be %s, got %s", bindPath, pth) |
| } |
| |
| logDone("container REST API - check volume binds on start") |
| } |
| |
| // Test for GH#10618 |
| func TestContainerApiStartDupVolumeBinds(t *testing.T) { |
| defer deleteAllContainers() |
| name := "testdups" |
| config := map[string]interface{}{ |
| "Image": "busybox", |
| "Volumes": map[string]struct{}{"/tmp": {}}, |
| } |
| |
| if _, err := sockRequest("POST", "/containers/create?name="+name, config); err != nil && !strings.Contains(err.Error(), "201 Created") { |
| t.Fatal(err) |
| } |
| |
| bindPath1 := randomUnixTmpDirPath("test1") |
| bindPath2 := randomUnixTmpDirPath("test2") |
| |
| config = map[string]interface{}{ |
| "Binds": []string{bindPath1 + ":/tmp", bindPath2 + ":/tmp"}, |
| } |
| if body, err := sockRequest("POST", "/containers/"+name+"/start", config); err == nil { |
| t.Fatal("expected container start to fail when duplicate volume binds to same container path") |
| } else { |
| if !strings.Contains(string(body), "Duplicate volume") { |
| t.Fatalf("Expected failure due to duplicate bind mounts to same path, instead got: %q with error: %v", string(body), err) |
| } |
| } |
| |
| logDone("container REST API - check for duplicate volume binds error on start") |
| } |
| func TestContainerApiStartVolumesFrom(t *testing.T) { |
| defer deleteAllContainers() |
| volName := "voltst" |
| volPath := "/tmp" |
| |
| if out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "run", "-d", "--name", volName, "-v", volPath, "busybox")); err != nil { |
| t.Fatal(out, err) |
| } |
| |
| name := "testing" |
| config := map[string]interface{}{ |
| "Image": "busybox", |
| "Volumes": map[string]struct{}{volPath: {}}, |
| } |
| |
| if _, err := sockRequest("POST", "/containers/create?name="+name, config); err != nil && !strings.Contains(err.Error(), "201 Created") { |
| t.Fatal(err) |
| } |
| |
| config = map[string]interface{}{ |
| "VolumesFrom": []string{volName}, |
| } |
| if _, err := sockRequest("POST", "/containers/"+name+"/start", config); err != nil && !strings.Contains(err.Error(), "204 No Content") { |
| t.Fatal(err) |
| } |
| |
| pth, err := inspectFieldMap(name, "Volumes", volPath) |
| if err != nil { |
| t.Fatal(err) |
| } |
| pth2, err := inspectFieldMap(volName, "Volumes", volPath) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if pth != pth2 { |
| t.Fatalf("expected volume host path to be %s, got %s", pth, pth2) |
| } |
| |
| logDone("container REST API - check VolumesFrom on start") |
| } |
| |
| // Ensure that volumes-from has priority over binds/anything else |
| // This is pretty much the same as TestRunApplyVolumesFromBeforeVolumes, except with passing the VolumesFrom and the bind on start |
| func TestVolumesFromHasPriority(t *testing.T) { |
| defer deleteAllContainers() |
| volName := "voltst" |
| volPath := "/tmp" |
| |
| if out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "run", "-d", "--name", volName, "-v", volPath, "busybox")); err != nil { |
| t.Fatal(out, err) |
| } |
| |
| name := "testing" |
| config := map[string]interface{}{ |
| "Image": "busybox", |
| "Volumes": map[string]struct{}{volPath: {}}, |
| } |
| |
| if _, err := sockRequest("POST", "/containers/create?name="+name, config); err != nil && !strings.Contains(err.Error(), "201 Created") { |
| t.Fatal(err) |
| } |
| |
| bindPath := randomUnixTmpDirPath("test") |
| config = map[string]interface{}{ |
| "VolumesFrom": []string{volName}, |
| "Binds": []string{bindPath + ":/tmp"}, |
| } |
| if _, err := sockRequest("POST", "/containers/"+name+"/start", config); err != nil && !strings.Contains(err.Error(), "204 No Content") { |
| t.Fatal(err) |
| } |
| |
| pth, err := inspectFieldMap(name, "Volumes", volPath) |
| if err != nil { |
| t.Fatal(err) |
| } |
| pth2, err := inspectFieldMap(volName, "Volumes", volPath) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if pth != pth2 { |
| t.Fatalf("expected volume host path to be %s, got %s", pth, pth2) |
| } |
| |
| logDone("container REST API - check VolumesFrom has priority") |
| } |
| |
| func TestGetContainerStats(t *testing.T) { |
| defer deleteAllContainers() |
| var ( |
| name = "statscontainer" |
| runCmd = exec.Command(dockerBinary, "run", "-d", "--name", name, "busybox", "top") |
| ) |
| out, _, err := runCommandWithOutput(runCmd) |
| if err != nil { |
| t.Fatalf("Error on container creation: %v, output: %q", err, out) |
| } |
| type b struct { |
| body []byte |
| err error |
| } |
| bc := make(chan b, 1) |
| go func() { |
| body, err := sockRequest("GET", "/containers/"+name+"/stats", nil) |
| bc <- b{body, err} |
| }() |
| |
| // allow some time to stream the stats from the container |
| time.Sleep(4 * time.Second) |
| if _, err := runCommand(exec.Command(dockerBinary, "rm", "-f", name)); err != nil { |
| t.Fatal(err) |
| } |
| |
| // collect the results from the stats stream or timeout and fail |
| // if the stream was not disconnected. |
| select { |
| case <-time.After(2 * time.Second): |
| t.Fatal("stream was not closed after container was removed") |
| case sr := <-bc: |
| if sr.err != nil { |
| t.Fatal(sr.err) |
| } |
| |
| dec := json.NewDecoder(bytes.NewBuffer(sr.body)) |
| var s *types.Stats |
| // decode only one object from the stream |
| if err := dec.Decode(&s); err != nil { |
| t.Fatal(err) |
| } |
| } |
| logDone("container REST API - check GET containers/stats") |
| } |
| |
| func TestGetStoppedContainerStats(t *testing.T) { |
| defer deleteAllContainers() |
| var ( |
| name = "statscontainer" |
| runCmd = exec.Command(dockerBinary, "create", "--name", name, "busybox", "top") |
| ) |
| out, _, err := runCommandWithOutput(runCmd) |
| if err != nil { |
| t.Fatalf("Error on container creation: %v, output: %q", err, out) |
| } |
| |
| go func() { |
| // We'll never get return for GET stats from sockRequest as of now, |
| // just send request and see if panic or error would happen on daemon side. |
| _, err := sockRequest("GET", "/containers/"+name+"/stats", nil) |
| if err != nil { |
| t.Fatal(err) |
| } |
| }() |
| |
| // allow some time to send request and let daemon deal with it |
| time.Sleep(1 * time.Second) |
| |
| logDone("container REST API - check GET stopped containers/stats") |
| } |
| |
| func TestBuildApiDockerfilePath(t *testing.T) { |
| // Test to make sure we stop people from trying to leave the |
| // build context when specifying the path to the dockerfile |
| buffer := new(bytes.Buffer) |
| tw := tar.NewWriter(buffer) |
| defer tw.Close() |
| |
| dockerfile := []byte("FROM busybox") |
| if err := tw.WriteHeader(&tar.Header{ |
| Name: "Dockerfile", |
| Size: int64(len(dockerfile)), |
| }); err != nil { |
| t.Fatalf("failed to write tar file header: %v", err) |
| } |
| if _, err := tw.Write(dockerfile); err != nil { |
| t.Fatalf("failed to write tar file content: %v", err) |
| } |
| if err := tw.Close(); err != nil { |
| t.Fatalf("failed to close tar archive: %v", err) |
| } |
| |
| out, err := sockRequestRaw("POST", "/build?dockerfile=../Dockerfile", buffer, "application/x-tar") |
| if err == nil { |
| t.Fatalf("Build was supposed to fail: %s", out) |
| } |
| |
| if !strings.Contains(string(out), "must be within the build context") { |
| t.Fatalf("Didn't complain about leaving build context: %s", out) |
| } |
| |
| logDone("container REST API - check build w/bad Dockerfile path") |
| } |
| |
| func TestBuildApiDockerFileRemote(t *testing.T) { |
| server, err := fakeStorage(map[string]string{ |
| "testD": `FROM busybox |
| COPY * /tmp/ |
| RUN find / -name ba* |
| RUN find /tmp/`, |
| }) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer server.Close() |
| |
| buf, err := sockRequestRaw("POST", "/build?dockerfile=baz&remote="+server.URL()+"/testD", nil, "application/json") |
| if err != nil { |
| t.Fatalf("Build failed: %s", err) |
| } |
| |
| // Make sure Dockerfile exists. |
| // Make sure 'baz' doesn't exist ANYWHERE despite being mentioned in the URL |
| out := string(buf) |
| if !strings.Contains(out, "/tmp/Dockerfile") || |
| strings.Contains(out, "baz") { |
| t.Fatalf("Incorrect output: %s", out) |
| } |
| |
| logDone("container REST API - check build with -f from remote") |
| } |
| |
| func TestBuildApiLowerDockerfile(t *testing.T) { |
| git, err := fakeGIT("repo", map[string]string{ |
| "dockerfile": `FROM busybox |
| RUN echo from dockerfile`, |
| }, false) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer git.Close() |
| |
| buf, err := sockRequestRaw("POST", "/build?remote="+git.RepoURL, nil, "application/json") |
| if err != nil { |
| t.Fatalf("Build failed: %s\n%q", err, buf) |
| } |
| |
| out := string(buf) |
| if !strings.Contains(out, "from dockerfile") { |
| t.Fatalf("Incorrect output: %s", out) |
| } |
| |
| logDone("container REST API - check build with lower dockerfile") |
| } |
| |
| func TestBuildApiBuildGitWithF(t *testing.T) { |
| git, err := fakeGIT("repo", map[string]string{ |
| "baz": `FROM busybox |
| RUN echo from baz`, |
| "Dockerfile": `FROM busybox |
| RUN echo from Dockerfile`, |
| }, false) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer git.Close() |
| |
| // Make sure it tries to 'dockerfile' query param value |
| buf, err := sockRequestRaw("POST", "/build?dockerfile=baz&remote="+git.RepoURL, nil, "application/json") |
| if err != nil { |
| t.Fatalf("Build failed: %s\n%q", err, buf) |
| } |
| |
| out := string(buf) |
| if !strings.Contains(out, "from baz") { |
| t.Fatalf("Incorrect output: %s", out) |
| } |
| |
| logDone("container REST API - check build from git w/F") |
| } |
| |
| func TestBuildApiDoubleDockerfile(t *testing.T) { |
| testRequires(t, UnixCli) // dockerfile overwrites Dockerfile on Windows |
| git, err := fakeGIT("repo", map[string]string{ |
| "Dockerfile": `FROM busybox |
| RUN echo from Dockerfile`, |
| "dockerfile": `FROM busybox |
| RUN echo from dockerfile`, |
| }, false) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer git.Close() |
| |
| // Make sure it tries to 'dockerfile' query param value |
| buf, err := sockRequestRaw("POST", "/build?remote="+git.RepoURL, nil, "application/json") |
| if err != nil { |
| t.Fatalf("Build failed: %s", err) |
| } |
| |
| out := string(buf) |
| if !strings.Contains(out, "from Dockerfile") { |
| t.Fatalf("Incorrect output: %s", out) |
| } |
| |
| logDone("container REST API - check build with two dockerfiles") |
| } |
| |
| func TestBuildApiDockerfileSymlink(t *testing.T) { |
| // Test to make sure we stop people from trying to leave the |
| // build context when specifying a symlink as the path to the dockerfile |
| buffer := new(bytes.Buffer) |
| tw := tar.NewWriter(buffer) |
| defer tw.Close() |
| |
| if err := tw.WriteHeader(&tar.Header{ |
| Name: "Dockerfile", |
| Typeflag: tar.TypeSymlink, |
| Linkname: "/etc/passwd", |
| }); err != nil { |
| t.Fatalf("failed to write tar file header: %v", err) |
| } |
| if err := tw.Close(); err != nil { |
| t.Fatalf("failed to close tar archive: %v", err) |
| } |
| |
| out, err := sockRequestRaw("POST", "/build", buffer, "application/x-tar") |
| if err == nil { |
| t.Fatalf("Build was supposed to fail: %s", out) |
| } |
| |
| // The reason the error is "Cannot locate specified Dockerfile" is because |
| // in the builder, the symlink is resolved within the context, therefore |
| // Dockerfile -> /etc/passwd becomes etc/passwd from the context which is |
| // a nonexistent file. |
| if !strings.Contains(string(out), "Cannot locate specified Dockerfile: Dockerfile") { |
| t.Fatalf("Didn't complain about leaving build context: %s", out) |
| } |
| |
| logDone("container REST API - check build w/bad Dockerfile symlink path") |
| } |
| |
| // #9981 - Allow a docker created volume (ie, one in /var/lib/docker/volumes) to be used to overwrite (via passing in Binds on api start) an existing volume |
| func TestPostContainerBindNormalVolume(t *testing.T) { |
| defer deleteAllContainers() |
| |
| out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "create", "-v", "/foo", "--name=one", "busybox")) |
| if err != nil { |
| t.Fatal(err, out) |
| } |
| |
| fooDir, err := inspectFieldMap("one", "Volumes", "/foo") |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| out, _, err = runCommandWithOutput(exec.Command(dockerBinary, "create", "-v", "/foo", "--name=two", "busybox")) |
| if err != nil { |
| t.Fatal(err, out) |
| } |
| |
| bindSpec := map[string][]string{"Binds": {fooDir + ":/foo"}} |
| _, err = sockRequest("POST", "/containers/two/start", bindSpec) |
| if err != nil && !strings.Contains(err.Error(), "204 No Content") { |
| t.Fatal(err) |
| } |
| |
| fooDir2, err := inspectFieldMap("two", "Volumes", "/foo") |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if fooDir2 != fooDir { |
| t.Fatal("expected volume path to be %s, got: %s", fooDir, fooDir2) |
| } |
| |
| logDone("container REST API - can use path from normal volume as bind-mount to overwrite another volume") |
| } |