github.com/OpenFlowLabs/moby@v17.12.1-ce-rc2+incompatible/integration-cli/docker_cli_external_volume_driver_unix_test.go (about) 1 // +build !windows 2 3 package main 4 5 import ( 6 "encoding/json" 7 "fmt" 8 "io" 9 "io/ioutil" 10 "net/http" 11 "net/http/httptest" 12 "os" 13 "os/exec" 14 "path/filepath" 15 "strings" 16 "time" 17 18 "github.com/docker/docker/api/types" 19 "github.com/docker/docker/integration-cli/checker" 20 "github.com/docker/docker/integration-cli/daemon" 21 "github.com/docker/docker/pkg/stringid" 22 "github.com/docker/docker/volume" 23 "github.com/go-check/check" 24 ) 25 26 const volumePluginName = "test-external-volume-driver" 27 28 func init() { 29 check.Suite(&DockerExternalVolumeSuite{ 30 ds: &DockerSuite{}, 31 }) 32 } 33 34 type eventCounter struct { 35 activations int 36 creations int 37 removals int 38 mounts int 39 unmounts int 40 paths int 41 lists int 42 gets int 43 caps int 44 } 45 46 type DockerExternalVolumeSuite struct { 47 ds *DockerSuite 48 d *daemon.Daemon 49 *volumePlugin 50 } 51 52 func (s *DockerExternalVolumeSuite) SetUpTest(c *check.C) { 53 testRequires(c, SameHostDaemon) 54 s.d = daemon.New(c, dockerBinary, dockerdBinary, daemon.Config{ 55 Experimental: testEnv.ExperimentalDaemon(), 56 }) 57 s.ec = &eventCounter{} 58 } 59 60 func (s *DockerExternalVolumeSuite) TearDownTest(c *check.C) { 61 if s.d != nil { 62 s.d.Stop(c) 63 s.ds.TearDownTest(c) 64 } 65 } 66 67 func (s *DockerExternalVolumeSuite) SetUpSuite(c *check.C) { 68 s.volumePlugin = newVolumePlugin(c, volumePluginName) 69 } 70 71 type volumePlugin struct { 72 ec *eventCounter 73 *httptest.Server 74 vols map[string]vol 75 } 76 77 type vol struct { 78 Name string 79 Mountpoint string 80 Ninja bool // hack used to trigger a null volume return on `Get` 81 Status map[string]interface{} 82 Options map[string]string 83 } 84 85 func (p *volumePlugin) Close() { 86 p.Server.Close() 87 } 88 89 func newVolumePlugin(c *check.C, name string) *volumePlugin { 90 mux := http.NewServeMux() 91 s := &volumePlugin{Server: httptest.NewServer(mux), ec: &eventCounter{}, vols: make(map[string]vol)} 92 93 type pluginRequest struct { 94 Name string 95 Opts map[string]string 96 ID string 97 } 98 99 type pluginResp struct { 100 Mountpoint string `json:",omitempty"` 101 Err string `json:",omitempty"` 102 } 103 104 read := func(b io.ReadCloser) (pluginRequest, error) { 105 defer b.Close() 106 var pr pluginRequest 107 err := json.NewDecoder(b).Decode(&pr) 108 return pr, err 109 } 110 111 send := func(w http.ResponseWriter, data interface{}) { 112 switch t := data.(type) { 113 case error: 114 http.Error(w, t.Error(), 500) 115 case string: 116 w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") 117 fmt.Fprintln(w, t) 118 default: 119 w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") 120 json.NewEncoder(w).Encode(&data) 121 } 122 } 123 124 mux.HandleFunc("/Plugin.Activate", func(w http.ResponseWriter, r *http.Request) { 125 s.ec.activations++ 126 send(w, `{"Implements": ["VolumeDriver"]}`) 127 }) 128 129 mux.HandleFunc("/VolumeDriver.Create", func(w http.ResponseWriter, r *http.Request) { 130 s.ec.creations++ 131 pr, err := read(r.Body) 132 if err != nil { 133 send(w, err) 134 return 135 } 136 _, isNinja := pr.Opts["ninja"] 137 status := map[string]interface{}{"Hello": "world"} 138 s.vols[pr.Name] = vol{Name: pr.Name, Ninja: isNinja, Status: status, Options: pr.Opts} 139 send(w, nil) 140 }) 141 142 mux.HandleFunc("/VolumeDriver.List", func(w http.ResponseWriter, r *http.Request) { 143 s.ec.lists++ 144 vols := make([]vol, 0, len(s.vols)) 145 for _, v := range s.vols { 146 if v.Ninja { 147 continue 148 } 149 vols = append(vols, v) 150 } 151 send(w, map[string][]vol{"Volumes": vols}) 152 }) 153 154 mux.HandleFunc("/VolumeDriver.Get", func(w http.ResponseWriter, r *http.Request) { 155 s.ec.gets++ 156 pr, err := read(r.Body) 157 if err != nil { 158 send(w, err) 159 return 160 } 161 162 v, exists := s.vols[pr.Name] 163 if !exists { 164 send(w, `{"Err": "no such volume"}`) 165 } 166 167 if v.Ninja { 168 send(w, map[string]vol{}) 169 return 170 } 171 172 v.Mountpoint = hostVolumePath(pr.Name) 173 send(w, map[string]vol{"Volume": v}) 174 return 175 }) 176 177 mux.HandleFunc("/VolumeDriver.Remove", func(w http.ResponseWriter, r *http.Request) { 178 s.ec.removals++ 179 pr, err := read(r.Body) 180 if err != nil { 181 send(w, err) 182 return 183 } 184 185 v, ok := s.vols[pr.Name] 186 if !ok { 187 send(w, nil) 188 return 189 } 190 191 if err := os.RemoveAll(hostVolumePath(v.Name)); err != nil { 192 send(w, &pluginResp{Err: err.Error()}) 193 return 194 } 195 delete(s.vols, v.Name) 196 send(w, nil) 197 }) 198 199 mux.HandleFunc("/VolumeDriver.Path", func(w http.ResponseWriter, r *http.Request) { 200 s.ec.paths++ 201 202 pr, err := read(r.Body) 203 if err != nil { 204 send(w, err) 205 return 206 } 207 p := hostVolumePath(pr.Name) 208 send(w, &pluginResp{Mountpoint: p}) 209 }) 210 211 mux.HandleFunc("/VolumeDriver.Mount", func(w http.ResponseWriter, r *http.Request) { 212 s.ec.mounts++ 213 214 pr, err := read(r.Body) 215 if err != nil { 216 send(w, err) 217 return 218 } 219 220 if v, exists := s.vols[pr.Name]; exists { 221 // Use this to simulate a mount failure 222 if _, exists := v.Options["invalidOption"]; exists { 223 send(w, fmt.Errorf("invalid argument")) 224 return 225 } 226 } 227 228 p := hostVolumePath(pr.Name) 229 if err := os.MkdirAll(p, 0755); err != nil { 230 send(w, &pluginResp{Err: err.Error()}) 231 return 232 } 233 234 if err := ioutil.WriteFile(filepath.Join(p, "test"), []byte(s.Server.URL), 0644); err != nil { 235 send(w, err) 236 return 237 } 238 239 if err := ioutil.WriteFile(filepath.Join(p, "mountID"), []byte(pr.ID), 0644); err != nil { 240 send(w, err) 241 return 242 } 243 244 send(w, &pluginResp{Mountpoint: p}) 245 }) 246 247 mux.HandleFunc("/VolumeDriver.Unmount", func(w http.ResponseWriter, r *http.Request) { 248 s.ec.unmounts++ 249 250 _, err := read(r.Body) 251 if err != nil { 252 send(w, err) 253 return 254 } 255 256 send(w, nil) 257 }) 258 259 mux.HandleFunc("/VolumeDriver.Capabilities", func(w http.ResponseWriter, r *http.Request) { 260 s.ec.caps++ 261 262 _, err := read(r.Body) 263 if err != nil { 264 send(w, err) 265 return 266 } 267 268 send(w, `{"Capabilities": { "Scope": "global" }}`) 269 }) 270 271 err := os.MkdirAll("/etc/docker/plugins", 0755) 272 c.Assert(err, checker.IsNil) 273 274 err = ioutil.WriteFile("/etc/docker/plugins/"+name+".spec", []byte(s.Server.URL), 0644) 275 c.Assert(err, checker.IsNil) 276 return s 277 } 278 279 func (s *DockerExternalVolumeSuite) TearDownSuite(c *check.C) { 280 s.volumePlugin.Close() 281 282 err := os.RemoveAll("/etc/docker/plugins") 283 c.Assert(err, checker.IsNil) 284 } 285 286 func (s *DockerExternalVolumeSuite) TestVolumeCLICreateOptionConflict(c *check.C) { 287 dockerCmd(c, "volume", "create", "test") 288 289 out, _, err := dockerCmdWithError("volume", "create", "test", "--driver", volumePluginName) 290 c.Assert(err, check.NotNil, check.Commentf("volume create exception name already in use with another driver")) 291 c.Assert(out, checker.Contains, "must be unique") 292 293 out, _ = dockerCmd(c, "volume", "inspect", "--format={{ .Driver }}", "test") 294 _, _, err = dockerCmdWithError("volume", "create", "test", "--driver", strings.TrimSpace(out)) 295 c.Assert(err, check.IsNil) 296 } 297 298 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverNamed(c *check.C) { 299 s.d.StartWithBusybox(c) 300 301 out, err := s.d.Cmd("run", "--rm", "--name", "test-data", "-v", "external-volume-test:/tmp/external-volume-test", "--volume-driver", volumePluginName, "busybox:latest", "cat", "/tmp/external-volume-test/test") 302 c.Assert(err, checker.IsNil, check.Commentf(out)) 303 c.Assert(out, checker.Contains, s.Server.URL) 304 305 _, err = s.d.Cmd("volume", "rm", "external-volume-test") 306 c.Assert(err, checker.IsNil) 307 308 p := hostVolumePath("external-volume-test") 309 _, err = os.Lstat(p) 310 c.Assert(err, checker.NotNil) 311 c.Assert(os.IsNotExist(err), checker.True, check.Commentf("Expected volume path in host to not exist: %s, %v\n", p, err)) 312 313 c.Assert(s.ec.activations, checker.Equals, 1) 314 c.Assert(s.ec.creations, checker.Equals, 1) 315 c.Assert(s.ec.removals, checker.Equals, 1) 316 c.Assert(s.ec.mounts, checker.Equals, 1) 317 c.Assert(s.ec.unmounts, checker.Equals, 1) 318 } 319 320 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverUnnamed(c *check.C) { 321 s.d.StartWithBusybox(c) 322 323 out, err := s.d.Cmd("run", "--rm", "--name", "test-data", "-v", "/tmp/external-volume-test", "--volume-driver", volumePluginName, "busybox:latest", "cat", "/tmp/external-volume-test/test") 324 c.Assert(err, checker.IsNil, check.Commentf(out)) 325 c.Assert(out, checker.Contains, s.Server.URL) 326 327 c.Assert(s.ec.activations, checker.Equals, 1) 328 c.Assert(s.ec.creations, checker.Equals, 1) 329 c.Assert(s.ec.removals, checker.Equals, 1) 330 c.Assert(s.ec.mounts, checker.Equals, 1) 331 c.Assert(s.ec.unmounts, checker.Equals, 1) 332 } 333 334 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverVolumesFrom(c *check.C) { 335 s.d.StartWithBusybox(c) 336 337 out, err := s.d.Cmd("run", "--name", "vol-test1", "-v", "/foo", "--volume-driver", volumePluginName, "busybox:latest") 338 c.Assert(err, checker.IsNil, check.Commentf(out)) 339 340 out, err = s.d.Cmd("run", "--rm", "--volumes-from", "vol-test1", "--name", "vol-test2", "busybox", "ls", "/tmp") 341 c.Assert(err, checker.IsNil, check.Commentf(out)) 342 343 out, err = s.d.Cmd("rm", "-fv", "vol-test1") 344 c.Assert(err, checker.IsNil, check.Commentf(out)) 345 346 c.Assert(s.ec.activations, checker.Equals, 1) 347 c.Assert(s.ec.creations, checker.Equals, 1) 348 c.Assert(s.ec.removals, checker.Equals, 1) 349 c.Assert(s.ec.mounts, checker.Equals, 2) 350 c.Assert(s.ec.unmounts, checker.Equals, 2) 351 } 352 353 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverDeleteContainer(c *check.C) { 354 s.d.StartWithBusybox(c) 355 356 out, err := s.d.Cmd("run", "--name", "vol-test1", "-v", "/foo", "--volume-driver", volumePluginName, "busybox:latest") 357 c.Assert(err, checker.IsNil, check.Commentf(out)) 358 359 out, err = s.d.Cmd("rm", "-fv", "vol-test1") 360 c.Assert(err, checker.IsNil, check.Commentf(out)) 361 362 c.Assert(s.ec.activations, checker.Equals, 1) 363 c.Assert(s.ec.creations, checker.Equals, 1) 364 c.Assert(s.ec.removals, checker.Equals, 1) 365 c.Assert(s.ec.mounts, checker.Equals, 1) 366 c.Assert(s.ec.unmounts, checker.Equals, 1) 367 } 368 369 func hostVolumePath(name string) string { 370 return fmt.Sprintf("/var/lib/docker/volumes/%s", name) 371 } 372 373 // Make sure a request to use a down driver doesn't block other requests 374 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverLookupNotBlocked(c *check.C) { 375 specPath := "/etc/docker/plugins/down-driver.spec" 376 err := ioutil.WriteFile(specPath, []byte("tcp://127.0.0.7:9999"), 0644) 377 c.Assert(err, check.IsNil) 378 defer os.RemoveAll(specPath) 379 380 chCmd1 := make(chan struct{}) 381 chCmd2 := make(chan error) 382 cmd1 := exec.Command(dockerBinary, "volume", "create", "-d", "down-driver") 383 cmd2 := exec.Command(dockerBinary, "volume", "create") 384 385 c.Assert(cmd1.Start(), checker.IsNil) 386 defer cmd1.Process.Kill() 387 time.Sleep(100 * time.Millisecond) // ensure API has been called 388 c.Assert(cmd2.Start(), checker.IsNil) 389 390 go func() { 391 cmd1.Wait() 392 close(chCmd1) 393 }() 394 go func() { 395 chCmd2 <- cmd2.Wait() 396 }() 397 398 select { 399 case <-chCmd1: 400 cmd2.Process.Kill() 401 c.Fatalf("volume create with down driver finished unexpectedly") 402 case err := <-chCmd2: 403 c.Assert(err, checker.IsNil) 404 case <-time.After(5 * time.Second): 405 cmd2.Process.Kill() 406 c.Fatal("volume creates are blocked by previous create requests when previous driver is down") 407 } 408 } 409 410 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverRetryNotImmediatelyExists(c *check.C) { 411 s.d.StartWithBusybox(c) 412 driverName := "test-external-volume-driver-retry" 413 414 errchan := make(chan error) 415 started := make(chan struct{}) 416 go func() { 417 close(started) 418 if out, err := s.d.Cmd("run", "--rm", "--name", "test-data-retry", "-v", "external-volume-test:/tmp/external-volume-test", "--volume-driver", driverName, "busybox:latest"); err != nil { 419 errchan <- fmt.Errorf("%v:\n%s", err, out) 420 } 421 close(errchan) 422 }() 423 424 <-started 425 // wait for a retry to occur, then create spec to allow plugin to register 426 time.Sleep(2 * time.Second) 427 p := newVolumePlugin(c, driverName) 428 defer p.Close() 429 430 select { 431 case err := <-errchan: 432 c.Assert(err, checker.IsNil) 433 case <-time.After(8 * time.Second): 434 c.Fatal("volume creates fail when plugin not immediately available") 435 } 436 437 _, err := s.d.Cmd("volume", "rm", "external-volume-test") 438 c.Assert(err, checker.IsNil) 439 440 c.Assert(p.ec.activations, checker.Equals, 1) 441 c.Assert(p.ec.creations, checker.Equals, 1) 442 c.Assert(p.ec.removals, checker.Equals, 1) 443 c.Assert(p.ec.mounts, checker.Equals, 1) 444 c.Assert(p.ec.unmounts, checker.Equals, 1) 445 } 446 447 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverBindExternalVolume(c *check.C) { 448 dockerCmd(c, "volume", "create", "-d", volumePluginName, "foo") 449 dockerCmd(c, "run", "-d", "--name", "testing", "-v", "foo:/bar", "busybox", "top") 450 451 var mounts []struct { 452 Name string 453 Driver string 454 } 455 out := inspectFieldJSON(c, "testing", "Mounts") 456 c.Assert(json.NewDecoder(strings.NewReader(out)).Decode(&mounts), checker.IsNil) 457 c.Assert(len(mounts), checker.Equals, 1, check.Commentf(out)) 458 c.Assert(mounts[0].Name, checker.Equals, "foo") 459 c.Assert(mounts[0].Driver, checker.Equals, volumePluginName) 460 } 461 462 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverList(c *check.C) { 463 dockerCmd(c, "volume", "create", "-d", volumePluginName, "abc3") 464 out, _ := dockerCmd(c, "volume", "ls") 465 ls := strings.Split(strings.TrimSpace(out), "\n") 466 c.Assert(len(ls), check.Equals, 2, check.Commentf("\n%s", out)) 467 468 vol := strings.Fields(ls[len(ls)-1]) 469 c.Assert(len(vol), check.Equals, 2, check.Commentf("%v", vol)) 470 c.Assert(vol[0], check.Equals, volumePluginName) 471 c.Assert(vol[1], check.Equals, "abc3") 472 473 c.Assert(s.ec.lists, check.Equals, 1) 474 } 475 476 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverGet(c *check.C) { 477 out, _, err := dockerCmdWithError("volume", "inspect", "dummy") 478 c.Assert(err, check.NotNil, check.Commentf(out)) 479 c.Assert(out, checker.Contains, "No such volume") 480 c.Assert(s.ec.gets, check.Equals, 1) 481 482 dockerCmd(c, "volume", "create", "test", "-d", volumePluginName) 483 out, _ = dockerCmd(c, "volume", "inspect", "test") 484 485 type vol struct { 486 Status map[string]string 487 } 488 var st []vol 489 490 c.Assert(json.Unmarshal([]byte(out), &st), checker.IsNil) 491 c.Assert(st, checker.HasLen, 1) 492 c.Assert(st[0].Status, checker.HasLen, 1, check.Commentf("%v", st[0])) 493 c.Assert(st[0].Status["Hello"], checker.Equals, "world", check.Commentf("%v", st[0].Status)) 494 } 495 496 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverWithDaemonRestart(c *check.C) { 497 dockerCmd(c, "volume", "create", "-d", volumePluginName, "abc1") 498 s.d.Restart(c) 499 500 dockerCmd(c, "run", "--name=test", "-v", "abc1:/foo", "busybox", "true") 501 var mounts []types.MountPoint 502 inspectFieldAndUnmarshall(c, "test", "Mounts", &mounts) 503 c.Assert(mounts, checker.HasLen, 1) 504 c.Assert(mounts[0].Driver, checker.Equals, volumePluginName) 505 } 506 507 // Ensures that the daemon handles when the plugin responds to a `Get` request with a null volume and a null error. 508 // Prior the daemon would panic in this scenario. 509 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverGetEmptyResponse(c *check.C) { 510 s.d.Start(c) 511 512 out, err := s.d.Cmd("volume", "create", "-d", volumePluginName, "abc2", "--opt", "ninja=1") 513 c.Assert(err, checker.IsNil, check.Commentf(out)) 514 515 out, err = s.d.Cmd("volume", "inspect", "abc2") 516 c.Assert(err, checker.NotNil, check.Commentf(out)) 517 c.Assert(out, checker.Contains, "No such volume") 518 } 519 520 // Ensure only cached paths are used in volume list to prevent N+1 calls to `VolumeDriver.Path` 521 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverPathCalls(c *check.C) { 522 s.d.Start(c) 523 c.Assert(s.ec.paths, checker.Equals, 0) 524 525 out, err := s.d.Cmd("volume", "create", "test", "--driver=test-external-volume-driver") 526 c.Assert(err, checker.IsNil, check.Commentf(out)) 527 c.Assert(s.ec.paths, checker.Equals, 1) 528 529 out, err = s.d.Cmd("volume", "ls") 530 c.Assert(err, checker.IsNil, check.Commentf(out)) 531 c.Assert(s.ec.paths, checker.Equals, 1) 532 533 out, err = s.d.Cmd("volume", "inspect", "--format='{{.Mountpoint}}'", "test") 534 c.Assert(err, checker.IsNil, check.Commentf(out)) 535 c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "") 536 c.Assert(s.ec.paths, checker.Equals, 1) 537 } 538 539 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverMountID(c *check.C) { 540 s.d.StartWithBusybox(c) 541 542 out, err := s.d.Cmd("run", "--rm", "-v", "external-volume-test:/tmp/external-volume-test", "--volume-driver", volumePluginName, "busybox:latest", "cat", "/tmp/external-volume-test/test") 543 c.Assert(err, checker.IsNil, check.Commentf(out)) 544 c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "") 545 } 546 547 // Check that VolumeDriver.Capabilities gets called, and only called once 548 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverCapabilities(c *check.C) { 549 s.d.Start(c) 550 c.Assert(s.ec.caps, checker.Equals, 0) 551 552 for i := 0; i < 3; i++ { 553 out, err := s.d.Cmd("volume", "create", "-d", volumePluginName, fmt.Sprintf("test%d", i)) 554 c.Assert(err, checker.IsNil, check.Commentf(out)) 555 c.Assert(s.ec.caps, checker.Equals, 1) 556 out, err = s.d.Cmd("volume", "inspect", "--format={{.Scope}}", fmt.Sprintf("test%d", i)) 557 c.Assert(err, checker.IsNil) 558 c.Assert(strings.TrimSpace(out), checker.Equals, volume.GlobalScope) 559 } 560 } 561 562 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverOutOfBandDelete(c *check.C) { 563 driverName := stringid.GenerateNonCryptoID() 564 p := newVolumePlugin(c, driverName) 565 defer p.Close() 566 567 s.d.StartWithBusybox(c) 568 569 out, err := s.d.Cmd("volume", "create", "-d", driverName, "--name", "test") 570 c.Assert(err, checker.IsNil, check.Commentf(out)) 571 572 out, err = s.d.Cmd("volume", "create", "-d", "local", "--name", "test") 573 c.Assert(err, checker.NotNil, check.Commentf(out)) 574 c.Assert(out, checker.Contains, "must be unique") 575 576 // simulate out of band volume deletion on plugin level 577 delete(p.vols, "test") 578 579 // test re-create with same driver 580 out, err = s.d.Cmd("volume", "create", "-d", driverName, "--opt", "foo=bar", "--name", "test") 581 c.Assert(err, checker.IsNil, check.Commentf(out)) 582 out, err = s.d.Cmd("volume", "inspect", "test") 583 c.Assert(err, checker.IsNil, check.Commentf(out)) 584 585 var vs []types.Volume 586 err = json.Unmarshal([]byte(out), &vs) 587 c.Assert(err, checker.IsNil) 588 c.Assert(vs, checker.HasLen, 1) 589 c.Assert(vs[0].Driver, checker.Equals, driverName) 590 c.Assert(vs[0].Options, checker.NotNil) 591 c.Assert(vs[0].Options["foo"], checker.Equals, "bar") 592 c.Assert(vs[0].Driver, checker.Equals, driverName) 593 594 // simulate out of band volume deletion on plugin level 595 delete(p.vols, "test") 596 597 // test create with different driver 598 out, err = s.d.Cmd("volume", "create", "-d", "local", "--name", "test") 599 c.Assert(err, checker.IsNil, check.Commentf(out)) 600 601 out, err = s.d.Cmd("volume", "inspect", "test") 602 c.Assert(err, checker.IsNil, check.Commentf(out)) 603 vs = nil 604 err = json.Unmarshal([]byte(out), &vs) 605 c.Assert(err, checker.IsNil) 606 c.Assert(vs, checker.HasLen, 1) 607 c.Assert(vs[0].Options, checker.HasLen, 0) 608 c.Assert(vs[0].Driver, checker.Equals, "local") 609 } 610 611 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverUnmountOnMountFail(c *check.C) { 612 s.d.StartWithBusybox(c) 613 s.d.Cmd("volume", "create", "-d", "test-external-volume-driver", "--opt=invalidOption=1", "--name=testumount") 614 615 out, _ := s.d.Cmd("run", "-v", "testumount:/foo", "busybox", "true") 616 c.Assert(s.ec.unmounts, checker.Equals, 0, check.Commentf(out)) 617 out, _ = s.d.Cmd("run", "-w", "/foo", "-v", "testumount:/foo", "busybox", "true") 618 c.Assert(s.ec.unmounts, checker.Equals, 0, check.Commentf(out)) 619 } 620 621 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverUnmountOnCp(c *check.C) { 622 s.d.StartWithBusybox(c) 623 s.d.Cmd("volume", "create", "-d", "test-external-volume-driver", "--name=test") 624 625 out, _ := s.d.Cmd("run", "-d", "--name=test", "-v", "test:/foo", "busybox", "/bin/sh", "-c", "touch /test && top") 626 c.Assert(s.ec.mounts, checker.Equals, 1, check.Commentf(out)) 627 628 out, _ = s.d.Cmd("cp", "test:/test", "/tmp/test") 629 c.Assert(s.ec.mounts, checker.Equals, 2, check.Commentf(out)) 630 c.Assert(s.ec.unmounts, checker.Equals, 1, check.Commentf(out)) 631 632 out, _ = s.d.Cmd("kill", "test") 633 c.Assert(s.ec.unmounts, checker.Equals, 2, check.Commentf(out)) 634 }