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

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

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

@@ -20,7 +20,7 @@ go_library(
         "//vendor/github.com/google/cadvisor/watcher:go_default_library",
         "//vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs:go_default_library",
         "//vendor/github.com/opencontainers/runc/libcontainer/configs:go_default_library",
-        "//vendor/k8s.io/klog:go_default_library",
+        "//vendor/k8s.io/klog/v2:go_default_library",
     ],
 )
 

vendor/github.com/google/cadvisor/container/crio/client.go

@@ -15,10 +15,12 @@
 package crio
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"net"
 	"net/http"
+	"sync"
 	"syscall"
 	"time"
 )
@@ -28,6 +30,12 @@ const (
 	maxUnixSocketPathSize = len(syscall.RawSockaddrUnix{}.Path)
 )
 
+var (
+	theClient      CrioClient
+	clientErr      error
+	crioClientOnce sync.Once
+)
+
 // Info represents CRI-O information as sent by the CRI-O server
 type Info struct {
 	StorageDriver string `json:"storage_driver"`
@@ -45,9 +53,10 @@ type ContainerInfo struct {
 	LogPath     string            `json:"log_path"`
 	Root        string            `json:"root"`
 	IP          string            `json:"ip_address"`
+	IPs         []string          `json:"ip_addresses"`
 }
 
-type crioClient interface {
+type CrioClient interface {
 	Info() (Info, error)
 	ContainerInfo(string) (*ContainerInfo, error)
 }
@@ -62,22 +71,27 @@ func configureUnixTransport(tr *http.Transport, proto, addr string) error {
 	}
 	// No need for compression in local communications.
 	tr.DisableCompression = true
-	tr.Dial = func(_, _ string) (net.Conn, error) {
+	tr.DialContext = func(_ context.Context, _, _ string) (net.Conn, error) {
 		return net.DialTimeout(proto, addr, 32*time.Second)
 	}
 	return nil
 }
 
 // Client returns a new configured CRI-O client
-func Client() (crioClient, error) {
-	tr := new(http.Transport)
-	configureUnixTransport(tr, "unix", CrioSocket)
-	c := &http.Client{
-		Transport: tr,
-	}
-	return &crioClientImpl{
-		client: c,
-	}, nil
+func Client() (CrioClient, error) {
+	crioClientOnce.Do(func() {
+		tr := new(http.Transport)
+		theClient = nil
+		if clientErr = configureUnixTransport(tr, "unix", CrioSocket); clientErr != nil {
+			return
+		}
+		theClient = &crioClientImpl{
+			client: &http.Client{
+				Transport: tr,
+			},
+		}
+	})
+	return theClient, clientErr
 }
 
 func getRequest(path string) (*http.Request, error) {
@@ -117,6 +131,7 @@ func (c *crioClientImpl) ContainerInfo(id string) (*ContainerInfo, error) {
 	if err != nil {
 		return nil, err
 	}
+	cInfo := ContainerInfo{}
 	resp, err := c.client.Do(req)
 	if err != nil {
 		return nil, err
@@ -129,9 +144,14 @@ func (c *crioClientImpl) ContainerInfo(id string) (*ContainerInfo, error) {
 		return nil, fmt.Errorf("Error finding container %s: Status %d returned error %s", id, resp.StatusCode, resp.Body)
 	}
 
-	cInfo := ContainerInfo{}
 	if err := json.NewDecoder(resp.Body).Decode(&cInfo); err != nil {
 		return nil, err
 	}
+	if len(cInfo.IP) > 0 {
+		return &cInfo, nil
+	}
+	if len(cInfo.IPs) > 0 {
+		cInfo.IP = cInfo.IPs[0]
+	}
 	return &cInfo, nil
 }

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

@@ -26,7 +26,7 @@ import (
 	info "github.com/google/cadvisor/info/v1"
 	"github.com/google/cadvisor/watcher"
 
-	"k8s.io/klog"
+	"k8s.io/klog/v2"
 )
 
 // The namespace under which crio aliases are unique.
@@ -57,14 +57,14 @@ type crioFactory struct {
 
 	includedMetrics container.MetricSet
 
-	client crioClient
+	client CrioClient
 }
 
-func (self *crioFactory) String() string {
+func (f *crioFactory) String() string {
 	return CrioNamespace
 }
 
-func (self *crioFactory) NewContainerHandler(name string, inHostNamespace bool) (handler container.ContainerHandler, err error) {
+func (f *crioFactory) NewContainerHandler(name string, inHostNamespace bool) (handler container.ContainerHandler, err error) {
 	client, err := Client()
 	if err != nil {
 		return
@@ -74,14 +74,14 @@ func (self *crioFactory) NewContainerHandler(name string, inHostNamespace bool)
 	handler, err = newCrioContainerHandler(
 		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.includedMetrics,
+		f.includedMetrics,
 	)
 	return
 }
@@ -108,7 +108,7 @@ func isContainerName(name string) bool {
 }
 
 // crio handles all containers under /crio
-func (self *crioFactory) CanHandleAndAccept(name string) (bool, bool, error) {
+func (f *crioFactory) CanHandleAndAccept(name string) (bool, bool, error) {
 	if strings.HasPrefix(path.Base(name), "crio-conmon") {
 		// TODO(runcom): should we include crio-conmon cgroups?
 		return false, false, nil
@@ -123,18 +123,10 @@ func (self *crioFactory) CanHandleAndAccept(name string) (bool, bool, error) {
 	return true, true, nil
 }
 
-func (self *crioFactory) DebugInfo() map[string][]string {
+func (f *crioFactory) DebugInfo() map[string][]string {
 	return map[string][]string{}
 }
 
-var (
-	// TODO(runcom): handle versioning in CRI-O
-	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)
-)
-
 // Register root container before running this function!
 func Register(factory info.MachineInfoFactory, fsInfo fs.FsInfo, includedMetrics container.MetricSet) error {
 	client, err := Client()

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

@@ -17,7 +17,6 @@ package crio
 
 import (
 	"fmt"
-	"path"
 	"path/filepath"
 	"strconv"
 	"strings"
@@ -33,7 +32,7 @@ import (
 )
 
 type crioContainerHandler struct {
-	client crioClient
+	client CrioClient
 	name   string
 
 	machineInfoFactory info.MachineInfoFactory
@@ -80,7 +79,7 @@ var _ container.ContainerHandler = &crioContainerHandler{}
 
 // newCrioContainerHandler returns a new container.ContainerHandler
 func newCrioContainerHandler(
-	client crioClient,
+	client CrioClient,
 	name string,
 	machineInfoFactory info.MachineInfoFactory,
 	fsInfo fs.FsInfo,
@@ -105,7 +104,6 @@ func newCrioContainerHandler(
 	rootFs := "/"
 	if !inHostNamespace {
 		rootFs = "/rootfs"
-		storageDir = path.Join(rootFs, storageDir)
 	}
 
 	id := ContainerNameToCrioId(name)
@@ -199,59 +197,59 @@ func newCrioContainerHandler(
 	return handler, nil
 }
 
-func (self *crioContainerHandler) Start() {
-	if self.fsHandler != nil {
-		self.fsHandler.Start()
+func (h *crioContainerHandler) Start() {
+	if h.fsHandler != nil {
+		h.fsHandler.Start()
 	}
 }
 
-func (self *crioContainerHandler) Cleanup() {
-	if self.fsHandler != nil {
-		self.fsHandler.Stop()
+func (h *crioContainerHandler) Cleanup() {
+	if h.fsHandler != nil {
+		h.fsHandler.Stop()
 	}
 }
 
-func (self *crioContainerHandler) ContainerReference() (info.ContainerReference, error) {
-	return self.reference, nil
+func (h *crioContainerHandler) ContainerReference() (info.ContainerReference, error) {
+	return h.reference, nil
 }
 
-func (self *crioContainerHandler) needNet() bool {
-	if self.includedMetrics.Has(container.NetworkUsageMetrics) {
-		return self.labels["io.kubernetes.container.name"] == "POD"
+func (h *crioContainerHandler) needNet() bool {
+	if h.includedMetrics.Has(container.NetworkUsageMetrics) {
+		return h.labels["io.kubernetes.container.name"] == "POD"
 	}
 	return false
 }
 
-func (self *crioContainerHandler) GetSpec() (info.ContainerSpec, error) {
-	hasFilesystem := self.includedMetrics.Has(container.DiskUsageMetrics)
-	spec, err := common.GetSpec(self.cgroupPaths, self.machineInfoFactory, self.needNet(), hasFilesystem)
+func (h *crioContainerHandler) 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.Labels = h.labels
+	spec.Envs = h.envs
+	spec.Image = h.image
 
 	return spec, err
 }
 
-func (self *crioContainerHandler) getFsStats(stats *info.ContainerStats) error {
-	mi, err := self.machineInfoFactory.GetMachineInfo()
+func (h *crioContainerHandler) 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 overlay2StorageDriver, overlayStorageDriver:
-		deviceInfo, err := self.fsInfo.GetDirFsDevice(self.rootfsStorageDir)
+		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
 	default:
@@ -276,7 +274,7 @@ func (self *crioContainerHandler) getFsStats(stats *info.ContainerStats) error {
 		return fmt.Errorf("unable to determine fs type for device: %v", device)
 	}
 	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
@@ -286,26 +284,26 @@ func (self *crioContainerHandler) getFsStats(stats *info.ContainerStats) error {
 	return nil
 }
 
-func (self *crioContainerHandler) getLibcontainerHandler() *containerlibcontainer.Handler {
-	if self.pidKnown {
-		return self.libcontainerHandler
+func (h *crioContainerHandler) getLibcontainerHandler() *containerlibcontainer.Handler {
+	if h.pidKnown {
+		return h.libcontainerHandler
 	}
 
-	id := ContainerNameToCrioId(self.name)
+	id := ContainerNameToCrioId(h.name)
 
-	cInfo, err := self.client.ContainerInfo(id)
+	cInfo, err := h.client.ContainerInfo(id)
 	if err != nil || cInfo.Pid == 0 {
-		return self.libcontainerHandler
+		return h.libcontainerHandler
 	}
 
-	self.pidKnown = true
-	self.libcontainerHandler = containerlibcontainer.NewHandler(self.cgroupManager, self.rootFs, cInfo.Pid, self.includedMetrics)
+	h.pidKnown = true
+	h.libcontainerHandler = containerlibcontainer.NewHandler(h.cgroupManager, h.rootFs, cInfo.Pid, h.includedMetrics)
 
-	return self.libcontainerHandler
+	return h.libcontainerHandler
 }
 
-func (self *crioContainerHandler) GetStats() (*info.ContainerStats, error) {
-	libcontainerHandler := self.getLibcontainerHandler()
+func (h *crioContainerHandler) GetStats() (*info.ContainerStats, error) {
+	libcontainerHandler := h.getLibcontainerHandler()
 	stats, err := libcontainerHandler.GetStats()
 	if err != nil {
 		return stats, err
@@ -314,12 +312,12 @@ func (self *crioContainerHandler) 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
 	}
@@ -327,35 +325,35 @@ func (self *crioContainerHandler) GetStats() (*info.ContainerStats, error) {
 	return stats, nil
 }
 
-func (self *crioContainerHandler) ListContainers(listType container.ListType) ([]info.ContainerReference, error) {
+func (h *crioContainerHandler) ListContainers(listType container.ListType) ([]info.ContainerReference, error) {
 	// No-op for Docker driver.
 	return []info.ContainerReference{}, nil
 }
 
-func (self *crioContainerHandler) GetCgroupPath(resource string) (string, error) {
-	path, ok := self.cgroupPaths[resource]
+func (h *crioContainerHandler) 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 *crioContainerHandler) GetContainerLabels() map[string]string {
-	return self.labels
+func (h *crioContainerHandler) GetContainerLabels() map[string]string {
+	return h.labels
 }
 
-func (self *crioContainerHandler) GetContainerIPAddress() string {
-	return self.ipAddress
+func (h *crioContainerHandler) GetContainerIPAddress() string {
+	return h.ipAddress
 }
 
-func (self *crioContainerHandler) ListProcesses(listType container.ListType) ([]int, error) {
-	return self.libcontainerHandler.GetProcesses()
+func (h *crioContainerHandler) ListProcesses(listType container.ListType) ([]int, error) {
+	return h.libcontainerHandler.GetProcesses()
 }
 
-func (self *crioContainerHandler) Exists() bool {
-	return common.CgroupExists(self.cgroupPaths)
+func (h *crioContainerHandler) Exists() bool {
+	return common.CgroupExists(h.cgroupPaths)
 }
 
-func (self *crioContainerHandler) Type() container.ContainerType {
+func (h *crioContainerHandler) Type() container.ContainerType {
 	return container.ContainerTypeCrio
 }

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

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

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

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

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

@@ -19,7 +19,7 @@ import (
 	"github.com/google/cadvisor/fs"
 	info "github.com/google/cadvisor/info/v1"
 	"github.com/google/cadvisor/watcher"
-	"k8s.io/klog"
+	"k8s.io/klog/v2"
 )
 
 // NewPlugin returns an implementation of container.Plugin suitable for passing to container.RegisterPlugin()