pkg/cdi: add functions for writing Spec files.

Implement Spec.Write() and Cache.WriteSpec() for writing
Spec file content atomically to the filesystem.

Spec.Write() puts the Spec in its associated location (set
by NewSpec() or ReadSpec()). Cache.WriteSpec() always puts
the Spec file in the last Spec directory (with the highest
priority). WriteSpec() validates the Spec first before any
data is written to the filesystem.

Cache.WriteSpec() replaces any existing Spec file with the
new Spec data. Spec.Write() overwrites existing Spec files
only if explicitly asked to do so.

Signed-off-by: Krisztian Litkey <krisztian.litkey@intel.com>

Author: klihub

pkg/cdi/cache.go

@@ -22,6 +22,7 @@ import (
 	"strings"
 	"sync"
 
+	cdi "github.com/container-orchestrated-devices/container-device-interface/specs-go"
 	"github.com/fsnotify/fsnotify"
 	"github.com/hashicorp/go-multierror"
 	oci "github.com/opencontainers/runtime-spec/specs-go"
@@ -254,6 +255,39 @@ func (c *Cache) InjectDevices(ociSpec *oci.Spec, devices ...string) ([]string, e
 	return nil, nil
 }
 
+// WriteSpec writes a Spec file with the given content. Priority is used
+// as an index into the list of Spec directories to pick a directory for
+// the file, adjusting for any under- or overflows. If name has a "json"
+// or "yaml" extension it choses the encoding. Otherwise JSON encoding
+// is used with a "json" extension.
+func (c *Cache) WriteSpec(raw *cdi.Spec, name string) error {
+	var (
+		specDir string
+		path    string
+		prio    int
+		spec    *Spec
+		err     error
+	)
+
+	if len(c.specDirs) == 0 {
+		return errors.New("no Spec directories to write to")
+	}
+
+	prio = len(c.specDirs) - 1
+	specDir = c.specDirs[prio]
+	path = filepath.Join(specDir, name)
+	if ext := filepath.Ext(path); ext != ".json" && ext != ".yaml" {
+		path += ".json"
+	}
+
+	spec, err = NewSpec(raw, path, prio)
+	if err != nil {
+		return err
+	}
+
+	return spec.Write(true)
+}
+
 // GetDevice returns the cached device for the given qualified name.
 func (c *Cache) GetDevice(device string) *Device {
 	c.Lock()

pkg/cdi/cache_test.go

@@ -25,6 +25,8 @@ import (
 	"testing"
 	"time"
 
+	"github.com/container-orchestrated-devices/container-device-interface/pkg/cdi/validate"
+	cdi "github.com/container-orchestrated-devices/container-device-interface/specs-go"
 	oci "github.com/opencontainers/runtime-spec/specs-go"
 	"github.com/pkg/errors"
 	"github.com/stretchr/testify/require"
@@ -1420,6 +1422,218 @@ devices:
 	}
 }
 
+func TestCacheWriteSpec(t *testing.T) {
+	type testCase struct {
+		name    string
+		etc     map[string]string
+		invalid map[string]bool
+	}
+	for _, tc := range []*testCase{
+		{
+			name: "one spec file",
+			etc: map[string]string{
+				"vendor1.yaml": `
+cdiVersion: "0.3.0"
+kind:       "vendor1.com/device"
+devices:
+  - name: "dev1"
+    containerEdits:
+      deviceNodes:
+      - path: "/dev/vendor1-dev1"
+        type: b
+        major: 10
+        minor: 1
+`,
+			},
+		},
+		{
+			name: "multiple spec files",
+			etc: map[string]string{
+				"vendor1.yaml": `
+cdiVersion: "0.3.0"
+kind:       "vendor1.com/device"
+devices:
+  - name: "dev1"
+    containerEdits:
+      deviceNodes:
+      - path: "/dev/vendor1-dev1"
+        type: b
+        major: 10
+        minor: 1
+  - name: "dev2"
+    containerEdits:
+      deviceNodes:
+      - path: "/dev/vendor1-dev2"
+        type: b
+        major: 10
+        minor: 2
+`,
+				"vendor2.yaml": `
+cdiVersion: "0.3.0"
+kind:       "vendor2.com/device"
+devices:
+  - name: "dev1"
+    containerEdits:
+      deviceNodes:
+      - path: "/dev/vendor2-dev1"
+        type: b
+        major: 10
+        minor: 1
+`,
+				"vendor3.yaml": `
+cdiVersion: "0.3.0"
+kind:       "vendor3.com/device"
+devices:
+  - name: "dev1"
+    containerEdits:
+      deviceNodes:
+      - path: "/dev/vendor3-dev1"
+        type: b
+        major: 10
+        minor: 1
+`,
+			},
+		},
+
+		{
+			name: "multiple spec files/data, some invalid",
+			etc: map[string]string{
+				"vendor1.yaml": `
+cdiVersion: "0.3.0"
+kind:       "vendor1.comdevice"
+devices:
+  - name: "dev1"
+    containerEdits:
+      deviceNodes:
+      - path: "/dev/vendor1-dev1"
+        type: b
+        major: 10
+        minor: 1
+  - name: "dev2"
+    containerEdits:
+      deviceNodes:
+      - path: "/dev/vendor1-dev2"
+        type: b
+        major: 10
+        minor: 2
+`,
+				"vendor2.yaml": `
+cdiVersion: "0.3.0"
+kind:       "vendor2.com/device"
+devices:
+  - name: "dev1"
+    containerEdits:
+      deviceNodes:
+      - path: "/dev/vendor2-dev1"
+        type: b
+        major: 10
+        minor: 1
+`,
+				"vendor3.yaml": `
+cdiVersion: "0.3.0"
+kind:       "vendor3.com/device"
+containerEdits:
+  deviceNodes:
+  - path: "/dev/vendor3-dev1"
+    type: b
+    major: 10
+    minor: 1
+`,
+			},
+			invalid: map[string]bool{
+				"vendor1.yaml": true,
+				"vendor3.yaml": true,
+			},
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			var (
+				dir   string
+				etc   map[string]string
+				raw   *cdi.Spec
+				err   error
+				cache *Cache
+				other *Cache
+			)
+
+			SetSpecValidator(validate.WithNamedSchema("builtin"))
+
+			if len(tc.invalid) != 0 {
+				dir, err = createSpecDirs(t, nil, nil)
+				require.NoError(t, err)
+				cache, err = NewCache(
+					WithSpecDirs(
+						filepath.Join(dir, "etc"),
+						filepath.Join(dir, "run"),
+					),
+					WithAutoRefresh(false),
+				)
+
+				require.NoError(t, err)
+				require.NotNil(t, cache)
+
+				etc = map[string]string{}
+				for name, data := range tc.etc {
+					raw, err = ParseSpec([]byte(data))
+					require.NoError(t, err)
+					require.NotNil(t, raw)
+
+					err = cache.WriteSpec(raw, name)
+
+					if tc.invalid[name] {
+						require.Error(t, err)
+					} else {
+						require.NoError(t, err)
+						etc[name] = data
+					}
+				}
+			} else {
+				etc = tc.etc
+			}
+
+			dir, err = createSpecDirs(t, etc, nil)
+			require.NoError(t, err)
+
+			cache, err = NewCache(
+				WithSpecDirs(
+					filepath.Join(dir, "etc"),
+				),
+			)
+			require.NoError(t, err)
+			require.NotNil(t, cache)
+
+			other, err = NewCache(
+				WithSpecDirs(
+					filepath.Join(dir, "run"),
+				),
+				WithAutoRefresh(false),
+			)
+			require.NoError(t, err)
+			require.NotNil(t, other)
+
+			cSpecs := map[string]*cdi.Spec{}
+			for _, vendor := range cache.ListVendors() {
+				for _, spec := range cache.GetVendorSpecs(vendor) {
+					name := filepath.Base(spec.GetPath())
+					cSpecs[name] = spec.Spec
+					err = other.WriteSpec(spec.Spec, name)
+					require.NoError(t, err)
+				}
+			}
+
+			err = other.Refresh()
+			require.NoError(t, err)
+
+			for _, vendor := range other.ListVendors() {
+				for _, spec := range other.GetVendorSpecs(vendor) {
+					name := filepath.Base(spec.GetPath())
+					require.Equal(t, spec.Spec, cSpecs[name])
+				}
+			}
+		})
+	}
+}
+
 // 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{

