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/info/v1/docker.go

@@ -0,0 +1,38 @@
+// Copyright 2016 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.
+
+// Types used for docker containers.
+package v1
+
+type DockerStatus struct {
+	Version       string            `json:"version"`
+	APIVersion    string            `json:"api_version"`
+	KernelVersion string            `json:"kernel_version"`
+	OS            string            `json:"os"`
+	Hostname      string            `json:"hostname"`
+	RootDir       string            `json:"root_dir"`
+	Driver        string            `json:"driver"`
+	DriverStatus  map[string]string `json:"driver_status"`
+	ExecDriver    string            `json:"exec_driver"`
+	NumImages     int               `json:"num_images"`
+	NumContainers int               `json:"num_containers"`
+}
+
+type DockerImage struct {
+	ID          string   `json:"id"`
+	RepoTags    []string `json:"repo_tags"` // repository name and tags.
+	Created     int64    `json:"created"`   // unix time since creation.
+	VirtualSize int64    `json:"virtual_size"`
+	Size        int64    `json:"size"`
+}

vendor/github.com/google/cadvisor/info/v1/machine.go

@@ -0,0 +1,327 @@
+// 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 v1
+
+import "time"
+
+type FsInfo struct {
+	// Block device associated with the filesystem.
+	Device string `json:"device"`
+	// DeviceMajor is the major identifier of the device, used for correlation with blkio stats
+	DeviceMajor uint64 `json:"-"`
+	// DeviceMinor is the minor identifier of the device, used for correlation with blkio stats
+	DeviceMinor uint64 `json:"-"`
+
+	// Total number of bytes available on the filesystem.
+	Capacity uint64 `json:"capacity"`
+
+	// Type of device.
+	Type string `json:"type"`
+
+	// Total number of inodes available on the filesystem.
+	Inodes uint64 `json:"inodes"`
+
+	// HasInodes when true, indicates that Inodes info will be available.
+	HasInodes bool `json:"has_inodes"`
+}
+
+type Node struct {
+	Id int `json:"node_id"`
+	// Per-node memory
+	Memory    uint64          `json:"memory"`
+	HugePages []HugePagesInfo `json:"hugepages"`
+	Cores     []Core          `json:"cores"`
+	Caches    []Cache         `json:"caches"`
+	Distances []uint64        `json:"distances"`
+}
+
+type Core struct {
+	Id           int     `json:"core_id"`
+	Threads      []int   `json:"thread_ids"`
+	Caches       []Cache `json:"caches"`
+	UncoreCaches []Cache `json:"uncore_caches"`
+	SocketID     int     `json:"socket_id"`
+	BookID       string  `json:"book_id,omitempty"`
+	DrawerID     string  `json:"drawer_id,omitempty"`
+}
+
+type Cache struct {
+	// Id of memory cache
+	Id int `json:"id"`
+	// Size of memory cache in bytes.
+	Size uint64 `json:"size"`
+	// Type of memory cache: data, instruction, or unified.
+	Type string `json:"type"`
+	// Level (distance from cpus) in a multi-level cache hierarchy.
+	Level int `json:"level"`
+}
+
+func (n *Node) FindCore(id int) (bool, int) {
+	for i, n := range n.Cores {
+		if n.Id == id {
+			return true, i
+		}
+	}
+	return false, -1
+}
+
+// FindCoreByThread returns bool if found Core with same thread as provided and it's index in Node Core array.
+// If it's not found, returns false and -1.
+func (n *Node) FindCoreByThread(thread int) (bool, int) {
+	for i, n := range n.Cores {
+		for _, t := range n.Threads {
+			if t == thread {
+				return true, i
+			}
+		}
+	}
+	return false, -1
+}
+
+func (n *Node) AddThread(thread int, core int) {
+	var coreIdx int
+	if core == -1 {
+		// Assume one hyperthread per core when topology data is missing.
+		core = thread
+	}
+	ok, coreIdx := n.FindCore(core)
+
+	if !ok {
+		// New core
+		core := Core{Id: core}
+		n.Cores = append(n.Cores, core)
+		coreIdx = len(n.Cores) - 1
+	}
+	n.Cores[coreIdx].Threads = append(n.Cores[coreIdx].Threads, thread)
+}
+
+func (n *Node) AddNodeCache(c Cache) {
+	n.Caches = append(n.Caches, c)
+}
+
+func (n *Node) AddPerCoreCache(c Cache) {
+	for idx := range n.Cores {
+		n.Cores[idx].Caches = append(n.Cores[idx].Caches, c)
+	}
+}
+
+type HugePagesInfo struct {
+	// huge page size (in kB)
+	PageSize uint64 `json:"page_size"`
+
+	// number of huge pages
+	NumPages uint64 `json:"num_pages"`
+}
+
+type DiskInfo struct {
+	// device name
+	Name string `json:"name"`
+
+	// Major number
+	Major uint64 `json:"major"`
+
+	// Minor number
+	Minor uint64 `json:"minor"`
+
+	// Size in bytes
+	Size uint64 `json:"size"`
+
+	// I/O Scheduler - one of "none", "noop", "cfq", "deadline"
+	Scheduler string `json:"scheduler"`
+}
+
+type NetInfo struct {
+	// Device name
+	Name string `json:"name"`
+
+	// Mac Address
+	MacAddress string `json:"mac_address"`
+
+	// Speed in MBits/s
+	Speed int64 `json:"speed"`
+
+	// Maximum Transmission Unit
+	Mtu int64 `json:"mtu"`
+}
+
+type CloudProvider string
+
+const (
+	GCE             CloudProvider = "GCE"
+	AWS             CloudProvider = "AWS"
+	Azure           CloudProvider = "Azure"
+	UnknownProvider CloudProvider = "Unknown"
+)
+
+type InstanceType string
+
+const (
+	UnknownInstance = "Unknown"
+)
+
+type InstanceID string
+
+const (
+	UnNamedInstance InstanceID = "None"
+)
+
+type MachineInfo struct {
+	// The time of this information point.
+	Timestamp time.Time `json:"timestamp"`
+
+	// Vendor id of CPU.
+	CPUVendorID string `json:"vendor_id"`
+
+	// The number of cores in this machine.
+	NumCores int `json:"num_cores"`
+
+	// The number of physical cores in this machine.
+	NumPhysicalCores int `json:"num_physical_cores"`
+
+	// The number of cpu sockets in this machine.
+	NumSockets int `json:"num_sockets"`
+
+	// Maximum clock speed for the cores, in KHz.
+	CpuFrequency uint64 `json:"cpu_frequency_khz"`
+
+	// The amount of memory (in bytes) in this machine
+	MemoryCapacity uint64 `json:"memory_capacity"`
+
+	// The amount of swap (in bytes) in this machine
+	SwapCapacity uint64 `json:"swap_capacity"`
+
+	// Memory capacity and number of DIMMs by memory type
+	MemoryByType map[string]*MemoryInfo `json:"memory_by_type"`
+
+	NVMInfo NVMInfo `json:"nvm"`
+
+	// HugePages on this machine.
+	HugePages []HugePagesInfo `json:"hugepages"`
+
+	// The machine id
+	MachineID string `json:"machine_id"`
+
+	// The system uuid
+	SystemUUID string `json:"system_uuid"`
+
+	// The boot id
+	BootID string `json:"boot_id"`
+
+	// Filesystems on this machine.
+	Filesystems []FsInfo `json:"filesystems"`
+
+	// Disk map
+	DiskMap map[string]DiskInfo `json:"disk_map"`
+
+	// Network devices
+	NetworkDevices []NetInfo `json:"network_devices"`
+
+	// Machine Topology
+	// Describes cpu/memory layout and hierarchy.
+	Topology []Node `json:"topology"`
+
+	// Cloud provider the machine belongs to.
+	CloudProvider CloudProvider `json:"cloud_provider"`
+
+	// Type of cloud instance (e.g. GCE standard) the machine is.
+	InstanceType InstanceType `json:"instance_type"`
+
+	// ID of cloud instance (e.g. instance-1) given to it by the cloud provider.
+	InstanceID InstanceID `json:"instance_id"`
+}
+
+func (m *MachineInfo) Clone() *MachineInfo {
+	memoryByType := m.MemoryByType
+	if len(m.MemoryByType) > 0 {
+		memoryByType = make(map[string]*MemoryInfo)
+		for memoryType, memoryInfo := range m.MemoryByType {
+			memoryByType[memoryType] = memoryInfo
+		}
+	}
+	diskMap := m.DiskMap
+	if len(m.DiskMap) > 0 {
+		diskMap = make(map[string]DiskInfo)
+		for k, info := range m.DiskMap {
+			diskMap[k] = info
+		}
+	}
+	copy := MachineInfo{
+		CPUVendorID:      m.CPUVendorID,
+		Timestamp:        m.Timestamp,
+		NumCores:         m.NumCores,
+		NumPhysicalCores: m.NumPhysicalCores,
+		NumSockets:       m.NumSockets,
+		CpuFrequency:     m.CpuFrequency,
+		MemoryCapacity:   m.MemoryCapacity,
+		SwapCapacity:     m.SwapCapacity,
+		MemoryByType:     memoryByType,
+		NVMInfo:          m.NVMInfo,
+		HugePages:        m.HugePages,
+		MachineID:        m.MachineID,
+		SystemUUID:       m.SystemUUID,
+		BootID:           m.BootID,
+		Filesystems:      m.Filesystems,
+		DiskMap:          diskMap,
+		NetworkDevices:   m.NetworkDevices,
+		Topology:         m.Topology,
+		CloudProvider:    m.CloudProvider,
+		InstanceType:     m.InstanceType,
+		InstanceID:       m.InstanceID,
+	}
+	return &copy
+}
+
+type MemoryInfo struct {
+	// The amount of memory (in bytes).
+	Capacity uint64 `json:"capacity"`
+
+	// Number of memory DIMMs.
+	DimmCount uint `json:"dimm_count"`
+}
+
+type NVMInfo struct {
+	// The total NVM capacity in bytes for memory mode.
+	MemoryModeCapacity uint64 `json:"memory_mode_capacity"`
+
+	//The total NVM capacity in bytes for app direct mode.
+	AppDirectModeCapacity uint64 `json:"app direct_mode_capacity"`
+
+	// Average power budget in watts for NVM devices configured in BIOS.
+	AvgPowerBudget uint `json:"avg_power_budget"`
+}
+
+type VersionInfo struct {
+	// Kernel version.
+	KernelVersion string `json:"kernel_version"`
+
+	// OS image being used for cadvisor container, or host image if running on host directly.
+	ContainerOsVersion string `json:"container_os_version"`
+
+	// Docker version.
+	DockerVersion string `json:"docker_version"`
+
+	// Docker API Version
+	DockerAPIVersion string `json:"docker_api_version"`
+
+	// cAdvisor version.
+	CadvisorVersion string `json:"cadvisor_version"`
+	// cAdvisor git revision.
+	CadvisorRevision string `json:"cadvisor_revision"`
+}
+
+type MachineInfoFactory interface {
+	GetMachineInfo() (*MachineInfo, error)
+	GetVersionInfo() (*VersionInfo, error)
+}

