Support multiple versions in custom metrics client

cmd/kube-controller-manager/app/autoscaling.go

@@ -28,6 +28,7 @@ import (
 	"k8s.io/client-go/scale"
 	"k8s.io/kubernetes/pkg/controller/podautoscaler"
 	"k8s.io/kubernetes/pkg/controller/podautoscaler/metrics"
+
 	resourceclient "k8s.io/metrics/pkg/client/clientset/versioned/typed/metrics/v1beta1"
 	"k8s.io/metrics/pkg/client/custom_metrics"
 	"k8s.io/metrics/pkg/client/external_metrics"
@@ -48,9 +49,19 @@ func startHPAController(ctx ControllerContext) (http.Handler, bool, error) {
 
 func startHPAControllerWithRESTClient(ctx ControllerContext) (http.Handler, bool, error) {
 	clientConfig := ctx.ClientBuilder.ConfigOrDie("horizontal-pod-autoscaler")
+	hpaClient := ctx.ClientBuilder.ClientOrDie("horizontal-pod-autoscaler")
+
+	apiVersionsGetter := custom_metrics.NewAvailableAPIsGetter(hpaClient.Discovery())
+	// invalidate the discovery information roughly once per resync interval our API
+	// information is *at most* two resync intervals old.
+	go custom_metrics.PeriodicallyInvalidate(
+		apiVersionsGetter,
+		ctx.ComponentConfig.HPAController.HorizontalPodAutoscalerSyncPeriod.Duration,
+		ctx.Stop)
+
 	metricsClient := metrics.NewRESTMetricsClient(
 		resourceclient.NewForConfigOrDie(clientConfig),
-		custom_metrics.NewForConfigOrDie(clientConfig),
+		custom_metrics.NewForConfig(clientConfig, ctx.RESTMapper, apiVersionsGetter),
 		external_metrics.NewForConfigOrDie(clientConfig),
 	)
 	return startHPAControllerWithMetricsClient(ctx, metricsClient)

staging/src/k8s.io/metrics/Godeps/Godeps.json

@@ -91,6 +91,18 @@
 			"Rev": "5f041e8faa004a95c88a202771f4cc3e991971e6"
 		},
 		{
+			"ImportPath": "github.com/pmezard/go-difflib/difflib",
+			"Rev": "d8ed2627bdf02c080bf22230dbb337003b7aba2d"
+		},
+		{
+			"ImportPath": "github.com/stretchr/testify/assert",
+			"Rev": "c679ae2cc0cb27ec3293fea7e254e47386f05d69"
+		},
+		{
+			"ImportPath": "github.com/stretchr/testify/require",
+			"Rev": "c679ae2cc0cb27ec3293fea7e254e47386f05d69"
+		},
+		{
 			"ImportPath": "golang.org/x/crypto/ssh/terminal",
 			"Rev": "de0752318171da717af4ce24d0a2e8626afaeb11"
 		},
@@ -439,6 +451,10 @@
 			"Rev": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 		},
 		{
+			"ImportPath": "k8s.io/client-go/discovery/cached",
+			"Rev": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+		},
+		{
 			"ImportPath": "k8s.io/client-go/discovery/fake",
 			"Rev": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 		},

staging/src/k8s.io/metrics/pkg/apis/custom_metrics/register.go

@@ -46,6 +46,7 @@ func addKnownTypes(scheme *runtime.Scheme) error {
 	scheme.AddKnownTypes(SchemeGroupVersion,
 		&MetricValue{},
 		&MetricValueList{},
+		&MetricListOptions{},
 	)
 	return nil
 }

staging/src/k8s.io/metrics/pkg/apis/custom_metrics/types.go

@@ -71,6 +71,22 @@ type MetricValue struct {
 // for all objects matching the given label selector
 const AllObjects = "*"
 
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// MetricListOptions is used to select metrics by their label selectors
+type MetricListOptions struct {
+	metav1.TypeMeta `json:",inline"`
+
+	// A selector to restrict the list of returned objects by their labels.
+	// Defaults to everything.
+	// +optional
+	LabelSelector string `json:"labelSelector,omitempty" protobuf:"bytes,1,opt,name=labelSelector"`
+
+	// A selector to restrict the list of returned metrics by their labels
+	// +optional
+	MetricLabelSelector string `json:"metricLabelSelector,omitempty" protobuf:"bytes,2,opt,name=metricLabelSelector"`
+}
+
 // NOTE: ObjectReference is copied from k8s.io/kubernetes/pkg/api/types.go. We
 // cannot depend on k8s.io/kubernetes/pkg/api because that creates cyclic
 // dependency between k8s.io/metrics and k8s.io/kubernetes. We cannot depend on

staging/src/k8s.io/metrics/pkg/apis/custom_metrics/v1beta1/generated.proto

@@ -30,6 +30,18 @@ import "k8s.io/apimachinery/pkg/runtime/schema/generated.proto";
 // Package-wide variables from generator "generated".
 option go_package = "v1beta1";
 
+// MetricListOptions is used to select metrics by their label selectors
+message MetricListOptions {
+  // A selector to restrict the list of returned objects by their labels.
+  // Defaults to everything.
+  // +optional
+  optional string labelSelector = 1;
+
+  // A selector to restrict the list of returned metrics by their labels
+  // +optional
+  optional string metricLabelSelector = 2;
+}
+
 // a metric value for some object
 message MetricValue {
   // a reference to the described object

staging/src/k8s.io/metrics/pkg/apis/custom_metrics/v1beta1/register.go

@@ -43,6 +43,7 @@ func addKnownTypes(scheme *runtime.Scheme) error {
 	scheme.AddKnownTypes(SchemeGroupVersion,
 		&MetricValue{},
 		&MetricValueList{},
+		&MetricListOptions{},
 	)
 	metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
 	return nil

staging/src/k8s.io/metrics/pkg/apis/custom_metrics/v1beta1/types.go

@@ -65,6 +65,22 @@ type MetricValue struct {
 	Selector *metav1.LabelSelector `json:"selector" protobuf:"bytes,6,opt,name=selector"`
 }
 
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// MetricListOptions is used to select metrics by their label selectors
+type MetricListOptions struct {
+	metav1.TypeMeta `json:",inline"`
+
+	// A selector to restrict the list of returned objects by their labels.
+	// Defaults to everything.
+	// +optional
+	LabelSelector string `json:"labelSelector,omitempty" protobuf:"bytes,1,opt,name=labelSelector"`
+
+	// A selector to restrict the list of returned metrics by their labels
+	// +optional
+	MetricLabelSelector string `json:"metricLabelSelector,omitempty" protobuf:"bytes,2,opt,name=metricLabelSelector"`
+}
+
 // allObjects is a wildcard used to select metrics
 // for all objects matching the given label selector
 const AllObjects = "*"

staging/src/k8s.io/metrics/pkg/apis/custom_metrics/v1beta1/zz_generated.conversion.go

@@ -35,6 +35,16 @@ func init() {
 // RegisterConversions adds conversion functions to the given scheme.
 // Public to allow building arbitrary schemes.
 func RegisterConversions(s *runtime.Scheme) error {
+	if err := s.AddGeneratedConversionFunc((*MetricListOptions)(nil), (*custommetrics.MetricListOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
+		return Convert_v1beta1_MetricListOptions_To_custom_metrics_MetricListOptions(a.(*MetricListOptions), b.(*custommetrics.MetricListOptions), scope)
+	}); err != nil {
+		return err
+	}
+	if err := s.AddGeneratedConversionFunc((*custommetrics.MetricListOptions)(nil), (*MetricListOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
+		return Convert_custom_metrics_MetricListOptions_To_v1beta1_MetricListOptions(a.(*custommetrics.MetricListOptions), b.(*MetricListOptions), scope)
+	}); err != nil {
+		return err
+	}
 	if err := s.AddGeneratedConversionFunc((*MetricValue)(nil), (*custommetrics.MetricValue)(nil), func(a, b interface{}, scope conversion.Scope) error {
 		return Convert_v1beta1_MetricValue_To_custom_metrics_MetricValue(a.(*MetricValue), b.(*custommetrics.MetricValue), scope)
 	}); err != nil {
@@ -68,6 +78,28 @@ func RegisterConversions(s *runtime.Scheme) error {
 	return nil
 }
 
+func autoConvert_v1beta1_MetricListOptions_To_custom_metrics_MetricListOptions(in *MetricListOptions, out *custommetrics.MetricListOptions, s conversion.Scope) error {
+	out.LabelSelector = in.LabelSelector
+	out.MetricLabelSelector = in.MetricLabelSelector
+	return nil
+}
+
+// Convert_v1beta1_MetricListOptions_To_custom_metrics_MetricListOptions is an autogenerated conversion function.
+func Convert_v1beta1_MetricListOptions_To_custom_metrics_MetricListOptions(in *MetricListOptions, out *custommetrics.MetricListOptions, s conversion.Scope) error {
+	return autoConvert_v1beta1_MetricListOptions_To_custom_metrics_MetricListOptions(in, out, s)
+}
+
+func autoConvert_custom_metrics_MetricListOptions_To_v1beta1_MetricListOptions(in *custommetrics.MetricListOptions, out *MetricListOptions, s conversion.Scope) error {
+	out.LabelSelector = in.LabelSelector
+	out.MetricLabelSelector = in.MetricLabelSelector
+	return nil
+}
+
+// Convert_custom_metrics_MetricListOptions_To_v1beta1_MetricListOptions is an autogenerated conversion function.
+func Convert_custom_metrics_MetricListOptions_To_v1beta1_MetricListOptions(in *custommetrics.MetricListOptions, out *MetricListOptions, s conversion.Scope) error {
+	return autoConvert_custom_metrics_MetricListOptions_To_v1beta1_MetricListOptions(in, out, s)
+}
+
 func autoConvert_v1beta1_MetricValue_To_custom_metrics_MetricValue(in *MetricValue, out *custommetrics.MetricValue, s conversion.Scope) error {
 	// TODO: Inefficient conversion - can we improve it?
 	if err := s.Convert(&in.DescribedObject, &out.DescribedObject, 0); err != nil {

staging/src/k8s.io/metrics/pkg/apis/custom_metrics/v1beta1/zz_generated.deepcopy.go

@@ -26,6 +26,31 @@ import (
 )
 
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *MetricListOptions) DeepCopyInto(out *MetricListOptions) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricListOptions.
+func (in *MetricListOptions) DeepCopy() *MetricListOptions {
+	if in == nil {
+		return nil
+	}
+	out := new(MetricListOptions)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *MetricListOptions) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	}
+	return nil
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *MetricValue) DeepCopyInto(out *MetricValue) {
 	*out = *in
 	out.TypeMeta = in.TypeMeta

staging/src/k8s.io/metrics/pkg/apis/custom_metrics/v1beta2/zz_generated.conversion.go

@@ -46,6 +46,16 @@ func RegisterConversions(s *runtime.Scheme) error {
 	}); err != nil {
 		return err
 	}
+	if err := s.AddGeneratedConversionFunc((*MetricListOptions)(nil), (*custommetrics.MetricListOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
+		return Convert_v1beta2_MetricListOptions_To_custom_metrics_MetricListOptions(a.(*MetricListOptions), b.(*custommetrics.MetricListOptions), scope)
+	}); err != nil {
+		return err
+	}
+	if err := s.AddGeneratedConversionFunc((*custommetrics.MetricListOptions)(nil), (*MetricListOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
+		return Convert_custom_metrics_MetricListOptions_To_v1beta2_MetricListOptions(a.(*custommetrics.MetricListOptions), b.(*MetricListOptions), scope)
+	}); err != nil {
+		return err
+	}
 	if err := s.AddGeneratedConversionFunc((*MetricValue)(nil), (*custommetrics.MetricValue)(nil), func(a, b interface{}, scope conversion.Scope) error {
 		return Convert_v1beta2_MetricValue_To_custom_metrics_MetricValue(a.(*MetricValue), b.(*custommetrics.MetricValue), scope)
 	}); err != nil {
@@ -91,6 +101,28 @@ func Convert_custom_metrics_MetricIdentifier_To_v1beta2_MetricIdentifier(in *cus
 	return autoConvert_custom_metrics_MetricIdentifier_To_v1beta2_MetricIdentifier(in, out, s)
 }
 
+func autoConvert_v1beta2_MetricListOptions_To_custom_metrics_MetricListOptions(in *MetricListOptions, out *custommetrics.MetricListOptions, s conversion.Scope) error {
+	out.LabelSelector = in.LabelSelector
+	out.MetricLabelSelector = in.MetricLabelSelector
+	return nil
+}
+
+// Convert_v1beta2_MetricListOptions_To_custom_metrics_MetricListOptions is an autogenerated conversion function.
+func Convert_v1beta2_MetricListOptions_To_custom_metrics_MetricListOptions(in *MetricListOptions, out *custommetrics.MetricListOptions, s conversion.Scope) error {
+	return autoConvert_v1beta2_MetricListOptions_To_custom_metrics_MetricListOptions(in, out, s)
+}
+
+func autoConvert_custom_metrics_MetricListOptions_To_v1beta2_MetricListOptions(in *custommetrics.MetricListOptions, out *MetricListOptions, s conversion.Scope) error {
+	out.LabelSelector = in.LabelSelector
+	out.MetricLabelSelector = in.MetricLabelSelector
+	return nil
+}
+
+// Convert_custom_metrics_MetricListOptions_To_v1beta2_MetricListOptions is an autogenerated conversion function.
+func Convert_custom_metrics_MetricListOptions_To_v1beta2_MetricListOptions(in *custommetrics.MetricListOptions, out *MetricListOptions, s conversion.Scope) error {
+	return autoConvert_custom_metrics_MetricListOptions_To_v1beta2_MetricListOptions(in, out, s)
+}
+
 func autoConvert_v1beta2_MetricValue_To_custom_metrics_MetricValue(in *MetricValue, out *custommetrics.MetricValue, s conversion.Scope) error {
 	// TODO: Inefficient conversion - can we improve it?
 	if err := s.Convert(&in.DescribedObject, &out.DescribedObject, 0); err != nil {

staging/src/k8s.io/metrics/pkg/apis/custom_metrics/zz_generated.deepcopy.go

@@ -47,6 +47,31 @@ func (in *MetricIdentifier) DeepCopy() *MetricIdentifier {
 }
 
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *MetricListOptions) DeepCopyInto(out *MetricListOptions) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricListOptions.
+func (in *MetricListOptions) DeepCopy() *MetricListOptions {
+	if in == nil {
+		return nil
+	}
+	out := new(MetricListOptions)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *MetricListOptions) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	}
+	return nil
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *MetricValue) DeepCopyInto(out *MetricValue) {
 	*out = *in
 	out.TypeMeta = in.TypeMeta

staging/src/k8s.io/metrics/pkg/client/custom_metrics/BUILD

-load("@io_bazel_rules_go//go:def.bzl", "go_library")
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
     srcs = [
-        "client.go",
+        "converter.go",
+        "discovery.go",
         "interfaces.go",
+        "multi_client.go",
+        "versioned_client.go",
     ],
     importmap = "k8s.io/kubernetes/vendor/k8s.io/metrics/pkg/client/custom_metrics",
     importpath = "k8s.io/metrics/pkg/client/custom_metrics",
     visibility = ["//visibility:public"],
     deps = [
         "//staging/src/k8s.io/apimachinery/pkg/api/meta:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/labels:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/runtime/serializer:go_default_library",
+        "//staging/src/k8s.io/client-go/discovery:go_default_library",
         "//staging/src/k8s.io/client-go/rest:go_default_library",
         "//staging/src/k8s.io/client-go/util/flowcontrol:go_default_library",
+        "//staging/src/k8s.io/metrics/pkg/apis/custom_metrics:go_default_library",
+        "//staging/src/k8s.io/metrics/pkg/apis/custom_metrics/v1beta1:go_default_library",
         "//staging/src/k8s.io/metrics/pkg/apis/custom_metrics/v1beta2:go_default_library",
         "//staging/src/k8s.io/metrics/pkg/client/custom_metrics/scheme:go_default_library",
     ],
@@ -38,3 +46,18 @@ filegroup(
     tags = ["automanaged"],
     visibility = ["//visibility:public"],
 )
+
+go_test(
+    name = "go_default_test",
+    srcs = ["util_test.go"],
+    embed = [":go_default_library"],
+    deps = [
+        "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//staging/src/k8s.io/metrics/pkg/apis/custom_metrics:go_default_library",
+        "//staging/src/k8s.io/metrics/pkg/apis/custom_metrics/v1beta1:go_default_library",
+        "//staging/src/k8s.io/metrics/pkg/apis/custom_metrics/v1beta2:go_default_library",
+        "//vendor/github.com/stretchr/testify/require:go_default_library",
+    ],
+)

staging/src/k8s.io/metrics/pkg/client/custom_metrics/converter.go

+/*
+Copyright 2018 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 custom_metrics
+
+import (
+	"fmt"
+
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/runtime/serializer"
+	"k8s.io/client-go/rest"
+
+	cmint "k8s.io/metrics/pkg/apis/custom_metrics"
+	cmv1beta1 "k8s.io/metrics/pkg/apis/custom_metrics/v1beta1"
+	cmv1beta2 "k8s.io/metrics/pkg/apis/custom_metrics/v1beta2"
+	"k8s.io/metrics/pkg/client/custom_metrics/scheme"
+)
+
+var (
+	// MetricVersions is the set of metric versions accepted by the converter.
+	MetricVersions = []schema.GroupVersion{
+		cmv1beta2.SchemeGroupVersion,
+		cmv1beta1.SchemeGroupVersion,
+		cmint.SchemeGroupVersion,
+	}
+)
+
+// MetricConverter knows how to convert between external MetricValue versions.
+type MetricConverter struct {
+	scheme            *runtime.Scheme
+	codecs            serializer.CodecFactory
+	internalVersioner runtime.GroupVersioner
+}
+
+// NewMetricConverter creates a MetricConverter which knows how to convert objects
+// between different versions of the custom metrics api.
+func NewMetricConverter() *MetricConverter {
+	return &MetricConverter{
+		scheme: scheme.Scheme,
+		codecs: serializer.NewCodecFactory(scheme.Scheme),
+		internalVersioner: runtime.NewMultiGroupVersioner(
+			scheme.SchemeGroupVersion,
+			schema.GroupKind{Group: cmint.GroupName, Kind: ""},
+			schema.GroupKind{Group: cmv1beta1.GroupName, Kind: ""},
+			schema.GroupKind{Group: cmv1beta2.GroupName, Kind: ""},
+		),
+	}
+}
+
+// Scheme returns the scheme used by this metric converter.
+func (c *MetricConverter) Scheme() *runtime.Scheme {
+	return c.scheme
+}
+
+// Codecs returns the codecs used by this metric converter
+func (c *MetricConverter) Codecs() serializer.CodecFactory {
+	return c.codecs
+}
+
+// ConvertListOptionsToVersion converts converts a set of MetricListOptions
+// to the provided GroupVersion.
+func (c *MetricConverter) ConvertListOptionsToVersion(opts *cmint.MetricListOptions, version schema.GroupVersion) (runtime.Object, error) {
+	paramObj, err := c.UnsafeConvertToVersionVia(opts, version)
+	if err != nil {
+		return nil, err
+	}
+	return paramObj, nil
+}
+
+// ConvertResultToVersion converts a Result to the provided GroupVersion
+func (c *MetricConverter) ConvertResultToVersion(res rest.Result, gv schema.GroupVersion) (runtime.Object, error) {
+	if err := res.Error(); err != nil {
+		return nil, err
+	}
+
+	metricBytes, err := res.Raw()
+	if err != nil {
+		return nil, err
+	}
+
+	decoder := c.codecs.UniversalDecoder(MetricVersions...)
+	rawMetricObj, err := runtime.Decode(decoder, metricBytes)
+	if err != nil {
+		return nil, err
+	}
+
+	metricObj, err := c.UnsafeConvertToVersionVia(rawMetricObj, gv)
+	if err != nil {
+		return nil, err
+	}
+	return metricObj, nil
+}
+
+// unsafeConvertToVersionVia is like Scheme.UnsafeConvertToVersion, but it does so via an internal version first.
+// We use it here to work with the v1beta2 client internally, while preserving backwards compatibility for existing custom metrics adapters
+func (c *MetricConverter) UnsafeConvertToVersionVia(obj runtime.Object, externalVersion schema.GroupVersion) (runtime.Object, error) {
+	objInt, err := c.scheme.UnsafeConvertToVersion(obj, schema.GroupVersion{Group: externalVersion.Group, Version: runtime.APIVersionInternal})
+	if err != nil {
+		return nil, fmt.Errorf("failed to convert the given object to the internal version: %v", err)
+	}
+
+	objExt, err := c.scheme.UnsafeConvertToVersion(objInt, externalVersion)
+	if err != nil {
+		return nil, fmt.Errorf("failed to convert the given object back to the external version: %v", err)
+	}
+
+	return objExt, err
+}

staging/src/k8s.io/metrics/pkg/client/custom_metrics/discovery.go

+/*
+Copyright 2018 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 custom_metrics
+
+import (
+	"fmt"
+	"sync"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/discovery"
+
+	cmint "k8s.io/metrics/pkg/apis/custom_metrics"
+)
+
+var (
+	// metricVersionsToGV is the map of string group-versions
+	// accepted by the converter to group-version objects (so
+	// we don't have to re-parse)
+	metricVersionsToGV map[string]schema.GroupVersion
+)
+
+func init() {
+	metricVersionsToGV = make(map[string]schema.GroupVersion)
+	for _, ver := range MetricVersions {
+		metricVersionsToGV[ver.String()] = ver
+	}
+}
+
+// NewAvailableAPIsGetter creates an AvailableAPIsGetter that checks discovery
+// to find the available versions of the custom metrics api.
+func NewAvailableAPIsGetter(client discovery.DiscoveryInterface) AvailableAPIsGetter {
+	return &apiVersionsFromDiscovery{
+		client: client,
+	}
+}
+
+// apiVersionsFromDiscovery caches a preferred version of the custom metrics api.
+type apiVersionsFromDiscovery struct {
+	client discovery.DiscoveryInterface
+
+	// just cache the group directly since the discovery interface doesn't yet allow
+	// asking for a single API group's versions.
+	prefVersion *schema.GroupVersion
+	mu          sync.RWMutex
+}
+
+// fetchVersions fetches the versions, but doesn't try to invalidate on cache misses.
+func (d *apiVersionsFromDiscovery) fetchVersions() (*metav1.APIGroup, error) {
+	// TODO(directxman12): amend the discovery interface to ask for a particular group (/apis/foo)
+	groups, err := d.client.ServerGroups()
+	if err != nil {
+		return nil, err
+	}
+
+	// Determine the preferred version on the server by first finding the custom metrics group
+	var apiGroup *metav1.APIGroup
+	for _, group := range groups.Groups {
+		if group.Name == cmint.GroupName {
+			apiGroup = &group
+			break
+		}
+	}
+
+	if apiGroup == nil {
+		return nil, fmt.Errorf("no custom metrics API (%s) registered", cmint.GroupName)
+	}
+
+	return apiGroup, nil
+}
+
+// chooseVersion sets a preferred version of the custom metrics api based on available versions.
+func (d *apiVersionsFromDiscovery) chooseVersion(apiGroup *metav1.APIGroup) (schema.GroupVersion, error) {
+	var preferredVersion *schema.GroupVersion
+	if gv, present := metricVersionsToGV[apiGroup.PreferredVersion.GroupVersion]; present && len(apiGroup.PreferredVersion.GroupVersion) != 0 {
+		preferredVersion = &gv
+	} else {
+		for _, version := range apiGroup.Versions {
+			if gv, present := metricVersionsToGV[version.GroupVersion]; present {
+				preferredVersion = &gv
+				break
+			}
+		}
+	}
+
+	if preferredVersion == nil {
+		return schema.GroupVersion{}, fmt.Errorf("no known available metric versions found")
+	}
+	return *preferredVersion, nil
+}
+
+// PreferredVersion returns the current preferred version of the custom metrics api.
+// If none is specified, it will use the first known one.
+func (d *apiVersionsFromDiscovery) PreferredVersion() (schema.GroupVersion, error) {
+	d.mu.RLock()
+	if d.prefVersion != nil {
+		// if we've already got one, proceed with that
+		defer d.mu.RUnlock()
+		return *d.prefVersion, nil
+	}
+	d.mu.RUnlock()
+
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	// double check, someone might have beaten us to it
+	if d.prefVersion != nil {
+		return *d.prefVersion, nil
+	}
+
+	// populate our cache
+	groupInfo, err := d.fetchVersions()
+	if err != nil {
+		return schema.GroupVersion{}, err
+	}
+	prefVersion, err := d.chooseVersion(groupInfo)
+	if err != nil {
+		return schema.GroupVersion{}, err
+	}
+
+	d.prefVersion = &prefVersion
+	return *d.prefVersion, nil
+}
+
+// Invalidate refreshes the preferred version information.
+func (d *apiVersionsFromDiscovery) Invalidate() {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	d.prefVersion = nil
+}

staging/src/k8s.io/metrics/pkg/client/custom_metrics/multi_client.go

+/*
+Copyright 2018 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 custom_metrics
+
+import (
+	"sync"
+	"time"
+
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/rest"
+
+	"k8s.io/metrics/pkg/apis/custom_metrics/v1beta2"
+)
+
+// AvailableAPIsGetter knows how to fetch and cache the preferred custom metrics API version,
+// and invalidate that cache when asked.
+type AvailableAPIsGetter interface {
+	PreferredVersion() (schema.GroupVersion, error)
+	Invalidate()
+}
+
+// PeriodicallyInvalidate periodically invalidates the preferred version cache until
+// told to stop.
+func PeriodicallyInvalidate(cache AvailableAPIsGetter, interval time.Duration, stopCh <-chan struct{}) {
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C:
+			cache.Invalidate()
+		case <-stopCh:
+			break
+		}
+	}
+}
+
+// NewForConfig creates a new custom metrics client which delegates to a client which
+// uses the preferred api version.
+func NewForConfig(baseConfig *rest.Config, mapper meta.RESTMapper, availableAPIs AvailableAPIsGetter) CustomMetricsClient {
+	return &multiClient{
+		clients:       make(map[schema.GroupVersion]CustomMetricsClient),
+		availableAPIs: availableAPIs,
+
+		newClient: func(ver schema.GroupVersion) (CustomMetricsClient, error) {
+			return NewForVersionForConfig(rest.CopyConfig(baseConfig), mapper, ver)
+		},
+	}
+}
+
+// multiClient is a CustomMetricsClient that can work with *any* metrics API version.
+type multiClient struct {
+	newClient     func(schema.GroupVersion) (CustomMetricsClient, error)
+	clients       map[schema.GroupVersion]CustomMetricsClient
+	availableAPIs AvailableAPIsGetter
+	mu            sync.RWMutex
+}
+
+// getPreferredClient returns a custom metrics client of the preferred api version.
+func (c *multiClient) getPreferredClient() (CustomMetricsClient, error) {
+	pref, err := c.availableAPIs.PreferredVersion()
+	if err != nil {
+		return nil, err
+	}
+
+	c.mu.RLock()
+	client, present := c.clients[pref]
+	c.mu.RUnlock()
+	if present {
+		return client, nil
+	}
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	client, err = c.newClient(pref)
+	if err != nil {
+		return nil, err
+	}
+	c.clients[pref] = client
+
+	return client, nil
+}
+
+func (c *multiClient) RootScopedMetrics() MetricsInterface {
+	return &multiClientInterface{clients: c}
+}
+
+func (c *multiClient) NamespacedMetrics(namespace string) MetricsInterface {
+	return &multiClientInterface{
+		clients:   c,
+		namespace: &namespace,
+	}
+}
+
+type multiClientInterface struct {
+	clients   *multiClient
+	namespace *string
+}
+
+func (m *multiClientInterface) GetForObject(groupKind schema.GroupKind, name string, metricName string, metricSelector labels.Selector) (*v1beta2.MetricValue, error) {
+	client, err := m.clients.getPreferredClient()
+	if err != nil {
+		return nil, err
+	}
+	if m.namespace == nil {
+		return client.RootScopedMetrics().GetForObject(groupKind, name, metricName, metricSelector)
+	} else {
+		return client.NamespacedMetrics(*m.namespace).GetForObject(groupKind, name, metricName, metricSelector)
+	}
+}
+
+func (m *multiClientInterface) GetForObjects(groupKind schema.GroupKind, selector labels.Selector, metricName string, metricSelector labels.Selector) (*v1beta2.MetricValueList, error) {
+	client, err := m.clients.getPreferredClient()
+	if err != nil {
+		return nil, err
+	}
+	if m.namespace == nil {
+		return client.RootScopedMetrics().GetForObjects(groupKind, selector, metricName, metricSelector)
+	} else {
+		return client.NamespacedMetrics(*m.namespace).GetForObjects(groupKind, selector, metricName, metricSelector)
+	}
+}

staging/src/k8s.io/metrics/pkg/client/custom_metrics/scheme/BUILD

@@ -11,6 +11,7 @@ go_library(
         "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/runtime/serializer:go_default_library",
+        "//staging/src/k8s.io/metrics/pkg/apis/custom_metrics:go_default_library",
         "//staging/src/k8s.io/metrics/pkg/apis/custom_metrics/v1beta1:go_default_library",
         "//staging/src/k8s.io/metrics/pkg/apis/custom_metrics/v1beta2:go_default_library",
     ],

staging/src/k8s.io/metrics/pkg/client/custom_metrics/scheme/register.go

@@ -21,10 +21,15 @@ import (
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	schema "k8s.io/apimachinery/pkg/runtime/schema"
 	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
+	cmint "k8s.io/metrics/pkg/apis/custom_metrics"
 	cmv1beta1 "k8s.io/metrics/pkg/apis/custom_metrics/v1beta1"
 	cmv1beta2 "k8s.io/metrics/pkg/apis/custom_metrics/v1beta2"
 )
 
+const GroupName = cmv1beta1.GroupName
+
+var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}
+
 var Scheme = runtime.NewScheme()
 var Codecs = serializer.NewCodecFactory(Scheme)
 var ParameterCodec = runtime.NewParameterCodec(Scheme)
@@ -49,6 +54,7 @@ func init() {
 // After this, RawExtensions in Kubernetes types will serialize kube-aggregator types
 // correctly.
 func AddToScheme(scheme *runtime.Scheme) {
+	cmint.AddToScheme(scheme)
 	cmv1beta1.AddToScheme(scheme)
 	cmv1beta2.AddToScheme(scheme)
 }

staging/src/k8s.io/metrics/pkg/client/custom_metrics/util_test.go

+/*
+Copyright 2018 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 custom_metrics
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+
+	cmint "k8s.io/metrics/pkg/apis/custom_metrics"
+	cmv1beta1 "k8s.io/metrics/pkg/apis/custom_metrics/v1beta1"
+	cmv1beta2 "k8s.io/metrics/pkg/apis/custom_metrics/v1beta2"
+)
+
+func TestMetricConverter(t *testing.T) {
+	testCases := []struct {
+		name     string
+		group    schema.GroupVersion
+		expected runtime.Object
+	}{
+		{
+			name:  "Use custom metrics v1beta2",
+			group: cmv1beta2.SchemeGroupVersion,
+			expected: &cmv1beta2.MetricListOptions{
+				TypeMeta:            metav1.TypeMeta{Kind: "MetricListOptions", APIVersion: cmv1beta2.SchemeGroupVersion.String()},
+				MetricLabelSelector: "foo",
+			},
+		},
+		{
+			name:  "Use custom metrics v1beta1",
+			group: cmv1beta1.SchemeGroupVersion,
+			expected: &cmv1beta1.MetricListOptions{
+				TypeMeta:            metav1.TypeMeta{Kind: "MetricListOptions", APIVersion: cmv1beta1.SchemeGroupVersion.String()},
+				MetricLabelSelector: "foo",
+			},
+		},
+	}
+
+	for _, test := range testCases {
+		t.Run(test.name, func(t *testing.T) {
+			metricConverter := NewMetricConverter()
+			opts := &cmint.MetricListOptions{MetricLabelSelector: "foo"}
+			res, err := metricConverter.ConvertListOptionsToVersion(opts, test.group)
+			require.NoError(t, err)
+			require.Equal(t, test.expected, res)
+		})
+	}
+}

staging/src/k8s.io/metrics/pkg/client/custom_metrics/client.go → staging/src/k8s.io/metrics/pkg/client/custom_metrics/versioned_client.go

@@ -25,22 +25,35 @@ import (
 	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/util/flowcontrol"
+
+	cmint "k8s.io/metrics/pkg/apis/custom_metrics"
+	"k8s.io/metrics/pkg/apis/custom_metrics/v1beta1"
 	"k8s.io/metrics/pkg/apis/custom_metrics/v1beta2"
 	"k8s.io/metrics/pkg/client/custom_metrics/scheme"
 )
 
+var (
+	codecs           = serializer.NewCodecFactory(scheme.Scheme)
+	versionConverter = NewMetricConverter()
+)
+
 type customMetricsClient struct {
-	client rest.Interface
-	mapper meta.RESTMapper
+	client  rest.Interface
+	version schema.GroupVersion
+	mapper  meta.RESTMapper
 }
 
-func New(client rest.Interface) CustomMetricsClient {
+// NewForVersion returns a new CustomMetricsClient for a particular api version.
+func NewForVersion(client rest.Interface, mapper meta.RESTMapper, version schema.GroupVersion) CustomMetricsClient {
 	return &customMetricsClient{
-		client: client,
+		client:  client,
+		version: version,
+		mapper:  mapper,
 	}
 }
 
-func NewForConfig(c *rest.Config) (CustomMetricsClient, error) {
+// NewForVersionForConfig returns a new CustomMetricsClient for a particular api version and base configuration.
+func NewForVersionForConfig(c *rest.Config, mapper meta.RESTMapper, version schema.GroupVersion) (CustomMetricsClient, error) {
 	configShallowCopy := *c
 	if configShallowCopy.RateLimiter == nil && configShallowCopy.QPS > 0 {
 		configShallowCopy.RateLimiter = flowcontrol.NewTokenBucketRateLimiter(configShallowCopy.QPS, configShallowCopy.Burst)
@@ -49,7 +62,7 @@ func NewForConfig(c *rest.Config) (CustomMetricsClient, error) {
 	if configShallowCopy.UserAgent == "" {
 		configShallowCopy.UserAgent = rest.DefaultKubernetesUserAgent()
 	}
-	configShallowCopy.GroupVersion = &v1beta2.SchemeGroupVersion
+	configShallowCopy.GroupVersion = &version
 	configShallowCopy.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}
 
 	client, err := rest.RESTClientFor(&configShallowCopy)
@@ -57,24 +70,7 @@ func NewForConfig(c *rest.Config) (CustomMetricsClient, error) {
 		return nil, err
 	}
 
-	return New(client), nil
-}
-
-func NewForConfigOrDie(c *rest.Config) CustomMetricsClient {
-	client, err := NewForConfig(c)
-	if err != nil {
-		panic(err)
-	}
-	return client
-}
-
-// NewForMapper constructs the client with a RESTMapper, which allows more
-// accurate translation from GroupVersionKind to GroupVersionResource.
-func NewForMapper(client rest.Interface, mapper meta.RESTMapper) CustomMetricsClient {
-	return &customMetricsClient{
-		client: client,
-		mapper: mapper,
-	}
+	return NewForVersion(client, mapper, version), nil
 }
 
 func (c *customMetricsClient) RootScopedMetrics() MetricsInterface {
@@ -88,16 +84,8 @@ func (c *customMetricsClient) NamespacedMetrics(namespace string) MetricsInterfa
 	}
 }
 
+// qualResourceForKind returns the string format of a qualified group resource for the specified GroupKind
 func (c *customMetricsClient) qualResourceForKind(groupKind schema.GroupKind) (string, error) {
-	if c.mapper == nil {
-		// the version doesn't matter
-		gvk := groupKind.WithVersion("")
-		gvr, _ := meta.UnsafeGuessKindToResource(gvk)
-		gr := gvr.GroupResource()
-		return gr.String(), nil
-	}
-
-	// use the mapper if it's available
 	mapping, err := c.mapper.RESTMapping(groupKind)
 	if err != nil {
 		return "", fmt.Errorf("unable to map kind %s to resource: %v", groupKind.String(), err)
@@ -112,21 +100,26 @@ type rootScopedMetrics struct {
 }
 
 func (m *rootScopedMetrics) getForNamespace(namespace string, metricName string, metricSelector labels.Selector) (*v1beta2.MetricValue, error) {
-	res := &v1beta2.MetricValueList{}
-	err := m.client.client.Get().
+	params, err := versionConverter.ConvertListOptionsToVersion(&cmint.MetricListOptions{
+		MetricLabelSelector: metricSelector.String(),
+	}, m.client.version)
+	if err != nil {
+		return nil, err
+	}
+
+	result := m.client.client.Get().
 		Resource("metrics").
 		Namespace(namespace).
 		Name(metricName).
-		VersionedParams(&v1beta2.MetricListOptions{
-			MetricLabelSelector: metricSelector.String(),
-		}, scheme.ParameterCodec).
-		Do().
-		Into(res)
+		VersionedParams(params, scheme.ParameterCodec).
+		Do()
 
+	metricObj, err := versionConverter.ConvertResultToVersion(result, v1beta2.SchemeGroupVersion)
 	if err != nil {
 		return nil, err
 	}
 
+	res := metricObj.(*v1beta2.MetricValueList)
 	if len(res.Items) != 1 {
 		return nil, fmt.Errorf("the custom metrics API server returned %v results when we asked for exactly one", len(res.Items))
 	}
@@ -145,21 +138,26 @@ func (m *rootScopedMetrics) GetForObject(groupKind schema.GroupKind, name string
 		return nil, err
 	}
 
-	res := &v1beta2.MetricValueList{}
-	err = m.client.client.Get().
+	params, err := versionConverter.ConvertListOptionsToVersion(&cmint.MetricListOptions{
+		MetricLabelSelector: metricSelector.String(),
+	}, m.client.version)
+	if err != nil {
+		return nil, err
+	}
+
+	result := m.client.client.Get().
 		Resource(resourceName).
 		Name(name).
 		SubResource(metricName).
-		VersionedParams(&v1beta2.MetricListOptions{
-			MetricLabelSelector: metricSelector.String(),
-		}, scheme.ParameterCodec).
-		Do().
-		Into(res)
+		VersionedParams(params, scheme.ParameterCodec).
+		Do()
 
+	metricObj, err := versionConverter.ConvertResultToVersion(result, v1beta2.SchemeGroupVersion)
 	if err != nil {
 		return nil, err
 	}
 
+	res := metricObj.(*v1beta2.MetricValueList)
 	if len(res.Items) != 1 {
 		return nil, fmt.Errorf("the custom metrics API server returned %v results when we asked for exactly one", len(res.Items))
 	}
@@ -178,22 +176,27 @@ func (m *rootScopedMetrics) GetForObjects(groupKind schema.GroupKind, selector l
 		return nil, err
 	}
 
-	res := &v1beta2.MetricValueList{}
-	err = m.client.client.Get().
+	params, err := versionConverter.ConvertListOptionsToVersion(&cmint.MetricListOptions{
+		LabelSelector:       selector.String(),
+		MetricLabelSelector: metricSelector.String(),
+	}, m.client.version)
+	if err != nil {
+		return nil, err
+	}
+
+	result := m.client.client.Get().
 		Resource(resourceName).
-		Name(v1beta2.AllObjects).
+		Name(v1beta1.AllObjects).
 		SubResource(metricName).
-		VersionedParams(&v1beta2.MetricListOptions{
-			LabelSelector:       selector.String(),
-			MetricLabelSelector: metricSelector.String(),
-		}, scheme.ParameterCodec).
-		Do().
-		Into(res)
+		VersionedParams(params, scheme.ParameterCodec).
+		Do()
 
+	metricObj, err := versionConverter.ConvertResultToVersion(result, v1beta2.SchemeGroupVersion)
 	if err != nil {
 		return nil, err
 	}
 
+	res := metricObj.(*v1beta2.MetricValueList)
 	return res, nil
 }
 
@@ -208,22 +211,27 @@ func (m *namespacedMetrics) GetForObject(groupKind schema.GroupKind, name string
 		return nil, err
 	}
 
-	res := &v1beta2.MetricValueList{}
-	err = m.client.client.Get().
+	params, err := versionConverter.ConvertListOptionsToVersion(&cmint.MetricListOptions{
+		MetricLabelSelector: metricSelector.String(),
+	}, m.client.version)
+	if err != nil {
+		return nil, err
+	}
+
+	result := m.client.client.Get().
 		Resource(resourceName).
 		Namespace(m.namespace).
 		Name(name).
 		SubResource(metricName).
-		VersionedParams(&v1beta2.MetricListOptions{
-			MetricLabelSelector: metricSelector.String(),
-		}, scheme.ParameterCodec).
-		Do().
-		Into(res)
+		VersionedParams(params, scheme.ParameterCodec).
+		Do()
 
+	metricObj, err := versionConverter.ConvertResultToVersion(result, v1beta2.SchemeGroupVersion)
 	if err != nil {
 		return nil, err
 	}
 
+	res := metricObj.(*v1beta2.MetricValueList)
 	if len(res.Items) != 1 {
 		return nil, fmt.Errorf("the custom metrics API server returned %v results when we asked for exactly one", len(res.Items))
 	}
@@ -237,22 +245,27 @@ func (m *namespacedMetrics) GetForObjects(groupKind schema.GroupKind, selector l
 		return nil, err
 	}
 
-	res := &v1beta2.MetricValueList{}
-	err = m.client.client.Get().
+	params, err := versionConverter.ConvertListOptionsToVersion(&cmint.MetricListOptions{
+		LabelSelector:       selector.String(),
+		MetricLabelSelector: metricSelector.String(),
+	}, m.client.version)
+	if err != nil {
+		return nil, err
+	}
+
+	result := m.client.client.Get().
 		Resource(resourceName).
 		Namespace(m.namespace).
-		Name(v1beta2.AllObjects).
+		Name(v1beta1.AllObjects).
 		SubResource(metricName).
-		VersionedParams(&v1beta2.MetricListOptions{
-			LabelSelector:       selector.String(),
-			MetricLabelSelector: metricSelector.String(),
-		}, scheme.ParameterCodec).
-		Do().
-		Into(res)
+		VersionedParams(params, scheme.ParameterCodec).
+		Do()
 
+	metricObj, err := versionConverter.ConvertResultToVersion(result, v1beta2.SchemeGroupVersion)
 	if err != nil {
 		return nil, err
 	}
 
+	res := metricObj.(*v1beta2.MetricValueList)
 	return res, nil
 }

test/e2e/instrumentation/monitoring/BUILD

@@ -29,6 +29,7 @@ go_library(
         "//staging/src/k8s.io/apimachinery/pkg/selection:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/util/wait:go_default_library",
         "//staging/src/k8s.io/client-go/discovery:go_default_library",
+        "//staging/src/k8s.io/client-go/discovery/cached:go_default_library",
         "//staging/src/k8s.io/client-go/kubernetes:go_default_library",
         "//staging/src/k8s.io/metrics/pkg/client/custom_metrics:go_default_library",
         "//staging/src/k8s.io/metrics/pkg/client/external_metrics:go_default_library",

test/e2e/instrumentation/monitoring/custom_metrics_stackdriver.go

@@ -29,11 +29,13 @@ import (
 
 	gcm "google.golang.org/api/monitoring/v3"
 	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/selection"
 	"k8s.io/client-go/discovery"
 	"k8s.io/kubernetes/test/e2e/framework"
+	cmv1beta1 "k8s.io/metrics/pkg/apis/custom_metrics/v1beta1"
 	customclient "k8s.io/metrics/pkg/client/custom_metrics"
 	externalclient "k8s.io/metrics/pkg/client/external_metrics"
 )
@@ -57,8 +59,10 @@ var _ = instrumentation.SIGDescribe("Stackdriver Monitoring", func() {
 		if err != nil {
 			framework.Failf("Failed to load config: %s", err)
 		}
-		customMetricsClient := customclient.NewForConfigOrDie(config)
 		discoveryClient := discovery.NewDiscoveryClientForConfigOrDie(config)
+		apiVersionsGetter := customclient.NewAvailableAPIsGetter(discoveryClient)
+		restMapper := meta.NewDefaultRESTMapper([]schema.GroupVersion{cmv1beta1.SchemeGroupVersion})
+		customMetricsClient := customclient.NewForConfig(config, restMapper, apiVersionsGetter)
 		testCustomMetrics(f, kubeClient, customMetricsClient, discoveryClient, AdapterForOldResourceModel)
 	})
 
@@ -68,8 +72,10 @@ var _ = instrumentation.SIGDescribe("Stackdriver Monitoring", func() {
 		if err != nil {
 			framework.Failf("Failed to load config: %s", err)
 		}
-		customMetricsClient := customclient.NewForConfigOrDie(config)
 		discoveryClient := discovery.NewDiscoveryClientForConfigOrDie(config)
+		apiVersionsGetter := customclient.NewAvailableAPIsGetter(discoveryClient)
+		restMapper := meta.NewDefaultRESTMapper([]schema.GroupVersion{cmv1beta1.SchemeGroupVersion})
+		customMetricsClient := customclient.NewForConfig(config, restMapper, apiVersionsGetter)
 		testCustomMetrics(f, kubeClient, customMetricsClient, discoveryClient, AdapterForNewResourceModel)
 	})