Vendor in container storage

This should add quota support to cri-o

Signed-off-by: Daniel J Walsh <dwalsh@redhat.com>

vendor/github.com/containers/storage/pkg/archive/example_changes.go

@@ -0,0 +1,97 @@
+// +build ignore
+
+// Simple tool to create an archive stream from an old and new directory
+//
+// By default it will stream the comparison of two temporary directories with junk files
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path"
+
+	"github.com/containers/storage/pkg/archive"
+	"github.com/sirupsen/logrus"
+)
+
+var (
+	flDebug  = flag.Bool("D", false, "debugging output")
+	flNewDir = flag.String("newdir", "", "")
+	flOldDir = flag.String("olddir", "", "")
+	log      = logrus.New()
+)
+
+func main() {
+	flag.Usage = func() {
+		fmt.Println("Produce a tar from comparing two directory paths. By default a demo tar is created of around 200 files (including hardlinks)")
+		fmt.Printf("%s [OPTIONS]\n", os.Args[0])
+		flag.PrintDefaults()
+	}
+	flag.Parse()
+	log.Out = os.Stderr
+	if (len(os.Getenv("DEBUG")) > 0) || *flDebug {
+		logrus.SetLevel(logrus.DebugLevel)
+	}
+	var newDir, oldDir string
+
+	if len(*flNewDir) == 0 {
+		var err error
+		newDir, err = ioutil.TempDir("", "storage-test-newDir")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(newDir)
+		if _, err := prepareUntarSourceDirectory(100, newDir, true); err != nil {
+			log.Fatal(err)
+		}
+	} else {
+		newDir = *flNewDir
+	}
+
+	if len(*flOldDir) == 0 {
+		oldDir, err := ioutil.TempDir("", "storage-test-oldDir")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(oldDir)
+	} else {
+		oldDir = *flOldDir
+	}
+
+	changes, err := archive.ChangesDirs(newDir, oldDir)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	a, err := archive.ExportChanges(newDir, changes)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer a.Close()
+
+	i, err := io.Copy(os.Stdout, a)
+	if err != nil && err != io.EOF {
+		log.Fatal(err)
+	}
+	fmt.Fprintf(os.Stderr, "wrote archive of %d bytes", i)
+}
+
+func prepareUntarSourceDirectory(numberOfFiles int, targetPath string, makeLinks bool) (int, error) {
+	fileData := []byte("fooo")
+	for n := 0; n < numberOfFiles; n++ {
+		fileName := fmt.Sprintf("file-%d", n)
+		if err := ioutil.WriteFile(path.Join(targetPath, fileName), fileData, 0700); err != nil {
+			return 0, err
+		}
+		if makeLinks {
+			if err := os.Link(path.Join(targetPath, fileName), path.Join(targetPath, fileName+"-link")); err != nil {
+				return 0, err
+			}
+		}
+	}
+	totalSize := numberOfFiles * len(fileData)
+	return totalSize, nil
+}

vendor/github.com/containers/storage/pkg/dmesg/dmesg_linux.go

@@ -0,0 +1,20 @@
+// +build linux
+
+package dmesg
+
+import (
+	"unsafe"
+
+	"golang.org/x/sys/unix"
+)
+
+// Dmesg returns last messages from the kernel log, up to size bytes
+func Dmesg(size int) []byte {
+	t := uintptr(3) // SYSLOG_ACTION_READ_ALL
+	b := make([]byte, size)
+	amt, _, err := unix.Syscall(unix.SYS_SYSLOG, t, uintptr(unsafe.Pointer(&b[0])), uintptr(len(b)))
+	if err != 0 {
+		return []byte{}
+	}
+	return b[:amt]
+}

vendor/github.com/containers/storage/pkg/fsutils/fsutils_linux.go

