diff --git a/cli/delete_test.go b/cli/delete_test.go index 041ea3aee..e3cde76f7 100644 --- a/cli/delete_test.go +++ b/cli/delete_test.go @@ -16,6 +16,7 @@ import ( vc "github.com/kata-containers/runtime/virtcontainers" vcAnnotations "github.com/kata-containers/runtime/virtcontainers/pkg/annotations" "github.com/kata-containers/runtime/virtcontainers/pkg/vcmock" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/stretchr/testify/assert" "github.com/urfave/cli" ) @@ -163,7 +164,7 @@ func TestDeleteSandbox(t *testing.T) { vcAnnotations.ContainerTypeKey: string(vc.PodSandbox), vcAnnotations.ConfigJSONKey: configJSON, }, - State: vc.State{ + State: types.State{ State: "ready", }, }, nil @@ -180,8 +181,8 @@ func TestDeleteSandbox(t *testing.T) { testingImpl.StatusSandboxFunc = func(ctx context.Context, sandboxID string) (vc.SandboxStatus, error) { return vc.SandboxStatus{ ID: sandbox.ID(), - State: vc.State{ - State: vc.StateReady, + State: types.State{ + State: types.StateReady, }, }, nil } @@ -241,7 +242,7 @@ func TestDeleteInvalidContainerType(t *testing.T) { vcAnnotations.ContainerTypeKey: "InvalidType", vcAnnotations.ConfigJSONKey: configJSON, }, - State: vc.State{ + State: types.State{ State: "created", }, }, nil @@ -280,7 +281,7 @@ func TestDeleteSandboxRunning(t *testing.T) { vcAnnotations.ContainerTypeKey: string(vc.PodSandbox), vcAnnotations.ConfigJSONKey: configJSON, }, - State: vc.State{ + State: types.State{ State: "running", }, }, nil @@ -298,8 +299,8 @@ func TestDeleteSandboxRunning(t *testing.T) { testingImpl.StatusSandboxFunc = func(ctx context.Context, sandboxID string) (vc.SandboxStatus, error) { return vc.SandboxStatus{ ID: sandbox.ID(), - State: vc.State{ - State: vc.StateRunning, + State: types.State{ + State: types.StateRunning, }, }, nil } @@ -360,7 +361,7 @@ func TestDeleteRunningContainer(t *testing.T) { vcAnnotations.ContainerTypeKey: string(vc.PodContainer), vcAnnotations.ConfigJSONKey: configJSON, }, - State: vc.State{ + State: types.State{ State: "running", }, }, nil @@ -443,7 +444,7 @@ func TestDeleteContainer(t *testing.T) { vcAnnotations.ContainerTypeKey: string(vc.PodContainer), vcAnnotations.ConfigJSONKey: configJSON, }, - State: vc.State{ + State: types.State{ State: "ready", }, }, nil @@ -543,7 +544,7 @@ func TestDeleteCLIFunctionSuccess(t *testing.T) { vcAnnotations.ContainerTypeKey: string(vc.PodSandbox), vcAnnotations.ConfigJSONKey: configJSON, }, - State: vc.State{ + State: types.State{ State: "ready", }, }, nil @@ -552,8 +553,8 @@ func TestDeleteCLIFunctionSuccess(t *testing.T) { testingImpl.StatusSandboxFunc = func(ctx context.Context, sandboxID string) (vc.SandboxStatus, error) { return vc.SandboxStatus{ ID: sandbox.ID(), - State: vc.State{ - State: vc.StateReady, + State: types.State{ + State: types.StateReady, }, }, nil } diff --git a/cli/events.go b/cli/events.go index 96acce621..9e9200a6f 100644 --- a/cli/events.go +++ b/cli/events.go @@ -14,6 +14,7 @@ import ( "time" vc "github.com/kata-containers/runtime/virtcontainers" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/kata-containers/runtime/pkg/katautils" "github.com/sirupsen/logrus" @@ -175,7 +176,7 @@ information is displayed once every 5 seconds.`, span.SetTag("container", containerID) span.SetTag("sandbox", sandboxID) - if status.State.State == vc.StateStopped { + if status.State.State == types.StateStopped { return fmt.Errorf("container with id %s is not running", status.ID) } diff --git a/cli/events_test.go b/cli/events_test.go index e544202b5..b71ca1b3f 100644 --- a/cli/events_test.go +++ b/cli/events_test.go @@ -15,6 +15,7 @@ import ( vc "github.com/kata-containers/runtime/virtcontainers" vcAnnotations "github.com/kata-containers/runtime/virtcontainers/pkg/annotations" "github.com/kata-containers/runtime/virtcontainers/pkg/vcmock" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/stretchr/testify/assert" "github.com/urfave/cli" ) @@ -111,8 +112,8 @@ func TestEventsCLISuccessful(t *testing.T) { Annotations: map[string]string{ vcAnnotations.ContainerTypeKey: string(vc.PodContainer), }, - State: vc.State{ - State: vc.StateRunning, + State: types.State{ + State: types.StateRunning, }, }, nil } diff --git a/cli/exec.go b/cli/exec.go index 549c29210..1c1574ce0 100644 --- a/cli/exec.go +++ b/cli/exec.go @@ -15,8 +15,9 @@ import ( "syscall" "github.com/kata-containers/runtime/pkg/katautils" - vc "github.com/kata-containers/runtime/virtcontainers" "github.com/kata-containers/runtime/virtcontainers/pkg/oci" + "github.com/kata-containers/runtime/virtcontainers/types" + specs "github.com/opencontainers/runtime-spec/specs-go" "github.com/urfave/cli" ) @@ -226,8 +227,8 @@ func execute(ctx context.Context, context *cli.Context) error { span.SetTag("container", containerID) // container MUST be ready or running. - if status.State.State != vc.StateReady && - status.State.State != vc.StateRunning { + if status.State.State != types.StateReady && + status.State.State != types.StateRunning { return fmt.Errorf("Container %s is not ready or running", params.cID) } @@ -248,7 +249,7 @@ func execute(ctx context.Context, context *cli.Context) error { user = params.ociProcess.User.Username } - cmd := vc.Cmd{ + cmd := types.Cmd{ Args: params.ociProcess.Args, Envs: envVars, WorkDir: params.ociProcess.Cwd, diff --git a/cli/exec_test.go b/cli/exec_test.go index 8319b5da0..30edaf4cb 100644 --- a/cli/exec_test.go +++ b/cli/exec_test.go @@ -18,6 +18,7 @@ import ( vcAnnotations "github.com/kata-containers/runtime/virtcontainers/pkg/annotations" "github.com/kata-containers/runtime/virtcontainers/pkg/oci" "github.com/kata-containers/runtime/virtcontainers/pkg/vcmock" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/stretchr/testify/assert" "github.com/urfave/cli" ) @@ -77,7 +78,7 @@ func TestExecuteErrors(t *testing.T) { } testingImpl.StatusContainerFunc = func(ctx context.Context, sandboxID, containerID string) (vc.ContainerStatus, error) { - return newSingleContainerStatus(testContainerID, vc.State{}, annotations), nil + return newSingleContainerStatus(testContainerID, types.State{}, annotations), nil } defer func() { @@ -99,7 +100,7 @@ func TestExecuteErrors(t *testing.T) { vcAnnotations.ConfigJSONKey: configJSON, } - containerState := vc.State{} + containerState := types.State{} testingImpl.StatusContainerFunc = func(ctx context.Context, sandboxID, containerID string) (vc.ContainerStatus, error) { return newSingleContainerStatus(testContainerID, containerState, annotations), nil } @@ -109,8 +110,8 @@ func TestExecuteErrors(t *testing.T) { assert.False(vcmock.IsMockError(err)) // Container paused - containerState = vc.State{ - State: vc.StatePaused, + containerState = types.State{ + State: types.StatePaused, } testingImpl.StatusContainerFunc = func(ctx context.Context, sandboxID, containerID string) (vc.ContainerStatus, error) { return newSingleContainerStatus(testContainerID, containerState, annotations), nil @@ -121,8 +122,8 @@ func TestExecuteErrors(t *testing.T) { assert.False(vcmock.IsMockError(err)) // Container stopped - containerState = vc.State{ - State: vc.StateStopped, + containerState = types.State{ + State: types.StateStopped, } testingImpl.StatusContainerFunc = func(ctx context.Context, sandboxID, containerID string) (vc.ContainerStatus, error) { return newSingleContainerStatus(testContainerID, containerState, annotations), nil @@ -158,8 +159,8 @@ func TestExecuteErrorReadingProcessJson(t *testing.T) { vcAnnotations.ConfigJSONKey: configJSON, } - state := vc.State{ - State: vc.StateRunning, + state := types.State{ + State: types.StateRunning, } path, err := createTempContainerIDMapping(testContainerID, testSandboxID) @@ -207,8 +208,8 @@ func TestExecuteErrorOpeningConsole(t *testing.T) { vcAnnotations.ConfigJSONKey: configJSON, } - state := vc.State{ - State: vc.StateRunning, + state := types.State{ + State: types.StateRunning, } path, err := createTempContainerIDMapping(testContainerID, testSandboxID) @@ -274,8 +275,8 @@ func TestExecuteWithFlags(t *testing.T) { vcAnnotations.ConfigJSONKey: configJSON, } - state := vc.State{ - State: vc.StateRunning, + state := types.State{ + State: types.StateRunning, } path, err := createTempContainerIDMapping(testContainerID, testSandboxID) @@ -299,7 +300,7 @@ func TestExecuteWithFlags(t *testing.T) { assert.True(vcmock.IsMockError(err)) - testingImpl.EnterContainerFunc = func(ctx context.Context, sandboxID, containerID string, cmd vc.Cmd) (vc.VCSandbox, vc.VCContainer, *vc.Process, error) { + testingImpl.EnterContainerFunc = func(ctx context.Context, sandboxID, containerID string, cmd types.Cmd) (vc.VCSandbox, vc.VCContainer, *vc.Process, error) { return &vcmock.Sandbox{}, &vcmock.Container{}, &vc.Process{}, nil } @@ -316,7 +317,7 @@ func TestExecuteWithFlags(t *testing.T) { os.Remove(pidFilePath) // Process ran and exited successfully - testingImpl.EnterContainerFunc = func(ctx context.Context, sandboxID, containerID string, cmd vc.Cmd) (vc.VCSandbox, vc.VCContainer, *vc.Process, error) { + testingImpl.EnterContainerFunc = func(ctx context.Context, sandboxID, containerID string, cmd types.Cmd) (vc.VCSandbox, vc.VCContainer, *vc.Process, error) { // create a fake container process workload := []string{"cat", "/dev/null"} command := exec.Command(workload[0], workload[1:]...) @@ -364,8 +365,8 @@ func TestExecuteWithFlagsDetached(t *testing.T) { vcAnnotations.ConfigJSONKey: configJSON, } - state := vc.State{ - State: vc.StateRunning, + state := types.State{ + State: types.StateRunning, } path, err := createTempContainerIDMapping(testContainerID, testSandboxID) @@ -380,7 +381,7 @@ func TestExecuteWithFlagsDetached(t *testing.T) { testingImpl.StatusContainerFunc = nil }() - testingImpl.EnterContainerFunc = func(ctx context.Context, sandboxID, containerID string, cmd vc.Cmd) (vc.VCSandbox, vc.VCContainer, *vc.Process, error) { + testingImpl.EnterContainerFunc = func(ctx context.Context, sandboxID, containerID string, cmd types.Cmd) (vc.VCSandbox, vc.VCContainer, *vc.Process, error) { // create a fake container process workload := []string{"cat", "/dev/null"} command := exec.Command(workload[0], workload[1:]...) @@ -443,8 +444,8 @@ func TestExecuteWithInvalidProcessJson(t *testing.T) { vcAnnotations.ConfigJSONKey: configJSON, } - state := vc.State{ - State: vc.StateRunning, + state := types.State{ + State: types.StateRunning, } path, err := createTempContainerIDMapping(testContainerID, testSandboxID) @@ -495,8 +496,8 @@ func TestExecuteWithValidProcessJson(t *testing.T) { vcAnnotations.ConfigJSONKey: configJSON, } - state := vc.State{ - State: vc.StateRunning, + state := types.State{ + State: types.StateRunning, } path, err := createTempContainerIDMapping(testContainerID, testSandboxID) @@ -542,7 +543,7 @@ func TestExecuteWithValidProcessJson(t *testing.T) { workload := []string{"cat", "/dev/null"} - testingImpl.EnterContainerFunc = func(ctx context.Context, sandboxID, containerID string, cmd vc.Cmd) (vc.VCSandbox, vc.VCContainer, *vc.Process, error) { + testingImpl.EnterContainerFunc = func(ctx context.Context, sandboxID, containerID string, cmd types.Cmd) (vc.VCSandbox, vc.VCContainer, *vc.Process, error) { // create a fake container process command := exec.Command(workload[0], workload[1:]...) err := command.Start() @@ -596,8 +597,8 @@ func TestExecuteWithEmptyEnvironmentValue(t *testing.T) { vcAnnotations.ConfigJSONKey: configJSON, } - state := vc.State{ - State: vc.StateRunning, + state := types.State{ + State: types.StateRunning, } path, err := createTempContainerIDMapping(testContainerID, testSandboxID) @@ -644,7 +645,7 @@ func TestExecuteWithEmptyEnvironmentValue(t *testing.T) { workload := []string{"cat", "/dev/null"} - testingImpl.EnterContainerFunc = func(ctx context.Context, sandboxID, containerID string, cmd vc.Cmd) (vc.VCSandbox, vc.VCContainer, *vc.Process, error) { + testingImpl.EnterContainerFunc = func(ctx context.Context, sandboxID, containerID string, cmd types.Cmd) (vc.VCSandbox, vc.VCContainer, *vc.Process, error) { // create a fake container process command := exec.Command(workload[0], workload[1:]...) err := command.Start() diff --git a/cli/kill.go b/cli/kill.go index 645e231c6..97b3a549b 100644 --- a/cli/kill.go +++ b/cli/kill.go @@ -15,6 +15,7 @@ import ( "github.com/kata-containers/runtime/pkg/katautils" vc "github.com/kata-containers/runtime/virtcontainers" "github.com/kata-containers/runtime/virtcontainers/pkg/oci" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -132,7 +133,7 @@ func kill(ctx context.Context, containerID, signal string, all bool) error { kataLog.WithField("signal", signal).WithField("container state", status.State.State).Info("kill") // container MUST be created, running or paused - if status.State.State == vc.StateReady || status.State.State == vc.StateRunning || status.State.State == vc.StatePaused { + if status.State.State == types.StateReady || status.State.State == types.StateRunning || status.State.State == types.StatePaused { if err := vci.KillContainer(ctx, sandboxID, containerID, signum, all); err != nil { return err } diff --git a/cli/kill_test.go b/cli/kill_test.go index 41094fce3..45ba4225b 100644 --- a/cli/kill_test.go +++ b/cli/kill_test.go @@ -16,6 +16,7 @@ import ( vc "github.com/kata-containers/runtime/virtcontainers" vcAnnotations "github.com/kata-containers/runtime/virtcontainers/pkg/annotations" "github.com/kata-containers/runtime/virtcontainers/pkg/vcmock" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/stretchr/testify/assert" ) @@ -64,8 +65,8 @@ func TestProcessSignal(t *testing.T) { func testKillCLIFunctionTerminationSignalSuccessful(t *testing.T, sig string) { assert := assert.New(t) - state := vc.State{ - State: vc.StateRunning, + state := types.State{ + State: types.StateRunning, } annotations := map[string]string{ @@ -122,8 +123,8 @@ func TestKillCLIFunctionSigtermSuccessful(t *testing.T) { func TestKillCLIFunctionNotTerminationSignalSuccessful(t *testing.T) { assert := assert.New(t) - state := vc.State{ - State: vc.StateRunning, + state := types.State{ + State: types.StateRunning, } testingImpl.KillContainerFunc = testKillContainerFuncReturnNil @@ -150,8 +151,8 @@ func TestKillCLIFunctionNotTerminationSignalSuccessful(t *testing.T) { func TestKillCLIFunctionNoSignalSuccessful(t *testing.T) { assert := assert.New(t) - state := vc.State{ - State: vc.StateRunning, + state := types.State{ + State: types.StateRunning, } annotations := map[string]string{ @@ -200,8 +201,8 @@ func TestKillCLIFunctionNoSignalSuccessful(t *testing.T) { func TestKillCLIFunctionEnableAllSuccessful(t *testing.T) { assert := assert.New(t) - state := vc.State{ - State: vc.StateRunning, + state := types.State{ + State: types.StateRunning, } annotations := map[string]string{ @@ -288,8 +289,8 @@ func TestKillCLIFunctionContainerNotExistFailure(t *testing.T) { func TestKillCLIFunctionInvalidSignalFailure(t *testing.T) { assert := assert.New(t) - state := vc.State{ - State: vc.StateRunning, + state := types.State{ + State: types.StateRunning, } testingImpl.KillContainerFunc = testKillContainerFuncReturnNil @@ -316,8 +317,8 @@ func TestKillCLIFunctionInvalidSignalFailure(t *testing.T) { func TestKillCLIFunctionStatePausedSuccessful(t *testing.T) { assert := assert.New(t) - state := vc.State{ - State: vc.StatePaused, + state := types.State{ + State: types.StatePaused, } testingImpl.KillContainerFunc = testKillContainerFuncReturnNil @@ -347,8 +348,8 @@ func TestKillCLIFunctionStatePausedSuccessful(t *testing.T) { func TestKillCLIFunctionInvalidStateStoppedFailure(t *testing.T) { assert := assert.New(t) - state := vc.State{ - State: vc.StateStopped, + state := types.State{ + State: types.StateStopped, } testingImpl.KillContainerFunc = testKillContainerFuncReturnNil @@ -375,8 +376,8 @@ func TestKillCLIFunctionInvalidStateStoppedFailure(t *testing.T) { func TestKillCLIFunctionKillContainerFailure(t *testing.T) { assert := assert.New(t) - state := vc.State{ - State: vc.StateRunning, + state := types.State{ + State: types.StateRunning, } path, err := createTempContainerIDMapping(testContainerID, testSandboxID) @@ -400,8 +401,8 @@ func TestKillCLIFunctionKillContainerFailure(t *testing.T) { func TestKillCLIFunctionInvalidStateStoppedAllSuccess(t *testing.T) { assert := assert.New(t) - state := vc.State{ - State: vc.StateStopped, + state := types.State{ + State: types.StateStopped, } testingImpl.KillContainerFunc = testKillContainerFuncReturnNil diff --git a/cli/main_test.go b/cli/main_test.go index b9843a5c7..f9a65fce8 100644 --- a/cli/main_test.go +++ b/cli/main_test.go @@ -26,6 +26,7 @@ import ( vc "github.com/kata-containers/runtime/virtcontainers" "github.com/kata-containers/runtime/virtcontainers/pkg/oci" "github.com/kata-containers/runtime/virtcontainers/pkg/vcmock" + "github.com/kata-containers/runtime/virtcontainers/types" specs "github.com/opencontainers/runtime-spec/specs-go" "github.com/stretchr/testify/assert" jaeger "github.com/uber/jaeger-client-go" @@ -444,7 +445,7 @@ func writeOCIConfigFile(spec oci.CompatOCISpec, configPath string) error { return ioutil.WriteFile(configPath, bytes, testFileMode) } -func newSingleContainerStatus(containerID string, containerState vc.State, annotations map[string]string) vc.ContainerStatus { +func newSingleContainerStatus(containerID string, containerState types.State, annotations map[string]string) vc.ContainerStatus { return vc.ContainerStatus{ ID: containerID, State: containerState, diff --git a/cli/network.go b/cli/network.go index 75f120290..881a23580 100644 --- a/cli/network.go +++ b/cli/network.go @@ -11,8 +11,8 @@ import ( "fmt" "os" - vc "github.com/kata-containers/runtime/virtcontainers" vcTypes "github.com/kata-containers/runtime/virtcontainers/pkg/types" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -132,7 +132,7 @@ func networkModifyCommand(ctx context.Context, containerID, input string, opType setExternalLoggers(ctx, kataLog) // container MUST be running - if status.State.State != vc.StateRunning { + if status.State.State != types.StateRunning { return fmt.Errorf("container %s is not running", containerID) } @@ -201,7 +201,7 @@ func networkListCommand(ctx context.Context, containerID string, opType networkT setExternalLoggers(ctx, kataLog) // container MUST be running - if status.State.State != vc.StateRunning { + if status.State.State != types.StateRunning { return fmt.Errorf("container %s is not running", containerID) } diff --git a/cli/network_test.go b/cli/network_test.go index befdcd1ae..a4d408d6d 100644 --- a/cli/network_test.go +++ b/cli/network_test.go @@ -14,6 +14,7 @@ import ( vc "github.com/kata-containers/runtime/virtcontainers" vcTypes "github.com/kata-containers/runtime/virtcontainers/pkg/types" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/stretchr/testify/assert" ) @@ -38,8 +39,8 @@ var ( func TestNetworkCliFunction(t *testing.T) { assert := assert.New(t) - state := vc.State{ - State: vc.StateRunning, + state := types.State{ + State: types.StateRunning, } testingImpl.AddInterfaceFunc = testAddInterfaceFuncReturnNil diff --git a/cli/pause_test.go b/cli/pause_test.go index 1ad38537f..2fa1df4be 100644 --- a/cli/pause_test.go +++ b/cli/pause_test.go @@ -13,6 +13,7 @@ import ( "testing" vc "github.com/kata-containers/runtime/virtcontainers" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/stretchr/testify/assert" ) @@ -29,8 +30,8 @@ var ( func TestPauseCLIFunctionSuccessful(t *testing.T) { assert := assert.New(t) - state := vc.State{ - State: vc.StateRunning, + state := types.State{ + State: types.StateRunning, } testingImpl.PauseContainerFunc = testPauseContainerFuncReturnNil @@ -77,8 +78,8 @@ func TestPauseCLIFunctionContainerNotExistFailure(t *testing.T) { func TestPauseCLIFunctionPauseContainerFailure(t *testing.T) { assert := assert.New(t) - state := vc.State{ - State: vc.StateRunning, + state := types.State{ + State: types.StateRunning, } path, err := createTempContainerIDMapping(testContainerID, testSandboxID) @@ -102,8 +103,8 @@ func TestPauseCLIFunctionPauseContainerFailure(t *testing.T) { func TestResumeCLIFunctionSuccessful(t *testing.T) { assert := assert.New(t) - state := vc.State{ - State: vc.StateRunning, + state := types.State{ + State: types.StateRunning, } testingImpl.ResumeContainerFunc = testResumeContainerFuncReturnNil @@ -149,8 +150,8 @@ func TestResumeCLIFunctionContainerNotExistFailure(t *testing.T) { func TestResumeCLIFunctionPauseContainerFailure(t *testing.T) { assert := assert.New(t) - state := vc.State{ - State: vc.StateRunning, + state := types.State{ + State: types.StateRunning, } path, err := createTempContainerIDMapping(testContainerID, testSandboxID) diff --git a/cli/ps.go b/cli/ps.go index 26d335a24..190a72d9d 100644 --- a/cli/ps.go +++ b/cli/ps.go @@ -12,6 +12,8 @@ import ( "github.com/kata-containers/runtime/pkg/katautils" vc "github.com/kata-containers/runtime/virtcontainers" + "github.com/kata-containers/runtime/virtcontainers/types" + "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -80,7 +82,7 @@ func ps(ctx context.Context, containerID, format string, args []string) error { span.SetTag("sandbox", sandboxID) // container MUST be running - if status.State.State != vc.StateRunning { + if status.State.State != types.StateRunning { return fmt.Errorf("Container %s is not running", containerID) } diff --git a/cli/ps_test.go b/cli/ps_test.go index 66e6e7ffa..5a5728533 100644 --- a/cli/ps_test.go +++ b/cli/ps_test.go @@ -14,6 +14,7 @@ import ( vc "github.com/kata-containers/runtime/virtcontainers" vcAnnotations "github.com/kata-containers/runtime/virtcontainers/pkg/annotations" "github.com/kata-containers/runtime/virtcontainers/pkg/vcmock" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/stretchr/testify/assert" "github.com/urfave/cli" ) @@ -95,8 +96,8 @@ func TestPSSuccessful(t *testing.T) { testingImpl.StatusContainerFunc = func(ctx context.Context, sandboxID, containerID string) (vc.ContainerStatus, error) { return vc.ContainerStatus{ - State: vc.State{ - State: vc.StateRunning, + State: types.State{ + State: types.StateRunning, }, ID: sandbox.ID(), Annotations: map[string]string{ diff --git a/cli/update.go b/cli/update.go index 91ec33ae7..4a25fbe9c 100644 --- a/cli/update.go +++ b/cli/update.go @@ -14,7 +14,8 @@ import ( "github.com/docker/go-units" "github.com/kata-containers/runtime/pkg/katautils" - vc "github.com/kata-containers/runtime/virtcontainers" + "github.com/kata-containers/runtime/virtcontainers/types" + "github.com/opencontainers/runtime-spec/specs-go" "github.com/sirupsen/logrus" "github.com/urfave/cli" @@ -164,7 +165,7 @@ other options are ignored. span.SetTag("sandbox", sandboxID) // container MUST be running - if status.State.State != vc.StateRunning { + if status.State.State != types.StateRunning { return fmt.Errorf("Container %s is not running", containerID) } diff --git a/cli/update_test.go b/cli/update_test.go index b08cc769c..c1d7cf3ca 100644 --- a/cli/update_test.go +++ b/cli/update_test.go @@ -15,6 +15,7 @@ import ( vc "github.com/kata-containers/runtime/virtcontainers" vcAnnotations "github.com/kata-containers/runtime/virtcontainers/pkg/annotations" "github.com/kata-containers/runtime/virtcontainers/pkg/vcmock" + "github.com/kata-containers/runtime/virtcontainers/types" specs "github.com/opencontainers/runtime-spec/specs-go" "github.com/stretchr/testify/assert" "github.com/urfave/cli" @@ -94,8 +95,8 @@ func TestUpdateCLIFailure(t *testing.T) { Annotations: map[string]string{ vcAnnotations.ContainerTypeKey: string(vc.PodContainer), }, - State: vc.State{ - State: vc.StateRunning, + State: types.State{ + State: types.StateRunning, }, }, nil } @@ -167,8 +168,8 @@ func TestUpdateCLISuccessful(t *testing.T) { Annotations: map[string]string{ vcAnnotations.ContainerTypeKey: string(vc.PodContainer), }, - State: vc.State{ - State: vc.StateRunning, + State: types.State{ + State: types.StateRunning, }, }, nil } diff --git a/containerd-shim-v2/delete.go b/containerd-shim-v2/delete.go index 7d2fa491b..936133b5c 100644 --- a/containerd-shim-v2/delete.go +++ b/containerd-shim-v2/delete.go @@ -11,7 +11,8 @@ import ( "github.com/containerd/containerd/mount" "github.com/kata-containers/runtime/pkg/katautils" - vc "github.com/kata-containers/runtime/virtcontainers" + "github.com/kata-containers/runtime/virtcontainers/types" + "github.com/sirupsen/logrus" ) @@ -21,7 +22,7 @@ func deleteContainer(ctx context.Context, s *service, c *container) error { if err != nil { return err } - if status.State.State != vc.StateStopped { + if status.State.State != types.StateStopped { _, err = s.sandbox.StopContainer(c.id) if err != nil { return err diff --git a/containerd-shim-v2/exec.go b/containerd-shim-v2/exec.go index d730c2666..1a9146130 100644 --- a/containerd-shim-v2/exec.go +++ b/containerd-shim-v2/exec.go @@ -14,13 +14,13 @@ import ( "github.com/containerd/containerd/api/types/task" "github.com/containerd/containerd/errdefs" googleProtobuf "github.com/gogo/protobuf/types" - vc "github.com/kata-containers/runtime/virtcontainers" + "github.com/kata-containers/runtime/virtcontainers/types" specs "github.com/opencontainers/runtime-spec/specs-go" ) type exec struct { container *container - cmds *vc.Cmd + cmds *types.Cmd tty *tty ttyio *ttyIO id string @@ -44,17 +44,17 @@ type tty struct { terminal bool } -func getEnvs(envs []string) []vc.EnvVar { - var vcEnvs = []vc.EnvVar{} - var env vc.EnvVar +func getEnvs(envs []string) []types.EnvVar { + var vcEnvs = []types.EnvVar{} + var env types.EnvVar for _, v := range envs { pair := strings.SplitN(v, "=", 2) if len(pair) == 2 { - env = vc.EnvVar{Var: pair[0], Value: pair[1]} + env = types.EnvVar{Var: pair[0], Value: pair[1]} } else if len(pair) == 1 { - env = vc.EnvVar{Var: pair[0], Value: ""} + env = types.EnvVar{Var: pair[0], Value: ""} } vcEnvs = append(vcEnvs, env) @@ -91,7 +91,7 @@ func newExec(c *container, stdin, stdout, stderr string, terminal bool, jspec *g terminal: terminal, } - cmds := &vc.Cmd{ + cmds := &types.Cmd{ Args: spec.Args, Envs: getEnvs(spec.Env), User: fmt.Sprintf("%d", spec.User.UID), diff --git a/containerd-shim-v2/pause_test.go b/containerd-shim-v2/pause_test.go index 552e5baa2..212e64e8c 100644 --- a/containerd-shim-v2/pause_test.go +++ b/containerd-shim-v2/pause_test.go @@ -15,6 +15,7 @@ import ( vc "github.com/kata-containers/runtime/virtcontainers" "github.com/kata-containers/runtime/virtcontainers/pkg/vcmock" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/stretchr/testify/assert" ) @@ -38,8 +39,8 @@ func TestPauseContainerSuccess(t *testing.T) { return vc.ContainerStatus{ ID: testContainerID, Annotations: make(map[string]string), - State: vc.State{ - State: vc.StateRunning, + State: types.State{ + State: types.StateRunning, }, }, nil } @@ -86,8 +87,8 @@ func TestPauseContainerFail(t *testing.T) { return vc.ContainerStatus{ ID: testContainerID, Annotations: make(map[string]string), - State: vc.State{ - State: vc.StateRunning, + State: types.State{ + State: types.StateRunning, }, }, nil } @@ -129,8 +130,8 @@ func TestResumeContainerSuccess(t *testing.T) { return vc.ContainerStatus{ ID: testContainerID, Annotations: make(map[string]string), - State: vc.State{ - State: vc.StateRunning, + State: types.State{ + State: types.StateRunning, }, }, nil } @@ -177,8 +178,8 @@ func TestResumeContainerFail(t *testing.T) { return vc.ContainerStatus{ ID: testContainerID, Annotations: make(map[string]string), - State: vc.State{ - State: vc.StateRunning, + State: types.State{ + State: types.StateRunning, }, }, nil } diff --git a/containerd-shim-v2/service.go b/containerd-shim-v2/service.go index 6990a863a..32dcf0cc1 100644 --- a/containerd-shim-v2/service.go +++ b/containerd-shim-v2/service.go @@ -27,6 +27,7 @@ import ( "github.com/kata-containers/runtime/pkg/katautils" vc "github.com/kata-containers/runtime/virtcontainers" "github.com/kata-containers/runtime/virtcontainers/pkg/oci" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/opencontainers/runtime-spec/specs-go" "github.com/containerd/containerd/api/types/task" @@ -782,13 +783,13 @@ func (s *service) getContainerStatus(containerID string) (task.Status, error) { var status task.Status switch cStatus.State.State { - case vc.StateReady: + case types.StateReady: status = task.StatusCreated - case vc.StateRunning: + case types.StateRunning: status = task.StatusRunning - case vc.StatePaused: + case types.StatePaused: status = task.StatusPaused - case vc.StateStopped: + case types.StateStopped: status = task.StatusStopped } diff --git a/virtcontainers/agent.go b/virtcontainers/agent.go index 40a2ee2d9..8774d49ce 100644 --- a/virtcontainers/agent.go +++ b/virtcontainers/agent.go @@ -12,6 +12,7 @@ import ( "github.com/kata-containers/agent/protocols/grpc" vcTypes "github.com/kata-containers/runtime/virtcontainers/pkg/types" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/mitchellh/mapstructure" specs "github.com/opencontainers/runtime-spec/specs-go" "golang.org/x/net/context" @@ -160,7 +161,7 @@ type agent interface { createSandbox(sandbox *Sandbox) error // exec will tell the agent to run a command in an already running container. - exec(sandbox *Sandbox, c Container, cmd Cmd) (*Process, error) + exec(sandbox *Sandbox, c Container, cmd types.Cmd) (*Process, error) // startSandbox will tell the agent to start all containers related to the Sandbox. startSandbox(sandbox *Sandbox) error diff --git a/virtcontainers/api.go b/virtcontainers/api.go index ea10414e7..52caeb1d2 100644 --- a/virtcontainers/api.go +++ b/virtcontainers/api.go @@ -14,6 +14,7 @@ import ( deviceApi "github.com/kata-containers/runtime/virtcontainers/device/api" deviceConfig "github.com/kata-containers/runtime/virtcontainers/device/config" vcTypes "github.com/kata-containers/runtime/virtcontainers/pkg/types" + "github.com/kata-containers/runtime/virtcontainers/types" specs "github.com/opencontainers/runtime-spec/specs-go" opentracing "github.com/opentracing/opentracing-go" "github.com/sirupsen/logrus" @@ -489,7 +490,7 @@ func StopContainer(ctx context.Context, sandboxID, containerID string) (VCContai // EnterContainer is the virtcontainers container command execution entry point. // EnterContainer enters an already running container and runs a given command. -func EnterContainer(ctx context.Context, sandboxID, containerID string, cmd Cmd) (VCSandbox, VCContainer, *Process, error) { +func EnterContainer(ctx context.Context, sandboxID, containerID string, cmd types.Cmd) (VCSandbox, VCContainer, *Process, error) { span, ctx := trace(ctx, "EnterContainer") defer span.Finish() @@ -569,9 +570,9 @@ func statusContainer(sandbox *Sandbox, containerID string) (ContainerStatus, err // We have to check for the process state to make sure // we update the status in case the process is supposed // to be running but has been killed or terminated. - if (container.state.State == StateReady || - container.state.State == StateRunning || - container.state.State == StatePaused) && + if (container.state.State == types.StateReady || + container.state.State == types.StateRunning || + container.state.State == types.StatePaused) && container.process.Pid > 0 { running, err := isShimRunning(container.process.Pid) diff --git a/virtcontainers/api_test.go b/virtcontainers/api_test.go index a5a669ea3..eed59f680 100644 --- a/virtcontainers/api_test.go +++ b/virtcontainers/api_test.go @@ -20,6 +20,7 @@ import ( "github.com/containernetworking/plugins/pkg/ns" "github.com/kata-containers/runtime/virtcontainers/pkg/mock" vcTypes "github.com/kata-containers/runtime/virtcontainers/pkg/types" + "github.com/kata-containers/runtime/virtcontainers/types" specs "github.com/opencontainers/runtime-spec/specs-go" "github.com/stretchr/testify/assert" ) @@ -38,15 +39,15 @@ var containerAnnotations = map[string]string{ "container.hello": "container.world", } -func newBasicTestCmd() Cmd { - envs := []EnvVar{ +func newBasicTestCmd() types.Cmd { + envs := []types.EnvVar{ { Var: "PATH", Value: "/bin:/usr/bin:/sbin:/usr/sbin", }, } - cmd := Cmd{ + cmd := types.Cmd{ Args: strings.Split("/bin/sh", " "), Envs: envs, WorkDir: "/", @@ -581,7 +582,7 @@ func TestPauseThenResumeSandboxNoopAgentSuccessful(t *testing.T) { pImpl, ok := p.(*Sandbox) assert.True(t, ok) - expectedState := StatePaused + expectedState := types.StatePaused assert.Equal(t, pImpl.state.State, expectedState, "unexpected paused sandbox state") @@ -601,7 +602,7 @@ func TestPauseThenResumeSandboxNoopAgentSuccessful(t *testing.T) { pImpl, ok = p.(*Sandbox) assert.True(t, ok) - expectedState = StateRunning + expectedState = types.StateRunning assert.Equal(t, pImpl.state.State, expectedState, "unexpected resumed sandbox state") @@ -868,8 +869,8 @@ func TestStatusSandboxSuccessfulStateReady(t *testing.T) { expectedStatus := SandboxStatus{ ID: testSandboxID, - State: State{ - State: StateReady, + State: types.State{ + State: types.StateReady, }, Hypervisor: MockHypervisor, HypervisorConfig: hypervisorConfig, @@ -878,8 +879,8 @@ func TestStatusSandboxSuccessfulStateReady(t *testing.T) { ContainersStatus: []ContainerStatus{ { ID: containerID, - State: State{ - State: StateReady, + State: types.State{ + State: types.StateReady, }, PID: 0, RootFs: filepath.Join(testDir, testBundle), @@ -926,8 +927,8 @@ func TestStatusSandboxSuccessfulStateRunning(t *testing.T) { expectedStatus := SandboxStatus{ ID: testSandboxID, - State: State{ - State: StateRunning, + State: types.State{ + State: types.StateRunning, }, Hypervisor: MockHypervisor, HypervisorConfig: hypervisorConfig, @@ -936,8 +937,8 @@ func TestStatusSandboxSuccessfulStateRunning(t *testing.T) { ContainersStatus: []ContainerStatus{ { ID: containerID, - State: State{ - State: StateRunning, + State: types.State{ + State: types.StateRunning, }, PID: 0, RootFs: filepath.Join(testDir, testBundle), @@ -1776,8 +1777,8 @@ func TestStatusContainerStateReady(t *testing.T) { expectedStatus := ContainerStatus{ ID: contID, - State: State{ - State: StateReady, + State: types.State{ + State: types.StateReady, }, PID: 0, RootFs: filepath.Join(testDir, testBundle), @@ -1851,8 +1852,8 @@ func TestStatusContainerStateRunning(t *testing.T) { expectedStatus := ContainerStatus{ ID: contID, - State: State{ - State: StateRunning, + State: types.State{ + State: types.StateRunning, }, PID: 0, RootFs: filepath.Join(testDir, testBundle), @@ -2044,14 +2045,14 @@ func createNewSandboxConfig(hType HypervisorType, aType AgentType, aConfig inter func createNewContainerConfigs(numOfContainers int) []ContainerConfig { var contConfigs []ContainerConfig - envs := []EnvVar{ + envs := []types.EnvVar{ { Var: "PATH", Value: "/bin:/usr/bin:/sbin:/usr/sbin", }, } - cmd := Cmd{ + cmd := types.Cmd{ Args: strings.Split("/bin/ps -A", " "), Envs: envs, WorkDir: "/", diff --git a/virtcontainers/container.go b/virtcontainers/container.go index de593134c..545700b77 100644 --- a/virtcontainers/container.go +++ b/virtcontainers/container.go @@ -17,6 +17,7 @@ import ( "time" "github.com/kata-containers/runtime/virtcontainers/pkg/annotations" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/kata-containers/runtime/virtcontainers/utils" specs "github.com/opencontainers/runtime-spec/specs-go" opentracing "github.com/opentracing/opentracing-go" @@ -66,7 +67,7 @@ type Process struct { // ContainerStatus describes a container status. type ContainerStatus struct { ID string - State State + State types.State PID int StartTime time.Time RootFs string @@ -210,7 +211,7 @@ type ContainerConfig struct { ReadonlyRootfs bool // Cmd specifies the command to run on a container - Cmd Cmd + Cmd types.Cmd // Annotations allow clients to store arbitrary values, // for example to add additional status values required @@ -273,7 +274,7 @@ type Container struct { configPath string containerPath string - state State + state types.State process Process @@ -399,7 +400,7 @@ func (c *Container) storeContainer() error { // setContainerState sets both the in-memory and on-disk state of the // container. -func (c *Container) setContainerState(state stateString) error { +func (c *Container) setContainerState(state types.StateString) error { if state == "" { return errNeedState } @@ -614,7 +615,7 @@ func newContainer(sandbox *Sandbox, contConfig ContainerConfig) (*Container, err runPath: filepath.Join(runStoragePath, sandbox.id, contConfig.ID), configPath: filepath.Join(configStoragePath, sandbox.id, contConfig.ID), containerPath: filepath.Join(sandbox.id, contConfig.ID), - state: State{}, + state: types.State{}, process: Process{}, mounts: contConfig.Mounts, ctx: sandbox.ctx, @@ -772,7 +773,7 @@ func (c *Container) create() (err error) { return } - if err = c.setContainerState(StateReady); err != nil { + if err = c.setContainerState(types.StateReady); err != nil { return } @@ -780,8 +781,8 @@ func (c *Container) create() (err error) { } func (c *Container) delete() error { - if c.state.State != StateReady && - c.state.State != StateStopped { + if c.state.State != types.StateReady && + c.state.State != types.StateStopped { return fmt.Errorf("Container not ready or stopped, impossible to delete") } @@ -803,7 +804,7 @@ func (c *Container) checkSandboxRunning(cmd string) error { return fmt.Errorf("Cmd cannot be empty") } - if c.sandbox.state.State != StateRunning { + if c.sandbox.state.State != types.StateRunning { return fmt.Errorf("Sandbox not running, impossible to %s the container", cmd) } @@ -828,12 +829,12 @@ func (c *Container) start() error { return err } - if c.state.State != StateReady && - c.state.State != StateStopped { + if c.state.State != types.StateReady && + c.state.State != types.StateStopped { return fmt.Errorf("Container not ready or stopped, impossible to start") } - if err := c.state.validTransition(c.state.State, StateRunning); err != nil { + if err := c.state.ValidTransition(c.state.State, types.StateRunning); err != nil { return err } @@ -846,7 +847,7 @@ func (c *Container) start() error { return err } - return c.setContainerState(StateRunning) + return c.setContainerState(types.StateRunning) } func (c *Container) stop() error { @@ -860,16 +861,16 @@ func (c *Container) stop() error { // // This has to be handled before the transition validation since this // is an exception. - if c.state.State == StateStopped { + if c.state.State == types.StateStopped { c.Logger().Info("Container already stopped") return nil } - if c.sandbox.state.State != StateReady && c.sandbox.state.State != StateRunning { + if c.sandbox.state.State != types.StateReady && c.sandbox.state.State != types.StateRunning { return fmt.Errorf("Sandbox not ready or running, impossible to stop the container") } - if err := c.state.validTransition(c.state.State, StateStopped); err != nil { + if err := c.state.ValidTransition(c.state.State, types.StateStopped); err != nil { return err } @@ -938,16 +939,16 @@ func (c *Container) stop() error { return err } - return c.setContainerState(StateStopped) + return c.setContainerState(types.StateStopped) } -func (c *Container) enter(cmd Cmd) (*Process, error) { +func (c *Container) enter(cmd types.Cmd) (*Process, error) { if err := c.checkSandboxRunning("enter"); err != nil { return nil, err } - if c.state.State != StateReady && - c.state.State != StateRunning { + if c.state.State != types.StateReady && + c.state.State != types.StateRunning { return nil, fmt.Errorf("Container not ready or running, " + "impossible to enter") } @@ -961,8 +962,8 @@ func (c *Container) enter(cmd Cmd) (*Process, error) { } func (c *Container) wait(processID string) (int32, error) { - if c.state.State != StateReady && - c.state.State != StateRunning { + if c.state.State != types.StateReady && + c.state.State != types.StateRunning { return 0, fmt.Errorf("Container not ready or running, " + "impossible to wait") } @@ -975,11 +976,11 @@ func (c *Container) kill(signal syscall.Signal, all bool) error { } func (c *Container) signalProcess(processID string, signal syscall.Signal, all bool) error { - if c.sandbox.state.State != StateReady && c.sandbox.state.State != StateRunning { + if c.sandbox.state.State != types.StateReady && c.sandbox.state.State != types.StateRunning { return fmt.Errorf("Sandbox not ready or running, impossible to signal the container") } - if c.state.State != StateReady && c.state.State != StateRunning && c.state.State != StatePaused { + if c.state.State != types.StateReady && c.state.State != types.StateRunning && c.state.State != types.StatePaused { return fmt.Errorf("Container not ready, running or paused, impossible to signal the container") } @@ -987,7 +988,7 @@ func (c *Container) signalProcess(processID string, signal syscall.Signal, all b } func (c *Container) winsizeProcess(processID string, height, width uint32) error { - if c.state.State != StateReady && c.state.State != StateRunning { + if c.state.State != types.StateReady && c.state.State != types.StateRunning { return fmt.Errorf("Container not ready or running, impossible to signal the container") } @@ -995,7 +996,7 @@ func (c *Container) winsizeProcess(processID string, height, width uint32) error } func (c *Container) ioStream(processID string) (io.WriteCloser, io.Reader, io.Reader, error) { - if c.state.State != StateReady && c.state.State != StateRunning { + if c.state.State != types.StateReady && c.state.State != types.StateRunning { return nil, nil, nil, fmt.Errorf("Container not ready or running, impossible to signal the container") } @@ -1009,7 +1010,7 @@ func (c *Container) processList(options ProcessListOptions) (ProcessList, error) return nil, err } - if c.state.State != StateRunning { + if c.state.State != types.StateRunning { return nil, fmt.Errorf("Container not running, impossible to list processes") } @@ -1028,7 +1029,7 @@ func (c *Container) update(resources specs.LinuxResources) error { return err } - if c.state.State != StateRunning { + if c.state.State != types.StateRunning { return fmt.Errorf("Container not running, impossible to update") } @@ -1065,7 +1066,7 @@ func (c *Container) pause() error { return err } - if c.state.State != StateRunning && c.state.State != StateReady { + if c.state.State != types.StateRunning && c.state.State != types.StateReady { return fmt.Errorf("Container not running or ready, impossible to pause") } @@ -1073,7 +1074,7 @@ func (c *Container) pause() error { return err } - return c.setContainerState(StatePaused) + return c.setContainerState(types.StatePaused) } func (c *Container) resume() error { @@ -1081,7 +1082,7 @@ func (c *Container) resume() error { return err } - if c.state.State != StatePaused { + if c.state.State != types.StatePaused { return fmt.Errorf("Container not paused, impossible to resume") } @@ -1089,7 +1090,7 @@ func (c *Container) resume() error { return err } - return c.setContainerState(StateRunning) + return c.setContainerState(types.StateRunning) } func (c *Container) hotplugDrive() error { diff --git a/virtcontainers/container_test.go b/virtcontainers/container_test.go index e9bb57bea..1a0bd7a4f 100644 --- a/virtcontainers/container_test.go +++ b/virtcontainers/container_test.go @@ -20,6 +20,7 @@ import ( "github.com/kata-containers/runtime/virtcontainers/device/config" "github.com/kata-containers/runtime/virtcontainers/device/drivers" "github.com/kata-containers/runtime/virtcontainers/device/manager" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/stretchr/testify/assert" ) @@ -289,8 +290,8 @@ func TestCheckSandboxRunningNotRunningFailure(t *testing.T) { func TestCheckSandboxRunningSuccessful(t *testing.T) { c := &Container{ sandbox: &Sandbox{ - state: State{ - State: StateRunning, + state: types.State{ + State: types.StateRunning, }, }, } @@ -302,24 +303,24 @@ func TestContainerEnterErrorsOnContainerStates(t *testing.T) { assert := assert.New(t) c := &Container{ sandbox: &Sandbox{ - state: State{ - State: StateRunning, + state: types.State{ + State: types.StateRunning, }, }, } - cmd := Cmd{} + cmd := types.Cmd{} // Container state undefined _, err := c.enter(cmd) assert.Error(err) // Container paused - c.state.State = StatePaused + c.state.State = types.StatePaused _, err = c.enter(cmd) assert.Error(err) // Container stopped - c.state.State = StateStopped + c.state.State = types.StateStopped _, err = c.enter(cmd) assert.Error(err) } @@ -328,8 +329,8 @@ func TestContainerWaitErrorState(t *testing.T) { assert := assert.New(t) c := &Container{ sandbox: &Sandbox{ - state: State{ - State: StateRunning, + state: types.State{ + State: types.StateRunning, }, }, } @@ -340,12 +341,12 @@ func TestContainerWaitErrorState(t *testing.T) { assert.Error(err) // Container paused - c.state.State = StatePaused + c.state.State = types.StatePaused _, err = c.wait(processID) assert.Error(err) // Container stopped - c.state.State = StateStopped + c.state.State = types.StateStopped _, err = c.wait(processID) assert.Error(err) } @@ -354,8 +355,8 @@ func TestKillContainerErrorState(t *testing.T) { assert := assert.New(t) c := &Container{ sandbox: &Sandbox{ - state: State{ - State: StateRunning, + state: types.State{ + State: types.StateRunning, }, }, } @@ -364,7 +365,7 @@ func TestKillContainerErrorState(t *testing.T) { assert.Error(err) // Container stopped - c.state.State = StateStopped + c.state.State = types.StateStopped err = c.kill(syscall.SIGKILL, true) assert.Error(err) } @@ -373,8 +374,8 @@ func TestWinsizeProcessErrorState(t *testing.T) { assert := assert.New(t) c := &Container{ sandbox: &Sandbox{ - state: State{ - State: StateRunning, + state: types.State{ + State: types.StateRunning, }, }, } @@ -385,12 +386,12 @@ func TestWinsizeProcessErrorState(t *testing.T) { assert.Error(err) // Container paused - c.state.State = StatePaused + c.state.State = types.StatePaused err = c.winsizeProcess(processID, 100, 200) assert.Error(err) // Container stopped - c.state.State = StateStopped + c.state.State = types.StateStopped err = c.winsizeProcess(processID, 100, 200) assert.Error(err) } @@ -399,8 +400,8 @@ func TestProcessIOStream(t *testing.T) { assert := assert.New(t) c := &Container{ sandbox: &Sandbox{ - state: State{ - State: StateRunning, + state: types.State{ + State: types.StateRunning, }, }, } @@ -411,12 +412,12 @@ func TestProcessIOStream(t *testing.T) { assert.Error(err) // Container paused - c.state.State = StatePaused + c.state.State = types.StatePaused _, _, _, err = c.ioStream(processID) assert.Error(err) // Container stopped - c.state.State = StateStopped + c.state.State = types.StateStopped _, _, _, err = c.ioStream(processID) assert.Error(err) } diff --git a/virtcontainers/example_pod_run_test.go b/virtcontainers/example_pod_run_test.go index 85cf7ca26..5b9347907 100644 --- a/virtcontainers/example_pod_run_test.go +++ b/virtcontainers/example_pod_run_test.go @@ -11,6 +11,7 @@ import ( "strings" vc "github.com/kata-containers/runtime/virtcontainers" + "github.com/kata-containers/runtime/virtcontainers/types" ) const containerRootfs = "/var/lib/container/bundle/" @@ -18,14 +19,14 @@ const containerRootfs = "/var/lib/container/bundle/" // This example creates and starts a single container sandbox, // using qemu as the hypervisor and hyperstart as the VM agent. func Example_createAndStartSandbox() { - envs := []vc.EnvVar{ + envs := []types.EnvVar{ { Var: "PATH", Value: "/bin:/usr/bin:/sbin:/usr/sbin", }, } - cmd := vc.Cmd{ + cmd := types.Cmd{ Args: strings.Split("/bin/sh", " "), Envs: envs, WorkDir: "/", diff --git a/virtcontainers/filesystem_resource_storage.go b/virtcontainers/filesystem_resource_storage.go index fa74b5094..1cfb3ee56 100644 --- a/virtcontainers/filesystem_resource_storage.go +++ b/virtcontainers/filesystem_resource_storage.go @@ -19,6 +19,7 @@ import ( "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. @@ -630,7 +631,7 @@ func (fs *filesystem) storeResource(sandboxSpecific bool, sandboxID, containerID case SandboxConfig, ContainerConfig: return fs.storeSandboxAndContainerConfigResource(sandboxSpecific, sandboxID, containerID, resource, file) - case State: + case types.State: return fs.storeStateResource(sandboxSpecific, sandboxID, containerID, resource, file) case NetworkNamespace: @@ -690,11 +691,11 @@ func (fs *filesystem) fetchSandboxConfig(sandboxID string) (SandboxConfig, error return sandboxConfig, nil } -func (fs *filesystem) fetchSandboxState(sandboxID string) (State, error) { - var state State +func (fs *filesystem) fetchSandboxState(sandboxID string) (types.State, error) { + var state types.State if err := fs.fetchResource(true, sandboxID, "", stateFileType, &state); err != nil { - return State{}, err + return types.State{}, err } return state, nil @@ -797,11 +798,11 @@ func (fs *filesystem) fetchContainerConfig(sandboxID, containerID string) (Conta return config, nil } -func (fs *filesystem) fetchContainerState(sandboxID, containerID string) (State, error) { - var state State +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 State{}, err + return types.State{}, err } return state, nil diff --git a/virtcontainers/filesystem_resource_storage_test.go b/virtcontainers/filesystem_resource_storage_test.go index 559550f55..3e51a845b 100644 --- a/virtcontainers/filesystem_resource_storage_test.go +++ b/virtcontainers/filesystem_resource_storage_test.go @@ -15,6 +15,7 @@ import ( "testing" "github.com/kata-containers/runtime/virtcontainers/device/manager" + "github.com/kata-containers/runtime/virtcontainers/types" ) func TestFilesystemCreateAllResourcesSuccessful(t *testing.T) { @@ -520,7 +521,7 @@ func TestFilesystemStoreResourceFailingContainerConfigResourceURI(t *testing.T) func TestFilesystemStoreResourceFailingStateConfigFileType(t *testing.T) { fs := &filesystem{} - data := State{} + data := types.State{} for _, b := range []bool{true, false} { err := fs.storeResource(b, testSandboxID, "100", configFileType, data) @@ -532,7 +533,7 @@ func TestFilesystemStoreResourceFailingStateConfigFileType(t *testing.T) { func TestFilesystemStoreResourceFailingStateResourceURI(t *testing.T) { fs := &filesystem{} - data := State{} + data := types.State{} for _, b := range []bool{true, false} { err := fs.storeResource(b, "", "100", stateFileType, data) diff --git a/virtcontainers/hack/virtc/main.go b/virtcontainers/hack/virtc/main.go index 23362496e..7521d90ab 100644 --- a/virtcontainers/hack/virtc/main.go +++ b/virtcontainers/hack/virtc/main.go @@ -14,6 +14,7 @@ import ( "text/tabwriter" "github.com/kata-containers/runtime/virtcontainers/pkg/uuid" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/sirupsen/logrus" "github.com/urfave/cli" @@ -582,14 +583,14 @@ func createContainer(context *cli.Context) error { interactive = true } - envs := []vc.EnvVar{ + envs := []types.EnvVar{ { Var: "PATH", Value: "/bin:/usr/bin:/sbin:/usr/sbin", }, } - cmd := vc.Cmd{ + cmd := types.Cmd{ Args: strings.Split(context.String("cmd"), " "), Envs: envs, WorkDir: "/", @@ -660,14 +661,14 @@ func enterContainer(context *cli.Context) error { interactive = true } - envs := []vc.EnvVar{ + envs := []types.EnvVar{ { Var: "PATH", Value: "/bin:/usr/bin:/sbin:/usr/sbin", }, } - cmd := vc.Cmd{ + cmd := types.Cmd{ Args: strings.Split(context.String("cmd"), " "), Envs: envs, WorkDir: "/", diff --git a/virtcontainers/hyperstart_agent.go b/virtcontainers/hyperstart_agent.go index 1056478bf..31d774ac5 100644 --- a/virtcontainers/hyperstart_agent.go +++ b/virtcontainers/hyperstart_agent.go @@ -23,6 +23,7 @@ import ( "github.com/kata-containers/runtime/virtcontainers/pkg/hyperstart" ns "github.com/kata-containers/runtime/virtcontainers/pkg/nsenter" vcTypes "github.com/kata-containers/runtime/virtcontainers/pkg/types" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/kata-containers/runtime/virtcontainers/utils" specs "github.com/opencontainers/runtime-spec/specs-go" "golang.org/x/net/context" @@ -58,7 +59,7 @@ func (h *hyper) generateSockets(sandbox *Sandbox, c HyperConfig) { } for i := 0; i < len(sandboxSocketPaths); i++ { - s := Socket{ + s := types.Socket{ DeviceID: fmt.Sprintf(defaultDeviceIDTemplate, i), ID: fmt.Sprintf(defaultIDTemplate, i), HostPath: sandboxSocketPaths[i], @@ -83,7 +84,7 @@ type hyper struct { client *proxyClient.Client state HyperAgentState - sockets []Socket + sockets []types.Socket ctx context.Context } @@ -99,7 +100,7 @@ func (h *hyper) Logger() *logrus.Entry { return virtLog.WithField("subsystem", "hyper") } -func (h *hyper) buildHyperContainerProcess(cmd Cmd) (*hyperstart.Process, error) { +func (h *hyper) buildHyperContainerProcess(cmd types.Cmd) (*hyperstart.Process, error) { var envVars []hyperstart.EnvironmentVar for _, e := range cmd.Envs { @@ -313,7 +314,7 @@ func (h *hyper) configure(hv hypervisor, id, sharePath string, builtin bool, con // Adding the hyper shared volume. // This volume contains all bind mounted container bundles. - sharedVolume := Volume{ + sharedVolume := types.Volume{ MountTag: mountTag, HostPath: sharePath, } @@ -339,7 +340,7 @@ func (h *hyper) capabilities() capabilities { } // exec is the agent command execution implementation for hyperstart. -func (h *hyper) exec(sandbox *Sandbox, c Container, cmd Cmd) (*Process, error) { +func (h *hyper) exec(sandbox *Sandbox, c Container, cmd types.Cmd) (*Process, error) { token, err := h.attach() if err != nil { return nil, err @@ -610,7 +611,7 @@ func (h *hyper) startContainer(sandbox *Sandbox, c *Container) error { // stopContainer is the agent Container stopping implementation for hyperstart. func (h *hyper) stopContainer(sandbox *Sandbox, c Container) error { // Nothing to be done in case the container has not been started. - if c.state.State == StateReady { + if c.state.State == types.StateReady { return nil } @@ -648,7 +649,7 @@ func (h *hyper) stopOneContainer(sandboxID string, c Container) error { func (h *hyper) signalProcess(c *Container, processID string, signal syscall.Signal, all bool) error { // Send the signal to the shim directly in case the container has not // been started yet. - if c.state.State == StateReady { + if c.state.State == types.StateReady { return signalShim(c.process.Pid, signal) } diff --git a/virtcontainers/hyperstart_agent_test.go b/virtcontainers/hyperstart_agent_test.go index 23a3ef0cd..6821601be 100644 --- a/virtcontainers/hyperstart_agent_test.go +++ b/virtcontainers/hyperstart_agent_test.go @@ -13,6 +13,7 @@ import ( "testing" "github.com/kata-containers/runtime/virtcontainers/pkg/hyperstart" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/stretchr/testify/assert" "github.com/vishvananda/netlink" ) @@ -36,7 +37,7 @@ func TestHyperstartGenerateSocketsSuccessful(t *testing.T) { h.generateSockets(sandbox, config) - expectedSockets := []Socket{ + expectedSockets := []types.Socket{ { DeviceID: fmt.Sprintf(defaultDeviceIDTemplate, 0), ID: fmt.Sprintf(defaultIDTemplate, 0), @@ -67,7 +68,7 @@ func TestHyperstartGenerateSocketsSuccessfulNoPathProvided(t *testing.T) { h.generateSockets(sandbox, config) - expectedSockets := []Socket{ + expectedSockets := []types.Socket{ { DeviceID: fmt.Sprintf(defaultDeviceIDTemplate, 0), ID: fmt.Sprintf(defaultIDTemplate, 0), diff --git a/virtcontainers/implementation.go b/virtcontainers/implementation.go index 98d6730e1..865a84271 100644 --- a/virtcontainers/implementation.go +++ b/virtcontainers/implementation.go @@ -16,6 +16,7 @@ import ( "github.com/kata-containers/runtime/virtcontainers/device/api" "github.com/kata-containers/runtime/virtcontainers/device/config" vcTypes "github.com/kata-containers/runtime/virtcontainers/pkg/types" + "github.com/kata-containers/runtime/virtcontainers/types" specs "github.com/opencontainers/runtime-spec/specs-go" "github.com/sirupsen/logrus" ) @@ -107,7 +108,7 @@ func (impl *VCImpl) StopContainer(ctx context.Context, sandboxID, containerID st } // EnterContainer implements the VC function of the same name. -func (impl *VCImpl) EnterContainer(ctx context.Context, sandboxID, containerID string, cmd Cmd) (VCSandbox, VCContainer, *Process, error) { +func (impl *VCImpl) EnterContainer(ctx context.Context, sandboxID, containerID string, cmd types.Cmd) (VCSandbox, VCContainer, *Process, error) { return EnterContainer(ctx, sandboxID, containerID, cmd) } diff --git a/virtcontainers/interfaces.go b/virtcontainers/interfaces.go index cd52c2f2a..d62389d7f 100644 --- a/virtcontainers/interfaces.go +++ b/virtcontainers/interfaces.go @@ -13,6 +13,7 @@ import ( "github.com/kata-containers/runtime/virtcontainers/device/api" "github.com/kata-containers/runtime/virtcontainers/device/config" vcTypes "github.com/kata-containers/runtime/virtcontainers/pkg/types" + "github.com/kata-containers/runtime/virtcontainers/types" specs "github.com/opencontainers/runtime-spec/specs-go" "github.com/sirupsen/logrus" ) @@ -35,7 +36,7 @@ type VC interface { CreateContainer(ctx context.Context, sandboxID string, containerConfig ContainerConfig) (VCSandbox, VCContainer, error) DeleteContainer(ctx context.Context, sandboxID, containerID string) (VCContainer, error) - EnterContainer(ctx context.Context, sandboxID, containerID string, cmd Cmd) (VCSandbox, VCContainer, *Process, error) + EnterContainer(ctx context.Context, sandboxID, containerID string, cmd types.Cmd) (VCSandbox, VCContainer, *Process, error) KillContainer(ctx context.Context, sandboxID, containerID string, signal syscall.Signal, all bool) error StartContainer(ctx context.Context, sandboxID, containerID string) (VCContainer, error) StatusContainer(ctx context.Context, sandboxID, containerID string) (ContainerStatus, error) @@ -83,7 +84,7 @@ type VCSandbox interface { StatsContainer(containerID string) (ContainerStats, error) PauseContainer(containerID string) error ResumeContainer(containerID string) error - EnterContainer(containerID string, cmd Cmd) (VCContainer, *Process, error) + EnterContainer(containerID string, cmd types.Cmd) (VCContainer, *Process, error) UpdateContainer(containerID string, resources specs.LinuxResources) error ProcessListContainer(containerID string, options ProcessListOptions) (ProcessList, error) WaitProcess(containerID, processID string) (int32, error) diff --git a/virtcontainers/kata_agent.go b/virtcontainers/kata_agent.go index 62d8f41cd..64b40a789 100644 --- a/virtcontainers/kata_agent.go +++ b/virtcontainers/kata_agent.go @@ -27,6 +27,7 @@ import ( ns "github.com/kata-containers/runtime/virtcontainers/pkg/nsenter" vcTypes "github.com/kata-containers/runtime/virtcontainers/pkg/types" "github.com/kata-containers/runtime/virtcontainers/pkg/uuid" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/kata-containers/runtime/virtcontainers/utils" opentracing "github.com/opentracing/opentracing-go" @@ -151,7 +152,7 @@ func (k *kataAgent) generateVMSocket(id string, c KataAgentConfig) error { return err } - k.vmSocket = Socket{ + k.vmSocket = types.Socket{ DeviceID: defaultKataDeviceID, ID: defaultKataID, HostPath: kataSock, @@ -201,7 +202,7 @@ func (k *kataAgent) init(ctx context.Context, sandbox *Sandbox, config interface func (k *kataAgent) agentURL() (string, error) { switch s := k.vmSocket.(type) { - case Socket: + case types.Socket: return s.HostPath, nil case kataVSOCK: return s.String(), nil @@ -233,7 +234,7 @@ func (k *kataAgent) configure(h hypervisor, id, sharePath string, builtin bool, } switch s := k.vmSocket.(type) { - case Socket: + case types.Socket: err := h.addDevice(s, serialPortDev) if err != nil { return err @@ -266,7 +267,7 @@ func (k *kataAgent) configure(h hypervisor, id, sharePath string, builtin bool, // Create shared directory and add the shared volume if filesystem sharing is supported. // This volume contains all bind mounted container bundles. - sharedVolume := Volume{ + sharedVolume := types.Volume{ MountTag: mountGuest9pTag, HostPath: sharePath, } @@ -285,7 +286,7 @@ func (k *kataAgent) createSandbox(sandbox *Sandbox) error { return k.configure(sandbox.hypervisor, sandbox.id, k.getSharePath(sandbox.id), k.proxyBuiltIn, nil) } -func cmdToKataProcess(cmd Cmd) (process *grpc.Process, err error) { +func cmdToKataProcess(cmd types.Cmd) (process *grpc.Process, err error) { var i uint64 var extraGids []uint32 @@ -351,7 +352,7 @@ func cmdToKataProcess(cmd Cmd) (process *grpc.Process, err error) { return process, nil } -func cmdEnvsToStringSlice(ev []EnvVar) []string { +func cmdEnvsToStringSlice(ev []types.EnvVar) []string { var env []string for _, e := range ev { @@ -362,7 +363,7 @@ func cmdEnvsToStringSlice(ev []EnvVar) []string { return env } -func (k *kataAgent) exec(sandbox *Sandbox, c Container, cmd Cmd) (*Process, error) { +func (k *kataAgent) exec(sandbox *Sandbox, c Container, cmd types.Cmd) (*Process, error) { span, _ := k.trace("exec") defer span.Finish() diff --git a/virtcontainers/kata_agent_test.go b/virtcontainers/kata_agent_test.go index c3ac47829..5ea995a3a 100644 --- a/virtcontainers/kata_agent_test.go +++ b/virtcontainers/kata_agent_test.go @@ -32,6 +32,7 @@ import ( vcAnnotations "github.com/kata-containers/runtime/virtcontainers/pkg/annotations" "github.com/kata-containers/runtime/virtcontainers/pkg/mock" vcTypes "github.com/kata-containers/runtime/virtcontainers/pkg/types" + "github.com/kata-containers/runtime/virtcontainers/types" ) var ( @@ -637,7 +638,7 @@ func TestAgentPathAPI(t *testing.T) { err = k1.generateVMSocket(id, c) assert.Nil(err) - _, ok := k1.vmSocket.(Socket) + _, ok := k1.vmSocket.(types.Socket) assert.True(ok) c.UseVSock = true @@ -676,9 +677,9 @@ func TestAgentConfigure(t *testing.T) { func TestCmdToKataProcess(t *testing.T) { assert := assert.New(t) - cmd := Cmd{ + cmd := types.Cmd{ Args: strings.Split("foo", " "), - Envs: []EnvVar{}, + Envs: []types.EnvVar{}, WorkDir: "/", User: "1000", PrimaryGroup: "1000", @@ -738,7 +739,7 @@ func TestAgentCreateContainer(t *testing.T) { id: "barfoo", sandboxID: "foobar", sandbox: sandbox, - state: State{ + state: types.State{ Fstype: "xfs", }, config: &ContainerConfig{ diff --git a/virtcontainers/noop_agent.go b/virtcontainers/noop_agent.go index 92bfa2a1a..f0e38bcc9 100644 --- a/virtcontainers/noop_agent.go +++ b/virtcontainers/noop_agent.go @@ -11,6 +11,7 @@ import ( "github.com/kata-containers/agent/protocols/grpc" vcTypes "github.com/kata-containers/runtime/virtcontainers/pkg/types" + "github.com/kata-containers/runtime/virtcontainers/types" specs "github.com/opencontainers/runtime-spec/specs-go" "golang.org/x/net/context" ) @@ -46,7 +47,7 @@ func (n *noopAgent) disconnect() error { } // exec is the Noop agent command execution implementation. It does nothing. -func (n *noopAgent) exec(sandbox *Sandbox, c Container, cmd Cmd) (*Process, error) { +func (n *noopAgent) exec(sandbox *Sandbox, c Container, cmd types.Cmd) (*Process, error) { return nil, nil } diff --git a/virtcontainers/noop_agent_test.go b/virtcontainers/noop_agent_test.go index feae80110..9018c700d 100644 --- a/virtcontainers/noop_agent_test.go +++ b/virtcontainers/noop_agent_test.go @@ -10,6 +10,7 @@ import ( "context" "testing" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/stretchr/testify/assert" ) @@ -45,7 +46,7 @@ func TestNoopAgentInit(t *testing.T) { func TestNoopAgentExec(t *testing.T) { n := &noopAgent{} - cmd := Cmd{} + cmd := types.Cmd{} sandbox, container, err := testCreateNoopContainer() if err != nil { t.Fatal(err) diff --git a/virtcontainers/noop_resource_storage.go b/virtcontainers/noop_resource_storage.go index 2c1b931e0..89db7c7fa 100644 --- a/virtcontainers/noop_resource_storage.go +++ b/virtcontainers/noop_resource_storage.go @@ -7,6 +7,7 @@ package virtcontainers import ( "github.com/kata-containers/runtime/virtcontainers/device/api" + "github.com/kata-containers/runtime/virtcontainers/types" ) type noopResourceStorage struct{} @@ -35,8 +36,8 @@ func (n *noopResourceStorage) fetchSandboxConfig(sandboxID string) (SandboxConfi return SandboxConfig{}, nil } -func (n *noopResourceStorage) fetchSandboxState(sandboxID string) (State, error) { - return State{}, nil +func (n *noopResourceStorage) fetchSandboxState(sandboxID string) (types.State, error) { + return types.State{}, nil } func (n *noopResourceStorage) fetchSandboxNetwork(sandboxID string) (NetworkNamespace, error) { @@ -83,8 +84,8 @@ func (n *noopResourceStorage) fetchContainerConfig(sandboxID, containerID string return ContainerConfig{}, nil } -func (n *noopResourceStorage) fetchContainerState(sandboxID, containerID string) (State, error) { - return State{}, nil +func (n *noopResourceStorage) fetchContainerState(sandboxID, containerID string) (types.State, error) { + return types.State{}, nil } func (n *noopResourceStorage) fetchContainerProcess(sandboxID, containerID string) (Process, error) { diff --git a/virtcontainers/pkg/oci/utils.go b/virtcontainers/pkg/oci/utils.go index 0bd7e4b4a..02d86f7e9 100644 --- a/virtcontainers/pkg/oci/utils.go +++ b/virtcontainers/pkg/oci/utils.go @@ -25,6 +25,7 @@ import ( "github.com/kata-containers/runtime/virtcontainers/device/config" vcAnnotations "github.com/kata-containers/runtime/virtcontainers/pkg/annotations" dockershimAnnotations "github.com/kata-containers/runtime/virtcontainers/pkg/annotations/dockershim" + "github.com/kata-containers/runtime/virtcontainers/types" ) type annotationContainerType struct { @@ -146,7 +147,7 @@ func SetLogger(ctx context.Context, logger *logrus.Entry) { ociLog = logger.WithFields(fields) } -func cmdEnvs(spec CompatOCISpec, envs []vc.EnvVar) []vc.EnvVar { +func cmdEnvs(spec CompatOCISpec, envs []types.EnvVar) []types.EnvVar { for _, env := range spec.Process.Env { kv := strings.Split(env, "=") if len(kv) < 2 { @@ -154,7 +155,7 @@ func cmdEnvs(spec CompatOCISpec, envs []vc.EnvVar) []vc.EnvVar { } envs = append(envs, - vc.EnvVar{ + types.EnvVar{ Var: kv[0], Value: kv[1], }) @@ -248,9 +249,9 @@ func containerDeviceInfos(spec CompatOCISpec) ([]config.DeviceInfo, error) { return devices, nil } -func containerCapabilities(s CompatOCISpec) (vc.LinuxCapabilities, error) { +func containerCapabilities(s CompatOCISpec) (types.LinuxCapabilities, error) { capabilities := s.Process.Capabilities - var c vc.LinuxCapabilities + var c types.LinuxCapabilities // In spec v1.0.0-rc4, capabilities was a list of strings. This was changed // to an object with v1.0.0-rc5. @@ -289,7 +290,7 @@ func containerCapabilities(s CompatOCISpec) (vc.LinuxCapabilities, error) { list = append(list, str.(string)) } - c = vc.LinuxCapabilities{ + c = types.LinuxCapabilities{ Bounding: list, Effective: list, Inheritable: list, @@ -307,9 +308,9 @@ func containerCapabilities(s CompatOCISpec) (vc.LinuxCapabilities, error) { } // ContainerCapabilities return a LinuxCapabilities for virtcontainer -func ContainerCapabilities(s CompatOCISpec) (vc.LinuxCapabilities, error) { +func ContainerCapabilities(s CompatOCISpec) (types.LinuxCapabilities, error) { if s.Process == nil { - return vc.LinuxCapabilities{}, fmt.Errorf("ContainerCapabilities, Process is nil") + return types.LinuxCapabilities{}, fmt.Errorf("ContainerCapabilities, Process is nil") } return containerCapabilities(s) } @@ -516,9 +517,9 @@ func ContainerConfig(ocispec CompatOCISpec, bundlePath, cid, console string, det } ociLog.Debugf("container rootfs: %s", rootfs) - cmd := vc.Cmd{ + cmd := types.Cmd{ Args: ocispec.Process.Args, - Envs: cmdEnvs(ocispec, []vc.EnvVar{}), + Envs: cmdEnvs(ocispec, []types.EnvVar{}), WorkDir: ocispec.Process.Cwd, User: strconv.FormatUint(uint64(ocispec.Process.User.UID), 10), PrimaryGroup: strconv.FormatUint(uint64(ocispec.Process.User.GID), 10), @@ -539,7 +540,7 @@ func ContainerConfig(ocispec CompatOCISpec, bundlePath, cid, console string, det } if ocispec.Process != nil { - caps, ok := ocispec.Process.Capabilities.(vc.LinuxCapabilities) + caps, ok := ocispec.Process.Capabilities.(types.LinuxCapabilities) if !ok { return vc.ContainerConfig{}, fmt.Errorf("Unexpected format for capabilities: %v", ocispec.Process.Capabilities) } @@ -609,15 +610,15 @@ func StatusToOCIState(status vc.ContainerStatus) spec.State { } // StateToOCIState translates a virtcontainers container state into an OCI one. -func StateToOCIState(state vc.State) string { +func StateToOCIState(state types.State) string { switch state.State { - case vc.StateReady: + case types.StateReady: return StateCreated - case vc.StateRunning: + case types.StateRunning: return StateRunning - case vc.StateStopped: + case types.StateStopped: return StateStopped - case vc.StatePaused: + case types.StatePaused: return StatePaused default: return "" @@ -626,8 +627,8 @@ func StateToOCIState(state vc.State) string { // EnvVars converts an OCI process environment variables slice // into a virtcontainers EnvVar slice. -func EnvVars(envs []string) ([]vc.EnvVar, error) { - var envVars []vc.EnvVar +func EnvVars(envs []string) ([]types.EnvVar, error) { + var envVars []types.EnvVar envDelimiter := "=" expectedEnvLen := 2 @@ -636,17 +637,17 @@ func EnvVars(envs []string) ([]vc.EnvVar, error) { envSlice := strings.SplitN(env, envDelimiter, expectedEnvLen) if len(envSlice) < expectedEnvLen { - return []vc.EnvVar{}, fmt.Errorf("Wrong string format: %s, expecting only %v parameters separated with %q", + return []types.EnvVar{}, fmt.Errorf("Wrong string format: %s, expecting only %v parameters separated with %q", env, expectedEnvLen, envDelimiter) } if envSlice[0] == "" { - return []vc.EnvVar{}, fmt.Errorf("Environment variable cannot be empty") + return []types.EnvVar{}, fmt.Errorf("Environment variable cannot be empty") } envSlice[1] = strings.Trim(envSlice[1], "' ") - envVar := vc.EnvVar{ + envVar := types.EnvVar{ Var: envSlice[0], Value: envSlice[1], } diff --git a/virtcontainers/pkg/oci/utils_test.go b/virtcontainers/pkg/oci/utils_test.go index 968fd5c69..db7a33cb0 100644 --- a/virtcontainers/pkg/oci/utils_test.go +++ b/virtcontainers/pkg/oci/utils_test.go @@ -24,6 +24,7 @@ import ( vc "github.com/kata-containers/runtime/virtcontainers" "github.com/kata-containers/runtime/virtcontainers/device/config" vcAnnotations "github.com/kata-containers/runtime/virtcontainers/pkg/annotations" + "github.com/kata-containers/runtime/virtcontainers/types" ) const ( @@ -114,9 +115,9 @@ func TestMinimalSandboxConfig(t *testing.T) { capList := []string{"CAP_AUDIT_WRITE", "CAP_KILL", "CAP_NET_BIND_SERVICE"} - expectedCmd := vc.Cmd{ + expectedCmd := types.Cmd{ Args: []string{"sh"}, - Envs: []vc.EnvVar{ + Envs: []types.EnvVar{ { Var: "PATH", Value: "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", @@ -133,7 +134,7 @@ func TestMinimalSandboxConfig(t *testing.T) { Interactive: true, Console: consolePath, NoNewPrivileges: true, - Capabilities: vc.LinuxCapabilities{ + Capabilities: types.LinuxCapabilities{ Bounding: capList, Effective: capList, Inheritable: capList, @@ -271,8 +272,8 @@ func TestStatusToOCIStateSuccessfulWithReadyState(t *testing.T) { testPID := 12345 testRootFs := "testRootFs" - state := vc.State{ - State: vc.StateReady, + state := types.State{ + State: types.StateReady, } containerAnnotations := map[string]string{ @@ -307,8 +308,8 @@ func TestStatusToOCIStateSuccessfulWithRunningState(t *testing.T) { testPID := 12345 testRootFs := "testRootFs" - state := vc.State{ - State: vc.StateRunning, + state := types.State{ + State: types.StateRunning, } containerAnnotations := map[string]string{ @@ -342,8 +343,8 @@ func TestStatusToOCIStateSuccessfulWithStoppedState(t *testing.T) { testPID := 12345 testRootFs := "testRootFs" - state := vc.State{ - State: vc.StateStopped, + state := types.State{ + State: types.StateStopped, } containerAnnotations := map[string]string{ @@ -403,28 +404,28 @@ func TestStatusToOCIStateSuccessfulWithNoState(t *testing.T) { } func TestStateToOCIState(t *testing.T) { - var state vc.State + var state types.State if ociState := StateToOCIState(state); ociState != "" { t.Fatalf("Expecting \"created\" state, got \"%s\"", ociState) } - state.State = vc.StateReady + state.State = types.StateReady if ociState := StateToOCIState(state); ociState != "created" { t.Fatalf("Expecting \"created\" state, got \"%s\"", ociState) } - state.State = vc.StateRunning + state.State = types.StateRunning if ociState := StateToOCIState(state); ociState != "running" { t.Fatalf("Expecting \"created\" state, got \"%s\"", ociState) } - state.State = vc.StateStopped + state.State = types.StateStopped if ociState := StateToOCIState(state); ociState != "stopped" { t.Fatalf("Expecting \"created\" state, got \"%s\"", ociState) } - state.State = vc.StatePaused + state.State = types.StatePaused if ociState := StateToOCIState(state); ociState != "paused" { t.Fatalf("Expecting \"paused\" state, got \"%s\"", ociState) } @@ -432,7 +433,7 @@ func TestStateToOCIState(t *testing.T) { func TestEnvVars(t *testing.T) { envVars := []string{"foo=bar", "TERM=xterm", "HOME=/home/foo", "TERM=\"bar\"", "foo=\"\""} - expectecVcEnvVars := []vc.EnvVar{ + expectecVcEnvVars := []types.EnvVar{ { Var: "foo", Value: "bar", diff --git a/virtcontainers/pkg/vcmock/mock.go b/virtcontainers/pkg/vcmock/mock.go index 4f908c8d4..b2455850f 100644 --- a/virtcontainers/pkg/vcmock/mock.go +++ b/virtcontainers/pkg/vcmock/mock.go @@ -24,6 +24,7 @@ import ( "github.com/kata-containers/runtime/virtcontainers/device/api" "github.com/kata-containers/runtime/virtcontainers/device/config" vcTypes "github.com/kata-containers/runtime/virtcontainers/pkg/types" + "github.com/kata-containers/runtime/virtcontainers/types" specs "github.com/opencontainers/runtime-spec/specs-go" "github.com/sirupsen/logrus" ) @@ -173,7 +174,7 @@ func (m *VCMock) StopContainer(ctx context.Context, sandboxID, containerID strin } // EnterContainer implements the VC function of the same name. -func (m *VCMock) EnterContainer(ctx context.Context, sandboxID, containerID string, cmd vc.Cmd) (vc.VCSandbox, vc.VCContainer, *vc.Process, error) { +func (m *VCMock) EnterContainer(ctx context.Context, sandboxID, containerID string, cmd types.Cmd) (vc.VCSandbox, vc.VCContainer, *vc.Process, error) { if m.EnterContainerFunc != nil { return m.EnterContainerFunc(ctx, sandboxID, containerID, cmd) } diff --git a/virtcontainers/pkg/vcmock/mock_test.go b/virtcontainers/pkg/vcmock/mock_test.go index e60d0cdd3..d369e6574 100644 --- a/virtcontainers/pkg/vcmock/mock_test.go +++ b/virtcontainers/pkg/vcmock/mock_test.go @@ -14,6 +14,7 @@ import ( vc "github.com/kata-containers/runtime/virtcontainers" "github.com/kata-containers/runtime/virtcontainers/factory" vcTypes "github.com/kata-containers/runtime/virtcontainers/pkg/types" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/sirupsen/logrus" "github.com/stretchr/testify/assert" ) @@ -421,12 +422,12 @@ func TestVCMockEnterContainer(t *testing.T) { assert.Nil(m.EnterContainerFunc) ctx := context.Background() - cmd := vc.Cmd{} + cmd := types.Cmd{} _, _, _, err := m.EnterContainer(ctx, testSandboxID, testContainerID, cmd) assert.Error(err) assert.True(IsMockError(err)) - m.EnterContainerFunc = func(ctx context.Context, sandboxID, containerID string, cmd vc.Cmd) (vc.VCSandbox, vc.VCContainer, *vc.Process, error) { + m.EnterContainerFunc = func(ctx context.Context, sandboxID, containerID string, cmd types.Cmd) (vc.VCSandbox, vc.VCContainer, *vc.Process, error) { return &Sandbox{}, &Container{}, &vc.Process{}, nil } diff --git a/virtcontainers/pkg/vcmock/sandbox.go b/virtcontainers/pkg/vcmock/sandbox.go index 4f01eaac6..2c00d23f8 100644 --- a/virtcontainers/pkg/vcmock/sandbox.go +++ b/virtcontainers/pkg/vcmock/sandbox.go @@ -13,6 +13,7 @@ import ( "github.com/kata-containers/runtime/virtcontainers/device/api" "github.com/kata-containers/runtime/virtcontainers/device/config" vcTypes "github.com/kata-containers/runtime/virtcontainers/pkg/types" + "github.com/kata-containers/runtime/virtcontainers/types" specs "github.com/opencontainers/runtime-spec/specs-go" ) @@ -143,7 +144,7 @@ func (s *Sandbox) Status() vc.SandboxStatus { } // EnterContainer implements the VCSandbox function of the same name. -func (s *Sandbox) EnterContainer(containerID string, cmd vc.Cmd) (vc.VCContainer, *vc.Process, error) { +func (s *Sandbox) EnterContainer(containerID string, cmd types.Cmd) (vc.VCContainer, *vc.Process, error) { return &Container{}, &vc.Process{}, nil } diff --git a/virtcontainers/pkg/vcmock/types.go b/virtcontainers/pkg/vcmock/types.go index 2b89885e4..6f7df5a3d 100644 --- a/virtcontainers/pkg/vcmock/types.go +++ b/virtcontainers/pkg/vcmock/types.go @@ -13,6 +13,7 @@ import ( "github.com/kata-containers/runtime/virtcontainers/device/api" "github.com/kata-containers/runtime/virtcontainers/device/config" vcTypes "github.com/kata-containers/runtime/virtcontainers/pkg/types" + "github.com/kata-containers/runtime/virtcontainers/types" specs "github.com/opencontainers/runtime-spec/specs-go" "github.com/sirupsen/logrus" ) @@ -57,7 +58,7 @@ type VCMock struct { CreateContainerFunc func(ctx context.Context, sandboxID string, containerConfig vc.ContainerConfig) (vc.VCSandbox, vc.VCContainer, error) DeleteContainerFunc func(ctx context.Context, sandboxID, containerID string) (vc.VCContainer, error) - EnterContainerFunc func(ctx context.Context, sandboxID, containerID string, cmd vc.Cmd) (vc.VCSandbox, vc.VCContainer, *vc.Process, error) + EnterContainerFunc func(ctx context.Context, sandboxID, containerID string, cmd types.Cmd) (vc.VCSandbox, vc.VCContainer, *vc.Process, error) KillContainerFunc func(ctx context.Context, sandboxID, containerID string, signal syscall.Signal, all bool) error StartContainerFunc func(ctx context.Context, sandboxID, containerID string) (vc.VCContainer, error) StatusContainerFunc func(ctx context.Context, sandboxID, containerID string) (vc.ContainerStatus, error) diff --git a/virtcontainers/qemu.go b/virtcontainers/qemu.go index 9c79c20b6..60b647689 100644 --- a/virtcontainers/qemu.go +++ b/virtcontainers/qemu.go @@ -22,6 +22,7 @@ import ( "unsafe" "github.com/kata-containers/runtime/virtcontainers/device/config" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/kata-containers/runtime/virtcontainers/utils" "golang.org/x/sys/unix" ) @@ -1207,9 +1208,9 @@ func (q *qemu) addDevice(devInfo interface{}, devType deviceType) error { defer span.Finish() switch v := devInfo.(type) { - case Volume: + case types.Volume: q.qemuConfig.Devices = q.arch.append9PVolume(q.qemuConfig.Devices, v) - case Socket: + case types.Socket: q.qemuConfig.Devices = q.arch.appendSocket(q.qemuConfig.Devices, v) case kataVSOCK: q.fds = append(q.fds, v.vhostFd) diff --git a/virtcontainers/qemu_arch_base.go b/virtcontainers/qemu_arch_base.go index 7c098f7b5..aa852353d 100644 --- a/virtcontainers/qemu_arch_base.go +++ b/virtcontainers/qemu_arch_base.go @@ -14,6 +14,7 @@ import ( govmmQemu "github.com/intel/govmm/qemu" "github.com/kata-containers/runtime/virtcontainers/device/config" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/kata-containers/runtime/virtcontainers/utils" ) @@ -71,10 +72,10 @@ type qemuArch interface { appendBridges(devices []govmmQemu.Device, bridges []Bridge) []govmmQemu.Device // append9PVolume appends a 9P volume to devices - append9PVolume(devices []govmmQemu.Device, volume Volume) []govmmQemu.Device + append9PVolume(devices []govmmQemu.Device, volume types.Volume) []govmmQemu.Device // appendSocket appends a socket to devices - appendSocket(devices []govmmQemu.Device, socket Socket) []govmmQemu.Device + appendSocket(devices []govmmQemu.Device, socket types.Socket) []govmmQemu.Device // appendVSockPCI appends a vsock PCI to devices appendVSockPCI(devices []govmmQemu.Device, vsock kataVSOCK) []govmmQemu.Device @@ -370,7 +371,7 @@ func (q *qemuArchBase) appendBridges(devices []govmmQemu.Device, bridges []Bridg return devices } -func (q *qemuArchBase) append9PVolume(devices []govmmQemu.Device, volume Volume) []govmmQemu.Device { +func (q *qemuArchBase) append9PVolume(devices []govmmQemu.Device, volume types.Volume) []govmmQemu.Device { if volume.MountTag == "" || volume.HostPath == "" { return devices } @@ -395,7 +396,7 @@ func (q *qemuArchBase) append9PVolume(devices []govmmQemu.Device, volume Volume) return devices } -func (q *qemuArchBase) appendSocket(devices []govmmQemu.Device, socket Socket) []govmmQemu.Device { +func (q *qemuArchBase) appendSocket(devices []govmmQemu.Device, socket types.Socket) []govmmQemu.Device { devID := socket.ID if len(devID) > maxDevIDSize { devID = devID[:maxDevIDSize] diff --git a/virtcontainers/qemu_arch_base_test.go b/virtcontainers/qemu_arch_base_test.go index f2c2a8dd3..711d585f4 100644 --- a/virtcontainers/qemu_arch_base_test.go +++ b/virtcontainers/qemu_arch_base_test.go @@ -16,6 +16,7 @@ import ( "github.com/stretchr/testify/assert" "github.com/kata-containers/runtime/virtcontainers/device/config" + "github.com/kata-containers/runtime/virtcontainers/types" ) const ( @@ -204,9 +205,9 @@ func testQemuArchBaseAppend(t *testing.T, structure interface{}, expected []govm qemuArchBase := newQemuArchBase() switch s := structure.(type) { - case Volume: + case types.Volume: devices = qemuArchBase.append9PVolume(devices, s) - case Socket: + case types.Socket: devices = qemuArchBase.appendSocket(devices, s) case config.BlockDrive: devices = qemuArchBase.appendBlockDevice(devices, s) @@ -316,7 +317,7 @@ func TestQemuArchBaseAppend9PVolume(t *testing.T) { }, } - volume := Volume{ + volume := types.Volume{ MountTag: mountTag, HostPath: hostPath, } @@ -341,7 +342,7 @@ func TestQemuArchBaseAppendSocket(t *testing.T) { }, } - socket := Socket{ + socket := types.Socket{ DeviceID: deviceID, ID: id, HostPath: hostPath, diff --git a/virtcontainers/qemu_test.go b/virtcontainers/qemu_test.go index 019f9fe98..3bd09e3cd 100644 --- a/virtcontainers/qemu_test.go +++ b/virtcontainers/qemu_test.go @@ -15,6 +15,7 @@ import ( "testing" govmmQemu "github.com/intel/govmm/qemu" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/stretchr/testify/assert" ) @@ -213,7 +214,7 @@ func TestQemuAddDeviceFsDev(t *testing.T) { }, } - volume := Volume{ + volume := types.Volume{ MountTag: mountTag, HostPath: hostPath, } @@ -238,7 +239,7 @@ func TestQemuAddDeviceSerialPortDev(t *testing.T) { }, } - socket := Socket{ + socket := types.Socket{ DeviceID: deviceID, ID: id, HostPath: hostPath, diff --git a/virtcontainers/resource_storage.go b/virtcontainers/resource_storage.go index 187e4421c..91cbf27a5 100644 --- a/virtcontainers/resource_storage.go +++ b/virtcontainers/resource_storage.go @@ -10,6 +10,7 @@ import ( "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 @@ -39,7 +40,7 @@ type resourceStorage interface { storeSandboxResource(sandboxID string, resource sandboxResource, data interface{}) error deleteSandboxResources(sandboxID string, resources []sandboxResource) error fetchSandboxConfig(sandboxID string) (SandboxConfig, error) - fetchSandboxState(sandboxID string) (State, error) + fetchSandboxState(sandboxID string) (types.State, error) fetchSandboxNetwork(sandboxID string) (NetworkNamespace, error) storeSandboxNetwork(sandboxID string, networkNS NetworkNamespace) error fetchSandboxDevices(sandboxID string) ([]api.Device, error) @@ -57,7 +58,7 @@ type resourceStorage interface { 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) (State, 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) diff --git a/virtcontainers/sandbox.go b/virtcontainers/sandbox.go index 665f382c2..a34203b12 100644 --- a/virtcontainers/sandbox.go +++ b/virtcontainers/sandbox.go @@ -12,7 +12,6 @@ import ( "net" "os" "path/filepath" - "strings" "sync" "syscall" @@ -27,6 +26,7 @@ import ( "github.com/kata-containers/runtime/virtcontainers/device/drivers" deviceManager "github.com/kata-containers/runtime/virtcontainers/device/manager" vcTypes "github.com/kata-containers/runtime/virtcontainers/pkg/types" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/kata-containers/runtime/virtcontainers/utils" "github.com/vishvananda/netlink" ) @@ -37,274 +37,10 @@ const ( vmStartTimeout = 10 ) -// stateString is a string representing a sandbox state. -type stateString string - -const ( - // StateReady represents a sandbox/container that's ready to be run - StateReady stateString = "ready" - - // StateRunning represents a sandbox/container that's currently running. - StateRunning stateString = "running" - - // StatePaused represents a sandbox/container that has been paused. - StatePaused stateString = "paused" - - // StateStopped represents a sandbox/container that has been stopped. - StateStopped stateString = "stopped" -) - -// State is a sandbox state structure. -type State struct { - State stateString `json:"state"` - - BlockDeviceID string - // Index of the block device passed to hypervisor. - BlockIndex int `json:"blockIndex"` - - // File system of the rootfs incase it is block device - Fstype string `json:"fstype"` - - // Pid is the process id of the sandbox container which is the first - // container to be started. - Pid int `json:"pid"` - - // GuestMemoryBlockSizeMB is the size of memory block of guestos - GuestMemoryBlockSizeMB uint32 `json:"guestMemoryBlockSize"` -} - -// valid checks that the sandbox state is valid. -func (state *State) valid() bool { - for _, validState := range []stateString{StateReady, StateRunning, StatePaused, StateStopped} { - if state.State == validState { - return true - } - } - - return false -} - -// validTransition returns an error if we want to move to -// an unreachable state. -func (state *State) validTransition(oldState stateString, newState stateString) error { - if state.State != oldState { - return fmt.Errorf("Invalid state %s (Expecting %s)", state.State, oldState) - } - - switch state.State { - case StateReady: - if newState == StateRunning || newState == StateStopped { - return nil - } - - case StateRunning: - if newState == StatePaused || newState == StateStopped { - return nil - } - - case StatePaused: - if newState == StateRunning || newState == StateStopped { - return nil - } - - case StateStopped: - if newState == StateRunning { - return nil - } - } - - return fmt.Errorf("Can not move from %s to %s", - state.State, newState) -} - -// Volume is a shared volume between the host and the VM, -// defined by its mount tag and its host path. -type Volume struct { - // MountTag is a label used as a hint to the guest. - MountTag string - - // HostPath is the host filesystem path for this volume. - HostPath string -} - -// Volumes is a Volume list. -type Volumes []Volume - -// Set assigns volume values from string to a Volume. -func (v *Volumes) Set(volStr string) error { - if volStr == "" { - return fmt.Errorf("volStr cannot be empty") - } - - volSlice := strings.Split(volStr, " ") - const expectedVolLen = 2 - const volDelimiter = ":" - - for _, vol := range volSlice { - volArgs := strings.Split(vol, volDelimiter) - - if len(volArgs) != expectedVolLen { - return fmt.Errorf("Wrong string format: %s, expecting only %v parameters separated with %q", - vol, expectedVolLen, volDelimiter) - } - - if volArgs[0] == "" || volArgs[1] == "" { - return fmt.Errorf("Volume parameters cannot be empty") - } - - volume := Volume{ - MountTag: volArgs[0], - HostPath: volArgs[1], - } - - *v = append(*v, volume) - } - - return nil -} - -// String converts a Volume to a string. -func (v *Volumes) String() string { - var volSlice []string - - for _, volume := range *v { - volSlice = append(volSlice, fmt.Sprintf("%s:%s", volume.MountTag, volume.HostPath)) - } - - return strings.Join(volSlice, " ") -} - -// Socket defines a socket to communicate between -// the host and any process inside the VM. -type Socket struct { - DeviceID string - ID string - HostPath string - Name string -} - -// Sockets is a Socket list. -type Sockets []Socket - -// Set assigns socket values from string to a Socket. -func (s *Sockets) Set(sockStr string) error { - if sockStr == "" { - return fmt.Errorf("sockStr cannot be empty") - } - - sockSlice := strings.Split(sockStr, " ") - const expectedSockCount = 4 - const sockDelimiter = ":" - - for _, sock := range sockSlice { - sockArgs := strings.Split(sock, sockDelimiter) - - if len(sockArgs) != expectedSockCount { - return fmt.Errorf("Wrong string format: %s, expecting only %v parameters separated with %q", sock, expectedSockCount, sockDelimiter) - } - - for _, a := range sockArgs { - if a == "" { - return fmt.Errorf("Socket parameters cannot be empty") - } - } - - socket := Socket{ - DeviceID: sockArgs[0], - ID: sockArgs[1], - HostPath: sockArgs[2], - Name: sockArgs[3], - } - - *s = append(*s, socket) - } - - return nil -} - -// String converts a Socket to a string. -func (s *Sockets) String() string { - var sockSlice []string - - for _, sock := range *s { - sockSlice = append(sockSlice, fmt.Sprintf("%s:%s:%s:%s", sock.DeviceID, sock.ID, sock.HostPath, sock.Name)) - } - - return strings.Join(sockSlice, " ") -} - -// EnvVar is a key/value structure representing a command -// environment variable. -type EnvVar struct { - Var string - Value string -} - -// LinuxCapabilities specify the capabilities to keep when executing -// the process inside the container. -type LinuxCapabilities struct { - // Bounding is the set of capabilities checked by the kernel. - Bounding []string - // Effective is the set of capabilities checked by the kernel. - Effective []string - // Inheritable is the capabilities preserved across execve. - Inheritable []string - // Permitted is the limiting superset for effective capabilities. - Permitted []string - // Ambient is the ambient set of capabilities that are kept. - Ambient []string -} - -// Cmd represents a command to execute in a running container. -type Cmd struct { - Args []string - Envs []EnvVar - SupplementaryGroups []string - - // Note that these fields *MUST* remain as strings. - // - // The reason being that we want runtimes to be able to support CLI - // operations like "exec --user=". That option allows the - // specification of a user (either as a string username or a numeric - // UID), and may optionally also include a group (groupame or GID). - // - // Since this type is the interface to allow the runtime to specify - // the user and group the workload can run as, these user and group - // fields cannot be encoded as integer values since that would imply - // the runtime itself would need to perform a UID/GID lookup on the - // user-specified username/groupname. But that isn't practically - // possible given that to do so would require the runtime to access - // the image to allow it to interrogate the appropriate databases to - // convert the username/groupnames to UID/GID values. - // - // Note that this argument applies solely to the _runtime_ supporting - // a "--user=" option when running in a "standalone mode" - there is - // no issue when the runtime is called by a container manager since - // all the user and group mapping is handled by the container manager - // and specified to the runtime in terms of UID/GID's in the - // configuration file generated by the container manager. - User string - PrimaryGroup string - WorkDir string - Console string - Capabilities LinuxCapabilities - - Interactive bool - Detach bool - NoNewPrivileges bool -} - -// Resources describes VM resources configuration. -type Resources struct { - // Memory is the amount of available memory in MiB. - Memory uint - MemorySlots uint8 -} - // SandboxStatus describes a sandbox status. type SandboxStatus struct { ID string - State State + State types.State Hypervisor HypervisorType HypervisorConfig HypervisorConfig Agent AgentType @@ -338,7 +74,7 @@ type SandboxConfig struct { NetworkConfig NetworkConfig // Volumes is a list of shared volumes between the host and the Sandbox. - Volumes []Volume + Volumes []types.Volume // Containers describe the list of containers within a Sandbox. // This list can be empty and populated by adding containers @@ -355,7 +91,7 @@ type SandboxConfig struct { // SharePidNs sets all containers to share the same sandbox level pid namespace. SharePidNs bool - // Stateful keeps sandbox resources in memory across APIs. Users will be responsible + // types.Stateful keeps sandbox resources in memory across APIs. Users will be responsible // for calling Release() to release the memory resources. Stateful bool @@ -477,14 +213,14 @@ type Sandbox struct { devManager api.DeviceManager - volumes []Volume + volumes []types.Volume containers map[string]*Container runPath string configPath string - state State + state types.State networkNS NetworkNamespace @@ -625,7 +361,7 @@ func (s *Sandbox) Status() SandboxStatus { // Monitor returns a error channel for watcher to watch at func (s *Sandbox) Monitor() (chan error, error) { - if s.state.State != StateRunning { + if s.state.State != types.StateRunning { return nil, fmt.Errorf("Sandbox is not running") } @@ -640,7 +376,7 @@ func (s *Sandbox) Monitor() (chan error, error) { // WaitProcess waits on a container process and return its exit code func (s *Sandbox) WaitProcess(containerID, processID string) (int32, error) { - if s.state.State != StateRunning { + if s.state.State != types.StateRunning { return 0, fmt.Errorf("Sandbox not running") } @@ -655,7 +391,7 @@ func (s *Sandbox) WaitProcess(containerID, processID string) (int32, error) { // SignalProcess sends a signal to a process of a container when all is false. // When all is true, it sends the signal to all processes of a container. func (s *Sandbox) SignalProcess(containerID, processID string, signal syscall.Signal, all bool) error { - if s.state.State != StateRunning { + if s.state.State != types.StateRunning { return fmt.Errorf("Sandbox not running") } @@ -669,7 +405,7 @@ func (s *Sandbox) SignalProcess(containerID, processID string, signal syscall.Si // WinsizeProcess resizes the tty window of a process func (s *Sandbox) WinsizeProcess(containerID, processID string, height, width uint32) error { - if s.state.State != StateRunning { + if s.state.State != types.StateRunning { return fmt.Errorf("Sandbox not running") } @@ -683,7 +419,7 @@ func (s *Sandbox) WinsizeProcess(containerID, processID string, height, width ui // IOStream returns stdin writer, stdout reader and stderr reader of a process func (s *Sandbox) IOStream(containerID, processID string) (io.WriteCloser, io.Reader, io.Reader, error) { - if s.state.State != StateRunning { + if s.state.State != types.StateRunning { return nil, nil, nil, fmt.Errorf("Sandbox not running") } @@ -795,7 +531,7 @@ func createSandbox(ctx context.Context, sandboxConfig SandboxConfig, factory Fac } // Set sandbox state - if err := s.setSandboxState(StateReady); err != nil { + if err := s.setSandboxState(types.StateReady); err != nil { return nil, err } @@ -831,7 +567,7 @@ func newSandbox(ctx context.Context, sandboxConfig SandboxConfig, factory Factor containers: map[string]*Container{}, runPath: filepath.Join(runStoragePath, sandboxConfig.ID), configPath: filepath.Join(configStoragePath, sandboxConfig.ID), - state: State{}, + state: types.State{}, annotationsLock: &sync.RWMutex{}, wg: &sync.WaitGroup{}, shmSize: sandboxConfig.ShmSize, @@ -984,9 +720,9 @@ func (s *Sandbox) removeContainer(containerID string) error { // Delete deletes an already created sandbox. // The VM in which the sandbox is running will be shut down. func (s *Sandbox) Delete() error { - if s.state.State != StateReady && - s.state.State != StatePaused && - s.state.State != StateStopped { + if s.state.State != types.StateReady && + s.state.State != types.StatePaused && + s.state.State != types.StateStopped { return fmt.Errorf("Sandbox not ready, paused or stopped, impossible to delete") } @@ -1464,7 +1200,7 @@ func (s *Sandbox) StatusContainer(containerID string) (ContainerStatus, error) { // EnterContainer is the virtcontainers container command execution entry point. // EnterContainer enters an already running container and runs a given command. -func (s *Sandbox) EnterContainer(containerID string, cmd Cmd) (VCContainer, *Process, error) { +func (s *Sandbox) EnterContainer(containerID string, cmd types.Cmd) (VCContainer, *Process, error) { // Fetch the container. c, err := s.findContainer(containerID) if err != nil { @@ -1566,11 +1302,11 @@ func (s *Sandbox) createContainers() error { // Start starts a sandbox. The containers that are making the sandbox // will be started. func (s *Sandbox) Start() error { - if err := s.state.validTransition(s.state.State, StateRunning); err != nil { + if err := s.state.ValidTransition(s.state.State, types.StateRunning); err != nil { return err } - if err := s.setSandboxState(StateRunning); err != nil { + if err := s.setSandboxState(types.StateRunning); err != nil { return err } @@ -1591,12 +1327,12 @@ func (s *Sandbox) Stop() error { span, _ := s.trace("stop") defer span.Finish() - if s.state.State == StateStopped { + if s.state.State == types.StateStopped { s.Logger().Info("sandbox already stopped") return nil } - if err := s.state.validTransition(s.state.State, StateStopped); err != nil { + if err := s.state.ValidTransition(s.state.State, types.StateStopped); err != nil { return err } @@ -1610,7 +1346,7 @@ func (s *Sandbox) Stop() error { return err } - if err := s.setSandboxState(StateStopped); err != nil { + if err := s.setSandboxState(types.StateStopped); err != nil { return err } @@ -1656,7 +1392,7 @@ func (s *Sandbox) enter(args []string) error { // setSandboxState sets both the in-memory and on-disk state of the // sandbox. -func (s *Sandbox) setSandboxState(state stateString) error { +func (s *Sandbox) setSandboxState(state types.StateString) error { if state == "" { return errNeedState } @@ -1671,21 +1407,21 @@ func (s *Sandbox) setSandboxState(state stateString) error { func (s *Sandbox) pauseSetStates() error { // XXX: When a sandbox is paused, all its containers are forcibly // paused too. - if err := s.setContainersState(StatePaused); err != nil { + if err := s.setContainersState(types.StatePaused); err != nil { return err } - return s.setSandboxState(StatePaused) + return s.setSandboxState(types.StatePaused) } func (s *Sandbox) resumeSetStates() error { // XXX: Resuming a paused sandbox puts all containers back into the // running state. - if err := s.setContainersState(StateRunning); err != nil { + if err := s.setContainersState(types.StateRunning); err != nil { return err } - return s.setSandboxState(StateRunning) + return s.setSandboxState(types.StateRunning) } // getAndSetSandboxBlockIndex retrieves sandbox block index and increments it for @@ -1729,7 +1465,7 @@ func (s *Sandbox) setSandboxPid(pid int) error { return s.storage.storeSandboxResource(s.id, stateFileType, s.state) } -func (s *Sandbox) setContainersState(state stateString) error { +func (s *Sandbox) setContainersState(state types.StateString) error { if state == "" { return errNeedState } diff --git a/virtcontainers/sandbox_test.go b/virtcontainers/sandbox_test.go index 8503a9a15..125e35422 100644 --- a/virtcontainers/sandbox_test.go +++ b/virtcontainers/sandbox_test.go @@ -24,6 +24,7 @@ import ( "github.com/kata-containers/runtime/virtcontainers/device/drivers" "github.com/kata-containers/runtime/virtcontainers/device/manager" "github.com/kata-containers/runtime/virtcontainers/pkg/annotations" + "github.com/kata-containers/runtime/virtcontainers/types" "golang.org/x/sys/unix" ) @@ -41,7 +42,7 @@ func newHypervisorConfig(kernelParams []Param, hParams []Param) HypervisorConfig func testCreateSandbox(t *testing.T, id string, htype HypervisorType, hconfig HypervisorConfig, atype AgentType, nmodel NetworkModel, nconfig NetworkConfig, containers []ContainerConfig, - volumes []Volume) (*Sandbox, error) { + volumes []types.Volume) (*Sandbox, error) { sconfig := SandboxConfig{ ID: id, @@ -114,7 +115,7 @@ func TestCreateSandboxEmtpyID(t *testing.T) { defer cleanUp() } -func testSandboxStateTransition(t *testing.T, state stateString, newState stateString) error { +func testSandboxStateTransition(t *testing.T, state types.StateString, newState types.StateString) error { hConfig := newHypervisorConfig(nil, nil) p, err := testCreateSandbox(t, testSandboxID, MockHypervisor, hConfig, NoopAgentType, NoopNetworkModel, NetworkConfig{}, nil, nil) @@ -123,57 +124,57 @@ func testSandboxStateTransition(t *testing.T, state stateString, newState stateS } defer cleanUp() - p.state = State{ + p.state = types.State{ State: state, } - return p.state.validTransition(state, newState) + return p.state.ValidTransition(state, newState) } func TestSandboxStateReadyRunning(t *testing.T) { - err := testSandboxStateTransition(t, StateReady, StateRunning) + err := testSandboxStateTransition(t, types.StateReady, types.StateRunning) if err != nil { t.Fatal(err) } } func TestSandboxStateRunningPaused(t *testing.T) { - err := testSandboxStateTransition(t, StateRunning, StatePaused) + err := testSandboxStateTransition(t, types.StateRunning, types.StatePaused) if err != nil { t.Fatal(err) } } func TestSandboxStatePausedRunning(t *testing.T) { - err := testSandboxStateTransition(t, StatePaused, StateRunning) + err := testSandboxStateTransition(t, types.StatePaused, types.StateRunning) if err != nil { t.Fatal(err) } } func TestSandboxStatePausedStopped(t *testing.T) { - err := testSandboxStateTransition(t, StatePaused, StateStopped) + err := testSandboxStateTransition(t, types.StatePaused, types.StateStopped) if err != nil { t.Fatal(err) } } func TestSandboxStateRunningStopped(t *testing.T) { - err := testSandboxStateTransition(t, StateRunning, StateStopped) + err := testSandboxStateTransition(t, types.StateRunning, types.StateStopped) if err != nil { t.Fatal(err) } } func TestSandboxStateReadyPaused(t *testing.T) { - err := testSandboxStateTransition(t, StateReady, StateStopped) + err := testSandboxStateTransition(t, types.StateReady, types.StateStopped) if err != nil { t.Fatal(err) } } func TestSandboxStatePausedReady(t *testing.T) { - err := testSandboxStateTransition(t, StateStopped, StateReady) + err := testSandboxStateTransition(t, types.StateStopped, types.StateReady) if err == nil { t.Fatal("Invalid transition from Ready to Paused") } @@ -265,22 +266,22 @@ func TestSandboxFileNegative(t *testing.T) { } } -func testStateValid(t *testing.T, stateStr stateString, expected bool) { - state := &State{ +func testStateValid(t *testing.T, stateStr types.StateString, expected bool) { + state := &types.State{ State: stateStr, } - ok := state.valid() + ok := state.Valid() if ok != expected { t.Fatal() } } func TestStateValidSuccessful(t *testing.T) { - testStateValid(t, StateReady, true) - testStateValid(t, StateRunning, true) - testStateValid(t, StatePaused, true) - testStateValid(t, StateStopped, true) + testStateValid(t, types.StateReady, true) + testStateValid(t, types.StateRunning, true) + testStateValid(t, types.StatePaused, true) + testStateValid(t, types.StateStopped, true) } func TestStateValidFailing(t *testing.T) { @@ -288,22 +289,22 @@ func TestStateValidFailing(t *testing.T) { } func TestValidTransitionFailingOldStateMismatch(t *testing.T) { - state := &State{ - State: StateReady, + state := &types.State{ + State: types.StateReady, } - err := state.validTransition(StateRunning, StateStopped) + err := state.ValidTransition(types.StateRunning, types.StateStopped) if err == nil { t.Fatal() } } func TestVolumesSetSuccessful(t *testing.T) { - volumes := &Volumes{} + volumes := &types.Volumes{} volStr := "mountTag1:hostPath1 mountTag2:hostPath2" - expected := Volumes{ + expected := types.Volumes{ { MountTag: "mountTag1", HostPath: "hostPath1", @@ -325,7 +326,7 @@ func TestVolumesSetSuccessful(t *testing.T) { } func TestVolumesSetFailingTooFewArguments(t *testing.T) { - volumes := &Volumes{} + volumes := &types.Volumes{} volStr := "mountTag1 mountTag2" @@ -336,7 +337,7 @@ func TestVolumesSetFailingTooFewArguments(t *testing.T) { } func TestVolumesSetFailingTooManyArguments(t *testing.T) { - volumes := &Volumes{} + volumes := &types.Volumes{} volStr := "mountTag1:hostPath1:Foo1 mountTag2:hostPath2:Foo2" @@ -347,7 +348,7 @@ func TestVolumesSetFailingTooManyArguments(t *testing.T) { } func TestVolumesSetFailingVoidArguments(t *testing.T) { - volumes := &Volumes{} + volumes := &types.Volumes{} volStr := ": : :" @@ -358,7 +359,7 @@ func TestVolumesSetFailingVoidArguments(t *testing.T) { } func TestVolumesStringSuccessful(t *testing.T) { - volumes := &Volumes{ + volumes := &types.Volumes{ { MountTag: "mountTag1", HostPath: "hostPath1", @@ -378,11 +379,11 @@ func TestVolumesStringSuccessful(t *testing.T) { } func TestSocketsSetSuccessful(t *testing.T) { - sockets := &Sockets{} + sockets := &types.Sockets{} sockStr := "devID1:id1:hostPath1:Name1 devID2:id2:hostPath2:Name2" - expected := Sockets{ + expected := types.Sockets{ { DeviceID: "devID1", ID: "id1", @@ -408,7 +409,7 @@ func TestSocketsSetSuccessful(t *testing.T) { } func TestSocketsSetFailingWrongArgsAmount(t *testing.T) { - sockets := &Sockets{} + sockets := &types.Sockets{} sockStr := "devID1:id1:hostPath1" @@ -419,7 +420,7 @@ func TestSocketsSetFailingWrongArgsAmount(t *testing.T) { } func TestSocketsSetFailingVoidArguments(t *testing.T) { - sockets := &Sockets{} + sockets := &types.Sockets{} sockStr := ":::" @@ -430,7 +431,7 @@ func TestSocketsSetFailingVoidArguments(t *testing.T) { } func TestSocketsStringSuccessful(t *testing.T) { - sockets := &Sockets{ + sockets := &types.Sockets{ { DeviceID: "devID1", ID: "id1", @@ -471,7 +472,7 @@ func TestSandboxEnterSuccessful(t *testing.T) { } } -func testCheckInitSandboxAndContainerStates(p *Sandbox, initialSandboxState State, c *Container, initialContainerState State) error { +func testCheckInitSandboxAndContainerStates(p *Sandbox, initialSandboxState types.State, c *Container, initialContainerState types.State) error { if p.state.State != initialSandboxState.State { return fmt.Errorf("Expected sandbox state %v, got %v", initialSandboxState.State, p.state.State) } @@ -483,7 +484,7 @@ func testCheckInitSandboxAndContainerStates(p *Sandbox, initialSandboxState Stat return nil } -func testForceSandboxStateChangeAndCheck(t *testing.T, p *Sandbox, newSandboxState State) error { +func testForceSandboxStateChangeAndCheck(t *testing.T, p *Sandbox, newSandboxState types.State) error { // force sandbox state change if err := p.setSandboxState(newSandboxState.State); err != nil { t.Fatalf("Unexpected error: %v (sandbox %+v)", err, p) @@ -497,7 +498,7 @@ func testForceSandboxStateChangeAndCheck(t *testing.T, p *Sandbox, newSandboxSta return nil } -func testForceContainerStateChangeAndCheck(t *testing.T, p *Sandbox, c *Container, newContainerState State) error { +func testForceContainerStateChangeAndCheck(t *testing.T, p *Sandbox, c *Container, newContainerState types.State) error { // force container state change if err := c.setContainerState(newContainerState.State); err != nil { t.Fatalf("Unexpected error: %v (sandbox %+v)", err, p) @@ -511,7 +512,7 @@ func testForceContainerStateChangeAndCheck(t *testing.T, p *Sandbox, c *Containe return nil } -func testCheckSandboxOnDiskState(p *Sandbox, sandboxState State) error { +func testCheckSandboxOnDiskState(p *Sandbox, sandboxState types.State) error { // check on-disk state is correct if p.state.State != sandboxState.State { return fmt.Errorf("Expected state %v, got %v", sandboxState.State, p.state.State) @@ -520,7 +521,7 @@ func testCheckSandboxOnDiskState(p *Sandbox, sandboxState State) error { return nil } -func testCheckContainerOnDiskState(c *Container, containerState State) error { +func testCheckContainerOnDiskState(c *Container, containerState types.State) error { // check on-disk state is correct if c.state.State != containerState.State { return fmt.Errorf("Expected state %v, got %v", containerState.State, c.state.State) @@ -546,13 +547,13 @@ func TestSandboxSetSandboxAndContainerState(t *testing.T) { t.Fatalf("Expected 1 container found %v", l) } - initialSandboxState := State{ - State: StateReady, + initialSandboxState := types.State{ + State: types.StateReady, } // After a sandbox creation, a container has a READY state - initialContainerState := State{ - State: StateReady, + initialContainerState := types.State{ + State: types.StateReady, } c, err := p.findContainer(contID) @@ -571,16 +572,16 @@ func TestSandboxSetSandboxAndContainerState(t *testing.T) { t.Fatal(err) } - newSandboxState := State{ - State: StateRunning, + newSandboxState := types.State{ + State: types.StateRunning, } if err := testForceSandboxStateChangeAndCheck(t, p, newSandboxState); err != nil { t.Error(err) } - newContainerState := State{ - State: StateStopped, + newContainerState := types.State{ + State: types.StateStopped, } if err := testForceContainerStateChangeAndCheck(t, p, c, newContainerState); err != nil { @@ -625,7 +626,7 @@ func TestSandboxSetSandboxStateFailingStoreSandboxResource(t *testing.T) { storage: fs, } - err := sandbox.setSandboxState(StateReady) + err := sandbox.setSandboxState(types.StateReady) if err == nil { t.Fatal() } @@ -645,7 +646,7 @@ func TestSandboxSetContainersStateFailingEmptySandboxID(t *testing.T) { sandbox.containers = containers - err := sandbox.setContainersState(StateReady) + err := sandbox.setContainersState(types.StateReady) if err == nil { t.Fatal() } @@ -970,7 +971,7 @@ func TestContainerSetStateBlockIndex(t *testing.T) { t.Fatal(err) } - state := State{ + state := types.State{ State: "stopped", Fstype: "vfs", } @@ -1011,7 +1012,7 @@ func TestContainerSetStateBlockIndex(t *testing.T) { t.Fatal() } - var res State + var res types.State err = json.Unmarshal([]byte(string(fileData)), &res) if err != nil { t.Fatal(err) @@ -1068,7 +1069,7 @@ func TestContainerStateSetFstype(t *testing.T) { t.Fatal(err) } - state := State{ + state := types.State{ State: "ready", Fstype: "vfs", BlockIndex: 3, @@ -1111,7 +1112,7 @@ func TestContainerStateSetFstype(t *testing.T) { t.Fatal() } - var res State + var res types.State err = json.Unmarshal([]byte(string(fileData)), &res) if err != nil { t.Fatal(err) @@ -1391,7 +1392,7 @@ func TestEnterContainer(t *testing.T) { defer cleanUp() contID := "999" - cmd := Cmd{} + cmd := types.Cmd{} _, _, err = s.EnterContainer(contID, cmd) assert.NotNil(t, err, "Entering non-existing container should fail") @@ -1613,7 +1614,7 @@ func TestAttachBlockDevice(t *testing.T) { err = device.Detach(sandbox) assert.Nil(t, err) - container.state.State = StateReady + container.state.State = types.StateReady err = device.Attach(sandbox) assert.Nil(t, err) @@ -1627,7 +1628,7 @@ func TestAttachBlockDevice(t *testing.T) { err = device.Detach(sandbox) assert.Nil(t, err) - container.state.State = StateReady + container.state.State = types.StateReady err = device.Attach(sandbox) assert.Nil(t, err) @@ -1664,7 +1665,7 @@ func TestPreAddDevice(t *testing.T) { id: contID, sandboxID: testSandboxID, } - container.state.State = StateReady + container.state.State = types.StateReady // create state file path := filepath.Join(runStoragePath, testSandboxID, container.ID()) @@ -1756,7 +1757,7 @@ func TestStartNetworkMonitor(t *testing.T) { } func TestSandboxStopStopped(t *testing.T) { - s := &Sandbox{state: State{State: StateStopped}} + s := &Sandbox{state: types.State{State: types.StateStopped}} err := s.Stop() assert.Nil(t, err) diff --git a/virtcontainers/shim.go b/virtcontainers/shim.go index 8d74c7f62..77ef44b17 100644 --- a/virtcontainers/shim.go +++ b/virtcontainers/shim.go @@ -13,6 +13,7 @@ import ( "time" ns "github.com/kata-containers/runtime/virtcontainers/pkg/nsenter" + "github.com/kata-containers/runtime/virtcontainers/types" "github.com/mitchellh/mapstructure" "github.com/sirupsen/logrus" ) @@ -155,7 +156,7 @@ func stopShim(pid int) error { return nil } -func prepareAndStartShim(sandbox *Sandbox, shim shim, cid, token, url string, cmd Cmd, +func prepareAndStartShim(sandbox *Sandbox, shim shim, cid, token, url string, cmd types.Cmd, createNSList []ns.NSType, enterNSList []ns.Namespace) (*Process, error) { process := &Process{ Token: token, diff --git a/virtcontainers/types/sandbox.go b/virtcontainers/types/sandbox.go index bbd5843d6..5bf986b83 100644 --- a/virtcontainers/types/sandbox.go +++ b/virtcontainers/types/sandbox.go @@ -10,26 +10,26 @@ import ( "strings" ) -// stateString is a string representing a sandbox state. -type stateString string +// StateString is a string representing a sandbox state. +type StateString string const ( // StateReady represents a sandbox/container that's ready to be run - StateReady stateString = "ready" + StateReady StateString = "ready" // StateRunning represents a sandbox/container that's currently running. - StateRunning stateString = "running" + StateRunning StateString = "running" // StatePaused represents a sandbox/container that has been paused. - StatePaused stateString = "paused" + StatePaused StateString = "paused" // StateStopped represents a sandbox/container that has been stopped. - StateStopped stateString = "stopped" + StateStopped StateString = "stopped" ) // State is a sandbox state structure. type State struct { - State stateString `json:"state"` + State StateString `json:"state"` BlockDeviceID string // Index of the block device passed to hypervisor. @@ -46,9 +46,9 @@ type State struct { GuestMemoryBlockSizeMB uint32 `json:"guestMemoryBlockSize"` } -// valid checks that the sandbox state is valid. -func (state *State) valid() bool { - for _, validState := range []stateString{StateReady, StateRunning, StatePaused, StateStopped} { +// Valid checks that the sandbox state is valid. +func (state *State) Valid() bool { + for _, validState := range []StateString{StateReady, StateRunning, StatePaused, StateStopped} { if state.State == validState { return true } @@ -57,9 +57,9 @@ func (state *State) valid() bool { return false } -// validTransition returns an error if we want to move to +// ValidTransition returns an error if we want to move to // an unreachable state. -func (state *State) validTransition(oldState stateString, newState stateString) error { +func (state *State) ValidTransition(oldState StateString, newState StateString) error { if state.State != oldState { return fmt.Errorf("Invalid state %s (Expecting %s)", state.State, oldState) }