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/summary/buffer.go

@@ -0,0 +1,74 @@
+// 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 summary
+
+import (
+	info "github.com/google/cadvisor/info/v2"
+)
+
+// Manages a buffer of usage samples.
+// This is similar to stats buffer in cache/memory.
+// The main difference is that we do not pre-allocate the buffer as most containers
+// won't live that long.
+type SamplesBuffer struct {
+	// list of collected samples.
+	samples []info.Usage
+	// maximum size this buffer can grow to.
+	maxSize int
+	// index for the latest sample.
+	index int
+}
+
+// Initializes an empty buffer.
+func NewSamplesBuffer(size int) *SamplesBuffer {
+	return &SamplesBuffer{
+		index:   -1,
+		maxSize: size,
+	}
+}
+
+// Returns the current number of samples in the buffer.
+func (s *SamplesBuffer) Size() int {
+	return len(s.samples)
+}
+
+// Add an element to the buffer. Oldest one is overwritten if required.
+func (s *SamplesBuffer) Add(stat info.Usage) {
+	if len(s.samples) < s.maxSize {
+		s.samples = append(s.samples, stat)
+		s.index++
+		return
+	}
+	s.index = (s.index + 1) % s.maxSize
+	s.samples[s.index] = stat
+}
+
+// Returns pointers to the last 'n' stats.
+func (s *SamplesBuffer) RecentStats(n int) []*info.Usage {
+	if n > len(s.samples) {
+		n = len(s.samples)
+	}
+	start := s.index - (n - 1)
+	if start < 0 {
+		start += len(s.samples)
+	}
+
+	out := make([]*info.Usage, n)
+	for i := 0; i < n; i++ {
+		index := (start + i) % len(s.samples)
+		out[i] = &s.samples[index]
+	}
+	return out
+}

vendor/github.com/google/cadvisor/summary/percentiles.go

