add the storageversion.Manager interface

Author: roycaihw

staging/src/k8s.io/apiserver/pkg/storageversion/manager.go

@@ -17,178 +17,203 @@ limitations under the License.
 package storageversion
 
 import (
+	"fmt"
 	"sync"
 	"sync/atomic"
 
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
-	apiserverclientset "k8s.io/apiserver/pkg/client/clientset_generated/clientset"
+	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
+	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
 	_ "k8s.io/component-base/metrics/prometheus/workqueue" // for workqueue metric registration
-	"k8s.io/klog"
+	"k8s.io/klog/v2"
 )
 
 // ResourceInfo contains the information to register the resource to the
 // storage version API.
 type ResourceInfo struct {
-	Resource metav1.APIResource
-	// We use a standalone Group instead of reusing the Resource.Group
-	// because Resource.Group is often omitted, see the comment on
-	// Resource.Group for why it's omitted.
-	Group                    string
-	EncodingVersion          string
-	DecodableVersions        []string
+	GroupResource schema.GroupResource
+
+	EncodingVersion string
+	// Used to calculate decodable versions. Can only be used after all
+	// equivalent versions are registered by InstallREST.
 	EquivalentResourceMapper runtime.EquivalentResourceRegistry
 }
 
 // Manager records the resources whose StorageVersions need updates, and provides a method to update those StorageVersions.
 type Manager interface {
-	// AddResourceInfo adds ResourceInfo to the manager.
+	// AddResourceInfo records resources whose StorageVersions need updates
 	AddResourceInfo(resources ...*ResourceInfo)
-	// RemoveResourceInfo removes ResourceInfo from the manager.
-	RemoveResourceInfo(r *ResourceInfo)
-	// UpdatesPending returns if the StorageVersion of a resource is still wait to be updated.
-	UpdatesPending(group, resource string) bool
-
-	// UpdateStorageVersions updates the StorageVersions.
-	UpdateStorageVersions(loopbackClientConfig *rest.Config, apiserverID string)
-	// Completed returns if updating StorageVersions has completed.
+	// UpdateStorageVersions tries to update the StorageVersions of the recorded resources
+	UpdateStorageVersions(kubeAPIServerClientConfig *rest.Config, apiserverID string)
+	// PendingUpdate returns true if the StorageVersion of the given resource is still pending update.
+	PendingUpdate(gr schema.GroupResource) bool
+	// LastUpdateError returns the last error hit when updating the storage version of the given resource.
+	LastUpdateError(gr schema.GroupResource) error
+	// Completed returns true if updating StorageVersions of all recorded resources has completed.
 	Completed() bool
 }
 
-var _ Manager = &DefaultManager{}
+var _ Manager = &defaultManager{}
+
+// defaultManager indicates if an apiserver has completed reporting its storage versions.
+type defaultManager struct {
+	completed atomic.Value
+
+	mu sync.RWMutex
+	// managedResourceInfos records the ResourceInfos whose StorageVersions will get updated in the next
+	// UpdateStorageVersions call
+	managedResourceInfos map[*ResourceInfo]struct{}
+	// managedStatus records the update status of StorageVersion for each GroupResource. Since one
+	// ResourceInfo may expand into multiple GroupResource (e.g. ingresses.networking.k8s.io and ingresses.extensions),
+	// this map allows quick status lookup for a GroupResource, during API request handling.
+	managedStatus map[schema.GroupResource]*updateStatus
+}
+
+type updateStatus struct {
+	done    bool
+	lastErr error
+}
 
