From 0fd2385e0bd8f639d59e1bd7992f415d6192a794 Mon Sep 17 00:00:00 2001 From: Yu-Ju Hong Date: Wed, 24 Aug 2016 14:12:23 -0700 Subject: [PATCH] Add "Sandboxes" to the kubecontainer.Pod This field will only be used by the kuberuntime package and should be ignored by other type of runtimes. --- pkg/kubelet/container/runtime.go | 5 ++++ pkg/kubelet/kuberuntime/helpers.go | 30 +++++++++++++++++++ .../kuberuntime/kuberuntime_manager.go | 17 ++++++++--- .../kuberuntime/kuberuntime_manager_test.go | 15 +++++++++- 4 files changed, 62 insertions(+), 5 deletions(-) diff --git a/pkg/kubelet/container/runtime.go b/pkg/kubelet/container/runtime.go index 1c86fa14b46..98d58b3aac4 100644 --- a/pkg/kubelet/container/runtime.go +++ b/pkg/kubelet/container/runtime.go @@ -153,6 +153,11 @@ type Pod struct { // List of containers that belongs to this pod. It may contain only // running containers, or mixed with dead ones (when GetPods(true)). Containers []*Container + // List of sandboxes associated with this pod. The sandboxes are converted + // to Container temporariliy to avoid substantial changes to other + // components. This is only populated by kuberuntime. + // TODO: use the runtimeApi.PodSandbox type directly. + Sandboxes []*Container } // PodPair contains both runtime#Pod and api#Pod diff --git a/pkg/kubelet/kuberuntime/helpers.go b/pkg/kubelet/kuberuntime/helpers.go index 7cc24dedc74..d0838573b99 100644 --- a/pkg/kubelet/kuberuntime/helpers.go +++ b/pkg/kubelet/kuberuntime/helpers.go @@ -64,6 +64,21 @@ func toKubeContainerState(state runtimeApi.ContainerState) kubecontainer.Contain return kubecontainer.ContainerStateUnknown } +// sandboxToKubeContainerState converts runtimeApi.PodSandboxState to +// kubecontainer.ContainerState. +// This is only needed because we need to return sandboxes as if they were +// kubecontainer.Containers to avoid substantial changes to PLEG. +// TODO: Remove this once it becomes obsolete. +func sandboxToKubeContainerState(state runtimeApi.PodSandBoxState) kubecontainer.ContainerState { + switch state { + case runtimeApi.PodSandBoxState_READY: + return kubecontainer.ContainerStateRunning + case runtimeApi.PodSandBoxState_NOTREADY: + return kubecontainer.ContainerStateExited + } + return kubecontainer.ContainerStateUnknown +} + // toRuntimeProtocol converts api.Protocol to runtimeApi.Protocol. func toRuntimeProtocol(protocol api.Protocol) runtimeApi.Protocol { switch protocol { @@ -94,6 +109,21 @@ func (m *kubeGenericRuntimeManager) toKubeContainer(c *runtimeApi.Container) (*k }, nil } +// sandboxToKubeContainer converts runtimeApi.PodSandbox to kubecontainer.Container. +// This is only needed because we need to return sandboxes as if they were +// kubecontainer.Containers to avoid substantial changes to PLEG. +// TODO: Remove this once it becomes obsolete. +func (m *kubeGenericRuntimeManager) sandboxToKubeContainer(s *runtimeApi.PodSandbox) (*kubecontainer.Container, error) { + if s == nil || s.Id == nil || s.State == nil { + return nil, fmt.Errorf("unable to convert a nil pointer to a runtime container") + } + + return &kubecontainer.Container{ + ID: kubecontainer.ContainerID{Type: m.runtimeName, ID: s.GetId()}, + State: sandboxToKubeContainerState(s.GetState()), + }, nil +} + // milliCPUToShares converts milliCPU to CPU shares func milliCPUToShares(milliCPU int64) int64 { if milliCPU == 0 { diff --git a/pkg/kubelet/kuberuntime/kuberuntime_manager.go b/pkg/kubelet/kuberuntime/kuberuntime_manager.go index 77d83b90f07..ca5d322cb3f 100644 --- a/pkg/kubelet/kuberuntime/kuberuntime_manager.go +++ b/pkg/kubelet/kuberuntime/kuberuntime_manager.go @@ -231,11 +231,20 @@ func (m *kubeGenericRuntimeManager) GetPods(all bool) ([]*kubecontainer.Pod, err } for _, s := range sandboxes { podUID := kubetypes.UID(s.Metadata.GetUid()) - pods[podUID] = &kubecontainer.Pod{ - ID: podUID, - Name: s.Metadata.GetName(), - Namespace: s.Metadata.GetNamespace(), + if _, ok := pods[podUID]; !ok { + pods[podUID] = &kubecontainer.Pod{ + ID: podUID, + Name: s.Metadata.GetName(), + Namespace: s.Metadata.GetNamespace(), + } } + p := pods[podUID] + converted, err := m.sandboxToKubeContainer(s) + if err != nil { + glog.Warningf("Convert %q sandbox %v of pod %q failed: %v", m.runtimeName, s, podUID, err) + continue + } + p.Sandboxes = append(p.Sandboxes, converted) } containers, err := m.getKubeletContainers(all) diff --git a/pkg/kubelet/kuberuntime/kuberuntime_manager_test.go b/pkg/kubelet/kuberuntime/kuberuntime_manager_test.go index 0f63d6eb6de..dae589df529 100644 --- a/pkg/kubelet/kuberuntime/kuberuntime_manager_test.go +++ b/pkg/kubelet/kuberuntime/kuberuntime_manager_test.go @@ -200,7 +200,7 @@ func TestGetPods(t *testing.T) { } // Set fake sandbox and fake containers to fakeRuntime. - _, fakeContainers, err := makeAndSetFakePod(m, fakeRuntime, pod) + fakeSandbox, fakeContainers, err := makeAndSetFakePod(m, fakeRuntime, pod) assert.NoError(t, err) // Convert the fakeContainers to kubecontainer.Container @@ -220,12 +220,25 @@ func TestGetPods(t *testing.T) { } containers[i] = c } + // Convert fakeSandbox to kubecontainer.Container + sandbox, err := m.sandboxToKubeContainer(&runtimeApi.PodSandbox{ + Id: fakeSandbox.Id, + Metadata: fakeSandbox.Metadata, + State: fakeSandbox.State, + CreatedAt: fakeSandbox.CreatedAt, + Labels: fakeSandbox.Labels, + }) + if err != nil { + t.Fatalf("unexpected error %v", err) + } + expected := []*kubecontainer.Pod{ { ID: kubetypes.UID("12345678"), Name: "foo", Namespace: "new", Containers: []*kubecontainer.Container{containers[0], containers[1]}, + Sandboxes: []*kubecontainer.Container{sandbox}, }, }