mirror of
https://github.com/aljazceru/kata-containers.git
synced 2025-12-22 16:54:25 +01:00
5fb4768f83
Currently we sometimes pass it as a pointer and other times not. As a result, the view of sandbox across virtcontainers may not be the same and it costs extra memory copy each time we pass it by value. Fix it by ensuring sandbox is always passed by pointers. Fixes: #262 Signed-off-by: Peng Tao <bergwolf@gmail.com>
561 lines
11 KiB
Go
561 lines
11 KiB
Go
// Copyright (c) 2016 Intel Corporation
|
|
//
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
//
|
|
|
|
package virtcontainers
|
|
|
|
import (
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
"path/filepath"
|
|
"reflect"
|
|
"testing"
|
|
)
|
|
|
|
func TestFilesystemCreateAllResourcesSuccessful(t *testing.T) {
|
|
fs := &filesystem{}
|
|
|
|
contConfigs := []ContainerConfig{
|
|
{ID: "1"},
|
|
{ID: "10"},
|
|
{ID: "100"},
|
|
}
|
|
|
|
sandboxConfig := &SandboxConfig{
|
|
Containers: contConfigs,
|
|
}
|
|
|
|
sandbox := &Sandbox{
|
|
id: testSandboxID,
|
|
storage: fs,
|
|
config: sandboxConfig,
|
|
}
|
|
|
|
if err := sandbox.newContainers(); 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(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(sandbox)
|
|
if err == nil {
|
|
t.Fatal()
|
|
}
|
|
}
|
|
|
|
func TestFilesystemCreateAllResourcesFailingContainerIDEmpty(t *testing.T) {
|
|
fs := &filesystem{}
|
|
|
|
containers := []*Container{
|
|
{id: ""},
|
|
}
|
|
|
|
sandbox := &Sandbox{
|
|
id: testSandboxID,
|
|
containers: containers,
|
|
}
|
|
|
|
err := fs.createAllResources(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 := 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 := 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()
|
|
}
|
|
}
|
|
}
|