@@ -0,0 +1,88 @@
+// +build linux
+
+package fsutils
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"unsafe"
+
+	"golang.org/x/sys/unix"
+)
+
+func locateDummyIfEmpty(path string) (string, error) {
+	children, err := ioutil.ReadDir(path)
+	if err != nil {
+		return "", err
+	}
+	if len(children) != 0 {
+		return "", nil
+	}
+	dummyFile, err := ioutil.TempFile(path, "fsutils-dummy")
+	if err != nil {
+		return "", err
+	}
+	name := dummyFile.Name()
+	err = dummyFile.Close()
+	return name, err
+}
+
+// SupportsDType returns whether the filesystem mounted on path supports d_type
+func SupportsDType(path string) (bool, error) {
+	// locate dummy so that we have at least one dirent
+	dummy, err := locateDummyIfEmpty(path)
+	if err != nil {
+		return false, err
+	}
+	if dummy != "" {
+		defer os.Remove(dummy)
+	}
+
+	visited := 0
+	supportsDType := true
+	fn := func(ent *unix.Dirent) bool {
+		visited++
+		if ent.Type == unix.DT_UNKNOWN {
+			supportsDType = false
+			// stop iteration
+			return true
+		}
+		// continue iteration
+		return false
+	}
+	if err = iterateReadDir(path, fn); err != nil {
+		return false, err
+	}
+	if visited == 0 {
+		return false, fmt.Errorf("did not hit any dirent during iteration %s", path)
+	}
+	return supportsDType, nil
+}
+
+func iterateReadDir(path string, fn func(*unix.Dirent) bool) error {
+	d, err := os.Open(path)
+	if err != nil {
+		return err
+	}
+	defer d.Close()
+	fd := int(d.Fd())
+	buf := make([]byte, 4096)
+	for {
+		nbytes, err := unix.ReadDirent(fd, buf)
+		if err != nil {
+			return err
+		}
+		if nbytes == 0 {
+			break
+		}
+		for off := 0; off < nbytes; {
+			ent := (*unix.Dirent)(unsafe.Pointer(&buf[off]))
+			if stop := fn(ent); stop {
+				return nil
+			}
+			off += int(ent.Reclen)
+		}
+	}
+	return nil
+}

vendor/github.com/containers/storage/pkg/locker/README.md

@@ -0,0 +1,65 @@
+Locker
+=====
+
+locker provides a mechanism for creating finer-grained locking to help
+free up more global locks to handle other tasks.
+
+The implementation looks close to a sync.Mutex, however, the user must provide a
+reference to use to refer to the underlying lock when locking and unlocking,
+and unlock may generate an error.
+
+If a lock with a given name does not exist when `Lock` is called, one is
+created.
+Lock references are automatically cleaned up on `Unlock` if nothing else is
+waiting for the lock.
+
+
+## Usage
+
+```go
+package important
+
+import (
+	"sync"
+	"time"
+
+	"github.com/containers/storage/pkg/locker"
+)
+
+type important struct {
+	locks *locker.Locker
+	data  map[string]interface{}
+	mu    sync.Mutex
+}
+
+func (i *important) Get(name string) interface{} {
+	i.locks.Lock(name)
+	defer i.locks.Unlock(name)
+	return data[name]
+}
+
+func (i *important) Create(name string, data interface{}) {
+	i.locks.Lock(name)
+	defer i.locks.Unlock(name)
+
+	i.createImportant(data)
+
+	s.mu.Lock()
+	i.data[name] = data
+	s.mu.Unlock()
+}
+
+func (i *important) createImportant(data interface{}) {
+	time.Sleep(10 * time.Second)
+}
+```
+
+For functions dealing with a given name, always lock at the beginning of the
+function (or before doing anything with the underlying state), this ensures any
+other function that is dealing with the same name will block.
+
+When needing to modify the underlying data, use the global lock to ensure nothing
+else is modifying it at the same time.
+Since name lock is already in place, no reads will occur while the modification
+is being performed.
+

vendor/github.com/containers/storage/pkg/locker/locker.go

