github.com/fabiokung/docker@v0.11.2-0.20170222101415-4534dcd49497/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 s.d = daemon.New(c, dockerBinary, dockerdBinary, daemon.Config{ 54 Experimental: testEnv.ExperimentalDaemon(), 55 }) 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, "A volume named test already exists") 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 // make sure hidden --name option conflicts with positional arg name 297 out, _, err = dockerCmdWithError("volume", "create", "--name", "test2", "test2") 298 c.Assert(err, check.NotNil) 299 c.Assert(strings.TrimSpace(out), checker.Equals, "Conflicting options: either specify --name or provide positional arg, not both") 300 } 301 302 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverNamed(c *check.C) { 303 s.d.StartWithBusybox(c) 304 305 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") 306 c.Assert(err, checker.IsNil, check.Commentf(out)) 307 c.Assert(out, checker.Contains, s.Server.URL) 308 309 _, err = s.d.Cmd("volume", "rm", "external-volume-test") 310 c.Assert(err, checker.IsNil) 311 312 p := hostVolumePath("external-volume-test") 313 _, err = os.Lstat(p) 314 c.Assert(err, checker.NotNil) 315 c.Assert(os.IsNotExist(err), checker.True, check.Commentf("Expected volume path in host to not exist: %s, %v\n", p, err)) 316 317 c.Assert(s.ec.activations, checker.Equals, 1) 318 c.Assert(s.ec.creations, checker.Equals, 1) 319 c.Assert(s.ec.removals, checker.Equals, 1) 320 c.Assert(s.ec.mounts, checker.Equals, 1) 321 c.Assert(s.ec.unmounts, checker.Equals, 1) 322 } 323 324 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverUnnamed(c *check.C) { 325 s.d.StartWithBusybox(c) 326 327 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") 328 c.Assert(err, checker.IsNil, check.Commentf(out)) 329 c.Assert(out, checker.Contains, s.Server.URL) 330 331 c.Assert(s.ec.activations, checker.Equals, 1) 332 c.Assert(s.ec.creations, checker.Equals, 1) 333 c.Assert(s.ec.removals, checker.Equals, 1) 334 c.Assert(s.ec.mounts, checker.Equals, 1) 335 c.Assert(s.ec.unmounts, checker.Equals, 1) 336 } 337 338 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverVolumesFrom(c *check.C) { 339 s.d.StartWithBusybox(c) 340 341 out, err := s.d.Cmd("run", "--name", "vol-test1", "-v", "/foo", "--volume-driver", volumePluginName, "busybox:latest") 342 c.Assert(err, checker.IsNil, check.Commentf(out)) 343 344 out, err = s.d.Cmd("run", "--rm", "--volumes-from", "vol-test1", "--name", "vol-test2", "busybox", "ls", "/tmp") 345 c.Assert(err, checker.IsNil, check.Commentf(out)) 346 347 out, err = s.d.Cmd("rm", "-fv", "vol-test1") 348 c.Assert(err, checker.IsNil, check.Commentf(out)) 349 350 c.Assert(s.ec.activations, checker.Equals, 1) 351 c.Assert(s.ec.creations, checker.Equals, 1) 352 c.Assert(s.ec.removals, checker.Equals, 1) 353 c.Assert(s.ec.mounts, checker.Equals, 2) 354 c.Assert(s.ec.unmounts, checker.Equals, 2) 355 } 356 357 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverDeleteContainer(c *check.C) { 358 s.d.StartWithBusybox(c) 359 360 out, err := s.d.Cmd("run", "--name", "vol-test1", "-v", "/foo", "--volume-driver", volumePluginName, "busybox:latest") 361 c.Assert(err, checker.IsNil, check.Commentf(out)) 362 363 out, err = s.d.Cmd("rm", "-fv", "vol-test1") 364 c.Assert(err, checker.IsNil, check.Commentf(out)) 365 366 c.Assert(s.ec.activations, checker.Equals, 1) 367 c.Assert(s.ec.creations, checker.Equals, 1) 368 c.Assert(s.ec.removals, checker.Equals, 1) 369 c.Assert(s.ec.mounts, checker.Equals, 1) 370 c.Assert(s.ec.unmounts, checker.Equals, 1) 371 } 372 373 func hostVolumePath(name string) string { 374 return fmt.Sprintf("/var/lib/docker/volumes/%s", name) 375 } 376 377 // Make sure a request to use a down driver doesn't block other requests 378 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverLookupNotBlocked(c *check.C) { 379 specPath := "/etc/docker/plugins/down-driver.spec" 380 err := ioutil.WriteFile(specPath, []byte("tcp://127.0.0.7:9999"), 0644) 381 c.Assert(err, check.IsNil) 382 defer os.RemoveAll(specPath) 383 384 chCmd1 := make(chan struct{}) 385 chCmd2 := make(chan error) 386 cmd1 := exec.Command(dockerBinary, "volume", "create", "-d", "down-driver") 387 cmd2 := exec.Command(dockerBinary, "volume", "create") 388 389 c.Assert(cmd1.Start(), checker.IsNil) 390 defer cmd1.Process.Kill() 391 time.Sleep(100 * time.Millisecond) // ensure API has been called 392 c.Assert(cmd2.Start(), checker.IsNil) 393 394 go func() { 395 cmd1.Wait() 396 close(chCmd1) 397 }() 398 go func() { 399 chCmd2 <- cmd2.Wait() 400 }() 401 402 select { 403 case <-chCmd1: 404 cmd2.Process.Kill() 405 c.Fatalf("volume create with down driver finished unexpectedly") 406 case err := <-chCmd2: 407 c.Assert(err, checker.IsNil) 408 case <-time.After(5 * time.Second): 409 cmd2.Process.Kill() 410 c.Fatal("volume creates are blocked by previous create requests when previous driver is down") 411 } 412 } 413 414 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverRetryNotImmediatelyExists(c *check.C) { 415 s.d.StartWithBusybox(c) 416 driverName := "test-external-volume-driver-retry" 417 418 errchan := make(chan error) 419 started := make(chan struct{}) 420 go func() { 421 close(started) 422 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 { 423 errchan <- fmt.Errorf("%v:\n%s", err, out) 424 } 425 close(errchan) 426 }() 427 428 <-started 429 // wait for a retry to occur, then create spec to allow plugin to register 430 time.Sleep(2 * time.Second) 431 p := newVolumePlugin(c, driverName) 432 defer p.Close() 433 434 select { 435 case err := <-errchan: 436 c.Assert(err, checker.IsNil) 437 case <-time.After(8 * time.Second): 438 c.Fatal("volume creates fail when plugin not immediately available") 439 } 440 441 _, err := s.d.Cmd("volume", "rm", "external-volume-test") 442 c.Assert(err, checker.IsNil) 443 444 c.Assert(p.ec.activations, checker.Equals, 1) 445 c.Assert(p.ec.creations, checker.Equals, 1) 446 c.Assert(p.ec.removals, checker.Equals, 1) 447 c.Assert(p.ec.mounts, checker.Equals, 1) 448 c.Assert(p.ec.unmounts, checker.Equals, 1) 449 } 450 451 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverBindExternalVolume(c *check.C) { 452 dockerCmd(c, "volume", "create", "-d", volumePluginName, "foo") 453 dockerCmd(c, "run", "-d", "--name", "testing", "-v", "foo:/bar", "busybox", "top") 454 455 var mounts []struct { 456 Name string 457 Driver string 458 } 459 out := inspectFieldJSON(c, "testing", "Mounts") 460 c.Assert(json.NewDecoder(strings.NewReader(out)).Decode(&mounts), checker.IsNil) 461 c.Assert(len(mounts), checker.Equals, 1, check.Commentf(out)) 462 c.Assert(mounts[0].Name, checker.Equals, "foo") 463 c.Assert(mounts[0].Driver, checker.Equals, volumePluginName) 464 } 465 466 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverList(c *check.C) { 467 dockerCmd(c, "volume", "create", "-d", volumePluginName, "abc3") 468 out, _ := dockerCmd(c, "volume", "ls") 469 ls := strings.Split(strings.TrimSpace(out), "\n") 470 c.Assert(len(ls), check.Equals, 2, check.Commentf("\n%s", out)) 471 472 vol := strings.Fields(ls[len(ls)-1]) 473 c.Assert(len(vol), check.Equals, 2, check.Commentf("%v", vol)) 474 c.Assert(vol[0], check.Equals, volumePluginName) 475 c.Assert(vol[1], check.Equals, "abc3") 476 477 c.Assert(s.ec.lists, check.Equals, 1) 478 } 479 480 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverGet(c *check.C) { 481 out, _, err := dockerCmdWithError("volume", "inspect", "dummy") 482 c.Assert(err, check.NotNil, check.Commentf(out)) 483 c.Assert(out, checker.Contains, "No such volume") 484 c.Assert(s.ec.gets, check.Equals, 1) 485 486 dockerCmd(c, "volume", "create", "test", "-d", volumePluginName) 487 out, _ = dockerCmd(c, "volume", "inspect", "test") 488 489 type vol struct { 490 Status map[string]string 491 } 492 var st []vol 493 494 c.Assert(json.Unmarshal([]byte(out), &st), checker.IsNil) 495 c.Assert(st, checker.HasLen, 1) 496 c.Assert(st[0].Status, checker.HasLen, 1, check.Commentf("%v", st[0])) 497 c.Assert(st[0].Status["Hello"], checker.Equals, "world", check.Commentf("%v", st[0].Status)) 498 } 499 500 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverWithDaemonRestart(c *check.C) { 501 dockerCmd(c, "volume", "create", "-d", volumePluginName, "abc1") 502 s.d.Restart(c) 503 504 dockerCmd(c, "run", "--name=test", "-v", "abc1:/foo", "busybox", "true") 505 var mounts []types.MountPoint 506 inspectFieldAndUnmarshall(c, "test", "Mounts", &mounts) 507 c.Assert(mounts, checker.HasLen, 1) 508 c.Assert(mounts[0].Driver, checker.Equals, volumePluginName) 509 } 510 511 // Ensures that the daemon handles when the plugin responds to a `Get` request with a null volume and a null error. 512 // Prior the daemon would panic in this scenario. 513 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverGetEmptyResponse(c *check.C) { 514 s.d.Start(c) 515 516 out, err := s.d.Cmd("volume", "create", "-d", volumePluginName, "abc2", "--opt", "ninja=1") 517 c.Assert(err, checker.IsNil, check.Commentf(out)) 518 519 out, err = s.d.Cmd("volume", "inspect", "abc2") 520 c.Assert(err, checker.NotNil, check.Commentf(out)) 521 c.Assert(out, checker.Contains, "No such volume") 522 } 523 524 // Ensure only cached paths are used in volume list to prevent N+1 calls to `VolumeDriver.Path` 525 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverPathCalls(c *check.C) { 526 s.d.Start(c) 527 c.Assert(s.ec.paths, checker.Equals, 0) 528 529 out, err := s.d.Cmd("volume", "create", "test", "--driver=test-external-volume-driver") 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", "ls") 534 c.Assert(err, checker.IsNil, check.Commentf(out)) 535 c.Assert(s.ec.paths, checker.Equals, 1) 536 537 out, err = s.d.Cmd("volume", "inspect", "--format='{{.Mountpoint}}'", "test") 538 c.Assert(err, checker.IsNil, check.Commentf(out)) 539 c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "") 540 c.Assert(s.ec.paths, checker.Equals, 1) 541 } 542 543 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverMountID(c *check.C) { 544 s.d.StartWithBusybox(c) 545 546 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") 547 c.Assert(err, checker.IsNil, check.Commentf(out)) 548 c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "") 549 } 550 551 // Check that VolumeDriver.Capabilities gets called, and only called once 552 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverCapabilities(c *check.C) { 553 s.d.Start(c) 554 c.Assert(s.ec.caps, checker.Equals, 0) 555 556 for i := 0; i < 3; i++ { 557 out, err := s.d.Cmd("volume", "create", "-d", volumePluginName, fmt.Sprintf("test%d", i)) 558 c.Assert(err, checker.IsNil, check.Commentf(out)) 559 c.Assert(s.ec.caps, checker.Equals, 1) 560 out, err = s.d.Cmd("volume", "inspect", "--format={{.Scope}}", fmt.Sprintf("test%d", i)) 561 c.Assert(err, checker.IsNil) 562 c.Assert(strings.TrimSpace(out), checker.Equals, volume.GlobalScope) 563 } 564 } 565 566 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverOutOfBandDelete(c *check.C) { 567 driverName := stringid.GenerateNonCryptoID() 568 p := newVolumePlugin(c, driverName) 569 defer p.Close() 570 571 s.d.StartWithBusybox(c) 572 573 out, err := s.d.Cmd("volume", "create", "-d", driverName, "--name", "test") 574 c.Assert(err, checker.IsNil, check.Commentf(out)) 575 576 out, err = s.d.Cmd("volume", "create", "-d", "local", "--name", "test") 577 c.Assert(err, checker.NotNil, check.Commentf(out)) 578 c.Assert(out, checker.Contains, "volume named test already exists") 579 580 // simulate out of band volume deletion on plugin level 581 delete(p.vols, "test") 582 583 // test re-create with same driver 584 out, err = s.d.Cmd("volume", "create", "-d", driverName, "--opt", "foo=bar", "--name", "test") 585 c.Assert(err, checker.IsNil, check.Commentf(out)) 586 out, err = s.d.Cmd("volume", "inspect", "test") 587 c.Assert(err, checker.IsNil, check.Commentf(out)) 588 589 var vs []types.Volume 590 err = json.Unmarshal([]byte(out), &vs) 591 c.Assert(err, checker.IsNil) 592 c.Assert(vs, checker.HasLen, 1) 593 c.Assert(vs[0].Driver, checker.Equals, driverName) 594 c.Assert(vs[0].Options, checker.NotNil) 595 c.Assert(vs[0].Options["foo"], checker.Equals, "bar") 596 c.Assert(vs[0].Driver, checker.Equals, driverName) 597 598 // simulate out of band volume deletion on plugin level 599 delete(p.vols, "test") 600 601 // test create with different driver 602 out, err = s.d.Cmd("volume", "create", "-d", "local", "--name", "test") 603 c.Assert(err, checker.IsNil, check.Commentf(out)) 604 605 out, err = s.d.Cmd("volume", "inspect", "test") 606 c.Assert(err, checker.IsNil, check.Commentf(out)) 607 vs = nil 608 err = json.Unmarshal([]byte(out), &vs) 609 c.Assert(err, checker.IsNil) 610 c.Assert(vs, checker.HasLen, 1) 611 c.Assert(vs[0].Options, checker.HasLen, 0) 612 c.Assert(vs[0].Driver, checker.Equals, "local") 613 } 614 615 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverUnmountOnMountFail(c *check.C) { 616 s.d.StartWithBusybox(c) 617 s.d.Cmd("volume", "create", "-d", "test-external-volume-driver", "--opt=invalidOption=1", "--name=testumount") 618 619 out, _ := s.d.Cmd("run", "-v", "testumount:/foo", "busybox", "true") 620 c.Assert(s.ec.unmounts, checker.Equals, 0, check.Commentf(out)) 621 out, _ = s.d.Cmd("run", "-w", "/foo", "-v", "testumount:/foo", "busybox", "true") 622 c.Assert(s.ec.unmounts, checker.Equals, 0, check.Commentf(out)) 623 }