Remove legacy cadvisor stats provider

cmd/kubelet/app/server.go

@@ -578,7 +578,7 @@ func run(s *options.KubeletServer, kubeDeps *kubelet.Dependencies, stopCh <-chan
 
 	if kubeDeps.CAdvisorInterface == nil {
 		imageFsInfoProvider := cadvisor.NewImageFsInfoProvider(s.ContainerRuntime, s.RemoteRuntimeEndpoint)
-		kubeDeps.CAdvisorInterface, err = cadvisor.New(imageFsInfoProvider, s.RootDirectory, cadvisor.UsingLegacyCadvisorStats(s.ContainerRuntime, s.RemoteRuntimeEndpoint))
+		kubeDeps.CAdvisorInterface, err = cadvisor.New(imageFsInfoProvider, s.RootDirectory)
 		if err != nil {
 			return err
 		}

pkg/kubelet/cadvisor/cadvisor_linux.go

@@ -101,7 +101,7 @@ func containerLabels(c *cadvisorapi.ContainerInfo) map[string]string {
 }
 
 // New creates a cAdvisor and exports its API on the specified port if port > 0.
-func New(imageFsInfoProvider ImageFsInfoProvider, rootPath string, usingLegacyStats bool) (Interface, error) {
+func New(imageFsInfoProvider ImageFsInfoProvider, rootPath string) (Interface, error) {
 	sysFs := sysfs.NewRealSysFs()
 
 	includedMetrics := cadvisormetrics.MetricSet{
@@ -113,9 +113,6 @@ func New(imageFsInfoProvider ImageFsInfoProvider, rootPath string, usingLegacySt
 		cadvisormetrics.AcceleratorUsageMetrics: struct{}{},
 		cadvisormetrics.AppMetrics:              struct{}{},
 	}
-	if usingLegacyStats {
-		includedMetrics[cadvisormetrics.DiskUsageMetrics] = struct{}{}
-	}
 
 	// collect metrics for all cgroups
 	rawContainerCgroupPathPrefixWhiteList := []string{"/"}

pkg/kubelet/cadvisor/helpers_linux.go

@@ -20,9 +20,6 @@ package cadvisor
 
 import (
 	"fmt"
-
-	cadvisorfs "github.com/google/cadvisor/fs"
-	"k8s.io/kubernetes/pkg/kubelet/types"
 )
 
 // imageFsInfoProvider knows how to translate the configured runtime
@@ -35,15 +32,6 @@ type imageFsInfoProvider struct {
 // ImageFsInfoLabel returns the image fs label for the configured runtime.
 // For remote runtimes, it handles additional runtimes natively understood by cAdvisor.
 func (i *imageFsInfoProvider) ImageFsInfoLabel() (string, error) {
-	switch i.runtime {
-	case types.RemoteContainerRuntime:
-		// This is a temporary workaround to get stats for cri-o from cadvisor
-		// and should be removed.
-		// Related to https://github.com/kubernetes/kubernetes/issues/51798
-		if i.runtimeEndpoint == CrioSocket {
-			return cadvisorfs.LabelCrioImages, nil
-		}
-	}
 	return "", fmt.Errorf("no imagefs label for configured runtime")
 }
 

pkg/kubelet/cadvisor/util.go

@@ -26,12 +26,6 @@ import (
 	"k8s.io/kubernetes/pkg/features"
 )
 
-const (
-	// Please keep this in sync with the one in:
-	// github.com/google/cadvisor/container/crio/client.go
-	CrioSocket = "/var/run/crio/crio.sock"
-)
-
 func CapacityFromMachineInfo(info *cadvisorapi.MachineInfo) v1.ResourceList {
 	c := v1.ResourceList{
 		v1.ResourceCPU: *resource.NewMilliQuantity(
@@ -63,14 +57,3 @@ func EphemeralStorageCapacityFromFsInfo(info cadvisorapi2.FsInfo) v1.ResourceLis
 	}
 	return c
 }
-
-// CRI integrations should get container metrics via CRI. Docker
-// uses the built-in cadvisor to gather such metrics on Linux for
-// historical reasons.
-// cri-o relies on cadvisor as a temporary workaround. The code should
-// be removed. Related issue:
-// https://github.com/kubernetes/kubernetes/issues/51798
-// UsingLegacyCadvisorStats returns true if container stats are provided by cadvisor instead of through the CRI
-func UsingLegacyCadvisorStats(runtime, runtimeEndpoint string) bool {
-	return runtimeEndpoint == CrioSocket
-}

pkg/kubelet/kubelet.go

@@ -618,23 +618,14 @@ func NewMainKubelet(kubeCfg *kubeletconfiginternal.KubeletConfiguration,
 	}
 	klet.runtimeCache = runtimeCache
 
-	if cadvisor.UsingLegacyCadvisorStats(containerRuntime, remoteRuntimeEndpoint) {
-		klet.StatsProvider = stats.NewCadvisorStatsProvider(
-			klet.cadvisor,
-			klet.resourceAnalyzer,
-			klet.podManager,
-			klet.runtimeCache,
-			klet.containerRuntime)
-	} else {
-		klet.StatsProvider = stats.NewCRIStatsProvider(
-			klet.cadvisor,
-			klet.resourceAnalyzer,
-			klet.podManager,
-			klet.runtimeCache,
-			runtimeService,
-			imageService,
-			stats.NewLogMetricsService())
-	}
+	klet.StatsProvider = stats.NewCRIStatsProvider(
+		klet.cadvisor,
+		klet.resourceAnalyzer,
+		klet.podManager,
+		klet.runtimeCache,
+		runtimeService,
+		imageService,
+		stats.NewLogMetricsService())
 
 	klet.pleg = pleg.NewGenericPLEG(klet.containerRuntime, plegChannelCapacity, plegRelistPeriod, klet.podCache, clock.RealClock{})
 	klet.runtimeState = newRuntimeState(maxWaitForContainerRuntime)

pkg/kubelet/stats/cadvisor_stats_provider.go

@@ -18,133 +18,19 @@ package stats
 
 import (
 	"fmt"
-	"path"
-	"sort"
-	"strings"
-
 	"github.com/golang/glog"
 	cadvisorapiv2 "github.com/google/cadvisor/info/v2"
+	"path"
+	"sort"
 
 	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/cadvisor"
 	"k8s.io/kubernetes/pkg/kubelet/cm"
-	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
-	"k8s.io/kubernetes/pkg/kubelet/leaky"
-	"k8s.io/kubernetes/pkg/kubelet/server/stats"
 	kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
 )
 
-// cadvisorStatsProvider implements the containerStatsProvider interface by
-// getting the container stats from cAdvisor. This is needed by docker and rkt
-// integrations since they do not provide stats from CRI.
-type cadvisorStatsProvider struct {
-	// cadvisor is used to get the stats of the cgroup for the containers that
-	// are managed by pods.
-	cadvisor cadvisor.Interface
-	// resourceAnalyzer is used to get the volume stats of the pods.
-	resourceAnalyzer stats.ResourceAnalyzer
-	// imageService is used to get the stats of the image filesystem.
-	imageService kubecontainer.ImageService
-}
-
-// newCadvisorStatsProvider returns a containerStatsProvider that provides
-// container stats from cAdvisor.
-func newCadvisorStatsProvider(
-	cadvisor cadvisor.Interface,
-	resourceAnalyzer stats.ResourceAnalyzer,
-	imageService kubecontainer.ImageService,
-) containerStatsProvider {
-	return &cadvisorStatsProvider{
-		cadvisor:         cadvisor,
-		resourceAnalyzer: resourceAnalyzer,
-		imageService:     imageService,
-	}
-}
-
-// ListPodStats returns the stats of all the pod-managed containers.
-func (p *cadvisorStatsProvider) ListPodStats() ([]statsapi.PodStats, error) {
-	// Gets node root filesystem information and image filesystem stats, which
-	// will be used to populate the available and capacity bytes/inodes in
-	// container stats.
-	rootFsInfo, err := p.cadvisor.RootFsInfo()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get rootFs info: %v", err)
-	}
-	imageFsInfo, err := p.cadvisor.ImagesFsInfo()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get imageFs info: %v", err)
-	}
-	infos, err := getCadvisorContainerInfo(p.cadvisor)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get container info from cadvisor: %v", err)
-	}
-	// removeTerminatedContainerInfo will also remove pod level cgroups, so save the infos into allInfos first
-	allInfos := infos
-	infos = removeTerminatedContainerInfo(infos)
-	// Map each container to a pod and update the PodStats with container data.
-	podToStats := map[statsapi.PodReference]*statsapi.PodStats{}
-	for key, cinfo := range infos {
-		// On systemd using devicemapper each mount into the container has an
-		// associated cgroup. We ignore them to ensure we do not get duplicate
-		// entries in our summary. For details on .mount units:
-		// http://man7.org/linux/man-pages/man5/systemd.mount.5.html
-		if strings.HasSuffix(key, ".mount") {
-			continue
-		}
-		// Build the Pod key if this container is managed by a Pod
-		if !isPodManagedContainer(&cinfo) {
-			continue
-		}
-		ref := buildPodRef(cinfo.Spec.Labels)
-
-		// Lookup the PodStats for the pod using the PodRef. If none exists,
-		// initialize a new entry.
-		podStats, found := podToStats[ref]
-		if !found {
-			podStats = &statsapi.PodStats{PodRef: ref}
-			podToStats[ref] = podStats
-		}
-
-		// Update the PodStats entry with the stats from the container by
-		// adding it to podStats.Containers.
-		containerName := kubetypes.GetContainerName(cinfo.Spec.Labels)
-		if containerName == leaky.PodInfraContainerName {
-			// Special case for infrastructure container which is hidden from
-			// the user and has network stats.
-			podStats.Network = cadvisorInfoToNetworkStats("pod:"+ref.Namespace+"_"+ref.Name, &cinfo)
-			podStats.StartTime = metav1.NewTime(cinfo.Spec.CreationTime)
-		} else {
-			podStats.Containers = append(podStats.Containers, *cadvisorInfoToContainerStats(containerName, &cinfo, &rootFsInfo, &imageFsInfo))
-		}
-	}
-
-	// Add each PodStats to the result.
-	result := make([]statsapi.PodStats, 0, len(podToStats))
-	for _, podStats := range podToStats {
-		// Lookup the volume stats for each pod.
-		podUID := types.UID(podStats.PodRef.UID)
-		var ephemeralStats []statsapi.VolumeStats
-		if vstats, found := p.resourceAnalyzer.GetPodVolumeStats(podUID); found {
-			ephemeralStats = make([]statsapi.VolumeStats, len(vstats.EphemeralVolumes))
-			copy(ephemeralStats, vstats.EphemeralVolumes)
-			podStats.VolumeStats = append(vstats.EphemeralVolumes, vstats.PersistentVolumes...)
-		}
-		podStats.EphemeralStorage = calcEphemeralStorage(podStats.Containers, ephemeralStats, &rootFsInfo)
-		// Lookup the pod-level cgroup's CPU and memory stats
-		podInfo := getCadvisorPodInfoFromPodUID(podUID, allInfos)
-		if podInfo != nil {
-			cpu, memory := cadvisorInfoToCPUandMemoryStats(podInfo)
-			podStats.CPU = cpu
-			podStats.Memory = memory
-		}
-		result = append(result, *podStats)
-	}
-
-	return result, nil
-}
-
 func calcEphemeralStorage(containers []statsapi.ContainerStats, volumes []statsapi.VolumeStats, rootFsInfo *cadvisorapiv2.FsInfo) *statsapi.FsStats {
 	result := &statsapi.FsStats{
 		Time:           metav1.NewTime(rootFsInfo.Timestamp),
@@ -192,44 +78,6 @@ func addUsage(first, second *uint64) *uint64 {
 	return &total
 }
 
-// ImageFsStats returns the stats of the filesystem for storing images.
-func (p *cadvisorStatsProvider) ImageFsStats() (*statsapi.FsStats, error) {
-	imageFsInfo, err := p.cadvisor.ImagesFsInfo()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get imageFs info: %v", err)
-	}
-	imageStats, err := p.imageService.ImageStats()
-	if err != nil || imageStats == nil {
-		return nil, fmt.Errorf("failed to get image stats: %v", err)
-	}
-
-	var imageFsInodesUsed *uint64
-	if imageFsInfo.Inodes != nil && imageFsInfo.InodesFree != nil {
-		imageFsIU := *imageFsInfo.Inodes - *imageFsInfo.InodesFree
-		imageFsInodesUsed = &imageFsIU
-	}
-
-	return &statsapi.FsStats{
-		Time:           metav1.NewTime(imageFsInfo.Timestamp),
-		AvailableBytes: &imageFsInfo.Available,
-		CapacityBytes:  &imageFsInfo.Capacity,
-		UsedBytes:      &imageStats.TotalStorageBytes,
-		InodesFree:     imageFsInfo.InodesFree,
-		Inodes:         imageFsInfo.Inodes,
-		InodesUsed:     imageFsInodesUsed,
-	}, nil
-}
-
-// ImageFsDevice returns name of the device where the image filesystem locates,
-// e.g. /dev/sda1.
-func (p *cadvisorStatsProvider) ImageFsDevice() (string, error) {
-	imageFsInfo, err := p.cadvisor.ImagesFsInfo()
-	if err != nil {
-		return "", err
-	}
-	return imageFsInfo.Device, nil
-}
-
 // buildPodRef returns a PodReference that identifies the Pod managing cinfo
 func buildPodRef(containerLabels map[string]string) statsapi.PodReference {
 	podName := kubetypes.GetPodName(containerLabels)

pkg/kubelet/stats/stats_provider.go

@@ -44,18 +44,6 @@ func NewCRIStatsProvider(
 	return newStatsProvider(cadvisor, podManager, runtimeCache, newCRIStatsProvider(cadvisor, resourceAnalyzer, runtimeService, imageService, logMetricsService))
 }
 
-// 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(