vendor/github.com/google/cadvisor/info/v1/metric.go

@@ -0,0 +1,77 @@
+// Copyright 2015 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 v1
+
+import (
+	"time"
+)
+
+// Type of metric being exported.
+type MetricType string
+
+const (
+	// Instantaneous value. May increase or decrease.
+	MetricGauge MetricType = "gauge"
+
+	// A counter-like value that is only expected to increase.
+	MetricCumulative MetricType = "cumulative"
+)
+
+// DataType for metric being exported.
+type DataType string
+
+const (
+	IntType   DataType = "int"
+	FloatType DataType = "float"
+)
+
+// Spec for custom metric.
+type MetricSpec struct {
+	// The name of the metric.
+	Name string `json:"name"`
+
+	// Type of the metric.
+	Type MetricType `json:"type"`
+
+	// Data Type for the stats.
+	Format DataType `json:"format"`
+
+	// Display Units for the stats.
+	Units string `json:"units"`
+}
+
+// An exported metric.
+type MetricValBasic struct {
+	// Time at which the metric was queried
+	Timestamp time.Time `json:"timestamp"`
+
+	// The value of the metric at this point.
+	IntValue   int64   `json:"int_value,omitempty"`
+	FloatValue float64 `json:"float_value,omitempty"`
+}
+
+// An exported metric.
+type MetricVal struct {
+	// Label associated with a metric
+	Label  string            `json:"label,omitempty"`
+	Labels map[string]string `json:"labels,omitempty"`
+
+	// Time at which the metric was queried
+	Timestamp time.Time `json:"timestamp"`
+
+	// The value of the metric at this point.
+	IntValue   int64   `json:"int_value,omitempty"`
+	FloatValue float64 `json:"float_value,omitempty"`
+}

