dotcloud/docker

package daemon

import (
    "context"
    "fmt"

    "github.com/containerd/log"
    "github.com/docker/docker/errdefs"
    "github.com/hashicorp/go-multierror"
    specs "github.com/opencontainers/runtime-spec/specs-go"
    "github.com/pkg/errors"
    "tags.cncf.io/container-device-interface/pkg/cdi"
)

type cdiHandler struct {
    registry *cdi.Cache
}

// RegisterCDIDriver registers the CDI device driver.
// The driver injects CDI devices into an incoming OCI spec and is called for DeviceRequests associated with CDI devices.
// If the list of CDI spec directories is empty, the driver is not registered.
func RegisterCDIDriver(cdiSpecDirs ...string) {
    driver := newCDIDeviceDriver(cdiSpecDirs...)

    registerDeviceDriver("cdi", driver)
}

// newCDIDeviceDriver creates a new CDI device driver.
// If the creation of the CDI cache fails, a driver is returned that will return an error on an injection request.
func newCDIDeviceDriver(cdiSpecDirs ...string) *deviceDriver {
    cache, err := createCDICache(cdiSpecDirs...)
    if err != nil {
        log.G(context.TODO()).WithError(err)
        // We create a spec updater that always returns an error.
        // This error will be returned only when a CDI device is requested.
        // This ensures that daemon startup is not blocked by a CDI registry initialization failure or being disabled
        // by configuratrion.
        errorOnUpdateSpec := func(s *specs.Spec, dev *deviceInstance) error {
            return fmt.Errorf("CDI device injection failed: %w", err)
        }
        return &deviceDriver{
            updateSpec: errorOnUpdateSpec,
        }
    }

    // We construct a spec updates that injects CDI devices into the OCI spec using the initialized registry.
    c := &cdiHandler{
        registry: cache,
    }

    return &deviceDriver{
        updateSpec: c.injectCDIDevices,
    }
}

// createCDICache creates a CDI cache for the specified CDI specification directories.
// If the list of CDI specification directories is empty or the creation of the CDI cache fails, an error is returned.
func createCDICache(cdiSpecDirs ...string) (*cdi.Cache, error) {
    if len(cdiSpecDirs) == 0 {
        return nil, fmt.Errorf("No CDI specification directories specified")
    }

    cache, err := cdi.NewCache(cdi.WithSpecDirs(cdiSpecDirs...))
    if err != nil {
        return nil, fmt.Errorf("CDI registry initialization failure: %w", err)
    }

    return cache, nil
}

// injectCDIDevices injects a set of CDI devices into the specified OCI specification.
func (c *cdiHandler) injectCDIDevices(s *specs.Spec, dev *deviceInstance) error {
    if dev.req.Count != 0 {
        return errdefs.InvalidParameter(errors.New("unexpected count in CDI device request"))
    }
    if len(dev.req.Options) > 0 {
        return errdefs.InvalidParameter(errors.New("unexpected options in CDI device request"))
    }

    cdiDeviceNames := dev.req.DeviceIDs
    if len(cdiDeviceNames) == 0 {
        return nil
    }

    _, err := c.registry.InjectDevices(s, cdiDeviceNames...)
    if err != nil {
        if rerrs := c.getErrors(); rerrs != nil {
            // We log the errors that may have been generated while refreshing the CDI registry.
            // These may be due to malformed specifications or device name conflicts that could be
            // the cause of an injection failure.
            log.G(context.TODO()).WithError(rerrs).Warning("Refreshing the CDI registry generated errors")
        }

        return fmt.Errorf("CDI device injection failed: %w", err)
    }

    return nil
}

// getErrors returns a single error representation of errors that may have occurred while refreshing the CDI registry.
func (c *cdiHandler) getErrors() error {
    errors := c.registry.GetErrors()

    var err *multierror.Error
    for _, errs := range errors {
        err = multierror.Append(err, errs...)
    }
    return err.ErrorOrNil()
}