Make plural handling more robust

Author: jthomperoo

example/simple-pod-metrics-python/config.yaml

@@ -1,15 +1,16 @@
 evaluate:
   type: "shell"
   timeout: 2500
-  shell: 
+  shell:
     entrypoint: "python"
-    command: 
+    command:
       - "/evaluate.py"
 metric:
   type: "shell"
   timeout: 2500
-  shell: 
+  shell:
     entrypoint: "python"
-    command: 
+    command:
       - "/metric.py"
-runMode: "per-pod"
+runMode: "per-pod"
+logVerbosity: 3

internal/resourceclient/resourceclient.go

@@ -18,14 +18,12 @@ package resourceclient
 
 import (
 	"context"
-	"fmt"
-
-	"strings"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/client-go/dynamic"
+	"k8s.io/client-go/restmapper"
 )
 
 // Client provides methods for retrieving arbitrary Kubernetes resources, returned as generalised metav1.Object, which
@@ -37,31 +35,21 @@ type Client interface {
 // UnstructuredClient is an implementation of the arbitrary resource client that uses a dynamic Kubernetes interface,
 // retrieving unstructured k8s objects and converting them to metav1.Object
 type UnstructuredClient struct {
-	Dynamic dynamic.Interface
+	Dynamic    dynamic.Interface
+	RESTMapper restmapper.DeferredDiscoveryRESTMapper
 }
 
 // Get takes descriptors of a Kubernetes object (api version, kind, name, namespace) and fetches the matching object,
 // returning it as an unstructured Kubernetes resource
 func (u *UnstructuredClient) Get(apiVersion string, kind string, name string, namespace string) (*unstructured.Unstructured, error) {
-	// TODO: update this to be less hacky
-	// Convert to plural and lowercase
-	kindPlural := fmt.Sprintf("%ss", strings.ToLower(kind))
-
-	// Parse group version
-	resourceGV, err := schema.ParseGroupVersion(apiVersion)
+	resourceGK := schema.FromAPIVersionAndKind(apiVersion, kind)
+	mapping, err := u.RESTMapper.RESTMapping(resourceGK.GroupKind(), resourceGK.Version)
 	if err != nil {
 		return nil, err
 	}
 
-	// Build GVR
-	resourceGVR := schema.GroupVersionResource{
-		Group:    resourceGV.Group,
-		Version:  resourceGV.Version,
-		Resource: kindPlural,
-	}
-
 	// Get resource
-	resource, err := u.Dynamic.Resource(resourceGVR).Namespace(namespace).Get(context.Background(), name, metav1.GetOptions{})
+	resource, err := u.Dynamic.Resource(mapping.Resource).Namespace(namespace).Get(context.Background(), name, metav1.GetOptions{})
 	if err != nil {
 		return nil, err
 	}

internal/scaling/scaling.go

@@ -22,7 +22,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"strings"
 	"time"
 
 	"github.com/golang/glog"
@@ -34,6 +33,7 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/client-go/restmapper"
 	k8sscale "k8s.io/client-go/scale"
 )
 
@@ -49,6 +49,7 @@ type Scale struct {
 	Config                   *config.Config
 	Execute                  execute.Executer
 	StabilizationEvaluations []TimestampedEvaluation
+	RESTMapper               restmapper.DeferredDiscoveryRESTMapper
 }
 
 // TimestampedEvaluation is used to associate an evaluation with a timestamp, used in stabilizing evaluations
@@ -133,14 +134,12 @@ func (s *Scale) Scale(info scale.Info, scaleResource *autoscalingv1.Scale) (*eva
 		glog.V(0).Infof("Rescaling from %d to %d replicas", currentReplicas, targetReplicas)
 		glog.V(3).Infoln("Attempting to parse group version")
 		// Parse group version
-		resourceGV, err := schema.ParseGroupVersion(info.ScaleTargetRef.APIVersion)
+		resourceGK := schema.FromAPIVersionAndKind(info.ScaleTargetRef.APIVersion, info.ScaleTargetRef.Kind)
+		mapping, err := s.RESTMapper.RESTMapping(resourceGK.GroupKind(), resourceGK.Version)
 		if err != nil {
 			return nil, err
 		}
-		glog.V(3).Infof("Group version parsed: %+v", resourceGV)
-
-		kindPlural := fmt.Sprintf("%ss", strings.ToLower(info.ScaleTargetRef.Kind))
-		targetGVR := resourceGV.WithResource(kindPlural)
+		glog.V(3).Infof("Group version parsed: %+v", mapping.Resource)
 
 		glog.V(3).Infoln("Attempting to apply scaling changes to resource")
 
@@ -149,7 +148,7 @@ func (s *Scale) Scale(info scale.Info, scaleResource *autoscalingv1.Scale) (*eva
 
 		glog.V(3).Infof("Applying patch: %s to resource %s in namespace %s", string(patch), scaleResource.Name, info.Namespace)
 
-		_, err = s.Scaler.Scales(info.Namespace).Patch(context.Background(), targetGVR, scaleResource.Name, types.StrategicMergePatchType, patch, metav1.PatchOptions{})
+		_, err = s.Scaler.Scales(info.Namespace).Patch(context.Background(), mapping.Resource, scaleResource.Name, types.StrategicMergePatchType, patch, metav1.PatchOptions{})
 		if err != nil {
 			return nil, fmt.Errorf("failed to apply scaling changes to resource: %w", err)
 		}

main.go

@@ -51,6 +51,8 @@ import (
 	"github.com/jthomperoo/k8shorizmetrics/v3"
 	"github.com/jthomperoo/k8shorizmetrics/v3/metricsclient"
 	"github.com/jthomperoo/k8shorizmetrics/v3/podsclient"
+	"k8s.io/client-go/discovery"
+	memory "k8s.io/client-go/discovery/cached"
 	"k8s.io/client-go/dynamic"
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
@@ -123,11 +125,11 @@ func main() {
 		glog.Fatalf("Fail to set up Kubernetes dynamic client: %s", err)
 	}
 
-	// Get group resources
-	groupResources, err := restmapper.GetAPIGroupResources(clientset.Discovery())
+	discoveryClient, err := discovery.NewDiscoveryClientForConfig(clusterConfig)
 	if err != nil {
-		glog.Fatalf("Fail get group resources: %s", err)
+		glog.Fatalf("Fail to set up Kubernetes discovery client: %s", err)
 	}
+	cachedDiscoveryClient := memory.NewMemCacheClient(discoveryClient)
 
 	// Set logging level
 	err = flag.Lookup("v").Value.Set(strconv.Itoa(int(loadedConfig.LogVerbosity)))
@@ -140,20 +142,19 @@ func main() {
 
 	// Set up resource client
 	resourceClient := &resourceclient.UnstructuredClient{
-		Dynamic: dynamicClient,
+		Dynamic:    dynamicClient,
+		RESTMapper: *restmapper.NewDeferredDiscoveryRESTMapper(cachedDiscoveryClient),
 	}
 
 	scaleClient := k8sscale.New(
 		clientset.RESTClient(),
-		restmapper.NewDiscoveryRESTMapper(groupResources),
+		restmapper.NewDeferredDiscoveryRESTMapper(cachedDiscoveryClient),
 		dynamic.LegacyAPIPathResolverFunc,
-		k8sscale.NewDiscoveryScaleKindResolver(
-			clientset.Discovery(),
-		),
+		k8sscale.NewDiscoveryScaleKindResolver(cachedDiscoveryClient),
 	)
 
 	// Create K8s metric gatherer, with required clients and configuration
-	metricsclient := metricsclient.NewClient(clusterConfig, clientset.Discovery())
+	metricsclient := metricsclient.NewClient(clusterConfig, cachedDiscoveryClient)
 	podsclient := &podsclient.OnDemandPodLister{
 		Clientset: clientset,
 	}
@@ -178,9 +179,10 @@ func main() {
 
 	// Set up scaling client
 	scaler := &scaling.Scale{
-		Scaler:  scaleClient,
-		Config:  loadedConfig,
-		Execute: combinedExecute,
+		Scaler:     scaleClient,
+		Config:     loadedConfig,
+		Execute:    combinedExecute,
+		RESTMapper: *restmapper.NewDeferredDiscoveryRESTMapper(cachedDiscoveryClient),
 	}
 
 	// Set up metric gathering