@@ -0,0 +1,112 @@
+/*
+Package locker provides a mechanism for creating finer-grained locking to help
+free up more global locks to handle other tasks.
+
+The implementation looks close to a sync.Mutex, however the user must provide a
+reference to use to refer to the underlying lock when locking and unlocking,
+and unlock may generate an error.
+
+If a lock with a given name does not exist when `Lock` is called, one is
+created.
+Lock references are automatically cleaned up on `Unlock` if nothing else is
+waiting for the lock.
+*/
+package locker
+
+import (
+	"errors"
+	"sync"
+	"sync/atomic"
+)
+
+// ErrNoSuchLock is returned when the requested lock does not exist
+var ErrNoSuchLock = errors.New("no such lock")
+
+// Locker provides a locking mechanism based on the passed in reference name
+type Locker struct {
+	mu    sync.Mutex
+	locks map[string]*lockCtr
+}
+
+// lockCtr is used by Locker to represent a lock with a given name.
+type lockCtr struct {
+	mu sync.Mutex
+	// waiters is the number of waiters waiting to acquire the lock
+	// this is int32 instead of uint32 so we can add `-1` in `dec()`
+	waiters int32
+}
+
+// inc increments the number of waiters waiting for the lock
+func (l *lockCtr) inc() {
+	atomic.AddInt32(&l.waiters, 1)
+}
+
+// dec decrements the number of waiters waiting on the lock
+func (l *lockCtr) dec() {
+	atomic.AddInt32(&l.waiters, -1)
+}
+
+// count gets the current number of waiters
+func (l *lockCtr) count() int32 {
+	return atomic.LoadInt32(&l.waiters)
+}
+
+// Lock locks the mutex
+func (l *lockCtr) Lock() {
+	l.mu.Lock()
+}
+
+// Unlock unlocks the mutex
+func (l *lockCtr) Unlock() {
+	l.mu.Unlock()
+}
+
+// New creates a new Locker
+func New() *Locker {
+	return &Locker{
+		locks: make(map[string]*lockCtr),
+	}
+}
+
+// Lock locks a mutex with the given name. If it doesn't exist, one is created
+func (l *Locker) Lock(name string) {
+	l.mu.Lock()
+	if l.locks == nil {
+		l.locks = make(map[string]*lockCtr)
+	}
+
+	nameLock, exists := l.locks[name]
+	if !exists {
+		nameLock = &lockCtr{}
+		l.locks[name] = nameLock
+	}
+
+	// increment the nameLock waiters while inside the main mutex
+	// this makes sure that the lock isn't deleted if `Lock` and `Unlock` are called concurrently
+	nameLock.inc()
+	l.mu.Unlock()
+
+	// Lock the nameLock outside the main mutex so we don't block other operations
+	// once locked then we can decrement the number of waiters for this lock
+	nameLock.Lock()
+	nameLock.dec()
+}
+
+// Unlock unlocks the mutex with the given name
+// If the given lock is not being waited on by any other callers, it is deleted
+func (l *Locker) Unlock(name string) error {
+	l.mu.Lock()
+	nameLock, exists := l.locks[name]
+	if !exists {
+		l.mu.Unlock()
+		return ErrNoSuchLock
+	}
+
+	if nameLock.count() == 0 {
+		delete(l.locks, name)
+	}
+	nameLock.Unlock()
+
+	l.mu.Unlock()
+	return nil
+}

vendor/github.com/containers/storage/pkg/plugins/client.go

