Updating dependency github.com/google/cadvisor to version 6a8d614

Signed-off-by: Davanum Srinivas <davanum@gmail.com>

vendor/github.com/google/cadvisor/container/docker/BUILD

@@ -31,7 +31,7 @@ go_library(
         "//vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs:go_default_library",
         "//vendor/github.com/opencontainers/runc/libcontainer/configs:go_default_library",
         "//vendor/golang.org/x/net/context:go_default_library",
-        "//vendor/k8s.io/klog:go_default_library",
+        "//vendor/k8s.io/klog/v2:go_default_library",
     ],
 )
 

vendor/github.com/google/cadvisor/container/docker/docker.go

@@ -134,7 +134,7 @@ func ValidateInfo() (*dockertypes.Info, error) {
 		}
 		dockerInfo.ServerVersion = version.Version
 	}
-	version, err := parseVersion(dockerInfo.ServerVersion, version_re, 3)
+	version, err := parseVersion(dockerInfo.ServerVersion, versionRe, 3)
 	if err != nil {
 		return nil, err
 	}
@@ -150,59 +150,51 @@ func ValidateInfo() (*dockertypes.Info, error) {
 	return &dockerInfo, nil
 }
 
-func Version() ([]int, error) {
-	ver, err := VersionString()
-	if err != nil {
-		return nil, err
-	}
-	return parseVersion(ver, version_re, 3)
-}
-
 func APIVersion() ([]int, error) {
 	ver, err := APIVersionString()
 	if err != nil {
 		return nil, err
 	}
-	return parseVersion(ver, apiversion_re, 2)
+	return parseVersion(ver, apiVersionRe, 2)
 }
 
 func VersionString() (string, error) {
-	docker_version := "Unknown"
+	dockerVersion := "Unknown"
 	client, err := Client()
 	if err == nil {
 		version, err := client.ServerVersion(defaultContext())
 		if err == nil {
-			docker_version = version.Version
+			dockerVersion = version.Version
 		}
 	}
-	return docker_version, err
+	return dockerVersion, err
 }
 
 func APIVersionString() (string, error) {
-	docker_api_version := "Unknown"
+	apiVersion := "Unknown"
 	client, err := Client()
 	if err == nil {
 		version, err := client.ServerVersion(defaultContext())
 		if err == nil {
-			docker_api_version = version.APIVersion
+			apiVersion = version.APIVersion
 		}
 	}
-	return docker_api_version, err
+	return apiVersion, err
 }
 
