| package main |
| |
| import ( |
| "fmt" |
| "io/ioutil" |
| "os" |
| "os/exec" |
| "path/filepath" |
| "strings" |
| |
| "github.com/docker/docker/pkg/integration/checker" |
| icmd "github.com/docker/docker/pkg/integration/cmd" |
| "github.com/go-check/check" |
| ) |
| |
| func (s *DockerSuite) TestVolumeCLICreate(c *check.C) { |
| dockerCmd(c, "volume", "create") |
| |
| _, err := runCommand(exec.Command(dockerBinary, "volume", "create", "-d", "nosuchdriver")) |
| c.Assert(err, check.Not(check.IsNil)) |
| |
| // test using hidden --name option |
| out, _ := dockerCmd(c, "volume", "create", "--name=test") |
| name := strings.TrimSpace(out) |
| c.Assert(name, check.Equals, "test") |
| |
| out, _ = dockerCmd(c, "volume", "create", "test2") |
| name = strings.TrimSpace(out) |
| c.Assert(name, check.Equals, "test2") |
| } |
| |
| func (s *DockerSuite) TestVolumeCLIInspect(c *check.C) { |
| c.Assert( |
| exec.Command(dockerBinary, "volume", "inspect", "doesntexist").Run(), |
| check.Not(check.IsNil), |
| check.Commentf("volume inspect should error on non-existent volume"), |
| ) |
| |
| out, _ := dockerCmd(c, "volume", "create") |
| name := strings.TrimSpace(out) |
| out, _ = dockerCmd(c, "volume", "inspect", "--format={{ .Name }}", name) |
| c.Assert(strings.TrimSpace(out), check.Equals, name) |
| |
| dockerCmd(c, "volume", "create", "test") |
| out, _ = dockerCmd(c, "volume", "inspect", "--format={{ .Name }}", "test") |
| c.Assert(strings.TrimSpace(out), check.Equals, "test") |
| } |
| |
| func (s *DockerSuite) TestVolumeCLIInspectMulti(c *check.C) { |
| dockerCmd(c, "volume", "create", "test1") |
| dockerCmd(c, "volume", "create", "test2") |
| dockerCmd(c, "volume", "create", "not-shown") |
| |
| result := dockerCmdWithResult("volume", "inspect", "--format={{ .Name }}", "test1", "test2", "doesntexist", "not-shown") |
| c.Assert(result, icmd.Matches, icmd.Expected{ |
| ExitCode: 1, |
| Err: "No such volume: doesntexist", |
| }) |
| |
| out := result.Stdout() |
| outArr := strings.Split(strings.TrimSpace(out), "\n") |
| c.Assert(len(outArr), check.Equals, 2, check.Commentf("\n%s", out)) |
| |
| c.Assert(out, checker.Contains, "test1") |
| c.Assert(out, checker.Contains, "test2") |
| c.Assert(out, checker.Not(checker.Contains), "not-shown") |
| } |
| |
| func (s *DockerSuite) TestVolumeCLILs(c *check.C) { |
| prefix, _ := getPrefixAndSlashFromDaemonPlatform() |
| dockerCmd(c, "volume", "create", "aaa") |
| |
| dockerCmd(c, "volume", "create", "test") |
| |
| dockerCmd(c, "volume", "create", "soo") |
| dockerCmd(c, "run", "-v", "soo:"+prefix+"/foo", "busybox", "ls", "/") |
| |
| out, _ := dockerCmd(c, "volume", "ls") |
| outArr := strings.Split(strings.TrimSpace(out), "\n") |
| c.Assert(len(outArr), check.Equals, 4, check.Commentf("\n%s", out)) |
| |
| assertVolList(c, out, []string{"aaa", "soo", "test"}) |
| } |
| |
| func (s *DockerSuite) TestVolumeLsFormat(c *check.C) { |
| dockerCmd(c, "volume", "create", "aaa") |
| dockerCmd(c, "volume", "create", "test") |
| dockerCmd(c, "volume", "create", "soo") |
| |
| out, _ := dockerCmd(c, "volume", "ls", "--format", "{{.Name}}") |
| lines := strings.Split(strings.TrimSpace(string(out)), "\n") |
| |
| expected := []string{"aaa", "soo", "test"} |
| var names []string |
| names = append(names, lines...) |
| c.Assert(expected, checker.DeepEquals, names, check.Commentf("Expected array with truncated names: %v, got: %v", expected, names)) |
| } |
| |
| func (s *DockerSuite) TestVolumeLsFormatDefaultFormat(c *check.C) { |
| dockerCmd(c, "volume", "create", "aaa") |
| dockerCmd(c, "volume", "create", "test") |
| dockerCmd(c, "volume", "create", "soo") |
| |
| config := `{ |
| "volumesFormat": "{{ .Name }} default" |
| }` |
| d, err := ioutil.TempDir("", "integration-cli-") |
| c.Assert(err, checker.IsNil) |
| defer os.RemoveAll(d) |
| |
| err = ioutil.WriteFile(filepath.Join(d, "config.json"), []byte(config), 0644) |
| c.Assert(err, checker.IsNil) |
| |
| out, _ := dockerCmd(c, "--config", d, "volume", "ls") |
| lines := strings.Split(strings.TrimSpace(string(out)), "\n") |
| |
| expected := []string{"aaa default", "soo default", "test default"} |
| var names []string |
| names = append(names, lines...) |
| c.Assert(expected, checker.DeepEquals, names, check.Commentf("Expected array with truncated names: %v, got: %v", expected, names)) |
| } |
| |
| // assertVolList checks volume retrieved with ls command |
| // equals to expected volume list |
| // note: out should be `volume ls [option]` result |
| func assertVolList(c *check.C, out string, expectVols []string) { |
| lines := strings.Split(out, "\n") |
| var volList []string |
| for _, line := range lines[1 : len(lines)-1] { |
| volFields := strings.Fields(line) |
| // wrap all volume name in volList |
| volList = append(volList, volFields[1]) |
| } |
| |
| // volume ls should contains all expected volumes |
| c.Assert(volList, checker.DeepEquals, expectVols) |
| } |
| |
| func (s *DockerSuite) TestVolumeCLILsFilterDangling(c *check.C) { |
| prefix, _ := getPrefixAndSlashFromDaemonPlatform() |
| dockerCmd(c, "volume", "create", "testnotinuse1") |
| dockerCmd(c, "volume", "create", "testisinuse1") |
| dockerCmd(c, "volume", "create", "testisinuse2") |
| |
| // Make sure both "created" (but not started), and started |
| // containers are included in reference counting |
| dockerCmd(c, "run", "--name", "volume-test1", "-v", "testisinuse1:"+prefix+"/foo", "busybox", "true") |
| dockerCmd(c, "create", "--name", "volume-test2", "-v", "testisinuse2:"+prefix+"/foo", "busybox", "true") |
| |
| out, _ := dockerCmd(c, "volume", "ls") |
| |
| // No filter, all volumes should show |
| c.Assert(out, checker.Contains, "testnotinuse1\n", check.Commentf("expected volume 'testnotinuse1' in output")) |
| c.Assert(out, checker.Contains, "testisinuse1\n", check.Commentf("expected volume 'testisinuse1' in output")) |
| c.Assert(out, checker.Contains, "testisinuse2\n", check.Commentf("expected volume 'testisinuse2' in output")) |
| |
| out, _ = dockerCmd(c, "volume", "ls", "--filter", "dangling=false") |
| |
| // Explicitly disabling dangling |
| c.Assert(out, check.Not(checker.Contains), "testnotinuse1\n", check.Commentf("expected volume 'testnotinuse1' in output")) |
| c.Assert(out, checker.Contains, "testisinuse1\n", check.Commentf("expected volume 'testisinuse1' in output")) |
| c.Assert(out, checker.Contains, "testisinuse2\n", check.Commentf("expected volume 'testisinuse2' in output")) |
| |
| out, _ = dockerCmd(c, "volume", "ls", "--filter", "dangling=true") |
| |
| // Filter "dangling" volumes; only "dangling" (unused) volumes should be in the output |
| c.Assert(out, checker.Contains, "testnotinuse1\n", check.Commentf("expected volume 'testnotinuse1' in output")) |
| c.Assert(out, check.Not(checker.Contains), "testisinuse1\n", check.Commentf("volume 'testisinuse1' in output, but not expected")) |
| c.Assert(out, check.Not(checker.Contains), "testisinuse2\n", check.Commentf("volume 'testisinuse2' in output, but not expected")) |
| |
| out, _ = dockerCmd(c, "volume", "ls", "--filter", "dangling=1") |
| // Filter "dangling" volumes; only "dangling" (unused) volumes should be in the output, dangling also accept 1 |
| c.Assert(out, checker.Contains, "testnotinuse1\n", check.Commentf("expected volume 'testnotinuse1' in output")) |
| c.Assert(out, check.Not(checker.Contains), "testisinuse1\n", check.Commentf("volume 'testisinuse1' in output, but not expected")) |
| c.Assert(out, check.Not(checker.Contains), "testisinuse2\n", check.Commentf("volume 'testisinuse2' in output, but not expected")) |
| |
| out, _ = dockerCmd(c, "volume", "ls", "--filter", "dangling=0") |
| // dangling=0 is same as dangling=false case |
| c.Assert(out, check.Not(checker.Contains), "testnotinuse1\n", check.Commentf("expected volume 'testnotinuse1' in output")) |
| c.Assert(out, checker.Contains, "testisinuse1\n", check.Commentf("expected volume 'testisinuse1' in output")) |
| c.Assert(out, checker.Contains, "testisinuse2\n", check.Commentf("expected volume 'testisinuse2' in output")) |
| |
| out, _ = dockerCmd(c, "volume", "ls", "--filter", "name=testisin") |
| c.Assert(out, check.Not(checker.Contains), "testnotinuse1\n", check.Commentf("expected volume 'testnotinuse1' in output")) |
| c.Assert(out, checker.Contains, "testisinuse1\n", check.Commentf("execpeted volume 'testisinuse1' in output")) |
| c.Assert(out, checker.Contains, "testisinuse2\n", check.Commentf("expected volume 'testisinuse2' in output")) |
| |
| out, _ = dockerCmd(c, "volume", "ls", "--filter", "driver=invalidDriver") |
| outArr := strings.Split(strings.TrimSpace(out), "\n") |
| c.Assert(len(outArr), check.Equals, 1, check.Commentf("%s\n", out)) |
| |
| out, _ = dockerCmd(c, "volume", "ls", "--filter", "driver=local") |
| outArr = strings.Split(strings.TrimSpace(out), "\n") |
| c.Assert(len(outArr), check.Equals, 4, check.Commentf("\n%s", out)) |
| |
| out, _ = dockerCmd(c, "volume", "ls", "--filter", "driver=loc") |
| outArr = strings.Split(strings.TrimSpace(out), "\n") |
| c.Assert(len(outArr), check.Equals, 4, check.Commentf("\n%s", out)) |
| |
| } |
| |
| func (s *DockerSuite) TestVolumeCLILsErrorWithInvalidFilterName(c *check.C) { |
| out, _, err := dockerCmdWithError("volume", "ls", "-f", "FOO=123") |
| c.Assert(err, checker.NotNil) |
| c.Assert(out, checker.Contains, "Invalid filter") |
| } |
| |
| func (s *DockerSuite) TestVolumeCLILsWithIncorrectFilterValue(c *check.C) { |
| out, _, err := dockerCmdWithError("volume", "ls", "-f", "dangling=invalid") |
| c.Assert(err, check.NotNil) |
| c.Assert(out, checker.Contains, "Invalid filter") |
| } |
| |
| func (s *DockerSuite) TestVolumeCLIRm(c *check.C) { |
| prefix, _ := getPrefixAndSlashFromDaemonPlatform() |
| out, _ := dockerCmd(c, "volume", "create") |
| id := strings.TrimSpace(out) |
| |
| dockerCmd(c, "volume", "create", "test") |
| dockerCmd(c, "volume", "rm", id) |
| dockerCmd(c, "volume", "rm", "test") |
| |
| out, _ = dockerCmd(c, "volume", "ls") |
| outArr := strings.Split(strings.TrimSpace(out), "\n") |
| c.Assert(len(outArr), check.Equals, 1, check.Commentf("%s\n", out)) |
| |
| volumeID := "testing" |
| dockerCmd(c, "run", "-v", volumeID+":"+prefix+"/foo", "--name=test", "busybox", "sh", "-c", "echo hello > /foo/bar") |
| out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "volume", "rm", "testing")) |
| c.Assert( |
| err, |
| check.Not(check.IsNil), |
| check.Commentf("Should not be able to remove volume that is in use by a container\n%s", out)) |
| |
| out, _ = dockerCmd(c, "run", "--volumes-from=test", "--name=test2", "busybox", "sh", "-c", "cat /foo/bar") |
| c.Assert(strings.TrimSpace(out), check.Equals, "hello") |
| dockerCmd(c, "rm", "-fv", "test2") |
| dockerCmd(c, "volume", "inspect", volumeID) |
| dockerCmd(c, "rm", "-f", "test") |
| |
| out, _ = dockerCmd(c, "run", "--name=test2", "-v", volumeID+":"+prefix+"/foo", "busybox", "sh", "-c", "cat /foo/bar") |
| c.Assert(strings.TrimSpace(out), check.Equals, "hello", check.Commentf("volume data was removed")) |
| dockerCmd(c, "rm", "test2") |
| |
| dockerCmd(c, "volume", "rm", volumeID) |
| c.Assert( |
| exec.Command("volume", "rm", "doesntexist").Run(), |
| check.Not(check.IsNil), |
| check.Commentf("volume rm should fail with non-existent volume"), |
| ) |
| } |
| |
| func (s *DockerSuite) TestVolumeCLINoArgs(c *check.C) { |
| out, _ := dockerCmd(c, "volume") |
| // no args should produce the cmd usage output |
| usage := "Usage: docker volume COMMAND" |
| c.Assert(out, checker.Contains, usage) |
| |
| // invalid arg should error and show the command usage on stderr |
| _, stderr, _, err := runCommandWithStdoutStderr(exec.Command(dockerBinary, "volume", "somearg")) |
| c.Assert(err, check.NotNil, check.Commentf(stderr)) |
| c.Assert(stderr, checker.Contains, usage) |
| |
| // invalid flag should error and show the flag error and cmd usage |
| _, stderr, _, err = runCommandWithStdoutStderr(exec.Command(dockerBinary, "volume", "--no-such-flag")) |
| c.Assert(err, check.NotNil, check.Commentf(stderr)) |
| c.Assert(stderr, checker.Contains, usage) |
| c.Assert(stderr, checker.Contains, "unknown flag: --no-such-flag") |
| } |
| |
| func (s *DockerSuite) TestVolumeCLIInspectTmplError(c *check.C) { |
| out, _ := dockerCmd(c, "volume", "create") |
| name := strings.TrimSpace(out) |
| |
| out, exitCode, err := dockerCmdWithError("volume", "inspect", "--format='{{ .FooBar }}'", name) |
| c.Assert(err, checker.NotNil, check.Commentf("Output: %s", out)) |
| c.Assert(exitCode, checker.Equals, 1, check.Commentf("Output: %s", out)) |
| c.Assert(out, checker.Contains, "Template parsing error") |
| } |
| |
| func (s *DockerSuite) TestVolumeCLICreateWithOpts(c *check.C) { |
| testRequires(c, DaemonIsLinux) |
| |
| dockerCmd(c, "volume", "create", "-d", "local", "test", "--opt=type=tmpfs", "--opt=device=tmpfs", "--opt=o=size=1m,uid=1000") |
| out, _ := dockerCmd(c, "run", "-v", "test:/foo", "busybox", "mount") |
| |
| mounts := strings.Split(out, "\n") |
| var found bool |
| for _, m := range mounts { |
| if strings.Contains(m, "/foo") { |
| found = true |
| info := strings.Fields(m) |
| // tmpfs on <path> type tmpfs (rw,relatime,size=1024k,uid=1000) |
| c.Assert(info[0], checker.Equals, "tmpfs") |
| c.Assert(info[2], checker.Equals, "/foo") |
| c.Assert(info[4], checker.Equals, "tmpfs") |
| c.Assert(info[5], checker.Contains, "uid=1000") |
| c.Assert(info[5], checker.Contains, "size=1024k") |
| } |
| } |
| c.Assert(found, checker.Equals, true) |
| } |
| |
| func (s *DockerSuite) TestVolumeCLICreateLabel(c *check.C) { |
| testVol := "testvolcreatelabel" |
| testLabel := "foo" |
| testValue := "bar" |
| |
| out, _, err := dockerCmdWithError("volume", "create", "--label", testLabel+"="+testValue, testVol) |
| c.Assert(err, check.IsNil) |
| |
| out, _ = dockerCmd(c, "volume", "inspect", "--format={{ .Labels."+testLabel+" }}", testVol) |
| c.Assert(strings.TrimSpace(out), check.Equals, testValue) |
| } |
| |
| func (s *DockerSuite) TestVolumeCLICreateLabelMultiple(c *check.C) { |
| testVol := "testvolcreatelabel" |
| |
| testLabels := map[string]string{ |
| "foo": "bar", |
| "baz": "foo", |
| } |
| |
| args := []string{ |
| "volume", |
| "create", |
| testVol, |
| } |
| |
| for k, v := range testLabels { |
| args = append(args, "--label", k+"="+v) |
| } |
| |
| out, _, err := dockerCmdWithError(args...) |
| c.Assert(err, check.IsNil) |
| |
| for k, v := range testLabels { |
| out, _ = dockerCmd(c, "volume", "inspect", "--format={{ .Labels."+k+" }}", testVol) |
| c.Assert(strings.TrimSpace(out), check.Equals, v) |
| } |
| } |
| |
| func (s *DockerSuite) TestVolumeCLILsFilterLabels(c *check.C) { |
| testVol1 := "testvolcreatelabel-1" |
| out, _, err := dockerCmdWithError("volume", "create", "--label", "foo=bar1", testVol1) |
| c.Assert(err, check.IsNil) |
| |
| testVol2 := "testvolcreatelabel-2" |
| out, _, err = dockerCmdWithError("volume", "create", "--label", "foo=bar2", testVol2) |
| c.Assert(err, check.IsNil) |
| |
| out, _ = dockerCmd(c, "volume", "ls", "--filter", "label=foo") |
| |
| // filter with label=key |
| c.Assert(out, checker.Contains, "testvolcreatelabel-1\n", check.Commentf("expected volume 'testvolcreatelabel-1' in output")) |
| c.Assert(out, checker.Contains, "testvolcreatelabel-2\n", check.Commentf("expected volume 'testvolcreatelabel-2' in output")) |
| |
| out, _ = dockerCmd(c, "volume", "ls", "--filter", "label=foo=bar1") |
| |
| // filter with label=key=value |
| c.Assert(out, checker.Contains, "testvolcreatelabel-1\n", check.Commentf("expected volume 'testvolcreatelabel-1' in output")) |
| c.Assert(out, check.Not(checker.Contains), "testvolcreatelabel-2\n", check.Commentf("expected volume 'testvolcreatelabel-2 in output")) |
| |
| out, _ = dockerCmd(c, "volume", "ls", "--filter", "label=non-exist") |
| outArr := strings.Split(strings.TrimSpace(out), "\n") |
| c.Assert(len(outArr), check.Equals, 1, check.Commentf("\n%s", out)) |
| |
| out, _ = dockerCmd(c, "volume", "ls", "--filter", "label=foo=non-exist") |
| outArr = strings.Split(strings.TrimSpace(out), "\n") |
| c.Assert(len(outArr), check.Equals, 1, check.Commentf("\n%s", out)) |
| } |
| |
| func (s *DockerSuite) TestVolumeCLIRmForceUsage(c *check.C) { |
| out, _ := dockerCmd(c, "volume", "create") |
| id := strings.TrimSpace(out) |
| |
| dockerCmd(c, "volume", "rm", "-f", id) |
| dockerCmd(c, "volume", "rm", "--force", "nonexist") |
| |
| out, _ = dockerCmd(c, "volume", "ls") |
| outArr := strings.Split(strings.TrimSpace(out), "\n") |
| c.Assert(len(outArr), check.Equals, 1, check.Commentf("%s\n", out)) |
| } |
| |
| func (s *DockerSuite) TestVolumeCLIRmForce(c *check.C) { |
| testRequires(c, SameHostDaemon, DaemonIsLinux) |
| |
| name := "test" |
| out, _ := dockerCmd(c, "volume", "create", name) |
| id := strings.TrimSpace(out) |
| c.Assert(id, checker.Equals, name) |
| |
| out, _ = dockerCmd(c, "volume", "inspect", "--format", "{{.Mountpoint}}", name) |
| c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "") |
| // Mountpoint is in the form of "/var/lib/docker/volumes/.../_data", removing `/_data` |
| path := strings.TrimSuffix(strings.TrimSpace(out), "/_data") |
| out, _, err := runCommandWithOutput(exec.Command("rm", "-rf", path)) |
| c.Assert(err, check.IsNil) |
| |
| dockerCmd(c, "volume", "rm", "-f", "test") |
| out, _ = dockerCmd(c, "volume", "ls") |
| c.Assert(out, checker.Not(checker.Contains), name) |
| dockerCmd(c, "volume", "create", "test") |
| out, _ = dockerCmd(c, "volume", "ls") |
| c.Assert(out, checker.Contains, name) |
| } |
| |
| func (s *DockerSuite) TestVolumeCliInspectWithVolumeOpts(c *check.C) { |
| testRequires(c, DaemonIsLinux) |
| |
| // Without options |
| name := "test1" |
| dockerCmd(c, "volume", "create", "-d", "local", name) |
| out, _ := dockerCmd(c, "volume", "inspect", "--format={{ .Options }}", name) |
| c.Assert(strings.TrimSpace(out), checker.Contains, "map[]") |
| |
| // With options |
| name = "test2" |
| k1, v1 := "type", "tmpfs" |
| k2, v2 := "device", "tmpfs" |
| k3, v3 := "o", "size=1m,uid=1000" |
| dockerCmd(c, "volume", "create", "-d", "local", name, "--opt", fmt.Sprintf("%s=%s", k1, v1), "--opt", fmt.Sprintf("%s=%s", k2, v2), "--opt", fmt.Sprintf("%s=%s", k3, v3)) |
| out, _ = dockerCmd(c, "volume", "inspect", "--format={{ .Options }}", name) |
| c.Assert(strings.TrimSpace(out), checker.Contains, fmt.Sprintf("%s:%s", k1, v1)) |
| c.Assert(strings.TrimSpace(out), checker.Contains, fmt.Sprintf("%s:%s", k2, v2)) |
| c.Assert(strings.TrimSpace(out), checker.Contains, fmt.Sprintf("%s:%s", k3, v3)) |
| } |
