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