-func parseVersion(version_string string, regex *regexp.Regexp, length int) ([]int, error) {
-	matches := regex.FindAllStringSubmatch(version_string, -1)
+func parseVersion(versionString string, regex *regexp.Regexp, length int) ([]int, error) {
+	matches := regex.FindAllStringSubmatch(versionString, -1)
 	if len(matches) != 1 {
-		return nil, fmt.Errorf("version string \"%v\" doesn't match expected regular expression: \"%v\"", version_string, regex.String())
+		return nil, fmt.Errorf("version string \"%v\" doesn't match expected regular expression: \"%v\"", versionString, regex.String())
 	}
-	version_string_array := matches[0][1:]
-	version_array := make([]int, length)
-	for index, version_str := range version_string_array {
-		version, err := strconv.Atoi(version_str)
+	versionStringArray := matches[0][1:]
+	versionArray := make([]int, length)
+	for index, versionStr := range versionStringArray {
+		version, err := strconv.Atoi(versionStr)
 		if err != nil {
-			return nil, fmt.Errorf("error while parsing \"%v\" in \"%v\"", version_str, version_string)
+			return nil, fmt.Errorf("error while parsing \"%v\" in \"%v\"", versionStr, versionString)
 		}
-		version_array[index] = version
+		versionArray[index] = version
 	}
-	return version_array, nil
+	return versionArray, nil
 }

vendor/github.com/google/cadvisor/container/docker/factory.go

@@ -38,7 +38,7 @@ import (
 
 	docker "github.com/docker/docker/client"
 	"golang.org/x/net/context"
-	"k8s.io/klog"
+	"k8s.io/klog/v2"
 )
 
 var ArgDockerEndpoint = flag.String("docker", "unix:///var/run/docker.sock", "docker endpoint")
@@ -103,6 +103,7 @@ const (
 	overlayStorageDriver      storageDriver = "overlay"
 	overlay2StorageDriver     storageDriver = "overlay2"
 	zfsStorageDriver          storageDriver = "zfs"
+	vfsStorageDriver          storageDriver = "vfs"
 )
 
 type dockerFactory struct {
@@ -131,11 +132,11 @@ type dockerFactory struct {
 	zfsWatcher *zfs.ZfsWatcher
 }
 
-func (self *dockerFactory) String() string {
+func (f *dockerFactory) String() string {
 	return DockerNamespace
 }
 
-func (self *dockerFactory) NewContainerHandler(name string, inHostNamespace bool) (handler container.ContainerHandler, err error) {
+func (f *dockerFactory) NewContainerHandler(name string, inHostNamespace bool) (handler container.ContainerHandler, err error) {
 	client, err := Client()
 	if err != nil {
 		return
@@ -146,18 +147,18 @@ func (self *dockerFactory) NewContainerHandler(name string, inHostNamespace bool
 	handler, err = newDockerContainerHandler(
 		client,
 		name,
-		self.machineInfoFactory,
-		self.fsInfo,
-		self.storageDriver,
-		self.storageDir,
-		&self.cgroupSubsystems,
+		f.machineInfoFactory,
+		f.fsInfo,
+		f.storageDriver,
+		f.storageDir,
+		&f.cgroupSubsystems,
 		inHostNamespace,
 		metadataEnvs,
-		self.dockerVersion,
-		self.includedMetrics,
-		self.thinPoolName,
-		self.thinPoolWatcher,
-		self.zfsWatcher,
+		f.dockerVersion,
+		f.includedMetrics,
+		f.thinPoolName,
+		f.thinPoolWatcher,
+		f.zfsWatcher,
 	)
 	return
 }
@@ -184,7 +185,7 @@ func isContainerName(name string) bool {
 }
 
 // Docker handles all containers under /docker
-func (self *dockerFactory) CanHandleAndAccept(name string) (bool, bool, error) {
+func (f *dockerFactory) CanHandleAndAccept(name string) (bool, bool, error) {
 	// if the container is not associated with docker, we can't handle it or accept it.
 	if !isContainerName(name) {
 		return false, false, nil
@@ -194,7 +195,7 @@ func (self *dockerFactory) CanHandleAndAccept(name string) (bool, bool, error) {
 	id := ContainerNameToDockerId(name)
 
 	// We assume that if Inspect fails then the container is not known to docker.
-	ctnr, err := self.client.ContainerInspect(context.Background(), id)
+	ctnr, err := f.client.ContainerInspect(context.Background(), id)
 	if err != nil || !ctnr.State.Running {
 		return false, true, fmt.Errorf("error inspecting container: %v", err)
 	}
@@ -202,15 +203,15 @@ func (self *dockerFactory) CanHandleAndAccept(name string) (bool, bool, error) {
 	return true, true, nil
 }
 
-func (self *dockerFactory) DebugInfo() map[string][]string {
+func (f *dockerFactory) DebugInfo() map[string][]string {
 	return map[string][]string{}
 }
 
 var (
-	version_regexp_string    = `(\d+)\.(\d+)\.(\d+)`
-	version_re               = regexp.MustCompile(version_regexp_string)
-	apiversion_regexp_string = `(\d+)\.(\d+)`
-	apiversion_re            = regexp.MustCompile(apiversion_regexp_string)
+	versionRegexpString    = `(\d+)\.(\d+)\.(\d+)`
+	versionRe              = regexp.MustCompile(versionRegexpString)
+	apiVersionRegexpString = `(\d+)\.(\d+)`
+	apiVersionRe           = regexp.MustCompile(apiVersionRegexpString)
 )
 
 func startThinPoolWatcher(dockerInfo *dockertypes.Info) (*devicemapper.ThinPoolWatcher, error) {
@@ -268,7 +269,7 @@ func ensureThinLsKernelVersion(kernelVersion string) error {
 	// thin_ls to work without corrupting the thin pool
 	minRhel7KernelVersion := semver.MustParse("3.10.0")
 
-	matches := version_re.FindStringSubmatch(kernelVersion)
+	matches := versionRe.FindStringSubmatch(kernelVersion)
 	if len(matches) < 4 {
 		return fmt.Errorf("error parsing kernel version: %q is not a semver", kernelVersion)
 	}
@@ -334,7 +335,7 @@ func Register(factory info.MachineInfoFactory, fsInfo fs.FsInfo, includedMetrics
 	}
 
 	// Version already validated above, assume no error here.
-	dockerVersion, _ := parseVersion(dockerInfo.ServerVersion, version_re, 3)
+	dockerVersion, _ := parseVersion(dockerInfo.ServerVersion, versionRe, 3)
 
 	dockerAPIVersion, _ := APIVersion()
 

vendor/github.com/google/cadvisor/container/docker/handler.go

@@ -37,7 +37,7 @@ import (
 	cgroupfs "github.com/opencontainers/runc/libcontainer/cgroups/fs"
 	libcontainerconfigs "github.com/opencontainers/runc/libcontainer/configs"
 	"golang.org/x/net/context"
-	"k8s.io/klog"
+	"k8s.io/klog/v2"
 )
 
 const (
@@ -174,6 +174,8 @@ func newDockerContainerHandler(
 		rootfsStorageDir = path.Join(storageDir, string(storageDriver), rwLayerID, overlayRWLayer)
 	case overlay2StorageDriver:
 		rootfsStorageDir = path.Join(storageDir, string(storageDriver), rwLayerID, overlay2RWLayer)
+	case vfsStorageDriver:
+		rootfsStorageDir = path.Join(storageDir)
 	case zfsStorageDriver:
 		status, err := Status()
 		if err != nil {
@@ -230,8 +232,8 @@ func newDockerContainerHandler(
 	ipAddress := ctnr.NetworkSettings.IPAddress
 	networkMode := string(ctnr.HostConfig.NetworkMode)
 	if ipAddress == "" && strings.HasPrefix(networkMode, "container:") {
-		containerId := strings.TrimPrefix(networkMode, "container:")
-		c, err := client.ContainerInspect(context.Background(), containerId)
+		containerID := strings.TrimPrefix(networkMode, "container:")
+		c, err := client.ContainerInspect(context.Background(), containerID)
 		if err != nil {
 			return nil, fmt.Errorf("failed to inspect container %q: %v", id, err)
 		}
@@ -329,68 +331,68 @@ func (h *dockerFsHandler) Usage() common.FsUsage {
 	return usage
 }
 
-func (self *dockerContainerHandler) Start() {
-	if self.fsHandler != nil {
-		self.fsHandler.Start()
+func (h *dockerContainerHandler) Start() {
+	if h.fsHandler != nil {
+		h.fsHandler.Start()
 	}
 }
 
-func (self *dockerContainerHandler) Cleanup() {
-	if self.fsHandler != nil {
-		self.fsHandler.Stop()
+func (h *dockerContainerHandler) Cleanup() {
+	if h.fsHandler != nil {
+		h.fsHandler.Stop()
 	}
 }
 
-func (self *dockerContainerHandler) ContainerReference() (info.ContainerReference, error) {
-	return self.reference, nil
+func (h *dockerContainerHandler) ContainerReference() (info.ContainerReference, error) {
+	return h.reference, nil
 }
 
-func (self *dockerContainerHandler) needNet() bool {
-	if self.includedMetrics.Has(container.NetworkUsageMetrics) {
-		return !self.networkMode.IsContainer()
+func (h *dockerContainerHandler) needNet() bool {
+	if h.includedMetrics.Has(container.NetworkUsageMetrics) {
+		return !h.networkMode.IsContainer()
 	}
 	return false
 }
 
-func (self *dockerContainerHandler) GetSpec() (info.ContainerSpec, error) {
-	hasFilesystem := self.includedMetrics.Has(container.DiskUsageMetrics)
-	spec, err := common.GetSpec(self.cgroupPaths, self.machineInfoFactory, self.needNet(), hasFilesystem)
+func (h *dockerContainerHandler) GetSpec() (info.ContainerSpec, error) {
+	hasFilesystem := h.includedMetrics.Has(container.DiskUsageMetrics)
+	spec, err := common.GetSpec(h.cgroupPaths, h.machineInfoFactory, h.needNet(), hasFilesystem)
 
-	spec.Labels = self.labels
-	spec.Envs = self.envs
-	spec.Image = self.image
-	spec.CreationTime = self.creationTime
+	spec.Labels = h.labels
+	spec.Envs = h.envs
+	spec.Image = h.image
+	spec.CreationTime = h.creationTime
 
 	return spec, err
 }
 
-func (self *dockerContainerHandler) getFsStats(stats *info.ContainerStats) error {
-	mi, err := self.machineInfoFactory.GetMachineInfo()
+func (h *dockerContainerHandler) getFsStats(stats *info.ContainerStats) error {
+	mi, err := h.machineInfoFactory.GetMachineInfo()
 	if err != nil {
 		return err
 	}
 
-	if self.includedMetrics.Has(container.DiskIOMetrics) {
+	if h.includedMetrics.Has(container.DiskIOMetrics) {
 		common.AssignDeviceNamesToDiskStats((*common.MachineInfoNamer)(mi), &stats.DiskIo)
 	}
 
-	if !self.includedMetrics.Has(container.DiskUsageMetrics) {
+	if !h.includedMetrics.Has(container.DiskUsageMetrics) {
 		return nil
 	}
 	var device string
-	switch self.storageDriver {
+	switch h.storageDriver {
 	case devicemapperStorageDriver:
 		// Device has to be the pool name to correlate with the device name as
 		// set in the machine info filesystems.
-		device = self.poolName
-	case aufsStorageDriver, overlayStorageDriver, overlay2StorageDriver:
-		deviceInfo, err := self.fsInfo.GetDirFsDevice(self.rootfsStorageDir)
+		device = h.poolName
+	case aufsStorageDriver, overlayStorageDriver, overlay2StorageDriver, vfsStorageDriver:
+		deviceInfo, err := h.fsInfo.GetDirFsDevice(h.rootfsStorageDir)
 		if err != nil {
-			return fmt.Errorf("unable to determine device info for dir: %v: %v", self.rootfsStorageDir, err)
+			return fmt.Errorf("unable to determine device info for dir: %v: %v", h.rootfsStorageDir, err)
 		}
 		device = deviceInfo.Device
 	case zfsStorageDriver:
-		device = self.zfsParent
+		device = h.zfsParent
 	default:
 		return nil
 	}
@@ -410,7 +412,7 @@ func (self *dockerContainerHandler) getFsStats(stats *info.ContainerStats) error
 	}
 
 	fsStat := info.FsStats{Device: device, Type: fsType, Limit: limit}
-	usage := self.fsHandler.Usage()
+	usage := h.fsHandler.Usage()
 	fsStat.BaseUsage = usage.BaseUsageBytes
 	fsStat.Usage = usage.TotalUsageBytes
 	fsStat.Inodes = usage.InodeUsage
@@ -421,8 +423,8 @@ func (self *dockerContainerHandler) getFsStats(stats *info.ContainerStats) error
 }
 
 // TODO(vmarmol): Get from libcontainer API instead of cgroup manager when we don't have to support older Dockers.
-func (self *dockerContainerHandler) GetStats() (*info.ContainerStats, error) {
-	stats, err := self.libcontainerHandler.GetStats()
+func (h *dockerContainerHandler) GetStats() (*info.ContainerStats, error) {
+	stats, err := h.libcontainerHandler.GetStats()
 	if err != nil {
 		return stats, err
 	}
@@ -430,12 +432,12 @@ func (self *dockerContainerHandler) GetStats() (*info.ContainerStats, error) {
 	// includes containers running in Kubernetes pods that use the network of the
 	// infrastructure container. This stops metrics being reported multiple times
 	// for each container in a pod.
-	if !self.needNet() {
+	if !h.needNet() {
 		stats.Network = info.NetworkStats{}
 	}
 
 	// Get filesystem stats.
-	err = self.getFsStats(stats)
+	err = h.getFsStats(stats)
 	if err != nil {
 		return stats, err
 	}
@@ -443,35 +445,35 @@ func (self *dockerContainerHandler) GetStats() (*info.ContainerStats, error) {
 	return stats, nil
 }
 
-func (self *dockerContainerHandler) ListContainers(listType container.ListType) ([]info.ContainerReference, error) {
+func (h *dockerContainerHandler) ListContainers(listType container.ListType) ([]info.ContainerReference, error) {
 	// No-op for Docker driver.
 	return []info.ContainerReference{}, nil
 }
 
-func (self *dockerContainerHandler) GetCgroupPath(resource string) (string, error) {
-	path, ok := self.cgroupPaths[resource]
+func (h *dockerContainerHandler) GetCgroupPath(resource string) (string, error) {
+	path, ok := h.cgroupPaths[resource]
 	if !ok {
-		return "", fmt.Errorf("could not find path for resource %q for container %q\n", resource, self.reference.Name)
+		return "", fmt.Errorf("could not find path for resource %q for container %q", resource, h.reference.Name)
 	}
 	return path, nil
 }
 
-func (self *dockerContainerHandler) GetContainerLabels() map[string]string {
-	return self.labels
+func (h *dockerContainerHandler) GetContainerLabels() map[string]string {
+	return h.labels
 }
 
-func (self *dockerContainerHandler) GetContainerIPAddress() string {
-	return self.ipAddress
+func (h *dockerContainerHandler) GetContainerIPAddress() string {
+	return h.ipAddress
 }
 
-func (self *dockerContainerHandler) ListProcesses(listType container.ListType) ([]int, error) {
-	return self.libcontainerHandler.GetProcesses()
+func (h *dockerContainerHandler) ListProcesses(listType container.ListType) ([]int, error) {
+	return h.libcontainerHandler.GetProcesses()
 }
 
-func (self *dockerContainerHandler) Exists() bool {
-	return common.CgroupExists(self.cgroupPaths)
+func (h *dockerContainerHandler) Exists() bool {
+	return common.CgroupExists(h.cgroupPaths)
 }
 
-func (self *dockerContainerHandler) Type() container.ContainerType {
+func (h *dockerContainerHandler) Type() container.ContainerType {
 	return container.ContainerTypeDocker
 }

vendor/github.com/google/cadvisor/container/docker/install/BUILD

@@ -9,7 +9,7 @@ go_library(
     deps = [
         "//vendor/github.com/google/cadvisor/container:go_default_library",
         "//vendor/github.com/google/cadvisor/container/docker:go_default_library",
-        "//vendor/k8s.io/klog:go_default_library",
+        "//vendor/k8s.io/klog/v2:go_default_library",
     ],
 )
 

vendor/github.com/google/cadvisor/container/docker/install/install.go

@@ -18,7 +18,7 @@ package install
 import (
 	"github.com/google/cadvisor/container"
 	"github.com/google/cadvisor/container/docker"
-	"k8s.io/klog"
+	"k8s.io/klog/v2"
 )
 
 func init() {

vendor/github.com/google/cadvisor/container/docker/plugin.go

@@ -22,7 +22,7 @@ import (
 	info "github.com/google/cadvisor/info/v1"
 	"github.com/google/cadvisor/watcher"
 	"golang.org/x/net/context"
-	"k8s.io/klog"
+	"k8s.io/klog/v2"
 )
 
 const dockerClientTimeout = 10 * time.Second

vendor/github.com/google/cadvisor/container/docker/utils/docker.go

@@ -23,10 +23,7 @@ import (
 )
 
 const (
-	DockerInfoDriver          = "Driver"
-	DockerInfoDriverStatus    = "DriverStatus"
 	DriverStatusPoolName      = "Pool Name"
-	DriverStatusDataLoopFile  = "Data loop file"
 	DriverStatusMetadataFile  = "Metadata file"
 	DriverStatusParentDataset = "Parent Dataset"
 )