Lint on pkg/* packages

- pkg/useragent
- pkg/units
- pkg/ulimit
- pkg/truncindex
- pkg/timeoutconn
- pkg/term
- pkg/tarsum
- pkg/tailfile
- pkg/systemd
- pkg/stringutils
- pkg/stringid
- pkg/streamformatter
- pkg/sockets
- pkg/signal
- pkg/proxy
- pkg/progressreader
- pkg/pools
- pkg/plugins
- pkg/pidfile
- pkg/parsers
- pkg/parsers/filters
- pkg/parsers/kernel
- pkg/parsers/operatingsystem

Signed-off-by: Vincent Demeester <vincent@sbr.pm>

plugins/client.go

@@ -19,6 +19,7 @@ const (
 	defaultTimeOut  = 30
 )
 
+// NewClient creates a new plugin client (http).
 func NewClient(addr string, tlsConfig tlsconfig.Options) (*Client, error) {
 	tr := &http.Transport{}
 
@@ -33,11 +34,14 @@ func NewClient(addr string, tlsConfig tlsconfig.Options) (*Client, error) {
 	return &Client{&http.Client{Transport: tr}, protoAndAddr[1]}, nil
 }
 
+// Client represents a plugin client.
 type Client struct {
-	http *http.Client
-	addr string
+	http *http.Client // http client to use
+	addr string       // http address of the plugin
 }
 
+// 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 {
 	return c.callWithRetry(serviceMethod, args, ret, true)
 }

plugins/discovery.go

@@ -12,22 +12,28 @@ import (
 )
 
 var (
+	// ErrNotFound plugin not found
 	ErrNotFound = errors.New("Plugin not found")
 	socketsPath = "/run/docker/plugins"
 	specsPaths  = []string{"/etc/docker/plugins", "/usr/lib/docker/plugins"}
 )
 
+// Registry defines behavior of a registry of plugins.
 type Registry interface {
+	// Plugins lists all plugins.
 	Plugins() ([]*Plugin, error)
+	// Plugin returns the plugin registered with the given name (or returns an error).
 	Plugin(name string) (*Plugin, error)
 }
 
+// LocalRegistry defines a registry that is local (using unix socket).
 type LocalRegistry struct{}
 
 func newLocalRegistry() LocalRegistry {
 	return LocalRegistry{}
 }
 
+// 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")
 

plugins/plugins.go

@@ -1,3 +1,25 @@
+// 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)
+//	}
 package plugins
 
 import (
@@ -9,6 +31,7 @@ import (
 )
 
 var (
+	// ErrNotImplements is returned if the plugin does not implement the requested driver.
 	ErrNotImplements = errors.New("Plugin does not implement the requested driver")
 )
 
@@ -22,16 +45,24 @@ var (
 	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 docker plugin.
 type Plugin struct {
-	Name      string `json:"-"`
-	Addr      string
+	// Name of the plugin
+	Name string `json:"-"`
+	// Address of the plugin
+	Addr string
+	// TLS configuration of the plugin
 	TLSConfig tlsconfig.Options
-	Client    *Client   `json:"-"`
-	Manifest  *Manifest `json:"-"`
+	// Client attached to the plugin
+	Client *Client `json:"-"`
+	// Manifest of the plugin (see above)
+	Manifest *Manifest `json:"-"`
 }
 
 func newLocalPlugin(name, addr string) *Plugin {
@@ -96,6 +127,7 @@ func get(name string) (*Plugin, error) {
 	return pl, nil
 }
 
+// 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 {
@@ -110,6 +142,7 @@ func Get(name, imp string) (*Plugin, error) {
 	return nil, ErrNotImplements
 }
 
+// Handle adds the specified function to the extpointHandlers.
 func Handle(iface string, fn func(string, *Client)) {
 	extpointHandlers[iface] = fn
 }