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/k8s.io/kubernetes/pkg/kubelet/status/state/checkpoint.go

@@ -0,0 +1,80 @@
+/*
+Copyright 2021 The Kubernetes Authors.
+
+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 state
+
+import (
+	"encoding/json"
+	"fmt"
+
+	v1 "k8s.io/api/core/v1"
+	"k8s.io/kubernetes/pkg/kubelet/checkpointmanager"
+	"k8s.io/kubernetes/pkg/kubelet/checkpointmanager/checksum"
+)
+
+var _ checkpointmanager.Checkpoint = &Checkpoint{}
+
+type PodResourceAllocationInfo struct {
+	AllocationEntries map[string]map[string]v1.ResourceRequirements `json:"allocationEntries,omitempty"`
+}
+
+// Checkpoint represents a structure to store pod resource allocation checkpoint data
+type Checkpoint struct {
+	// Data is a serialized PodResourceAllocationInfo
+	Data string `json:"data"`
+	// Checksum is a checksum of Data
+	Checksum checksum.Checksum `json:"checksum"`
+}
+
+// NewCheckpoint creates a new checkpoint from a list of claim info states
+func NewCheckpoint(allocations *PodResourceAllocationInfo) (*Checkpoint, error) {
+
+	serializedAllocations, err := json.Marshal(allocations)
+	if err != nil {
+		return nil, fmt.Errorf("failed to serialize allocations for checkpointing: %w", err)
+	}
+
+	cp := &Checkpoint{
+		Data: string(serializedAllocations),
+	}
+	cp.Checksum = checksum.New(cp.Data)
+	return cp, nil
+}
+
+func (cp *Checkpoint) MarshalCheckpoint() ([]byte, error) {
+	return json.Marshal(cp)
+}
+
+// UnmarshalCheckpoint unmarshals checkpoint from JSON
+func (cp *Checkpoint) UnmarshalCheckpoint(blob []byte) error {
+	return json.Unmarshal(blob, cp)
+}
+
+// VerifyChecksum verifies that current checksum
+// of checkpointed Data is valid
+func (cp *Checkpoint) VerifyChecksum() error {
+	return cp.Checksum.Verify(cp.Data)
+}
+
+// GetPodResourceAllocationInfo returns Pod Resource Allocation info states from checkpoint
+func (cp *Checkpoint) GetPodResourceAllocationInfo() (*PodResourceAllocationInfo, error) {
+	var data PodResourceAllocationInfo
+	if err := json.Unmarshal([]byte(cp.Data), &data); err != nil {
+		return nil, err
+	}
+
+	return &data, nil
+}

vendor/k8s.io/kubernetes/pkg/kubelet/status/state/state.go

@@ -0,0 +1,60 @@
+/*
+Copyright 2021 The Kubernetes Authors.
+
+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 state
+
+import (
+	v1 "k8s.io/api/core/v1"
+)
+
+// PodResourceAllocation type is used in tracking resources allocated to pod's containers
+type PodResourceAllocation map[string]map[string]v1.ResourceRequirements
+
+// PodResizeStatus type is used in tracking the last resize decision for pod
+type PodResizeStatus map[string]v1.PodResizeStatus
+
+// Clone returns a copy of PodResourceAllocation
+func (pr PodResourceAllocation) Clone() PodResourceAllocation {
+	prCopy := make(PodResourceAllocation)
+	for pod := range pr {
+		prCopy[pod] = make(map[string]v1.ResourceRequirements)
+		for container, alloc := range pr[pod] {
+			prCopy[pod][container] = *alloc.DeepCopy()
+		}
+	}
+	return prCopy
+}
+
+// Reader interface used to read current pod resource allocation state
+type Reader interface {
+	GetContainerResourceAllocation(podUID string, containerName string) (v1.ResourceRequirements, bool)
+	GetPodResourceAllocation() PodResourceAllocation
+	GetPodResizeStatus(podUID string) v1.PodResizeStatus
+}
+
+type writer interface {
+	SetContainerResourceAllocation(podUID string, containerName string, alloc v1.ResourceRequirements) error
+	SetPodResourceAllocation(PodResourceAllocation) error
+	SetPodResizeStatus(podUID string, resizeStatus v1.PodResizeStatus)
+	Delete(podUID string, containerName string) error
+	ClearState() error
+}
+
+// State interface provides methods for tracking and setting pod resource allocation
+type State interface {
+	Reader
+	writer
+}

vendor/k8s.io/kubernetes/pkg/kubelet/status/state/state_checkpoint.go

@@ -0,0 +1,200 @@
+/*
+Copyright 2021 The Kubernetes Authors.
+
+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 state
+
+import (
+	"fmt"
+	"path"
+	"sync"
+
+	v1 "k8s.io/api/core/v1"
+	"k8s.io/klog/v2"
+	"k8s.io/kubernetes/pkg/kubelet/checkpointmanager"
+	"k8s.io/kubernetes/pkg/kubelet/checkpointmanager/errors"
+)
+
+var _ State = &stateCheckpoint{}
+
+type stateCheckpoint struct {
+	mux               sync.RWMutex
+	cache             State
+	checkpointManager checkpointmanager.CheckpointManager
+	checkpointName    string
+}
+
+// NewStateCheckpoint creates new State for keeping track of pod resource allocations with checkpoint backend
+func NewStateCheckpoint(stateDir, checkpointName string) (State, error) {
+	checkpointManager, err := checkpointmanager.NewCheckpointManager(stateDir)
+	if err != nil {
+		return nil, fmt.Errorf("failed to initialize checkpoint manager for pod allocation tracking: %v", err)
+	}
+	stateCheckpoint := &stateCheckpoint{
+		cache:             NewStateMemory(),
+		checkpointManager: checkpointManager,
+		checkpointName:    checkpointName,
+	}
+
+	if err := stateCheckpoint.restoreState(); err != nil {
+		//lint:ignore ST1005 user-facing error message
+		return nil, fmt.Errorf("could not restore state from checkpoint: %v, please drain this node and delete pod allocation checkpoint file %q before restarting Kubelet", err, path.Join(stateDir, checkpointName))
+	}
+	return stateCheckpoint, nil
+}
+
+// restores state from a checkpoint and creates it if it doesn't exist
+func (sc *stateCheckpoint) restoreState() error {
+	sc.mux.Lock()
+	defer sc.mux.Unlock()
+	var err error
+
+	checkpoint, err := NewCheckpoint(nil)
+	if err != nil {
+		return fmt.Errorf("failed to create new checkpoint: %w", err)
+	}
+
+	if err = sc.checkpointManager.GetCheckpoint(sc.checkpointName, checkpoint); err != nil {
+		if err == errors.ErrCheckpointNotFound {
+			return sc.storeState()
+		}
+		return err
+	}
+	praInfo, err := checkpoint.GetPodResourceAllocationInfo()
+	if err != nil {
+		return fmt.Errorf("failed to get pod resource allocation info: %w", err)
+	}
+	err = sc.cache.SetPodResourceAllocation(praInfo.AllocationEntries)
+	if err != nil {
+		return fmt.Errorf("failed to set pod resource allocation: %w", err)
+	}
+	klog.V(2).InfoS("State checkpoint: restored pod resource allocation state from checkpoint")
+	return nil
+}
+
+// saves state to a checkpoint, caller is responsible for locking
+func (sc *stateCheckpoint) storeState() error {
+	podAllocation := sc.cache.GetPodResourceAllocation()
+
+	checkpoint, err := NewCheckpoint(&PodResourceAllocationInfo{
+		AllocationEntries: podAllocation,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to create checkpoint: %w", err)
+	}
+	err = sc.checkpointManager.CreateCheckpoint(sc.checkpointName, checkpoint)
+	if err != nil {
+		klog.ErrorS(err, "Failed to save pod allocation checkpoint")
+		return err
+	}
+	return nil
+}
+
+// GetContainerResourceAllocation returns current resources allocated to a pod's container
+func (sc *stateCheckpoint) GetContainerResourceAllocation(podUID string, containerName string) (v1.ResourceRequirements, bool) {
+	sc.mux.RLock()
+	defer sc.mux.RUnlock()
+	return sc.cache.GetContainerResourceAllocation(podUID, containerName)
+}
+
+// GetPodResourceAllocation returns current pod resource allocation
+func (sc *stateCheckpoint) GetPodResourceAllocation() PodResourceAllocation {
+	sc.mux.RLock()
+	defer sc.mux.RUnlock()
+	return sc.cache.GetPodResourceAllocation()
+}
+
+// GetPodResizeStatus returns the last resize decision for a pod
+func (sc *stateCheckpoint) GetPodResizeStatus(podUID string) v1.PodResizeStatus {
+	sc.mux.RLock()
+	defer sc.mux.RUnlock()
+	return sc.cache.GetPodResizeStatus(podUID)
+}
+
+// SetContainerResourceAllocation sets resources allocated to a pod's container
+func (sc *stateCheckpoint) SetContainerResourceAllocation(podUID string, containerName string, alloc v1.ResourceRequirements) error {
+	sc.mux.Lock()
+	defer sc.mux.Unlock()
+	sc.cache.SetContainerResourceAllocation(podUID, containerName, alloc)
+	return sc.storeState()
+}
+
+// SetPodResourceAllocation sets pod resource allocation
+func (sc *stateCheckpoint) SetPodResourceAllocation(a PodResourceAllocation) error {
+	sc.mux.Lock()
+	defer sc.mux.Unlock()
+	sc.cache.SetPodResourceAllocation(a)
+	return sc.storeState()
+}
+
+// SetPodResizeStatus sets the last resize decision for a pod
+func (sc *stateCheckpoint) SetPodResizeStatus(podUID string, resizeStatus v1.PodResizeStatus) {
+	sc.mux.Lock()
+	defer sc.mux.Unlock()
+	sc.cache.SetPodResizeStatus(podUID, resizeStatus)
+}
+
+// Delete deletes allocations for specified pod
+func (sc *stateCheckpoint) Delete(podUID string, containerName string) error {
+	sc.mux.Lock()
+	defer sc.mux.Unlock()
+	sc.cache.Delete(podUID, containerName)
+	return sc.storeState()
+}
+
+// ClearState clears the state and saves it in a checkpoint
+func (sc *stateCheckpoint) ClearState() error {
+	sc.mux.Lock()
+	defer sc.mux.Unlock()
+	sc.cache.ClearState()
+	return sc.storeState()
+}
+
+type noopStateCheckpoint struct{}
+
+// NewNoopStateCheckpoint creates a dummy state checkpoint manager
+func NewNoopStateCheckpoint() State {
+	return &noopStateCheckpoint{}
+}
+
+func (sc *noopStateCheckpoint) GetContainerResourceAllocation(_ string, _ string) (v1.ResourceRequirements, bool) {
+	return v1.ResourceRequirements{}, false
+}
+
+func (sc *noopStateCheckpoint) GetPodResourceAllocation() PodResourceAllocation {
+	return nil
+}
+
+func (sc *noopStateCheckpoint) GetPodResizeStatus(_ string) v1.PodResizeStatus {
+	return ""
+}
+
+func (sc *noopStateCheckpoint) SetContainerResourceAllocation(_ string, _ string, _ v1.ResourceRequirements) error {
+	return nil
+}
+
+func (sc *noopStateCheckpoint) SetPodResourceAllocation(_ PodResourceAllocation) error {
+	return nil
+}
+
+func (sc *noopStateCheckpoint) SetPodResizeStatus(_ string, _ v1.PodResizeStatus) {}
+
+func (sc *noopStateCheckpoint) Delete(_ string, _ string) error {
+	return nil
+}
+
+func (sc *noopStateCheckpoint) ClearState() error {
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubelet/status/state/state_mem.go

@@ -0,0 +1,128 @@
+/*
+Copyright 2021 The Kubernetes Authors.
+
+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 state
+
+import (
+	"sync"
+
+	v1 "k8s.io/api/core/v1"
+	"k8s.io/klog/v2"
+)
+
+type stateMemory struct {
+	sync.RWMutex
+	podAllocation   PodResourceAllocation
+	podResizeStatus PodResizeStatus
+}
+
+var _ State = &stateMemory{}
+
+// NewStateMemory creates new State to track resources allocated to pods
+func NewStateMemory() State {
+	klog.V(2).InfoS("Initialized new in-memory state store for pod resource allocation tracking")
+	return &stateMemory{
+		podAllocation:   PodResourceAllocation{},
+		podResizeStatus: PodResizeStatus{},
+	}
+}
+
+func (s *stateMemory) GetContainerResourceAllocation(podUID string, containerName string) (v1.ResourceRequirements, bool) {
+	s.RLock()
+	defer s.RUnlock()
+
+	alloc, ok := s.podAllocation[podUID][containerName]
+	return *alloc.DeepCopy(), ok
+}
+
+func (s *stateMemory) GetPodResourceAllocation() PodResourceAllocation {
+	s.RLock()
+	defer s.RUnlock()
+	return s.podAllocation.Clone()
+}
+
+func (s *stateMemory) GetPodResizeStatus(podUID string) v1.PodResizeStatus {
+	s.RLock()
+	defer s.RUnlock()
+
+	return s.podResizeStatus[podUID]
+}
+
+func (s *stateMemory) SetContainerResourceAllocation(podUID string, containerName string, alloc v1.ResourceRequirements) error {
+	s.Lock()
+	defer s.Unlock()
+
+	if _, ok := s.podAllocation[podUID]; !ok {
+		s.podAllocation[podUID] = make(map[string]v1.ResourceRequirements)
+	}
+
+	s.podAllocation[podUID][containerName] = alloc
+	klog.V(3).InfoS("Updated container resource allocation", "podUID", podUID, "containerName", containerName, "alloc", alloc)
+	return nil
+}
+
+func (s *stateMemory) SetPodResourceAllocation(a PodResourceAllocation) error {
+	s.Lock()
+	defer s.Unlock()
+
+	s.podAllocation = a.Clone()
+	klog.V(3).InfoS("Updated pod resource allocation", "allocation", a)
+	return nil
+}
+
+func (s *stateMemory) SetPodResizeStatus(podUID string, resizeStatus v1.PodResizeStatus) {
+	s.Lock()
+	defer s.Unlock()
+
+	if resizeStatus != "" {
+		s.podResizeStatus[podUID] = resizeStatus
+	} else {
+		delete(s.podResizeStatus, podUID)
+	}
+	klog.V(3).InfoS("Updated pod resize state", "podUID", podUID, "resizeStatus", resizeStatus)
+}
+
+func (s *stateMemory) deleteContainer(podUID string, containerName string) {
+	delete(s.podAllocation[podUID], containerName)
+	if len(s.podAllocation[podUID]) == 0 {
+		delete(s.podAllocation, podUID)
+		delete(s.podResizeStatus, podUID)
+	}
+	klog.V(3).InfoS("Deleted pod resource allocation", "podUID", podUID, "containerName", containerName)
+}
+
+func (s *stateMemory) Delete(podUID string, containerName string) error {
+	s.Lock()
+	defer s.Unlock()
+	if len(containerName) == 0 {
+		delete(s.podAllocation, podUID)
+		delete(s.podResizeStatus, podUID)
+		klog.V(3).InfoS("Deleted pod resource allocation and resize state", "podUID", podUID)
+		return nil
+	}
+	s.deleteContainer(podUID, containerName)
+	return nil
+}
+
+func (s *stateMemory) ClearState() error {
+	s.Lock()
+	defer s.Unlock()
+
+	s.podAllocation = make(PodResourceAllocation)
+	s.podResizeStatus = make(PodResizeStatus)
+	klog.V(3).InfoS("Cleared state")
+	return nil
+}