vendor/github.com/google/cadvisor/info/v2/container.go

@@ -0,0 +1,358 @@
+// Copyright 2015 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 v2
+
+import (
+	"time"
+
+	// TODO(rjnagal): Remove dependency after moving all stats structs from v1.
+	// using v1 now for easy conversion.
+	v1 "github.com/google/cadvisor/info/v1"
+)
+
+const (
+	TypeName   = "name"
+	TypeDocker = "docker"
+	TypePodman = "podman"
+)
+
+type CpuSpec struct {
+	// Requested cpu shares. Default is 1024.
+	Limit uint64 `json:"limit"`
+	// Requested cpu hard limit. Default is unlimited (0).
+	// Units: milli-cpus.
+	MaxLimit uint64 `json:"max_limit"`
+	// Cpu affinity mask.
+	// TODO(rjnagal): Add a library to convert mask string to set of cpu bitmask.
+	Mask string `json:"mask,omitempty"`
+	// CPUQuota Default is disabled
+	Quota uint64 `json:"quota,omitempty"`
+	// Period is the CPU reference time in ns e.g the quota is compared against this.
+	Period uint64 `json:"period,omitempty"`
+}
+
+type MemorySpec struct {
+	// The amount of memory requested. Default is unlimited (-1).
+	// Units: bytes.
+	Limit uint64 `json:"limit,omitempty"`
+
+	// The amount of guaranteed memory.  Default is 0.
+	// Units: bytes.
+	Reservation uint64 `json:"reservation,omitempty"`
+
+	// The amount of swap space requested. Default is unlimited (-1).
+	// Units: bytes.
+	SwapLimit uint64 `json:"swap_limit,omitempty"`
+}
+
+type ContainerInfo struct {
+	// Describes the container.
+	Spec ContainerSpec `json:"spec,omitempty"`
+
+	// Historical statistics gathered from the container.
+	Stats []*ContainerStats `json:"stats,omitempty"`
+}
+
+type ContainerSpec struct {
+	// Time at which the container was created.
+	CreationTime time.Time `json:"creation_time,omitempty"`
+
+	// Other names by which the container is known within a certain namespace.
+	// This is unique within that namespace.
+	Aliases []string `json:"aliases,omitempty"`
+
+	// Namespace under which the aliases of a container are unique.
+	// An example of a namespace is "docker" for Docker containers.
+	Namespace string `json:"namespace,omitempty"`
+
+	// Metadata labels associated with this container.
+	Labels map[string]string `json:"labels,omitempty"`
+	// Metadata envs associated with this container. Only whitelisted envs are added.
+	Envs map[string]string `json:"envs,omitempty"`
+
+	HasCpu bool    `json:"has_cpu"`
+	Cpu    CpuSpec `json:"cpu,omitempty"`
+
+	HasMemory bool       `json:"has_memory"`
+	Memory    MemorySpec `json:"memory,omitempty"`
+
+	HasHugetlb bool `json:"has_hugetlb"`
+
+	HasCustomMetrics bool            `json:"has_custom_metrics"`
+	CustomMetrics    []v1.MetricSpec `json:"custom_metrics,omitempty"`
+
+	HasProcesses bool           `json:"has_processes"`
+	Processes    v1.ProcessSpec `json:"processes,omitempty"`
+
+	// Following resources have no associated spec, but are being isolated.
+	HasNetwork    bool `json:"has_network"`
+	HasFilesystem bool `json:"has_filesystem"`
+	HasDiskIo     bool `json:"has_diskio"`
+
+	// Image name used for this container.
+	Image string `json:"image,omitempty"`
+}
+
+type DeprecatedContainerStats struct {
+	// The time of this stat point.
+	Timestamp time.Time `json:"timestamp"`
+	// CPU statistics
+	HasCpu bool `json:"has_cpu"`
+	// In nanoseconds (aggregated)
+	Cpu v1.CpuStats `json:"cpu,omitempty"`
+	// In nanocores per second (instantaneous)
+	CpuInst *CpuInstStats `json:"cpu_inst,omitempty"`
+	// Disk IO statistics
+	HasDiskIo bool           `json:"has_diskio"`
+	DiskIo    v1.DiskIoStats `json:"diskio,omitempty"`
+	// Memory statistics
+	HasMemory bool           `json:"has_memory"`
+	Memory    v1.MemoryStats `json:"memory,omitempty"`
+	// Hugepage statistics
+	HasHugetlb bool                       `json:"has_hugetlb"`
+	Hugetlb    map[string]v1.HugetlbStats `json:"hugetlb,omitempty"`
+	// Network statistics
+	HasNetwork bool         `json:"has_network"`
+	Network    NetworkStats `json:"network,omitempty"`
+	// Processes statistics
+	HasProcesses bool            `json:"has_processes"`
+	Processes    v1.ProcessStats `json:"processes,omitempty"`
+	// Filesystem statistics
+	HasFilesystem bool         `json:"has_filesystem"`
+	Filesystem    []v1.FsStats `json:"filesystem,omitempty"`
+	// Task load statistics
+	HasLoad bool         `json:"has_load"`
+	Load    v1.LoadStats `json:"load_stats,omitempty"`
+	// Custom Metrics
+	HasCustomMetrics bool                      `json:"has_custom_metrics"`
+	CustomMetrics    map[string][]v1.MetricVal `json:"custom_metrics,omitempty"`
+	// Perf events counters
+	PerfStats []v1.PerfStat `json:"perf_stats,omitempty"`
+	// Statistics originating from perf uncore events.
+	// Applies only for root container.
+	PerfUncoreStats []v1.PerfUncoreStat `json:"perf_uncore_stats,omitempty"`
+	// Referenced memory
+	ReferencedMemory uint64 `json:"referenced_memory,omitempty"`
+	// Resource Control (resctrl) statistics
+	Resctrl v1.ResctrlStats `json:"resctrl,omitempty"`
+}
+
+type ContainerStats struct {
+	// The time of this stat point.
+	Timestamp time.Time `json:"timestamp"`
+	// CPU statistics
+	// In nanoseconds (aggregated)
+	Cpu *v1.CpuStats `json:"cpu,omitempty"`
+	// In nanocores per second (instantaneous)
+	CpuInst *CpuInstStats `json:"cpu_inst,omitempty"`
+	// Disk IO statistics
+	DiskIo *v1.DiskIoStats `json:"diskio,omitempty"`
+	// Memory statistics
+	Memory *v1.MemoryStats `json:"memory,omitempty"`
+	// Hugepage statistics
+	Hugetlb *map[string]v1.HugetlbStats `json:"hugetlb,omitempty"`
+	// Network statistics
+	Network *NetworkStats `json:"network,omitempty"`
+	// Processes statistics
+	Processes *v1.ProcessStats `json:"processes,omitempty"`
+	// Filesystem statistics
+	Filesystem *FilesystemStats `json:"filesystem,omitempty"`
+	// Task load statistics
+	Load *v1.LoadStats `json:"load_stats,omitempty"`
+	// Metrics for Accelerators. Each Accelerator corresponds to one element in the array.
+	Accelerators []v1.AcceleratorStats `json:"accelerators,omitempty"`
+	// Custom Metrics
+	CustomMetrics map[string][]v1.MetricVal `json:"custom_metrics,omitempty"`
+	// Perf events counters
+	PerfStats []v1.PerfStat `json:"perf_stats,omitempty"`
+	// Statistics originating from perf uncore events.
+	// Applies only for root container.
+	PerfUncoreStats []v1.PerfUncoreStat `json:"perf_uncore_stats,omitempty"`
+	// Referenced memory
+	ReferencedMemory uint64 `json:"referenced_memory,omitempty"`
+	// Resource Control (resctrl) statistics
+	Resctrl v1.ResctrlStats `json:"resctrl,omitempty"`
+}
+
+type Percentiles struct {
+	// Indicates whether the stats are present or not.
+	// If true, values below do not have any data.
+	Present bool `json:"present"`
+	// Average over the collected sample.
+	Mean uint64 `json:"mean"`
+	// Max seen over the collected sample.
+	Max uint64 `json:"max"`
+	// 50th percentile over the collected sample.
+	Fifty uint64 `json:"fifty"`
+	// 90th percentile over the collected sample.
+	Ninety uint64 `json:"ninety"`
+	// 95th percentile over the collected sample.
+	NinetyFive uint64 `json:"ninetyfive"`
+}
+
+type Usage struct {
+	// Indicates amount of data available [0-100].
+	// If we have data for half a day, we'll still process DayUsage,
+	// but set PercentComplete to 50.
+	PercentComplete int32 `json:"percent_complete"`
+	// Mean, Max, and 90p cpu rate value in milliCpus/seconds. Converted to milliCpus to avoid floats.
+	Cpu Percentiles `json:"cpu"`
+	// Mean, Max, and 90p memory size in bytes.
+	Memory Percentiles `json:"memory"`
+}
+
+// latest sample collected for a container.
+type InstantUsage struct {
+	// cpu rate in cpu milliseconds/second.
+	Cpu uint64 `json:"cpu"`
+	// Memory usage in bytes.
+	Memory uint64 `json:"memory"`
+}
+
+type DerivedStats struct {
+	// Time of generation of these stats.
+	Timestamp time.Time `json:"timestamp"`
+	// Latest instantaneous sample.
+	LatestUsage InstantUsage `json:"latest_usage"`
+	// Percentiles in last observed minute.
+	MinuteUsage Usage `json:"minute_usage"`
+	// Percentile in last hour.
+	HourUsage Usage `json:"hour_usage"`
+	// Percentile in last day.
+	DayUsage Usage `json:"day_usage"`
+}
+
+type FsInfo struct {
+	// Time of generation of these stats.
+	Timestamp time.Time `json:"timestamp"`
+
+	// The block device name associated with the filesystem.
+	Device string `json:"device"`
+
+	// Path where the filesystem is mounted.
+	Mountpoint string `json:"mountpoint"`
+
+	// Filesystem usage in bytes.
+	Capacity uint64 `json:"capacity"`
+
+	// Bytes available for non-root use.
+	Available uint64 `json:"available"`
+
+	// Number of bytes used on this filesystem.
+	Usage uint64 `json:"usage"`
+
+	// Labels associated with this filesystem.
+	Labels []string `json:"labels"`
+
+	// Number of Inodes.
+	Inodes *uint64 `json:"inodes,omitempty"`
+
+	// Number of available Inodes (if known)
+	InodesFree *uint64 `json:"inodes_free,omitempty"`
+}
+
+type RequestOptions struct {
+	// Type of container identifier specified - TypeName (default) or TypeDocker
+	IdType string `json:"type"`
+	// Number of stats to return, -1 means no limit.
+	Count int `json:"count"`
+	// Whether to include stats for child subcontainers.
+	Recursive bool `json:"recursive"`
+	// Update stats if they are older than MaxAge
+	// nil indicates no update, and 0 will always trigger an update.
+	MaxAge *time.Duration `json:"max_age"`
+}
+
+type ProcessInfo struct {
+	User          string  `json:"user"`
+	Pid           int     `json:"pid"`
+	Ppid          int     `json:"parent_pid"`
+	StartTime     string  `json:"start_time"`
+	PercentCpu    float32 `json:"percent_cpu"`
+	PercentMemory float32 `json:"percent_mem"`
+	RSS           uint64  `json:"rss"`
+	VirtualSize   uint64  `json:"virtual_size"`
+	Status        string  `json:"status"`
+	RunningTime   string  `json:"running_time"`
+	CgroupPath    string  `json:"cgroup_path"`
+	Cmd           string  `json:"cmd"`
+	FdCount       int     `json:"fd_count"`
+	Psr           int     `json:"psr"`
+}
+
+type TcpStat struct {
+	Established uint64
+	SynSent     uint64
+	SynRecv     uint64
+	FinWait1    uint64
+	FinWait2    uint64
+	TimeWait    uint64
+	Close       uint64
+	CloseWait   uint64
+	LastAck     uint64
+	Listen      uint64
+	Closing     uint64
+}
+
+type NetworkStats struct {
+	// Network stats by interface.
+	Interfaces []v1.InterfaceStats `json:"interfaces,omitempty"`
+	// TCP connection stats (Established, Listen...)
+	Tcp TcpStat `json:"tcp"`
+	// TCP6 connection stats (Established, Listen...)
+	Tcp6 TcpStat `json:"tcp6"`
+	// UDP connection stats
+	Udp v1.UdpStat `json:"udp"`
+	// UDP6 connection stats
+	Udp6 v1.UdpStat `json:"udp6"`
+	// TCP advanced stats
+	TcpAdvanced v1.TcpAdvancedStat `json:"tcp_advanced"`
+}
+
+// Instantaneous CPU stats
+type CpuInstStats struct {
+	Usage CpuInstUsage `json:"usage"`
+}
+
+// CPU usage time statistics.
+type CpuInstUsage struct {
+	// Total CPU usage.
+	// Units: nanocores per second
+	Total uint64 `json:"total"`
+
+	// Per CPU/core usage of the container.
+	// Unit: nanocores per second
+	PerCpu []uint64 `json:"per_cpu_usage,omitempty"`
+
+	// Time spent in user space.
+	// Unit: nanocores per second
+	User uint64 `json:"user"`
+
+	// Time spent in kernel space.
+	// Unit: nanocores per second
+	System uint64 `json:"system"`
+}
+
+// Filesystem usage statistics.
+type FilesystemStats struct {
+	// Total Number of bytes consumed by container.
+	TotalUsageBytes *uint64 `json:"totalUsageBytes,omitempty"`
+	// Number of bytes consumed by a container through its root filesystem.
+	BaseUsageBytes *uint64 `json:"baseUsageBytes,omitempty"`
+	// Number of inodes used within the container's root filesystem.
+	// This only accounts for inodes that are shared across containers,
+	// and does not include inodes used in mounted directories.
+	InodeUsage *uint64 `json:"containter_inode_usage,omitempty"`
+}

