Move stats summary types to a new kubelet/api package to avoid unnecessary dependencies

pkg/kubelet/server/stats/fs_resource_analyzer.go

@@ -21,6 +21,7 @@ import (
 	"time"
 
 	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/stats"
 	"k8s.io/kubernetes/pkg/kubelet/metrics"
 	"k8s.io/kubernetes/pkg/kubelet/util/format"
 	"k8s.io/kubernetes/pkg/types"
@@ -36,7 +37,7 @@ type Cache map[types.UID]*PodVolumeStats
 
 // PodVolumeStats encapsulates all VolumeStats for a pod
 type PodVolumeStats struct {
-	Volumes []VolumeStats
+	Volumes []stats.VolumeStats
 }
 
 // fsResourceAnalyzerInterface is for embedding fs functions into ResourceAnalyzer
@@ -107,7 +108,7 @@ func (s *fsResourceAnalyzer) getPodVolumeStats(pod *api.Pod) (PodVolumeStats, bo
 	}
 
 	// Call GetMetrics on each Volume and copy the result to a new VolumeStats.FsStats
-	stats := make([]VolumeStats, 0, len(volumes))
+	stats := make([]stats.VolumeStats, 0, len(volumes))
 	for name, v := range volumes {
 		metric, err := v.GetMetrics()
 		if err != nil {
@@ -123,13 +124,13 @@ func (s *fsResourceAnalyzer) getPodVolumeStats(pod *api.Pod) (PodVolumeStats, bo
 	return PodVolumeStats{Volumes: stats}, true
 }
 
-func (s *fsResourceAnalyzer) parsePodVolumeStats(podName string, metric *volume.Metrics) VolumeStats {
+func (s *fsResourceAnalyzer) parsePodVolumeStats(podName string, metric *volume.Metrics) stats.VolumeStats {
 	available := uint64(metric.Available.Value())
 	capacity := uint64(metric.Capacity.Value())
 	used := uint64((metric.Used.Value()))
-	return VolumeStats{
+	return stats.VolumeStats{
 		Name: podName,
-		FsStats: FsStats{
+		FsStats: stats.FsStats{
 			AvailableBytes: &available,
 			CapacityBytes:  &capacity,
 			UsedBytes:      &used}}

pkg/kubelet/server/stats/fs_resource_analyzer_test.go

@@ -23,6 +23,7 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/resource"
+	"k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/stats"
 	"k8s.io/kubernetes/pkg/types"
 	"k8s.io/kubernetes/pkg/volume"
 
@@ -32,34 +33,34 @@ import (
 // TestGetPodVolumeStats tests that GetPodVolumeStats reads from the cache and returns the value
 func TestGetPodVolumeStats(t *testing.T) {
 	instance := newFsResourceAnalyzer(&MockStatsProvider{}, time.Minute*5)
-	stats, found := instance.GetPodVolumeStats("testpod1")
+	vStats, found := instance.GetPodVolumeStats("testpod1")
 	assert.False(t, found)
-	assert.Equal(t, PodVolumeStats{}, stats)
+	assert.Equal(t, PodVolumeStats{}, vStats)
 
 	instance.cachedVolumeStats.Store(make(Cache))
-	stats, found = instance.GetPodVolumeStats("testpod1")
+	vStats, found = instance.GetPodVolumeStats("testpod1")
 	assert.False(t, found)
-	assert.Equal(t, PodVolumeStats{}, stats)
+	assert.Equal(t, PodVolumeStats{}, vStats)
 
 	available := uint64(100)
 	used := uint64(200)
 	capacity := uint64(400)
-	vs1 := VolumeStats{
+	vs1 := stats.VolumeStats{
 		Name: "vol1",
-		FsStats: FsStats{
+		FsStats: stats.FsStats{
 			AvailableBytes: &available,
 			UsedBytes:      &used,
 			CapacityBytes:  &capacity,
 		},
 	}
 	pvs := &PodVolumeStats{
-		Volumes: []VolumeStats{vs1},
+		Volumes: []stats.VolumeStats{vs1},
 	}
 
 	instance.cachedVolumeStats.Load().(Cache)["testpod1"] = pvs
-	stats, found = instance.GetPodVolumeStats("testpod1")
+	vStats, found = instance.GetPodVolumeStats("testpod1")
 	assert.True(t, found)
-	assert.Equal(t, *pvs, stats)
+	assert.Equal(t, *pvs, vStats)
 }
 
 // TestUpdateCachedPodVolumeStats tests that the cache is updated from the stats provider
@@ -120,9 +121,9 @@ func TestUpdateCachedPodVolumeStats(t *testing.T) {
 	v1available := uint64(100)
 	v1used := uint64(200)
 	v1capacity := uint64(400)
-	assert.Contains(t, actual1.Volumes, VolumeStats{
+	assert.Contains(t, actual1.Volumes, stats.VolumeStats{
 		Name: "v1",
-		FsStats: FsStats{
+		FsStats: stats.FsStats{
 			AvailableBytes: &v1available,
 			UsedBytes:      &v1used,
 			CapacityBytes:  &v1capacity,
@@ -132,9 +133,9 @@ func TestUpdateCachedPodVolumeStats(t *testing.T) {
 	v2available := uint64(600)
 	v2used := uint64(700)
 	v2capacity := uint64(1400)
-	assert.Contains(t, actual1.Volumes, VolumeStats{
+	assert.Contains(t, actual1.Volumes, stats.VolumeStats{
 		Name: "v2",
-		FsStats: FsStats{
+		FsStats: stats.FsStats{
 			AvailableBytes: &v2available,
 			UsedBytes:      &v2used,
 			CapacityBytes:  &v2capacity,
@@ -147,9 +148,9 @@ func TestUpdateCachedPodVolumeStats(t *testing.T) {
 	actual2, found := instance.GetPodVolumeStats("testpod2")
 	assert.True(t, found)
 	assert.Len(t, actual2.Volumes, 1)
-	assert.Contains(t, actual2.Volumes, VolumeStats{
+	assert.Contains(t, actual2.Volumes, stats.VolumeStats{
 		Name: "v3",
-		FsStats: FsStats{
+		FsStats: stats.FsStats{
 			AvailableBytes: &v3available,
 			UsedBytes:      &v3used,
 			CapacityBytes:  &v3capacity,

pkg/kubelet/server/stats/summary_test.go

@@ -27,6 +27,7 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	kubestats "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/stats"
 	"k8s.io/kubernetes/pkg/kubelet/cm"
 	"k8s.io/kubernetes/pkg/kubelet/leaky"
 )
@@ -87,9 +88,9 @@ func TestBuildSummary(t *testing.T) {
 		cName20 = "c1" // ensure cName20 conflicts with cName01, but is in a different pod + namespace
 	)
 
-	prf0 := PodReference{Name: pName0, Namespace: namespace0, UID: "UID" + pName0}
-	prf1 := PodReference{Name: pName1, Namespace: namespace0, UID: "UID" + pName1}
-	prf2 := PodReference{Name: pName2, Namespace: namespace2, UID: "UID" + pName2}
+	prf0 := kubestats.PodReference{Name: pName0, Namespace: namespace0, UID: "UID" + pName0}
+	prf1 := kubestats.PodReference{Name: pName1, Namespace: namespace0, UID: "UID" + pName1}
+	prf2 := kubestats.PodReference{Name: pName2, Namespace: namespace2, UID: "UID" + pName2}
 	infos := map[string]v2.ContainerInfo{
 		"/":              summaryTestContainerInfo(seedRoot, "", "", ""),
 		"/docker-daemon": summaryTestContainerInfo(seedRuntime, "", "", ""),
@@ -123,9 +124,9 @@ func TestBuildSummary(t *testing.T) {
 	checkNetworkStats(t, "Node", seedRoot, nodeStats.Network)
 
 	systemSeeds := map[string]int{
-		SystemContainerRuntime: seedRuntime,
-		SystemContainerKubelet: seedKubelet,
-		SystemContainerMisc:    seedMisc,
+		kubestats.SystemContainerRuntime: seedRuntime,
+		kubestats.SystemContainerKubelet: seedKubelet,
+		kubestats.SystemContainerMisc:    seedMisc,
 	}
 	for _, sys := range nodeStats.SystemContainers {
 		name := sys.Name
@@ -139,7 +140,7 @@ func TestBuildSummary(t *testing.T) {
 	}
 
 	assert.Equal(t, 3, len(summary.Pods))
-	indexPods := make(map[PodReference]PodStats, len(summary.Pods))
+	indexPods := make(map[kubestats.PodReference]kubestats.PodStats, len(summary.Pods))
 	for _, pod := range summary.Pods {
 		indexPods[pod.PodRef] = pod
 	}
@@ -148,7 +149,7 @@ func TestBuildSummary(t *testing.T) {
 	ps, found := indexPods[prf0]
 	assert.True(t, found)
 	assert.Len(t, ps.Containers, 2)
-	indexCon := make(map[string]ContainerStats, len(ps.Containers))
+	indexCon := make(map[string]kubestats.ContainerStats, len(ps.Containers))
 	for _, con := range ps.Containers {
 		indexCon[con.Name] = con
 	}
@@ -284,7 +285,7 @@ func testTime(base time.Time, seed int) time.Time {
 	return base.Add(time.Duration(seed) * time.Second)
 }
 
-func checkNetworkStats(t *testing.T, label string, seed int, stats *NetworkStats) {
+func checkNetworkStats(t *testing.T, label string, seed int, stats *kubestats.NetworkStats) {
 	assert.EqualValues(t, testTime(timestamp, seed).Unix(), stats.Time.Time.Unix(), label+".Net.Time")
 	assert.EqualValues(t, seed+offsetNetRxBytes, *stats.RxBytes, label+".Net.RxBytes")
 	assert.EqualValues(t, seed+offsetNetRxErrors, *stats.RxErrors, label+".Net.RxErrors")
@@ -292,13 +293,13 @@ func checkNetworkStats(t *testing.T, label string, seed int, stats *NetworkStats
 	assert.EqualValues(t, seed+offsetNetTxErrors, *stats.TxErrors, label+".Net.TxErrors")
 }
 
-func checkCPUStats(t *testing.T, label string, seed int, stats *CPUStats) {
+func checkCPUStats(t *testing.T, label string, seed int, stats *kubestats.CPUStats) {
 	assert.EqualValues(t, testTime(timestamp, seed).Unix(), stats.Time.Time.Unix(), label+".CPU.Time")
 	assert.EqualValues(t, seed+offsetCPUUsageCores, *stats.UsageNanoCores, label+".CPU.UsageCores")
 	assert.EqualValues(t, seed+offsetCPUUsageCoreSeconds, *stats.UsageCoreNanoSeconds, label+".CPU.UsageCoreSeconds")
 }
 
-func checkMemoryStats(t *testing.T, label string, seed int, stats *MemoryStats) {
+func checkMemoryStats(t *testing.T, label string, seed int, stats *kubestats.MemoryStats) {
 	assert.EqualValues(t, testTime(timestamp, seed).Unix(), stats.Time.Time.Unix(), label+".Mem.Time")
 	assert.EqualValues(t, seed+offsetMemUsageBytes, *stats.UsageBytes, label+".Mem.UsageBytes")
 	assert.EqualValues(t, seed+offsetMemWorkingSetBytes, *stats.WorkingSetBytes, label+".Mem.WorkingSetBytes")
@@ -357,19 +358,19 @@ func TestCustomMetrics(t *testing.T) {
 	}
 	sb := &summaryBuilder{}
 	assert.Contains(t, sb.containerInfoV2ToUserDefinedMetrics(&cInfo),
-		UserDefinedMetric{
-			UserDefinedMetricDescriptor: UserDefinedMetricDescriptor{
+		kubestats.UserDefinedMetric{
+			UserDefinedMetricDescriptor: kubestats.UserDefinedMetricDescriptor{
 				Name:  "qos",
-				Type:  MetricGauge,
+				Type:  kubestats.MetricGauge,
 				Units: "per second",
 			},
 			Time:  unversioned.NewTime(timestamp2),
 			Value: 100,
 		},
-		UserDefinedMetric{
-			UserDefinedMetricDescriptor: UserDefinedMetricDescriptor{
+		kubestats.UserDefinedMetric{
+			UserDefinedMetricDescriptor: kubestats.UserDefinedMetricDescriptor{
 				Name:  "cpuLoad",
-				Type:  MetricCumulative,
+				Type:  kubestats.MetricCumulative,
 				Units: "count",
 			},
 			Time:  unversioned.NewTime(timestamp2),

test/e2e_node/kubelet_test.go

@@ -27,7 +27,7 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
-	"k8s.io/kubernetes/pkg/kubelet/server/stats"
+	"k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/stats"
 
 	"github.com/davecgh/go-spew/spew"
 	. "github.com/onsi/ginkgo"