vendor files

vendor/k8s.io/kubernetes/pkg/kubelet/util/BUILD

@@ -0,0 +1,70 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["util_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/kubelet/util",
+    library = ":go_default_library",
+    deps = ["//vendor/github.com/stretchr/testify/assert:go_default_library"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "util.go",
+        "util_unsupported.go",
+    ] + select({
+        "@io_bazel_rules_go//go/platform:darwin_amd64": [
+            "util_unix.go",
+        ],
+        "@io_bazel_rules_go//go/platform:linux_amd64": [
+            "util_unix.go",
+        ],
+        "@io_bazel_rules_go//go/platform:windows_amd64": [
+            "util_windows.go",
+        ],
+        "//conditions:default": [],
+    }),
+    importpath = "k8s.io/kubernetes/pkg/kubelet/util",
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+    ] + select({
+        "@io_bazel_rules_go//go/platform:darwin_amd64": [
+            "//vendor/github.com/golang/glog:go_default_library",
+            "//vendor/golang.org/x/sys/unix:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:linux_amd64": [
+            "//vendor/github.com/golang/glog:go_default_library",
+            "//vendor/golang.org/x/sys/unix:go_default_library",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//pkg/kubelet/util/cache:all-srcs",
+        "//pkg/kubelet/util/format:all-srcs",
+        "//pkg/kubelet/util/ioutils:all-srcs",
+        "//pkg/kubelet/util/queue:all-srcs",
+        "//pkg/kubelet/util/sliceutils:all-srcs",
+        "//pkg/kubelet/util/store:all-srcs",
+    ],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/kubelet/util/cache/BUILD

@@ -0,0 +1,38 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["object_cache.go"],
+    importpath = "k8s.io/kubernetes/pkg/kubelet/util/cache",
+    deps = ["//vendor/k8s.io/client-go/tools/cache:go_default_library"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["object_cache_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/kubelet/util/cache",
+    library = ":go_default_library",
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/util/clock:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/kubelet/util/cache/object_cache.go

@@ -0,0 +1,84 @@
+/*
+Copyright 2016 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 cache
+
+import (
+	"time"
+
+	expirationcache "k8s.io/client-go/tools/cache"
+)
+
+// ObjectCache is a simple wrapper of expiration cache that
+// 1. use string type key
+// 2. has an updater to get value directly if it is expired
+// 3. then update the cache
+type ObjectCache struct {
+	cache   expirationcache.Store
+	updater func() (interface{}, error)
+}
+
+// objectEntry is an object with string type key.
+type objectEntry struct {
+	key string
+	obj interface{}
+}
+
+// NewObjectCache creates ObjectCache with an updater.
+// updater returns an object to cache.
+func NewObjectCache(f func() (interface{}, error), ttl time.Duration) *ObjectCache {
+	return &ObjectCache{
+		updater: f,
+		cache:   expirationcache.NewTTLStore(stringKeyFunc, ttl),
+	}
+}
+
+// stringKeyFunc is a string as cache key function
+func stringKeyFunc(obj interface{}) (string, error) {
+	key := obj.(objectEntry).key
+	return key, nil
+}
+
+// Get gets cached objectEntry by using a unique string as the key.
+func (c *ObjectCache) Get(key string) (interface{}, error) {
+	value, ok, err := c.cache.Get(objectEntry{key: key})
+	if err != nil {
+		return nil, err
+	}
+	if !ok {
+		obj, err := c.updater()
+		if err != nil {
+			return nil, err
+		}
+		err = c.cache.Add(objectEntry{
+			key: key,
+			obj: obj,
+		})
+		if err != nil {
+			return nil, err
+		}
+		return obj, nil
+	}
+	return value.(objectEntry).obj, nil
+}
+
+func (c *ObjectCache) Add(key string, obj interface{}) error {
+	err := c.cache.Add(objectEntry{key: key, obj: obj})
+	if err != nil {
+		return err
+	}
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubelet/util/cache/object_cache_test.go

@@ -0,0 +1,96 @@
+/*
+Copyright 2016 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 cache
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"k8s.io/apimachinery/pkg/util/clock"
+	expirationcache "k8s.io/client-go/tools/cache"
+)
+
+type testObject struct {
+	key string
+	val string
+}
+
+// A fake objectCache for unit test.
+func NewFakeObjectCache(f func() (interface{}, error), ttl time.Duration, clock clock.Clock) *ObjectCache {
+	ttlPolicy := &expirationcache.TTLPolicy{Ttl: ttl, Clock: clock}
+	deleteChan := make(chan string, 1)
+	return &ObjectCache{
+		updater: f,
+		cache:   expirationcache.NewFakeExpirationStore(stringKeyFunc, deleteChan, ttlPolicy, clock),
+	}
+}
+
+func TestAddAndGet(t *testing.T) {
+	testObj := testObject{
+		key: "foo",
+		val: "bar",
+	}
+	objectCache := NewFakeObjectCache(func() (interface{}, error) {
+		return nil, fmt.Errorf("Unexpected Error: updater should never be called in this test!")
+	}, 1*time.Hour, clock.NewFakeClock(time.Now()))
+
+	err := objectCache.Add(testObj.key, testObj.val)
+	if err != nil {
+		t.Errorf("Unable to add obj %#v by key: %s", testObj, testObj.key)
+	}
+	value, err := objectCache.Get(testObj.key)
+	if err != nil {
+		t.Errorf("Unable to get obj %#v by key: %s", testObj, testObj.key)
+	}
+	if value.(string) != testObj.val {
+		t.Errorf("Expected to get cached value: %#v, but got: %s", testObj.val, value.(string))
+	}
+
+}
+
+func TestExpirationBasic(t *testing.T) {
+	unexpectedVal := "bar"
+	expectedVal := "bar2"
+
+	testObj := testObject{
+		key: "foo",
+		val: unexpectedVal,
+	}
+
+	fakeClock := clock.NewFakeClock(time.Now())
+
+	objectCache := NewFakeObjectCache(func() (interface{}, error) {
+		return expectedVal, nil
+	}, 1*time.Second, fakeClock)
+
+	err := objectCache.Add(testObj.key, testObj.val)
+	if err != nil {
+		t.Errorf("Unable to add obj %#v by key: %s", testObj, testObj.key)
+	}
+
+	// sleep 2s so cache should be expired.
+	fakeClock.Sleep(2 * time.Second)
+
+	value, err := objectCache.Get(testObj.key)
+	if err != nil {
+		t.Errorf("Unable to get obj %#v by key: %s", testObj, testObj.key)
+	}
+	if value.(string) != expectedVal {
+		t.Errorf("Expected to get cached value: %#v, but got: %s", expectedVal, value.(string))
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubelet/util/doc.go

@@ -0,0 +1,18 @@
+/*
+Copyright 2015 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.
+*/
+
+// Utility functions.
+package util // import "k8s.io/kubernetes/pkg/kubelet/util"

vendor/k8s.io/kubernetes/pkg/kubelet/util/format/BUILD

@@ -0,0 +1,44 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "pod.go",
+        "resources.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/kubelet/util/format",
+    deps = [
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["resources_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/kubelet/util/format",
+    library = ":go_default_library",
+    deps = [
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/kubelet/util/format/pod.go

@@ -0,0 +1,72 @@
+/*
+Copyright 2015 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 format
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/types"
+)
+
+type podHandler func(*v1.Pod) string
+
+// Pod returns a string representing a pod in a consistent human readable format,
+// with pod UID as part of the string.
+func Pod(pod *v1.Pod) string {
+	return PodDesc(pod.Name, pod.Namespace, pod.UID)
+}
+
+// PodDesc returns a string representing a pod in a consistent human readable format,
+// with pod UID as part of the string.
+func PodDesc(podName, podNamespace string, podUID types.UID) string {
+	// Use underscore as the delimiter because it is not allowed in pod name
+	// (DNS subdomain format), while allowed in the container name format.
+	return fmt.Sprintf("%s_%s(%s)", podName, podNamespace, podUID)
+}
+
+// PodWithDeletionTimestamp is the same as Pod. In addition, it prints the
+// deletion timestamp of the pod if it's not nil.
+func PodWithDeletionTimestamp(pod *v1.Pod) string {
+	var deletionTimestamp string
+	if pod.DeletionTimestamp != nil {
+		deletionTimestamp = ":DeletionTimestamp=" + pod.DeletionTimestamp.UTC().Format(time.RFC3339)
+	}
+	return Pod(pod) + deletionTimestamp
+}
+
+// Pods returns a string representating a list of pods in a human
+// readable format.
+func Pods(pods []*v1.Pod) string {
+	return aggregatePods(pods, Pod)
+}
+
+// PodsWithDeletiontimestamps is the same as Pods. In addition, it prints the
+// deletion timestamps of the pods if they are not nil.
+func PodsWithDeletiontimestamps(pods []*v1.Pod) string {
+	return aggregatePods(pods, PodWithDeletionTimestamp)
+}
+
+func aggregatePods(pods []*v1.Pod, handler podHandler) string {
+	podStrings := make([]string, 0, len(pods))
+	for _, pod := range pods {
+		podStrings = append(podStrings, handler(pod))
+	}
+	return fmt.Sprintf(strings.Join(podStrings, ", "))
+}

vendor/k8s.io/kubernetes/pkg/kubelet/util/format/resources.go

@@ -0,0 +1,36 @@
+/*
+Copyright 2016 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 format
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+
+	"k8s.io/api/core/v1"
+)
+
+// ResourceList returns a string representation of a resource list in a human readable format.
+func ResourceList(resources v1.ResourceList) string {
+	resourceStrings := make([]string, 0, len(resources))
+	for key, value := range resources {
+		resourceStrings = append(resourceStrings, fmt.Sprintf("%v=%v", key, value.String()))
+	}
+	// sort the results for consistent log output
+	sort.Strings(resourceStrings)
+	return strings.Join(resourceStrings, ",")
+}

vendor/k8s.io/kubernetes/pkg/kubelet/util/format/resources_test.go

@@ -0,0 +1,35 @@
+/*
+Copyright 2016 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 format
+
+import (
+	"testing"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+)
+
+func TestResourceList(t *testing.T) {
+	resourceList := v1.ResourceList{}
+	resourceList[v1.ResourceCPU] = resource.MustParse("100m")
+	resourceList[v1.ResourceMemory] = resource.MustParse("5Gi")
+	actual := ResourceList(resourceList)
+	expected := "cpu=100m,memory=5Gi"
+	if actual != expected {
+		t.Errorf("Unexpected result, actual: %v, expected: %v", actual, expected)
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubelet/util/ioutils/BUILD

@@ -0,0 +1,25 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["ioutils.go"],
+    importpath = "k8s.io/kubernetes/pkg/kubelet/util/ioutils",
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/kubelet/util/ioutils/ioutils.go

@@ -0,0 +1,37 @@
+/*
+Copyright 2016 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 ioutils
+
+import "io"
+
+// writeCloserWrapper represents a WriteCloser whose closer operation is noop.
+type writeCloserWrapper struct {
+	Writer io.Writer
+}
+
+func (w *writeCloserWrapper) Write(buf []byte) (int, error) {
+	return w.Writer.Write(buf)
+}
+
+func (w *writeCloserWrapper) Close() error {
+	return nil
+}
+
+// WriteCloserWrapper returns a writeCloserWrapper.
+func WriteCloserWrapper(w io.Writer) io.WriteCloser {
+	return &writeCloserWrapper{w}
+}

vendor/k8s.io/kubernetes/pkg/kubelet/util/queue/BUILD

@@ -0,0 +1,42 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["work_queue.go"],
+    importpath = "k8s.io/kubernetes/pkg/kubelet/util/queue",
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/clock:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["work_queue_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/kubelet/util/queue",
+    library = ":go_default_library",
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/clock:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/kubelet/util/queue/work_queue.go

@@ -0,0 +1,67 @@
+/*
+Copyright 2015 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 queue
+
+import (
+	"sync"
+	"time"
+
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/clock"
+)
+
+// WorkQueue allows queuing items with a timestamp. An item is
+// considered ready to process if the timestamp has expired.
+type WorkQueue interface {
+	// GetWork dequeues and returns all ready items.
+	GetWork() []types.UID
+	// Enqueue inserts a new item or overwrites an existing item.
+	Enqueue(item types.UID, delay time.Duration)
+}
+
+type basicWorkQueue struct {
+	clock clock.Clock
+	lock  sync.Mutex
+	queue map[types.UID]time.Time
+}
+
+var _ WorkQueue = &basicWorkQueue{}
+
+func NewBasicWorkQueue(clock clock.Clock) WorkQueue {
+	queue := make(map[types.UID]time.Time)
+	return &basicWorkQueue{queue: queue, clock: clock}
+}
+
+func (q *basicWorkQueue) GetWork() []types.UID {
+	q.lock.Lock()
+	defer q.lock.Unlock()
+	now := q.clock.Now()
+	var items []types.UID
+	for k, v := range q.queue {
+		if v.Before(now) {
+			items = append(items, k)
+			delete(q.queue, k)
+		}
+	}
+	return items
+}
+
+func (q *basicWorkQueue) Enqueue(item types.UID, delay time.Duration) {
+	q.lock.Lock()
+	defer q.lock.Unlock()
+	q.queue[item] = q.clock.Now().Add(delay)
+}

vendor/k8s.io/kubernetes/pkg/kubelet/util/queue/work_queue_test.go

@@ -0,0 +1,65 @@
+/*
+Copyright 2015 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 queue
+
+import (
+	"testing"
+	"time"
+
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/clock"
+	"k8s.io/apimachinery/pkg/util/sets"
+)
+
+func newTestBasicWorkQueue() (*basicWorkQueue, *clock.FakeClock) {
+	fakeClock := clock.NewFakeClock(time.Now())
+	wq := &basicWorkQueue{
+		clock: fakeClock,
+		queue: make(map[types.UID]time.Time),
+	}
+	return wq, fakeClock
+}
+
+func compareResults(t *testing.T, expected, actual []types.UID) {
+	expectedSet := sets.NewString()
+	for _, u := range expected {
+		expectedSet.Insert(string(u))
+	}
+	actualSet := sets.NewString()
+	for _, u := range actual {
+		actualSet.Insert(string(u))
+	}
+	if !expectedSet.Equal(actualSet) {
+		t.Errorf("Expected %#v, got %#v", expectedSet.List(), actualSet.List())
+	}
+}
+
+func TestGetWork(t *testing.T) {
+	q, clock := newTestBasicWorkQueue()
+	q.Enqueue(types.UID("foo1"), -1*time.Minute)
+	q.Enqueue(types.UID("foo2"), -1*time.Minute)
+	q.Enqueue(types.UID("foo3"), 1*time.Minute)
+	q.Enqueue(types.UID("foo4"), 1*time.Minute)
+	expected := []types.UID{types.UID("foo1"), types.UID("foo2")}
+	compareResults(t, expected, q.GetWork())
+	compareResults(t, []types.UID{}, q.GetWork())
+	// Dial the time to 1 hour ahead.
+	clock.Step(time.Hour)
+	expected = []types.UID{types.UID("foo3"), types.UID("foo4")}
+	compareResults(t, expected, q.GetWork())
+	compareResults(t, []types.UID{}, q.GetWork())
+}

vendor/k8s.io/kubernetes/pkg/kubelet/util/sliceutils/BUILD

@@ -0,0 +1,42 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["sliceutils.go"],
+    importpath = "k8s.io/kubernetes/pkg/kubelet/util/sliceutils",
+    deps = [
+        "//pkg/kubelet/container:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["sliceutils_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/kubelet/util/sliceutils",
+    library = ":go_default_library",
+    deps = [
+        "//pkg/kubelet/container:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/kubelet/util/sliceutils/sliceutils.go

@@ -0,0 +1,58 @@
+/*
+Copyright 2015 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 sliceutils
+
+import (
+	"k8s.io/api/core/v1"
+	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
+)
+
+func StringInSlice(s string, list []string) bool {
+	for _, v := range list {
+		if v == s {
+			return true
+		}
+	}
+
+	return false
+}
+
+// PodsByCreationTime makes an array of pods sortable by their creation
+// timestamps in ascending order.
+type PodsByCreationTime []*v1.Pod
+
+func (s PodsByCreationTime) Len() int {
+	return len(s)
+}
+
+func (s PodsByCreationTime) Swap(i, j int) {
+	s[i], s[j] = s[j], s[i]
+}
+
+func (s PodsByCreationTime) Less(i, j int) bool {
+	return s[i].CreationTimestamp.Before(&s[j].CreationTimestamp)
+}
+
+// ByImageSize makes an array of images sortable by their size in descending
+// order.
+type ByImageSize []kubecontainer.Image
+
+func (a ByImageSize) Less(i, j int) bool {
+	return a[i].Size > a[j].Size
+}
+func (a ByImageSize) Len() int      { return len(a) }
+func (a ByImageSize) Swap(i, j int) { a[i], a[j] = a[j], a[i] }

vendor/k8s.io/kubernetes/pkg/kubelet/util/sliceutils/sliceutils_test.go

@@ -0,0 +1,222 @@
+/*
+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 sliceutils
+
+import (
+	"testing"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
+	"time"
+)
+
+func TestStringInSlice(t *testing.T) {
+	fooTests := []struct {
+		s    string
+		list []string
+		er   bool
+	}{
+		{"first", []string{"first", "second"}, true},
+		{"FIRST", []string{"first", "second"}, false},
+		{"third", []string{"first", "second"}, false},
+		{"first", nil, false},
+
+		{"", []string{"first", "second"}, false},
+		{"", []string{"first", "second", ""}, true},
+		{"", nil, false},
+	}
+
+	for _, fooTest := range fooTests {
+		r := StringInSlice(fooTest.s, fooTest.list)
+		if r != fooTest.er {
+			t.Errorf("returned %t but expected %t for s=%s & list=%s", r, fooTest.er, fooTest.s, fooTest.list)
+		}
+	}
+}
+
+func buildPodsByCreationTime() PodsByCreationTime {
+	return []*v1.Pod{
+		{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      "foo1",
+				Namespace: v1.NamespaceDefault,
+				CreationTimestamp: metav1.Time{
+					Time: time.Now(),
+				},
+			},
+		},
+		{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      "foo2",
+				Namespace: v1.NamespaceDefault,
+				CreationTimestamp: metav1.Time{
+					Time: time.Now().Add(time.Hour * 1),
+				},
+			},
+		},
+		{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      "foo3",
+				Namespace: v1.NamespaceDefault,
+				CreationTimestamp: metav1.Time{
+					Time: time.Now().Add(time.Hour * 2),
+				},
+			},
+		},
+	}
+}
+
+func TestPodsByCreationTimeLen(t *testing.T) {
+	fooTests := []struct {
+		pods PodsByCreationTime
+		el   int
+	}{
+		{[]*v1.Pod{}, 0},
+		{buildPodsByCreationTime(), 3},
+		{[]*v1.Pod{nil, {}}, 2},
+		{nil, 0},
+	}
+
+	for _, fooTest := range fooTests {
+		r := fooTest.pods.Len()
+		if r != fooTest.el {
+			t.Errorf("returned %d but expected %d for the len of PodsByCreationTime=%s", r, fooTest.el, fooTest.pods)
+		}
+	}
+}
+
+func TestPodsByCreationTimeSwap(t *testing.T) {
+	fooTests := []struct {
+		pods PodsByCreationTime
+		i    int
+		j    int
+	}{
+		{buildPodsByCreationTime(), 0, 1},
+		{buildPodsByCreationTime(), 2, 1},
+	}
+
+	for _, fooTest := range fooTests {
+		fooi := fooTest.pods[fooTest.i]
+		fooj := fooTest.pods[fooTest.j]
+		fooTest.pods.Swap(fooTest.i, fooTest.j)
+		if fooi.GetName() != fooTest.pods[fooTest.j].GetName() || fooj.GetName() != fooTest.pods[fooTest.i].GetName() {
+			t.Errorf("failed to swap for %v", fooTest)
+		}
+	}
+}
+
+func TestPodsByCreationTimeLess(t *testing.T) {
+	fooTests := []struct {
+		pods PodsByCreationTime
+		i    int
+		j    int
+		er   bool
+	}{
+		// ascending order
+		{buildPodsByCreationTime(), 0, 2, true},
+		{buildPodsByCreationTime(), 1, 0, false},
+	}
+
+	for _, fooTest := range fooTests {
+		r := fooTest.pods.Less(fooTest.i, fooTest.j)
+		if r != fooTest.er {
+			t.Errorf("returned %t but expected %t for the foo=%s", r, fooTest.er, fooTest.pods)
+		}
+	}
+}
+
+func buildByImageSize() ByImageSize {
+	return []kubecontainer.Image{
+		{
+			ID:          "1",
+			RepoTags:    []string{"foo-tag11", "foo-tag12"},
+			RepoDigests: []string{"foo-rd11", "foo-rd12"},
+			Size:        1,
+		},
+		{
+			ID:          "2",
+			RepoTags:    []string{"foo-tag21", "foo-tag22"},
+			RepoDigests: []string{"foo-rd21", "foo-rd22"},
+			Size:        2,
+		},
+		{
+			ID:          "3",
+			RepoTags:    []string{"foo-tag31", "foo-tag32"},
+			RepoDigests: []string{"foo-rd31", "foo-rd32"},
+			Size:        3,
+		},
+	}
+}
+
+func TestByImageSizeLen(t *testing.T) {
+	fooTests := []struct {
+		images ByImageSize
+		el     int
+	}{
+		{[]kubecontainer.Image{}, 0},
+		{buildByImageSize(), 3},
+		{nil, 0},
+	}
+
+	for _, fooTest := range fooTests {
+		r := fooTest.images.Len()
+		if r != fooTest.el {
+			t.Errorf("returned %d but expected %d for the len of ByImageSize=%v", r, fooTest.el, fooTest.images)
+		}
+	}
+}
+
+func TestByImageSizeSwap(t *testing.T) {
+	fooTests := []struct {
+		images ByImageSize
+		i      int
+		j      int
+	}{
+		{buildByImageSize(), 0, 1},
+		{buildByImageSize(), 2, 1},
+	}
+
+	for _, fooTest := range fooTests {
+		fooi := fooTest.images[fooTest.i]
+		fooj := fooTest.images[fooTest.j]
+		fooTest.images.Swap(fooTest.i, fooTest.j)
+		if fooi.ID != fooTest.images[fooTest.j].ID || fooj.ID != fooTest.images[fooTest.i].ID {
+			t.Errorf("failed to swap for %v", fooTest)
+		}
+	}
+}
+
+func TestByImageSizeLess(t *testing.T) {
+	fooTests := []struct {
+		images ByImageSize
+		i      int
+		j      int
+		er     bool
+	}{
+		// descending order
+		{buildByImageSize(), 0, 2, false},
+		{buildByImageSize(), 1, 0, true},
+	}
+
+	for _, fooTest := range fooTests {
+		r := fooTest.images.Less(fooTest.i, fooTest.j)
+		if r != fooTest.er {
+			t.Errorf("returned %t but expected %t for the foo=%v", r, fooTest.er, fooTest.images)
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubelet/util/store/BUILD

@@ -0,0 +1,42 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "filestore.go",
+        "store.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/kubelet/util/store",
+    visibility = ["//visibility:public"],
+    deps = ["//pkg/util/filesystem:go_default_library"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "filestore_test.go",
+        "store_test.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/kubelet/util/store",
+    library = ":go_default_library",
+    deps = [
+        "//pkg/util/filesystem:go_default_library",
+        "//vendor/github.com/stretchr/testify/assert:go_default_library",
+        "//vendor/github.com/stretchr/testify/require: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"],
+)

vendor/k8s.io/kubernetes/pkg/kubelet/util/store/doc.go

@@ -0,0 +1,18 @@
+/*
+Copyright 2015 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 store hosts a Store interface and its implementations.
+package store // import "k8s.io/kubernetes/pkg/kubelet/util/store"

vendor/k8s.io/kubernetes/pkg/kubelet/util/store/filestore.go

@@ -0,0 +1,167 @@
+/*
+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 store
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	utilfs "k8s.io/kubernetes/pkg/util/filesystem"
+)
+
+const (
+	// Name prefix for the temporary files.
+	tmpPrefix = "."
+)
+
+// FileStore is an implementation of the Store interface which stores data in files.
+type FileStore struct {
+	// Absolute path to the base directory for storing data files.
+	directoryPath string
+
+	// filesystem to use.
+	filesystem utilfs.Filesystem
+}
+
+// NewFileStore returns an instance of FileStore.
+func NewFileStore(path string, fs utilfs.Filesystem) (Store, error) {
+	if err := ensureDirectory(fs, path); err != nil {
+		return nil, err
+	}
+	return &FileStore{directoryPath: path, filesystem: fs}, nil
+}
+
+// Write writes the given data to a file named key.
+func (f *FileStore) Write(key string, data []byte) error {
+	if err := ValidateKey(key); err != nil {
+		return err
+	}
+	if err := ensureDirectory(f.filesystem, f.directoryPath); err != nil {
+		return err
+	}
+
+	return writeFile(f.filesystem, f.getPathByKey(key), data)
+}
+
+// Read reads the data from the file named key.
+func (f *FileStore) Read(key string) ([]byte, error) {
+	if err := ValidateKey(key); err != nil {
+		return nil, err
+	}
+	bytes, err := f.filesystem.ReadFile(f.getPathByKey(key))
+	if os.IsNotExist(err) {
+		return bytes, ErrKeyNotFound
+	}
+	return bytes, err
+}
+
+// Delete deletes the key file.
+func (f *FileStore) Delete(key string) error {
+	if err := ValidateKey(key); err != nil {
+		return err
+	}
+	return removePath(f.filesystem, f.getPathByKey(key))
+}
+
+// List returns all keys in the store.
+func (f *FileStore) List() ([]string, error) {
+	keys := make([]string, 0)
+	files, err := f.filesystem.ReadDir(f.directoryPath)
+	if err != nil {
+		return keys, err
+	}
+	for _, f := range files {
+		if !strings.HasPrefix(f.Name(), tmpPrefix) {
+			keys = append(keys, f.Name())
+		}
+	}
+	return keys, nil
+}
+
+// getPathByKey returns the full path of the file for the key.
+func (f *FileStore) getPathByKey(key string) string {
+	return filepath.Join(f.directoryPath, key)
+}
+
+// ensureDirectory creates the directory if it does not exist.
+func ensureDirectory(fs utilfs.Filesystem, path string) error {
+	if _, err := fs.Stat(path); err != nil {
+		// MkdirAll returns nil if directory already exists.
+		return fs.MkdirAll(path, 0755)
+	}
+	return nil
+}
+
+// writeFile writes data to path in a single transaction.
+func writeFile(fs utilfs.Filesystem, path string, data []byte) (retErr error) {
+	// Create a temporary file in the base directory of `path` with a prefix.
+	tmpFile, err := fs.TempFile(filepath.Dir(path), tmpPrefix)
+	if err != nil {
+		return err
+	}
+
+	tmpPath := tmpFile.Name()
+	shouldClose := true
+
+	defer func() {
+		// Close the file.
+		if shouldClose {
+			if err := tmpFile.Close(); err != nil {
+				if retErr == nil {
+					retErr = fmt.Errorf("close error: %v", err)
+				} else {
+					retErr = fmt.Errorf("failed to close temp file after error %v; close error: %v", retErr, err)
+				}
+			}
+		}
+
+		// Clean up the temp file on error.
+		if retErr != nil && tmpPath != "" {
+			if err := removePath(fs, tmpPath); err != nil {
+				retErr = fmt.Errorf("failed to remove the temporary file (%q) after error %v; remove error: %v", tmpPath, retErr, err)
+			}
+		}
+	}()
+
+	// Write data.
+	if _, err := tmpFile.Write(data); err != nil {
+		return err
+	}
+
+	// Sync file.
+	if err := tmpFile.Sync(); err != nil {
+		return err
+	}
+
+	// Closing the file before renaming.
+	err = tmpFile.Close()
+	shouldClose = false
+	if err != nil {
+		return err
+	}
+
+	return fs.Rename(tmpPath, path)
+}
+
+func removePath(fs utilfs.Filesystem, path string) error {
+	if err := fs.Remove(path); err != nil && !os.IsNotExist(err) {
+		return err
+	}
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubelet/util/store/filestore_test.go

@@ -0,0 +1,126 @@
+/*
+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 store
+
+import (
+	"io/ioutil"
+	"sort"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"k8s.io/kubernetes/pkg/util/filesystem"
+)
+
+func TestFileStore(t *testing.T) {
+	path, err := ioutil.TempDir("", "FileStore")
+	assert.NoError(t, err)
+	store, err := NewFileStore(path, filesystem.DefaultFs{})
+	assert.NoError(t, err)
+	testStore(t, store)
+}
+
+func TestFakeFileStore(t *testing.T) {
+	store, err := NewFileStore("/tmp/test-fake-file-store", filesystem.NewFakeFs())
+	assert.NoError(t, err)
+	testStore(t, store)
+}
+
+func testStore(t *testing.T, store Store) {
+	testCases := []struct {
+		key       string
+		data      string
+		expectErr bool
+	}{
+		{
+			"id1",
+			"data1",
+			false,
+		},
+		{
+			"id2",
+			"data2",
+			false,
+		},
+		{
+			"/id1",
+			"data1",
+			true,
+		},
+		{
+			".id1",
+			"data1",
+			true,
+		},
+		{
+			"   ",
+			"data2",
+			true,
+		},
+		{
+			"___",
+			"data2",
+			true,
+		},
+	}
+
+	// Test add data.
+	for _, c := range testCases {
+		t.Log("test case: ", c)
+		_, err := store.Read(c.key)
+		assert.Error(t, err)
+
+		err = store.Write(c.key, []byte(c.data))
+		if c.expectErr {
+			assert.Error(t, err)
+			continue
+		}
+
+		require.NoError(t, err)
+		// Test read data by key.
+		data, err := store.Read(c.key)
+		require.NoError(t, err)
+		assert.Equal(t, string(data), c.data)
+	}
+
+	// Test list keys.
+	keys, err := store.List()
+	assert.NoError(t, err)
+	sort.Strings(keys)
+	assert.Equal(t, keys, []string{"id1", "id2"})
+
+	// Test Delete data
+	for _, c := range testCases {
+		if c.expectErr {
+			continue
+		}
+
+		err = store.Delete(c.key)
+		require.NoError(t, err)
+		_, err = store.Read(c.key)
+		assert.EqualValues(t, ErrKeyNotFound, err)
+	}
+
+	// Test delete non-existent key.
+	err = store.Delete("id1")
+	assert.NoError(t, err)
+
+	// Test list keys.
+	keys, err = store.List()
+	require.NoError(t, err)
+	assert.Equal(t, len(keys), 0)
+}

vendor/k8s.io/kubernetes/pkg/kubelet/util/store/store.go

@@ -0,0 +1,64 @@
+/*
+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 store
+
+import (
+	"fmt"
+	"regexp"
+)
+
+const (
+	keyMaxLength = 250
+
+	keyCharFmt      string = "[A-Za-z0-9]"
+	keyExtCharFmt   string = "[-A-Za-z0-9_.]"
+	qualifiedKeyFmt string = "(" + keyCharFmt + keyExtCharFmt + "*)?" + keyCharFmt
+)
+
+var (
+	// Key must consist of alphanumeric characters, '-', '_' or '.', and must start
+	// and end with an alphanumeric character.
+	keyRegex = regexp.MustCompile("^" + qualifiedKeyFmt + "$")
+
+	// ErrKeyNotFound is the error returned if key is not found in Store.
+	ErrKeyNotFound = fmt.Errorf("key is not found")
+)
+
+// Store provides the interface for storing keyed data.
+// Store must be thread-safe
+type Store interface {
+	// key must contain one or more characters in [A-Za-z0-9]
+	// Write writes data with key.
+	Write(key string, data []byte) error
+	// Read retrieves data with key
+	// Read must return ErrKeyNotFound if key is not found.
+	Read(key string) ([]byte, error)
+	// Delete deletes data by key
+	// Delete must not return error if key does not exist
+	Delete(key string) error
+	// List lists all existing keys.
+	List() ([]string, error)
+}
+
+// ValidateKey returns an error if the given key does not meet the requirement
+// of the key format and length.
+func ValidateKey(key string) error {
+	if len(key) <= keyMaxLength && keyRegex.MatchString(key) {
+		return nil
+	}
+	return fmt.Errorf("invalid key: %q", key)
+}

vendor/k8s.io/kubernetes/pkg/kubelet/util/store/store_test.go

@@ -0,0 +1,63 @@
+/*
+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 store
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIsValidKey(t *testing.T) {
+	testcases := []struct {
+		key   string
+		valid bool
+	}{
+		{
+			"    ",
+			false,
+		},
+		{
+			"/foo/bar",
+			false,
+		},
+		{
+			".foo",
+			false,
+		},
+		{
+			"a78768279290d33d0b82eaea43cb8346f500057cb5bd250e88c97a5585385d66",
+			true,
+		},
+		{
+			"a7.87-6_8",
+			true,
+		},
+		{
+			"a7.87-677-",
+			false,
+		},
+	}
+
+	for _, tc := range testcases {
+		if tc.valid {
+			assert.NoError(t, ValidateKey(tc.key))
+		} else {
+			assert.Error(t, ValidateKey(tc.key))
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubelet/util/util.go

@@ -0,0 +1,47 @@
+/*
+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 util
+
+import (
+	"fmt"
+	"net/url"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+// FromApiserverCache modifies <opts> so that the GET request will
+// be served from apiserver cache instead of from etcd.
+func FromApiserverCache(opts *metav1.GetOptions) {
+	opts.ResourceVersion = "0"
+}
+
+func parseEndpoint(endpoint string) (string, string, error) {
+	u, err := url.Parse(endpoint)
+	if err != nil {
+		return "", "", err
+	}
+
+	if u.Scheme == "tcp" {
+		return "tcp", u.Host, nil
+	} else if u.Scheme == "unix" {
+		return "unix", u.Path, nil
+	} else if u.Scheme == "" {
+		return "", "", fmt.Errorf("Using %q as endpoint is deprecated, please consider using full url format", endpoint)
+	} else {
+		return u.Scheme, "", fmt.Errorf("protocol %q not supported", u.Scheme)
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubelet/util/util_test.go

@@ -0,0 +1,64 @@
+/*
+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 util
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestParseEndpoint(t *testing.T) {
+	tests := []struct {
+		endpoint         string
+		expectError      bool
+		expectedProtocol string
+		expectedAddr     string
+	}{
+		{
+			endpoint:         "unix:///tmp/s1.sock",
+			expectedProtocol: "unix",
+			expectedAddr:     "/tmp/s1.sock",
+		},
+		{
+			endpoint:         "tcp://localhost:15880",
+			expectedProtocol: "tcp",
+			expectedAddr:     "localhost:15880",
+		},
+		{
+			endpoint:         "tcp1://abc",
+			expectedProtocol: "tcp1",
+			expectError:      true,
+		},
+		{
+			endpoint:    "a b c",
+			expectError: true,
+		},
+	}
+
+	for _, test := range tests {
+		protocol, addr, err := parseEndpoint(test.endpoint)
+		assert.Equal(t, test.expectedProtocol, protocol)
+		if test.expectError {
+			assert.NotNil(t, err, "Expect error during parsing %q", test.endpoint)
+			continue
+		}
+		assert.Nil(t, err, "Expect no error during parsing %q", test.endpoint)
+		assert.Equal(t, test.expectedAddr, addr)
+	}
+
+}

vendor/k8s.io/kubernetes/pkg/kubelet/util/util_unix.go

@@ -0,0 +1,79 @@
+// +build freebsd linux darwin
+
+/*
+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 util
+
+import (
+	"fmt"
+	"net"
+	"os"
+	"time"
+
+	"github.com/golang/glog"
+	"golang.org/x/sys/unix"
+)
+
+const (
+	// unixProtocol is the network protocol of unix socket.
+	unixProtocol = "unix"
+)
+
+func CreateListener(endpoint string) (net.Listener, error) {
+	protocol, addr, err := parseEndpointWithFallbackProtocol(endpoint, unixProtocol)
+	if err != nil {
+		return nil, err
+	}
+	if protocol != unixProtocol {
+		return nil, fmt.Errorf("only support unix socket endpoint")
+	}
+
+	// Unlink to cleanup the previous socket file.
+	err = unix.Unlink(addr)
+	if err != nil && !os.IsNotExist(err) {
+		return nil, fmt.Errorf("failed to unlink socket file %q: %v", addr, err)
+	}
+
+	return net.Listen(protocol, addr)
+}
+
+func GetAddressAndDialer(endpoint string) (string, func(addr string, timeout time.Duration) (net.Conn, error), error) {
+	protocol, addr, err := parseEndpointWithFallbackProtocol(endpoint, unixProtocol)
+	if err != nil {
+		return "", nil, err
+	}
+	if protocol != unixProtocol {
+		return "", nil, fmt.Errorf("only support unix socket endpoint")
+	}
+
+	return addr, dial, nil
+}
+
+func dial(addr string, timeout time.Duration) (net.Conn, error) {
+	return net.DialTimeout(unixProtocol, addr, timeout)
+}
+
+func parseEndpointWithFallbackProtocol(endpoint string, fallbackProtocol string) (protocol string, addr string, err error) {
+	if protocol, addr, err = parseEndpoint(endpoint); err != nil && protocol == "" {
+		fallbackEndpoint := fallbackProtocol + "://" + endpoint
+		protocol, addr, err = parseEndpoint(fallbackEndpoint)
+		if err == nil {
+			glog.Warningf("Using %q as endpoint is deprecated, please consider using full url format %q.", endpoint, fallbackEndpoint)
+		}
+	}
+	return
+}

vendor/k8s.io/kubernetes/pkg/kubelet/util/util_unsupported.go

@@ -0,0 +1,33 @@
+// +build !freebsd,!linux,!windows,!darwin
+
+/*
+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 util
+
+import (
+	"fmt"
+	"net"
+	"time"
+)
+
+func CreateListener(endpoint string) (net.Listener, error) {
+	return nil, fmt.Errorf("CreateListener is unsupported in this build")
+}
+
+func GetAddressAndDialer(endpoint string) (string, func(addr string, timeout time.Duration) (net.Conn, error), error) {
+	return "", nil, fmt.Errorf("GetAddressAndDialer is unsupported in this build")
+}

vendor/k8s.io/kubernetes/pkg/kubelet/util/util_windows.go

@@ -0,0 +1,57 @@
+// +build windows
+
+/*
+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 util
+
+import (
+	"fmt"
+	"net"
+	"time"
+)
+
+const (
+	tcpProtocol = "tcp"
+)
+
+func CreateListener(endpoint string) (net.Listener, error) {
+	protocol, addr, err := parseEndpoint(endpoint)
+	if err != nil {
+		return nil, err
+	}
+	if protocol != tcpProtocol {
+		return nil, fmt.Errorf("only support tcp endpoint")
+	}
+
+	return net.Listen(protocol, addr)
+}
+
+func GetAddressAndDialer(endpoint string) (string, func(addr string, timeout time.Duration) (net.Conn, error), error) {
+	protocol, addr, err := parseEndpoint(endpoint)
+	if err != nil {
+		return "", nil, err
+	}
+	if protocol != tcpProtocol {
+		return "", nil, fmt.Errorf("only support tcp endpoint")
+	}
+
+	return addr, dial, nil
+}
+
+func dial(addr string, timeout time.Duration) (net.Conn, error) {
+	return net.DialTimeout(tcpProtocol, addr, timeout)
+}