vendor/github.com/google/cadvisor/info/v2/conversion.go

@@ -0,0 +1,316 @@
+// Copyright 2015 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 v2
+
+import (
+	"fmt"
+	"time"
+
+	"k8s.io/klog/v2"
+
+	v1 "github.com/google/cadvisor/info/v1"
+)
+
+func machineFsStatsFromV1(fsStats []v1.FsStats) []MachineFsStats {
+	var result []MachineFsStats
+	for i := range fsStats {
+		stat := fsStats[i]
+		readDuration := time.Millisecond * time.Duration(stat.ReadTime)
+		writeDuration := time.Millisecond * time.Duration(stat.WriteTime)
+		ioDuration := time.Millisecond * time.Duration(stat.IoTime)
+		weightedDuration := time.Millisecond * time.Duration(stat.WeightedIoTime)
+		machineFsStat := MachineFsStats{
+			Device:    stat.Device,
+			Type:      stat.Type,
+			Capacity:  &stat.Limit,
+			Usage:     &stat.Usage,
+			Available: &stat.Available,
+			DiskStats: DiskStats{
+				ReadsCompleted:     &stat.ReadsCompleted,
+				ReadsMerged:        &stat.ReadsMerged,
+				SectorsRead:        &stat.SectorsRead,
+				ReadDuration:       &readDuration,
+				WritesCompleted:    &stat.WritesCompleted,
+				WritesMerged:       &stat.WritesMerged,
+				SectorsWritten:     &stat.SectorsWritten,
+				WriteDuration:      &writeDuration,
+				IoInProgress:       &stat.IoInProgress,
+				IoDuration:         &ioDuration,
+				WeightedIoDuration: &weightedDuration,
+			},
+		}
+		if stat.HasInodes {
+			machineFsStat.InodesFree = &stat.InodesFree
+		}
+		result = append(result, machineFsStat)
+	}
+	return result
+}
+
+func MachineStatsFromV1(cont *v1.ContainerInfo) []MachineStats {
+	var stats []MachineStats
+	var last *v1.ContainerStats
+	for i := range cont.Stats {
+		val := cont.Stats[i]
+		stat := MachineStats{
+			Timestamp: val.Timestamp,
+		}
+		if cont.Spec.HasCpu {
+			stat.Cpu = &val.Cpu
+			cpuInst, err := InstCpuStats(last, val)
+			if err != nil {
+				klog.Warningf("Could not get instant cpu stats: %v", err)
+			} else {
+				stat.CpuInst = cpuInst
+			}
+			last = val
+		}
+		if cont.Spec.HasMemory {
+			stat.Memory = &val.Memory
+		}
+		if cont.Spec.HasNetwork {
+			stat.Network = &NetworkStats{
+				// FIXME: Use reflection instead.
+				Tcp:        TcpStat(val.Network.Tcp),
+				Tcp6:       TcpStat(val.Network.Tcp6),
+				Interfaces: val.Network.Interfaces,
+			}
+		}
+		if cont.Spec.HasFilesystem {
+			stat.Filesystem = machineFsStatsFromV1(val.Filesystem)
+		}
+		// TODO(rjnagal): Handle load stats.
+		stats = append(stats, stat)
+	}
+	return stats
+}
+
+func ContainerStatsFromV1(containerName string, spec *v1.ContainerSpec, stats []*v1.ContainerStats) []*ContainerStats {
+	newStats := make([]*ContainerStats, 0, len(stats))
+	var last *v1.ContainerStats
+	for _, val := range stats {
+		stat := &ContainerStats{
+			Timestamp:        val.Timestamp,
+			ReferencedMemory: val.ReferencedMemory,
+		}
+		if spec.HasCpu {
+			stat.Cpu = &val.Cpu
+			cpuInst, err := InstCpuStats(last, val)
+			if err != nil {
+				klog.Warningf("Could not get instant cpu stats: %v", err)
+			} else {
+				stat.CpuInst = cpuInst
+			}
+			last = val
+		}
+		if spec.HasMemory {
+			stat.Memory = &val.Memory
+		}
+		if spec.HasHugetlb {
+			stat.Hugetlb = &val.Hugetlb
+		}
+		if spec.HasNetwork {
+			// TODO: Handle TcpStats
+			stat.Network = &NetworkStats{
+				Tcp:        TcpStat(val.Network.Tcp),
+				Tcp6:       TcpStat(val.Network.Tcp6),
+				Interfaces: val.Network.Interfaces,
+			}
+		}
+		if spec.HasProcesses {
+			stat.Processes = &val.Processes
+		}
+		if spec.HasFilesystem {
+			if len(val.Filesystem) == 1 {
+				stat.Filesystem = &FilesystemStats{
+					TotalUsageBytes: &val.Filesystem[0].Usage,
+					BaseUsageBytes:  &val.Filesystem[0].BaseUsage,
+					InodeUsage:      &val.Filesystem[0].Inodes,
+				}
+			} else if len(val.Filesystem) > 1 && containerName != "/" {
+				// Cannot handle multiple devices per container.
+				klog.V(4).Infof("failed to handle multiple devices for container %s. Skipping Filesystem stats", containerName)
+			}
+		}
+		if spec.HasDiskIo {
+			stat.DiskIo = &val.DiskIo
+		}
+		if spec.HasCustomMetrics {
+			stat.CustomMetrics = val.CustomMetrics
+		}
+		if len(val.Accelerators) > 0 {
+			stat.Accelerators = val.Accelerators
+		}
+		if len(val.PerfStats) > 0 {
+			stat.PerfStats = val.PerfStats
+		}
+		if len(val.PerfUncoreStats) > 0 {
+			stat.PerfUncoreStats = val.PerfUncoreStats
+		}
+		if len(val.Resctrl.MemoryBandwidth) > 0 || len(val.Resctrl.Cache) > 0 {
+			stat.Resctrl = val.Resctrl
+		}
+		// TODO(rjnagal): Handle load stats.
+		newStats = append(newStats, stat)
+	}
+	return newStats
+}
+
+func DeprecatedStatsFromV1(cont *v1.ContainerInfo) []DeprecatedContainerStats {
+	stats := make([]DeprecatedContainerStats, 0, len(cont.Stats))
+	var last *v1.ContainerStats
+	for _, val := range cont.Stats {
+		stat := DeprecatedContainerStats{
+			Timestamp:        val.Timestamp,
+			HasCpu:           cont.Spec.HasCpu,
+			HasMemory:        cont.Spec.HasMemory,
+			HasHugetlb:       cont.Spec.HasHugetlb,
+			HasNetwork:       cont.Spec.HasNetwork,
+			HasFilesystem:    cont.Spec.HasFilesystem,
+			HasDiskIo:        cont.Spec.HasDiskIo,
+			HasCustomMetrics: cont.Spec.HasCustomMetrics,
+			ReferencedMemory: val.ReferencedMemory,
+		}
+		if stat.HasCpu {
+			stat.Cpu = val.Cpu
+			cpuInst, err := InstCpuStats(last, val)
+			if err != nil {
+				klog.Warningf("Could not get instant cpu stats: %v", err)
+			} else {
+				stat.CpuInst = cpuInst
+			}
+			last = val
+		}
+		if stat.HasMemory {
+			stat.Memory = val.Memory
+		}
+		if stat.HasHugetlb {
+			stat.Hugetlb = val.Hugetlb
+		}
+		if stat.HasNetwork {
+			stat.Network.Interfaces = val.Network.Interfaces
+		}
+		if stat.HasProcesses {
+			stat.Processes = val.Processes
+		}
+		if stat.HasFilesystem {
+			stat.Filesystem = val.Filesystem
+		}
+		if stat.HasDiskIo {
+			stat.DiskIo = val.DiskIo
+		}
+		if stat.HasCustomMetrics {
+			stat.CustomMetrics = val.CustomMetrics
+		}
+		if len(val.PerfStats) > 0 {
+			stat.PerfStats = val.PerfStats
+		}
+		if len(val.PerfUncoreStats) > 0 {
+			stat.PerfUncoreStats = val.PerfUncoreStats
+		}
+		if len(val.Resctrl.MemoryBandwidth) > 0 || len(val.Resctrl.Cache) > 0 {
+			stat.Resctrl = val.Resctrl
+		}
+		// TODO(rjnagal): Handle load stats.
+		stats = append(stats, stat)
+	}
+	return stats
+}
+
+func InstCpuStats(last, cur *v1.ContainerStats) (*CpuInstStats, error) {
+	if last == nil {
+		return nil, nil
+	}
+	if !cur.Timestamp.After(last.Timestamp) {
+		return nil, fmt.Errorf("container stats move backwards in time")
+	}
+	if len(last.Cpu.Usage.PerCpu) != len(cur.Cpu.Usage.PerCpu) {
+		return nil, fmt.Errorf("different number of cpus")
+	}
+	timeDelta := cur.Timestamp.Sub(last.Timestamp)
+	// Nanoseconds to gain precision and avoid having zero seconds if the
+	// difference between the timestamps is just under a second
+	timeDeltaNs := uint64(timeDelta.Nanoseconds())
+	convertToRate := func(lastValue, curValue uint64) (uint64, error) {
+		if curValue < lastValue {
+			return 0, fmt.Errorf("cumulative stats decrease")
+		}
+		valueDelta := curValue - lastValue
+		// Use float64 to keep precision
+		return uint64(float64(valueDelta) / float64(timeDeltaNs) * 1e9), nil
+	}
+	total, err := convertToRate(last.Cpu.Usage.Total, cur.Cpu.Usage.Total)
+	if err != nil {
+		return nil, err
+	}
+	percpu := make([]uint64, len(last.Cpu.Usage.PerCpu))
+	for i := range percpu {
+		var err error
+		percpu[i], err = convertToRate(last.Cpu.Usage.PerCpu[i], cur.Cpu.Usage.PerCpu[i])
+		if err != nil {
+			return nil, err
+		}
+	}
+	user, err := convertToRate(last.Cpu.Usage.User, cur.Cpu.Usage.User)
+	if err != nil {
+		return nil, err
+	}
+	system, err := convertToRate(last.Cpu.Usage.System, cur.Cpu.Usage.System)
+	if err != nil {
+		return nil, err
+	}
+	return &CpuInstStats{
+		Usage: CpuInstUsage{
+			Total:  total,
+			PerCpu: percpu,
+			User:   user,
+			System: system,
+		},
+	}, nil
+}
+
+// Get V2 container spec from v1 container info.
+func ContainerSpecFromV1(specV1 *v1.ContainerSpec, aliases []string, namespace string) ContainerSpec {
+	specV2 := ContainerSpec{
+		CreationTime:     specV1.CreationTime,
+		HasCpu:           specV1.HasCpu,
+		HasMemory:        specV1.HasMemory,
+		HasHugetlb:       specV1.HasHugetlb,
+		HasFilesystem:    specV1.HasFilesystem,
+		HasNetwork:       specV1.HasNetwork,
+		HasProcesses:     specV1.HasProcesses,
+		HasDiskIo:        specV1.HasDiskIo,
+		HasCustomMetrics: specV1.HasCustomMetrics,
+		Image:            specV1.Image,
+		Labels:           specV1.Labels,
+		Envs:             specV1.Envs,
+	}
+	if specV1.HasCpu {
+		specV2.Cpu.Limit = specV1.Cpu.Limit
+		specV2.Cpu.MaxLimit = specV1.Cpu.MaxLimit
+		specV2.Cpu.Mask = specV1.Cpu.Mask
+	}
+	if specV1.HasMemory {
+		specV2.Memory.Limit = specV1.Memory.Limit
+		specV2.Memory.Reservation = specV1.Memory.Reservation
+		specV2.Memory.SwapLimit = specV1.Memory.SwapLimit
+	}
+	if specV1.HasCustomMetrics {
+		specV2.CustomMetrics = specV1.CustomMetrics
+	}
+	specV2.Aliases = aliases
+	specV2.Namespace = namespace
+	return specV2
+}