pkg/cdi/registry.go

@@ -19,6 +19,7 @@ package cdi
 import (
 	"sync"
 
+	cdi "github.com/container-orchestrated-devices/container-device-interface/specs-go"
 	oci "github.com/opencontainers/runtime-spec/specs-go"
 )
 
@@ -97,11 +98,15 @@ type RegistryDeviceDB interface {
 //
 // GetSpecErrors returns any errors for the Spec encountered during
 // the last cache refresh.
+//
+// WriteSpec writes the Spec with the given content and name to the
+// last Spec directory.
 type RegistrySpecDB interface {
 	ListVendors() []string
 	ListClasses() []string
 	GetVendorSpecs(vendor string) []*Spec
 	GetSpecErrors(*Spec) []error
+	WriteSpec(raw *cdi.Spec, name string) error
 }
 
 type registry struct {

pkg/cdi/spec.go

@@ -17,6 +17,7 @@
 package cdi
 
 import (
+	"encoding/json"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -68,7 +69,7 @@ func ReadSpec(path string, priority int) (*Spec, error) {
 		return nil, errors.Wrapf(err, "failed to read CDI Spec %q", path)
 	}
 
-	raw, err := parseSpec(data)
+	raw, err := ParseSpec(data)
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to parse CDI Spec %q", path)
 	}
@@ -109,6 +110,56 @@ func NewSpec(raw *cdi.Spec, path string, priority int) (*Spec, error) {
 	return spec, nil
 }
 
+// Write the CDI Spec to the file associated with it during instantiation
+// by NewSpec() or ReadSpec().
+func (s *Spec) Write(overwrite bool) error {
+	var (
+		data []byte
+		dir  string
+		tmp  *os.File
+		err  error
+	)
+
+	err = validateSpec(s.Spec)
+	if err != nil {
+		return err
+	}
+
+	if filepath.Ext(s.path) == ".yaml" {
+		data, err = yaml.Marshal(s.Spec)
+	} else {
+		data, err = json.Marshal(s.Spec)
+	}
+	if err != nil {
+		return errors.Wrap(err, "failed to marshal Spec file")
+	}
+
+	dir = filepath.Dir(s.path)
+	err = os.MkdirAll(dir, 0o755)
+	if err != nil {
+		return errors.Wrap(err, "failed to create Spec dir")
+	}
+
+	tmp, err = os.CreateTemp(dir, "spec.*.tmp")
+	if err != nil {
+		return errors.Wrap(err, "failed to create Spec file")
+	}
+	_, err = tmp.Write(data)
+	tmp.Close()
+	if err != nil {
+		return errors.Wrap(err, "failed to write Spec file")
+	}
+
+	err = renameIn(dir, filepath.Base(tmp.Name()), filepath.Base(s.path), overwrite)
+
+	if err != nil {
+		os.Remove(tmp.Name())
+		err = errors.Wrap(err, "failed to write Spec file")
+	}
+
+	return err
+}
+
 // GetVendor returns the vendor of this Spec.
 func (s *Spec) GetVendor() string {
 	return s.vendor
@@ -183,8 +234,8 @@ func validateVersion(version string) error {
 	return nil
 }
 
-// Parse raw CDI Spec file data.
-func parseSpec(data []byte) (*cdi.Spec, error) {
+// ParseSpec parses CDI Spec data into a raw CDI Spec.
+func ParseSpec(data []byte) (*cdi.Spec, error) {
 	var raw *cdi.Spec
 	err := yaml.UnmarshalStrict(data, &raw)
 	if err != nil {