-// NewDefaultManager creates a new DefaultManager.
-func NewDefaultManager() *DefaultManager {
-	s := &DefaultManager{}
+// NewDefaultManager creates a new defaultManager.
+func NewDefaultManager() Manager {
+	s := &defaultManager{}
 	s.completed.Store(false)
-	s.groupResources = make(map[string]map[string]struct{})
-	s.resources = make(map[*ResourceInfo]struct{})
+	s.managedResourceInfos = make(map[*ResourceInfo]struct{})
+	s.managedStatus = make(map[schema.GroupResource]*updateStatus)
 	return s
 }
 
 // AddResourceInfo adds ResourceInfo to the manager.
-// This is not thread-safe. It is expected to be called when the apiserver is installing the endpoints, which is done serially.
-func (s *DefaultManager) AddResourceInfo(resources ...*ResourceInfo) {
+func (s *defaultManager) AddResourceInfo(resources ...*ResourceInfo) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
 	for _, r := range resources {
-		s.resources[r] = struct{}{}
-		s.addGroupResourceFor(r)
+		s.managedResourceInfos[r] = struct{}{}
+		s.addPendingManagedStatusLocked(r)
 	}
 }
 
-func (s *DefaultManager) addGroupResourceFor(r *ResourceInfo) {
-	gvrs := r.EquivalentResourceMapper.EquivalentResourcesFor(schema.GroupVersionResource{
-		Group:    r.Group,
-		Resource: r.Resource.Name,
-	}, "")
+func (s *defaultManager) addPendingManagedStatusLocked(r *ResourceInfo) {
+	gvrs := r.EquivalentResourceMapper.EquivalentResourcesFor(r.GroupResource.WithVersion(""), "")
 	for _, gvr := range gvrs {
-		s.addGroupResource(gvr.Group, gvr.Resource)
+		s.managedStatus[gvr.GroupResource()] = &updateStatus{}
 	}
 }
 
-func (s *DefaultManager) addGroupResource(group, resource string) {
-	if _, ok := s.groupResources[group]; !ok {
-		s.groupResources[group] = make(map[string]struct{})
+// UpdateStorageVersions tries to update the StorageVersions of the recorded resources
+func (s *defaultManager) UpdateStorageVersions(kubeAPIServerClientConfig *rest.Config, serverID string) {
+	clientset, err := kubernetes.NewForConfig(kubeAPIServerClientConfig)
+	if err != nil {
+		utilruntime.HandleError(fmt.Errorf("failed to get clientset: %v", err))
+		return
+	}
+	sc := clientset.InternalV1alpha1().StorageVersions()
+
+	s.mu.RLock()
+	resources := make([]*ResourceInfo, len(s.managedResourceInfos))
+	for resource := range s.managedResourceInfos {
+		resources = append(resources, resource)
 	}
-	s.groupResources[group][resource] = struct{}{}
+	s.mu.RUnlock()
+	hasFailure := false
+	for _, r := range resources {
+		dv := decodableVersions(r.EquivalentResourceMapper, r.GroupResource)
+		if err := updateStorageVersionFor(sc, serverID, r.GroupResource, r.EncodingVersion, dv); err != nil {
+			utilruntime.HandleError(fmt.Errorf("failed to update storage version for %v: %v", r.GroupResource, err))
+			s.recordStatusFailure(r, err)
+			hasFailure = true
+			continue
+		}
+		klog.V(2).Infof("successfully updated storage version for %v", r.GroupResource)
+		s.recordStatusSuccess(r)
+	}
+	if hasFailure {
+		return
+	}
+	klog.V(2).Infof("storage version updates complete")
+	s.setComplete()
 }
 
-// RemoveResourceInfo removes ResourceInfo from the manager.
-// It is not safe to call this function concurrently with AddResourceInfo.
-func (s *DefaultManager) RemoveResourceInfo(r *ResourceInfo) {
+// recordStatusSuccess marks updated ResourceInfo as completed.
+func (s *defaultManager) recordStatusSuccess(r *ResourceInfo) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
-	delete(s.resources, r)
-	s.removeGroupResourceFor(r)
+	s.recordStatusSuccessLocked(r)
 }
 
-func (s *DefaultManager) removeGroupResourceFor(r *ResourceInfo) {
-	gvrs := r.EquivalentResourceMapper.EquivalentResourcesFor(schema.GroupVersionResource{
-		Group:    r.Group,
-		Resource: r.Resource.Name,
-	}, "")
+func (s *defaultManager) recordStatusSuccessLocked(r *ResourceInfo) {
+	gvrs := r.EquivalentResourceMapper.EquivalentResourcesFor(r.GroupResource.WithVersion(""), "")
 	for _, gvr := range gvrs {
-		s.removeGroupResource(gvr.Group, gvr.Version)
+		s.recordSuccessGroupResourceLocked(gvr.GroupResource())
 	}
 }
 
-func (s *DefaultManager) removeGroupResource(group, resource string) {
-	if _, ok := s.groupResources[group]; !ok {
+func (s *defaultManager) recordSuccessGroupResourceLocked(gr schema.GroupResource) {
+	if _, ok := s.managedStatus[gr]; !ok {
 		return
 	}
-	delete(s.groupResources[group], resource)
-	if len(s.groupResources[group]) == 0 {
-		delete(s.groupResources, group)
+	s.managedStatus[gr].done = true
+	s.managedStatus[gr].lastErr = nil
+}
+
+// recordStatusFailure records latest error updating ResourceInfo.
+func (s *defaultManager) recordStatusFailure(r *ResourceInfo, err error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.recordStatusFailureLocked(r, err)
+}
+
+func (s *defaultManager) recordStatusFailureLocked(r *ResourceInfo, err error) {
+	gvrs := r.EquivalentResourceMapper.EquivalentResourcesFor(r.GroupResource.WithVersion(""), "")
+	for _, gvr := range gvrs {
+		s.recordErrorGroupResourceLocked(gvr.GroupResource(), err)
+	}
+}
+
+func (s *defaultManager) recordErrorGroupResourceLocked(gr schema.GroupResource, err error) {
+	if _, ok := s.managedStatus[gr]; !ok {
+		return
 	}
+	s.managedStatus[gr].lastErr = err
 }
 
-// UpdatesPending returns if the StorageVersion of a resource is still wait to be updated.
-func (s *DefaultManager) UpdatesPending(group, resource string) bool {
+// PendingUpdate returns if the StorageVersion of a resource is still wait to be updated.
+func (s *defaultManager) PendingUpdate(gr schema.GroupResource) bool {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
-	if _, ok := s.groupResources[group]; !ok {
+	if _, ok := s.managedStatus[gr]; !ok {
 		return false
 	}
-	_, ok := s.groupResources[group][resource]
-	return ok
+	return !s.managedStatus[gr].done
 }
 
-// DefaultManager indicates if the aggregator, kube-apiserver, and the
-// apiextensions-apiserver have completed reporting their storage versions.
-type DefaultManager struct {
-	completed atomic.Value
-
-	mu             sync.RWMutex
-	resources      map[*ResourceInfo]struct{}
-	groupResources map[string]map[string]struct{}
+// LastUpdateError returns the last error hit when updating the storage version of the given resource.
+func (s *defaultManager) LastUpdateError(gr schema.GroupResource) error {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	if _, ok := s.managedStatus[gr]; !ok {
+		return fmt.Errorf("couldn't find managed status for %v", gr)
+	}
+	return s.managedStatus[gr].lastErr
 }
 
 // setComplete marks the completion of updating StorageVersions. No write requests need to be blocked anymore.
-func (s *DefaultManager) setComplete() {
+func (s *defaultManager) setComplete() {
 	s.completed.Store(true)
 }
 
 // Completed returns if updating StorageVersions has completed.
-func (s *DefaultManager) Completed() bool {
+func (s *defaultManager) Completed() bool {
 	return s.completed.Load().(bool)
 }
 
-func decodableVersions(e runtime.EquivalentResourceRegistry, group string, resource string) []string {
+func decodableVersions(e runtime.EquivalentResourceRegistry, gr schema.GroupResource) []string {
 	var versions []string
-	decodingGVRs := e.EquivalentResourcesFor(schema.GroupVersionResource{
-		Group:    group,
-		Resource: resource,
-	}, "")
+	decodingGVRs := e.EquivalentResourcesFor(gr.WithVersion(""), "")
 	for _, v := range decodingGVRs {
 		versions = append(versions, v.GroupVersion().String())
 	}
 	return versions
 }
-
-// UpdateStorageVersions updates the StorageVersions. If the updates are
-// successful, following calls to Completed() returns true.
-func (s *DefaultManager) UpdateStorageVersions(loopbackClientConfig *rest.Config, serverID string) {
-	cfg := rest.AddUserAgent(loopbackClientConfig, "system:kube-apiserver")
-	clientset, err := apiserverclientset.NewForConfig(cfg)
-	if err != nil {
-		klog.Fatalf("failed to get clientset: %v", err)
-		return
-	}
-	sc := clientset.InternalV1alpha1().StorageVersions()
-
-	s.mu.RLock()
-	resources := s.resources
-	s.mu.RUnlock()
-	for r := range resources {
-		r.DecodableVersions = decodableVersions(r.EquivalentResourceMapper, r.Group, r.Resource.Name)
-		if err := updateStorageVersionFor(sc, serverID, r.Group+"."+r.Resource.Name, r.EncodingVersion, r.DecodableVersions); err != nil {
-			klog.Fatalf("failed to update storage version for %v", r.Resource.Name)
-			return
-		}
-		klog.V(2).Infof("successfully updated storage version for %v", r.Resource.Name)
-		s.RemoveResourceInfo(r)
-	}
-	klog.V(2).Infof("storage version updates complete")
-	s.setComplete()
-}