Bumping k8s dependencies to 1.13

vendor/k8s.io/kubernetes/pkg/controller/volume/attachdetach/metrics/BUILD

@@ -0,0 +1,50 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["metrics.go"],
+    importpath = "k8s.io/kubernetes/pkg/controller/volume/attachdetach/metrics",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//pkg/controller/volume/attachdetach/cache:go_default_library",
+        "//pkg/controller/volume/attachdetach/util:go_default_library",
+        "//pkg/volume:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/labels:go_default_library",
+        "//staging/src/k8s.io/client-go/listers/core/v1:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/github.com/prometheus/client_golang/prometheus:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["metrics_test.go"],
+    embed = [":go_default_library"],
+    deps = [
+        "//pkg/controller:go_default_library",
+        "//pkg/controller/volume/attachdetach/cache:go_default_library",
+        "//pkg/controller/volume/attachdetach/testing:go_default_library",
+        "//pkg/volume/testing:go_default_library",
+        "//pkg/volume/util/types:go_default_library",
+        "//staging/src/k8s.io/api/core/v1:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//staging/src/k8s.io/client-go/informers:go_default_library",
+        "//staging/src/k8s.io/client-go/kubernetes/fake: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/controller/volume/attachdetach/metrics/metrics.go

@@ -0,0 +1,201 @@
+/*
+Copyright 2018 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 metrics
+
+import (
+	"sync"
+
+	"github.com/golang/glog"
+	"github.com/prometheus/client_golang/prometheus"
+	"k8s.io/apimachinery/pkg/labels"
+	corelisters "k8s.io/client-go/listers/core/v1"
+	"k8s.io/kubernetes/pkg/controller/volume/attachdetach/cache"
+	"k8s.io/kubernetes/pkg/controller/volume/attachdetach/util"
+	"k8s.io/kubernetes/pkg/volume"
+)
+
+const pluginNameNotAvailable = "N/A"
+
+var (
+	inUseVolumeMetricDesc = prometheus.NewDesc(
+		prometheus.BuildFQName("", "storage_count", "attachable_volumes_in_use"),
+		"Measure number of volumes in use",
+		[]string{"node", "volume_plugin"}, nil)
+
+	totalVolumesMetricDesc = prometheus.NewDesc(
+		prometheus.BuildFQName("", "attachdetach_controller", "total_volumes"),
+		"Number of volumes in A/D Controller",
+		[]string{"plugin_name", "state"}, nil)
+
+	forcedDetachMetricCounter = prometheus.NewCounter(
+		prometheus.CounterOpts{
+			Name: "attachdetach_controller_forced_detaches",
+			Help: "Number of times the A/D Controller performed a forced detach"})
+)
+var registerMetrics sync.Once
+
+// Register registers metrics in A/D Controller.
+func Register(pvcLister corelisters.PersistentVolumeClaimLister,
+	pvLister corelisters.PersistentVolumeLister,
+	podLister corelisters.PodLister,
+	asw cache.ActualStateOfWorld,
+	dsw cache.DesiredStateOfWorld,
+	pluginMgr *volume.VolumePluginMgr) {
+	registerMetrics.Do(func() {
+		prometheus.MustRegister(newAttachDetachStateCollector(pvcLister,
+			podLister,
+			pvLister,
+			asw,
+			dsw,
+			pluginMgr))
+		prometheus.MustRegister(forcedDetachMetricCounter)
+	})
+}
+
+type attachDetachStateCollector struct {
+	pvcLister       corelisters.PersistentVolumeClaimLister
+	podLister       corelisters.PodLister
+	pvLister        corelisters.PersistentVolumeLister
+	asw             cache.ActualStateOfWorld
+	dsw             cache.DesiredStateOfWorld
+	volumePluginMgr *volume.VolumePluginMgr
+}
+
+// volumeCount is a map of maps used as a counter, e.g.:
+//     node 172.168.1.100.ec2.internal has 10 EBS and 3 glusterfs PVC in use:
+//     {"172.168.1.100.ec2.internal": {"aws-ebs": 10, "glusterfs": 3}}
+//     state actual_state_of_world contains a total of 10 EBS volumes:
+//     {"actual_state_of_world": {"aws-ebs": 10}}
+type volumeCount map[string]map[string]int64
+
+func (v volumeCount) add(typeKey, counterKey string) {
+	count, ok := v[typeKey]
+	if !ok {
+		count = map[string]int64{}
+	}
+	count[counterKey]++
+	v[typeKey] = count
+}
+
+func newAttachDetachStateCollector(
+	pvcLister corelisters.PersistentVolumeClaimLister,
+	podLister corelisters.PodLister,
+	pvLister corelisters.PersistentVolumeLister,
+	asw cache.ActualStateOfWorld,
+	dsw cache.DesiredStateOfWorld,
+	pluginMgr *volume.VolumePluginMgr) *attachDetachStateCollector {
+	return &attachDetachStateCollector{pvcLister, podLister, pvLister, asw, dsw, pluginMgr}
+}
+
+// Check if our collector implements necessary collector interface
+var _ prometheus.Collector = &attachDetachStateCollector{}
+
+func (collector *attachDetachStateCollector) Describe(ch chan<- *prometheus.Desc) {
+	ch <- inUseVolumeMetricDesc
+	ch <- totalVolumesMetricDesc
+}
+
+func (collector *attachDetachStateCollector) Collect(ch chan<- prometheus.Metric) {
+	nodeVolumeMap := collector.getVolumeInUseCount()
+	for nodeName, pluginCount := range nodeVolumeMap {
+		for pluginName, count := range pluginCount {
+			metric, err := prometheus.NewConstMetric(inUseVolumeMetricDesc,
+				prometheus.GaugeValue,
+				float64(count),
+				string(nodeName),
+				pluginName)
+			if err != nil {
+				glog.Warningf("Failed to create metric : %v", err)
+			}
+			ch <- metric
+		}
+	}
+
+	stateVolumeMap := collector.getTotalVolumesCount()
+	for stateName, pluginCount := range stateVolumeMap {
+		for pluginName, count := range pluginCount {
+			metric, err := prometheus.NewConstMetric(totalVolumesMetricDesc,
+				prometheus.GaugeValue,
+				float64(count),
+				pluginName,
+				string(stateName))
+			if err != nil {
+				glog.Warningf("Failed to create metric : %v", err)
+			}
+			ch <- metric
+		}
+	}
+}
+
+func (collector *attachDetachStateCollector) getVolumeInUseCount() volumeCount {
+	pods, err := collector.podLister.List(labels.Everything())
+	if err != nil {
+		glog.Errorf("Error getting pod list")
+		return nil
+	}
+
+	nodeVolumeMap := make(volumeCount)
+	for _, pod := range pods {
+		if len(pod.Spec.Volumes) <= 0 {
+			continue
+		}
+
+		if pod.Spec.NodeName == "" {
+			continue
+		}
+		for _, podVolume := range pod.Spec.Volumes {
+			volumeSpec, err := util.CreateVolumeSpec(podVolume, pod.Namespace, collector.pvcLister, collector.pvLister)
+			if err != nil {
+				continue
+			}
+			volumePlugin, err := collector.volumePluginMgr.FindPluginBySpec(volumeSpec)
+			if err != nil {
+				continue
+			}
+			nodeVolumeMap.add(pod.Spec.NodeName, volumePlugin.GetPluginName())
+		}
+	}
+	return nodeVolumeMap
+}
+
+func (collector *attachDetachStateCollector) getTotalVolumesCount() volumeCount {
+	stateVolumeMap := make(volumeCount)
+	for _, v := range collector.dsw.GetVolumesToAttach() {
+		if plugin, err := collector.volumePluginMgr.FindPluginBySpec(v.VolumeSpec); err == nil {
+			pluginName := pluginNameNotAvailable
+			if plugin != nil {
+				pluginName = plugin.GetPluginName()
+			}
+			stateVolumeMap.add("desired_state_of_world", pluginName)
+		}
+	}
+	for _, v := range collector.asw.GetAttachedVolumes() {
+		if plugin, err := collector.volumePluginMgr.FindPluginBySpec(v.VolumeSpec); err == nil {
+			pluginName := pluginNameNotAvailable
+			if plugin != nil {
+				pluginName = plugin.GetPluginName()
+			}
+			stateVolumeMap.add("actual_state_of_world", pluginName)
+		}
+	}
+	return stateVolumeMap
+}
+
+// RecordForcedDetachMetric register a forced detach metric.
+func RecordForcedDetachMetric() {
+	forcedDetachMetricCounter.Inc()
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/attachdetach/metrics/metrics_test.go

@@ -0,0 +1,180 @@
+/*
+Copyright 2018 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 metrics
+
+import (
+	"testing"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	k8stypes "k8s.io/apimachinery/pkg/types"
+	"k8s.io/client-go/informers"
+	"k8s.io/client-go/kubernetes/fake"
+	"k8s.io/kubernetes/pkg/controller"
+	"k8s.io/kubernetes/pkg/controller/volume/attachdetach/cache"
+	controllervolumetesting "k8s.io/kubernetes/pkg/controller/volume/attachdetach/testing"
+	volumetesting "k8s.io/kubernetes/pkg/volume/testing"
+	"k8s.io/kubernetes/pkg/volume/util/types"
+)
+
+func TestVolumesInUseMetricCollection(t *testing.T) {
+	fakeVolumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
+	fakeClient := &fake.Clientset{}
+
+	fakeInformerFactory := informers.NewSharedInformerFactory(fakeClient, controller.NoResyncPeriodFunc())
+	fakePodInformer := fakeInformerFactory.Core().V1().Pods()
+	pod := &v1.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "metric-test-pod",
+			UID:       "metric-test-pod-uid",
+			Namespace: "metric-test",
+		},
+		Spec: v1.PodSpec{
+			NodeName: "metric-test-host",
+			Volumes: []v1.Volume{
+				{
+					Name: "metric-test-volume-name",
+					VolumeSource: v1.VolumeSource{
+						PersistentVolumeClaim: &v1.PersistentVolumeClaimVolumeSource{
+							ClaimName: "metric-test-pvc",
+						},
+					},
+				},
+			},
+		},
+		Status: v1.PodStatus{
+			Phase: v1.PodPhase("Running"),
+		},
+	}
+
+	fakePodInformer.Informer().GetStore().Add(pod)
+	pvcInformer := fakeInformerFactory.Core().V1().PersistentVolumeClaims()
+	pvInformer := fakeInformerFactory.Core().V1().PersistentVolumes()
+
+	pvc := &v1.PersistentVolumeClaim{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "metric-test-pvc",
+			Namespace: "metric-test",
+			UID:       "metric-test-pvc-1",
+		},
+		Spec: v1.PersistentVolumeClaimSpec{
+			AccessModes: []v1.PersistentVolumeAccessMode{v1.ReadOnlyMany, v1.ReadWriteOnce},
+			Resources: v1.ResourceRequirements{
+				Requests: v1.ResourceList{
+					v1.ResourceName(v1.ResourceStorage): resource.MustParse("2G"),
+				},
+			},
+			VolumeName: "test-metric-pv-1",
+		},
+		Status: v1.PersistentVolumeClaimStatus{
+			Phase: v1.ClaimBound,
+		},
+	}
+	pv := &v1.PersistentVolume{
+		ObjectMeta: metav1.ObjectMeta{
+			UID:  "test-metric-pv-1",
+			Name: "test-metric-pv-1",
+		},
+		Spec: v1.PersistentVolumeSpec{
+			Capacity: v1.ResourceList{
+				v1.ResourceName(v1.ResourceStorage): resource.MustParse("5G"),
+			},
+			PersistentVolumeSource: v1.PersistentVolumeSource{
+				GCEPersistentDisk: &v1.GCEPersistentDiskVolumeSource{},
+			},
+			AccessModes: []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce, v1.ReadOnlyMany},
+			// this one we're pretending is already bound
+			ClaimRef: &v1.ObjectReference{UID: "metric-test-pvc-1", Namespace: "metric-test"},
+		},
+	}
+	pvcInformer.Informer().GetStore().Add(pvc)
+	pvInformer.Informer().GetStore().Add(pv)
+	pvcLister := pvcInformer.Lister()
+	pvLister := pvInformer.Lister()
+
+	metricCollector := newAttachDetachStateCollector(
+		pvcLister,
+		fakePodInformer.Lister(),
+		pvLister,
+		nil,
+		nil,
+		fakeVolumePluginMgr)
+	nodeUseMap := metricCollector.getVolumeInUseCount()
+	if len(nodeUseMap) < 1 {
+		t.Errorf("Expected one volume in use got %d", len(nodeUseMap))
+	}
+	testNodeMetric := nodeUseMap["metric-test-host"]
+	pluginUseCount, ok := testNodeMetric["fake-plugin"]
+	if !ok {
+		t.Errorf("Expected fake plugin pvc got nothing")
+	}
+
+	if pluginUseCount < 1 {
+		t.Errorf("Expected at least in-use volume metric got %d", pluginUseCount)
+	}
+}
+
+func TestTotalVolumesMetricCollection(t *testing.T) {
+	fakeVolumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
+	dsw := cache.NewDesiredStateOfWorld(fakeVolumePluginMgr)
+	asw := cache.NewActualStateOfWorld(fakeVolumePluginMgr)
+	podName := "pod-uid"
+	volumeName := v1.UniqueVolumeName("volume-name")
+	volumeSpec := controllervolumetesting.GetTestVolumeSpec(string(volumeName), volumeName)
+	nodeName := k8stypes.NodeName("node-name")
+
+	dsw.AddNode(nodeName, false)
+	_, err := dsw.AddPod(types.UniquePodName(podName), controllervolumetesting.NewPod(podName, podName), volumeSpec, nodeName)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+	asw.AddVolumeNode(volumeName, volumeSpec, nodeName, "")
+
+	metricCollector := newAttachDetachStateCollector(
+		nil,
+		nil,
+		nil,
+		asw,
+		dsw,
+		fakeVolumePluginMgr)
+
+	totalVolumesMap := metricCollector.getTotalVolumesCount()
+	if len(totalVolumesMap) != 2 {
+		t.Errorf("Expected 2 states, got %d", len(totalVolumesMap))
+	}
+
+	dswCount, ok := totalVolumesMap["desired_state_of_world"]
+	if !ok {
+		t.Errorf("Expected desired_state_of_world, got nothing")
+	}
+
+	fakePluginCount := dswCount["fake-plugin"]
+	if fakePluginCount != 1 {
+		t.Errorf("Expected 1 fake-plugin volume in DesiredStateOfWorld, got %d", fakePluginCount)
+	}
+
+	aswCount, ok := totalVolumesMap["actual_state_of_world"]
+	if !ok {
+		t.Errorf("Expected actual_state_of_world, got nothing")
+	}
+
+	fakePluginCount = aswCount["fake-plugin"]
+	if fakePluginCount != 1 {
+		t.Errorf("Expected 1 fake-plugin volume in ActualStateOfWorld, got %d", fakePluginCount)
+	}
+}