@@ -1,205 +0,0 @@
-package plugins
-
-import (
-	"bytes"
-	"encoding/json"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-	"time"
-
-	"github.com/containers/storage/pkg/plugins/transport"
-	"github.com/docker/go-connections/sockets"
-	"github.com/docker/go-connections/tlsconfig"
-	"github.com/sirupsen/logrus"
-)
-
-const (
-	defaultTimeOut = 30
-)
-
-func newTransport(addr string, tlsConfig *tlsconfig.Options) (transport.Transport, error) {
-	tr := &http.Transport{}
-
-	if tlsConfig != nil {
-		c, err := tlsconfig.Client(*tlsConfig)
-		if err != nil {
-			return nil, err
-		}
-		tr.TLSClientConfig = c
-	}
-
-	u, err := url.Parse(addr)
-	if err != nil {
-		return nil, err
-	}
-	socket := u.Host
-	if socket == "" {
-		// valid local socket addresses have the host empty.
-		socket = u.Path
-	}
-	if err := sockets.ConfigureTransport(tr, u.Scheme, socket); err != nil {
-		return nil, err
-	}
-	scheme := httpScheme(u)
-
-	return transport.NewHTTPTransport(tr, scheme, socket), nil
-}
-
-// NewClient creates a new plugin client (http).
-func NewClient(addr string, tlsConfig *tlsconfig.Options) (*Client, error) {
-	clientTransport, err := newTransport(addr, tlsConfig)
-	if err != nil {
-		return nil, err
-	}
-	return newClientWithTransport(clientTransport, 0), nil
-}
-
-// NewClientWithTimeout creates a new plugin client (http).
-func NewClientWithTimeout(addr string, tlsConfig *tlsconfig.Options, timeout time.Duration) (*Client, error) {
-	clientTransport, err := newTransport(addr, tlsConfig)
-	if err != nil {
-		return nil, err
-	}
-	return newClientWithTransport(clientTransport, timeout), nil
-}
-
-// newClientWithTransport creates a new plugin client with a given transport.
-func newClientWithTransport(tr transport.Transport, timeout time.Duration) *Client {
-	return &Client{
-		http: &http.Client{
-			Transport: tr,
-			Timeout:   timeout,
-		},
-		requestFactory: tr,
-	}
-}
-
-// Client represents a plugin client.
-type Client struct {
-	http           *http.Client // http client to use
-	requestFactory transport.RequestFactory
-}
-
-// Call calls the specified method with the specified arguments for the plugin.
-// It will retry for 30 seconds if a failure occurs when calling.
-func (c *Client) Call(serviceMethod string, args interface{}, ret interface{}) error {
-	var buf bytes.Buffer
-	if args != nil {
-		if err := json.NewEncoder(&buf).Encode(args); err != nil {
-			return err
-		}
-	}
-	body, err := c.callWithRetry(serviceMethod, &buf, true)
-	if err != nil {
-		return err
-	}
-	defer body.Close()
-	if ret != nil {
-		if err := json.NewDecoder(body).Decode(&ret); err != nil {
-			logrus.Errorf("%s: error reading plugin resp: %v", serviceMethod, err)
-			return err
-		}
-	}
-	return nil
-}
-
-// Stream calls the specified method with the specified arguments for the plugin and returns the response body
-func (c *Client) Stream(serviceMethod string, args interface{}) (io.ReadCloser, error) {
-	var buf bytes.Buffer
-	if err := json.NewEncoder(&buf).Encode(args); err != nil {
-		return nil, err
-	}
-	return c.callWithRetry(serviceMethod, &buf, true)
-}
-
-// SendFile calls the specified method, and passes through the IO stream
-func (c *Client) SendFile(serviceMethod string, data io.Reader, ret interface{}) error {
-	body, err := c.callWithRetry(serviceMethod, data, true)
-	if err != nil {
-		return err
-	}
-	defer body.Close()
-	if err := json.NewDecoder(body).Decode(&ret); err != nil {
-		logrus.Errorf("%s: error reading plugin resp: %v", serviceMethod, err)
-		return err
-	}
-	return nil
-}
-
-func (c *Client) callWithRetry(serviceMethod string, data io.Reader, retry bool) (io.ReadCloser, error) {
-	var retries int
-	start := time.Now()
-
-	for {
-		req, err := c.requestFactory.NewRequest(serviceMethod, data)
-		if err != nil {
-			return nil, err
-		}
-
-		resp, err := c.http.Do(req)
-		if err != nil {
-			if !retry {
-				return nil, err
-			}
-
-			timeOff := backoff(retries)
-			if abort(start, timeOff) {
-				return nil, err
-			}
-			retries++
-			logrus.Warnf("Unable to connect to plugin: %s%s: %v, retrying in %v", req.URL.Host, req.URL.Path, err, timeOff)
-			time.Sleep(timeOff)
-			continue
-		}
-
-		if resp.StatusCode != http.StatusOK {
-			b, err := ioutil.ReadAll(resp.Body)
-			resp.Body.Close()
-			if err != nil {
-				return nil, &statusError{resp.StatusCode, serviceMethod, err.Error()}
-			}
-
-			// Plugins' Response(s) should have an Err field indicating what went
-			// wrong. Try to unmarshal into ResponseErr. Otherwise fallback to just
-			// return the string(body)
-			type responseErr struct {
-				Err string
-			}
-			remoteErr := responseErr{}
-			if err := json.Unmarshal(b, &remoteErr); err == nil {
-				if remoteErr.Err != "" {
-					return nil, &statusError{resp.StatusCode, serviceMethod, remoteErr.Err}
-				}
-			}
-			// old way...
-			return nil, &statusError{resp.StatusCode, serviceMethod, string(b)}
-		}
-		return resp.Body, nil
-	}
-}
-
-func backoff(retries int) time.Duration {
-	b, max := 1, defaultTimeOut
-	for b < max && retries > 0 {
-		b *= 2
-		retries--
-	}
-	if b > max {
-		b = max
-	}
-	return time.Duration(b) * time.Second
-}
-
-func abort(start time.Time, timeOff time.Duration) bool {
-	return timeOff+time.Since(start) >= time.Duration(defaultTimeOut)*time.Second
-}
-
-func httpScheme(u *url.URL) string {
-	scheme := u.Scheme
-	if scheme != "https" {
-		scheme = "http"
-	}
-	return scheme
-}

