jiebi/CodeConvo huggingface dataset:
syncFn func(key string) error queue workqueue.RateLimitingInterface <ins> // last generation this controller updated the condition per CRD name (to avoid two // different version of the apiextensions-apiservers in HA to fight for the right message) lastSeenGenerationLock sync.Mutex lastSeenGeneration     map[string]int64 </ins> } // NewConditionController constructs a non-structural schema condition controller.
crdClient client.CustomResourceDefinitionsGetter, ) *ConditionController { c := &ConditionController{ <del> crdClient: crdClient, crdLister: crdInformer.Lister(), crdSynced: crdInformer.Informer().HasSynced, queue:     workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "non_structural_schema_condition_controller"), </del> <ins> crdClient:          crdClient, crdLister:          crdInformer.Lister(), crdSynced:          crdInformer.Informer().HasSynced, queue:              workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "non_structural_schema_condition_controller"), lastSeenGeneration: map[string]int64{}, </ins> } crdInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{ AddFunc:    c.addCustomResourceDefinition, UpdateFunc: c.updateCustomResourceDefinition, <del> DeleteFunc: nil, </del> <ins> DeleteFunc: c.deleteCustomResourceDefinition, </ins> }) c.syncFn = c.sync
return err } <ins> // avoid repeated calculation for the same generation c.lastSeenGenerationLock.Lock() lastSeen, seenBefore := c.lastSeenGeneration[inCustomResourceDefinition.Name] c.lastSeenGenerationLock.Unlock() if seenBefore && inCustomResourceDefinition.Generation <= lastSeen { return nil } </ins> // check old condition cond := calculateCondition(inCustomResourceDefinition) old := apiextensions.FindCRDCondition(inCustomResourceDefinition, apiextensions.NonStructuralSchema)
klog.V(4).Infof("Updating %s", castObj.Name) c.enqueue(castObj) } <ins> func (c *ConditionController) deleteCustomResourceDefinition(obj interface{}) { castObj, ok := obj.(*apiextensions.CustomResourceDefinition) if !ok { tombstone, ok := obj.(cache.DeletedFinalStateUnknown) if !ok { klog.Errorf("Couldn't get object from tombstone %#v", obj) return } castObj, ok = tombstone.Obj.(*apiextensions.CustomResourceDefinition) if !ok { klog.Errorf("Tombstone contained object that is not expected %#v", obj) return } } c.lastSeenGenerationLock.Lock() defer c.lastSeenGenerationLock.Unlock() delete(c.lastSeenGeneration, castObj.Name) } </ins>
"//test/e2e/framework/providers/vsphere:go_default_library", "//test/e2e/framework/testfiles:go_default_library", "//test/e2e/manifest:go_default_library", <ins> "//test/e2e/reporters:go_default_library", </ins> "//test/utils:go_default_library", "//vendor/github.com/onsi/ginkgo:go_default_library", "//vendor/github.com/onsi/ginkgo/config:go_default_library",
"//test/e2e/network:all-srcs", "//test/e2e/node:all-srcs", "//test/e2e/perftype:all-srcs", <ins> "//test/e2e/reporters:all-srcs", </ins> "//test/e2e/scheduling:all-srcs", "//test/e2e/servicecatalog:all-srcs", "//test/e2e/storage:all-srcs",
e2enode "k8s.io/kubernetes/test/e2e/framework/node" e2epod "k8s.io/kubernetes/test/e2e/framework/pod" "k8s.io/kubernetes/test/e2e/manifest" <ins> e2ereporters "k8s.io/kubernetes/test/e2e/reporters" </ins> testutils "k8s.io/kubernetes/test/utils" utilnet "k8s.io/utils/net"
r = append(r, reporters.NewJUnitReporter(path.Join(framework.TestContext.ReportDir, fmt.Sprintf("junit_%v%02d.xml", framework.TestContext.ReportPrefix, config.GinkgoConfig.ParallelNode)))) } } <del> klog.Infof("Starting e2e run %q on Ginkgo node %d", framework.RunID, config.GinkgoConfig.ParallelNode) </del> <ins> // Stream the progress to stdout and optionally a URL accepting progress updates. r = append(r, e2ereporters.NewProgressReporter(framework.TestContext.ProgressReportURL)) klog.Infof("Starting e2e run %q on Ginkgo node %d", framework.RunID, config.GinkgoConfig.ParallelNode) </ins> ginkgo.RunSpecsWithDefaultAndCustomReporters(t, "Kubernetes e2e suite", r) }
flags.BoolVar(&TestContext.ListImages, "list-images", false, "If true, will show list of images used for runnning tests.") flags.StringVar(&TestContext.KubectlPath, "kubectl-path", "kubectl", "The kubectl binary to use. For development, you might use 'cluster/kubectl.sh' here.") <ins> flags.StringVar(&TestContext.ProgressReportURL, "progress-report-url", "", "The URL to POST progress updates to as the suite runs to assist in aiding integrations. If empty, no messages sent.") </ins> } // RegisterClusterFlags registers flags specific to the cluster e2e test suite.
<ins> load("@io_bazel_rules_go//go:def.bzl", "go_library") go_library( name = "go_default_library", srcs = ["progress.go"], importpath = "k8s.io/kubernetes/test/e2e/reporters", visibility = ["//visibility:public"], deps = [ "//vendor/github.com/onsi/ginkgo/config:go_default_library", "//vendor/github.com/onsi/ginkgo/types:go_default_library", "//vendor/k8s.io/klog:go_default_library", ], ) filegroup( name = "package-srcs", srcs = glob(["**"]), tags = ["automanaged"], visibility = ["//visibility:private"], ) filegroup( name = "all-srcs", srcs = [":package-srcs"], tags = ["automanaged"], visibility = ["//visibility:public"], ) </ins>
fi } <ins> # outputs md5 hash of $1, works on macOS and Linux function kube::util::md5() { if which md5 >/dev/null 2>&1; then md5 -q "$1" else md5sum "$1" | awk '{ print $1 }' fi } </ins> # kube::util::read-array # Reads in stdin and adds it line by line to the array provided. This can be # used instead of "mapfile -t", and is bash 3 compatible.
// If we need to (re-)create the pod sandbox, everything will need to be // killed and recreated, and init containers should be purged. if createPodSandbox { <del> if !shouldRestartOnFailure(pod) && attempt != 0 { </del> <ins> if !shouldRestartOnFailure(pod) && attempt != 0 && len(podStatus.ContainerStatuses) != 0 { </ins> // Should not restart the pod, just return. // we should not create a sandbox for a pod if it is already done. // if all containers are done and should not be started, there is no need to create a new sandbox. // this stops confusing logs on pods whose containers all have exit codes, but we recreate a sandbox before terminating it. <ins> // // If ContainerStatuses is empty, we assume that we've never // successfully created any containers. In this case, we should // retry creating the sandbox. </ins> changes.CreateSandbox = false return changes }
ContainersToKill:  map[kubecontainer.ContainerID]containerToKillInfo{}, }, }, <ins> "Verify we create a pod sandbox if no ready sandbox for pod with RestartPolicy=Never and no containers have ever been created": { mutatePodFn: func(pod *v1.Pod) { pod.Spec.RestartPolicy = v1.RestartPolicyNever }, mutateStatusFn: func(status *kubecontainer.PodStatus) { // no ready sandbox status.SandboxStatuses[0].State = runtimeapi.PodSandboxState_SANDBOX_NOTREADY status.SandboxStatuses[0].Metadata.Attempt = uint32(2) // no visible containers status.ContainerStatuses = []*kubecontainer.ContainerStatus{} }, actions: podActions{ SandboxID:         baseStatus.SandboxStatuses[0].Id, Attempt:           uint32(3), CreateSandbox:     true, KillPod:           true, ContainersToStart: []int{0, 1, 2}, ContainersToKill:  map[kubecontainer.ContainerID]containerToKillInfo{}, }, }, </ins> "Kill and recreate the container if the container is in unknown state": { mutatePodFn: func(pod *v1.Pod) { pod.Spec.RestartPolicy = v1.RestartPolicyNever }, mutateStatusFn: func(status *kubecontainer.PodStatus) {
ContainersToKill:  getKillMapWithInitContainers(basePod, baseStatus, []int{}), }, }, <ins> "Pod sandbox not ready, init container failed, but RestartPolicy == Never; kill pod only": { mutatePodFn: func(pod *v1.Pod) { pod.Spec.RestartPolicy = v1.RestartPolicyNever }, mutateStatusFn: func(status *kubecontainer.PodStatus) { status.SandboxStatuses[0].State = runtimeapi.PodSandboxState_SANDBOX_NOTREADY }, actions: podActions{ KillPod:           true, CreateSandbox:     false, SandboxID:         baseStatus.SandboxStatuses[0].Id, Attempt:           uint32(1), ContainersToStart: []int{}, ContainersToKill:  getKillMapWithInitContainers(basePod, baseStatus, []int{}), }, }, "Pod sandbox not ready, and RestartPolicy == Never, but no visible init containers;  create a new pod sandbox": { mutatePodFn: func(pod *v1.Pod) { pod.Spec.RestartPolicy = v1.RestartPolicyNever }, mutateStatusFn: func(status *kubecontainer.PodStatus) { status.SandboxStatuses[0].State = runtimeapi.PodSandboxState_SANDBOX_NOTREADY status.ContainerStatuses = []*kubecontainer.ContainerStatus{} }, actions: podActions{ KillPod:                  true, CreateSandbox:            true, SandboxID:                baseStatus.SandboxStatuses[0].Id, Attempt:                  uint32(1), NextInitContainerToStart: &basePod.Spec.InitContainers[0], ContainersToStart:        []int{}, ContainersToKill:         getKillMapWithInitContainers(basePod, baseStatus, []int{}), }, }, </ins> } { pod, status := makeBasePodAndStatusWithInitContainers() if test.mutatePodFn != nil {
package fake_test import ( <ins> "errors" </ins> "testing" <ins> "k8s.io/apimachinery/pkg/runtime" </ins> "k8s.io/apimachinery/pkg/version" fakediscovery "k8s.io/client-go/discovery/fake" fakeclientset "k8s.io/client-go/kubernetes/fake" <ins> kubetesting "k8s.io/client-go/testing" </ins> ) func TestFakingServerVersion(t *testing.T) {
t.Fatalf("unexpected faked discovery return value: %q", sv.GitCommit) } } <ins> func TestFakingServerVersionWithError(t *testing.T) { expectedError := errors.New("an error occurred") fakeClient := fakeclientset.NewSimpleClientset() fakeClient.Discovery().(*fakediscovery.FakeDiscovery).PrependReactor("*", "*", func(action kubetesting.Action) (handled bool, ret runtime.Object, err error) { return true, nil, expectedError }) _, err := fakeClient.Discovery().ServerVersion() if err == nil { t.Fatal("ServerVersion should return error, returned nil instead") } if err != expectedError { t.Fatal("ServerVersion should return expected error, returned different error instead") } } </ins>
url := fmt.Sprintf("%s/%s.txt", bucketURL, versionLabel) body, err := fetcher(url, getReleaseVersionTimeout) if err != nil { <del> // If the network operaton was successful but the server did not reply with StatusOK if body != "" { return "", err } </del> if clientVersionErr == nil { // Handle air-gapped environments by falling back to the client version. klog.Warningf("could not fetch a Kubernetes version from the internet: %v", err)
func TestVersionFromNetwork(t *testing.T) { type T struct { <del> Content       string Expected      string ErrorExpected bool </del> <ins> Content              string Expected             string FetcherErrorExpected bool ErrorExpected        bool </ins> } <ins> currentVersion := normalizedBuildVersion(constants.CurrentKubernetesVersion.String()) </ins> cases := map[string]T{ <del> "stable":     {"stable-1", "v1.4.6", false}, // recursive pointer to stable-1 "stable-1":   {"v1.4.6", "v1.4.6", false}, "stable-1.3": {"v1.3.10", "v1.3.10", false}, "latest":     {"v1.6.0-alpha.0", "v1.6.0-alpha.0", false}, "latest-1.3": {"v1.3.11-beta.0", "v1.3.11-beta.0", false}, "empty":      {"", "", true}, "garbage":    {"<?xml version='1.0'?><Error><Code>NoSuchKey</Code><Message>The specified key does not exist.</Message></Error>", "", true}, "unknown":    {"The requested URL was not found on this server.", "", true}, </del> <ins> "stable":     {"stable-1", "v1.4.6", false, false}, // recursive pointer to stable-1 "stable-1":   {"v1.4.6", "v1.4.6", false, false}, "stable-1.3": {"v1.3.10", "v1.3.10", false, false}, "latest":     {"v1.6.0-alpha.0", "v1.6.0-alpha.0", false, false}, "latest-1.3": {"v1.3.11-beta.0", "v1.3.11-beta.0", false, false}, "empty":      {"", currentVersion, true, false}, "garbage":    {"<?xml version='1.0'?><Error><Code>NoSuchKey</Code><Message>The specified key does not exist.</Message></Error>", currentVersion, true, false}, "unknown":    {"The requested URL was not found on this server.", currentVersion, true, false}, </ins> } for k, v := range cases {
github.com/json-iterator/go v1.1.6 github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024 github.com/karrick/godirwalk v1.7.5 // indirect <del> github.com/libopenstorage/openstorage v0.0.0-20170906232338-093a0c388875 </del> <ins> github.com/libopenstorage/openstorage v1.0.0 </ins> github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de github.com/lithammer/dedent v1.1.0 github.com/lpabon/godbc v0.1.1 // indirect
github.com/kr/pty => github.com/kr/pty v1.1.5 github.com/kr/text => github.com/kr/text v0.1.0 github.com/kylelemons/godebug => github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348 <del> github.com/libopenstorage/openstorage => github.com/libopenstorage/openstorage v0.0.0-20170906232338-093a0c388875 </del> <ins> github.com/libopenstorage/openstorage => github.com/libopenstorage/openstorage v1.0.0 </ins> github.com/liggitt/tabwriter => github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de github.com/lithammer/dedent => github.com/lithammer/dedent v1.1.0 github.com/lpabon/godbc => github.com/lpabon/godbc v0.1.1
github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348/go.mod h1:B69LEHPfb2qLo0BaaOLcbitczOKLWTsrBG9LczfCD4k= <del> github.com/libopenstorage/openstorage v0.0.0-20170906232338-093a0c388875 h1:s+gZ8/rkYrWgN7xTMUISDw6nspgWyju2OCKmpFBrviQ= github.com/libopenstorage/openstorage v0.0.0-20170906232338-093a0c388875/go.mod h1:Sp1sIObHjat1BeXhfMqLZ14wnOzEhNx2YQedreMcUyc= </del> <ins> github.com/libopenstorage/openstorage v1.0.0 h1:GLPam7/0mpdP8ZZtKjbfcXJBTIA/T1O6CBErVEFEyIM= github.com/libopenstorage/openstorage v1.0.0/go.mod h1:Sp1sIObHjat1BeXhfMqLZ14wnOzEhNx2YQedreMcUyc= </ins> github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de h1:9TO3cAIGXtEhnIaL+V+BEER86oLrvS+kWobKpbJuye0= github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de/go.mod h1:zAbeS9B/r2mtpb6U+EI2rYA5OAXxsYw6wTamcNW+zcE= github.com/lithammer/dedent v1.1.0 h1:VNzHMVCBNG1j0fh3OrsFRkVUwStdDArbgBWoPAffktY=
github.com/karrick/godirwalk # github.com/konsorten/go-windows-terminal-sequences v1.0.1 => github.com/konsorten/go-windows-terminal-sequences v1.0.1 github.com/konsorten/go-windows-terminal-sequences <del> # github.com/libopenstorage/openstorage v0.0.0-20170906232338-093a0c388875 => github.com/libopenstorage/openstorage v0.0.0-20170906232338-093a0c388875 </del> <ins> # github.com/libopenstorage/openstorage v1.0.0 => github.com/libopenstorage/openstorage v1.0.0 </ins> github.com/libopenstorage/openstorage/api github.com/libopenstorage/openstorage/api/client github.com/libopenstorage/openstorage/api/client/volume
panic(err) } <ins> mismatchErrorMessage := "ERROR: %v indicates that %v should be at version %v, but the following files didn't match:nn" + "%vnnif you are changing the version of %v, make sure all of the following files are updated with the newest version including %vn" + "then run ./hack/verify-external-dependencies-version.shnn" </ins> externalDeps := &dependencies{} <ins> var pathsToUpdate []string </ins> err = yaml.Unmarshal(externalDepsFile, externalDeps) if err != nil { panic(err)
} } if !found { <del> log.Fatalf("%v dependency: file %v doesn't contain the expected version %v or matcher %v did change. check the %v file", dep.Name, refPath.Path, dep.Version, refPath.Match, externalDepsFilePath) </del> <ins> pathsToUpdate = append(pathsToUpdate, refPath.Path) </ins> } } <ins> if len(pathsToUpdate) > 0 { log.Fatalf(mismatchErrorMessage, externalDepsFilePath, dep.Name, dep.Version, strings.Join(pathsToUpdate, "n"), dep.Name, externalDepsFilePath) } </ins> } }
factor = 2 ) duration := base <ins> // Responsible for checking limits in resolv.conf // The limits do not have anything to do with individual pods // Since this is called in syncLoop, we don't need to call it anywhere else if kl.dnsConfigurer != nil && kl.dnsConfigurer.ResolverConfig != "" { kl.dnsConfigurer.CheckLimitsForResolvConf() } </ins> for { if err := kl.runtimeState.runtimeErrors(); err != nil { klog.Errorf("skipping pod synchronization - %v", err)
func (kl *Kubelet) HandlePodAdditions(pods []*v1.Pod) { start := kl.clock.Now() sort.Sort(sliceutils.PodsByCreationTime(pods)) <del> // Responsible for checking limits in resolv.conf // The limits do not have anything to do with individual pods if kl.dnsConfigurer != nil && kl.dnsConfigurer.ResolverConfig != "" { kl.dnsConfigurer.CheckLimitsForResolvConf() } </del> for _, pod := range pods { existingPods := kl.podManager.GetPods() // Always add the pod to the pod manager. Kubelet relies on the pod
// being updated from a config source. func (kl *Kubelet) HandlePodUpdates(pods []*v1.Pod) { start := kl.clock.Now() <del> // Responsible for checking limits in resolv.conf if kl.dnsConfigurer != nil && kl.dnsConfigurer.ResolverConfig != "" { kl.dnsConfigurer.CheckLimitsForResolvConf() } </del> for _, pod := range pods { kl.podManager.UpdatePod(pod) if kubetypes.IsMirrorPod(pod) {
dial = (&net.Dialer{Timeout: 30 * time.Second, KeepAlive: 30 * time.Second}).DialContext } d := connrotation.NewDialer(dial) <del> a.onRotate = d.CloseAll </del> <ins> a.mu.Lock() defer a.mu.Unlock() a.onRotateList = append(a.onRotateList, d.CloseAll) onRotateListLength := len(a.onRotateList) if onRotateListLength > onRotateListWarningLength { klog.Warningf("constructing many client instances from the same exec auth config can cause performance problems during cert rotation and can exhaust available network connections; %d clients constructed calling %q", onRotateListLength, a.cmd) } </ins> c.Dial = d.DialContext return nil
a.cachedCreds = newCreds // Only close all connections when TLS cert rotates. Token rotation doesn't // need the extra noise. <del> if a.onRotate != nil && oldCreds != nil && !reflect.DeepEqual(oldCreds.cert, a.cachedCreds.cert) { a.onRotate() </del> <ins> if len(a.onRotateList) > 0 && oldCreds != nil && !reflect.DeepEqual(oldCreds.cert, a.cachedCreds.cert) { for _, onRotate := range a.onRotateList { onRotate() } </ins> } return nil }
get(t, "valid TLS cert again", false) } <ins> func TestConcurrentUpdateTransportConfig(t *testing.T) { n := time.Now() now := func() time.Time { return n } env := []string{""} environ := func() []string { s := make([]string, len(env)) copy(s, env) return s } c := api.ExecConfig{ Command:    "./testdata/test-plugin.sh", APIVersion: "client.authentication.k8s.io/v1alpha1", } a, err := newAuthenticator(newCache(), &c) if err != nil { t.Fatal(err) } a.environ = environ a.now = now a.stderr = ioutil.Discard stopCh := make(chan struct{}) defer close(stopCh) numConcurrent := 2 for i := 0; i < numConcurrent; i++ { go func() { for { tc := &transport.Config{} a.UpdateTransportConfig(tc) select { case <-stopCh: return default: continue } } }() } time.Sleep(2 * time.Second) } </ins> // genClientCert generates an x509 certificate for testing. Certificate and key // are returned in PEM encoding. func genClientCert(t *testing.T) ([]byte, []byte) {
"k8s.io/apimachinery/pkg/api/resource" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" <ins> "k8s.io/apimachinery/pkg/util/sets" </ins> cloudprovider "k8s.io/cloud-provider" cloudproviderapi "k8s.io/cloud-provider/api" "k8s.io/klog"
requiresUpdate := kl.reconcileCMADAnnotationWithExistingNode(node, existingNode) requiresUpdate = kl.updateDefaultLabels(node, existingNode) || requiresUpdate requiresUpdate = kl.reconcileExtendedResource(node, existingNode) || requiresUpdate <ins> requiresUpdate = kl.reconcileHugePageResource(node, existingNode) || requiresUpdate </ins> if requiresUpdate { if _, _, err := nodeutil.PatchNodeStatus(kl.kubeClient.CoreV1(), types.NodeName(kl.nodeName), originalNode, existingNode); err != nil { klog.Errorf("Unable to reconcile node %q with API server: error updating node: %v", kl.nodeName, err)
return true } <ins> // reconcileHugePageResource will update huge page capacity for each page size and remove huge page sizes no longer supported func (kl *Kubelet) reconcileHugePageResource(initialNode, existingNode *v1.Node) bool { requiresUpdate := false supportedHugePageResources := sets.String{} for resourceName := range initialNode.Status.Capacity { if !v1helper.IsHugePageResourceName(resourceName) { continue } supportedHugePageResources.Insert(string(resourceName)) initialCapacity := initialNode.Status.Capacity[resourceName] initialAllocatable := initialNode.Status.Allocatable[resourceName] capacity, resourceIsSupported := existingNode.Status.Capacity[resourceName] allocatable := existingNode.Status.Allocatable[resourceName] // Add or update capacity if it the size was previously unsupported or has changed if !resourceIsSupported || capacity.Cmp(initialCapacity) != 0 { existingNode.Status.Capacity[resourceName] = initialCapacity.DeepCopy() requiresUpdate = true } // Add or update allocatable if it the size was previously unsupported or has changed if !resourceIsSupported || allocatable.Cmp(initialAllocatable) != 0 { existingNode.Status.Allocatable[resourceName] = initialAllocatable.DeepCopy() requiresUpdate = true } } for resourceName := range existingNode.Status.Capacity { if !v1helper.IsHugePageResourceName(resourceName) { continue } // If huge page size no longer is supported, we remove it from the node if !supportedHugePageResources.Has(string(resourceName)) { delete(existingNode.Status.Capacity, resourceName) delete(existingNode.Status.Allocatable, resourceName) klog.Infof("Removing now unsupported huge page resource named: %s", resourceName) requiresUpdate = true } } return requiresUpdate } </ins> // Zeros out extended resource capacity during reconciliation. func (kl *Kubelet) reconcileExtendedResource(initialNode, node *v1.Node) bool { requiresUpdate := false
v1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/api/resource" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" <ins> "k8s.io/apimachinery/pkg/types" </ins> "k8s.io/apimachinery/pkg/util/uuid" "k8s.io/kubernetes/pkg/kubelet/cm" "k8s.io/kubernetes/test/e2e/framework"