Generalize the plugin package

Remove containerd specific parts of the plugin package to prepare its
move out of the main repository. Separate the plugin registration
singleton into a separate package.

Separating out the plugin package and registration makes it easier to
implement external plugins without creating a dependency loop.

Signed-off-by: Derek McGowan <derek@mcg.dev>

Author: dmcgowan

context.go

@@ -19,20 +19,15 @@ package plugin
 import (
 	"context"
 	"fmt"
-	"path/filepath"
 
-	"github.com/containerd/containerd/errdefs"
-	ocispec "github.com/opencontainers/image-spec/specs-go/v1"
+	imagespec "github.com/opencontainers/image-spec/specs-go/v1"
 )
 
 // InitContext is used for plugin initialization
 type InitContext struct {
 	Context           context.Context
-	Root              string
-	State             string
+	Properties        map[string]string
 	Config            interface{}
-	Address           string
-	TTRPCAddress      string
 	RegisterReadiness func() func()
 
 	// Meta is metadata plugins can fill in at init
@@ -42,11 +37,13 @@ type InitContext struct {
 }
 
 // NewContext returns a new plugin InitContext
-func NewContext(ctx context.Context, r *Registration, plugins *Set, root, state string) *InitContext {
+func NewContext(ctx context.Context, plugins *Set, properties map[string]string) *InitContext {
+	if properties == nil {
+		properties = map[string]string{}
+	}
 	return &InitContext{
-		Context: ctx,
-		Root:    filepath.Join(root, r.URI()),
-		State:   filepath.Join(state, r.URI()),
+		Context:    ctx,
+		Properties: properties,
 		Meta: &Meta{
 			Exports: map[string]string{},
 		},
@@ -62,16 +59,16 @@ func (i *InitContext) Get(t Type) (interface{}, error) {
 // Meta contains information gathered from the registration and initialization
 // process.
 type Meta struct {
-	Platforms    []ocispec.Platform // platforms supported by plugin
-	Exports      map[string]string  // values exported by plugin
-	Capabilities []string           // feature switches for plugin
+	Platforms    []imagespec.Platform // platforms supported by plugin
+	Exports      map[string]string    // values exported by plugin
+	Capabilities []string             // feature switches for plugin
 }
 
 // Plugin represents an initialized plugin, used with an init context.
 type Plugin struct {
-	Registration *Registration // registration, as initialized
-	Config       interface{}   // config, as initialized
-	Meta         *Meta
+	Registration Registration // registration, as initialized
+	Config       interface{}  // config, as initialized
+	Meta         Meta
 
 	instance interface{}
 	err      error // will be set if there was an error initializing the plugin
@@ -115,7 +112,7 @@ func (ps *Set) Add(p *Plugin) error {
 	} else if _, idok := byID[p.Registration.ID]; !idok {
 		byID[p.Registration.ID] = p
 	} else {
-		return fmt.Errorf("plugin %v already initialized: %w", p.Registration.URI(), errdefs.ErrAlreadyExists)
+		return fmt.Errorf("plugin add failed for %s: %w", p.Registration.URI(), ErrPluginInitialized)
 	}
 
 	ps.ordered = append(ps.ordered, p)
@@ -127,7 +124,7 @@ func (ps *Set) Get(t Type) (interface{}, error) {
 	for _, v := range ps.byTypeAndID[t] {
 		return v.Instance()
 	}
-	return nil, fmt.Errorf("no plugins registered for %s: %w", t, errdefs.ErrNotFound)
+	return nil, fmt.Errorf("no plugins registered for %s: %w", t, ErrPluginNotFound)
 }
 
 // GetAll returns all initialized plugins
@@ -153,7 +150,7 @@ func (i *InitContext) GetByID(t Type, id string) (interface{}, error) {
 	}
 	p, ok := ps[id]
 	if !ok {
-		return nil, fmt.Errorf("no %s plugins with id %s: %w", t, id, errdefs.ErrNotFound)
+		return nil, fmt.Errorf("no %s plugins with id %s: %w", t, id, ErrPluginNotFound)
 	}
 	return p.Instance()
 }
@@ -162,7 +159,7 @@ func (i *InitContext) GetByID(t Type, id string) (interface{}, error) {
 func (i *InitContext) GetByType(t Type) (map[string]*Plugin, error) {
 	p, ok := i.plugins.byTypeAndID[t]
 	if !ok {
-		return nil, fmt.Errorf("no plugins registered for %s: %w", t, errdefs.ErrNotFound)
+		return nil, fmt.Errorf("no plugins registered for %s: %w", t, ErrPluginNotFound)
 	}
 
 	return p, nil

plugin.go

@@ -20,7 +20,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"sync"
 )
 
 var (
@@ -34,6 +33,10 @@ var (
 	// this allows the plugin loader differentiate between a plugin which is configured
 	// not to load and one that fails to load.
 	ErrSkipPlugin = errors.New("skip plugin")
+	// ErrPluginInitialized is used when a plugin is already initialized
+	ErrPluginInitialized = errors.New("plugin: already initialized")
+	// ErrPluginNotFound is used when a plugin is looked up but not found
+	ErrPluginNotFound = errors.New("plugin: not found")
 
 	// ErrInvalidRequires will be thrown if the requirements for a plugin are
 	// defined in an invalid manner.
@@ -65,8 +68,6 @@ type Registration struct {
 	// context are passed in. The init function may modify the registration to
 	// add exports, capabilities and platform support declarations.
 	InitFn func(*InitContext) (interface{}, error)
-	// Disable the plugin from loading
-	Disable bool
 
 	// ConfigMigration allows a plugin to migrate configurations from an older
 	// version to handle plugin renames or moving of features from one plugin
@@ -79,12 +80,12 @@ type Registration struct {
 }
 
 // Init the registered plugin
-func (r *Registration) Init(ic *InitContext) *Plugin {
+func (r Registration) Init(ic *InitContext) *Plugin {
 	p, err := r.InitFn(ic)
 	return &Plugin{
 		Registration: r,
 		Config:       ic.Config,
-		Meta:         ic.Meta,
+		Meta:         *ic.Meta,
 		instance:     p,
 		err:          err,
 	}
@@ -95,11 +96,6 @@ func (r *Registration) URI() string {
 	return r.Type.String() + "." + r.ID
 }
 
-var register = struct {
-	sync.RWMutex
-	r []*Registration
-}{}
-
 // Load loads all plugins at the provided path into containerd.
 //
 // Load is currently only implemented on non-static, non-gccgo builds for amd64
@@ -118,87 +114,81 @@ func Load(path string) (err error) {
 	return loadPlugins(path)
 }
 
-// Register allows plugins to register
-func Register(r *Registration) {
-	register.Lock()
-	defer register.Unlock()
-
-	if r.Type == "" {
-		panic(ErrNoType)
-	}
-	if r.ID == "" {
-		panic(ErrNoPluginID)
-	}
-	if err := checkUnique(r); err != nil {
-		panic(err)
-	}
-
-	for _, requires := range r.Requires {
-		if requires == "*" && len(r.Requires) != 1 {
-			panic(ErrInvalidRequires)
-		}
-	}
-
-	register.r = append(register.r, r)
-}
-
-// Reset removes all global registrations
-func Reset() {
-	register.Lock()
-	defer register.Unlock()
-	register.r = nil
-}
-
-func checkUnique(r *Registration) error {
-	for _, registered := range register.r {
-		if r.URI() == registered.URI() {
-			return fmt.Errorf("%s: %w", r.URI(), ErrIDRegistered)
-		}
-	}
-	return nil
-}
-
 // DisableFilter filters out disabled plugins
 type DisableFilter func(r *Registration) bool
 
-// Graph returns an ordered list of registered plugins for initialization.
-// Plugins in disableList specified by id will be disabled.
-func Graph(filter DisableFilter) (ordered []*Registration) {
-	register.RLock()
-	defer register.RUnlock()
-
-	for _, r := range register.r {
+// Registry is list of registrations which can be registered to and
+// produce a filtered and ordered output.
+// The Registry itself is immutable and the list will be copied
+// and appeneded to a new registry when new items are registered.
+type Registry []*Registration
+
+// Graph computes the ordered list of registrations based on their dependencies,
+// filtering out any plugins which match the provided filter.
+func (registry Registry) Graph(filter DisableFilter) []Registration {
+	disabled := map[*Registration]bool{}
+	for _, r := range registry {
 		if filter(r) {
-			r.Disable = true
+			disabled[r] = true
 		}
 	}
 
+	ordered := make([]Registration, 0, len(registry)-len(disabled))
 	added := map[*Registration]bool{}
-	for _, r := range register.r {
-		if r.Disable {
+	for _, r := range registry {
+		if disabled[r] {
 			continue
 		}
-		children(r, added, &ordered)
+		children(r, registry, added, disabled, &ordered)
 		if !added[r] {
-			ordered = append(ordered, r)
+			ordered = append(ordered, *r)
 			added[r] = true
 		}
 	}
 	return ordered
 }
 
-func children(reg *Registration, added map[*Registration]bool, ordered *[]*Registration) {
+func children(reg *Registration, registry []*Registration, added, disabled map[*Registration]bool, ordered *[]Registration) {
 	for _, t := range reg.Requires {
-		for _, r := range register.r {
-			if !r.Disable &&
-				r.URI() != reg.URI() &&
-				(t == "*" || r.Type == t) {
-				children(r, added, ordered)
+		for _, r := range registry {
+			if !disabled[r] && r.URI() != reg.URI() && (t == "*" || r.Type == t) {
+				children(r, registry, added, disabled, ordered)
 				if !added[r] {
-					*ordered = append(*ordered, r)
+					*ordered = append(*ordered, *r)
 					added[r] = true
 				}
 			}
 		}
 	}
 }
+
+// Register adds the registration to a Registry and returns the
+// updated Registry, panicking if registration could not succeed.
+func (registry Registry) Register(r *Registration) Registry {
+	if r.Type == "" {
+		panic(ErrNoType)
+	}
+	if r.ID == "" {
+		panic(ErrNoPluginID)
+	}
+	if err := checkUnique(registry, r); err != nil {
+		panic(err)
+	}
+
+	for _, requires := range r.Requires {
+		if requires == "*" && len(r.Requires) != 1 {
+			panic(ErrInvalidRequires)
+		}
+	}
+
+	return append(registry, r)
+}
+
+func checkUnique(registry Registry, r *Registration) error {
+	for _, registered := range registry {
+		if r.URI() == registered.URI() {
+			return fmt.Errorf("%s: %w", r.URI(), ErrIDRegistered)
+		}
+	}
+	return nil
+}