Merge pull request #50932 from yguo0905/stats-cadvisor

hack/.golint_failures

@@ -279,6 +279,7 @@ pkg/kubelet/server/portforward
 pkg/kubelet/server/remotecommand
 pkg/kubelet/server/stats
 pkg/kubelet/server/streaming
+pkg/kubelet/stats
 pkg/kubelet/status
 pkg/kubelet/status/testing
 pkg/kubelet/sysctl

pkg/kubelet/BUILD

@@ -12,7 +12,6 @@ go_library(
         "active_deadline.go",
         "doc.go",
         "kubelet.go",
-        "kubelet_cadvisor.go",
         "kubelet_getters.go",
         "kubelet_network.go",
         "kubelet_node_status.go",
@@ -79,6 +78,7 @@ go_library(
         "//pkg/kubelet/server/remotecommand:go_default_library",
         "//pkg/kubelet/server/stats:go_default_library",
         "//pkg/kubelet/server/streaming:go_default_library",
+        "//pkg/kubelet/stats:go_default_library",
         "//pkg/kubelet/status:go_default_library",
         "//pkg/kubelet/sysctl:go_default_library",
         "//pkg/kubelet/types:go_default_library",
@@ -145,7 +145,6 @@ go_test(
     name = "go_default_test",
     srcs = [
         "active_deadline_test.go",
-        "kubelet_cadvisor_test.go",
         "kubelet_getters_test.go",
         "kubelet_network_test.go",
         "kubelet_node_status_test.go",
@@ -193,6 +192,7 @@ go_test(
         "//pkg/kubelet/server/portforward:go_default_library",
         "//pkg/kubelet/server/remotecommand:go_default_library",
         "//pkg/kubelet/server/stats:go_default_library",
+        "//pkg/kubelet/stats:go_default_library",
         "//pkg/kubelet/status:go_default_library",
         "//pkg/kubelet/status/testing:go_default_library",
         "//pkg/kubelet/types:go_default_library",
@@ -275,6 +275,7 @@ filegroup(
         "//pkg/kubelet/rktshim:all-srcs",
         "//pkg/kubelet/secret:all-srcs",
         "//pkg/kubelet/server:all-srcs",
+        "//pkg/kubelet/stats:all-srcs",
         "//pkg/kubelet/status:all-srcs",
         "//pkg/kubelet/sysctl:all-srcs",
         "//pkg/kubelet/types:all-srcs",

pkg/kubelet/container/BUILD

-package(default_visibility = ["//visibility:public"])
-
-load(
-    "@io_bazel_rules_go//go:def.bzl",
-    "go_library",
-    "go_test",
-)
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
@@ -27,6 +21,7 @@ go_library(
         ],
         "//conditions:default": [],
     }),
+    visibility = ["//visibility:public"],
     deps = [
         "//pkg/api:go_default_library",
         "//pkg/kubelet/apis/cri/v1alpha1/runtime:go_default_library",
@@ -96,4 +91,5 @@ filegroup(
         "//pkg/kubelet/container/testing:all-srcs",
     ],
     tags = ["automanaged"],
+    visibility = ["//visibility:public"],
 )

pkg/kubelet/container/testing/BUILD

-package(default_visibility = ["//visibility:public"])
-
-load(
-    "@io_bazel_rules_go//go:def.bzl",
-    "go_library",
-)
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
 
 go_library(
     name = "go_default_library",
@@ -11,10 +6,12 @@ go_library(
         "fake_cache.go",
         "fake_runtime.go",
         "fake_runtime_helper.go",
+        "mock_runtime_cache.go",
         "mockfileinfo.go",
         "os.go",
         "runtime_mock.go",
     ],
+    visibility = ["//visibility:public"],
     deps = [
         "//pkg/kubelet/container:go_default_library",
         "//pkg/volume:go_default_library",
@@ -38,4 +35,5 @@ filegroup(
     name = "all-srcs",
     srcs = [":package-srcs"],
     tags = ["automanaged"],
+    visibility = ["//visibility:public"],
 )

pkg/kubelet/container/testing/mock_runtime_cache.go

+/*
+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.
+*/
+
+// Code generated by mockery v1.0.0
+package testing
+
+import container "k8s.io/kubernetes/pkg/kubelet/container"
+import mock "github.com/stretchr/testify/mock"
+import time "time"
+
+// MockRuntimeCache is an autogenerated mock type for the RuntimeCache type
+type MockRuntimeCache struct {
+	mock.Mock
+}
+
+// ForceUpdateIfOlder provides a mock function with given fields: _a0
+func (_m *MockRuntimeCache) ForceUpdateIfOlder(_a0 time.Time) error {
+	ret := _m.Called(_a0)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(time.Time) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// GetPods provides a mock function with given fields:
+func (_m *MockRuntimeCache) GetPods() ([]*container.Pod, error) {
+	ret := _m.Called()
+
+	var r0 []*container.Pod
+	if rf, ok := ret.Get(0).(func() []*container.Pod); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*container.Pod)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}

pkg/kubelet/kubelet.go

@@ -88,8 +88,9 @@ import (
 	"k8s.io/kubernetes/pkg/kubelet/rkt"
 	"k8s.io/kubernetes/pkg/kubelet/secret"
 	"k8s.io/kubernetes/pkg/kubelet/server"
-	"k8s.io/kubernetes/pkg/kubelet/server/stats"
+	serverstats "k8s.io/kubernetes/pkg/kubelet/server/stats"
 	"k8s.io/kubernetes/pkg/kubelet/server/streaming"
+	"k8s.io/kubernetes/pkg/kubelet/stats"
 	"k8s.io/kubernetes/pkg/kubelet/status"
 	"k8s.io/kubernetes/pkg/kubelet/sysctl"
 	kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
@@ -560,6 +561,8 @@ func NewMainKubelet(kubeCfg *kubeletconfiginternal.KubeletConfiguration,
 		MTU:               int(crOptions.NetworkPluginMTU),
 	}
 
+	klet.resourceAnalyzer = serverstats.NewResourceAnalyzer(klet, kubeCfg.VolumeStatsAggPeriod.Duration)
+
 	// Remote runtime shim just cannot talk back to kubelet, so it doesn't
 	// support bandwidth shaping or hostports till #35457. To enable legacy
 	// features, replace with networkHost.
@@ -642,6 +645,12 @@ func NewMainKubelet(kubeCfg *kubeletconfiginternal.KubeletConfiguration,
 		}
 		klet.containerRuntime = runtime
 		klet.runner = runtime
+		klet.StatsProvider = stats.NewCadvisorStatsProvider(
+			klet.cadvisor,
+			klet.resourceAnalyzer,
+			klet.podManager,
+			klet.runtimeCache,
+			klet.containerRuntime)
 	} else {
 		// rkt uses the legacy, non-CRI, integration. Configure it the old way.
 		// TODO: Include hairpin mode settings in rkt?
@@ -674,11 +683,14 @@ func NewMainKubelet(kubeCfg *kubeletconfiginternal.KubeletConfiguration,
 		}
 		klet.containerRuntime = runtime
 		klet.runner = kubecontainer.DirectStreamingRunner(runtime)
+		klet.StatsProvider = stats.NewCadvisorStatsProvider(
+			klet.cadvisor,
+			klet.resourceAnalyzer,
+			klet.podManager,
+			klet.runtimeCache,
+			klet.containerRuntime)
 	}
 
-	// TODO: Factor out "StatsProvider" from Kubelet so we don't have a cyclic dependency
-	klet.resourceAnalyzer = stats.NewResourceAnalyzer(klet, kubeCfg.VolumeStatsAggPeriod.Duration, klet.containerRuntime)
-
 	klet.pleg = pleg.NewGenericPLEG(klet.containerRuntime, plegChannelCapacity, plegRelistPeriod, klet.podCache, clock.RealClock{})
 	klet.runtimeState = newRuntimeState(maxWaitForContainerRuntime)
 	klet.runtimeState.addHealthCheck("PLEG", klet.pleg.Healthy)
@@ -993,7 +1005,7 @@ type Kubelet struct {
 	oomWatcher OOMWatcher
 
 	// Monitor resource usage
-	resourceAnalyzer stats.ResourceAnalyzer
+	resourceAnalyzer serverstats.ResourceAnalyzer
 
 	// Whether or not we should have the QOS cgroup hierarchy for resource management
 	cgroupsPerQOS bool
@@ -1104,6 +1116,9 @@ type Kubelet struct {
 	// dockerLegacyService contains some legacy methods for backward compatibility.
 	// It should be set only when docker is using non json-file logging driver.
 	dockerLegacyService dockershim.DockerLegacyService
+
+	// StatsProvider provides the node and the container stats.
+	*stats.StatsProvider
 }
 
 func allLocalIPsWithoutLoopback() ([]net.IP, error) {

pkg/kubelet/kubelet_cadvisor.go

-/*
-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 kubelet
-
-import (
-	cadvisorapi "github.com/google/cadvisor/info/v1"
-	cadvisorapiv2 "github.com/google/cadvisor/info/v2"
-	"k8s.io/apimachinery/pkg/types"
-	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
-)
-
-// GetContainerInfo returns stats (from Cadvisor) for a container.
-func (kl *Kubelet) GetContainerInfo(podFullName string, podUID types.UID, containerName string, req *cadvisorapi.ContainerInfoRequest) (*cadvisorapi.ContainerInfo, error) {
-
-	// Resolve and type convert back again.
-	// We need the static pod UID but the kubecontainer API works with types.UID.
-	podUID = types.UID(kl.podManager.TranslatePodUID(podUID))
-
-	pods, err := kl.runtimeCache.GetPods()
-	if err != nil {
-		return nil, err
-	}
-	pod := kubecontainer.Pods(pods).FindPod(podFullName, podUID)
-	container := pod.FindContainerByName(containerName)
-	if container == nil {
-		return nil, kubecontainer.ErrContainerNotFound
-	}
-
-	ci, err := kl.cadvisor.DockerContainer(container.ID.ID, req)
-	if err != nil {
-		return nil, err
-	}
-	return &ci, nil
-}
-
-// GetContainerInfoV2 returns stats (from Cadvisor) for containers.
-func (kl *Kubelet) GetContainerInfoV2(name string, options cadvisorapiv2.RequestOptions) (map[string]cadvisorapiv2.ContainerInfo, error) {
-	return kl.cadvisor.ContainerInfoV2(name, options)
-}
-
-// ImagesFsInfo returns information about docker image fs usage from
-// cadvisor.
-func (kl *Kubelet) ImagesFsInfo() (cadvisorapiv2.FsInfo, error) {
-	return kl.cadvisor.ImagesFsInfo()
-}
-
-// RootFsInfo returns info about the root fs from cadvisor.
-func (kl *Kubelet) RootFsInfo() (cadvisorapiv2.FsInfo, error) {
-	return kl.cadvisor.RootFsInfo()
-}
-
-// GetRawContainerInfo returns stats (from Cadvisor) for a non-Kubernetes container.
-func (kl *Kubelet) GetRawContainerInfo(containerName string, req *cadvisorapi.ContainerInfoRequest, subcontainers bool) (map[string]*cadvisorapi.ContainerInfo, error) {
-	if subcontainers {
-		return kl.cadvisor.SubcontainerInfo(containerName, req)
-	}
-
-	containerInfo, err := kl.cadvisor.ContainerInfo(containerName, req)
-	if err != nil {
-		return nil, err
-	}
-	return map[string]*cadvisorapi.ContainerInfo{
-		containerInfo.Name: containerInfo,
-	}, nil
-}
-
-// GetVersionInfo returns information about the version of cAdvisor in use.
-func (kl *Kubelet) GetVersionInfo() (*cadvisorapi.VersionInfo, error) {
-	return kl.cadvisor.VersionInfo()
-}
-
-// GetCachedMachineInfo assumes that the machine info can't change without a reboot
-func (kl *Kubelet) GetCachedMachineInfo() (*cadvisorapi.MachineInfo, error) {
-	if kl.machineInfo == nil {
-		info, err := kl.cadvisor.MachineInfo()
-		if err != nil {
-			return nil, err
-		}
-		kl.machineInfo = info
-	}
-	return kl.machineInfo, nil
-}
-
-// GetCachedRootFsInfo assumes that the rootfs info can't change without a reboot
-func (kl *Kubelet) GetCachedRootFsInfo() (cadvisorapiv2.FsInfo, error) {
-	if kl.rootfsInfo == nil {
-		info, err := kl.cadvisor.RootFsInfo()
-		if err != nil {
-			return cadvisorapiv2.FsInfo{}, err
-		}
-		kl.rootfsInfo = &info
-	}
-	return *kl.rootfsInfo, nil
-}

pkg/kubelet/kubelet_cadvisor_test.go

-/*
-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 kubelet
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	cadvisorapi "github.com/google/cadvisor/info/v1"
-	"k8s.io/apimachinery/pkg/types"
-	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
-	kubecontainertest "k8s.io/kubernetes/pkg/kubelet/container/testing"
-)
-
-func TestGetContainerInfo(t *testing.T) {
-	cadvisorAPIFailure := fmt.Errorf("cAdvisor failure")
-	runtimeError := fmt.Errorf("List containers error")
-	tests := []struct {
-		name                      string
-		containerID               string
-		containerPath             string
-		cadvisorContainerInfo     cadvisorapi.ContainerInfo
-		runtimeError              error
-		podList                   []*kubecontainertest.FakePod
-		requestedPodFullName      string
-		requestedPodUID           types.UID
-		requestedContainerName    string
-		expectDockerContainerCall bool
-		mockError                 error
-		expectedError             error
-		expectStats               bool
-	}{
-		{
-			name:          "get container info",
-			containerID:   "ab2cdf",
-			containerPath: "/docker/ab2cdf",
-			cadvisorContainerInfo: cadvisorapi.ContainerInfo{
-				ContainerReference: cadvisorapi.ContainerReference{
-					Name: "/docker/ab2cdf",
-				},
-			},
-			runtimeError: nil,
-			podList: []*kubecontainertest.FakePod{
-				{
-					Pod: &kubecontainer.Pod{
-						ID:        "12345678",
-						Name:      "qux",
-						Namespace: "ns",
-						Containers: []*kubecontainer.Container{
-							{
-								Name: "foo",
-								ID:   kubecontainer.ContainerID{Type: "test", ID: "ab2cdf"},
-							},
-						},
-					},
-				},
-			},
-			requestedPodFullName:      "qux_ns",
-			requestedPodUID:           "",
-			requestedContainerName:    "foo",
-			expectDockerContainerCall: true,
-			mockError:                 nil,
-			expectedError:             nil,
-			expectStats:               true,
-		},
-		{
-			name:                  "get container info when cadvisor failed",
-			containerID:           "ab2cdf",
-			containerPath:         "/docker/ab2cdf",
-			cadvisorContainerInfo: cadvisorapi.ContainerInfo{},
-			runtimeError:          nil,
-			podList: []*kubecontainertest.FakePod{
-				{
-					Pod: &kubecontainer.Pod{
-						ID:        "uuid",
-						Name:      "qux",
-						Namespace: "ns",
-						Containers: []*kubecontainer.Container{
-							{
-								Name: "foo",
-								ID:   kubecontainer.ContainerID{Type: "test", ID: "ab2cdf"},
-							},
-						},
-					},
-				},
-			},
-			requestedPodFullName:      "qux_ns",
-			requestedPodUID:           "uuid",
-			requestedContainerName:    "foo",
-			expectDockerContainerCall: true,
-			mockError:                 cadvisorAPIFailure,
-			expectedError:             cadvisorAPIFailure,
-			expectStats:               false,
-		},
-		{
-			name:                      "get container info on non-existent container",
-			containerID:               "",
-			containerPath:             "",
-			cadvisorContainerInfo:     cadvisorapi.ContainerInfo{},
-			runtimeError:              nil,
-			podList:                   []*kubecontainertest.FakePod{},
-			requestedPodFullName:      "qux",
-			requestedPodUID:           "",
-			requestedContainerName:    "foo",
-			expectDockerContainerCall: false,
-			mockError:                 nil,
-			expectedError:             kubecontainer.ErrContainerNotFound,
-			expectStats:               false,
-		},
-		{
-			name:                   "get container info when container runtime failed",
-			containerID:            "",
-			containerPath:          "",
-			cadvisorContainerInfo:  cadvisorapi.ContainerInfo{},
-			runtimeError:           runtimeError,
-			podList:                []*kubecontainertest.FakePod{},
-			requestedPodFullName:   "qux",
-			requestedPodUID:        "",
-			requestedContainerName: "foo",
-			mockError:              nil,
-			expectedError:          runtimeError,
-			expectStats:            false,
-		},
-		{
-			name:                   "get container info with no containers",
-			containerID:            "",
-			containerPath:          "",
-			cadvisorContainerInfo:  cadvisorapi.ContainerInfo{},
-			runtimeError:           nil,
-			podList:                []*kubecontainertest.FakePod{},
-			requestedPodFullName:   "qux_ns",
-			requestedPodUID:        "",
-			requestedContainerName: "foo",
-			mockError:              nil,
-			expectedError:          kubecontainer.ErrContainerNotFound,
-			expectStats:            false,
-		},
-		{
-			name:                  "get container info with no matching containers",
-			containerID:           "",
-			containerPath:         "",
-			cadvisorContainerInfo: cadvisorapi.ContainerInfo{},
-			runtimeError:          nil,
-			podList: []*kubecontainertest.FakePod{
-				{
-					Pod: &kubecontainer.Pod{
-						ID:        "12345678",
-						Name:      "qux",
-						Namespace: "ns",
-						Containers: []*kubecontainer.Container{
-							{
-								Name: "bar",
-								ID:   kubecontainer.ContainerID{Type: "test", ID: "fakeID"},
-							},
-						},
-					},
-				},
-			},
-			requestedPodFullName:   "qux_ns",
-			requestedPodUID:        "",
-			requestedContainerName: "foo",
-			mockError:              nil,
-			expectedError:          kubecontainer.ErrContainerNotFound,
-			expectStats:            false,
-		},
-	}
-
-	for _, tc := range tests {
-		testKubelet := newTestKubelet(t, false /* controllerAttachDetachEnablec */)
-		defer testKubelet.Cleanup()
-		fakeRuntime := testKubelet.fakeRuntime
-		kubelet := testKubelet.kubelet
-		cadvisorReq := &cadvisorapi.ContainerInfoRequest{}
-		mockCadvisor := testKubelet.fakeCadvisor
-		if tc.expectDockerContainerCall {
-			mockCadvisor.On("DockerContainer", tc.containerID, cadvisorReq).Return(tc.cadvisorContainerInfo, tc.mockError)
-		}
-		fakeRuntime.Err = tc.runtimeError
-		fakeRuntime.PodList = tc.podList
-
-		stats, err := kubelet.GetContainerInfo(tc.requestedPodFullName, tc.requestedPodUID, tc.requestedContainerName, cadvisorReq)
-		assert.Equal(t, tc.expectedError, err)
-
-		if tc.expectStats {
-			require.NotNil(t, stats)
-		}
-		mockCadvisor.AssertExpectations(t)
-	}
-}
-
-func TestGetRawContainerInfoRoot(t *testing.T) {
-	containerPath := "/"
-	containerInfo := &cadvisorapi.ContainerInfo{
-		ContainerReference: cadvisorapi.ContainerReference{
-			Name: containerPath,
-		},
-	}
-	testKubelet := newTestKubelet(t, false /* controllerAttachDetachEnabled */)
-	defer testKubelet.Cleanup()
-	kubelet := testKubelet.kubelet
-	mockCadvisor := testKubelet.fakeCadvisor
-	cadvisorReq := &cadvisorapi.ContainerInfoRequest{}
-	mockCadvisor.On("ContainerInfo", containerPath, cadvisorReq).Return(containerInfo, nil)
-
-	_, err := kubelet.GetRawContainerInfo(containerPath, cadvisorReq, false)
-	assert.NoError(t, err)
-	mockCadvisor.AssertExpectations(t)
-}
-
-func TestGetRawContainerInfoSubcontainers(t *testing.T) {
-	containerPath := "/kubelet"
-	containerInfo := map[string]*cadvisorapi.ContainerInfo{
-		containerPath: {
-			ContainerReference: cadvisorapi.ContainerReference{
-				Name: containerPath,
-			},
-		},
-		"/kubelet/sub": {
-			ContainerReference: cadvisorapi.ContainerReference{
-				Name: "/kubelet/sub",
-			},
-		},
-	}
-	testKubelet := newTestKubelet(t, false /* controllerAttachDetachEnabled */)
-	defer testKubelet.Cleanup()
-	kubelet := testKubelet.kubelet
-	mockCadvisor := testKubelet.fakeCadvisor
-	cadvisorReq := &cadvisorapi.ContainerInfoRequest{}
-	mockCadvisor.On("SubcontainerInfo", containerPath, cadvisorReq).Return(containerInfo, nil)
-
-	result, err := kubelet.GetRawContainerInfo(containerPath, cadvisorReq, true)
-	assert.NoError(t, err)
-	assert.Len(t, result, 2)
-	mockCadvisor.AssertExpectations(t)
-}

pkg/kubelet/kubelet_getters.go

@@ -23,6 +23,8 @@ import (
 	"path/filepath"
 
 	"github.com/golang/glog"
+	cadvisorapiv1 "github.com/google/cadvisor/info/v1"
+
 	"k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/kubernetes/cmd/kubelet/app/options"
@@ -239,3 +241,20 @@ func (kl *Kubelet) getPodVolumePathListFromDisk(podUID types.UID) ([]string, err
 	}
 	return volumes, nil
 }
+
+// GetVersionInfo returns information about the version of cAdvisor in use.
+func (kl *Kubelet) GetVersionInfo() (*cadvisorapiv1.VersionInfo, error) {
+	return kl.cadvisor.VersionInfo()
+}
+
+// GetCachedMachineInfo assumes that the machine info can't change without a reboot
+func (kl *Kubelet) GetCachedMachineInfo() (*cadvisorapiv1.MachineInfo, error) {
+	if kl.machineInfo == nil {
+		info, err := kl.cadvisor.MachineInfo()
+		if err != nil {
+			return nil, err
+		}
+		kl.machineInfo = info
+	}
+	return kl.machineInfo, nil
+}

pkg/kubelet/kubelet_test.go

@@ -60,7 +60,8 @@ import (
 	proberesults "k8s.io/kubernetes/pkg/kubelet/prober/results"
 	probetest "k8s.io/kubernetes/pkg/kubelet/prober/testing"
 	"k8s.io/kubernetes/pkg/kubelet/secret"
-	"k8s.io/kubernetes/pkg/kubelet/server/stats"
+	serverstats "k8s.io/kubernetes/pkg/kubelet/server/stats"
+	"k8s.io/kubernetes/pkg/kubelet/stats"
 	"k8s.io/kubernetes/pkg/kubelet/status"
 	statustest "k8s.io/kubernetes/pkg/kubelet/status/testing"
 	kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
@@ -261,7 +262,7 @@ func newTestKubeletWithImageList(
 
 	// TODO: Factor out "StatsProvider" from Kubelet so we don't have a cyclic dependency
 	volumeStatsAggPeriod := time.Second * 10
-	kubelet.resourceAnalyzer = stats.NewResourceAnalyzer(kubelet, volumeStatsAggPeriod, kubelet.containerRuntime)
+	kubelet.resourceAnalyzer = serverstats.NewResourceAnalyzer(kubelet, volumeStatsAggPeriod)
 	nodeRef := &v1.ObjectReference{
 		Kind:      "Node",
 		Name:      string(kubelet.nodeName),
@@ -304,6 +305,12 @@ func newTestKubeletWithImageList(
 	kubelet.AddPodSyncLoopHandler(activeDeadlineHandler)
 	kubelet.AddPodSyncHandler(activeDeadlineHandler)
 	kubelet.gpuManager = gpu.NewGPUManagerStub()
+	kubelet.StatsProvider = stats.NewCadvisorStatsProvider(
+		kubelet.cadvisor,
+		kubelet.resourceAnalyzer,
+		kubelet.podManager,
+		kubelet.runtimeCache,
+		fakeRuntime)
 	return &TestKubelet{kubelet, fakeRuntime, mockCadvisor, fakeKubeClient, fakeMirrorClient, fakeClock, nil, plug}
 }
 

pkg/kubelet/pod/testing/BUILD

@@ -7,10 +7,16 @@ load(
 
 go_library(
     name = "go_default_library",
-    srcs = ["fake_mirror_client.go"],
+    srcs = [
+        "fake_mirror_client.go",
+        "mock_manager.go",
+    ],
     deps = [
         "//pkg/kubelet/container:go_default_library",
+        "//pkg/kubelet/types:go_default_library",
+        "//vendor/github.com/stretchr/testify/mock:go_default_library",
         "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
     ],
 )

pkg/kubelet/pod/testing/mock_manager.go

+/*
+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.
+*/
+
+// Code generated by mockery v1.0.0
+package testing
+
+import kubelettypes "k8s.io/kubernetes/pkg/kubelet/types"
+import mock "github.com/stretchr/testify/mock"
+
+import types "k8s.io/apimachinery/pkg/types"
+import v1 "k8s.io/api/core/v1"
+
+// MockManager is an autogenerated mock type for the Manager type
+type MockManager struct {
+	mock.Mock
+}
+
+// AddPod provides a mock function with given fields: _a0
+func (_m *MockManager) AddPod(_a0 *v1.Pod) {
+	_m.Called(_a0)
+}
+
+// CreateMirrorPod provides a mock function with given fields: _a0
+func (_m *MockManager) CreateMirrorPod(_a0 *v1.Pod) error {
+	ret := _m.Called(_a0)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*v1.Pod) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteMirrorPod provides a mock function with given fields: podFullName
+func (_m *MockManager) DeleteMirrorPod(podFullName string) error {
+	ret := _m.Called(podFullName)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(podFullName)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteOrphanedMirrorPods provides a mock function with given fields:
+func (_m *MockManager) DeleteOrphanedMirrorPods() {
+	_m.Called()
+}
+
+// DeletePod provides a mock function with given fields: _a0
+func (_m *MockManager) DeletePod(_a0 *v1.Pod) {
+	_m.Called(_a0)
+}
+
+// GetMirrorPodByPod provides a mock function with given fields: _a0
+func (_m *MockManager) GetMirrorPodByPod(_a0 *v1.Pod) (*v1.Pod, bool) {
+	ret := _m.Called(_a0)
+
+	var r0 *v1.Pod
+	if rf, ok := ret.Get(0).(func(*v1.Pod) *v1.Pod); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*v1.Pod)
+		}
+	}
+
+	var r1 bool
+	if rf, ok := ret.Get(1).(func(*v1.Pod) bool); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Get(1).(bool)
+	}
+
+	return r0, r1
+}
+
+// GetPodByFullName provides a mock function with given fields: podFullName
+func (_m *MockManager) GetPodByFullName(podFullName string) (*v1.Pod, bool) {
+	ret := _m.Called(podFullName)
+
+	var r0 *v1.Pod
+	if rf, ok := ret.Get(0).(func(string) *v1.Pod); ok {
+		r0 = rf(podFullName)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*v1.Pod)
+		}
+	}
+
+	var r1 bool
+	if rf, ok := ret.Get(1).(func(string) bool); ok {
+		r1 = rf(podFullName)
+	} else {
+		r1 = ret.Get(1).(bool)
+	}
+
+	return r0, r1
+}
+
+// GetPodByMirrorPod provides a mock function with given fields: _a0
+func (_m *MockManager) GetPodByMirrorPod(_a0 *v1.Pod) (*v1.Pod, bool) {
+	ret := _m.Called(_a0)
+
+	var r0 *v1.Pod
+	if rf, ok := ret.Get(0).(func(*v1.Pod) *v1.Pod); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*v1.Pod)
+		}
+	}
+
+	var r1 bool
+	if rf, ok := ret.Get(1).(func(*v1.Pod) bool); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Get(1).(bool)
+	}
+
+	return r0, r1
+}
+
+// GetPodByName provides a mock function with given fields: namespace, name
+func (_m *MockManager) GetPodByName(namespace string, name string) (*v1.Pod, bool) {
+	ret := _m.Called(namespace, name)
+
+	var r0 *v1.Pod
+	if rf, ok := ret.Get(0).(func(string, string) *v1.Pod); ok {
+		r0 = rf(namespace, name)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*v1.Pod)
+		}
+	}
+
+	var r1 bool
+	if rf, ok := ret.Get(1).(func(string, string) bool); ok {
+		r1 = rf(namespace, name)
+	} else {
+		r1 = ret.Get(1).(bool)
+	}
+
+	return r0, r1
+}
+
+// GetPodByUID provides a mock function with given fields: _a0
+func (_m *MockManager) GetPodByUID(_a0 types.UID) (*v1.Pod, bool) {
+	ret := _m.Called(_a0)
+
+	var r0 *v1.Pod
+	if rf, ok := ret.Get(0).(func(types.UID) *v1.Pod); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*v1.Pod)
+		}
+	}
+
+	var r1 bool
+	if rf, ok := ret.Get(1).(func(types.UID) bool); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Get(1).(bool)
+	}
+
+	return r0, r1
+}
+
+// GetPods provides a mock function with given fields:
+func (_m *MockManager) GetPods() []*v1.Pod {
+	ret := _m.Called()
+
+	var r0 []*v1.Pod
+	if rf, ok := ret.Get(0).(func() []*v1.Pod); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*v1.Pod)
+		}
+	}
+
+	return r0
+}
+
+// GetPodsAndMirrorPods provides a mock function with given fields:
+func (_m *MockManager) GetPodsAndMirrorPods() ([]*v1.Pod, []*v1.Pod) {
+	ret := _m.Called()
+
+	var r0 []*v1.Pod
+	if rf, ok := ret.Get(0).(func() []*v1.Pod); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*v1.Pod)
+		}
+	}
+
+	var r1 []*v1.Pod
+	if rf, ok := ret.Get(1).(func() []*v1.Pod); ok {
+		r1 = rf()
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).([]*v1.Pod)
+		}
+	}
+
+	return r0, r1
+}
+
+// GetUIDTranslations provides a mock function with given fields:
+func (_m *MockManager) GetUIDTranslations() (map[kubelettypes.ResolvedPodUID]kubelettypes.MirrorPodUID, map[kubelettypes.MirrorPodUID]kubelettypes.ResolvedPodUID) {
+	ret := _m.Called()
+
+	var r0 map[kubelettypes.ResolvedPodUID]kubelettypes.MirrorPodUID
+	if rf, ok := ret.Get(0).(func() map[kubelettypes.ResolvedPodUID]kubelettypes.MirrorPodUID); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[kubelettypes.ResolvedPodUID]kubelettypes.MirrorPodUID)
+		}
+	}
+
+	var r1 map[kubelettypes.MirrorPodUID]kubelettypes.ResolvedPodUID
+	if rf, ok := ret.Get(1).(func() map[kubelettypes.MirrorPodUID]kubelettypes.ResolvedPodUID); ok {
+		r1 = rf()
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(map[kubelettypes.MirrorPodUID]kubelettypes.ResolvedPodUID)
+		}
+	}
+
+	return r0, r1
+}
+
+// IsMirrorPodOf provides a mock function with given fields: mirrorPod, _a1
+func (_m *MockManager) IsMirrorPodOf(mirrorPod *v1.Pod, _a1 *v1.Pod) bool {
+	ret := _m.Called(mirrorPod, _a1)
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(*v1.Pod, *v1.Pod) bool); ok {
+		r0 = rf(mirrorPod, _a1)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	return r0
+}
+
+// SetPods provides a mock function with given fields: pods
+func (_m *MockManager) SetPods(pods []*v1.Pod) {
+	_m.Called(pods)
+}
+
+// TranslatePodUID provides a mock function with given fields: uid
+func (_m *MockManager) TranslatePodUID(uid types.UID) kubelettypes.ResolvedPodUID {
+	ret := _m.Called(uid)
+
+	var r0 kubelettypes.ResolvedPodUID
+	if rf, ok := ret.Get(0).(func(types.UID) kubelettypes.ResolvedPodUID); ok {
+		r0 = rf(uid)
+	} else {
+		r0 = ret.Get(0).(kubelettypes.ResolvedPodUID)
+	}
+
+	return r0
+}
+
+// UpdatePod provides a mock function with given fields: _a0
+func (_m *MockManager) UpdatePod(_a0 *v1.Pod) {
+	_m.Called(_a0)
+}

