github.com/fntlnz/docker@v1.9.0-rc3/volume/drivers/extpoint.go (about) 1 //go:generate pluginrpc-gen -i $GOFILE -o proxy.go -type volumeDriver -name VolumeDriver 2 3 package volumedrivers 4 5 import ( 6 "fmt" 7 "sync" 8 9 "github.com/docker/docker/pkg/plugins" 10 "github.com/docker/docker/volume" 11 ) 12 13 // currently created by hand. generation tool would generate this like: 14 // $ extpoint-gen Driver > volume/extpoint.go 15 16 var drivers = &driverExtpoint{extensions: make(map[string]volume.Driver)} 17 18 // NewVolumeDriver returns a driver has the given name mapped on the given client. 19 func NewVolumeDriver(name string, c client) volume.Driver { 20 proxy := &volumeDriverProxy{c} 21 return &volumeDriverAdapter{name, proxy} 22 } 23 24 type opts map[string]string 25 26 // volumeDriver defines the available functions that volume plugins must implement. 27 // This interface is only defined to generate the proxy objects. 28 // It's not intended to be public or reused. 29 type volumeDriver interface { 30 // Create a volume with the given name 31 Create(name string, opts opts) (err error) 32 // Remove the volume with the given name 33 Remove(name string) (err error) 34 // Get the mountpoint of the given volume 35 Path(name string) (mountpoint string, err error) 36 // Mount the given volume and return the mountpoint 37 Mount(name string) (mountpoint string, err error) 38 // Unmount the given volume 39 Unmount(name string) (err error) 40 } 41 42 type driverExtpoint struct { 43 extensions map[string]volume.Driver 44 sync.Mutex 45 } 46 47 // Register associates the given driver to the given name, checking if 48 // the name is already associated 49 func Register(extension volume.Driver, name string) bool { 50 drivers.Lock() 51 defer drivers.Unlock() 52 if name == "" { 53 return false 54 } 55 _, exists := drivers.extensions[name] 56 if exists { 57 return false 58 } 59 drivers.extensions[name] = extension 60 return true 61 } 62 63 // Unregister dissociates the name from it's driver, if the association exists. 64 func Unregister(name string) bool { 65 drivers.Lock() 66 defer drivers.Unlock() 67 _, exists := drivers.extensions[name] 68 if !exists { 69 return false 70 } 71 delete(drivers.extensions, name) 72 return true 73 } 74 75 // Lookup returns the driver associated with the given name. If a 76 // driver with the given name has not been registered it checks if 77 // there is a VolumeDriver plugin available with the given name. 78 func Lookup(name string) (volume.Driver, error) { 79 drivers.Lock() 80 ext, ok := drivers.extensions[name] 81 drivers.Unlock() 82 if ok { 83 return ext, nil 84 } 85 pl, err := plugins.Get(name, "VolumeDriver") 86 if err != nil { 87 return nil, fmt.Errorf("Error looking up volume plugin %s: %v", name, err) 88 } 89 90 drivers.Lock() 91 defer drivers.Unlock() 92 if ext, ok := drivers.extensions[name]; ok { 93 return ext, nil 94 } 95 96 d := NewVolumeDriver(name, pl.Client) 97 drivers.extensions[name] = d 98 return d, nil 99 } 100 101 // GetDriver returns a volume driver by it's name. 102 // If the driver is empty, it looks for the local driver. 103 func GetDriver(name string) (volume.Driver, error) { 104 if name == "" { 105 name = volume.DefaultDriverName 106 } 107 return Lookup(name) 108 }