rebase: update K8s packages to v0.32.1

Update K8s packages in go.mod to v0.32.1

Signed-off-by: Praveen M <m.praveen@ibm.com>

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

@@ -0,0 +1,114 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// 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 raw
+
+import (
+	"flag"
+	"fmt"
+	"strings"
+
+	"github.com/google/cadvisor/container"
+	"github.com/google/cadvisor/container/common"
+	"github.com/google/cadvisor/container/libcontainer"
+	"github.com/google/cadvisor/fs"
+	info "github.com/google/cadvisor/info/v1"
+	watch "github.com/google/cadvisor/watcher"
+
+	"k8s.io/klog/v2"
+)
+
+var (
+	DockerOnly             = flag.Bool("docker_only", false, "Only report docker containers in addition to root stats")
+	disableRootCgroupStats = flag.Bool("disable_root_cgroup_stats", false, "Disable collecting root Cgroup stats")
+)
+
+type rawFactory struct {
+	// Factory for machine information.
+	machineInfoFactory info.MachineInfoFactory
+
+	// Information about the cgroup subsystems.
+	cgroupSubsystems map[string]string
+
+	// Information about mounted filesystems.
+	fsInfo fs.FsInfo
+
+	// Watcher for inotify events.
+	watcher *common.InotifyWatcher
+
+	// List of metrics to be included.
+	includedMetrics map[container.MetricKind]struct{}
+
+	// List of raw container cgroup path prefix whitelist.
+	rawPrefixWhiteList []string
+}
+
+func (f *rawFactory) String() string {
+	return "raw"
+}
+
+func (f *rawFactory) NewContainerHandler(name string, metadataEnvAllowList []string, inHostNamespace bool) (container.ContainerHandler, error) {
+	rootFs := "/"
+	if !inHostNamespace {
+		rootFs = "/rootfs"
+	}
+	return newRawContainerHandler(name, f.cgroupSubsystems, f.machineInfoFactory, f.fsInfo, f.watcher, rootFs, f.includedMetrics)
+}
+
+// The raw factory can handle any container. If --docker_only is set to true, non-docker containers are ignored except for "/" and those whitelisted by raw_cgroup_prefix_whitelist flag.
+func (f *rawFactory) CanHandleAndAccept(name string) (bool, bool, error) {
+	if name == "/" {
+		return true, true, nil
+	}
+	if *DockerOnly && f.rawPrefixWhiteList[0] == "" {
+		return true, false, nil
+	}
+	for _, prefix := range f.rawPrefixWhiteList {
+		if strings.HasPrefix(name, prefix) {
+			return true, true, nil
+		}
+	}
+	return true, false, nil
+}
+
+func (f *rawFactory) DebugInfo() map[string][]string {
+	return common.DebugInfo(f.watcher.GetWatches())
+}
+
+func Register(machineInfoFactory info.MachineInfoFactory, fsInfo fs.FsInfo, includedMetrics map[container.MetricKind]struct{}, rawPrefixWhiteList []string) error {
+	cgroupSubsystems, err := libcontainer.GetCgroupSubsystems(includedMetrics)
+	if err != nil {
+		return fmt.Errorf("failed to get cgroup subsystems: %v", err)
+	}
+	if len(cgroupSubsystems) == 0 {
+		return fmt.Errorf("failed to find supported cgroup mounts for the raw factory")
+	}
+
+	watcher, err := common.NewInotifyWatcher()
+	if err != nil {
+		return err
+	}
+
+	klog.V(1).Infof("Registering Raw factory")
+	factory := &rawFactory{
+		machineInfoFactory: machineInfoFactory,
+		fsInfo:             fsInfo,
+		cgroupSubsystems:   cgroupSubsystems,
+		watcher:            watcher,
+		includedMetrics:    includedMetrics,
+		rawPrefixWhiteList: rawPrefixWhiteList,
+	}
+	container.RegisterContainerHandlerFactory(factory, []watch.ContainerWatchSource{watch.Raw})
+	return nil
+}

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

