mirror of
https://github.com/aljazceru/kata-containers.git
synced 2025-12-22 16:54:25 +01:00
6107694930
As agreed in [the kata containers API design](https://github.com/kata-containers/documentation/blob/master/design/kata-api-design.md), we need to rename pod notion to sandbox. The patch is a bit big but the actual change is done through the script: ``` sed -i -e 's/pod/sandbox/g' -e 's/Pod/Sandbox/g' -e 's/POD/SB/g' ``` The only expections are `pod_sandbox` and `pod_container` annotations, since we already pushed them to cri shims, we have to use them unchanged. Fixes: #199 Signed-off-by: Peng Tao <bergwolf@gmail.com>
572 lines
12 KiB
Go
572 lines
12 KiB
Go
//
|
|
// Copyright (c) 2016 Intel Corporation
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
|
|
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()
|
|
}
|
|
}
|
|
}
|