@@ -0,0 +1,201 @@
+// 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.
+
+// Utility methods to calculate percentiles.
+
+package summary
+
+import (
+	"fmt"
+	"math"
+	"sort"
+
+	info "github.com/google/cadvisor/info/v2"
+)
+
+const secondsToMilliSeconds = 1000
+const milliSecondsToNanoSeconds = 1000000
+const secondsToNanoSeconds = secondsToMilliSeconds * milliSecondsToNanoSeconds
+
+type Uint64Slice []uint64
+
+func (s Uint64Slice) Len() int           { return len(s) }
+func (s Uint64Slice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+func (s Uint64Slice) Less(i, j int) bool { return s[i] < s[j] }
+
+// Get percentile of the provided samples. Round to integer.
+func (s Uint64Slice) GetPercentile(d float64) uint64 {
+	if d < 0.0 || d > 1.0 {
+		return 0
+	}
+	count := s.Len()
+	if count == 0 {
+		return 0
+	}
+	sort.Sort(s)
+	n := float64(d * (float64(count) + 1))
+	idx, frac := math.Modf(n)
+	index := int(idx)
+	percentile := float64(s[index-1])
+	if index > 1 && index < count {
+		percentile += frac * float64(s[index]-s[index-1])
+	}
+	return uint64(percentile)
+}
+
+type mean struct {
+	// current count.
+	count uint64
+	// current mean.
+	Mean float64
+}
+
+func (m *mean) Add(value uint64) {
+	m.count++
+	if m.count == 1 {
+		m.Mean = float64(value)
+		return
+	}
+	c := float64(m.count)
+	v := float64(value)
+	m.Mean = (m.Mean*(c-1) + v) / c
+}
+
+type Percentile interface {
+	Add(info.Percentiles)
+	AddSample(uint64)
+	GetAllPercentiles() info.Percentiles
+}
+
+type resource struct {
+	// list of samples being tracked.
+	samples Uint64Slice
+	// average from existing samples.
+	mean mean
+	// maximum value seen so far in the added samples.
+	max uint64
+}
+
+// Adds a new percentile sample.
+func (r *resource) Add(p info.Percentiles) {
+	if !p.Present {
+		return
+	}
+	if p.Max > r.max {
+		r.max = p.Max
+	}
+	r.mean.Add(p.Mean)
+	// Selecting 90p of 90p :(
+	r.samples = append(r.samples, p.Ninety)
+}
+
+// Add a single sample. Internally, we convert it to a fake percentile sample.
+func (r *resource) AddSample(val uint64) {
+	sample := info.Percentiles{
+		Present:    true,
+		Mean:       val,
+		Max:        val,
+		Fifty:      val,
+		Ninety:     val,
+		NinetyFive: val,
+	}
+	r.Add(sample)
+}
+
+// Get max, average, and 90p from existing samples.
+func (r *resource) GetAllPercentiles() info.Percentiles {
+	p := info.Percentiles{}
+	p.Mean = uint64(r.mean.Mean)
+	p.Max = r.max
+	p.Fifty = r.samples.GetPercentile(0.5)
+	p.Ninety = r.samples.GetPercentile(0.9)
+	p.NinetyFive = r.samples.GetPercentile(0.95)
+	p.Present = true
+	return p
+}
+
+func NewResource(size int) Percentile {
+	return &resource{
+		samples: make(Uint64Slice, 0, size),
+		mean:    mean{count: 0, Mean: 0},
+	}
+}
+
+// Return aggregated percentiles from the provided percentile samples.
+func GetDerivedPercentiles(stats []*info.Usage) info.Usage {
+	cpu := NewResource(len(stats))
+	memory := NewResource(len(stats))
+	for _, stat := range stats {
+		cpu.Add(stat.Cpu)
+		memory.Add(stat.Memory)
+	}
+	usage := info.Usage{}
+	usage.Cpu = cpu.GetAllPercentiles()
+	usage.Memory = memory.GetAllPercentiles()
+	return usage
+}
+
+// Calculate part of a minute this sample set represent.
+func getPercentComplete(stats []*secondSample) (percent int32) {
+	numSamples := len(stats)
+	if numSamples > 1 {
+		percent = 100
+		timeRange := stats[numSamples-1].Timestamp.Sub(stats[0].Timestamp).Nanoseconds()
+		// allow some slack
+		if timeRange < 58*secondsToNanoSeconds {
+			percent = int32((timeRange * 100) / 60 * secondsToNanoSeconds)
+		}
+	}
+	return
+}
+
+// Calculate cpurate from two consecutive total cpu usage samples.
+func getCPURate(latest, previous secondSample) (uint64, error) {
+	elapsed := latest.Timestamp.Sub(previous.Timestamp).Nanoseconds()
+	if elapsed < 10*milliSecondsToNanoSeconds {
+		return 0, fmt.Errorf("elapsed time too small: %d ns: time now %s last %s", elapsed, latest.Timestamp.String(), previous.Timestamp.String())
+	}
+	if latest.Cpu < previous.Cpu {
+		return 0, fmt.Errorf("bad sample: cumulative cpu usage dropped from %d to %d", latest.Cpu, previous.Cpu)
+	}
+	// Cpurate is calculated in cpu-milliseconds per second.
+	cpuRate := (latest.Cpu - previous.Cpu) * secondsToMilliSeconds / uint64(elapsed)
+	return cpuRate, nil
+}
+
+// Returns a percentile sample for a minute by aggregating seconds samples.
+func GetMinutePercentiles(stats []*secondSample) info.Usage {
+	lastSample := secondSample{}
+	cpu := NewResource(len(stats))
+	memory := NewResource(len(stats))
+	for _, stat := range stats {
+		if !lastSample.Timestamp.IsZero() {
+			cpuRate, err := getCPURate(*stat, lastSample)
+			if err != nil {
+				continue
+			}
+			cpu.AddSample(cpuRate)
+			memory.AddSample(stat.Memory)
+		} else {
+			memory.AddSample(stat.Memory)
+		}
+		lastSample = *stat
+	}
+	percent := getPercentComplete(stats)
+	return info.Usage{
+		PercentComplete: percent,
+		Cpu:             cpu.GetAllPercentiles(),
+		Memory:          memory.GetAllPercentiles(),
+	}
+}

vendor/github.com/google/cadvisor/summary/summary.go

@@ -0,0 +1,184 @@
+// 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.
+
+// Maintains the summary of aggregated minute, hour, and day stats.
+// For a container running for more than a day, amount of tracked data can go up to
+// 40 KB when cpu and memory are tracked. We'll start by enabling collection for the
+// node, followed by docker, and then all containers as we understand the usage pattern
+// better
+// TODO(rjnagal): Optimize the size if we start running it for every container.
+package summary
+
+import (
+	"fmt"
+	"sync"
+	"time"
+
+	v1 "github.com/google/cadvisor/info/v1"
+	info "github.com/google/cadvisor/info/v2"
+)
+
+// Usage fields we track for generating percentiles.
+type secondSample struct {
+	Timestamp time.Time // time when the sample was recorded.
+	Cpu       uint64    // cpu usage
+	Memory    uint64    // memory usage
+}
+
+type availableResources struct {
+	Cpu    bool
+	Memory bool
+}
+
+type StatsSummary struct {
+	// Resources being tracked for this container.
+	available availableResources
+	// list of second samples. The list is cleared when a new minute samples is generated.
+	secondSamples []*secondSample
+	// minute percentiles. We track 24 * 60 maximum samples.
+	minuteSamples *SamplesBuffer
+	// latest derived instant, minute, hour, and day stats. Instant sample updated every second.
+	// Others updated every minute.
+	derivedStats info.DerivedStats // Guarded by dataLock.
+	dataLock     sync.RWMutex
+}
+
+// Adds a new seconds sample.
+// If enough seconds samples are collected, a minute sample is generated and derived
+// stats are updated.
+func (s *StatsSummary) AddSample(stat v1.ContainerStats) error {
+	sample := secondSample{}
+	sample.Timestamp = stat.Timestamp
+	if s.available.Cpu {
+		sample.Cpu = stat.Cpu.Usage.Total
+	}
+	if s.available.Memory {
+		sample.Memory = stat.Memory.WorkingSet
+	}
+	s.secondSamples = append(s.secondSamples, &sample)
+	s.updateLatestUsage()
+	// TODO(jnagal): Use 'available' to avoid unnecessary computation.
+	numSamples := len(s.secondSamples)
+	elapsed := time.Nanosecond
+	if numSamples > 1 {
+		start := s.secondSamples[0].Timestamp
+		end := s.secondSamples[numSamples-1].Timestamp
+		elapsed = end.Sub(start)
+	}
+	if elapsed > 60*time.Second {
+		// Make a minute sample. This works with dynamic housekeeping as long
+		// as we keep max dynamic housekeeping period close to a minute.
+		minuteSample := GetMinutePercentiles(s.secondSamples)
+		// Clear seconds samples. Keep the latest sample for continuity.
+		// Copying and resizing helps avoid slice re-allocation.
+		s.secondSamples[0] = s.secondSamples[numSamples-1]
+		s.secondSamples = s.secondSamples[:1]
+		s.minuteSamples.Add(minuteSample)
+		err := s.updateDerivedStats()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s *StatsSummary) updateLatestUsage() {
+	usage := info.InstantUsage{}
+	numStats := len(s.secondSamples)
+	if numStats < 1 {
+		return
+	}
+	latest := s.secondSamples[numStats-1]
+	usage.Memory = latest.Memory
+	if numStats > 1 {
+		previous := s.secondSamples[numStats-2]
+		cpu, err := getCPURate(*latest, *previous)
+		if err == nil {
+			usage.Cpu = cpu
+		}
+	}
+
+	s.dataLock.Lock()
+	defer s.dataLock.Unlock()
+	s.derivedStats.LatestUsage = usage
+	s.derivedStats.Timestamp = latest.Timestamp
+}
+
+// Generate new derived stats based on current minute stats samples.
+func (s *StatsSummary) updateDerivedStats() error {
+	derived := info.DerivedStats{}
+	derived.Timestamp = time.Now()
+	minuteSamples := s.minuteSamples.RecentStats(1)
+	if len(minuteSamples) != 1 {
+		return fmt.Errorf("failed to retrieve minute stats")
+	}
+	derived.MinuteUsage = *minuteSamples[0]
+	hourUsage, err := s.getDerivedUsage(60)
+	if err != nil {
+		return fmt.Errorf("failed to compute hour stats: %v", err)
+	}
+	dayUsage, err := s.getDerivedUsage(60 * 24)
+	if err != nil {
+		return fmt.Errorf("failed to compute day usage: %v", err)
+	}
+	derived.HourUsage = hourUsage
+	derived.DayUsage = dayUsage
+
+	s.dataLock.Lock()
+	defer s.dataLock.Unlock()
+	derived.LatestUsage = s.derivedStats.LatestUsage
+	s.derivedStats = derived
+
+	return nil
+}
+
+// helper method to get hour and daily derived stats
+func (s *StatsSummary) getDerivedUsage(n int) (info.Usage, error) {
+	if n < 1 {
+		return info.Usage{}, fmt.Errorf("invalid number of samples requested: %d", n)
+	}
+	samples := s.minuteSamples.RecentStats(n)
+	numSamples := len(samples)
+	if numSamples < 1 {
+		return info.Usage{}, fmt.Errorf("failed to retrieve any minute stats")
+	}
+	// We generate derived stats even with partial data.
+	usage := GetDerivedPercentiles(samples)
+	// Assumes we have equally placed minute samples.
+	usage.PercentComplete = int32(numSamples * 100 / n)
+	return usage, nil
+}
+
+// Return the latest calculated derived stats.
+func (s *StatsSummary) DerivedStats() (info.DerivedStats, error) {
+	s.dataLock.RLock()
+	defer s.dataLock.RUnlock()
+
+	return s.derivedStats, nil
+}
+
+func New(spec v1.ContainerSpec) (*StatsSummary, error) {
+	summary := StatsSummary{}
+	if spec.HasCpu {
+		summary.available.Cpu = true
+	}
+	if spec.HasMemory {
+		summary.available.Memory = true
+	}
+	if !summary.available.Cpu && !summary.available.Memory {
+		return nil, fmt.Errorf("none of the resources are being tracked")
+	}
+	summary.minuteSamples = NewSamplesBuffer(60 /* one hour */)
+	return &summary, nil
+}