pkg/kubelet/runonce_test.go

@@ -113,7 +113,7 @@ func TestRunOnce(t *testing.T) {
 	kb.networkPlugin, _ = network.InitNetworkPlugin([]network.NetworkPlugin{}, "", nettest.NewFakeHost(nil), kubeletconfig.HairpinNone, "", network.UseDefaultMTU)
 	// TODO: Factor out "StatsProvider" from Kubelet so we don't have a cyclic dependency
 	volumeStatsAggPeriod := time.Second * 10
-	kb.resourceAnalyzer = stats.NewResourceAnalyzer(kb, volumeStatsAggPeriod, kb.containerRuntime)
+	kb.resourceAnalyzer = stats.NewResourceAnalyzer(kb, volumeStatsAggPeriod)
 	nodeRef := &v1.ObjectReference{
 		Kind:      "Node",
 		Name:      string(kb.nodeName),

pkg/kubelet/server/BUILD

@@ -16,7 +16,6 @@ go_library(
     deps = [
         "//pkg/api:go_default_library",
         "//pkg/api/v1/validation:go_default_library",
-        "//pkg/kubelet/cm:go_default_library",
         "//pkg/kubelet/container:go_default_library",
         "//pkg/kubelet/server/portforward:go_default_library",
         "//pkg/kubelet/server/remotecommand:go_default_library",
@@ -25,11 +24,9 @@ go_library(
         "//pkg/kubelet/types:go_default_library",
         "//pkg/util/configz:go_default_library",
         "//pkg/util/limitwriter:go_default_library",
-        "//pkg/volume:go_default_library",
         "//vendor/github.com/emicklei/go-restful:go_default_library",
         "//vendor/github.com/golang/glog:go_default_library",
         "//vendor/github.com/google/cadvisor/info/v1:go_default_library",
-        "//vendor/github.com/google/cadvisor/info/v2:go_default_library",
         "//vendor/github.com/google/cadvisor/metrics:go_default_library",
         "//vendor/github.com/prometheus/client_golang/prometheus:go_default_library",
         "//vendor/github.com/prometheus/client_golang/prometheus/promhttp:go_default_library",
@@ -61,6 +58,7 @@ go_test(
     deps = [
         "//pkg/api:go_default_library",
         "//pkg/api/install:go_default_library",
+        "//pkg/kubelet/apis/stats/v1alpha1:go_default_library",
         "//pkg/kubelet/cm:go_default_library",
         "//pkg/kubelet/container:go_default_library",
         "//pkg/kubelet/container/testing:go_default_library",
@@ -69,7 +67,6 @@ go_test(
         "//pkg/kubelet/server/stats:go_default_library",
         "//pkg/volume:go_default_library",
         "//vendor/github.com/google/cadvisor/info/v1:go_default_library",
-        "//vendor/github.com/google/cadvisor/info/v2:go_default_library",
         "//vendor/github.com/stretchr/testify/assert:go_default_library",
         "//vendor/github.com/stretchr/testify/require:go_default_library",
         "//vendor/golang.org/x/net/websocket:go_default_library",

pkg/kubelet/server/server.go

@@ -33,7 +33,6 @@ import (
 	restful "github.com/emicklei/go-restful"
 	"github.com/golang/glog"
 	cadvisorapi "github.com/google/cadvisor/info/v1"
-	cadvisorapiv2 "github.com/google/cadvisor/info/v2"
 	"github.com/google/cadvisor/metrics"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
@@ -53,7 +52,6 @@ import (
 	"k8s.io/client-go/tools/remotecommand"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/v1/validation"
-	"k8s.io/kubernetes/pkg/kubelet/cm"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
 	"k8s.io/kubernetes/pkg/kubelet/server/portforward"
 	remotecommandserver "k8s.io/kubernetes/pkg/kubelet/server/remotecommand"
@@ -62,7 +60,6 @@ import (
 	kubelettypes "k8s.io/kubernetes/pkg/kubelet/types"
 	"k8s.io/kubernetes/pkg/util/configz"
 	"k8s.io/kubernetes/pkg/util/limitwriter"
-	"k8s.io/kubernetes/pkg/volume"
 )
 
 const (
@@ -169,14 +166,10 @@ type AuthInterface interface {
 // HostInterface contains all the kubelet methods required by the server.
 // For testability.
 type HostInterface interface {
-	GetContainerInfo(podFullName string, uid types.UID, containerName string, req *cadvisorapi.ContainerInfoRequest) (*cadvisorapi.ContainerInfo, error)
-	GetContainerInfoV2(name string, options cadvisorapiv2.RequestOptions) (map[string]cadvisorapiv2.ContainerInfo, error)
-	GetRawContainerInfo(containerName string, req *cadvisorapi.ContainerInfoRequest, subcontainers bool) (map[string]*cadvisorapi.ContainerInfo, error)
+	stats.StatsProvider
 	GetVersionInfo() (*cadvisorapi.VersionInfo, error)
 	GetCachedMachineInfo() (*cadvisorapi.MachineInfo, error)
-	GetPods() []*v1.Pod
 	GetRunningPods() ([]*v1.Pod, error)
-	GetPodByName(namespace, name string) (*v1.Pod, bool)
 	RunInContainer(name string, uid types.UID, container string, cmd []string) ([]byte, error)
 	ExecInContainer(name string, uid types.UID, container string, cmd []string, in io.Reader, out, err io.WriteCloser, tty bool, resize <-chan remotecommand.TerminalSize, timeout time.Duration) error
 	AttachContainer(name string, uid types.UID, container string, in io.Reader, out, err io.WriteCloser, tty bool, resize <-chan remotecommand.TerminalSize) error
@@ -186,12 +179,7 @@ type HostInterface interface {
 	StreamingConnectionIdleTimeout() time.Duration
 	ResyncInterval() time.Duration
 	GetHostname() string
-	GetNode() (*v1.Node, error)
-	GetNodeConfig() cm.NodeConfig
 	LatestLoopEntryTime() time.Time
-	ImagesFsInfo() (cadvisorapiv2.FsInfo, error)
-	RootFsInfo() (cadvisorapiv2.FsInfo, error)
-	ListVolumesForPod(podUID types.UID) (map[string]volume.Volume, bool)
 	GetExec(podFullName string, podUID types.UID, containerName string, cmd []string, streamOpts remotecommandserver.Options) (*url.URL, error)
 	GetAttach(podFullName string, podUID types.UID, containerName string, streamOpts remotecommandserver.Options) (*url.URL, error)
 	GetPortForward(podName, podNamespace string, podUID types.UID, portForwardOpts portforward.V4Options) (*url.URL, error)

pkg/kubelet/server/server_test.go

@@ -35,7 +35,6 @@ import (
 	"time"
 
 	cadvisorapi "github.com/google/cadvisor/info/v1"
-	cadvisorapiv2 "github.com/google/cadvisor/info/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"k8s.io/api/core/v1"
@@ -49,6 +48,7 @@ import (
 	"k8s.io/client-go/tools/remotecommand"
 	utiltesting "k8s.io/client-go/util/testing"
 	"k8s.io/kubernetes/pkg/api"
+	statsapi "k8s.io/kubernetes/pkg/kubelet/apis/stats/v1alpha1"
 	// Do some initialization to decode the query parameters correctly.
 	_ "k8s.io/kubernetes/pkg/api/install"
 	"k8s.io/kubernetes/pkg/kubelet/cm"
@@ -166,18 +166,6 @@ func (fk *fakeKubelet) StreamingConnectionIdleTimeout() time.Duration {
 }
 
 // Unused functions
-func (_ *fakeKubelet) GetContainerInfoV2(_ string, _ cadvisorapiv2.RequestOptions) (map[string]cadvisorapiv2.ContainerInfo, error) {
-	return nil, nil
-}
-
-func (_ *fakeKubelet) ImagesFsInfo() (cadvisorapiv2.FsInfo, error) {
-	return cadvisorapiv2.FsInfo{}, fmt.Errorf("Unsupported Operation ImagesFsInfo")
-}
-
-func (_ *fakeKubelet) RootFsInfo() (cadvisorapiv2.FsInfo, error) {
-	return cadvisorapiv2.FsInfo{}, fmt.Errorf("Unsupport Operation RootFsInfo")
-}
-
 func (_ *fakeKubelet) GetNode() (*v1.Node, error)   { return nil, nil }
 func (_ *fakeKubelet) GetNodeConfig() cm.NodeConfig { return cm.NodeConfig{} }
 
@@ -185,6 +173,13 @@ func (fk *fakeKubelet) ListVolumesForPod(podUID types.UID) (map[string]volume.Vo
 	return map[string]volume.Volume{}, true
 }
 
+func (_ *fakeKubelet) RootFsStats() (*statsapi.FsStats, error)    { return nil, nil }
+func (_ *fakeKubelet) ListPodStats() ([]statsapi.PodStats, error) { return nil, nil }
+func (_ *fakeKubelet) ImageFsStats() (*statsapi.FsStats, error)   { return nil, nil }
+func (_ *fakeKubelet) GetCgroupStats(cgroupName string) (*statsapi.ContainerStats, *statsapi.NetworkStats, error) {
+	return nil, nil, nil
+}
+
 type fakeAuth struct {
 	authenticateFunc func(*http.Request) (user.Info, bool, error)
 	attributesFunc   func(user.Info, *http.Request) authorizer.Attributes
@@ -242,7 +237,7 @@ func newServerTest() *serverTestFramework {
 	}
 	server := NewServer(
 		fw.fakeKubelet,
-		stats.NewResourceAnalyzer(fw.fakeKubelet, time.Minute, &kubecontainertesting.FakeRuntime{}),
+		stats.NewResourceAnalyzer(fw.fakeKubelet, time.Minute),
 		fw.fakeAuth,
 		true,
 		false,

pkg/kubelet/server/stats/BUILD

-package(default_visibility = ["//visibility:public"])
-
-load(
-    "@io_bazel_rules_go//go:def.bzl",
-    "go_library",
-    "go_test",
-)
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
@@ -16,19 +10,16 @@ go_library(
         "summary.go",
         "volume_stat_calculator.go",
     ],
+    visibility = ["//visibility:public"],
     deps = [
         "//pkg/kubelet/apis/stats/v1alpha1:go_default_library",
         "//pkg/kubelet/cm:go_default_library",
         "//pkg/kubelet/container:go_default_library",
-        "//pkg/kubelet/leaky:go_default_library",
-        "//pkg/kubelet/network:go_default_library",
-        "//pkg/kubelet/types:go_default_library",
         "//pkg/kubelet/util/format:go_default_library",
         "//pkg/volume:go_default_library",
         "//vendor/github.com/emicklei/go-restful:go_default_library",
         "//vendor/github.com/golang/glog:go_default_library",
         "//vendor/github.com/google/cadvisor/info/v1:go_default_library",
-        "//vendor/github.com/google/cadvisor/info/v2: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/types:go_default_library",
@@ -38,25 +29,16 @@ go_library(
 
 go_test(
     name = "go_default_test",
-    srcs = [
-        "mocks_test.go",
-        "summary_test.go",
-    ],
+    srcs = ["summary_test.go"],
     library = ":go_default_library",
     deps = [
         "//pkg/kubelet/apis/stats/v1alpha1:go_default_library",
         "//pkg/kubelet/cm:go_default_library",
-        "//pkg/kubelet/container:go_default_library",
-        "//pkg/kubelet/leaky:go_default_library",
-        "//pkg/volume:go_default_library",
-        "//vendor/github.com/google/cadvisor/info/v1:go_default_library",
-        "//vendor/github.com/google/cadvisor/info/v2:go_default_library",
+        "//pkg/kubelet/server/stats/testing:go_default_library",
         "//vendor/github.com/google/gofuzz:go_default_library",
         "//vendor/github.com/stretchr/testify/assert:go_default_library",
-        "//vendor/github.com/stretchr/testify/mock: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/types:go_default_library",
     ],
 )
 
@@ -69,6 +51,10 @@ filegroup(
 
 filegroup(
     name = "all-srcs",
-    srcs = [":package-srcs"],
+    srcs = [
+        ":package-srcs",
+        "//pkg/kubelet/server/stats/testing:all-srcs",
+    ],
     tags = ["automanaged"],
+    visibility = ["//visibility:public"],
 )

pkg/kubelet/server/stats/handler.go

@@ -24,14 +24,14 @@ import (
 	"path"
 	"time"
 
+	restful "github.com/emicklei/go-restful"
 	"github.com/golang/glog"
 	cadvisorapi "github.com/google/cadvisor/info/v1"
-	cadvisorapiv2 "github.com/google/cadvisor/info/v2"
 
-	"github.com/emicklei/go-restful"
 	"k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
+	statsapi "k8s.io/kubernetes/pkg/kubelet/apis/stats/v1alpha1"
 	"k8s.io/kubernetes/pkg/kubelet/cm"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
 	"k8s.io/kubernetes/pkg/volume"
@@ -39,15 +39,44 @@ import (
 
 // Host methods required by stats handlers.
 type StatsProvider interface {
+	// The following stats are provided by either CRI or cAdvisor.
+	//
+	// ListPodStats returns the stats of all the containers managed by pods.
+	ListPodStats() ([]statsapi.PodStats, error)
+	// ImageFsStats returns the stats of the image filesystem.
+	ImageFsStats() (*statsapi.FsStats, error)
+
+	// The following stats are provided by cAdvisor.
+	//
+	// GetCgroupStats returns the stats and the networking usage of the cgroup
+	// with the specified cgroupName.
+	GetCgroupStats(cgroupName string) (*statsapi.ContainerStats, *statsapi.NetworkStats, error)
+	// RootFsStats returns the stats of the node root filesystem.
+	RootFsStats() (*statsapi.FsStats, error)
+
+	// The following stats are provided by cAdvisor for legacy usage.
+	//
+	// GetContainerInfo returns the information of the container with the
+	// containerName managed by the pod with the uid.
 	GetContainerInfo(podFullName string, uid types.UID, containerName string, req *cadvisorapi.ContainerInfoRequest) (*cadvisorapi.ContainerInfo, error)
-	GetContainerInfoV2(name string, options cadvisorapiv2.RequestOptions) (map[string]cadvisorapiv2.ContainerInfo, error)
+	// GetRawContainerInfo returns the information of the container with the
+	// containerName. If subcontainers is true, this function will return the
+	// information of all the sub-containers as well.
 	GetRawContainerInfo(containerName string, req *cadvisorapi.ContainerInfoRequest, subcontainers bool) (map[string]*cadvisorapi.ContainerInfo, error)
+
+	// The following information is provided by Kubelet.
+	//
+	// GetPodByName returns the spec of the pod with the name in the specified
+	// namespace.
 	GetPodByName(namespace, name string) (*v1.Pod, bool)
+	// GetNode returns the spec of the local node.
 	GetNode() (*v1.Node, error)
+	// GetNodeConfig returns the configuration of the local node.
 	GetNodeConfig() cm.NodeConfig
-	ImagesFsInfo() (cadvisorapiv2.FsInfo, error)
-	RootFsInfo() (cadvisorapiv2.FsInfo, error)
+	// ListVolumesForPod returns the stats of the volume used by the pod with
+	// the podUID.
 	ListVolumesForPod(podUID types.UID) (map[string]volume.Volume, bool)
+	// GetPods returns the specs of all the pods running on this node.
 	GetPods() []*v1.Pod
 }
 

pkg/kubelet/server/stats/resource_analyzer.go

@@ -18,8 +18,6 @@ package stats
 
 import (
 	"time"
-
-	"k8s.io/kubernetes/pkg/kubelet/container"
 )
 
 // ResourceAnalyzer provides statistics on node resource consumption
@@ -39,9 +37,9 @@ type resourceAnalyzer struct {
 var _ ResourceAnalyzer = &resourceAnalyzer{}
 
 // NewResourceAnalyzer returns a new ResourceAnalyzer
-func NewResourceAnalyzer(statsProvider StatsProvider, calVolumeFrequency time.Duration, runtime container.Runtime) ResourceAnalyzer {
+func NewResourceAnalyzer(statsProvider StatsProvider, calVolumeFrequency time.Duration) ResourceAnalyzer {
 	fsAnalyzer := newFsResourceAnalyzer(statsProvider, calVolumeFrequency)
-	summaryProvider := NewSummaryProvider(statsProvider, fsAnalyzer, runtime)
+	summaryProvider := NewSummaryProvider(statsProvider)
 	return &resourceAnalyzer{fsAnalyzer, summaryProvider}
 }
 

pkg/kubelet/server/stats/testing/BUILD

+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["mock_stats_provider.go"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//pkg/kubelet/apis/stats/v1alpha1:go_default_library",
+        "//pkg/kubelet/cm:go_default_library",
+        "//pkg/volume:go_default_library",
+        "//vendor/github.com/google/cadvisor/info/v1:go_default_library",
+        "//vendor/github.com/stretchr/testify/mock:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types: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"],
+)

pkg/kubelet/stats/BUILD

+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "cadvisor_stats_provider.go",
+        "cri_stats_provider.go",
+        "helper.go",
+        "stats_provider.go",
+    ],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//pkg/kubelet/apis/cri:go_default_library",
+        "//pkg/kubelet/apis/stats/v1alpha1:go_default_library",
+        "//pkg/kubelet/cadvisor:go_default_library",
+        "//pkg/kubelet/container:go_default_library",
+        "//pkg/kubelet/leaky:go_default_library",
+        "//pkg/kubelet/network:go_default_library",
+        "//pkg/kubelet/pod:go_default_library",
+        "//pkg/kubelet/server/stats:go_default_library",
+        "//pkg/kubelet/types:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/github.com/google/cadvisor/info/v1:go_default_library",
+        "//vendor/github.com/google/cadvisor/info/v2:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types: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"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "cadvisor_stats_provider_test.go",
+        "helper_test.go",
+        "stats_provider_test.go",
+    ],
+    library = ":go_default_library",
+    deps = [
+        "//pkg/kubelet/apis/stats/v1alpha1:go_default_library",
+        "//pkg/kubelet/cadvisor/testing:go_default_library",
+        "//pkg/kubelet/container:go_default_library",
+        "//pkg/kubelet/container/testing:go_default_library",
+        "//pkg/kubelet/leaky:go_default_library",
+        "//pkg/kubelet/pod/testing:go_default_library",
+        "//pkg/kubelet/server/stats:go_default_library",
+        "//pkg/kubelet/types:go_default_library",
+        "//vendor/github.com/google/cadvisor/info/v1:go_default_library",
+        "//vendor/github.com/google/cadvisor/info/v2:go_default_library",
+        "//vendor/github.com/google/gofuzz:go_default_library",
+        "//vendor/github.com/stretchr/testify/assert:go_default_library",
+        "//vendor/github.com/stretchr/testify/require:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+    ],
+)

pkg/kubelet/stats/cri_stats_provider.go

+/*
+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 stats
+
+import (
+	"fmt"
+
+	internalapi "k8s.io/kubernetes/pkg/kubelet/apis/cri"
+	statsapi "k8s.io/kubernetes/pkg/kubelet/apis/stats/v1alpha1"
+	"k8s.io/kubernetes/pkg/kubelet/cadvisor"
+	"k8s.io/kubernetes/pkg/kubelet/server/stats"
+)
+
+// criStatsProvider implements the containerStatsProvider interface by getting
+// the container stats from CRI.
+type criStatsProvider struct {
+	// cadvisor is used to get the node root filesystem's stats (such as the
+	// capacity/available bytes/inodes) that will be populated in per container
+	// filesystem stats.
+	cadvisor cadvisor.Interface
+	// resourceAnalyzer is used to get the volume stats of the pods.
+	resourceAnalyzer stats.ResourceAnalyzer
+	// runtimeService is used to get the status and stats of the pods and its
+	// managed containers.
+	runtimeService internalapi.RuntimeService
+	// imageService is used to get the stats of the image filesystem.
+	imageService internalapi.ImageManagerService
+}
+
+// newCRIStatsProvider returns a containerStatsProvider implementation that
+// provides container stats using CRI.
+func newCRIStatsProvider(
+	cadvisor cadvisor.Interface,
+	resourceAnalyzer stats.ResourceAnalyzer,
+	runtimeService internalapi.RuntimeService,
+	imageService internalapi.ImageManagerService,
+) containerStatsProvider {
+	return &criStatsProvider{
+		cadvisor:         cadvisor,
+		resourceAnalyzer: resourceAnalyzer,
+		runtimeService:   runtimeService,
+		imageService:     imageService,
+	}
+}
+
+func (p *criStatsProvider) ListPodStats() ([]statsapi.PodStats, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func (p *criStatsProvider) ImageFsStats() (*statsapi.FsStats, error) {
+	return nil, fmt.Errorf("not implemented")
+}

pkg/kubelet/stats/helper.go

+/*
+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 stats
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/golang/glog"
+
+	cadvisorapiv1 "github.com/google/cadvisor/info/v1"
+	cadvisorapiv2 "github.com/google/cadvisor/info/v2"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	statsapi "k8s.io/kubernetes/pkg/kubelet/apis/stats/v1alpha1"
+	"k8s.io/kubernetes/pkg/kubelet/cadvisor"
+	"k8s.io/kubernetes/pkg/kubelet/network"
+)
+
+// cadvisorInfoToContainerStats returns the statsapi.ContainerStats converted
+// from the container and filesystem info.
+func cadvisorInfoToContainerStats(name string, info *cadvisorapiv2.ContainerInfo, rootFs, imageFs *cadvisorapiv2.FsInfo) *statsapi.ContainerStats {
+	result := &statsapi.ContainerStats{
+		StartTime: metav1.NewTime(info.Spec.CreationTime),
+		Name:      name,
+	}
+
+	cstat, found := latestContainerStats(info)
+	if !found {
+		return result
+	}
+
+	if info.Spec.HasCpu {
+		cpuStats := statsapi.CPUStats{
+			Time: metav1.NewTime(cstat.Timestamp),
+		}
+		if cstat.CpuInst != nil {
+			cpuStats.UsageNanoCores = &cstat.CpuInst.Usage.Total
+		}
+		if cstat.Cpu != nil {
+			cpuStats.UsageCoreNanoSeconds = &cstat.Cpu.Usage.Total
+		}
+		result.CPU = &cpuStats
+	}
+
+	if info.Spec.HasMemory {
+		pageFaults := cstat.Memory.ContainerData.Pgfault
+		majorPageFaults := cstat.Memory.ContainerData.Pgmajfault
+		result.Memory = &statsapi.MemoryStats{
+			Time:            metav1.NewTime(cstat.Timestamp),
+			UsageBytes:      &cstat.Memory.Usage,
+			WorkingSetBytes: &cstat.Memory.WorkingSet,
+			RSSBytes:        &cstat.Memory.RSS,
+			PageFaults:      &pageFaults,
+			MajorPageFaults: &majorPageFaults,
+		}
+		// availableBytes = memory limit (if known) - workingset
+		if !isMemoryUnlimited(info.Spec.Memory.Limit) {
+			availableBytes := info.Spec.Memory.Limit - cstat.Memory.WorkingSet
+			result.Memory.AvailableBytes = &availableBytes
+		}
+	}
+
+	// The container logs live on the node rootfs device
+	result.Logs = &statsapi.FsStats{
+		Time:           metav1.NewTime(cstat.Timestamp),
+		AvailableBytes: &rootFs.Available,
+		CapacityBytes:  &rootFs.Capacity,
+		InodesFree:     rootFs.InodesFree,
+		Inodes:         rootFs.Inodes,
+	}
+
+	if rootFs.Inodes != nil && rootFs.InodesFree != nil {
+		logsInodesUsed := *rootFs.Inodes - *rootFs.InodesFree
+		result.Logs.InodesUsed = &logsInodesUsed
+	}
+
+	// The container rootFs lives on the imageFs devices (which may not be the node root fs)
+	result.Rootfs = &statsapi.FsStats{
+		Time:           metav1.NewTime(cstat.Timestamp),
+		AvailableBytes: &imageFs.Available,
+		CapacityBytes:  &imageFs.Capacity,
+		InodesFree:     imageFs.InodesFree,
+		Inodes:         imageFs.Inodes,
+	}
+
+	cfs := cstat.Filesystem
+	if cfs != nil {
+		if cfs.BaseUsageBytes != nil {
+			rootfsUsage := *cfs.BaseUsageBytes
+			result.Rootfs.UsedBytes = &rootfsUsage
+			if cfs.TotalUsageBytes != nil {
+				logsUsage := *cfs.TotalUsageBytes - *cfs.BaseUsageBytes
+				result.Logs.UsedBytes = &logsUsage
+			}
+		}
+		if cfs.InodeUsage != nil {
+			rootInodes := *cfs.InodeUsage
+			result.Rootfs.InodesUsed = &rootInodes
+		}
+	}
+
+	result.UserDefinedMetrics = cadvisorInfoToUserDefinedMetrics(info)
+	return result
+}
+
+// cadvisorInfoToNetworkStats returns the statsapi.NetworkStats converted from
+// the container info from cadvisor.
+func cadvisorInfoToNetworkStats(name string, info *cadvisorapiv2.ContainerInfo) *statsapi.NetworkStats {
+	if !info.Spec.HasNetwork {
+		return nil
+	}
+	cstat, found := latestContainerStats(info)
+	if !found {
+		return nil
+	}
+	for _, inter := range cstat.Network.Interfaces {
+		if inter.Name == network.DefaultInterfaceName {
+			return &statsapi.NetworkStats{
+				Time:     metav1.NewTime(cstat.Timestamp),
+				RxBytes:  &inter.RxBytes,
+				RxErrors: &inter.RxErrors,
+				TxBytes:  &inter.TxBytes,
+				TxErrors: &inter.TxErrors,
+			}
+		}
+	}
+	glog.V(4).Infof("Missing default interface %q for %s", network.DefaultInterfaceName, name)
+	return nil
+}
+
+// cadvisorInfoToUserDefinedMetrics returns the statsapi.UserDefinedMetric
+// converted from the container info from cadvisor.
+func cadvisorInfoToUserDefinedMetrics(info *cadvisorapiv2.ContainerInfo) []statsapi.UserDefinedMetric {
+	type specVal struct {
+		ref     statsapi.UserDefinedMetricDescriptor
+		valType cadvisorapiv1.DataType
+		time    time.Time
+		value   float64
+	}
+	udmMap := map[string]*specVal{}
+	for _, spec := range info.Spec.CustomMetrics {
+		udmMap[spec.Name] = &specVal{
+			ref: statsapi.UserDefinedMetricDescriptor{
+				Name:  spec.Name,
+				Type:  statsapi.UserDefinedMetricType(spec.Type),
+				Units: spec.Units,
+			},
+			valType: spec.Format,
+		}
+	}
+	for _, stat := range info.Stats {
+		for name, values := range stat.CustomMetrics {
+			specVal, ok := udmMap[name]
+			if !ok {
+				glog.Warningf("spec for custom metric %q is missing from cAdvisor output. Spec: %+v, Metrics: %+v", name, info.Spec, stat.CustomMetrics)
+				continue
+			}
+			for _, value := range values {
+				// Pick the most recent value
+				if value.Timestamp.Before(specVal.time) {
+					continue
+				}
+				specVal.time = value.Timestamp
+				specVal.value = value.FloatValue
+				if specVal.valType == cadvisorapiv1.IntType {
+					specVal.value = float64(value.IntValue)
+				}
+			}
+		}
+	}
+	var udm []statsapi.UserDefinedMetric
+	for _, specVal := range udmMap {
+		udm = append(udm, statsapi.UserDefinedMetric{
+			UserDefinedMetricDescriptor: specVal.ref,
+			Time:  metav1.NewTime(specVal.time),
+			Value: specVal.value,
+		})
+	}
+	return udm
+}
+
+// latestContainerStats returns the latest container stats from cadvisor, or nil if none exist
+func latestContainerStats(info *cadvisorapiv2.ContainerInfo) (*cadvisorapiv2.ContainerStats, bool) {
+	stats := info.Stats
+	if len(stats) < 1 {
+		return nil, false
+	}
+	latest := stats[len(stats)-1]
+	if latest == nil {
+		return nil, false
+	}
+	return latest, true
+}
+
+func isMemoryUnlimited(v uint64) bool {
+	// Size after which we consider memory to be "unlimited". This is not
+	// MaxInt64 due to rounding by the kernel.
+	// TODO: cadvisor should export this https://github.com/google/cadvisor/blob/master/metrics/prometheus.go#L596
+	const maxMemorySize = uint64(1 << 62)
+
+	return v > maxMemorySize
+}
+
+// getCgroupInfo returns the information of the container with the specified
+// containerName from cadvisor.
+func getCgroupInfo(cadvisor cadvisor.Interface, containerName string) (*cadvisorapiv2.ContainerInfo, error) {
+	infoMap, err := cadvisor.ContainerInfoV2(containerName, cadvisorapiv2.RequestOptions{
+		IdType:    cadvisorapiv2.TypeName,
+		Count:     2, // 2 samples are needed to compute "instantaneous" CPU
+		Recursive: false,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to get container info for %q: %v", containerName, err)
+	}
+	if len(infoMap) != 1 {
+		return nil, fmt.Errorf("unexpected number of containers: %v", len(infoMap))
+	}
+	info := infoMap[containerName]
+	return &info, nil
+}
+
+// getCgroupStats returns the latest stats of the container having the
+// specified containerName from cadvisor.
+func getCgroupStats(cadvisor cadvisor.Interface, containerName string) (*cadvisorapiv2.ContainerStats, error) {
+	info, err := getCgroupInfo(cadvisor, containerName)
+	if err != nil {
+		return nil, err
+	}
+	stats, found := latestContainerStats(info)
+	if !found {
+		return nil, fmt.Errorf("failed to get latest stats from container info for %q", containerName)
+	}
+	return stats, nil
+}

pkg/kubelet/stats/helper_test.go

+/*
+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 stats
+
+import (
+	"testing"
+	"time"
+
+	cadvisorapiv1 "github.com/google/cadvisor/info/v1"
+	cadvisorapiv2 "github.com/google/cadvisor/info/v2"
+	"github.com/stretchr/testify/assert"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	statsapi "k8s.io/kubernetes/pkg/kubelet/apis/stats/v1alpha1"
+)
+
+func TestCustomMetrics(t *testing.T) {
+	spec := []cadvisorapiv1.MetricSpec{
+		{
+			Name:   "qos",
+			Type:   cadvisorapiv1.MetricGauge,
+			Format: cadvisorapiv1.IntType,
+			Units:  "per second",
+		},
+		{
+			Name:   "cpuLoad",
+			Type:   cadvisorapiv1.MetricCumulative,
+			Format: cadvisorapiv1.FloatType,
+			Units:  "count",
+		},
+	}
+	timestamp1 := time.Now()
+	timestamp2 := time.Now().Add(time.Minute)
+	metrics := map[string][]cadvisorapiv1.MetricVal{
+		"qos": {
+			{
+				Timestamp: timestamp1,
+				IntValue:  10,
+			},
+			{
+				Timestamp: timestamp2,
+				IntValue:  100,
+			},
+		},
+		"cpuLoad": {
+			{
+				Timestamp:  timestamp1,
+				FloatValue: 1.2,
+			},
+			{
+				Timestamp:  timestamp2,
+				FloatValue: 2.1,
+			},
+		},
+	}
+	cInfo := cadvisorapiv2.ContainerInfo{
+		Spec: cadvisorapiv2.ContainerSpec{
+			CustomMetrics: spec,
+		},
+		Stats: []*cadvisorapiv2.ContainerStats{
+			{
+				CustomMetrics: metrics,
+			},
+		},
+	}
+	assert.Contains(t, cadvisorInfoToUserDefinedMetrics(&cInfo),
+		statsapi.UserDefinedMetric{
+			UserDefinedMetricDescriptor: statsapi.UserDefinedMetricDescriptor{
+				Name:  "qos",
+				Type:  statsapi.MetricGauge,
+				Units: "per second",
+			},
+			Time:  metav1.NewTime(timestamp2),
+			Value: 100,
+		},
+		statsapi.UserDefinedMetric{
+			UserDefinedMetricDescriptor: statsapi.UserDefinedMetricDescriptor{
+				Name:  "cpuLoad",
+				Type:  statsapi.MetricCumulative,
+				Units: "count",
+			},
+			Time:  metav1.NewTime(timestamp2),
+			Value: 2.1,
+		})
+}

pkg/kubelet/stats/stats_provider.go

+/*
+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 stats
+
+import (
+	"fmt"
+
+	cadvisorapiv1 "github.com/google/cadvisor/info/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+	internalapi "k8s.io/kubernetes/pkg/kubelet/apis/cri"
+	statsapi "k8s.io/kubernetes/pkg/kubelet/apis/stats/v1alpha1"
+	"k8s.io/kubernetes/pkg/kubelet/cadvisor"
+	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
+	kubepod "k8s.io/kubernetes/pkg/kubelet/pod"
+	"k8s.io/kubernetes/pkg/kubelet/server/stats"
+)
+
+// NewCRIStatsProvider returns a StatsProvider that provides the node stats
+// from cAdvisor and the container stats from CRI.
+func NewCRIStatsProvider(
+	cadvisor cadvisor.Interface,
+	resourceAnalyzer stats.ResourceAnalyzer,
+	podManager kubepod.Manager,
+	runtimeCache kubecontainer.RuntimeCache,
+	runtimeService internalapi.RuntimeService,
+	imageService internalapi.ImageManagerService,
+) *StatsProvider {
+	return newStatsProvider(cadvisor, podManager, runtimeCache, newCRIStatsProvider(cadvisor, resourceAnalyzer, runtimeService, imageService))
+}
+
+// NewCadvisorStatsProvider returns a containerStatsProvider that provides both
+// the node and the container stats from cAdvisor.
+func NewCadvisorStatsProvider(
+	cadvisor cadvisor.Interface,
+	resourceAnalyzer stats.ResourceAnalyzer,
+	podManager kubepod.Manager,
+	runtimeCache kubecontainer.RuntimeCache,
+	imageService kubecontainer.ImageService,
+) *StatsProvider {
+	return newStatsProvider(cadvisor, podManager, runtimeCache, newCadvisorStatsProvider(cadvisor, resourceAnalyzer, imageService))
+}
+
+// newStatsProvider returns a new StatsProvider that provides node stats from
+// cAdvisor and the container stats using the containerStatsProvider.
+func newStatsProvider(
+	cadvisor cadvisor.Interface,
+	podManager kubepod.Manager,
+	runtimeCache kubecontainer.RuntimeCache,
+	containerStatsProvider containerStatsProvider,
+) *StatsProvider {
+	return &StatsProvider{
+		cadvisor:               cadvisor,
+		podManager:             podManager,
+		runtimeCache:           runtimeCache,
+		containerStatsProvider: containerStatsProvider,
+	}
+}
+
+// StatsProvider provides the stats of the node and the pod-managed containers.
+type StatsProvider struct {
+	cadvisor     cadvisor.Interface
+	podManager   kubepod.Manager
+	runtimeCache kubecontainer.RuntimeCache
+	containerStatsProvider
+}
+
+// containerStatsProvider is an interface that provides the stats of the
+// containers managed by pods.
+type containerStatsProvider interface {
+	ListPodStats() ([]statsapi.PodStats, error)
+	ImageFsStats() (*statsapi.FsStats, error)
+}
+
+// GetCgroupStats returns the stats of the cgroup with the cgroupName.
+func (p *StatsProvider) GetCgroupStats(cgroupName string) (*statsapi.ContainerStats, *statsapi.NetworkStats, error) {
+	info, err := getCgroupInfo(p.cadvisor, cgroupName)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to get cgroup stats for %q: %v", cgroupName, err)
+	}
+	rootFsInfo, err := p.cadvisor.RootFsInfo()
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to get rootFs info: %v", err)
+	}
+	imageFsInfo, err := p.cadvisor.ImagesFsInfo()
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to get imageFs info: %v", err)
+	}
+	s := cadvisorInfoToContainerStats(cgroupName, info, &rootFsInfo, &imageFsInfo)
+	n := cadvisorInfoToNetworkStats(cgroupName, info)
+	return s, n, nil
+}
+
+// RootFsStats returns the stats of the node root filesystem.
+func (p *StatsProvider) RootFsStats() (*statsapi.FsStats, error) {
+	rootFsInfo, err := p.cadvisor.RootFsInfo()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get rootFs info: %v", err)
+	}
+
+	var nodeFsInodesUsed *uint64
+	if rootFsInfo.Inodes != nil && rootFsInfo.InodesFree != nil {
+		nodeFsIU := *rootFsInfo.Inodes - *rootFsInfo.InodesFree
+		nodeFsInodesUsed = &nodeFsIU
+	}
+
+	// Get the root container stats's timestamp, which will be used as the
+	// imageFs stats timestamp.
+	rootStats, err := getCgroupStats(p.cadvisor, "/")
+	if err != nil {
+		return nil, fmt.Errorf("failed to get root container stats: %v", err)
+	}
+
+	return &statsapi.FsStats{
+		Time:           metav1.NewTime(rootStats.Timestamp),
+		AvailableBytes: &rootFsInfo.Available,
+		CapacityBytes:  &rootFsInfo.Capacity,
+		UsedBytes:      &rootFsInfo.Usage,
+		InodesFree:     rootFsInfo.InodesFree,
+		Inodes:         rootFsInfo.Inodes,
+		InodesUsed:     nodeFsInodesUsed,
+	}, nil
+}
+
+// GetContainerInfo returns stats (from cAdvisor) for a container.
+func (p *StatsProvider) GetContainerInfo(podFullName string, podUID types.UID, containerName string, req *cadvisorapiv1.ContainerInfoRequest) (*cadvisorapiv1.ContainerInfo, error) {
+	// Resolve and type convert back again.
+	// We need the static pod UID but the kubecontainer API works with types.UID.
+	podUID = types.UID(p.podManager.TranslatePodUID(podUID))
+
+	pods, err := p.runtimeCache.GetPods()
+	if err != nil {
+		return nil, err
+	}
+	pod := kubecontainer.Pods(pods).FindPod(podFullName, podUID)
+	container := pod.FindContainerByName(containerName)
+	if container == nil {
+		return nil, kubecontainer.ErrContainerNotFound
+	}
+
+	ci, err := p.cadvisor.DockerContainer(container.ID.ID, req)
+	if err != nil {
+		return nil, err
+	}
+	return &ci, nil
+}
+
+// GetRawContainerInfo returns the stats (from cadvisor) for a non-Kubernetes
+// container.
+func (p *StatsProvider) GetRawContainerInfo(containerName string, req *cadvisorapiv1.ContainerInfoRequest, subcontainers bool) (map[string]*cadvisorapiv1.ContainerInfo, error) {
+	if subcontainers {
+		return p.cadvisor.SubcontainerInfo(containerName, req)
+	}
+	containerInfo, err := p.cadvisor.ContainerInfo(containerName, req)
+	if err != nil {
+		return nil, err
+	}
+	return map[string]*cadvisorapiv1.ContainerInfo{
+		containerInfo.Name: containerInfo,
+	}, nil
+}