vendor/github.com/containers/storage/pkg/plugins/discovery.go

@@ -1,131 +0,0 @@
-package plugins
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"net/url"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-)
-
-var (
-	// ErrNotFound plugin not found
-	ErrNotFound = errors.New("plugin not found")
-	socketsPath = "/run/container/storage/plugins"
-)
-
-// localRegistry defines a registry that is local (using unix socket).
-type localRegistry struct{}
-
-func newLocalRegistry() localRegistry {
-	return localRegistry{}
-}
-
-// Scan scans all the plugin paths and returns all the names it found
-func Scan() ([]string, error) {
-	var names []string
-	if err := filepath.Walk(socketsPath, func(path string, fi os.FileInfo, err error) error {
-		if err != nil {
-			return nil
-		}
-
-		if fi.Mode()&os.ModeSocket != 0 {
-			name := strings.TrimSuffix(fi.Name(), filepath.Ext(fi.Name()))
-			names = append(names, name)
-		}
-		return nil
-	}); err != nil {
-		return nil, err
-	}
-
-	for _, path := range specsPaths {
-		if err := filepath.Walk(path, func(p string, fi os.FileInfo, err error) error {
-			if err != nil || fi.IsDir() {
-				return nil
-			}
-			name := strings.TrimSuffix(fi.Name(), filepath.Ext(fi.Name()))
-			names = append(names, name)
-			return nil
-		}); err != nil {
-			return nil, err
-		}
-	}
-	return names, nil
-}
-
-// Plugin returns the plugin registered with the given name (or returns an error).
-func (l *localRegistry) Plugin(name string) (*Plugin, error) {
-	socketpaths := pluginPaths(socketsPath, name, ".sock")
-
-	for _, p := range socketpaths {
-		if fi, err := os.Stat(p); err == nil && fi.Mode()&os.ModeSocket != 0 {
-			return NewLocalPlugin(name, "unix://"+p), nil
-		}
-	}
-
-	var txtspecpaths []string
-	for _, p := range specsPaths {
-		txtspecpaths = append(txtspecpaths, pluginPaths(p, name, ".spec")...)
-		txtspecpaths = append(txtspecpaths, pluginPaths(p, name, ".json")...)
-	}
-
-	for _, p := range txtspecpaths {
-		if _, err := os.Stat(p); err == nil {
-			if strings.HasSuffix(p, ".json") {
-				return readPluginJSONInfo(name, p)
-			}
-			return readPluginInfo(name, p)
-		}
-	}
-	return nil, ErrNotFound
-}
-
-func readPluginInfo(name, path string) (*Plugin, error) {
-	content, err := ioutil.ReadFile(path)
-	if err != nil {
-		return nil, err
-	}
-	addr := strings.TrimSpace(string(content))
-
-	u, err := url.Parse(addr)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(u.Scheme) == 0 {
-		return nil, fmt.Errorf("Unknown protocol")
-	}
-
-	return NewLocalPlugin(name, addr), nil
-}
-
-func readPluginJSONInfo(name, path string) (*Plugin, error) {
-	f, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-	defer f.Close()
-
-	var p Plugin
-	if err := json.NewDecoder(f).Decode(&p); err != nil {
-		return nil, err
-	}
-	p.name = name
-	if p.TLSConfig != nil && len(p.TLSConfig.CAFile) == 0 {
-		p.TLSConfig.InsecureSkipVerify = true
-	}
-	p.activateWait = sync.NewCond(&sync.Mutex{})
-
-	return &p, nil
-}
-
-func pluginPaths(base, name, ext string) []string {
-	return []string{
-		filepath.Join(base, name+ext),
-		filepath.Join(base, name, name+ext),
-	}
-}

