Skip to content

K
k3s
Commit aaf26b2e authored by Yu-Ju Hong's avatar Yu-Ju Hong
Browse files
Options

dockershim: remove support for legacy containers

The code was first introduced in 1.6 to help pre-CRI-kubelet upgrade to using the CRI implementation. They can safely be removed now.
parent db809c0e
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 5 additions and 558 deletions
pkg/kubelet/dockershim/BUILD
View file @ aaf26b2e
......@@ -15,7 +15,6 @@ go_library(
"docker_checkpoint.go",
"docker_container.go",
"docker_image.go",
"docker_legacy.go",
"docker_sandbox.go",
"docker_service.go",
"docker_stats.go",
......@@ -69,8 +68,6 @@ go_library(
"//vendor/k8s.io/api/core/v1:go_default_library",
"//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
"//vendor/k8s.io/apimachinery/pkg/util/errors:go_default_library",
"//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
"//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
"//vendor/k8s.io/client-go/tools/remotecommand:go_default_library",
"//vendor/k8s.io/utils/exec:go_default_library",
],
......@@ -84,7 +81,6 @@ go_test(
"docker_checkpoint_test.go",
"docker_container_test.go",
"docker_image_test.go",
"docker_legacy_test.go",
"docker_sandbox_test.go",
"docker_service_test.go",
"helpers_test.go",
......
pkg/kubelet/dockershim/docker_container.go
View file @ aaf26b2e
......@@ -75,15 +75,6 @@ func (ds *dockerService) ListContainers(filter *runtimeapi.ContainerFilter) ([]*
result = append(result, converted)
}
// Include legacy containers if there are still legacy containers not cleaned up yet.
if !ds.legacyCleanup.Done() {
legacyContainers, err := ds.ListLegacyContainers(filter)
if err != nil {
return nil, err
}
// Legacy containers are always older, so we can safely append them to the end.
result = append(result, legacyContainers...)
}
return result, nil
}
......@@ -370,15 +361,6 @@ func (ds *dockerService) ContainerStatus(containerID string) (*runtimeapi.Contai
ct, st, ft := createdAt.UnixNano(), startedAt.UnixNano(), finishedAt.UnixNano()
exitCode := int32(r.State.ExitCode)
// If the container has no containerTypeLabelKey label, treat it as a legacy container.
if _, ok := r.Config.Labels[containerTypeLabelKey]; !ok {
names, labels, err := convertLegacyNameAndLabels([]string{r.Name}, r.Config.Labels)
if err != nil {
return nil, err
}
r.Name, r.Config.Labels = names[0], labels
}
metadata, err := parseContainerName(r.Name)
if err != nil {
return nil, err
......
pkg/kubelet/dockershim/docker_legacy_test.go deleted 100644 → 0
View file @ db809c0e
/*
Copyright 2017 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package dockershim
import (
"testing"
dockercontainer "github.com/docker/docker/api/types/container"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"k8s.io/kubernetes/pkg/kubelet/dockershim/libdocker"
"k8s.io/kubernetes/pkg/kubelet/types"
)
func TestConvertLegacyNameAndLabels(t *testing.T) {
for desc, test := range map[string]struct {
names []string
labels map[string]string
expectNames []string
expectLabels map[string]string
expectError bool
}{
"legacy infra container": {
names: []string{"k8s_POD.hash1_podname_podnamespace_poduid_randomid"},
labels: map[string]string{
types.KubernetesPodNameLabel: "podname",
types.KubernetesPodNamespaceLabel: "podnamespace",
types.KubernetesPodUIDLabel: "poduid",
types.KubernetesContainerNameLabel: "POD",
containerHashLabel: "hash",
containerRestartCountLabel: "0",
},
expectNames: []string{"k8s_POD_podname_podnamespace_poduid_0"},
expectLabels: map[string]string{
types.KubernetesPodNameLabel: "podname",
types.KubernetesPodNamespaceLabel: "podnamespace",
types.KubernetesPodUIDLabel: "poduid",
types.KubernetesContainerNameLabel: "POD",
annotationPrefix + containerHashLabel: "hash",
annotationPrefix + containerRestartCountLabel: "0",
containerTypeLabelKey: containerTypeLabelSandbox,
},
},
"legacy application container": {
names: []string{"k8s_containername.hash_podname_podnamespace_poduid_randomid"},
labels: map[string]string{
types.KubernetesPodNameLabel: "podname",
types.KubernetesPodNamespaceLabel: "podnamespace",
types.KubernetesPodUIDLabel: "poduid",
types.KubernetesContainerNameLabel: "containername",
containerHashLabel: "hash",
containerRestartCountLabel: "5",
containerTerminationMessagePathLabel: "terminationmessagepath",
containerTerminationMessagePolicyLabel: "terminationmessagepolicy",
containerPreStopHandlerLabel: "prestophandler",
containerPortsLabel: "ports",
},
expectNames: []string{"k8s_containername_podname_podnamespace_poduid_5"},
expectLabels: map[string]string{
types.KubernetesPodNameLabel: "podname",
types.KubernetesPodNamespaceLabel: "podnamespace",
types.KubernetesPodUIDLabel: "poduid",
types.KubernetesContainerNameLabel: "containername",
annotationPrefix + containerHashLabel: "hash",
annotationPrefix + containerRestartCountLabel: "5",
annotationPrefix + containerTerminationMessagePathLabel: "terminationmessagepath",
annotationPrefix + containerTerminationMessagePolicyLabel: "terminationmessagepolicy",
annotationPrefix + containerPreStopHandlerLabel: "prestophandler",
annotationPrefix + containerPortsLabel: "ports",
containerTypeLabelKey: containerTypeLabelContainer,
},
expectError: false,
},
"invalid sandbox name": {
names: []string{"POD_podname_podnamespace_poduid_0"},
expectError: true,
},
"invalid dockershim container": {
names: []string{"containername_podname_podnamespace_poduid_5"},
expectError: true,
},
} {
t.Logf("TestCase %q", desc)
names, labels, err := convertLegacyNameAndLabels(test.names, test.labels)
require.Equal(t, test.expectError, err != nil)
assert.Equal(t, test.expectNames, names)
assert.Equal(t, test.expectLabels, labels)
}
}
// getFakeLegacyContainers returns a list of fake legacy containers.
func getFakeLegacyContainers() []*libdocker.FakeContainer {
return []*libdocker.FakeContainer{
{
ID: "12",
Name: "k8s_POD.hash1_podname_podnamespace_poduid_randomid",
Config: &dockercontainer.Config{
Labels: map[string]string{
types.KubernetesPodNameLabel: "podname",
types.KubernetesPodNamespaceLabel: "podnamespace",
types.KubernetesPodUIDLabel: "poduid",
types.KubernetesContainerNameLabel: "POD",
containerHashLabel: "hash1",
containerRestartCountLabel: "0",
},
},
},
{
ID: "34",
Name: "k8s_legacycontainer.hash2_podname_podnamespace_poduid_randomid",
Config: &dockercontainer.Config{
Labels: map[string]string{
types.KubernetesPodNameLabel: "podname",
types.KubernetesPodNamespaceLabel: "podnamespace",
types.KubernetesPodUIDLabel: "poduid",
types.KubernetesContainerNameLabel: "legacyContainer",
containerHashLabel: "hash2",
containerRestartCountLabel: "5",
},
},
},
}
}
// getFakeNewContainers returns a list of fake new containers.
func getFakeNewContainers() []*libdocker.FakeContainer {
return []*libdocker.FakeContainer{
{
ID: "56",
Name: "k8s_POD_podname_podnamespace_poduid_0",
Config: &dockercontainer.Config{
Labels: map[string]string{
types.KubernetesPodNameLabel: "podname",
types.KubernetesPodNamespaceLabel: "podnamespace",
types.KubernetesPodUIDLabel: "poduid",
types.KubernetesContainerNameLabel: "POD",
containerTypeLabelKey: containerTypeLabelSandbox,
},
},
},
{
ID: "78",
Name: "k8s_newcontainer_podname_podnamespace_poduid_3",
Config: &dockercontainer.Config{
Labels: map[string]string{
types.KubernetesPodNameLabel: "podname",
types.KubernetesPodNamespaceLabel: "podnamespace",
types.KubernetesPodUIDLabel: "poduid",
types.KubernetesContainerNameLabel: "newcontainer",
annotationPrefix + containerHashLabel: "hash4",
annotationPrefix + containerRestartCountLabel: "3",
containerTypeLabelKey: containerTypeLabelContainer,
},
},
},
}
}
func TestListLegacyContainers(t *testing.T) {
ds, fDocker, _ := newTestDockerService()
newContainers := getFakeLegacyContainers()
legacyContainers := getFakeNewContainers()
fDocker.SetFakeContainers(append(newContainers, legacyContainers...))
// ListContainers should list only new containers when legacyCleanup is done.
containers, err := ds.ListContainers(nil)
assert.NoError(t, err)
require.Len(t, containers, 1)
assert.Equal(t, "78", containers[0].Id)
// ListLegacyContainers should list only legacy containers.
containers, err = ds.ListLegacyContainers(nil)
assert.NoError(t, err)
require.Len(t, containers, 1)
assert.Equal(t, "34", containers[0].Id)
// Mark legacyCleanup as not done.
ds.legacyCleanup.done = 0
// ListContainers should list all containers when legacyCleanup is not done.
containers, err = ds.ListContainers(nil)
assert.NoError(t, err)
require.Len(t, containers, 2)
assert.Contains(t, []string{containers[0].Id, containers[1].Id}, "34")
assert.Contains(t, []string{containers[0].Id, containers[1].Id}, "78")
}
func TestListLegacyPodSandbox(t *testing.T) {
ds, fDocker, _ := newTestDockerService()
newContainers := getFakeLegacyContainers()
legacyContainers := getFakeNewContainers()
fDocker.SetFakeContainers(append(newContainers, legacyContainers...))
// ListPodSandbox should list only new sandboxes when legacyCleanup is done.
sandboxes, err := ds.ListPodSandbox(nil)
assert.NoError(t, err)
require.Len(t, sandboxes, 1)
assert.Equal(t, "56", sandboxes[0].Id)
// ListLegacyPodSandbox should list only legacy sandboxes.
sandboxes, err = ds.ListLegacyPodSandbox(nil)
assert.NoError(t, err)
require.Len(t, sandboxes, 1)
assert.Equal(t, "12", sandboxes[0].Id)
// Mark legacyCleanup as not done.
ds.legacyCleanup.done = 0
// ListPodSandbox should list all sandboxes when legacyCleanup is not done.
sandboxes, err = ds.ListPodSandbox(nil)
assert.NoError(t, err)
require.Len(t, sandboxes, 2)
assert.Contains(t, []string{sandboxes[0].Id, sandboxes[1].Id}, "12")
assert.Contains(t, []string{sandboxes[0].Id, sandboxes[1].Id}, "56")
}
func TestCheckLegacyCleanup(t *testing.T) {
for desc, test := range map[string]struct {
containers []*libdocker.FakeContainer
done bool
}{
"no containers": {
containers: []*libdocker.FakeContainer{},
done: true,
},
"only new containers": {
containers: getFakeNewContainers(),
done: true,
},
"only legacy containers": {
containers: getFakeLegacyContainers(),
done: false,
},
"both legacy and new containers": {
containers: append(getFakeNewContainers(), getFakeLegacyContainers()...),
done: false,
},
} {
t.Logf("TestCase %q", desc)
ds, fDocker, _ := newTestDockerService()
fDocker.SetFakeContainers(test.containers)
ds.legacyCleanup.done = 0
clean, err := ds.checkLegacyCleanup()
assert.NoError(t, err)
assert.Equal(t, test.done, clean)
assert.Equal(t, test.done, ds.legacyCleanup.Done())
}
}
pkg/kubelet/dockershim/docker_sandbox.go
View file @ aaf26b2e
......@@ -373,17 +373,6 @@ func (ds *dockerService) PodSandboxStatus(podSandboxID string) (*runtimeapi.PodS
}
hostNetwork := sharesHostNetwork(r)
// If the sandbox has no containerTypeLabelKey label, treat it as a legacy sandbox.
if _, ok := r.Config.Labels[containerTypeLabelKey]; !ok {
names, labels, err := convertLegacyNameAndLabels([]string{r.Name}, r.Config.Labels)
if err != nil {
return nil, err
}
r.Name, r.Config.Labels = names[0], labels
// Forcibly trigger infra container restart.
hostNetwork = !hostNetwork
}
metadata, err := parseSandboxName(r.Name)
if err != nil {
return nil, err
......@@ -503,15 +492,6 @@ func (ds *dockerService) ListPodSandbox(filter *runtimeapi.PodSandboxFilter) ([]
result = append(result, checkpointToRuntimeAPISandbox(id, checkpoint))
}
// Include legacy sandboxes if there are still legacy sandboxes not cleaned up yet.
if !ds.legacyCleanup.Done() {
legacySandboxes, err := ds.ListLegacyPodSandbox(filter)
if err != nil {
return nil, err
}
// Legacy sandboxes are always older, so we can safely append them to the end.
result = append(result, legacySandboxes...)
}
return result, nil
}
......
pkg/kubelet/dockershim/docker_service.go
View file @ aaf26b2e
......@@ -258,8 +258,6 @@ type dockerService struct {
// cgroup driver used by Docker runtime.
cgroupDriver string
checkpointHandler CheckpointHandler
// legacyCleanup indicates whether legacy cleanup has finished or not.
legacyCleanup legacyCleanupFlag
// caches the version of the runtime.
// To be compatible with multiple docker versions, we need to perform
// version checking for some operations. Use this cache to avoid querying
......@@ -352,7 +350,6 @@ func (ds *dockerService) GetPodPortMappings(podSandboxID string) ([]*hostport.Po
// Start initializes and starts components in dockerService.
func (ds *dockerService) Start() error {
// Initialize the legacy cleanup flag.
ds.LegacyCleanupInit()
return ds.containerManager.Start()
}
......
pkg/kubelet/dockershim/docker_service_test.go
View file @ aaf26b2e
......@@ -50,7 +50,6 @@ func newTestDockerService() (*dockerService, *libdocker.FakeDockerClient, *clock
client: c,
os: &containertest.FakeOS{},
network: pm,
legacyCleanup: legacyCleanupFlag{done: 1},
checkpointHandler: NewTestPersistentCheckpointHandler(),
networkReady: make(map[string]bool),
}, c, fakeClock
......
pkg/kubelet/dockershim/libdocker/BUILD
View file @ aaf26b2e
......@@ -11,15 +11,11 @@ go_test(
srcs = [
"helpers_test.go",
"kube_docker_client_test.go",
"legacy_test.go",
],
library = ":go_default_library",
deps = [
"//pkg/util/hash:go_default_library",
"//vendor/github.com/docker/docker/api/types:go_default_library",
"//vendor/github.com/stretchr/testify/assert:go_default_library",
"//vendor/k8s.io/api/core/v1:go_default_library",
"//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
],
)
......@@ -31,10 +27,8 @@ go_library(
"helpers.go",
"instrumented_client.go",
"kube_docker_client.go",
"legacy.go",
],
deps = [
"//pkg/kubelet/container:go_default_library",
"//pkg/kubelet/metrics:go_default_library",
"//vendor/github.com/docker/distribution/reference:go_default_library",
"//vendor/github.com/docker/docker/api/types:go_default_library",
......@@ -47,7 +41,6 @@ go_library(
"//vendor/github.com/opencontainers/go-digest:go_default_library",
"//vendor/golang.org/x/net/context:go_default_library",
"//vendor/k8s.io/api/core/v1:go_default_library",
"//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
"//vendor/k8s.io/apimachinery/pkg/util/clock:go_default_library",
],
)
......
pkg/kubelet/dockershim/libdocker/fake_client.go
View file @ aaf26b2e
......@@ -83,6 +83,9 @@ const (
fakeDockerVersion = "1.11.2"
fakeImageSize = 1024
// Docker prepends '/' to the container name.
dockerNamePrefix = "/"
)
func NewFakeDockerClient() *FakeDockerClient {
......@@ -289,11 +292,7 @@ func (f *FakeDockerClient) AssertCallDetails(calls ...calledDetail) (err error)
func (f *FakeDockerClient) idsToNames(ids []string) ([]string, error) {
names := []string{}
for _, id := range ids {
dockerName, _, err := ParseDockerName(f.ContainerMap[id].Name)
if err != nil {
return nil, fmt.Errorf("unexpected error: %v", err)
}
names = append(names, dockerName.ContainerName)
names = append(names, strings.TrimPrefix(f.ContainerMap[id].Name, dockerNamePrefix))
}
return names, nil
}
......@@ -523,8 +522,7 @@ func (f *FakeDockerClient) CreateContainer(c dockertypes.ContainerCreateConfig)
return nil, err
}
// This is not a very good fake. We'll just add this container's name to the list.
// Docker likes to add a '/', so copy that behavior.
name := "/" + c.Name
name := dockerNamePrefix + c.Name
id := GetFakeContainerID(name)
f.appendContainerTrace("Created", id)
timestamp := f.Clock.Now()
......
pkg/kubelet/dockershim/libdocker/legacy.go deleted 100644 → 0
View file @ db809c0e
/*
Copyright 2014 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package libdocker
import (
"fmt"
"math/rand"
"strconv"
"strings"
"github.com/golang/glog"
"k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/types"
kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
)
// This file contains functions used in the non-CRI integration (< 1.6). They
// are currently used for recoginzing containers created by pre-1.6 kubelets.
// TODO: Remove this file for kubernetes 1.8+.
// Creates a name which can be reversed to identify both full pod name and container name.
// This function returns stable name, unique name and a unique id.
// Although rand.Uint32() is not really unique, but it's enough for us because error will
// only occur when instances of the same container in the same pod have the same UID. The
// chance is really slim.
func BuildDockerName(dockerName KubeletContainerName, container *v1.Container) (string, string, string) {
containerName := dockerName.ContainerName + "." + strconv.FormatUint(kubecontainer.HashContainerLegacy(container), 16)
stableName := fmt.Sprintf("%s_%s_%s_%s",
containerNamePrefix,
containerName,
dockerName.PodFullName,
dockerName.PodUID)
UID := fmt.Sprintf("%08x", rand.Uint32())
return stableName, fmt.Sprintf("%s_%s", stableName, UID), UID
}
// Unpacks a container name, returning the pod full name and container name we would have used to
// construct the docker name. If we are unable to parse the name, an error is returned.
func ParseDockerName(name string) (dockerName *KubeletContainerName, hash uint64, err error) {
// For some reason docker appears to be appending '/' to names.
// If it's there, strip it.
name = strings.TrimPrefix(name, "/")
parts := strings.Split(name, "_")
if len(parts) == 0 || parts[0] != containerNamePrefix {
err = fmt.Errorf("failed to parse Docker container name %q into parts", name)
return nil, 0, err
}
if len(parts) < 6 {
// We have at least 5 fields. We may have more in the future.
// Anything with less fields than this is not something we can
// manage.
glog.Warningf("found a container with the %q prefix, but too few fields (%d): %q", containerNamePrefix, len(parts), name)
err = fmt.Errorf("Docker container name %q has less parts than expected %v", name, parts)
return nil, 0, err
}
nameParts := strings.Split(parts[1], ".")
containerName := nameParts[0]
if len(nameParts) > 1 {
hash, err = strconv.ParseUint(nameParts[1], 16, 32)
if err != nil {
glog.Warningf("invalid container hash %q in container %q", nameParts[1], name)
}
}
podFullName := parts[2] + "_" + parts[3]
podUID := types.UID(parts[4])
return &KubeletContainerName{podFullName, podUID, containerName}, hash, nil
}
// KubeletContainerName encapsulates a pod name and a Kubernetes container name.
type KubeletContainerName struct {
PodFullName string
PodUID types.UID
ContainerName string
}
pkg/kubelet/dockershim/libdocker/legacy_test.go deleted 100644 → 0
View file @ db809c0e
/*
Copyright 2014 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package libdocker
import (
"fmt"
"hash/adler32"
"testing"
dockertypes "github.com/docker/docker/api/types"
"github.com/stretchr/testify/assert"
"k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/types"
hashutil "k8s.io/kubernetes/pkg/util/hash"
)
func verifyCalls(t *testing.T, fakeDocker *FakeDockerClient, calls []string) {
assert.New(t).NoError(fakeDocker.AssertCalls(calls))
}
func verifyStringArrayEquals(t *testing.T, actual, expected []string) {
invalid := len(actual) != len(expected)
if !invalid {
for ix, value := range actual {
if expected[ix] != value {
invalid = true
}
}
}
if invalid {
t.Errorf("Expected: %#v, Actual: %#v", expected, actual)
}
}
func findPodContainer(dockerContainers []*dockertypes.Container, podFullName string, uid types.UID, containerName string) (*dockertypes.Container, bool, uint64) {
for _, dockerContainer := range dockerContainers {
if len(dockerContainer.Names) == 0 {
continue
}
dockerName, hash, err := ParseDockerName(dockerContainer.Names[0])
if err != nil {
continue
}
if dockerName.PodFullName == podFullName &&
(uid == "" || dockerName.PodUID == uid) &&
dockerName.ContainerName == containerName {
return dockerContainer, true, hash
}
}
return nil, false, 0
}
func TestGetContainerID(t *testing.T) {
fakeDocker := NewFakeDockerClient()
fakeDocker.SetFakeRunningContainers([]*FakeContainer{
{
ID: "foobar",
Name: "/k8s_foo_qux_ns_1234_42",
},
{
ID: "barbar",
Name: "/k8s_bar_qux_ns_2565_42",
},
})
dockerContainers, err := GetKubeletDockerContainers(fakeDocker, false)
if err != nil {
t.Errorf("Expected no error, Got %#v", err)
}
if len(dockerContainers) != 2 {
t.Errorf("Expected %#v, Got %#v", fakeDocker.RunningContainerList, dockerContainers)
}
verifyCalls(t, fakeDocker, []string{"list"})
dockerContainer, found, _ := findPodContainer(dockerContainers, "qux_ns", "", "foo")
if dockerContainer == nil || !found {
t.Errorf("Failed to find container %#v", dockerContainer)
}
fakeDocker.ClearCalls()
dockerContainer, found, _ = findPodContainer(dockerContainers, "foobar", "", "foo")
verifyCalls(t, fakeDocker, []string{})
if dockerContainer != nil || found {
t.Errorf("Should not have found container %#v", dockerContainer)
}
}
func verifyPackUnpack(t *testing.T, podNamespace, podUID, podName, containerName string) {
container := &v1.Container{Name: containerName}
hasher := adler32.New()
hashutil.DeepHashObject(hasher, *container)
computedHash := uint64(hasher.Sum32())
podFullName := fmt.Sprintf("%s_%s", podName, podNamespace)
_, name, _ := BuildDockerName(KubeletContainerName{podFullName, types.UID(podUID), container.Name}, container)
returned, hash, err := ParseDockerName(name)
if err != nil {
t.Errorf("Failed to parse Docker container name %q: %v", name, err)
}
if podFullName != returned.PodFullName || podUID != string(returned.PodUID) || containerName != returned.ContainerName || computedHash != hash {
t.Errorf("For (%s, %s, %s, %d), unpacked (%s, %s, %s, %d)", podFullName, podUID, containerName, computedHash, returned.PodFullName, returned.PodUID, returned.ContainerName, hash)
}
}
func TestContainerNaming(t *testing.T) {
podUID := "12345678"
verifyPackUnpack(t, "file", podUID, "name", "container")
verifyPackUnpack(t, "file", podUID, "name-with-dashes", "container")
// UID is same as pod name
verifyPackUnpack(t, "file", podUID, podUID, "container")
// No Container name
verifyPackUnpack(t, "other", podUID, "name", "")
container := &v1.Container{Name: "container"}
podName := "foo"
podNamespace := "test"
name := fmt.Sprintf("k8s_%s_%s_%s_%s_42", container.Name, podName, podNamespace, podUID)
podFullName := fmt.Sprintf("%s_%s", podName, podNamespace)
returned, hash, err := ParseDockerName(name)
if err != nil {
t.Errorf("Failed to parse Docker container name %q: %v", name, err)
}
if returned.PodFullName != podFullName || string(returned.PodUID) != podUID || returned.ContainerName != container.Name || hash != 0 {
t.Errorf("unexpected parse: %s %s %s %d", returned.PodFullName, returned.PodUID, returned.ContainerName, hash)
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment