vendor files

vendor/k8s.io/kubernetes/pkg/kubelet/prober/results/BUILD

@@ -0,0 +1,45 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["results_manager.go"],
+    importpath = "k8s.io/kubernetes/pkg/kubelet/prober/results",
+    deps = [
+        "//pkg/kubelet/container:go_default_library",
+        "//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 = ["results_manager_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/kubelet/prober/results",
+    library = ":go_default_library",
+    deps = [
+        "//pkg/kubelet/container: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/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/wait: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/prober/results/results_manager.go

@@ -0,0 +1,121 @@
+/*
+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 results
+
+import (
+	"sync"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/types"
+	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
+)
+
+// Manager provides a probe results cache and channel of updates.
+type Manager interface {
+	// Get returns the cached result for the container with the given ID.
+	Get(kubecontainer.ContainerID) (Result, bool)
+	// Set sets the cached result for the container with the given ID.
+	// The pod is only included to be sent with the update.
+	Set(kubecontainer.ContainerID, Result, *v1.Pod)
+	// Remove clears the cached result for the container with the given ID.
+	Remove(kubecontainer.ContainerID)
+	// Updates creates a channel that receives an Update whenever its result changes (but not
+	// removed).
+	// NOTE: The current implementation only supports a single updates channel.
+	Updates() <-chan Update
+}
+
+// Result is the type for probe results.
+type Result bool
+
+const (
+	Success Result = true
+	Failure Result = false
+)
+
+func (r Result) String() string {
+	switch r {
+	case Success:
+		return "Success"
+	case Failure:
+		return "Failure"
+	default:
+		return "UNKNOWN"
+	}
+}
+
+// Update is an enum of the types of updates sent over the Updates channel.
+type Update struct {
+	ContainerID kubecontainer.ContainerID
+	Result      Result
+	PodUID      types.UID
+}
+
+// Manager implementation.
+type manager struct {
+	// guards the cache
+	sync.RWMutex
+	// map of container ID -> probe Result
+	cache map[kubecontainer.ContainerID]Result
+	// channel of updates
+	updates chan Update
+}
+
+var _ Manager = &manager{}
+
+// NewManager creates ane returns an empty results manager.
+func NewManager() Manager {
+	return &manager{
+		cache:   make(map[kubecontainer.ContainerID]Result),
+		updates: make(chan Update, 20),
+	}
+}
+
+func (m *manager) Get(id kubecontainer.ContainerID) (Result, bool) {
+	m.RLock()
+	defer m.RUnlock()
+	result, found := m.cache[id]
+	return result, found
+}
+
+func (m *manager) Set(id kubecontainer.ContainerID, result Result, pod *v1.Pod) {
+	if m.setInternal(id, result) {
+		m.updates <- Update{id, result, pod.UID}
+	}
+}
+
+// Internal helper for locked portion of set. Returns whether an update should be sent.
+func (m *manager) setInternal(id kubecontainer.ContainerID, result Result) bool {
+	m.Lock()
+	defer m.Unlock()
+	prev, exists := m.cache[id]
+	if !exists || prev != result {
+		m.cache[id] = result
+		return true
+	}
+	return false
+}
+
+func (m *manager) Remove(id kubecontainer.ContainerID) {
+	m.Lock()
+	defer m.Unlock()
+	delete(m.cache, id)
+}
+
+func (m *manager) Updates() <-chan Update {
+	return m.updates
+}

vendor/k8s.io/kubernetes/pkg/kubelet/prober/results/results_manager_test.go

@@ -0,0 +1,99 @@
+/*
+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 results
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/wait"
+	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
+)
+
+func TestCacheOperations(t *testing.T) {
+	m := NewManager()
+
+	unsetID := kubecontainer.ContainerID{Type: "test", ID: "unset"}
+	setID := kubecontainer.ContainerID{Type: "test", ID: "set"}
+
+	_, found := m.Get(unsetID)
+	assert.False(t, found, "unset result found")
+
+	m.Set(setID, Success, &v1.Pod{})
+	result, found := m.Get(setID)
+	assert.True(t, result == Success, "set result")
+	assert.True(t, found, "set result found")
+
+	m.Remove(setID)
+	_, found = m.Get(setID)
+	assert.False(t, found, "removed result found")
+}
+
+func TestUpdates(t *testing.T) {
+	m := NewManager()
+
+	pod := &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "test-pod"}}
+	fooID := kubecontainer.ContainerID{Type: "test", ID: "foo"}
+	barID := kubecontainer.ContainerID{Type: "test", ID: "bar"}
+
+	expectUpdate := func(expected Update, msg string) {
+		select {
+		case u := <-m.Updates():
+			if expected != u {
+				t.Errorf("Expected update %v, received %v: %s", expected, u, msg)
+			}
+		case <-time.After(wait.ForeverTestTimeout):
+			t.Errorf("Timed out waiting for update %v: %s", expected, msg)
+		}
+	}
+
+	expectNoUpdate := func(msg string) {
+		// NOTE: Since updates are accumulated asynchronously, this method is not guaranteed to fail
+		// when it should. In the event it misses a failure, the following calls to expectUpdate should
+		// still fail.
+		select {
+		case u := <-m.Updates():
+			t.Errorf("Unexpected update %v: %s", u, msg)
+		default:
+			// Pass
+		}
+	}
+
+	// New result should always push an update.
+	m.Set(fooID, Success, pod)
+	expectUpdate(Update{fooID, Success, pod.UID}, "new success")
+
+	m.Set(barID, Failure, pod)
+	expectUpdate(Update{barID, Failure, pod.UID}, "new failure")
+
+	// Unchanged results should not send an update.
+	m.Set(fooID, Success, pod)
+	expectNoUpdate("unchanged foo")
+
+	m.Set(barID, Failure, pod)
+	expectNoUpdate("unchanged bar")
+
+	// Changed results should send an update.
+	m.Set(fooID, Failure, pod)
+	expectUpdate(Update{fooID, Failure, pod.UID}, "changed foo")
+
+	m.Set(barID, Success, pod)
+	expectUpdate(Update{barID, Success, pod.UID}, "changed bar")
+}