@@ -0,0 +1,304 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// 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.
+
+// Handler for "raw" containers.
+package raw
+
+import (
+	"fmt"
+
+	"github.com/google/cadvisor/container"
+	"github.com/google/cadvisor/container/common"
+	"github.com/google/cadvisor/container/libcontainer"
+	"github.com/google/cadvisor/fs"
+	info "github.com/google/cadvisor/info/v1"
+	"github.com/google/cadvisor/machine"
+	"github.com/opencontainers/runc/libcontainer/cgroups"
+
+	"k8s.io/klog/v2"
+)
+
+type rawContainerHandler struct {
+	// Name of the container for this handler.
+	name               string
+	machineInfoFactory info.MachineInfoFactory
+
+	// Absolute path to the cgroup hierarchies of this container.
+	// (e.g.: "cpu" -> "/sys/fs/cgroup/cpu/test")
+	cgroupPaths map[string]string
+
+	fsInfo          fs.FsInfo
+	externalMounts  []common.Mount
+	includedMetrics container.MetricSet
+
+	libcontainerHandler *libcontainer.Handler
+}
+
+func isRootCgroup(name string) bool {
+	return name == "/"
+}
+
+func newRawContainerHandler(name string, cgroupSubsystems map[string]string, machineInfoFactory info.MachineInfoFactory, fsInfo fs.FsInfo, watcher *common.InotifyWatcher, rootFs string, includedMetrics container.MetricSet) (container.ContainerHandler, error) {
+	cHints, err := common.GetContainerHintsFromFile(*common.ArgContainerHints)
+	if err != nil {
+		return nil, err
+	}
+
+	cgroupPaths := common.MakeCgroupPaths(cgroupSubsystems, name)
+
+	cgroupManager, err := libcontainer.NewCgroupManager(name, cgroupPaths)
+	if err != nil {
+		return nil, err
+	}
+
+	var externalMounts []common.Mount
+	for _, container := range cHints.AllHosts {
+		if name == container.FullName {
+			externalMounts = container.Mounts
+			break
+		}
+	}
+
+	pid := 0
+	if isRootCgroup(name) {
+		pid = 1
+
+		// delete pids from cgroup paths because /sys/fs/cgroup/pids/pids.current not exist
+		delete(cgroupPaths, "pids")
+	}
+
+	handler := libcontainer.NewHandler(cgroupManager, rootFs, pid, includedMetrics)
+
+	return &rawContainerHandler{
+		name:                name,
+		machineInfoFactory:  machineInfoFactory,
+		cgroupPaths:         cgroupPaths,
+		fsInfo:              fsInfo,
+		externalMounts:      externalMounts,
+		includedMetrics:     includedMetrics,
+		libcontainerHandler: handler,
+	}, nil
+}
+
+func (h *rawContainerHandler) ContainerReference() (info.ContainerReference, error) {
+	// We only know the container by its one name.
+	return info.ContainerReference{
+		Name: h.name,
+	}, nil
+}
+
+func (h *rawContainerHandler) GetRootNetworkDevices() ([]info.NetInfo, error) {
+	nd := []info.NetInfo{}
+	if isRootCgroup(h.name) {
+		mi, err := h.machineInfoFactory.GetMachineInfo()
+		if err != nil {
+			return nd, err
+		}
+		return mi.NetworkDevices, nil
+	}
+	return nd, nil
+}
+
+// Nothing to start up.
+func (h *rawContainerHandler) Start() {}
+
+// Nothing to clean up.
+func (h *rawContainerHandler) Cleanup() {}
+
+func (h *rawContainerHandler) GetSpec() (info.ContainerSpec, error) {
+	const hasNetwork = false
+	hasFilesystem := isRootCgroup(h.name) || len(h.externalMounts) > 0
+	spec, err := common.GetSpec(h.cgroupPaths, h.machineInfoFactory, hasNetwork, hasFilesystem)
+	if err != nil {
+		return spec, err
+	}
+
+	if isRootCgroup(h.name) {
+		// Check physical network devices for root container.
+		nd, err := h.GetRootNetworkDevices()
+		if err != nil {
+			return spec, err
+		}
+		spec.HasNetwork = spec.HasNetwork || len(nd) != 0
+
+		// Get memory and swap limits of the running machine
+		memLimit, err := machine.GetMachineMemoryCapacity()
+		if err != nil {
+			klog.Warningf("failed to obtain memory limit for machine container")
+			spec.HasMemory = false
+		} else {
+			spec.Memory.Limit = uint64(memLimit)
+			// Spec is marked to have memory only if the memory limit is set
+			spec.HasMemory = true
+		}
+
+		swapLimit, err := machine.GetMachineSwapCapacity()
+		if err != nil {
+			klog.Warningf("failed to obtain swap limit for machine container")
+		} else {
+			spec.Memory.SwapLimit = uint64(swapLimit)
+		}
+	}
+
+	return spec, nil
+}
+
+func fsToFsStats(fs *fs.Fs) info.FsStats {
+	inodes := uint64(0)
+	inodesFree := uint64(0)
+	hasInodes := fs.InodesFree != nil
+	if hasInodes {
+		inodes = *fs.Inodes
+		inodesFree = *fs.InodesFree
+	}
+	return info.FsStats{
+		Device:          fs.Device,
+		Type:            fs.Type.String(),
+		Limit:           fs.Capacity,
+		Usage:           fs.Capacity - fs.Free,
+		HasInodes:       hasInodes,
+		Inodes:          inodes,
+		InodesFree:      inodesFree,
+		Available:       fs.Available,
+		ReadsCompleted:  fs.DiskStats.ReadsCompleted,
+		ReadsMerged:     fs.DiskStats.ReadsMerged,
+		SectorsRead:     fs.DiskStats.SectorsRead,
+		ReadTime:        fs.DiskStats.ReadTime,
+		WritesCompleted: fs.DiskStats.WritesCompleted,
+		WritesMerged:    fs.DiskStats.WritesMerged,
+		SectorsWritten:  fs.DiskStats.SectorsWritten,
+		WriteTime:       fs.DiskStats.WriteTime,
+		IoInProgress:    fs.DiskStats.IoInProgress,
+		IoTime:          fs.DiskStats.IoTime,
+		WeightedIoTime:  fs.DiskStats.WeightedIoTime,
+	}
+}
+
+func (h *rawContainerHandler) getFsStats(stats *info.ContainerStats) error {
+	var filesystems []fs.Fs
+	var err error
+	// Early exist if no disk metrics are to be collected.
+	if !h.includedMetrics.Has(container.DiskUsageMetrics) && !h.includedMetrics.Has(container.DiskIOMetrics) {
+		return nil
+	}
+
+	// Get Filesystem information only for the root cgroup.
+	if isRootCgroup(h.name) {
+		filesystems, err = h.fsInfo.GetGlobalFsInfo()
+		if err != nil {
+			return err
+		}
+	} else {
+		if len(h.externalMounts) > 0 {
+			mountSet := make(map[string]struct{})
+			for _, mount := range h.externalMounts {
+				mountSet[mount.HostDir] = struct{}{}
+			}
+			filesystems, err = h.fsInfo.GetFsInfoForPath(mountSet)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	if h.includedMetrics.Has(container.DiskUsageMetrics) {
+		for i := range filesystems {
+			fs := filesystems[i]
+			stats.Filesystem = append(stats.Filesystem, fsToFsStats(&fs))
+		}
+	}
+
+	if h.includedMetrics.Has(container.DiskIOMetrics) {
+		common.AssignDeviceNamesToDiskStats(&fsNamer{fs: filesystems, factory: h.machineInfoFactory}, &stats.DiskIo)
+
+	}
+	return nil
+}
+
+func (h *rawContainerHandler) GetStats() (*info.ContainerStats, error) {
+	if *disableRootCgroupStats && isRootCgroup(h.name) {
+		return nil, nil
+	}
+	stats, err := h.libcontainerHandler.GetStats()
+	if err != nil {
+		return stats, err
+	}
+
+	// Get filesystem stats.
+	err = h.getFsStats(stats)
+	if err != nil {
+		return stats, err
+	}
+
+	return stats, nil
+}
+
+func (h *rawContainerHandler) GetCgroupPath(resource string) (string, error) {
+	var res string
+	if !cgroups.IsCgroup2UnifiedMode() {
+		res = resource
+	}
+	path, ok := h.cgroupPaths[res]
+	if !ok {
+		return "", fmt.Errorf("could not find path for resource %q for container %q", resource, h.name)
+	}
+	return path, nil
+}
+
+func (h *rawContainerHandler) GetContainerLabels() map[string]string {
+	return map[string]string{}
+}
+
+func (h *rawContainerHandler) GetContainerIPAddress() string {
+	// the IP address for the raw container corresponds to the system ip address.
+	return "127.0.0.1"
+}
+
+func (h *rawContainerHandler) ListContainers(listType container.ListType) ([]info.ContainerReference, error) {
+	return common.ListContainers(h.name, h.cgroupPaths, listType)
+}
+
+func (h *rawContainerHandler) ListProcesses(listType container.ListType) ([]int, error) {
+	return h.libcontainerHandler.GetProcesses()
+}
+
+func (h *rawContainerHandler) Exists() bool {
+	return common.CgroupExists(h.cgroupPaths)
+}
+
+func (h *rawContainerHandler) Type() container.ContainerType {
+	return container.ContainerTypeRaw
+}
+
+type fsNamer struct {
+	fs      []fs.Fs
+	factory info.MachineInfoFactory
+	info    common.DeviceNamer
+}
+
+func (n *fsNamer) DeviceName(major, minor uint64) (string, bool) {
+	for _, info := range n.fs {
+		if uint64(info.Major) == major && uint64(info.Minor) == minor {
+			return info.Device, true
+		}
+	}
+	if n.info == nil {
+		mi, err := n.factory.GetMachineInfo()
+		if err != nil {
+			return "", false
+		}
+		n.info = (*common.MachineInfoNamer)(mi)
+	}
+	return n.info.DeviceName(major, minor)
+}

vendor/github.com/google/cadvisor/container/raw/watcher.go

@@ -0,0 +1,243 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// 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 container defines types for sub-container events and also
+// defines an interface for container operation handlers.
+package raw
+
+import (
+	"fmt"
+	"os"
+	"path"
+	"strings"
+
+	inotify "k8s.io/utils/inotify"
+
+	"github.com/google/cadvisor/container"
+	"github.com/google/cadvisor/container/common"
+	"github.com/google/cadvisor/container/libcontainer"
+	"github.com/google/cadvisor/watcher"
+
+	"k8s.io/klog/v2"
+)
+
+type rawContainerWatcher struct {
+	// Absolute path to the root of the cgroup hierarchies
+	cgroupPaths map[string]string
+
+	// Inotify event watcher.
+	watcher *common.InotifyWatcher
+
+	// Signal for watcher thread to stop.
+	stopWatcher chan error
+}
+
+func NewRawContainerWatcher(includedMetrics container.MetricSet) (watcher.ContainerWatcher, error) {
+	cgroupSubsystems, err := libcontainer.GetCgroupSubsystems(includedMetrics)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get cgroup subsystems: %v", err)
+	}
+	if len(cgroupSubsystems) == 0 {
+		return nil, fmt.Errorf("failed to find supported cgroup mounts for the raw factory")
+	}
+
+	watcher, err := common.NewInotifyWatcher()
+	if err != nil {
+		return nil, err
+	}
+
+	rawWatcher := &rawContainerWatcher{
+		cgroupPaths: cgroupSubsystems,
+		watcher:     watcher,
+		stopWatcher: make(chan error),
+	}
+
+	return rawWatcher, nil
+}
+
+func (w *rawContainerWatcher) Start(events chan watcher.ContainerEvent) error {
+	// Watch this container (all its cgroups) and all subdirectories.
+	watched := make([]string, 0)
+	for _, cgroupPath := range w.cgroupPaths {
+		_, err := w.watchDirectory(events, cgroupPath, "/")
+		if err != nil {
+			for _, watchedCgroupPath := range watched {
+				_, removeErr := w.watcher.RemoveWatch("/", watchedCgroupPath)
+				if removeErr != nil {
+					klog.Warningf("Failed to remove inotify watch for %q with error: %v", watchedCgroupPath, removeErr)
+				}
+			}
+			return err
+		}
+		watched = append(watched, cgroupPath)
+	}
+
+	// Process the events received from the kernel.
+	go func() {
+		for {
+			select {
+			case event := <-w.watcher.Event():
+				err := w.processEvent(event, events)
+				if err != nil {
+					klog.Warningf("Error while processing event (%+v): %v", event, err)
+				}
+			case err := <-w.watcher.Error():
+				klog.Warningf("Error while watching %q: %v", "/", err)
+			case <-w.stopWatcher:
+				err := w.watcher.Close()
+				if err == nil {
+					w.stopWatcher <- err
+					return
+				}
+			}
+		}
+	}()
+
+	return nil
+}
+
+func (w *rawContainerWatcher) Stop() error {
+	// Rendezvous with the watcher thread.
+	w.stopWatcher <- nil
+	return <-w.stopWatcher
+}
+
+// Watches the specified directory and all subdirectories. Returns whether the path was
+// already being watched and an error (if any).
+func (w *rawContainerWatcher) watchDirectory(events chan watcher.ContainerEvent, dir string, containerName string) (bool, error) {
+	// Don't watch .mount cgroups because they never have containers as sub-cgroups.  A single container
+	// can have many .mount cgroups associated with it which can quickly exhaust the inotify watches on a node.
+	if strings.HasSuffix(containerName, ".mount") {
+		return false, nil
+	}
+	alreadyWatching, err := w.watcher.AddWatch(containerName, dir)
+	if err != nil {
+		return alreadyWatching, err
+	}
+
+	// Remove the watch if further operations failed.
+	cleanup := true
+	defer func() {
+		if cleanup {
+			_, err := w.watcher.RemoveWatch(containerName, dir)
+			if err != nil {
+				klog.Warningf("Failed to remove inotify watch for %q: %v", dir, err)
+			}
+		}
+	}()
+
+	// TODO(vmarmol): We should re-do this once we're done to ensure directories were not added in the meantime.
+	// Watch subdirectories as well.
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return alreadyWatching, err
+	}
+	for _, entry := range entries {
+		if entry.IsDir() {
+			entryPath := path.Join(dir, entry.Name())
+			subcontainerName := path.Join(containerName, entry.Name())
+			alreadyWatchingSubDir, err := w.watchDirectory(events, entryPath, subcontainerName)
+			if err != nil {
+				klog.Errorf("Failed to watch directory %q: %v", entryPath, err)
+				if os.IsNotExist(err) {
+					// The directory may have been removed before watching. Try to watch the other
+					// subdirectories. (https://github.com/kubernetes/kubernetes/issues/28997)
+					continue
+				}
+				return alreadyWatching, err
+			}
+			// since we already missed the creation event for this directory, publish an event here.
+			if !alreadyWatchingSubDir {
+				go func() {
+					events <- watcher.ContainerEvent{
+						EventType:   watcher.ContainerAdd,
+						Name:        subcontainerName,
+						WatchSource: watcher.Raw,
+					}
+				}()
+			}
+		}
+	}
+
+	cleanup = false
+	return alreadyWatching, nil
+}
+
+func (w *rawContainerWatcher) processEvent(event *inotify.Event, events chan watcher.ContainerEvent) error {
+	// Convert the inotify event type to a container create or delete.
+	var eventType watcher.ContainerEventType
+	switch {
+	case (event.Mask & inotify.InCreate) > 0:
+		eventType = watcher.ContainerAdd
+	case (event.Mask & inotify.InDelete) > 0:
+		eventType = watcher.ContainerDelete
+	case (event.Mask & inotify.InMovedFrom) > 0:
+		eventType = watcher.ContainerDelete
+	case (event.Mask & inotify.InMovedTo) > 0:
+		eventType = watcher.ContainerAdd
+	default:
+		// Ignore other events.
+		return nil
+	}
+
+	// Derive the container name from the path name.
+	var containerName string
+	for _, mount := range w.cgroupPaths {
+		mountLocation := path.Clean(mount) + "/"
+		if strings.HasPrefix(event.Name, mountLocation) {
+			containerName = event.Name[len(mountLocation)-1:]
+			break
+		}
+	}
+	if containerName == "" {
+		return fmt.Errorf("unable to detect container from watch event on directory %q", event.Name)
+	}
+
+	// Maintain the watch for the new or deleted container.
+	switch eventType {
+	case watcher.ContainerAdd:
+		// New container was created, watch it.
+		alreadyWatched, err := w.watchDirectory(events, event.Name, containerName)
+		if err != nil {
+			return err
+		}
+
+		// Only report container creation once.
+		if alreadyWatched {
+			return nil
+		}
+	case watcher.ContainerDelete:
+		// Container was deleted, stop watching for it.
+		lastWatched, err := w.watcher.RemoveWatch(containerName, event.Name)
+		if err != nil {
+			return err
+		}
+
+		// Only report container deletion once.
+		if !lastWatched {
+			return nil
+		}
+	default:
+		return fmt.Errorf("unknown event type %v", eventType)
+	}
+
+	// Deliver the event.
+	events <- watcher.ContainerEvent{
+		EventType:   eventType,
+		Name:        containerName,
+		WatchSource: watcher.Raw,
+	}
+
+	return nil
+}