pkg/cdi: implement cache of specs and devices.

Implement discovery and caching of spec files and devices,
refreshing the cache.

Signed-off-by: Krisztian Litkey <[email protected]>

Author: klihub

pkg/cdi/cache.go

@@ -0,0 +1,147 @@
+/*
+   Copyright © 2021 The CDI Authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package cdi
+
+import (
+	"path/filepath"
+	"sync"
+
+	"github.com/hashicorp/go-multierror"
+	"github.com/pkg/errors"
+)
+
+// Option is an option to change some aspect of default CDI behavior.
+type Option func(*Cache) error
+
+// Cache stores CDI Specs loaded from Spec directories.
+type Cache struct {
+	sync.Mutex
+	specDirs []string
+	specs    map[string][]*Spec
+	devices  map[string]*Device
+	errors   map[string][]error
+}
+
+// NewCache creates a new CDI Cache. The cache is populated from a set
+// of CDI Spec directories. These can be specified using a WithSpecDirs
+// option. The default set of directories is exposed in DefaultSpecDirs.
+func NewCache(options ...Option) (*Cache, error) {
+	c := &Cache{}
+
+	if err := c.Configure(options...); err != nil {
+		return nil, err
+	}
+	if len(c.specDirs) == 0 {
+		c.Configure(WithSpecDirs(DefaultSpecDirs...))
+	}
+
+	return c, c.Refresh()
+}
+
+// Configure applies options to the cache. Updates the cache if options have
+// changed.
+func (c *Cache) Configure(options ...Option) error {
+	if len(options) == 0 {
+		return nil
+	}
+
+	c.Lock()
+	defer c.Unlock()
+
+	for _, o := range options {
+		if err := o(c); err != nil {
+			return errors.Wrapf(err, "failed to apply cache options")
+		}
+	}
+
+	return nil
+}
+
+// Refresh rescans the CDI Spec directories and refreshes the Cache.
+func (c *Cache) Refresh() error {
+	var (
+		specs      = map[string][]*Spec{}
+		devices    = map[string]*Device{}
+		conflicts  = map[string]struct{}{}
+		specErrors = map[string][]error{}
+		result     []error
+	)
+
+	// collect errors per spec file path and once globally
+	collectError := func(err error, paths ...string) {
+		result = append(result, err)
+		for _, path := range paths {
+			specErrors[path] = append(specErrors[path], err)
+		}
+	}
+	// resolve conflicts based on device Spec priority (order of precedence)
+	resolveConflict := func(name string, dev *Device, old *Device) bool {
+		devSpec, oldSpec := dev.GetSpec(), old.GetSpec()
+		devPrio, oldPrio := devSpec.GetPriority(), oldSpec.GetPriority()
+		switch {
+		case devPrio > oldPrio:
+			return false
+		case devPrio == oldPrio:
+			devPath, oldPath := devSpec.GetPath(), oldSpec.GetPath()
+			collectError(errors.Errorf("conflicting device %q (specs %q, %q)",
+				name, devPath, oldPath), devPath, oldPath)
+			conflicts[name] = struct{}{}
+		}
+		return true
+	}
+
+	_ = scanSpecDirs(c.specDirs, func(path string, priority int, spec *Spec, err error) error {
+		path = filepath.Clean(path)
+		if err != nil {
+			collectError(errors.Wrapf(err, "failed to load CDI Spec"), path)
+			return nil
+		}
+
+		vendor := spec.GetVendor()
+		specs[vendor] = append(specs[vendor], spec)
+
+		for _, dev := range spec.devices {
+			qualified := dev.GetQualifiedName()
+			other, ok := devices[qualified]
+			if ok {
+				if resolveConflict(qualified, dev, other) {
+					continue
+				}
+			}
+			devices[qualified] = dev
+		}
+
+		return nil
+	})
+
+	for conflict := range conflicts {
+		delete(devices, conflict)
+	}
+
+	c.Lock()
+	defer c.Unlock()
+
+	c.specs = specs
+	c.devices = devices
+	c.errors = specErrors
+
+	if len(result) > 0 {
+		return multierror.Append(nil, result...)
+	}
+
+	return nil
+}

pkg/cdi/cache_test.go

@@ -0,0 +1,206 @@
+/*
+   Copyright © 2021 The CDI Authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package cdi
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewCache(t *testing.T) {
+	type testCase struct {
+		name    string
+		etc     map[string]string
+		run     map[string]string
+		sources map[string]string
+		errors  map[string]struct{}
+	}
+	for _, tc := range []*testCase{
+		{
+			name: "no spec dirs",
+		},
+		{
+			name: "no spec files",
+			etc:  map[string]string{},
+			run:  map[string]string{},
+		},
+		{
+			name: "one spec file",
+			etc: map[string]string{
+				"vendor1.yaml": `
+cdiVersion: "0.2.0"
+kind:       "vendor1.com/device"
+devices:
+  - name: "dev1"
+    containerEdits:
+      deviceNodes:
+      - path: "/dev/vendor1-dev1"
+`,
+			},
+			sources: map[string]string{
+				"vendor1.com/device=dev1": "etc/vendor1.yaml",
+			},
+		},
+		{
+			name: "multiple spec files with override",
+			etc: map[string]string{
+				"vendor1.yaml": `
+cdiVersion: "0.2.0"
+kind:       "vendor1.com/device"
+devices:
+  - name: "dev1"
+    containerEdits:
+      deviceNodes:
+      - path: "/dev/vendor1-dev1"
+  - name: "dev2"
+    containerEdits:
+      deviceNodes:
+      - path: "/dev/vendor1-dev2"
+`,
+			},
+			run: map[string]string{
+				"vendor1.yaml": `
+cdiVersion: "0.2.0"
+kind:       "vendor1.com/device"
+devices:
+  - name: "dev1"
+    containerEdits:
+      deviceNodes:
+      - path: "/dev/vendor1-dev1"
+`,
+			},
+			sources: map[string]string{
+				"vendor1.com/device=dev1": "run/vendor1.yaml",
+				"vendor1.com/device=dev2": "etc/vendor1.yaml",
+			},
+		},
+		{
+			name: "multiple spec files, with conflicts",
+			run: map[string]string{
+				"vendor1.yaml": `
+cdiVersion: "0.2.0"
+kind:       "vendor1.com/device"
+devices:
+  - name: "dev1"
+    containerEdits:
+      deviceNodes:
+      - path: "/dev/vendor1-dev1"
+  - name: "dev2"
+    containerEdits:
+      deviceNodes:
+      - path: "/dev/vendor1-dev2"
+`,
+				"vendor1-other.yaml": `
+cdiVersion: "0.2.0"
+kind:       "vendor1.com/device"
+devices:
+  - name: "dev1"
+    containerEdits:
+      deviceNodes:
+      - path: "/dev/vendor1-dev1"
+`,
+			},
+			sources: map[string]string{
+				"vendor1.com/device=dev2": "run/vendor1.yaml",
+			},
+			errors: map[string]struct{}{
+				"run/vendor1.yaml":       {},
+				"run/vendor1-other.yaml": {},
+			},
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			var (
+				dir   string
+				err   error
+				cache *Cache
+			)
+			if tc.etc != nil || tc.run != nil {
+				dir, err = createSpecDirs(t, tc.etc, tc.run)
+				if err != nil {
+					t.Errorf("failed to create test directory: %v", err)
+					return
+				}
+			}
+			cache, err = NewCache(WithSpecDirs(
+				filepath.Join(dir, "etc"),
+				filepath.Join(dir, "run")),
+			)
+
+			if len(tc.errors) == 0 {
+				require.Nil(t, err)
+			}
+			require.NotNil(t, cache)
+
+			for name, dev := range cache.devices {
+				require.Equal(t, filepath.Join(dir, tc.sources[name]),
+					dev.GetSpec().GetPath())
+			}
+			for name, path := range tc.sources {
+				dev := cache.devices[name]
+				require.NotNil(t, dev)
+				require.Equal(t, filepath.Join(dir, path),
+					dev.GetSpec().GetPath())
+			}
+
+			for path := range tc.errors {
+				fullPath := filepath.Join(dir, path)
+				_, ok := cache.errors[fullPath]
+				require.True(t, ok)
+			}
+			for fullPath := range cache.errors {
+				path, err := filepath.Rel(dir, fullPath)
+				require.Nil(t, err)
+				_, ok := tc.errors[path]
+				require.True(t, ok)
+			}
+		})
+	}
+}
+
+// Create and populate automatically cleaned up spec directories.
+func createSpecDirs(t *testing.T, etc, run map[string]string) (string, error) {
+	return mkTestDir(t, map[string]map[string]string{
+		"etc": etc,
+		"run": run,
+	})
+}
+
+// Update spec directories with new data.
+func updateSpecDirs(t *testing.T, dir string, etc, run map[string]string) error {
+	updates := map[string]map[string]string{
+		"etc": {},
+		"run": {},
+	}
+	for sub, entries := range map[string]map[string]string{
+		"etc": etc,
+		"run": run,
+	} {
+		path := filepath.Join(dir, sub)
+		for name, data := range entries {
+			if data == "remove" {
+				os.Remove(filepath.Join(path, name))
+			} else {
+				updates[sub][name] = data
+			}
+		}
+	}
+	return updateTestDir(t, dir, updates)
+}