vendor/github.com/containers/storage/pkg/plugins/discovery_unix.go

@@ -1,5 +0,0 @@
-// +build !windows
-
-package plugins
-
-var specsPaths = []string{"/etc/containers/storage/plugins", "/usr/lib/containers/storage/plugins"}

vendor/github.com/containers/storage/pkg/plugins/discovery_windows.go

@@ -1,8 +0,0 @@
-package plugins
-
-import (
-	"os"
-	"path/filepath"
-)
-
-var specsPaths = []string{filepath.Join(os.Getenv("programdata"), "containers", "storage", "plugins")}

vendor/github.com/containers/storage/pkg/plugins/errors.go

@@ -1,33 +0,0 @@
-package plugins
-
-import (
-	"fmt"
-	"net/http"
-)
-
-type statusError struct {
-	status int
-	method string
-	err    string
-}
-
-// Error returns a formatted string for this error type
-func (e *statusError) Error() string {
-	return fmt.Sprintf("%s: %v", e.method, e.err)
-}
-
-// IsNotFound indicates if the passed in error is from an http.StatusNotFound from the plugin
-func IsNotFound(err error) bool {
-	return isStatusError(err, http.StatusNotFound)
-}
-
-func isStatusError(err error, status int) bool {
-	if err == nil {
-		return false
-	}
-	e, ok := err.(*statusError)
-	if !ok {
-		return false
-	}
-	return e.status == status
-}

vendor/github.com/containers/storage/pkg/plugins/plugins.go

