github/kata-containers
1
0
Fork 1
mirror of https://github.com/kata-containers/kata-containers.git synced 2025-07-01 17:52:40 +00:00
Code Issues Projects Releases Wiki Activity

virtcontainers: Remove the resource storage original implementation

Browse Source 
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 2019-01-09 11:08:39 +01:00
parent fad23ea54e
commit f8e7e308c3
6 changed files with 0 additions and 1811 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
virtcontainers/errors.go
View File

@ -14,8 +14,6 @@ var (
errNeedSandbox = errors.New("Sandbox must be specified") errNeedSandbox = errors.New("Sandbox must be specified")
errNeedSandboxID = errors.New("Sandbox ID cannot be empty") errNeedSandboxID = errors.New("Sandbox ID cannot be empty")
errNeedContainerID = errors.New("Container 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") errNeedState = errors.New("State cannot be empty")
errInvalidResource = errors.New("Invalid sandbox resource")
errNoSuchContainer = errors.New("Container does not exist") errNoSuchContainer = errors.New("Container does not exist")
) )

873
virtcontainers/filesystem_resource_storage.go
View File

@ -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
}

566
virtcontainers/filesystem_resource_storage_test.go
View File

@ -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()
}
}
}

113
virtcontainers/noop_resource_storage.go
View File

@ -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
}

188
virtcontainers/noop_resource_storage_test.go
View File

@ -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)
}

69
virtcontainers/resource_storage.go
View File

@ -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)
}