github.com/netbrain/docker@v1.9.0-rc2/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  }