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")

}