@@ -1,329 +0,0 @@
-// 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/container/storage/plugins, whereas spec files can be located
-// either under /etc/container/storage/plugins or /usr/lib/container/storage/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)
-//	}
-package plugins
-
-import (
-	"errors"
-	"sync"
-	"time"
-
-	"github.com/docker/go-connections/tlsconfig"
-	"github.com/sirupsen/logrus"
-)
-
-var (
-	// ErrNotImplements is returned if the plugin does not implement the requested driver.
-	ErrNotImplements = errors.New("Plugin does not implement the requested driver")
-)
-
-type plugins struct {
-	sync.Mutex
-	plugins map[string]*Plugin
-}
-
-type extpointHandlers struct {
-	sync.RWMutex
-	extpointHandlers map[string][]func(string, *Client)
-}
-
-var (
-	storage  = plugins{plugins: make(map[string]*Plugin)}
-	handlers = extpointHandlers{extpointHandlers: make(map[string][]func(string, *Client))}
-)
-
-// Manifest lists what a plugin implements.
-type Manifest struct {
-	// List of subsystem the plugin implements.
-	Implements []string
-}
-
-// Plugin is the definition of a container/storage plugin.
-type Plugin struct {
-	// Name of the plugin
-	name string
-	// Address of the plugin
-	Addr string
-	// TLS configuration of the plugin
-	TLSConfig *tlsconfig.Options
-	// Client attached to the plugin
-	client *Client
-	// Manifest of the plugin (see above)
-	Manifest *Manifest `json:"-"`
-
-	// wait for activation to finish
-	activateWait *sync.Cond
-	// error produced by activation
-	activateErr error
-	// keeps track of callback handlers run against this plugin
-	handlersRun bool
-}
-
-// 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
-}
-
-// IsV1 returns true for V1 plugins and false otherwise.
-func (p *Plugin) IsV1() bool {
-	return true
-}
-
-// NewLocalPlugin creates a new local plugin.
-func NewLocalPlugin(name, addr string) *Plugin {
-	return &Plugin{
-		name: name,
-		Addr: addr,
-		// TODO: change to nil
-		TLSConfig:    &tlsconfig.Options{InsecureSkipVerify: true},
-		activateWait: sync.NewCond(&sync.Mutex{}),
-	}
-}
-
-func (p *Plugin) activate() error {
-	p.activateWait.L.Lock()
-
-	if p.activated() {
-		p.runHandlers()
-		p.activateWait.L.Unlock()
-		return p.activateErr
-	}
-
-	p.activateErr = p.activateWithLock()
-
-	p.runHandlers()
-	p.activateWait.L.Unlock()
-	p.activateWait.Broadcast()
-	return p.activateErr
-}
-
-// runHandlers runs the registered handlers for the implemented plugin types
-// This should only be run after activation, and while the activation lock is held.
-func (p *Plugin) runHandlers() {
-	if !p.activated() {
-		return
-	}
-
-	handlers.RLock()
-	if !p.handlersRun {
-		for _, iface := range p.Manifest.Implements {
-			hdlrs, handled := handlers.extpointHandlers[iface]
-			if !handled {
-				continue
-			}
-			for _, handler := range hdlrs {
-				handler(p.name, p.client)
-			}
-		}
-		p.handlersRun = true
-	}
-	handlers.RUnlock()
-
-}
-
-// activated returns if the plugin has already been activated.
-// This should only be called with the activation lock held
-func (p *Plugin) activated() bool {
-	return p.Manifest != nil
-}
-
-func (p *Plugin) activateWithLock() error {
-	c, err := NewClient(p.Addr, p.TLSConfig)
-	if err != nil {
-		return err
-	}
-	p.client = c
-
-	m := new(Manifest)
-	if err = p.client.Call("Plugin.Activate", nil, m); err != nil {
-		return err
-	}
-
-	p.Manifest = m
-	return nil
-}
-
-func (p *Plugin) waitActive() error {
-	p.activateWait.L.Lock()
-	for !p.activated() && p.activateErr == nil {
-		p.activateWait.Wait()
-	}
-	p.activateWait.L.Unlock()
-	return p.activateErr
-}
-
-func (p *Plugin) implements(kind string) bool {
-	if p.Manifest == nil {
-		return false
-	}
-	for _, driver := range p.Manifest.Implements {
-		if driver == kind {
-			return true
-		}
-	}
-	return false
-}
-
-func load(name string) (*Plugin, error) {
-	return loadWithRetry(name, true)
-}
-
-func loadWithRetry(name string, retry bool) (*Plugin, error) {
-	registry := newLocalRegistry()
-	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()
-		if pl, exists := storage.plugins[name]; exists {
-			storage.Unlock()
-			return pl, pl.activate()
-		}
-		storage.plugins[name] = pl
-		storage.Unlock()
-
-		err = pl.activate()
-
-		if err != nil {
-			storage.Lock()
-			delete(storage.plugins, name)
-			storage.Unlock()
-		}
-
-		return pl, err
-	}
-}
-
-func get(name string) (*Plugin, error) {
-	storage.Lock()
-	pl, ok := storage.plugins[name]
-	storage.Unlock()
-	if ok {
-		return pl, pl.activate()
-	}
-	return load(name)
-}
-
-// Get returns the plugin given the specified name and requested implementation.
-func Get(name, imp string) (*Plugin, error) {
-	pl, err := get(name)
-	if err != nil {
-		return nil, err
-	}
-	if err := pl.waitActive(); err == nil && pl.implements(imp) {
-		logrus.Debugf("%s implements: %s", name, imp)
-		return pl, nil
-	}
-	return nil, ErrNotImplements
-}
-
-// Handle adds the specified function to the extpointHandlers.
-func Handle(iface string, fn func(string, *Client)) {
-	handlers.Lock()
-	hdlrs, ok := handlers.extpointHandlers[iface]
-	if !ok {
-		hdlrs = []func(string, *Client){}
-	}
-
-	hdlrs = append(hdlrs, fn)
-	handlers.extpointHandlers[iface] = hdlrs
-
-	storage.Lock()
-	for _, p := range storage.plugins {
-		p.activateWait.L.Lock()
-		if p.activated() && p.implements(iface) {
-			p.handlersRun = false
-		}
-		p.activateWait.L.Unlock()
-	}
-	storage.Unlock()
-
-	handlers.Unlock()
-}
-
-// 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
-	}
-
-	chPl := make(chan *plLoad, len(pluginNames))
-	var wg sync.WaitGroup
-	for _, name := range pluginNames {
-		storage.Lock()
-		pl, ok := storage.plugins[name]
-		storage.Unlock()
-		if ok {
-			chPl <- &plLoad{pl, nil}
-			continue
-		}
-
-		wg.Add(1)
-		go func(name string) {
-			defer wg.Done()
-			pl, err := loadWithRetry(name, false)
-			chPl <- &plLoad{pl, err}
-		}(name)
-	}
-
-	wg.Wait()
-	close(chPl)
-
-	var out []*Plugin
-	for pl := range chPl {
-		if pl.err != nil {
-			logrus.Error(pl.err)
-			continue
-		}
-		if err := pl.pl.waitActive(); err == nil && pl.pl.implements(imp) {
-			out = append(out, pl.pl)
-		}
-	}
-	return out, nil
-}

