2015-07-25 08:35:07 +00:00
|
|
|
// Package plugins provides structures and helper functions to manage Docker
|
|
|
|
// plugins.
|
|
|
|
//
|
|
|
|
// Docker discovers plugins by looking for them in the plugin directory whenever
|
|
|
|
// a user or container tries to use one by name. UNIX domain socket files must
|
|
|
|
// be located under /run/docker/plugins, whereas spec files can be located
|
|
|
|
// either under /etc/docker/plugins or /usr/lib/docker/plugins. This is handled
|
|
|
|
// by the Registry interface, which lets you list all plugins or get a plugin by
|
|
|
|
// its name if it exists.
|
|
|
|
//
|
|
|
|
// The plugins need to implement an HTTP server and bind this to the UNIX socket
|
|
|
|
// or the address specified in the spec files.
|
|
|
|
// A handshake is send at /Plugin.Activate, and plugins are expected to return
|
|
|
|
// a Manifest with a list of of Docker subsystems which this plugin implements.
|
|
|
|
//
|
|
|
|
// In order to use a plugins, you can use the ``Get`` with the name of the
|
|
|
|
// plugin and the subsystem it implements.
|
|
|
|
//
|
|
|
|
// plugin, err := plugins.Get("example", "VolumeDriver")
|
|
|
|
// if err != nil {
|
|
|
|
// return fmt.Errorf("Error looking up volume plugin example: %v", err)
|
|
|
|
// }
|
2015-05-14 17:05:39 +00:00
|
|
|
package plugins
|
|
|
|
|
|
|
|
import (
|
|
|
|
"errors"
|
|
|
|
"sync"
|
2015-08-28 18:55:05 +00:00
|
|
|
"time"
|
2015-05-14 17:05:39 +00:00
|
|
|
|
|
|
|
"github.com/Sirupsen/logrus"
|
2015-12-30 00:27:12 +00:00
|
|
|
"github.com/docker/go-connections/tlsconfig"
|
2015-05-14 17:05:39 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
var (
|
2015-07-25 08:35:07 +00:00
|
|
|
// ErrNotImplements is returned if the plugin does not implement the requested driver.
|
2015-05-14 17:05:39 +00:00
|
|
|
ErrNotImplements = errors.New("Plugin does not implement the requested driver")
|
|
|
|
)
|
|
|
|
|
|
|
|
type plugins struct {
|
|
|
|
sync.Mutex
|
|
|
|
plugins map[string]*Plugin
|
|
|
|
}
|
|
|
|
|
2016-10-19 00:34:09 +00:00
|
|
|
type extpointHandlers struct {
|
|
|
|
sync.RWMutex
|
|
|
|
extpointHandlers map[string][]func(string, *Client)
|
|
|
|
}
|
|
|
|
|
2015-05-15 11:07:59 +00:00
|
|
|
var (
|
2016-10-19 00:34:09 +00:00
|
|
|
storage = plugins{plugins: make(map[string]*Plugin)}
|
|
|
|
handlers = extpointHandlers{extpointHandlers: make(map[string][]func(string, *Client))}
|
2015-05-15 11:07:59 +00:00
|
|
|
)
|
2015-05-14 17:05:39 +00:00
|
|
|
|
2015-07-25 08:35:07 +00:00
|
|
|
// Manifest lists what a plugin implements.
|
2015-05-14 17:05:39 +00:00
|
|
|
type Manifest struct {
|
2015-07-25 08:35:07 +00:00
|
|
|
// List of subsystem the plugin implements.
|
2015-05-14 17:05:39 +00:00
|
|
|
Implements []string
|
|
|
|
}
|
|
|
|
|
2015-07-25 08:35:07 +00:00
|
|
|
// Plugin is the definition of a docker plugin.
|
2015-05-14 17:05:39 +00:00
|
|
|
type Plugin struct {
|
2015-07-25 08:35:07 +00:00
|
|
|
// Name of the plugin
|
2016-05-16 15:50:55 +00:00
|
|
|
name string
|
2015-07-25 08:35:07 +00:00
|
|
|
// Address of the plugin
|
|
|
|
Addr string
|
|
|
|
// TLS configuration of the plugin
|
2016-05-16 15:50:55 +00:00
|
|
|
TLSConfig *tlsconfig.Options
|
2015-07-25 08:35:07 +00:00
|
|
|
// Client attached to the plugin
|
2016-05-16 15:50:55 +00:00
|
|
|
client *Client
|
2015-07-25 08:35:07 +00:00
|
|
|
// Manifest of the plugin (see above)
|
|
|
|
Manifest *Manifest `json:"-"`
|
2015-08-19 05:04:22 +00:00
|
|
|
|
2016-03-23 19:25:15 +00:00
|
|
|
// error produced by activation
|
|
|
|
activateErr error
|
2016-04-08 07:05:31 +00:00
|
|
|
// specifies if the activation sequence is completed (not if it is successful or not)
|
2016-03-23 19:25:15 +00:00
|
|
|
activated bool
|
|
|
|
// wait for activation to finish
|
|
|
|
activateWait *sync.Cond
|
2015-05-27 22:21:18 +00:00
|
|
|
}
|
|
|
|
|
2016-05-16 15:50:55 +00:00
|
|
|
// Name returns the name of the plugin.
|
|
|
|
func (p *Plugin) Name() string {
|
|
|
|
return p.name
|
|
|
|
}
|
|
|
|
|
|
|
|
// Client returns a ready-to-use plugin client that can be used to communicate with the plugin.
|
|
|
|
func (p *Plugin) Client() *Client {
|
|
|
|
return p.client
|
|
|
|
}
|
|
|
|
|
2016-09-08 00:01:10 +00:00
|
|
|
// IsV1 returns true for V1 plugins and false otherwise.
|
|
|
|
func (p *Plugin) IsV1() bool {
|
2016-07-18 22:39:27 +00:00
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2016-05-16 15:50:55 +00:00
|
|
|
// NewLocalPlugin creates a new local plugin.
|
|
|
|
func NewLocalPlugin(name, addr string) *Plugin {
|
2015-05-27 22:21:18 +00:00
|
|
|
return &Plugin{
|
2016-05-16 15:50:55 +00:00
|
|
|
name: name,
|
|
|
|
Addr: addr,
|
|
|
|
// TODO: change to nil
|
|
|
|
TLSConfig: &tlsconfig.Options{InsecureSkipVerify: true},
|
2016-03-23 19:25:15 +00:00
|
|
|
activateWait: sync.NewCond(&sync.Mutex{}),
|
2015-05-27 22:21:18 +00:00
|
|
|
}
|
2015-05-14 17:05:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (p *Plugin) activate() error {
|
2016-03-23 19:25:15 +00:00
|
|
|
p.activateWait.L.Lock()
|
|
|
|
if p.activated {
|
|
|
|
p.activateWait.L.Unlock()
|
|
|
|
return p.activateErr
|
|
|
|
}
|
|
|
|
|
|
|
|
p.activateErr = p.activateWithLock()
|
|
|
|
p.activated = true
|
|
|
|
|
|
|
|
p.activateWait.L.Unlock()
|
|
|
|
p.activateWait.Broadcast()
|
|
|
|
return p.activateErr
|
2015-08-19 05:04:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (p *Plugin) activateWithLock() error {
|
2015-05-27 22:21:18 +00:00
|
|
|
c, err := NewClient(p.Addr, p.TLSConfig)
|
2015-05-14 17:05:39 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2016-05-16 15:50:55 +00:00
|
|
|
p.client = c
|
2015-05-27 22:21:18 +00:00
|
|
|
|
|
|
|
m := new(Manifest)
|
2016-05-16 15:50:55 +00:00
|
|
|
if err = p.client.Call("Plugin.Activate", nil, m); err != nil {
|
2015-05-27 22:21:18 +00:00
|
|
|
return err
|
|
|
|
}
|
2015-05-14 17:05:39 +00:00
|
|
|
|
|
|
|
p.Manifest = m
|
2015-05-27 22:21:18 +00:00
|
|
|
|
2016-10-19 00:34:09 +00:00
|
|
|
handlers.RLock()
|
2015-05-15 11:07:59 +00:00
|
|
|
for _, iface := range m.Implements {
|
2016-10-19 00:34:09 +00:00
|
|
|
hdlrs, handled := handlers.extpointHandlers[iface]
|
2015-05-15 11:07:59 +00:00
|
|
|
if !handled {
|
|
|
|
continue
|
|
|
|
}
|
2016-10-19 00:34:09 +00:00
|
|
|
for _, handler := range hdlrs {
|
2016-10-15 05:40:28 +00:00
|
|
|
handler(p.name, p.client)
|
|
|
|
}
|
2015-05-15 11:07:59 +00:00
|
|
|
}
|
2016-10-19 00:34:09 +00:00
|
|
|
handlers.RUnlock()
|
2015-05-14 17:05:39 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-03-23 19:25:15 +00:00
|
|
|
func (p *Plugin) waitActive() error {
|
|
|
|
p.activateWait.L.Lock()
|
|
|
|
for !p.activated {
|
|
|
|
p.activateWait.Wait()
|
|
|
|
}
|
|
|
|
p.activateWait.L.Unlock()
|
|
|
|
return p.activateErr
|
|
|
|
}
|
|
|
|
|
2015-09-23 20:29:14 +00:00
|
|
|
func (p *Plugin) implements(kind string) bool {
|
2016-03-23 19:25:15 +00:00
|
|
|
if err := p.waitActive(); err != nil {
|
|
|
|
return false
|
|
|
|
}
|
2015-09-23 20:29:14 +00:00
|
|
|
for _, driver := range p.Manifest.Implements {
|
|
|
|
if driver == kind {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2015-05-14 17:05:39 +00:00
|
|
|
func load(name string) (*Plugin, error) {
|
2015-08-28 18:55:05 +00:00
|
|
|
return loadWithRetry(name, true)
|
|
|
|
}
|
|
|
|
|
|
|
|
func loadWithRetry(name string, retry bool) (*Plugin, error) {
|
2015-06-15 22:35:49 +00:00
|
|
|
registry := newLocalRegistry()
|
2015-08-28 18:55:05 +00:00
|
|
|
start := time.Now()
|
|
|
|
|
|
|
|
var retries int
|
|
|
|
for {
|
|
|
|
pl, err := registry.Plugin(name)
|
|
|
|
if err != nil {
|
|
|
|
if !retry {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
timeOff := backoff(retries)
|
|
|
|
if abort(start, timeOff) {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
retries++
|
|
|
|
logrus.Warnf("Unable to locate plugin: %s, retrying in %v", name, timeOff)
|
|
|
|
time.Sleep(timeOff)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
storage.Lock()
|
2015-08-19 05:04:22 +00:00
|
|
|
storage.plugins[name] = pl
|
2015-08-28 18:55:05 +00:00
|
|
|
storage.Unlock()
|
2015-08-19 05:04:22 +00:00
|
|
|
|
2015-08-28 18:55:05 +00:00
|
|
|
err = pl.activate()
|
2015-08-19 05:04:22 +00:00
|
|
|
|
2015-08-28 18:55:05 +00:00
|
|
|
if err != nil {
|
|
|
|
storage.Lock()
|
|
|
|
delete(storage.plugins, name)
|
|
|
|
storage.Unlock()
|
|
|
|
}
|
2015-08-19 05:04:22 +00:00
|
|
|
|
2015-08-28 18:55:05 +00:00
|
|
|
return pl, err
|
2015-05-14 17:05:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func get(name string) (*Plugin, error) {
|
|
|
|
storage.Lock()
|
|
|
|
pl, ok := storage.plugins[name]
|
2015-08-19 05:04:22 +00:00
|
|
|
storage.Unlock()
|
2015-05-14 17:05:39 +00:00
|
|
|
if ok {
|
2015-08-19 05:04:22 +00:00
|
|
|
return pl, pl.activate()
|
2015-05-14 17:05:39 +00:00
|
|
|
}
|
2015-08-19 05:04:22 +00:00
|
|
|
return load(name)
|
2015-05-14 17:05:39 +00:00
|
|
|
}
|
|
|
|
|
2015-07-25 08:35:07 +00:00
|
|
|
// Get returns the plugin given the specified name and requested implementation.
|
2015-05-14 17:05:39 +00:00
|
|
|
func Get(name, imp string) (*Plugin, error) {
|
|
|
|
pl, err := get(name)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2015-09-23 20:29:14 +00:00
|
|
|
if pl.implements(imp) {
|
|
|
|
logrus.Debugf("%s implements: %s", name, imp)
|
|
|
|
return pl, nil
|
2015-05-14 17:05:39 +00:00
|
|
|
}
|
|
|
|
return nil, ErrNotImplements
|
|
|
|
}
|
2015-05-15 11:07:59 +00:00
|
|
|
|
2015-07-25 08:35:07 +00:00
|
|
|
// Handle adds the specified function to the extpointHandlers.
|
2015-05-15 11:07:59 +00:00
|
|
|
func Handle(iface string, fn func(string, *Client)) {
|
2016-10-19 00:34:09 +00:00
|
|
|
handlers.Lock()
|
|
|
|
hdlrs, ok := handlers.extpointHandlers[iface]
|
2016-10-15 05:40:28 +00:00
|
|
|
if !ok {
|
2016-10-19 00:34:09 +00:00
|
|
|
hdlrs = []func(string, *Client){}
|
2016-10-15 05:40:28 +00:00
|
|
|
}
|
|
|
|
|
2016-10-19 00:34:09 +00:00
|
|
|
hdlrs = append(hdlrs, fn)
|
|
|
|
handlers.extpointHandlers[iface] = hdlrs
|
2016-10-15 05:40:28 +00:00
|
|
|
for _, p := range storage.plugins {
|
|
|
|
p.activated = false
|
|
|
|
}
|
2016-10-19 00:34:09 +00:00
|
|
|
handlers.Unlock()
|
2015-05-15 11:07:59 +00:00
|
|
|
}
|
2015-09-23 20:29:14 +00:00
|
|
|
|
|
|
|
// GetAll returns all the plugins for the specified implementation
|
|
|
|
func GetAll(imp string) ([]*Plugin, error) {
|
|
|
|
pluginNames, err := Scan()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
type plLoad struct {
|
|
|
|
pl *Plugin
|
|
|
|
err error
|
|
|
|
}
|
|
|
|
|
2016-02-26 16:57:44 +00:00
|
|
|
chPl := make(chan *plLoad, len(pluginNames))
|
|
|
|
var wg sync.WaitGroup
|
2015-09-23 20:29:14 +00:00
|
|
|
for _, name := range pluginNames {
|
2016-02-26 16:57:44 +00:00
|
|
|
if pl, ok := storage.plugins[name]; ok {
|
|
|
|
chPl <- &plLoad{pl, nil}
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
wg.Add(1)
|
2015-09-23 20:29:14 +00:00
|
|
|
go func(name string) {
|
2016-02-26 16:57:44 +00:00
|
|
|
defer wg.Done()
|
2015-09-23 20:29:14 +00:00
|
|
|
pl, err := loadWithRetry(name, false)
|
2016-02-26 16:57:44 +00:00
|
|
|
chPl <- &plLoad{pl, err}
|
2015-09-23 20:29:14 +00:00
|
|
|
}(name)
|
|
|
|
}
|
|
|
|
|
2016-02-26 16:57:44 +00:00
|
|
|
wg.Wait()
|
|
|
|
close(chPl)
|
|
|
|
|
2015-09-23 20:29:14 +00:00
|
|
|
var out []*Plugin
|
2016-02-26 16:57:44 +00:00
|
|
|
for pl := range chPl {
|
2015-09-23 20:29:14 +00:00
|
|
|
if pl.err != nil {
|
2016-03-23 19:25:15 +00:00
|
|
|
logrus.Error(pl.err)
|
2015-09-23 20:29:14 +00:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
if pl.pl.implements(imp) {
|
|
|
|
out = append(out, pl.pl)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return out, nil
|
|
|
|
}
|