mirror of
https://github.com/kata-containers/kata-containers.git
synced 2025-07-01 01:33:20 +00:00
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 <sameo@linux.intel.com>
This commit is contained in:
Samuel Ortiz
parent
fad23ea54e
commit
f8e7e308c3
@ -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")
|
||||
)
|
||||
|
||||
@ -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
|
||||
}
|
||||
@ -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()
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -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
|
||||
}
|
||||
@ -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)
|
||||
}
|
||||
@ -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)
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user