vendor/github.com/containers/storage/pkg/plugins/plugins_unix.go

@@ -1,9 +0,0 @@
-// +build !windows
-
-package plugins
-
-// BasePath returns the path to which all paths returned by the plugin are relative to.
-// For v1 plugins, this always returns the host's root directory.
-func (p *Plugin) BasePath() string {
-	return "/"
-}

vendor/github.com/containers/storage/pkg/plugins/plugins_windows.go

@@ -1,8 +0,0 @@
-package plugins
-
-// BasePath returns the path to which all paths returned by the plugin are relative to.
-// For Windows v1 plugins, this returns an empty string, since the plugin is already aware
-// of the absolute path of the mount.
-func (p *Plugin) BasePath() string {
-	return ""
-}

vendor/github.com/containers/storage/pkg/plugins/transport/http.go

@@ -1,36 +0,0 @@
-package transport
-
-import (
-	"io"
-	"net/http"
-)
-
-// httpTransport holds an http.RoundTripper
-// and information about the scheme and address the transport
-// sends request to.
-type httpTransport struct {
-	http.RoundTripper
-	scheme string
-	addr   string
-}
-
-// NewHTTPTransport creates a new httpTransport.
-func NewHTTPTransport(r http.RoundTripper, scheme, addr string) Transport {
-	return httpTransport{
-		RoundTripper: r,
-		scheme:       scheme,
-		addr:         addr,
-	}
-}
-
-// NewRequest creates a new http.Request and sets the URL
-// scheme and address with the transport's fields.
-func (t httpTransport) NewRequest(path string, data io.Reader) (*http.Request, error) {
-	req, err := newHTTPRequest(path, data)
-	if err != nil {
-		return nil, err
-	}
-	req.URL.Scheme = t.scheme
-	req.URL.Host = t.addr
-	return req, nil
-}

vendor/github.com/containers/storage/pkg/plugins/transport/transport.go

@@ -1,36 +0,0 @@
-package transport
-
-import (
-	"io"
-	"net/http"
-	"strings"
-)
-
-// VersionMimetype is the Content-Type the engine sends to plugins.
-const VersionMimetype = "application/vnd.docker.plugins.v1.2+json"
-
-// RequestFactory defines an interface that
-// transports can implement to create new requests.
-type RequestFactory interface {
-	NewRequest(path string, data io.Reader) (*http.Request, error)
-}
-
-// Transport defines an interface that plugin transports
-// must implement.
-type Transport interface {
-	http.RoundTripper
-	RequestFactory
-}
-
-// newHTTPRequest creates a new request with a path and a body.
-func newHTTPRequest(path string, data io.Reader) (*http.Request, error) {
-	if !strings.HasPrefix(path, "/") {
-		path = "/" + path
-	}
-	req, err := http.NewRequest("POST", path, data)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Add("Accept", VersionMimetype)
-	return req, nil
-}