vendor/github.com/google/cadvisor/info/v2/machine.go

@@ -0,0 +1,198 @@
+// Copyright 2015 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 v2
+
+import (
+	// TODO(rjnagal): Move structs from v1.
+	"time"
+
+	v1 "github.com/google/cadvisor/info/v1"
+)
+
+type Attributes struct {
+	// Kernel version.
+	KernelVersion string `json:"kernel_version"`
+
+	// OS image being used for cadvisor container, or host image if running on host directly.
+	ContainerOsVersion string `json:"container_os_version"`
+
+	// Docker version.
+	DockerVersion string `json:"docker_version"`
+
+	// Docker API version.
+	DockerAPIVersion string `json:"docker_api_version"`
+
+	// cAdvisor version.
+	CadvisorVersion string `json:"cadvisor_version"`
+
+	// The number of cores in this machine.
+	NumCores int `json:"num_cores"`
+
+	// Maximum clock speed for the cores, in KHz.
+	CpuFrequency uint64 `json:"cpu_frequency_khz"`
+
+	// The amount of memory (in bytes) in this machine
+	MemoryCapacity uint64 `json:"memory_capacity"`
+
+	// The machine id
+	MachineID string `json:"machine_id"`
+
+	// The system uuid
+	SystemUUID string `json:"system_uuid"`
+
+	// HugePages on this machine.
+	HugePages []v1.HugePagesInfo `json:"hugepages"`
+
+	// Filesystems on this machine.
+	Filesystems []v1.FsInfo `json:"filesystems"`
+
+	// Disk map
+	DiskMap map[string]v1.DiskInfo `json:"disk_map"`
+
+	// Network devices
+	NetworkDevices []v1.NetInfo `json:"network_devices"`
+
+	// Machine Topology
+	// Describes cpu/memory layout and hierarchy.
+	Topology []v1.Node `json:"topology"`
+
+	// Cloud provider the machine belongs to
+	CloudProvider v1.CloudProvider `json:"cloud_provider"`
+
+	// Type of cloud instance (e.g. GCE standard) the machine is.
+	InstanceType v1.InstanceType `json:"instance_type"`
+}
+
+func GetAttributes(mi *v1.MachineInfo, vi *v1.VersionInfo) Attributes {
+	return Attributes{
+		KernelVersion:      vi.KernelVersion,
+		ContainerOsVersion: vi.ContainerOsVersion,
+		DockerVersion:      vi.DockerVersion,
+		DockerAPIVersion:   vi.DockerAPIVersion,
+		CadvisorVersion:    vi.CadvisorVersion,
+		NumCores:           mi.NumCores,
+		CpuFrequency:       mi.CpuFrequency,
+		MemoryCapacity:     mi.MemoryCapacity,
+		MachineID:          mi.MachineID,
+		SystemUUID:         mi.SystemUUID,
+		HugePages:          mi.HugePages,
+		Filesystems:        mi.Filesystems,
+		DiskMap:            mi.DiskMap,
+		NetworkDevices:     mi.NetworkDevices,
+		Topology:           mi.Topology,
+		CloudProvider:      mi.CloudProvider,
+		InstanceType:       mi.InstanceType,
+	}
+}
+
+// MachineStats contains usage statistics for the entire machine.
+type MachineStats struct {
+	// The time of this stat point.
+	Timestamp time.Time `json:"timestamp"`
+	// In nanoseconds (aggregated)
+	Cpu *v1.CpuStats `json:"cpu,omitempty"`
+	// In nanocores per second (instantaneous)
+	CpuInst *CpuInstStats `json:"cpu_inst,omitempty"`
+	// Memory statistics
+	Memory *v1.MemoryStats `json:"memory,omitempty"`
+	// Network statistics
+	Network *NetworkStats `json:"network,omitempty"`
+	// Filesystem statistics
+	Filesystem []MachineFsStats `json:"filesystem,omitempty"`
+	// Task load statistics
+	Load *v1.LoadStats `json:"load_stats,omitempty"`
+}
+
+// MachineFsStats contains per filesystem capacity and usage information.
+type MachineFsStats struct {
+	// The block device name associated with the filesystem.
+	Device string `json:"device"`
+
+	// Type of filesystem.
+	Type string `json:"type"`
+
+	// Number of bytes that can be consumed on this filesystem.
+	Capacity *uint64 `json:"capacity,omitempty"`
+
+	// Number of bytes that is currently consumed on this filesystem.
+	Usage *uint64 `json:"usage,omitempty"`
+
+	// Number of bytes available for non-root user on this filesystem.
+	Available *uint64 `json:"available,omitempty"`
+
+	// Number of inodes that are available on this filesystem.
+	InodesFree *uint64 `json:"inodes_free,omitempty"`
+
+	// DiskStats for this device.
+	DiskStats `json:"inline"`
+}
+
+// DiskStats contains per partition usage information.
+// This information is only available at the machine level.
+type DiskStats struct {
+	// Number of reads completed
+	// This is the total number of reads completed successfully.
+	ReadsCompleted *uint64 `json:"reads_completed,omitempty"`
+
+	// Number of reads merged
+	// Reads and writes which are adjacent to each other may be merged for
+	// efficiency.  Thus two 4K reads may become one 8K read before it is
+	// ultimately handed to the disk, and so it will be counted (and queued)
+	// as only one I/O.  This field lets you know how often this was done.
+	ReadsMerged *uint64 `json:"reads_merged,omitempty"`
+
+	// Number of sectors read
+	// This is the total number of sectors read successfully.
+	SectorsRead *uint64 `json:"sectors_read,omitempty"`
+
+	// Time spent reading
+	// This is the total number of milliseconds spent by all reads (as
+	// measured from __make_request() to end_that_request_last()).
+	ReadDuration *time.Duration `json:"read_duration,omitempty"`
+
+	// Number of writes completed
+	// This is the total number of writes completed successfully.
+	WritesCompleted *uint64 `json:"writes_completed,omitempty"`
+
+	// Number of writes merged
+	// See the description of reads merged.
+	WritesMerged *uint64 `json:"writes_merged,omitempty"`
+
+	// Number of sectors written
+	// This is the total number of sectors written successfully.
+	SectorsWritten *uint64 `json:"sectors_written,omitempty"`
+
+	// Time spent writing
+	// This is the total number of milliseconds spent by all writes (as
+	// measured from __make_request() to end_that_request_last()).
+	WriteDuration *time.Duration `json:"write_duration,omitempty"`
+
+	// Number of I/Os currently in progress
+	// The only field that should go to zero. Incremented as requests are
+	// given to appropriate struct request_queue and decremented as they finish.
+	IoInProgress *uint64 `json:"io_in_progress,omitempty"`
+
+	// Time spent doing I/Os
+	// This field increases so long as field 9 is nonzero.
+	IoDuration *time.Duration `json:"io_duration,omitempty"`
+
+	// weighted time spent doing I/Os
+	// This field is incremented at each I/O start, I/O completion, I/O
+	// merge, or read of these stats by the number of I/Os in progress
+	// (field 9) times the number of milliseconds spent doing I/O since the
+	// last update of this field.  This can provide an easy measure of both
+	// I/O completion time and the backlog that may be accumulating.
+	WeightedIoDuration *time.Duration `json:"weighted_io_duration,omitempty"`
+}