From f8e7e308c38007b55dcfd09e53ccf321c6a7a3a0 Mon Sep 17 00:00:00 2001 From: Samuel Ortiz Date: Wed, 9 Jan 2019 11:08:39 +0100 Subject: [PATCH] virtcontainers: Remove the resource storage original implementation Now that we converted the virtcontainers code to the store package, we can remove all the resource storage old code. Fixes: #1099 Signed-off-by: Samuel Ortiz --- virtcontainers/errors.go | 2 - virtcontainers/filesystem_resource_storage.go | 873 ------------------ .../filesystem_resource_storage_test.go | 566 ------------ virtcontainers/noop_resource_storage.go | 113 --- virtcontainers/noop_resource_storage_test.go | 188 ---- virtcontainers/resource_storage.go | 69 -- 6 files changed, 1811 deletions(-) delete mode 100644 virtcontainers/filesystem_resource_storage.go delete mode 100644 virtcontainers/filesystem_resource_storage_test.go delete mode 100644 virtcontainers/noop_resource_storage.go delete mode 100644 virtcontainers/noop_resource_storage_test.go delete mode 100644 virtcontainers/resource_storage.go diff --git a/virtcontainers/errors.go b/virtcontainers/errors.go index 4cca6548d..774ce2e31 100644 --- a/virtcontainers/errors.go +++ b/virtcontainers/errors.go @@ -14,8 +14,6 @@ var ( errNeedSandbox = errors.New("Sandbox must be specified") errNeedSandboxID = errors.New("Sandbox ID cannot be empty") errNeedContainerID = errors.New("Container ID cannot be empty") - errNeedFile = errors.New("File cannot be empty") errNeedState = errors.New("State cannot be empty") - errInvalidResource = errors.New("Invalid sandbox resource") errNoSuchContainer = errors.New("Container does not exist") ) diff --git a/virtcontainers/filesystem_resource_storage.go b/virtcontainers/filesystem_resource_storage.go deleted file mode 100644 index 1cfb3ee56..000000000 --- a/virtcontainers/filesystem_resource_storage.go +++ /dev/null @@ -1,873 +0,0 @@ -// Copyright (c) 2016 Intel Corporation -// -// SPDX-License-Identifier: Apache-2.0 -// - -package virtcontainers - -import ( - "context" - "encoding/json" - "fmt" - "io/ioutil" - "os" - "path/filepath" - - opentracing "github.com/opentracing/opentracing-go" - "github.com/sirupsen/logrus" - - "github.com/kata-containers/runtime/virtcontainers/device/api" - "github.com/kata-containers/runtime/virtcontainers/device/config" - "github.com/kata-containers/runtime/virtcontainers/device/drivers" - "github.com/kata-containers/runtime/virtcontainers/types" -) - -// sandboxResource is an int representing a sandbox resource type. -// -// Note that some are specific to the sandbox itself and others can apply to -// sandboxes and containers. -type sandboxResource int - -const ( - // configFileType represents a configuration file type - configFileType sandboxResource = iota - - // stateFileType represents a state file type - stateFileType - - // networkFileType represents a network file type (sandbox only) - networkFileType - - // hypervisorFileType represents a hypervisor file type (sandbox only) - hypervisorFileType - - // agentFileType represents an agent file type (sandbox only) - agentFileType - - // processFileType represents a process file type - processFileType - - // lockFileType represents a lock file type (sandbox only) - lockFileType - - // mountsFileType represents a mount file type - mountsFileType - - // devicesFileType represents a device file type - devicesFileType - - // devicesIDFileType saves reference IDs to file, e.g. device IDs - devicesIDFileType -) - -// configFile is the file name used for every JSON sandbox configuration. -const configFile = "config.json" - -// stateFile is the file name storing a sandbox state. -const stateFile = "state.json" - -// networkFile is the file name storing a sandbox network. -const networkFile = "network.json" - -// hypervisorFile is the file name storing a hypervisor's state. -const hypervisorFile = "hypervisor.json" - -// agentFile is the file name storing an agent's state. -const agentFile = "agent.json" - -// processFile is the file name storing a container process. -const processFile = "process.json" - -// lockFile is the file name locking the usage of a sandbox. -const lockFileName = "lock" - -const mountsFile = "mounts.json" - -// devicesFile is the file name storing a container's devices. -const devicesFile = "devices.json" - -// dirMode is the permission bits used for creating a directory -const dirMode = os.FileMode(0750) | os.ModeDir - -// storagePathSuffix is the suffix used for all storage paths -// -// Note: this very brief path represents "virtcontainers". It is as -// terse as possible to minimise path length. -const storagePathSuffix = "vc" - -// sandboxPathSuffix is the suffix used for sandbox storage -const sandboxPathSuffix = "sbs" - -// vmPathSuffix is the suffix used for guest VMs. -const vmPathSuffix = "vm" - -// configStoragePath is the sandbox configuration directory. -// It will contain one config.json file for each created sandbox. -var configStoragePath = filepath.Join("/var/lib", storagePathSuffix, sandboxPathSuffix) - -// runStoragePath is the sandbox runtime directory. -// It will contain one state.json and one lock file for each created sandbox. -var runStoragePath = filepath.Join("/run", storagePathSuffix, sandboxPathSuffix) - -// RunVMStoragePath is the vm directory. -// It will contain all guest vm sockets and shared mountpoints. -var RunVMStoragePath = filepath.Join("/run", storagePathSuffix, vmPathSuffix) - -// filesystem is a resourceStorage interface implementation for a local filesystem. -type filesystem struct { - ctx context.Context -} - -// Logger returns a logrus logger appropriate for logging filesystem messages -func (fs *filesystem) Logger() *logrus.Entry { - return virtLog.WithFields(logrus.Fields{ - "subsystem": "storage", - "type": "filesystem", - }) -} - -func (fs *filesystem) trace(name string) (opentracing.Span, context.Context) { - if fs.ctx == nil { - fs.Logger().WithField("type", "bug").Error("trace called before context set") - fs.ctx = context.Background() - } - - span, ctx := opentracing.StartSpanFromContext(fs.ctx, name) - - span.SetTag("subsystem", "storage") - span.SetTag("type", "filesystem") - - return span, ctx -} - -func (fs *filesystem) createAllResources(ctx context.Context, sandbox *Sandbox) (err error) { - fs.ctx = ctx - - span, _ := fs.trace("createAllResources") - defer span.Finish() - - for _, resource := range []sandboxResource{stateFileType, configFileType} { - _, path, _ := fs.sandboxURI(sandbox.id, resource) - err = os.MkdirAll(path, dirMode) - if err != nil { - return err - } - } - - for _, container := range sandbox.containers { - for _, resource := range []sandboxResource{stateFileType, configFileType} { - _, path, _ := fs.containerURI(sandbox.id, container.id, resource) - err = os.MkdirAll(path, dirMode) - if err != nil { - fs.deleteSandboxResources(sandbox.id, nil) - return err - } - } - } - - sandboxlockFile, _, err := fs.sandboxURI(sandbox.id, lockFileType) - if err != nil { - fs.deleteSandboxResources(sandbox.id, nil) - return err - } - - _, err = os.Stat(sandboxlockFile) - if err != nil { - lockFile, err := os.Create(sandboxlockFile) - if err != nil { - fs.deleteSandboxResources(sandbox.id, nil) - return err - } - lockFile.Close() - } - - return nil -} - -func (fs *filesystem) storeFile(file string, data interface{}) error { - if file == "" { - return errNeedFile - } - - f, err := os.Create(file) - if err != nil { - return err - } - defer f.Close() - - jsonOut, err := json.Marshal(data) - if err != nil { - return fmt.Errorf("Could not marshall data: %s", err) - } - f.Write(jsonOut) - - return nil -} - -// createSandboxTempFile is used to create a temporary file under sandbox runtime storage path. -func (fs *filesystem) createSandboxTempFile(sandboxID string) (string, error) { - if sandboxID == "" { - return "", errNeedSandboxID - } - - dirPath := filepath.Join(runStoragePath, sandboxID, "tempDir") - err := os.MkdirAll(dirPath, dirMode) - if err != nil { - return "", err - } - - f, err := ioutil.TempFile(dirPath, "tmp-") - if err != nil { - return "", err - } - - return f.Name(), nil -} - -// storeDeviceIDFile is used to marshal and store device IDs to disk. -func (fs *filesystem) storeDeviceIDFile(file string, data interface{}) error { - if file == "" { - return errNeedFile - } - - f, err := os.Create(file) - if err != nil { - return err - } - defer f.Close() - - devices, ok := data.([]ContainerDevice) - if !ok { - return fmt.Errorf("Incorrect data type received, Expected []string") - } - - jsonOut, err := json.Marshal(devices) - if err != nil { - return fmt.Errorf("Could not marshal devices: %s", err) - } - - if _, err := f.Write(jsonOut); err != nil { - return err - } - - return nil -} - -// storeDeviceFile is used to provide custom marshalling for Device objects. -// Device is first marshalled into TypedDevice to include the type -// of the Device object. -func (fs *filesystem) storeDeviceFile(file string, data interface{}) error { - if file == "" { - return errNeedFile - } - - f, err := os.Create(file) - if err != nil { - return err - } - defer f.Close() - - devices, ok := data.([]api.Device) - if !ok { - return fmt.Errorf("Incorrect data type received, Expected []Device") - } - - var typedDevices []TypedDevice - for _, d := range devices { - tempJSON, _ := json.Marshal(d) - typedDevice := TypedDevice{ - Type: string(d.DeviceType()), - Data: tempJSON, - } - typedDevices = append(typedDevices, typedDevice) - } - - jsonOut, err := json.Marshal(typedDevices) - if err != nil { - return fmt.Errorf("Could not marshal devices: %s", err) - } - - if _, err := f.Write(jsonOut); err != nil { - return err - } - - return nil -} - -func (fs *filesystem) fetchFile(file string, resource sandboxResource, data interface{}) error { - if file == "" { - return errNeedFile - } - - fileData, err := ioutil.ReadFile(file) - if err != nil { - return err - } - - switch resource { - case devicesFileType: - devices, ok := data.(*[]api.Device) - if !ok { - return fmt.Errorf("Could not cast %v into *[]Device type", data) - } - - return fs.fetchDeviceFile(fileData, devices) - } - - return json.Unmarshal(fileData, data) -} - -// fetchDeviceFile is used for custom unmarshalling of device interface objects. -func (fs *filesystem) fetchDeviceFile(fileData []byte, devices *[]api.Device) error { - var typedDevices []TypedDevice - if err := json.Unmarshal(fileData, &typedDevices); err != nil { - return err - } - - var tempDevices []api.Device - for _, d := range typedDevices { - l := fs.Logger().WithField("device-type", d.Type) - l.Info("Device type found") - - switch d.Type { - case string(config.DeviceVFIO): - // TODO: remove dependency of drivers package - var device drivers.VFIODevice - if err := json.Unmarshal(d.Data, &device); err != nil { - return err - } - tempDevices = append(tempDevices, &device) - l.Infof("VFIO device unmarshalled [%v]", device) - - case string(config.DeviceBlock): - // TODO: remove dependency of drivers package - var device drivers.BlockDevice - if err := json.Unmarshal(d.Data, &device); err != nil { - return err - } - tempDevices = append(tempDevices, &device) - l.Infof("Block Device unmarshalled [%v]", device) - case string(config.DeviceGeneric): - // TODO: remove dependency of drivers package - var device drivers.GenericDevice - if err := json.Unmarshal(d.Data, &device); err != nil { - return err - } - tempDevices = append(tempDevices, &device) - l.Infof("Generic device unmarshalled [%v]", device) - - default: - return fmt.Errorf("Unknown device type, could not unmarshal") - } - } - - *devices = tempDevices - return nil -} - -// resourceNeedsContainerID determines if the specified -// sandboxResource needs a containerID. Since some sandboxResources can -// be used for both sandboxes and containers, it is necessary to specify -// whether the resource is being used in a sandbox-specific context using -// the sandboxSpecific parameter. -func resourceNeedsContainerID(sandboxSpecific bool, resource sandboxResource) bool { - - switch resource { - case lockFileType, networkFileType, hypervisorFileType, agentFileType, devicesFileType: - // sandbox-specific resources - return false - default: - return !sandboxSpecific - } -} - -func resourceName(resource sandboxResource) string { - switch resource { - case agentFileType: - return "agentFileType" - case configFileType: - return "configFileType" - case devicesFileType: - return "devicesFileType" - case devicesIDFileType: - return "devicesIDFileType" - case hypervisorFileType: - return "hypervisorFileType" - case lockFileType: - return "lockFileType" - case mountsFileType: - return "mountsFileType" - case networkFileType: - return "networkFileType" - case processFileType: - return "processFileType" - case stateFileType: - return "stateFileType" - default: - return "" - } -} - -func resourceDir(sandboxSpecific bool, sandboxID, containerID string, resource sandboxResource) (string, error) { - if sandboxID == "" { - return "", errNeedSandboxID - } - - if resourceNeedsContainerID(sandboxSpecific, resource) == true && containerID == "" { - return "", errNeedContainerID - } - - var path string - - switch resource { - case configFileType: - path = configStoragePath - break - case stateFileType, networkFileType, processFileType, lockFileType, mountsFileType, devicesFileType, devicesIDFileType, hypervisorFileType, agentFileType: - path = runStoragePath - break - default: - return "", errInvalidResource - } - - dirPath := filepath.Join(path, sandboxID, containerID) - - return dirPath, nil -} - -// If sandboxSpecific is true, the resource is being applied for an empty -// sandbox (meaning containerID may be blank). -// Note that this function defers determining if containerID can be -// blank to resourceDIR() -func (fs *filesystem) resourceURI(sandboxSpecific bool, sandboxID, containerID string, resource sandboxResource) (string, string, error) { - if sandboxID == "" { - return "", "", errNeedSandboxID - } - - var filename string - - dirPath, err := resourceDir(sandboxSpecific, sandboxID, containerID, resource) - if err != nil { - return "", "", err - } - - switch resource { - case configFileType: - filename = configFile - break - case stateFileType: - filename = stateFile - case networkFileType: - filename = networkFile - case hypervisorFileType: - filename = hypervisorFile - case agentFileType: - filename = agentFile - case processFileType: - filename = processFile - case lockFileType: - filename = lockFileName - break - case mountsFileType: - filename = mountsFile - break - case devicesFileType: - filename = devicesFile - break - case devicesIDFileType: - filename = devicesFile - break - default: - return "", "", errInvalidResource - } - - filePath := filepath.Join(dirPath, filename) - - return filePath, dirPath, nil -} - -func (fs *filesystem) containerURI(sandboxID, containerID string, resource sandboxResource) (string, string, error) { - if sandboxID == "" { - return "", "", errNeedSandboxID - } - - if containerID == "" { - return "", "", errNeedContainerID - } - - return fs.resourceURI(false, sandboxID, containerID, resource) -} - -func (fs *filesystem) sandboxURI(sandboxID string, resource sandboxResource) (string, string, error) { - return fs.resourceURI(true, sandboxID, "", resource) -} - -// commonResourceChecks performs basic checks common to both setting and -// getting a sandboxResource. -func (fs *filesystem) commonResourceChecks(sandboxSpecific bool, sandboxID, containerID string, resource sandboxResource) error { - if sandboxID == "" { - return errNeedSandboxID - } - - if resourceNeedsContainerID(sandboxSpecific, resource) == true && containerID == "" { - return errNeedContainerID - } - - switch resource { - case configFileType: - case stateFileType: - case networkFileType: - case hypervisorFileType: - case agentFileType: - case processFileType: - case mountsFileType: - case devicesFileType: - case devicesIDFileType: - default: - return errInvalidResource - } - - return nil -} - -func (fs *filesystem) storeSandboxAndContainerConfigResource(sandboxSpecific bool, sandboxID, containerID string, resource sandboxResource, file interface{}) error { - if resource != configFileType { - return errInvalidResource - } - - configFile, _, err := fs.resourceURI(sandboxSpecific, sandboxID, containerID, configFileType) - if err != nil { - return err - } - - return fs.storeFile(configFile, file) -} - -func (fs *filesystem) storeStateResource(sandboxSpecific bool, sandboxID, containerID string, resource sandboxResource, file interface{}) error { - if resource != stateFileType { - return errInvalidResource - } - - stateFile, _, err := fs.resourceURI(sandboxSpecific, sandboxID, containerID, stateFileType) - if err != nil { - return err - } - - return fs.storeFile(stateFile, file) -} - -func (fs *filesystem) storeNetworkResource(sandboxSpecific bool, sandboxID, containerID string, resource sandboxResource, file interface{}) error { - if resource != networkFileType { - return errInvalidResource - } - - // sandbox only resource - networkFile, _, err := fs.resourceURI(true, sandboxID, containerID, networkFileType) - if err != nil { - return err - } - - return fs.storeFile(networkFile, file) -} - -func (fs *filesystem) storeProcessResource(sandboxSpecific bool, sandboxID, containerID string, resource sandboxResource, file interface{}) error { - if resource != processFileType { - return errInvalidResource - } - - processFile, _, err := fs.resourceURI(sandboxSpecific, sandboxID, containerID, processFileType) - if err != nil { - return err - } - - return fs.storeFile(processFile, file) -} - -func (fs *filesystem) storeMountResource(sandboxSpecific bool, sandboxID, containerID string, resource sandboxResource, file interface{}) error { - if resource != mountsFileType { - return errInvalidResource - } - - mountsFile, _, err := fs.resourceURI(sandboxSpecific, sandboxID, containerID, mountsFileType) - if err != nil { - return err - } - - return fs.storeFile(mountsFile, file) -} - -func (fs *filesystem) storeDeviceResource(sandboxSpecific bool, sandboxID, containerID string, resource sandboxResource, file interface{}) error { - if resource != devicesFileType { - return errInvalidResource - } - - devicesFile, _, err := fs.resourceURI(sandboxSpecific, sandboxID, containerID, devicesFileType) - if err != nil { - return err - } - - return fs.storeDeviceFile(devicesFile, file) -} - -func (fs *filesystem) storeDevicesIDResource(sandboxSpecific bool, sandboxID, containerID string, resource sandboxResource, file interface{}) error { - if resource != devicesIDFileType { - return errInvalidResource - } - - devicesFile, _, err := fs.resourceURI(sandboxSpecific, sandboxID, containerID, resource) - if err != nil { - return err - } - - return fs.storeDeviceIDFile(devicesFile, file) -} - -func (fs *filesystem) storeResource(sandboxSpecific bool, sandboxID, containerID string, resource sandboxResource, data interface{}) error { - if err := fs.commonResourceChecks(sandboxSpecific, sandboxID, containerID, resource); err != nil { - return err - } - - switch file := data.(type) { - case SandboxConfig, ContainerConfig: - return fs.storeSandboxAndContainerConfigResource(sandboxSpecific, sandboxID, containerID, resource, file) - - case types.State: - return fs.storeStateResource(sandboxSpecific, sandboxID, containerID, resource, file) - - case NetworkNamespace: - return fs.storeNetworkResource(sandboxSpecific, sandboxID, containerID, resource, file) - - case Process: - return fs.storeProcessResource(sandboxSpecific, sandboxID, containerID, resource, file) - - case []Mount: - return fs.storeMountResource(sandboxSpecific, sandboxID, containerID, resource, file) - - case []api.Device: - return fs.storeDeviceResource(sandboxSpecific, sandboxID, containerID, resource, file) - case []ContainerDevice: - return fs.storeDevicesIDResource(sandboxSpecific, sandboxID, containerID, resource, file) - - default: - return fmt.Errorf("Invalid resource data type") - } -} - -func (fs *filesystem) fetchResource(sandboxSpecific bool, sandboxID, containerID string, resource sandboxResource, data interface{}) error { - var span opentracing.Span - - if fs.ctx != nil { - span, _ = fs.trace("fetchResource") - defer span.Finish() - - span.SetTag("sandbox", sandboxID) - span.SetTag("container", containerID) - span.SetTag("resource", resourceName(resource)) - } - - if err := fs.commonResourceChecks(sandboxSpecific, sandboxID, containerID, resource); err != nil { - return err - } - - path, _, err := fs.resourceURI(sandboxSpecific, sandboxID, containerID, resource) - if err != nil { - return err - } - - return fs.fetchFile(path, resource, data) -} - -func (fs *filesystem) storeSandboxResource(sandboxID string, resource sandboxResource, data interface{}) error { - return fs.storeResource(true, sandboxID, "", resource, data) -} - -func (fs *filesystem) fetchSandboxConfig(sandboxID string) (SandboxConfig, error) { - var sandboxConfig SandboxConfig - - if err := fs.fetchResource(true, sandboxID, "", configFileType, &sandboxConfig); err != nil { - return SandboxConfig{}, err - } - - return sandboxConfig, nil -} - -func (fs *filesystem) fetchSandboxState(sandboxID string) (types.State, error) { - var state types.State - - if err := fs.fetchResource(true, sandboxID, "", stateFileType, &state); err != nil { - return types.State{}, err - } - - return state, nil -} - -func (fs *filesystem) fetchSandboxNetwork(sandboxID string) (NetworkNamespace, error) { - var networkNS NetworkNamespace - - if err := fs.fetchResource(true, sandboxID, "", networkFileType, &networkNS); err != nil { - return NetworkNamespace{}, err - } - - return networkNS, nil -} - -func (fs *filesystem) fetchSandboxDevices(sandboxID string) ([]api.Device, error) { - var devices []api.Device - if err := fs.fetchResource(true, sandboxID, "", devicesFileType, &devices); err != nil { - return []api.Device{}, err - } - return devices, nil -} - -func (fs *filesystem) storeSandboxDevices(sandboxID string, devices []api.Device) error { - return fs.storeSandboxResource(sandboxID, devicesFileType, devices) -} - -func (fs *filesystem) fetchHypervisorState(sandboxID string, state interface{}) error { - return fs.fetchResource(true, sandboxID, "", hypervisorFileType, state) -} - -func (fs *filesystem) fetchAgentState(sandboxID string, state interface{}) error { - return fs.fetchResource(true, sandboxID, "", agentFileType, state) -} - -func (fs *filesystem) storeSandboxNetwork(sandboxID string, networkNS NetworkNamespace) error { - return fs.storeSandboxResource(sandboxID, networkFileType, networkNS) -} - -func (fs *filesystem) storeHypervisorState(sandboxID string, state interface{}) error { - hypervisorFile, _, err := fs.resourceURI(true, sandboxID, "", hypervisorFileType) - if err != nil { - return err - } - - return fs.storeFile(hypervisorFile, state) -} - -func (fs *filesystem) storeAgentState(sandboxID string, state interface{}) error { - span, _ := fs.trace("storeAgentState") - defer span.Finish() - - agentFile, _, err := fs.resourceURI(true, sandboxID, "", agentFileType) - if err != nil { - return err - } - - return fs.storeFile(agentFile, state) -} - -func (fs *filesystem) deleteSandboxResources(sandboxID string, resources []sandboxResource) error { - if resources == nil { - resources = []sandboxResource{configFileType, stateFileType} - } - - for _, resource := range resources { - _, dir, err := fs.sandboxURI(sandboxID, resource) - if err != nil { - return err - } - - err = os.RemoveAll(dir) - if err != nil { - return err - } - } - - return nil -} - -func (fs *filesystem) storeContainerResource(sandboxID, containerID string, resource sandboxResource, data interface{}) error { - if sandboxID == "" { - return errNeedSandboxID - } - - if containerID == "" { - return errNeedContainerID - } - - return fs.storeResource(false, sandboxID, containerID, resource, data) -} - -func (fs *filesystem) fetchContainerConfig(sandboxID, containerID string) (ContainerConfig, error) { - var config ContainerConfig - - if err := fs.fetchResource(false, sandboxID, containerID, configFileType, &config); err != nil { - return ContainerConfig{}, err - } - - return config, nil -} - -func (fs *filesystem) fetchContainerState(sandboxID, containerID string) (types.State, error) { - var state types.State - - if err := fs.fetchResource(false, sandboxID, containerID, stateFileType, &state); err != nil { - return types.State{}, err - } - - return state, nil -} - -func (fs *filesystem) fetchContainerProcess(sandboxID, containerID string) (Process, error) { - var process Process - - if err := fs.fetchResource(false, sandboxID, containerID, processFileType, &process); err != nil { - return Process{}, err - } - - return process, nil -} - -func (fs *filesystem) storeContainerProcess(sandboxID, containerID string, process Process) error { - return fs.storeContainerResource(sandboxID, containerID, processFileType, process) -} - -func (fs *filesystem) fetchContainerMounts(sandboxID, containerID string) ([]Mount, error) { - var mounts []Mount - - if err := fs.fetchResource(false, sandboxID, containerID, mountsFileType, &mounts); err != nil { - return []Mount{}, err - } - - return mounts, nil -} - -func (fs *filesystem) fetchContainerDevices(sandboxID, containerID string) ([]ContainerDevice, error) { - var devices []ContainerDevice - - if err := fs.fetchResource(false, sandboxID, containerID, devicesIDFileType, &devices); err != nil { - return nil, err - } - - return devices, nil -} - -func (fs *filesystem) storeContainerMounts(sandboxID, containerID string, mounts []Mount) error { - return fs.storeContainerResource(sandboxID, containerID, mountsFileType, mounts) -} - -func (fs *filesystem) storeContainerDevices(sandboxID, containerID string, devices []ContainerDevice) error { - return fs.storeContainerResource(sandboxID, containerID, devicesIDFileType, devices) -} - -func (fs *filesystem) deleteContainerResources(sandboxID, containerID string, resources []sandboxResource) error { - if resources == nil { - resources = []sandboxResource{configFileType, stateFileType} - } - - for _, resource := range resources { - _, dir, err := fs.sandboxURI(sandboxID, resource) - if err != nil { - return err - } - - containerDir := filepath.Join(dir, containerID, "/") - - err = os.RemoveAll(containerDir) - if err != nil { - return err - } - } - - return nil -} diff --git a/virtcontainers/filesystem_resource_storage_test.go b/virtcontainers/filesystem_resource_storage_test.go deleted file mode 100644 index cbecc6297..000000000 --- a/virtcontainers/filesystem_resource_storage_test.go +++ /dev/null @@ -1,566 +0,0 @@ -// Copyright (c) 2016 Intel Corporation -// -// SPDX-License-Identifier: Apache-2.0 -// - -package virtcontainers - -import ( - "context" - "fmt" - "io/ioutil" - "os" - "path/filepath" - "reflect" - "testing" - - "github.com/kata-containers/runtime/virtcontainers/device/manager" - "github.com/kata-containers/runtime/virtcontainers/types" -) - -func TestFilesystemCreateAllResourcesSuccessful(t *testing.T) { - fs := &filesystem{} - - contConfigs := []ContainerConfig{ - {ID: "1"}, - {ID: "10"}, - {ID: "100"}, - } - - sandboxConfig := &SandboxConfig{ - Containers: contConfigs, - } - - sandbox := &Sandbox{ - ctx: context.Background(), - id: testSandboxID, - config: sandboxConfig, - devManager: manager.NewDeviceManager(manager.VirtioBlock, nil), - containers: map[string]*Container{}, - } - - if err := sandbox.fetchContainers(); err != nil { - t.Fatal(err) - } - - sandboxConfigPath := filepath.Join(configStoragePath, testSandboxID) - sandboxRunPath := filepath.Join(runStoragePath, testSandboxID) - - os.RemoveAll(sandboxConfigPath) - os.RemoveAll(sandboxRunPath) - - for _, container := range contConfigs { - configPath := filepath.Join(configStoragePath, testSandboxID, container.ID) - os.RemoveAll(configPath) - - runPath := filepath.Join(runStoragePath, testSandboxID, container.ID) - os.RemoveAll(runPath) - } - - err := fs.createAllResources(context.Background(), sandbox) - if err != nil { - t.Fatal(err) - } - - // Check resources - _, err = os.Stat(sandboxConfigPath) - if err != nil { - t.Fatal(err) - } - - _, err = os.Stat(sandboxRunPath) - if err != nil { - t.Fatal(err) - } - - for _, container := range contConfigs { - configPath := filepath.Join(configStoragePath, testSandboxID, container.ID) - s, err := os.Stat(configPath) - if err != nil { - t.Fatal(err) - } - - // Check we created the dirs with the correct mode - if s.Mode() != dirMode { - t.Fatal(fmt.Errorf("dirmode [%v] != expected [%v]", s.Mode(), dirMode)) - } - - runPath := filepath.Join(runStoragePath, testSandboxID, container.ID) - s, err = os.Stat(runPath) - if err != nil { - t.Fatal(err) - } - - // Check we created the dirs with the correct mode - if s.Mode() != dirMode { - t.Fatal(fmt.Errorf("dirmode [%v] != expected [%v]", s.Mode(), dirMode)) - } - - } -} - -func TestFilesystemCreateAllResourcesFailingSandboxIDEmpty(t *testing.T) { - fs := &filesystem{} - - sandbox := &Sandbox{} - - err := fs.createAllResources(context.Background(), sandbox) - if err == nil { - t.Fatal() - } -} - -func TestFilesystemCreateAllResourcesFailingContainerIDEmpty(t *testing.T) { - fs := &filesystem{} - - containers := map[string]*Container{ - testContainerID: {}, - } - - sandbox := &Sandbox{ - id: testSandboxID, - containers: containers, - } - - err := fs.createAllResources(context.Background(), sandbox) - if err == nil { - t.Fatal() - } -} - -type TestNoopStructure struct { - Field1 string - Field2 string -} - -func TestFilesystemStoreFileSuccessfulNotExisting(t *testing.T) { - fs := &filesystem{} - - path := filepath.Join(testDir, "testFilesystem") - os.Remove(path) - - data := TestNoopStructure{ - Field1: "value1", - Field2: "value2", - } - - expected := "{\"Field1\":\"value1\",\"Field2\":\"value2\"}" - - err := fs.storeFile(path, data) - if err != nil { - t.Fatal(err) - } - - fileData, err := ioutil.ReadFile(path) - if err != nil { - t.Fatal(err) - } - - if string(fileData) != expected { - t.Fatal() - } -} - -func TestFilesystemStoreFileSuccessfulExisting(t *testing.T) { - fs := &filesystem{} - - path := filepath.Join(testDir, "testFilesystem") - os.Remove(path) - - f, err := os.Create(path) - if err != nil { - t.Fatal(err) - } - f.Close() - - data := TestNoopStructure{ - Field1: "value1", - Field2: "value2", - } - - expected := "{\"Field1\":\"value1\",\"Field2\":\"value2\"}" - - err = fs.storeFile(path, data) - if err != nil { - t.Fatal(err) - } - - fileData, err := ioutil.ReadFile(path) - if err != nil { - t.Fatal(err) - } - - if string(fileData) != expected { - t.Fatal() - } -} - -func TestFilesystemStoreFileFailingMarshalling(t *testing.T) { - fs := &filesystem{} - - path := filepath.Join(testDir, "testFilesystem") - os.Remove(path) - - data := make(chan bool) - - err := fs.storeFile(path, data) - if err == nil { - t.Fatal() - } -} - -func TestFilesystemFetchFileSuccessful(t *testing.T) { - fs := &filesystem{} - data := TestNoopStructure{} - - path := filepath.Join(testDir, "testFilesystem") - os.Remove(path) - - f, err := os.Create(path) - if err != nil { - t.Fatal(err) - } - - dataToWrite := "{\"Field1\":\"value1\",\"Field2\":\"value2\"}" - n, err := f.WriteString(dataToWrite) - if err != nil || n != len(dataToWrite) { - f.Close() - t.Fatal(err) - } - f.Close() - - err = fs.fetchFile(path, sandboxResource(-1), &data) - if err != nil { - t.Fatal(err) - } - - expected := TestNoopStructure{ - Field1: "value1", - Field2: "value2", - } - - if reflect.DeepEqual(data, expected) == false { - t.Fatal() - } -} - -func TestFilesystemFetchFileFailingNoFile(t *testing.T) { - fs := &filesystem{} - data := TestNoopStructure{} - - path := filepath.Join(testDir, "testFilesystem") - os.Remove(path) - - err := fs.fetchFile(path, sandboxResource(-1), &data) - if err == nil { - t.Fatal() - } -} - -func TestFilesystemFetchFileFailingUnMarshalling(t *testing.T) { - fs := &filesystem{} - data := TestNoopStructure{} - - path := filepath.Join(testDir, "testFilesystem") - os.Remove(path) - - f, err := os.Create(path) - if err != nil { - t.Fatal(err) - } - f.Close() - - err = fs.fetchFile(path, sandboxResource(-1), data) - if err == nil { - t.Fatal() - } -} - -func TestFilesystemFetchContainerConfigSuccessful(t *testing.T) { - fs := &filesystem{} - contID := "100" - rootFs := "rootfs" - - contConfigDir := filepath.Join(configStoragePath, testSandboxID, contID) - os.MkdirAll(contConfigDir, dirMode) - - path := filepath.Join(contConfigDir, configFile) - os.Remove(path) - - f, err := os.Create(path) - if err != nil { - t.Fatal(err) - } - - configData := fmt.Sprintf("{\"ID\":\"%s\",\"RootFs\":\"%s\"}", contID, rootFs) - n, err := f.WriteString(configData) - if err != nil || n != len(configData) { - f.Close() - t.Fatal(err) - } - f.Close() - - data, err := fs.fetchContainerConfig(testSandboxID, contID) - if err != nil { - t.Fatal(err) - } - - expected := ContainerConfig{ - ID: contID, - RootFs: rootFs, - } - - if reflect.DeepEqual(data, expected) == false { - t.Fatal() - } -} - -func TestFilesystemFetchContainerConfigFailingContIDEmpty(t *testing.T) { - fs := &filesystem{} - - _, err := fs.fetchContainerConfig(testSandboxID, "") - if err == nil { - t.Fatal() - } -} - -func TestFilesystemFetchContainerConfigFailingSandboxIDEmpty(t *testing.T) { - fs := &filesystem{} - - _, err := fs.fetchContainerConfig("", "100") - if err == nil { - t.Fatal() - } -} - -func TestFilesystemFetchContainerMountsSuccessful(t *testing.T) { - fs := &filesystem{} - contID := "100" - - contMountsDir := filepath.Join(runStoragePath, testSandboxID, contID) - os.MkdirAll(contMountsDir, dirMode) - - path := filepath.Join(contMountsDir, mountsFile) - os.Remove(path) - - f, err := os.Create(path) - if err != nil { - t.Fatal(err) - } - - source := "/dev/sda1" - dest := "/root" - mntType := "ext4" - options := "rw" - hostPath := "/tmp/root" - - mountData := fmt.Sprintf(` - [ - { - "Source":"%s", - "Destination":"%s", - "Type":"%s", - "Options": ["%s"], - "HostPath":"%s" - } - ] - `, source, dest, mntType, options, hostPath) - - n, err := f.WriteString(mountData) - if err != nil || n != len(mountData) { - f.Close() - t.Fatal(err) - } - f.Close() - - data, err := fs.fetchContainerMounts(testSandboxID, contID) - if err != nil { - data, _ := ioutil.ReadFile(path) - t.Logf("Data from file : %s", string(data[:])) - t.Fatal(err) - } - - expected := []Mount{ - { - Source: source, - Destination: dest, - Type: mntType, - Options: []string{"rw"}, - HostPath: hostPath, - }, - } - - if reflect.DeepEqual(data, expected) == false { - t.Fatalf("Expected : [%v]\n, Got : [%v]\n", expected, data) - } -} - -func TestFilesystemFetchContainerMountsInvalidType(t *testing.T) { - fs := &filesystem{} - contID := "100" - - contMountsDir := filepath.Join(runStoragePath, testSandboxID, contID) - os.MkdirAll(contMountsDir, dirMode) - - path := filepath.Join(contMountsDir, mountsFile) - os.Remove(path) - - f, err := os.Create(path) - if err != nil { - t.Fatal(err) - } - - configData := fmt.Sprintf("{\"ID\":\"%s\",\"RootFs\":\"rootfs\"}", contID) - n, err := f.WriteString(configData) - if err != nil || n != len(configData) { - f.Close() - t.Fatal(err) - } - f.Close() - - _, err = fs.fetchContainerMounts(testSandboxID, contID) - if err == nil { - t.Fatal() - } -} - -func TestFilesystemFetchContainerMountsFailingContIDEmpty(t *testing.T) { - fs := &filesystem{} - - _, err := fs.fetchContainerMounts(testSandboxID, "") - if err == nil { - t.Fatal() - } -} - -func TestFilesystemFetchContainerMountsFailingSandboxIDEmpty(t *testing.T) { - fs := &filesystem{} - - _, err := fs.fetchContainerMounts("", "100") - if err == nil { - t.Fatal() - } -} - -func TestFilesystemResourceDirFailingSandboxIDEmpty(t *testing.T) { - for _, b := range []bool{true, false} { - _, err := resourceDir(b, "", "", configFileType) - if err == nil { - t.Fatal() - } - } -} - -func TestFilesystemResourceDirFailingInvalidResource(t *testing.T) { - for _, b := range []bool{true, false} { - _, err := resourceDir(b, testSandboxID, "100", sandboxResource(-1)) - if err == nil { - t.Fatal() - } - } -} - -func TestFilesystemResourceURIFailingResourceDir(t *testing.T) { - fs := &filesystem{} - - for _, b := range []bool{true, false} { - _, _, err := fs.resourceURI(b, testSandboxID, "100", sandboxResource(-1)) - if err == nil { - t.Fatal() - } - } -} - -func TestFilesystemStoreResourceFailingSandboxConfigStateFileType(t *testing.T) { - fs := &filesystem{} - data := SandboxConfig{} - - for _, b := range []bool{true, false} { - err := fs.storeResource(b, testSandboxID, "100", stateFileType, data) - if err == nil { - t.Fatal() - } - } -} - -func TestFilesystemStoreResourceFailingContainerConfigStateFileType(t *testing.T) { - fs := &filesystem{} - data := ContainerConfig{} - - for _, b := range []bool{true, false} { - err := fs.storeResource(b, testSandboxID, "100", stateFileType, data) - if err == nil { - t.Fatal() - } - } -} - -func TestFilesystemStoreResourceFailingSandboxConfigResourceURI(t *testing.T) { - fs := &filesystem{} - data := SandboxConfig{} - - for _, b := range []bool{true, false} { - err := fs.storeResource(b, "", "100", configFileType, data) - if err == nil { - t.Fatal() - } - } -} - -func TestFilesystemStoreResourceFailingContainerConfigResourceURI(t *testing.T) { - fs := &filesystem{} - data := ContainerConfig{} - - for _, b := range []bool{true, false} { - err := fs.storeResource(b, "", "100", configFileType, data) - if err == nil { - t.Fatal() - } - } -} - -func TestFilesystemStoreResourceFailingStateConfigFileType(t *testing.T) { - fs := &filesystem{} - data := types.State{} - - for _, b := range []bool{true, false} { - err := fs.storeResource(b, testSandboxID, "100", configFileType, data) - if err == nil { - t.Fatal() - } - } -} - -func TestFilesystemStoreResourceFailingStateResourceURI(t *testing.T) { - fs := &filesystem{} - data := types.State{} - - for _, b := range []bool{true, false} { - err := fs.storeResource(b, "", "100", stateFileType, data) - if err == nil { - t.Fatal() - } - } -} - -func TestFilesystemStoreResourceFailingWrongDataType(t *testing.T) { - fs := &filesystem{} - data := TestNoopStructure{} - - for _, b := range []bool{true, false} { - err := fs.storeResource(b, testSandboxID, "100", configFileType, data) - if err == nil { - t.Fatal() - } - } -} - -func TestFilesystemFetchResourceFailingWrongResourceType(t *testing.T) { - fs := &filesystem{} - - for _, b := range []bool{true, false} { - if err := fs.fetchResource(b, testSandboxID, "100", lockFileType, nil); err == nil { - t.Fatal() - } - } -} diff --git a/virtcontainers/noop_resource_storage.go b/virtcontainers/noop_resource_storage.go deleted file mode 100644 index 89db7c7fa..000000000 --- a/virtcontainers/noop_resource_storage.go +++ /dev/null @@ -1,113 +0,0 @@ -// Copyright (c) 2018 Intel Corporation -// -// SPDX-License-Identifier: Apache-2.0 -// - -package virtcontainers - -import ( - "github.com/kata-containers/runtime/virtcontainers/device/api" - "github.com/kata-containers/runtime/virtcontainers/types" -) - -type noopResourceStorage struct{} - -func (n *noopResourceStorage) createAllResources(sandbox *Sandbox) error { - return nil -} - -func (n *noopResourceStorage) containerURI(sandboxID, containerID string, resource sandboxResource) (string, string, error) { - return "", "", nil -} - -func (n *noopResourceStorage) sandboxURI(sandboxID string, resource sandboxResource) (string, string, error) { - return "", "", nil -} - -func (n *noopResourceStorage) storeSandboxResource(sandboxID string, resource sandboxResource, data interface{}) error { - return nil -} - -func (n *noopResourceStorage) deleteSandboxResources(sandboxID string, resources []sandboxResource) error { - return nil -} - -func (n *noopResourceStorage) fetchSandboxConfig(sandboxID string) (SandboxConfig, error) { - return SandboxConfig{}, nil -} - -func (n *noopResourceStorage) fetchSandboxState(sandboxID string) (types.State, error) { - return types.State{}, nil -} - -func (n *noopResourceStorage) fetchSandboxNetwork(sandboxID string) (NetworkNamespace, error) { - return NetworkNamespace{}, nil -} - -func (n *noopResourceStorage) storeSandboxNetwork(sandboxID string, networkNS NetworkNamespace) error { - return nil -} - -func (n *noopResourceStorage) fetchSandboxDevices(sandboxID string) ([]api.Device, error) { - return []api.Device{}, nil -} - -func (n *noopResourceStorage) storeSandboxDevices(sandboxID string, devices []api.Device) error { - return nil -} - -func (n *noopResourceStorage) fetchHypervisorState(sandboxID string, state interface{}) error { - return nil -} - -func (n *noopResourceStorage) storeHypervisorState(sandboxID string, state interface{}) error { - return nil -} - -func (n *noopResourceStorage) fetchAgentState(sandboxID string, state interface{}) error { - return nil -} - -func (n *noopResourceStorage) storeAgentState(sandboxID string, state interface{}) error { - return nil -} - -func (n *noopResourceStorage) storeContainerResource(sandboxID, containerID string, resource sandboxResource, data interface{}) error { - return nil -} - -func (n *noopResourceStorage) deleteContainerResources(sandboxID, containerID string, resources []sandboxResource) error { - return nil -} - -func (n *noopResourceStorage) fetchContainerConfig(sandboxID, containerID string) (ContainerConfig, error) { - return ContainerConfig{}, nil -} - -func (n *noopResourceStorage) fetchContainerState(sandboxID, containerID string) (types.State, error) { - return types.State{}, nil -} - -func (n *noopResourceStorage) fetchContainerProcess(sandboxID, containerID string) (Process, error) { - return Process{}, nil -} - -func (n *noopResourceStorage) storeContainerProcess(sandboxID, containerID string, process Process) error { - return nil -} - -func (n *noopResourceStorage) fetchContainerMounts(sandboxID, containerID string) ([]Mount, error) { - return []Mount{}, nil -} - -func (n *noopResourceStorage) storeContainerMounts(sandboxID, containerID string, mounts []Mount) error { - return nil -} - -func (n *noopResourceStorage) fetchContainerDevices(sandboxID, containerID string) ([]ContainerDevice, error) { - return []ContainerDevice{}, nil -} - -func (n *noopResourceStorage) storeContainerDevices(sandboxID, containerID string, devices []ContainerDevice) error { - return nil -} diff --git a/virtcontainers/noop_resource_storage_test.go b/virtcontainers/noop_resource_storage_test.go deleted file mode 100644 index 1e4a696bf..000000000 --- a/virtcontainers/noop_resource_storage_test.go +++ /dev/null @@ -1,188 +0,0 @@ -// Copyright (c) 2018 Intel Corporation -// -// SPDX-License-Identifier: Apache-2.0 -// - -package virtcontainers - -import ( - "testing" - - "github.com/kata-containers/runtime/virtcontainers/device/api" - "github.com/stretchr/testify/assert" -) - -func TestNoopCreateAllResources(t *testing.T) { - n := &noopResourceStorage{} - - err := n.createAllResources(nil) - assert.Nil(t, err) -} - -func TestNoopContainerURI(t *testing.T) { - n := &noopResourceStorage{} - - _, _, err := n.containerURI("", "", 0) - assert.Nil(t, err) -} - -func TestNoopSandboxURI(t *testing.T) { - n := &noopResourceStorage{} - - _, _, err := n.sandboxURI("", 0) - assert.Nil(t, err) -} - -func TestNoopStoreSandboxResource(t *testing.T) { - n := &noopResourceStorage{} - - err := n.storeSandboxResource("", 0, nil) - assert.Nil(t, err) -} - -func TestNoopDeleteSandboxResources(t *testing.T) { - n := &noopResourceStorage{} - - err := n.deleteSandboxResources("", []sandboxResource{0}) - assert.Nil(t, err) -} - -func TestNoopFetchSandboxConfig(t *testing.T) { - n := &noopResourceStorage{} - - _, err := n.fetchSandboxConfig("") - assert.Nil(t, err) -} - -func TestNoopFetchSandboxState(t *testing.T) { - n := &noopResourceStorage{} - - _, err := n.fetchSandboxState("") - assert.Nil(t, err) -} - -func TestNoopFetchSandboxNetwork(t *testing.T) { - n := &noopResourceStorage{} - - _, err := n.fetchSandboxNetwork("") - assert.Nil(t, err) -} - -func TestNoopStoreSandboxNetwork(t *testing.T) { - n := &noopResourceStorage{} - - err := n.storeSandboxNetwork("", NetworkNamespace{}) - assert.Nil(t, err) -} - -func TestNoopFetchSandboxDevices(t *testing.T) { - n := &noopResourceStorage{} - - _, err := n.fetchSandboxDevices("") - assert.Nil(t, err) -} - -func TestNoopStoreSandboxDevices(t *testing.T) { - n := &noopResourceStorage{} - - err := n.storeSandboxDevices("", []api.Device{}) - assert.Nil(t, err) -} - -func TestNoopFetchHypervisorState(t *testing.T) { - n := &noopResourceStorage{} - - err := n.fetchHypervisorState("", nil) - assert.Nil(t, err) -} - -func TestNoopStoreHypervisorState(t *testing.T) { - n := &noopResourceStorage{} - - err := n.storeHypervisorState("", nil) - assert.Nil(t, err) -} - -func TestNoopFetchAgentState(t *testing.T) { - n := &noopResourceStorage{} - - err := n.fetchAgentState("", nil) - assert.Nil(t, err) -} - -func TestNoopStoreAgentState(t *testing.T) { - n := &noopResourceStorage{} - - err := n.storeAgentState("", nil) - assert.Nil(t, err) -} - -func TestNoopStoreContainerResource(t *testing.T) { - n := &noopResourceStorage{} - - err := n.storeContainerResource("", "", 0, nil) - assert.Nil(t, err) -} - -func TestNoopDeleteContainerResources(t *testing.T) { - n := &noopResourceStorage{} - - err := n.deleteContainerResources("", "", []sandboxResource{0}) - assert.Nil(t, err) -} - -func TestNoopFetchContainerConfig(t *testing.T) { - n := &noopResourceStorage{} - - _, err := n.fetchContainerConfig("", "") - assert.Nil(t, err) -} - -func TestNoopFetchContainerState(t *testing.T) { - n := &noopResourceStorage{} - - _, err := n.fetchContainerState("", "") - assert.Nil(t, err) -} - -func TestNoopFetchContainerProcess(t *testing.T) { - n := &noopResourceStorage{} - - _, err := n.fetchContainerProcess("", "") - assert.Nil(t, err) -} - -func TestNoopStoreContainerProcess(t *testing.T) { - n := &noopResourceStorage{} - - err := n.storeContainerProcess("", "", Process{}) - assert.Nil(t, err) -} - -func TestNoopFetchContainerMounts(t *testing.T) { - n := &noopResourceStorage{} - - _, err := n.fetchContainerMounts("", "") - assert.Nil(t, err) -} - -func TestNoopStoreContainerMounts(t *testing.T) { - n := &noopResourceStorage{} - - err := n.storeContainerMounts("", "", []Mount{}) - assert.Nil(t, err) -} - -func TestNoopFetchContainerDevices(t *testing.T) { - n := &noopResourceStorage{} - - _, err := n.fetchContainerDevices("", "") - assert.Nil(t, err) -} - -func TestNoopStoreContainerDevices(t *testing.T) { - n := &noopResourceStorage{} - - err := n.storeContainerDevices("", "", []ContainerDevice{}) - assert.Nil(t, err) -} diff --git a/virtcontainers/resource_storage.go b/virtcontainers/resource_storage.go deleted file mode 100644 index 91cbf27a5..000000000 --- a/virtcontainers/resource_storage.go +++ /dev/null @@ -1,69 +0,0 @@ -// Copyright (c) 2018 Intel Corporation -// -// SPDX-License-Identifier: Apache-2.0 -// - -package virtcontainers - -import ( - "context" - "encoding/json" - - "github.com/kata-containers/runtime/virtcontainers/device/api" - "github.com/kata-containers/runtime/virtcontainers/types" -) - -// TypedDevice is used as an intermediate representation for marshalling -// and unmarshalling Device implementations. -type TypedDevice struct { - Type string - - // Data is assigned the Device object. - // This being declared as RawMessage prevents it from being marshalled/unmarshalled. - // We do that explicitly depending on Type. - Data json.RawMessage -} - -// resourceStorage is the virtcontainers resources (configuration, state, etc...) -// storage interface. -// The default resource storage implementation is filesystem. -type resourceStorage interface { - // Create all resources for a sandbox - createAllResources(ctx context.Context, sandbox *Sandbox) error - - // Resources URIs functions return both the URI - // for the actual resource and the URI base. - containerURI(sandboxID, containerID string, resource sandboxResource) (string, string, error) - sandboxURI(sandboxID string, resource sandboxResource) (string, string, error) - - // Sandbox resources - storeSandboxResource(sandboxID string, resource sandboxResource, data interface{}) error - deleteSandboxResources(sandboxID string, resources []sandboxResource) error - fetchSandboxConfig(sandboxID string) (SandboxConfig, error) - fetchSandboxState(sandboxID string) (types.State, error) - fetchSandboxNetwork(sandboxID string) (NetworkNamespace, error) - storeSandboxNetwork(sandboxID string, networkNS NetworkNamespace) error - fetchSandboxDevices(sandboxID string) ([]api.Device, error) - storeSandboxDevices(sandboxID string, devices []api.Device) error - - // Hypervisor resources - fetchHypervisorState(sandboxID string, state interface{}) error - storeHypervisorState(sandboxID string, state interface{}) error - - // Agent resources - fetchAgentState(sandboxID string, state interface{}) error - storeAgentState(sandboxID string, state interface{}) error - - // Container resources - storeContainerResource(sandboxID, containerID string, resource sandboxResource, data interface{}) error - deleteContainerResources(sandboxID, containerID string, resources []sandboxResource) error - fetchContainerConfig(sandboxID, containerID string) (ContainerConfig, error) - fetchContainerState(sandboxID, containerID string) (types.State, error) - fetchContainerProcess(sandboxID, containerID string) (Process, error) - storeContainerProcess(sandboxID, containerID string, process Process) error - fetchContainerMounts(sandboxID, containerID string) ([]Mount, error) - storeContainerMounts(sandboxID, containerID string, mounts []Mount) error - fetchContainerDevices(sandboxID, containerID string) ([]ContainerDevice, error) - storeContainerDevices(sandboxID, containerID string, devices []ContainerDevice) error - createSandboxTempFile(sandboxID string) (string, error) -}