Fix Godeps.json to point to kubernetes-1.11.0-beta.2 tags

Godeps/Godeps.json

@@ -156,7 +156,7 @@
 		},
 		{
 			"ImportPath": "github.com/json-iterator/go",
-			"Rev": "f2b4162afba35581b6d4a50d3b8f34e33c144682"
+			"Rev": "2ddf6d758266fcb080a4f9e054b9f292c85e6798"
 		},
 		{
 			"ImportPath": "github.com/modern-go/concurrent",
@@ -188,27 +188,27 @@
 		},
 		{
 			"ImportPath": "golang.org/x/net/context",
-			"Rev": "0ed95abb35c445290478a5348a7b38bb154135fd"
+			"Rev": "1c05540f6879653db88113bc4a2b70aec4bd491f"
 		},
 		{
 			"ImportPath": "golang.org/x/net/context/ctxhttp",
-			"Rev": "0ed95abb35c445290478a5348a7b38bb154135fd"
+			"Rev": "1c05540f6879653db88113bc4a2b70aec4bd491f"
 		},
 		{
 			"ImportPath": "golang.org/x/net/http2",
-			"Rev": "0ed95abb35c445290478a5348a7b38bb154135fd"
+			"Rev": "1c05540f6879653db88113bc4a2b70aec4bd491f"
 		},
 		{
 			"ImportPath": "golang.org/x/net/http2/hpack",
-			"Rev": "0ed95abb35c445290478a5348a7b38bb154135fd"
+			"Rev": "1c05540f6879653db88113bc4a2b70aec4bd491f"
 		},
 		{
 			"ImportPath": "golang.org/x/net/idna",
-			"Rev": "0ed95abb35c445290478a5348a7b38bb154135fd"
+			"Rev": "1c05540f6879653db88113bc4a2b70aec4bd491f"
 		},
 		{
 			"ImportPath": "golang.org/x/net/lex/httplex",
-			"Rev": "0ed95abb35c445290478a5348a7b38bb154135fd"
+			"Rev": "1c05540f6879653db88113bc4a2b70aec4bd491f"
 		},
 		{
 			"ImportPath": "golang.org/x/oauth2",
@@ -268,327 +268,327 @@
 		},
 		{
 			"ImportPath": "k8s.io/api/admissionregistration/v1alpha1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/admissionregistration/v1beta1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/apps/v1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/apps/v1beta1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/apps/v1beta2",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/authentication/v1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/authentication/v1beta1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/authorization/v1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/authorization/v1beta1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/autoscaling/v1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/autoscaling/v2beta1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/batch/v1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/batch/v1beta1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/batch/v2alpha1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/certificates/v1beta1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/core/v1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/events/v1beta1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/extensions/v1beta1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/imagepolicy/v1alpha1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/networking/v1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/policy/v1beta1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/rbac/v1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/rbac/v1alpha1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/rbac/v1beta1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/scheduling/v1alpha1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/scheduling/v1beta1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/settings/v1alpha1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/storage/v1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/storage/v1alpha1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/api/storage/v1beta1",
-			"Rev": "7f1f8e2603df931e711d6b1d2fac489440f151ef"
+			"Rev": "8c14244ab7eeffb1e4acd1ac1afb315b30fe67bf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/api/equality",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/api/errors",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/api/meta",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/api/resource",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/api/testing",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/api/testing/fuzzer",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/api/testing/roundtrip",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/fuzzer",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/internalversion",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1beta1",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/conversion",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/conversion/queryparams",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/fields",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/labels",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime/schema",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/json",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/protobuf",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/recognizer",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/streaming",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/versioning",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/selection",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/types",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/cache",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/clock",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/diff",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/errors",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/framer",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/httpstream",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/httpstream/spdy",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/intstr",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/json",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/mergepatch",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/net",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/remotecommand",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/runtime",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/sets",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/strategicpatch",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/validation",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/validation/field",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/wait",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/yaml",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/version",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/watch",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/third_party/forked/golang/json",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/third_party/forked/golang/netutil",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/third_party/forked/golang/reflect",
-			"Rev": "3d8ee2261517413977a62256b7d79644d7ffdc43"
+			"Rev": "1369ad3fdc6dcb2c933d7e570b349d71bd3052cf"
 		},
 		{
 			"ImportPath": "k8s.io/kube-openapi/pkg/util/proto",
-			"Rev": "91cfa479c814065e420cee7ed227db0f63a5854e"
+			"Rev": "8a9b82f00b3a86eac24681da3f9fe6c34c01cea2"
 		}
 	]
 }

dynamic/fake/simple.go

@@ -33,10 +33,6 @@ import (
 )
 
 func NewSimpleDynamicClient(scheme *runtime.Scheme, objects ...runtime.Object) *FakeDynamicClient {
-	// In order to use List with this client, you have to have the v1.List registered in your scheme. Neat thing though
-	// it does NOT have to be the *same* list
-	scheme.AddKnownTypeWithName(schema.GroupVersionKind{Group: "fake-dynamic-client-group", Version: "v1", Kind: "List"}, &unstructured.UnstructuredList{})
-
 	codecs := serializer.NewCodecFactory(scheme)
 	o := testing.NewObjectTracker(scheme, codecs.UniversalDecoder())
 	for _, obj := range objects {
@@ -276,11 +272,11 @@ func (c *dynamicResourceClient) List(opts metav1.ListOptions) (*unstructured.Uns
 	switch {
 	case len(c.namespace) == 0:
 		obj, err = c.client.Fake.
-			Invokes(testing.NewRootListAction(c.resource, schema.GroupVersionKind{Group: "fake-dynamic-client-group", Version: "v1", Kind: "" /*List is appended by the tracker automatically*/}, opts), &metav1.Status{Status: "dynamic list fail"})
+			Invokes(testing.NewRootListAction(c.resource, schema.GroupVersionKind{Version: "v1", Kind: "List"}, opts), &metav1.Status{Status: "dynamic list fail"})
 
 	case len(c.namespace) > 0:
 		obj, err = c.client.Fake.
-			Invokes(testing.NewListAction(c.resource, schema.GroupVersionKind{Group: "fake-dynamic-client-group", Version: "v1", Kind: "" /*List is appended by the tracker automatically*/}, c.namespace, opts), &metav1.Status{Status: "dynamic list fail"})
+			Invokes(testing.NewListAction(c.resource, schema.GroupVersionKind{Version: "v1", Kind: "List"}, c.namespace, opts), &metav1.Status{Status: "dynamic list fail"})
 
 	}
 
@@ -303,14 +299,13 @@ func (c *dynamicResourceClient) List(opts metav1.ListOptions) (*unstructured.Uns
 	}
 
 	list := &unstructured.UnstructuredList{}
-	for i := range entireList.Items {
-		item := &entireList.Items[i]
+	for _, item := range entireList.Items {
 		metadata, err := meta.Accessor(item)
 		if err != nil {
 			return nil, err
 		}
 		if label.Matches(labels.Set(metadata.GetLabels())) {
-			list.Items = append(list.Items, *item)
+			list.Items = append(list.Items, item)
 		}
 	}
 	return list, nil

dynamic/fake/simple_test.go

@@ -1,66 +0,0 @@
-/*
-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 fake
-
-import (
-	"testing"
-
-	"k8s.io/apimachinery/pkg/api/equality"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/util/diff"
-)
-
-func newUnstructured(apiVersion, kind, namespace, name string) *unstructured.Unstructured {
-	return &unstructured.Unstructured{
-		Object: map[string]interface{}{
-			"apiVersion": apiVersion,
-			"kind":       kind,
-			"metadata": map[string]interface{}{
-				"namespace": namespace,
-				"name":      name,
-			},
-		},
-	}
-}
-
-func TestList(t *testing.T) {
-	scheme := runtime.NewScheme()
-
-	client := NewSimpleDynamicClient(scheme,
-		newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"),
-		newUnstructured("group2/version", "TheKind", "ns-foo", "name2-foo"),
-		newUnstructured("group/version", "TheKind", "ns-foo", "name-bar"),
-		newUnstructured("group/version", "TheKind", "ns-foo", "name-baz"),
-		newUnstructured("group2/version", "TheKind", "ns-foo", "name2-baz"),
-	)
-	listFirst, err := client.Resource(schema.GroupVersionResource{Group: "group", Version: "version", Resource: "thekinds"}).List(metav1.ListOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	expected := []unstructured.Unstructured{
-		*newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"),
-		*newUnstructured("group/version", "TheKind", "ns-foo", "name-bar"),
-		*newUnstructured("group/version", "TheKind", "ns-foo", "name-baz"),
-	}
-	if !equality.Semantic.DeepEqual(listFirst.Items, expected) {
-		t.Fatal(diff.ObjectGoPrintDiff(expected, listFirst.Items))
-	}
-}

informers/autoscaling/v2beta1/interface.go

@@ -26,6 +26,8 @@ import (
 type Interface interface {
 	// HorizontalPodAutoscalers returns a HorizontalPodAutoscalerInformer.
 	HorizontalPodAutoscalers() HorizontalPodAutoscalerInformer
+	// VerticalPodAutoscalers returns a VerticalPodAutoscalerInformer.
+	VerticalPodAutoscalers() VerticalPodAutoscalerInformer
 }
 
 type version struct {
@@ -43,3 +45,8 @@ func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakList
 func (v *version) HorizontalPodAutoscalers() HorizontalPodAutoscalerInformer {
 	return &horizontalPodAutoscalerInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
 }
+
+// VerticalPodAutoscalers returns a VerticalPodAutoscalerInformer.
+func (v *version) VerticalPodAutoscalers() VerticalPodAutoscalerInformer {
+	return &verticalPodAutoscalerInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}

informers/autoscaling/v2beta1/verticalpodautoscaler.go

@@ -0,0 +1,89 @@
+/*
+Copyright 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.
+*/
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v2beta1
+
+import (
+	time "time"
+
+	autoscaling_v2beta1 "k8s.io/api/autoscaling/v2beta1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	watch "k8s.io/apimachinery/pkg/watch"
+	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
+	kubernetes "k8s.io/client-go/kubernetes"
+	v2beta1 "k8s.io/client-go/listers/autoscaling/v2beta1"
+	cache "k8s.io/client-go/tools/cache"
+)
+
+// VerticalPodAutoscalerInformer provides access to a shared informer and lister for
+// VerticalPodAutoscalers.
+type VerticalPodAutoscalerInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v2beta1.VerticalPodAutoscalerLister
+}
+
+type verticalPodAutoscalerInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewVerticalPodAutoscalerInformer constructs a new informer for VerticalPodAutoscaler type.
+// Always prefer using an informer factory to get a shared informer instead of getting an independent
+// one. This reduces memory footprint and number of connections to the server.
+func NewVerticalPodAutoscalerInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredVerticalPodAutoscalerInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredVerticalPodAutoscalerInformer constructs a new informer for VerticalPodAutoscaler type.
+// Always prefer using an informer factory to get a shared informer instead of getting an independent
+// one. This reduces memory footprint and number of connections to the server.
+func NewFilteredVerticalPodAutoscalerInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
+	return cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.AutoscalingV2beta1().VerticalPodAutoscalers(namespace).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.AutoscalingV2beta1().VerticalPodAutoscalers(namespace).Watch(options)
+			},
+		},
+		&autoscaling_v2beta1.VerticalPodAutoscaler{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *verticalPodAutoscalerInformer) defaultInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredVerticalPodAutoscalerInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *verticalPodAutoscalerInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&autoscaling_v2beta1.VerticalPodAutoscaler{}, f.defaultInformer)
+}
+
+func (f *verticalPodAutoscalerInformer) Lister() v2beta1.VerticalPodAutoscalerLister {
+	return v2beta1.NewVerticalPodAutoscalerLister(f.Informer().GetIndexer())
+}

informers/generic.go

@@ -125,6 +125,8 @@ func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource
 		// Group=autoscaling, Version=v2beta1
 	case v2beta1.SchemeGroupVersion.WithResource("horizontalpodautoscalers"):
 		return &genericInformer{resource: resource.GroupResource(), informer: f.Autoscaling().V2beta1().HorizontalPodAutoscalers().Informer()}, nil
+	case v2beta1.SchemeGroupVersion.WithResource("verticalpodautoscalers"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Autoscaling().V2beta1().VerticalPodAutoscalers().Informer()}, nil
 
 		// Group=batch, Version=v1
 	case batch_v1.SchemeGroupVersion.WithResource("jobs"):

kubernetes/typed/autoscaling/v2beta1/autoscaling_client.go

@@ -28,6 +28,7 @@ import (
 type AutoscalingV2beta1Interface interface {
 	RESTClient() rest.Interface
 	HorizontalPodAutoscalersGetter
+	VerticalPodAutoscalersGetter
 }
 
 // AutoscalingV2beta1Client is used to interact with features provided by the autoscaling group.
@@ -39,6 +40,10 @@ func (c *AutoscalingV2beta1Client) HorizontalPodAutoscalers(namespace string) Ho
 	return newHorizontalPodAutoscalers(c, namespace)
 }
 
+func (c *AutoscalingV2beta1Client) VerticalPodAutoscalers(namespace string) VerticalPodAutoscalerInterface {
+	return newVerticalPodAutoscalers(c, namespace)
+}
+
 // NewForConfig creates a new AutoscalingV2beta1Client for the given config.
 func NewForConfig(c *rest.Config) (*AutoscalingV2beta1Client, error) {
 	config := *c

kubernetes/typed/autoscaling/v2beta1/fake/fake_autoscaling_client.go

@@ -32,6 +32,10 @@ func (c *FakeAutoscalingV2beta1) HorizontalPodAutoscalers(namespace string) v2be
 	return &FakeHorizontalPodAutoscalers{c, namespace}
 }
 
+func (c *FakeAutoscalingV2beta1) VerticalPodAutoscalers(namespace string) v2beta1.VerticalPodAutoscalerInterface {
+	return &FakeVerticalPodAutoscalers{c, namespace}
+}
+
 // RESTClient returns a RESTClient that is used to communicate
 // with API server by this client implementation.
 func (c *FakeAutoscalingV2beta1) RESTClient() rest.Interface {

kubernetes/typed/autoscaling/v2beta1/fake/fake_verticalpodautoscaler.go

@@ -0,0 +1,140 @@
+/*
+Copyright 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.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	v2beta1 "k8s.io/api/autoscaling/v2beta1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeVerticalPodAutoscalers implements VerticalPodAutoscalerInterface
+type FakeVerticalPodAutoscalers struct {
+	Fake *FakeAutoscalingV2beta1
+	ns   string
+}
+
+var verticalpodautoscalersResource = schema.GroupVersionResource{Group: "autoscaling", Version: "v2beta1", Resource: "verticalpodautoscalers"}
+
+var verticalpodautoscalersKind = schema.GroupVersionKind{Group: "autoscaling", Version: "v2beta1", Kind: "VerticalPodAutoscaler"}
+
+// Get takes name of the verticalPodAutoscaler, and returns the corresponding verticalPodAutoscaler object, and an error if there is any.
+func (c *FakeVerticalPodAutoscalers) Get(name string, options v1.GetOptions) (result *v2beta1.VerticalPodAutoscaler, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(verticalpodautoscalersResource, c.ns, name), &v2beta1.VerticalPodAutoscaler{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v2beta1.VerticalPodAutoscaler), err
+}
+
+// List takes label and field selectors, and returns the list of VerticalPodAutoscalers that match those selectors.
+func (c *FakeVerticalPodAutoscalers) List(opts v1.ListOptions) (result *v2beta1.VerticalPodAutoscalerList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(verticalpodautoscalersResource, verticalpodautoscalersKind, c.ns, opts), &v2beta1.VerticalPodAutoscalerList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v2beta1.VerticalPodAutoscalerList{ListMeta: obj.(*v2beta1.VerticalPodAutoscalerList).ListMeta}
+	for _, item := range obj.(*v2beta1.VerticalPodAutoscalerList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested verticalPodAutoscalers.
+func (c *FakeVerticalPodAutoscalers) Watch(opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(verticalpodautoscalersResource, c.ns, opts))
+
+}
+
+// Create takes the representation of a verticalPodAutoscaler and creates it.  Returns the server's representation of the verticalPodAutoscaler, and an error, if there is any.
+func (c *FakeVerticalPodAutoscalers) Create(verticalPodAutoscaler *v2beta1.VerticalPodAutoscaler) (result *v2beta1.VerticalPodAutoscaler, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(verticalpodautoscalersResource, c.ns, verticalPodAutoscaler), &v2beta1.VerticalPodAutoscaler{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v2beta1.VerticalPodAutoscaler), err
+}
+
+// Update takes the representation of a verticalPodAutoscaler and updates it. Returns the server's representation of the verticalPodAutoscaler, and an error, if there is any.
+func (c *FakeVerticalPodAutoscalers) Update(verticalPodAutoscaler *v2beta1.VerticalPodAutoscaler) (result *v2beta1.VerticalPodAutoscaler, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(verticalpodautoscalersResource, c.ns, verticalPodAutoscaler), &v2beta1.VerticalPodAutoscaler{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v2beta1.VerticalPodAutoscaler), err
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *FakeVerticalPodAutoscalers) UpdateStatus(verticalPodAutoscaler *v2beta1.VerticalPodAutoscaler) (*v2beta1.VerticalPodAutoscaler, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(verticalpodautoscalersResource, "status", c.ns, verticalPodAutoscaler), &v2beta1.VerticalPodAutoscaler{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v2beta1.VerticalPodAutoscaler), err
+}
+
+// Delete takes name of the verticalPodAutoscaler and deletes it. Returns an error if one occurs.
+func (c *FakeVerticalPodAutoscalers) Delete(name string, options *v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(verticalpodautoscalersResource, c.ns, name), &v2beta1.VerticalPodAutoscaler{})
+
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeVerticalPodAutoscalers) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(verticalpodautoscalersResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v2beta1.VerticalPodAutoscalerList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched verticalPodAutoscaler.
+func (c *FakeVerticalPodAutoscalers) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v2beta1.VerticalPodAutoscaler, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(verticalpodautoscalersResource, c.ns, name, data, subresources...), &v2beta1.VerticalPodAutoscaler{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v2beta1.VerticalPodAutoscaler), err
+}

kubernetes/typed/autoscaling/v2beta1/generated_expansion.go

@@ -19,3 +19,5 @@ limitations under the License.
 package v2beta1
 
 type HorizontalPodAutoscalerExpansion interface{}
+
+type VerticalPodAutoscalerExpansion interface{}

kubernetes/typed/autoscaling/v2beta1/verticalpodautoscaler.go

@@ -0,0 +1,174 @@
+/*
+Copyright 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.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package v2beta1
+
+import (
+	v2beta1 "k8s.io/api/autoscaling/v2beta1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	scheme "k8s.io/client-go/kubernetes/scheme"
+	rest "k8s.io/client-go/rest"
+)
+
+// VerticalPodAutoscalersGetter has a method to return a VerticalPodAutoscalerInterface.
+// A group's client should implement this interface.
+type VerticalPodAutoscalersGetter interface {
+	VerticalPodAutoscalers(namespace string) VerticalPodAutoscalerInterface
+}
+
+// VerticalPodAutoscalerInterface has methods to work with VerticalPodAutoscaler resources.
+type VerticalPodAutoscalerInterface interface {
+	Create(*v2beta1.VerticalPodAutoscaler) (*v2beta1.VerticalPodAutoscaler, error)
+	Update(*v2beta1.VerticalPodAutoscaler) (*v2beta1.VerticalPodAutoscaler, error)
+	UpdateStatus(*v2beta1.VerticalPodAutoscaler) (*v2beta1.VerticalPodAutoscaler, error)
+	Delete(name string, options *v1.DeleteOptions) error
+	DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error
+	Get(name string, options v1.GetOptions) (*v2beta1.VerticalPodAutoscaler, error)
+	List(opts v1.ListOptions) (*v2beta1.VerticalPodAutoscalerList, error)
+	Watch(opts v1.ListOptions) (watch.Interface, error)
+	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v2beta1.VerticalPodAutoscaler, err error)
+	VerticalPodAutoscalerExpansion
+}
+
+// verticalPodAutoscalers implements VerticalPodAutoscalerInterface
+type verticalPodAutoscalers struct {
+	client rest.Interface
+	ns     string
+}
+
+// newVerticalPodAutoscalers returns a VerticalPodAutoscalers
+func newVerticalPodAutoscalers(c *AutoscalingV2beta1Client, namespace string) *verticalPodAutoscalers {
+	return &verticalPodAutoscalers{
+		client: c.RESTClient(),
+		ns:     namespace,
+	}
+}
+
+// Get takes name of the verticalPodAutoscaler, and returns the corresponding verticalPodAutoscaler object, and an error if there is any.
+func (c *verticalPodAutoscalers) Get(name string, options v1.GetOptions) (result *v2beta1.VerticalPodAutoscaler, err error) {
+	result = &v2beta1.VerticalPodAutoscaler{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("verticalpodautoscalers").
+		Name(name).
+		VersionedParams(&options, scheme.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of VerticalPodAutoscalers that match those selectors.
+func (c *verticalPodAutoscalers) List(opts v1.ListOptions) (result *v2beta1.VerticalPodAutoscalerList, err error) {
+	result = &v2beta1.VerticalPodAutoscalerList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("verticalpodautoscalers").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested verticalPodAutoscalers.
+func (c *verticalPodAutoscalers) Watch(opts v1.ListOptions) (watch.Interface, error) {
+	opts.Watch = true
+	return c.client.Get().
+		Namespace(c.ns).
+		Resource("verticalpodautoscalers").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Watch()
+}
+
+// Create takes the representation of a verticalPodAutoscaler and creates it.  Returns the server's representation of the verticalPodAutoscaler, and an error, if there is any.
+func (c *verticalPodAutoscalers) Create(verticalPodAutoscaler *v2beta1.VerticalPodAutoscaler) (result *v2beta1.VerticalPodAutoscaler, err error) {
+	result = &v2beta1.VerticalPodAutoscaler{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("verticalpodautoscalers").
+		Body(verticalPodAutoscaler).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a verticalPodAutoscaler and updates it. Returns the server's representation of the verticalPodAutoscaler, and an error, if there is any.
+func (c *verticalPodAutoscalers) Update(verticalPodAutoscaler *v2beta1.VerticalPodAutoscaler) (result *v2beta1.VerticalPodAutoscaler, err error) {
+	result = &v2beta1.VerticalPodAutoscaler{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("verticalpodautoscalers").
+		Name(verticalPodAutoscaler.Name).
+		Body(verticalPodAutoscaler).
+		Do().
+		Into(result)
+	return
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+
+func (c *verticalPodAutoscalers) UpdateStatus(verticalPodAutoscaler *v2beta1.VerticalPodAutoscaler) (result *v2beta1.VerticalPodAutoscaler, err error) {
+	result = &v2beta1.VerticalPodAutoscaler{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("verticalpodautoscalers").
+		Name(verticalPodAutoscaler.Name).
+		SubResource("status").
+		Body(verticalPodAutoscaler).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the verticalPodAutoscaler and deletes it. Returns an error if one occurs.
+func (c *verticalPodAutoscalers) Delete(name string, options *v1.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("verticalpodautoscalers").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *verticalPodAutoscalers) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("verticalpodautoscalers").
+		VersionedParams(&listOptions, scheme.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Patch applies the patch and returns the patched verticalPodAutoscaler.
+func (c *verticalPodAutoscalers) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v2beta1.VerticalPodAutoscaler, err error) {
+	result = &v2beta1.VerticalPodAutoscaler{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("verticalpodautoscalers").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

listers/autoscaling/v2beta1/expansion_generated.go

@@ -25,3 +25,11 @@ type HorizontalPodAutoscalerListerExpansion interface{}
 // HorizontalPodAutoscalerNamespaceListerExpansion allows custom methods to be added to
 // HorizontalPodAutoscalerNamespaceLister.
 type HorizontalPodAutoscalerNamespaceListerExpansion interface{}
+
+// VerticalPodAutoscalerListerExpansion allows custom methods to be added to
+// VerticalPodAutoscalerLister.
+type VerticalPodAutoscalerListerExpansion interface{}
+
+// VerticalPodAutoscalerNamespaceListerExpansion allows custom methods to be added to
+// VerticalPodAutoscalerNamespaceLister.
+type VerticalPodAutoscalerNamespaceListerExpansion interface{}

listers/autoscaling/v2beta1/verticalpodautoscaler.go

@@ -0,0 +1,94 @@
+/*
+Copyright 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.
+*/
+
+// Code generated by lister-gen. DO NOT EDIT.
+
+package v2beta1
+
+import (
+	v2beta1 "k8s.io/api/autoscaling/v2beta1"
+	"k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/client-go/tools/cache"
+)
+
+// VerticalPodAutoscalerLister helps list VerticalPodAutoscalers.
+type VerticalPodAutoscalerLister interface {
+	// List lists all VerticalPodAutoscalers in the indexer.
+	List(selector labels.Selector) (ret []*v2beta1.VerticalPodAutoscaler, err error)
+	// VerticalPodAutoscalers returns an object that can list and get VerticalPodAutoscalers.
+	VerticalPodAutoscalers(namespace string) VerticalPodAutoscalerNamespaceLister
+	VerticalPodAutoscalerListerExpansion
+}
+
+// verticalPodAutoscalerLister implements the VerticalPodAutoscalerLister interface.
+type verticalPodAutoscalerLister struct {
+	indexer cache.Indexer
+}
+
+// NewVerticalPodAutoscalerLister returns a new VerticalPodAutoscalerLister.
+func NewVerticalPodAutoscalerLister(indexer cache.Indexer) VerticalPodAutoscalerLister {
+	return &verticalPodAutoscalerLister{indexer: indexer}
+}
+
+// List lists all VerticalPodAutoscalers in the indexer.
+func (s *verticalPodAutoscalerLister) List(selector labels.Selector) (ret []*v2beta1.VerticalPodAutoscaler, err error) {
+	err = cache.ListAll(s.indexer, selector, func(m interface{}) {
+		ret = append(ret, m.(*v2beta1.VerticalPodAutoscaler))
+	})
+	return ret, err
+}
+
+// VerticalPodAutoscalers returns an object that can list and get VerticalPodAutoscalers.
+func (s *verticalPodAutoscalerLister) VerticalPodAutoscalers(namespace string) VerticalPodAutoscalerNamespaceLister {
+	return verticalPodAutoscalerNamespaceLister{indexer: s.indexer, namespace: namespace}
+}
+
+// VerticalPodAutoscalerNamespaceLister helps list and get VerticalPodAutoscalers.
+type VerticalPodAutoscalerNamespaceLister interface {
+	// List lists all VerticalPodAutoscalers in the indexer for a given namespace.
+	List(selector labels.Selector) (ret []*v2beta1.VerticalPodAutoscaler, err error)
+	// Get retrieves the VerticalPodAutoscaler from the indexer for a given namespace and name.
+	Get(name string) (*v2beta1.VerticalPodAutoscaler, error)
+	VerticalPodAutoscalerNamespaceListerExpansion
+}
+
+// verticalPodAutoscalerNamespaceLister implements the VerticalPodAutoscalerNamespaceLister
+// interface.
+type verticalPodAutoscalerNamespaceLister struct {
+	indexer   cache.Indexer
+	namespace string
+}
+
+// List lists all VerticalPodAutoscalers in the indexer for a given namespace.
+func (s verticalPodAutoscalerNamespaceLister) List(selector labels.Selector) (ret []*v2beta1.VerticalPodAutoscaler, err error) {
+	err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) {
+		ret = append(ret, m.(*v2beta1.VerticalPodAutoscaler))
+	})
+	return ret, err
+}
+
+// Get retrieves the VerticalPodAutoscaler from the indexer for a given namespace and name.
+func (s verticalPodAutoscalerNamespaceLister) Get(name string) (*v2beta1.VerticalPodAutoscaler, error) {
+	obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name)
+	if err != nil {
+		return nil, err
+	}
+	if !exists {
+		return nil, errors.NewNotFound(v2beta1.Resource("verticalpodautoscaler"), name)
+	}
+	return obj.(*v2beta1.VerticalPodAutoscaler), nil
+}

plugin/pkg/client/auth/exec/exec.go

@@ -20,7 +20,6 @@ import (
 	"bytes"
 	"context"
 	"crypto/tls"
-	"errors"
 	"fmt"
 	"io"
 	"net"
@@ -179,10 +178,21 @@ func (a *Authenticator) UpdateTransportConfig(c *transport.Config) error {
 		return &roundTripper{a, rt}
 	}
 
-	if c.TLS.GetCert != nil {
-		return errors.New("can't add TLS certificate callback: transport.Config.TLS.GetCert already set")
+	getCert := c.TLS.GetCert
+	c.TLS.GetCert = func() (*tls.Certificate, error) {
+		// If previous GetCert is present and returns a valid non-nil
+		// certificate, use that. Otherwise use cert from exec plugin.
+		if getCert != nil {
+			cert, err := getCert()
+			if err != nil {
+				return nil, err
+			}
+			if cert != nil {
+				return cert, nil
+			}
+		}
+		return a.cert()
 	}
-	c.TLS.GetCert = a.cert
 
 	var dial func(ctx context.Context, network, addr string) (net.Conn, error)
 	if c.Dial != nil {

rest/request.go

@@ -455,9 +455,17 @@ func (r *Request) URL() *url.URL {
 
 // finalURLTemplate is similar to URL(), but will make all specific parameter values equal
 // - instead of name or namespace, "{name}" and "{namespace}" will be used, and all query
-// parameters will be reset. This creates a copy of the url so as not to change the
-// underlying object.
+// parameters will be reset. This creates a copy of the request so as not to change the
+// underlying object.  This means some useful request info (like the types of field
+// selectors in use) will be lost.
+// TODO: preserve field selector keys
 func (r Request) finalURLTemplate() url.URL {
+	if len(r.resourceName) != 0 {
+		r.resourceName = "{name}"
+	}
+	if r.namespaceSet && len(r.namespace) != 0 {
+		r.namespace = "{namespace}"
+	}
 	newParams := url.Values{}
 	v := []string{"{value}"}
 	for k := range r.params {
@@ -465,59 +473,6 @@ func (r Request) finalURLTemplate() url.URL {
 	}
 	r.params = newParams
 	url := r.URL()
-	segments := strings.Split(r.URL().Path, "/")
-	groupIndex := 0
-	index := 0
-	if r.URL() != nil && r.baseURL != nil && strings.Contains(r.URL().Path, r.baseURL.Path) {
-		groupIndex += len(strings.Split(r.baseURL.Path, "/"))
-	}
-	if groupIndex >= len(segments) {
-		return *url
-	}
-
-	const CoreGroupPrefix = "api"
-	const NamedGroupPrefix = "apis"
-	isCoreGroup := segments[groupIndex] == CoreGroupPrefix
-	isNamedGroup := segments[groupIndex] == NamedGroupPrefix
-	if isCoreGroup {
-		// checking the case of core group with /api/v1/... format
-		index = groupIndex + 2
-	} else if isNamedGroup {
-		// checking the case of named group with /apis/apps/v1/... format
-		index = groupIndex + 3
-	} else {
-		// this should not happen that the only two possibilities are /api... and /apis..., just want to put an
-		// outlet here in case more API groups are added in future if ever possible:
-		// https://kubernetes.io/docs/concepts/overview/kubernetes-api/#api-groups
-		// if a wrong API groups name is encountered, return the {prefix} for url.Path
-		url.Path = "/{prefix}"
-		url.RawQuery = ""
-		return *url
-	}
-	//switch segLength := len(segments) - index; segLength {
-	switch {
-	// case len(segments) - index == 1:
-	// resource (with no name) do nothing
-	case len(segments)-index == 2:
-		// /$RESOURCE/$NAME: replace $NAME with {name}
-		segments[index+1] = "{name}"
-	case len(segments)-index == 3:
-		if segments[index+2] == "finalize" || segments[index+2] == "status" {
-			// /$RESOURCE/$NAME/$SUBRESOURCE: replace $NAME with {name}
-			segments[index+1] = "{name}"
-		} else {
-			// /namespace/$NAMESPACE/$RESOURCE: replace $NAMESPACE with {namespace}
-			segments[index+1] = "{namespace}"
-		}
-	case len(segments)-index >= 4:
-		segments[index+1] = "{namespace}"
-		// /namespace/$NAMESPACE/$RESOURCE/$NAME: replace $NAMESPACE with {namespace},  $NAME with {name}
-		if segments[index+3] != "finalize" && segments[index+3] != "status" {
-			// /$RESOURCE/$NAME/$SUBRESOURCE: replace $NAME with {name}
-			segments[index+3] = "{name}"
-		}
-	}
-	url.Path = path.Join(segments...)
 	return *url
 }
 

rest/request_test.go

@@ -340,169 +340,21 @@ func TestResultIntoWithNoBodyReturnsErr(t *testing.T) {
 }
 
 func TestURLTemplate(t *testing.T) {
-	uri, _ := url.Parse("http://localhost/some/base/url/path")
-	testCases := []struct {
-		Request          *Request
-		ExpectedFullURL  string
-		ExpectedFinalURL string
-	}{
-		{
-			// non dynamic client
-			Request: NewRequest(nil, "POST", uri, "", ContentConfig{GroupVersion: &schema.GroupVersion{Group: "test"}}, Serializers{}, nil, nil, 0).
-				Prefix("api", "v1").Resource("r1").Namespace("ns").Name("nm").Param("p0", "v0"),
-			ExpectedFullURL:  "http://localhost/some/base/url/path/api/v1/namespaces/ns/r1/nm?p0=v0",
-			ExpectedFinalURL: "http://localhost/some/base/url/path/api/v1/namespaces/%7Bnamespace%7D/r1/%7Bname%7D?p0=%7Bvalue%7D",
-		},
-		{
-			// non dynamic client with wrong api group
-			Request: NewRequest(nil, "POST", uri, "", ContentConfig{GroupVersion: &schema.GroupVersion{Group: "test"}}, Serializers{}, nil, nil, 0).
-				Prefix("pre1", "v1").Resource("r1").Namespace("ns").Name("nm").Param("p0", "v0"),
-			ExpectedFullURL:  "http://localhost/some/base/url/path/pre1/v1/namespaces/ns/r1/nm?p0=v0",
-			ExpectedFinalURL: "http://localhost/%7Bprefix%7D",
-		},
-		{
-			// dynamic client with core group + namespace + resourceResource (with name)
-			// /api/$RESOURCEVERSION/namespaces/$NAMESPACE/$RESOURCE/%NAME
-			Request: NewRequest(nil, "DELETE", uri, "", ContentConfig{GroupVersion: &schema.GroupVersion{Group: "test"}}, Serializers{}, nil, nil, 0).
-				Prefix("/api/v1/namespaces/ns/r1/name1"),
-			ExpectedFullURL:  "http://localhost/some/base/url/path/api/v1/namespaces/ns/r1/name1",
-			ExpectedFinalURL: "http://localhost/some/base/url/path/api/v1/namespaces/%7Bnamespace%7D/r1/%7Bname%7D",
-		},
-		{
-			// dynamic client with named group + namespace + resourceResource (with name)
-			// /apis/$NAMEDGROUPNAME/$RESOURCEVERSION/namespaces/$NAMESPACE/$RESOURCE/%NAME
-			Request: NewRequest(nil, "DELETE", uri, "", ContentConfig{GroupVersion: &schema.GroupVersion{Group: "test"}}, Serializers{}, nil, nil, 0).
-				Prefix("/apis/g1/v1/namespaces/ns/r1/name1"),
-			ExpectedFullURL:  "http://localhost/some/base/url/path/apis/g1/v1/namespaces/ns/r1/name1",
-			ExpectedFinalURL: "http://localhost/some/base/url/path/apis/g1/v1/namespaces/%7Bnamespace%7D/r1/%7Bname%7D",
-		},
-		{
-			// dynamic client with core group + namespace + resourceResource (with NO name)
-			// /api/$RESOURCEVERSION/namespaces/$NAMESPACE/$RESOURCE
-			Request: NewRequest(nil, "DELETE", uri, "", ContentConfig{GroupVersion: &schema.GroupVersion{Group: "test"}}, Serializers{}, nil, nil, 0).
-				Prefix("/api/v1/namespaces/ns/r1"),
-			ExpectedFullURL:  "http://localhost/some/base/url/path/api/v1/namespaces/ns/r1",
-			ExpectedFinalURL: "http://localhost/some/base/url/path/api/v1/namespaces/%7Bnamespace%7D/r1",
-		},
-		{
-			// dynamic client with named group + namespace + resourceResource (with NO name)
-			// /apis/$NAMEDGROUPNAME/$RESOURCEVERSION/namespaces/$NAMESPACE/$RESOURCE
-			Request: NewRequest(nil, "DELETE", uri, "", ContentConfig{GroupVersion: &schema.GroupVersion{Group: "test"}}, Serializers{}, nil, nil, 0).
-				Prefix("/apis/g1/v1/namespaces/ns/r1"),
-			ExpectedFullURL:  "http://localhost/some/base/url/path/apis/g1/v1/namespaces/ns/r1",
-			ExpectedFinalURL: "http://localhost/some/base/url/path/apis/g1/v1/namespaces/%7Bnamespace%7D/r1",
-		},
-		{
-			// dynamic client with core group + resourceResource (with name)
-			// /api/$RESOURCEVERSION/$RESOURCE/%NAME
-			Request: NewRequest(nil, "DELETE", uri, "", ContentConfig{GroupVersion: &schema.GroupVersion{Group: "test"}}, Serializers{}, nil, nil, 0).
-				Prefix("/api/v1/r1/name1"),
-			ExpectedFullURL:  "http://localhost/some/base/url/path/api/v1/r1/name1",
-			ExpectedFinalURL: "http://localhost/some/base/url/path/api/v1/r1/%7Bname%7D",
-		},
-		{
-			// dynamic client with named group + resourceResource (with name)
-			// /apis/$NAMEDGROUPNAME/$RESOURCEVERSION/$RESOURCE/%NAME
-			Request: NewRequest(nil, "DELETE", uri, "", ContentConfig{GroupVersion: &schema.GroupVersion{Group: "test"}}, Serializers{}, nil, nil, 0).
-				Prefix("/apis/g1/v1/r1/name1"),
-			ExpectedFullURL:  "http://localhost/some/base/url/path/apis/g1/v1/r1/name1",
-			ExpectedFinalURL: "http://localhost/some/base/url/path/apis/g1/v1/r1/%7Bname%7D",
-		},
-		{
-			// dynamic client with named group + namespace + resourceResource (with name) + subresource
-			// /apis/$NAMEDGROUPNAME/$RESOURCEVERSION/namespaces/$NAMESPACE/$RESOURCE/%NAME/$SUBRESOURCE
-			Request: NewRequest(nil, "DELETE", uri, "", ContentConfig{GroupVersion: &schema.GroupVersion{Group: "test"}}, Serializers{}, nil, nil, 0).
-				Prefix("/apis/namespaces/namespaces/namespaces/namespaces/namespaces/namespaces/finalize"),
-			ExpectedFullURL:  "http://localhost/some/base/url/path/apis/namespaces/namespaces/namespaces/namespaces/namespaces/namespaces/finalize",
-			ExpectedFinalURL: "http://localhost/some/base/url/path/apis/namespaces/namespaces/namespaces/%7Bnamespace%7D/namespaces/%7Bname%7D/finalize",
-		},
-		{
-			// dynamic client with named group + namespace + resourceResource (with name)
-			// /apis/$NAMEDGROUPNAME/$RESOURCEVERSION/namespaces/$NAMESPACE/$RESOURCE/%NAME
-			Request: NewRequest(nil, "DELETE", uri, "", ContentConfig{GroupVersion: &schema.GroupVersion{Group: "test"}}, Serializers{}, nil, nil, 0).
-				Prefix("/apis/namespaces/namespaces/namespaces/namespaces/namespaces/namespaces"),
-			ExpectedFullURL:  "http://localhost/some/base/url/path/apis/namespaces/namespaces/namespaces/namespaces/namespaces/namespaces",
-			ExpectedFinalURL: "http://localhost/some/base/url/path/apis/namespaces/namespaces/namespaces/%7Bnamespace%7D/namespaces/%7Bname%7D",
-		},
-		{
-			// dynamic client with named group + namespace + resourceResource (with NO name) + subresource
-			// /apis/$NAMEDGROUPNAME/$RESOURCEVERSION/namespaces/$NAMESPACE/$RESOURCE/%SUBRESOURCE
-			Request: NewRequest(nil, "DELETE", uri, "", ContentConfig{GroupVersion: &schema.GroupVersion{Group: "test"}}, Serializers{}, nil, nil, 0).
-				Prefix("/apis/namespaces/namespaces/namespaces/namespaces/namespaces/finalize"),
-			ExpectedFullURL:  "http://localhost/some/base/url/path/apis/namespaces/namespaces/namespaces/namespaces/namespaces/finalize",
-			ExpectedFinalURL: "http://localhost/some/base/url/path/apis/namespaces/namespaces/namespaces/%7Bnamespace%7D/namespaces/finalize",
-		},
-		{
-			// dynamic client with named group + namespace + resourceResource (with NO name) + subresource
-			// /apis/$NAMEDGROUPNAME/$RESOURCEVERSION/namespaces/$NAMESPACE/$RESOURCE/%SUBRESOURCE
-			Request: NewRequest(nil, "DELETE", uri, "", ContentConfig{GroupVersion: &schema.GroupVersion{Group: "test"}}, Serializers{}, nil, nil, 0).
-				Prefix("/apis/namespaces/namespaces/namespaces/namespaces/namespaces/status"),
-			ExpectedFullURL:  "http://localhost/some/base/url/path/apis/namespaces/namespaces/namespaces/namespaces/namespaces/status",
-			ExpectedFinalURL: "http://localhost/some/base/url/path/apis/namespaces/namespaces/namespaces/%7Bnamespace%7D/namespaces/status",
-		},
-		{
-			// dynamic client with named group + namespace + resourceResource (with no name)
-			// /apis/$NAMEDGROUPNAME/$RESOURCEVERSION/namespaces/$NAMESPACE/$RESOURCE/%NAME
-			Request: NewRequest(nil, "DELETE", uri, "", ContentConfig{GroupVersion: &schema.GroupVersion{Group: "test"}}, Serializers{}, nil, nil, 0).
-				Prefix("/apis/namespaces/namespaces/namespaces/namespaces/namespaces"),
-			ExpectedFullURL:  "http://localhost/some/base/url/path/apis/namespaces/namespaces/namespaces/namespaces/namespaces",
-			ExpectedFinalURL: "http://localhost/some/base/url/path/apis/namespaces/namespaces/namespaces/%7Bnamespace%7D/namespaces",
-		},
-		{
-			// dynamic client with named group + resourceResource (with name) + subresource
-			// /apis/$NAMEDGROUPNAME/$RESOURCEVERSION/namespaces/$NAMESPACE/$RESOURCE/%NAME
-			Request: NewRequest(nil, "DELETE", uri, "", ContentConfig{GroupVersion: &schema.GroupVersion{Group: "test"}}, Serializers{}, nil, nil, 0).
-				Prefix("/apis/namespaces/namespaces/namespaces/namespaces/finalize"),
-			ExpectedFullURL:  "http://localhost/some/base/url/path/apis/namespaces/namespaces/namespaces/namespaces/finalize",
-			ExpectedFinalURL: "http://localhost/some/base/url/path/apis/namespaces/namespaces/namespaces/%7Bname%7D/finalize",
-		},
-		{
-			// dynamic client with named group + resourceResource (with name) + subresource
-			// /apis/$NAMEDGROUPNAME/$RESOURCEVERSION/namespaces/$NAMESPACE/$RESOURCE/%NAME
-			Request: NewRequest(nil, "DELETE", uri, "", ContentConfig{GroupVersion: &schema.GroupVersion{Group: "test"}}, Serializers{}, nil, nil, 0).
-				Prefix("/apis/namespaces/namespaces/namespaces/namespaces/status"),
-			ExpectedFullURL:  "http://localhost/some/base/url/path/apis/namespaces/namespaces/namespaces/namespaces/status",
-			ExpectedFinalURL: "http://localhost/some/base/url/path/apis/namespaces/namespaces/namespaces/%7Bname%7D/status",
-		},
-		{
-			// dynamic client with named group + resourceResource (with name)
-			// /apis/$NAMEDGROUPNAME/$RESOURCEVERSION/$RESOURCE/%NAME
-			Request: NewRequest(nil, "DELETE", uri, "", ContentConfig{GroupVersion: &schema.GroupVersion{Group: "test"}}, Serializers{}, nil, nil, 0).
-				Prefix("/apis/namespaces/namespaces/namespaces/namespaces"),
-			ExpectedFullURL:  "http://localhost/some/base/url/path/apis/namespaces/namespaces/namespaces/namespaces",
-			ExpectedFinalURL: "http://localhost/some/base/url/path/apis/namespaces/namespaces/namespaces/%7Bname%7D",
-		},
-		{
-			// dynamic client with named group + resourceResource (with no name)
-			// /apis/$NAMEDGROUPNAME/$RESOURCEVERSION/$RESOURCE/%NAME
-			Request: NewRequest(nil, "DELETE", uri, "", ContentConfig{GroupVersion: &schema.GroupVersion{Group: "test"}}, Serializers{}, nil, nil, 0).
-				Prefix("/apis/namespaces/namespaces/namespaces"),
-			ExpectedFullURL:  "http://localhost/some/base/url/path/apis/namespaces/namespaces/namespaces",
-			ExpectedFinalURL: "http://localhost/some/base/url/path/apis/namespaces/namespaces/namespaces",
-		},
-		{
-			// dynamic client with wrong api group + namespace + resourceResource (with name) + subresource
-			// /apis/$NAMEDGROUPNAME/$RESOURCEVERSION/namespaces/$NAMESPACE/$RESOURCE/%NAME/$SUBRESOURCE
-			Request: NewRequest(nil, "DELETE", uri, "", ContentConfig{GroupVersion: &schema.GroupVersion{Group: "test"}}, Serializers{}, nil, nil, 0).
-				Prefix("/pre1/namespaces/namespaces/namespaces/namespaces/namespaces/namespaces/finalize"),
-			ExpectedFullURL:  "http://localhost/some/base/url/path/pre1/namespaces/namespaces/namespaces/namespaces/namespaces/namespaces/finalize",
-			ExpectedFinalURL: "http://localhost/%7Bprefix%7D",
-		},
+	uri, _ := url.Parse("http://localhost")
+	r := NewRequest(nil, "POST", uri, "", ContentConfig{GroupVersion: &schema.GroupVersion{Group: "test"}}, Serializers{}, nil, nil, 0)
+	r.Prefix("pre1").Resource("r1").Namespace("ns").Name("nm").Param("p0", "v0")
+	full := r.URL()
+	if full.String() != "http://localhost/pre1/namespaces/ns/r1/nm?p0=v0" {
+		t.Errorf("unexpected initial URL: %s", full)
 	}
-	for i, testCase := range testCases {
-		r := testCase.Request
-		full := r.URL()
-		if full.String() != testCase.ExpectedFullURL {
-			t.Errorf("%d: unexpected initial URL: %s %s", i, full, testCase.ExpectedFullURL)
-		}
-		actualURL := r.finalURLTemplate()
-		actual := actualURL.String()
-		if actual != testCase.ExpectedFinalURL {
-			t.Errorf("%d: unexpected URL template: %s %s", i, actual, testCase.ExpectedFinalURL)
-		}
-		if r.URL().String() != full.String() {
-			t.Errorf("%d, creating URL template changed request: %s -> %s", i, full.String(), r.URL().String())
-		}
+	actualURL := r.finalURLTemplate()
+	actual := actualURL.String()
+	expected := "http://localhost/pre1/namespaces/%7Bnamespace%7D/r1/%7Bname%7D?p0=%7Bvalue%7D"
+	if actual != expected {
+		t.Errorf("unexpected URL template: %s %s", actual, expected)
+	}
+	if r.URL().String() != full.String() {
+		t.Errorf("creating URL template changed request: %s -> %s", full.String(), r.URL().String())
 	}
 }
 

restmapper/discovery.go

@@ -99,20 +99,18 @@ func NewDiscoveryRESTMapper(groupResources []*APIGroupResources) meta.RESTMapper
 					scope = meta.RESTScopeRoot
 				}
 
-				// if we have a slash, then this is a subresource and we shouldn't create mappings for those.
-				if strings.Contains(resource.Name, "/") {
+				// this is for legacy resources and servers which don't list singular forms.  For those we must still guess.
+				if len(resource.SingularName) == 0 {
+					versionMapper.Add(gv.WithKind(resource.Kind), scope)
+					// TODO this is producing unsafe guesses that don't actually work, but it matches previous behavior
+					versionMapper.Add(gv.WithKind(resource.Kind+"List"), scope)
 					continue
 				}
 
 				plural := gv.WithResource(resource.Name)
 				singular := gv.WithResource(resource.SingularName)
-				// this is for legacy resources and servers which don't list singular forms.  For those we must still guess.
-				if len(resource.SingularName) == 0 {
-					_, singular = meta.UnsafeGuessKindToResource(gv.WithKind(resource.Kind))
-				}
-
-				versionMapper.AddSpecific(gv.WithKind(strings.ToLower(resource.Kind)), plural, singular, scope)
 				versionMapper.AddSpecific(gv.WithKind(resource.Kind), plural, singular, scope)
+				versionMapper.AddSpecific(gv.WithKind(strings.ToLower(resource.Kind)), plural, singular, scope)
 				// TODO this is producing unsafe guesses that don't actually work, but it matches previous behavior
 				versionMapper.Add(gv.WithKind(resource.Kind+"List"), scope)
 			}

tools/leaderelection/healthzadaptor.go

@@ -1,69 +0,0 @@
-/*
-Copyright 2015 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 leaderelection
-
-import (
-	"net/http"
-	"sync"
-	"time"
-)
-
-// HealthzAdaptor associates the /healthz endpoint with the LeaderElection object.
-// It helps deal with the /healthz endpoint being set up prior to the LeaderElection.
-// This contains the code needed to act as an adaptor between the leader
-// election code the health check code. It allows us to provide health
-// status about the leader election. Most specifically about if the leader
-// has failed to renew without exiting the process. In that case we should
-// report not healthy and rely on the kubelet to take down the process.
-type HealthzAdaptor struct {
-	pointerLock sync.Mutex
-	le          *LeaderElector
-	timeout     time.Duration
-}
-
-// Name returns the name of the health check we are implementing.
-func (l *HealthzAdaptor) Name() string {
-	return "leaderElection"
-}
-
-// Check is called by the healthz endpoint handler.
-// It fails (returns an error) if we own the lease but had not been able to renew it.
-func (l *HealthzAdaptor) Check(req *http.Request) error {
-	l.pointerLock.Lock()
-	defer l.pointerLock.Unlock()
-	if l.le == nil {
-		return nil
-	}
-	return l.le.Check(l.timeout)
-}
-
-// SetLeaderElection ties a leader election object to a HealthzAdaptor
-func (l *HealthzAdaptor) SetLeaderElection(le *LeaderElector) {
-	l.pointerLock.Lock()
-	defer l.pointerLock.Unlock()
-	l.le = le
-}
-
-// NewLeaderHealthzAdaptor creates a basic healthz adaptor to monitor a leader election.
-// timeout determines the time beyond the lease expiry to be allowed for timeout.
-// checks within the timeout period after the lease expires will still return healthy.
-func NewLeaderHealthzAdaptor(timeout time.Duration) *HealthzAdaptor {
-	result := &HealthzAdaptor{
-		timeout: timeout,
-	}
-	return result
-}

tools/leaderelection/healthzadaptor_test.go

@@ -1,175 +0,0 @@
-/*
-Copyright 2015 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 leaderelection
-
-import (
-	"fmt"
-	"testing"
-	"time"
-
-	"k8s.io/apimachinery/pkg/util/clock"
-	rl "k8s.io/client-go/tools/leaderelection/resourcelock"
-	"net/http"
-)
-
-type fakeLock struct {
-	identity string
-}
-
-// Get is a dummy to allow us to have a fakeLock for testing.
-func (fl *fakeLock) Get() (ler *rl.LeaderElectionRecord, err error) {
-	return nil, nil
-}
-
-// Create is a dummy to allow us to have a fakeLock for testing.
-func (fl *fakeLock) Create(ler rl.LeaderElectionRecord) error {
-	return nil
-}
-
-// Update is a dummy to allow us to have a fakeLock for testing.
-func (fl *fakeLock) Update(ler rl.LeaderElectionRecord) error {
-	return nil
-}
-
-// RecordEvent is a dummy to allow us to have a fakeLock for testing.
-func (fl *fakeLock) RecordEvent(string) {}
-
-// Identity is a dummy to allow us to have a fakeLock for testing.
-func (fl *fakeLock) Identity() string {
-	return fl.identity
-}
-
-// Describe is a dummy to allow us to have a fakeLock for testing.
-func (fl *fakeLock) Describe() string {
-	return "Dummy implementation of lock for testing"
-}
-
-// TestLeaderElectionHealthChecker tests that the healthcheck for leader election handles its edge cases.
-func TestLeaderElectionHealthChecker(t *testing.T) {
-	current := time.Now()
-	req := &http.Request{}
-
-	tests := []struct {
-		description    string
-		expected       error
-		adaptorTimeout time.Duration
-		elector        *LeaderElector
-	}{
-		{
-			description:    "call check before leader elector initialized",
-			expected:       nil,
-			adaptorTimeout: time.Second * 20,
-			elector:        nil,
-		},
-		{
-			description:    "call check when the the lease is far expired",
-			expected:       fmt.Errorf("failed election to renew leadership on lease %s", "foo"),
-			adaptorTimeout: time.Second * 20,
-			elector: &LeaderElector{
-				config: LeaderElectionConfig{
-					Lock:          &fakeLock{identity: "healthTest"},
-					LeaseDuration: time.Minute,
-					Name:          "foo",
-				},
-				observedRecord: rl.LeaderElectionRecord{
-					HolderIdentity: "healthTest",
-				},
-				observedTime: current,
-				clock:        clock.NewFakeClock(current.Add(time.Hour)),
-			},
-		},
-		{
-			description:    "call check when the the lease is far expired but held by another server",
-			expected:       nil,
-			adaptorTimeout: time.Second * 20,
-			elector: &LeaderElector{
-				config: LeaderElectionConfig{
-					Lock:          &fakeLock{identity: "healthTest"},
-					LeaseDuration: time.Minute,
-					Name:          "foo",
-				},
-				observedRecord: rl.LeaderElectionRecord{
-					HolderIdentity: "otherServer",
-				},
-				observedTime: current,
-				clock:        clock.NewFakeClock(current.Add(time.Hour)),
-			},
-		},
-		{
-			description:    "call check when the the lease is not expired",
-			expected:       nil,
-			adaptorTimeout: time.Second * 20,
-			elector: &LeaderElector{
-				config: LeaderElectionConfig{
-					Lock:          &fakeLock{identity: "healthTest"},
-					LeaseDuration: time.Minute,
-					Name:          "foo",
-				},
-				observedRecord: rl.LeaderElectionRecord{
-					HolderIdentity: "healthTest",
-				},
-				observedTime: current,
-				clock:        clock.NewFakeClock(current),
-			},
-		},
-		{
-			description:    "call check when the the lease is expired but inside the timeout",
-			expected:       nil,
-			adaptorTimeout: time.Second * 20,
-			elector: &LeaderElector{
-				config: LeaderElectionConfig{
-					Lock:          &fakeLock{identity: "healthTest"},
-					LeaseDuration: time.Minute,
-					Name:          "foo",
-				},
-				observedRecord: rl.LeaderElectionRecord{
-					HolderIdentity: "healthTest",
-				},
-				observedTime: current,
-				clock:        clock.NewFakeClock(current.Add(time.Minute).Add(time.Second)),
-			},
-		},
-	}
-
-	for _, test := range tests {
-		adaptor := NewLeaderHealthzAdaptor(test.adaptorTimeout)
-		if adaptor.le != nil {
-			t.Errorf("[%s] leaderChecker started with a LeaderElector %v", test.description, adaptor.le)
-		}
-		if test.elector != nil {
-			test.elector.config.WatchDog = adaptor
-			adaptor.SetLeaderElection(test.elector)
-			if adaptor.le == nil {
-				t.Errorf("[%s] adaptor failed to set the LeaderElector", test.description)
-			}
-		}
-		err := adaptor.Check(req)
-		if test.expected == nil {
-			if err == nil {
-				continue
-			}
-			t.Errorf("[%s] called check, expected no error but received \"%v\"", test.description, err)
-		} else {
-			if err == nil {
-				t.Errorf("[%s] called check and failed to received the expected error \"%v\"", test.description, test.expected)
-			}
-			if err.Error() != test.expected.Error() {
-				t.Errorf("[%s] called check, expected %v, received %v", test.description, test.expected, err)
-			}
-		}
-	}
-}

tools/leaderelection/leaderelection.go

@@ -55,7 +55,6 @@ import (
 
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/util/clock"
 	"k8s.io/apimachinery/pkg/util/runtime"
 	"k8s.io/apimachinery/pkg/util/wait"
 	rl "k8s.io/client-go/tools/leaderelection/resourcelock"
@@ -90,7 +89,6 @@ func NewLeaderElector(lec LeaderElectionConfig) (*LeaderElector, error) {
 	}
 	return &LeaderElector{
 		config: lec,
-		clock:  clock.RealClock{},
 	}, nil
 }
 
@@ -112,13 +110,6 @@ type LeaderElectionConfig struct {
 	// Callbacks are callbacks that are triggered during certain lifecycle
 	// events of the LeaderElector
 	Callbacks LeaderCallbacks
-
-	// WatchDog is the associated health checker
-	// WatchDog may be null if its not needed/configured.
-	WatchDog *HealthzAdaptor
-
-	// Name is the name of the resource lock for debugging
-	Name string
 }
 
 // LeaderCallbacks are callbacks that are triggered during certain
@@ -151,12 +142,6 @@ type LeaderElector struct {
 	// value observedRecord.HolderIdentity if the transition has
 	// not yet been reported.
 	reportedLeader string
-
-	// clock is wrapper around time to allow for less flaky testing
-	clock clock.Clock
-
-	// name is the name of the resource lock for debugging
-	name string
 }
 
 // Run starts the leader election loop
@@ -179,9 +164,6 @@ func RunOrDie(lec LeaderElectionConfig) {
 	if err != nil {
 		panic(err)
 	}
-	if lec.WatchDog != nil {
-		lec.WatchDog.SetLeaderElection(le)
-	}
 	le.Run()
 }
 
@@ -257,14 +239,14 @@ func (le *LeaderElector) tryAcquireOrRenew() bool {
 			return false
 		}
 		le.observedRecord = leaderElectionRecord
-		le.observedTime = le.clock.Now()
+		le.observedTime = time.Now()
 		return true
 	}
 
 	// 2. Record obtained, check the Identity & Time
 	if !reflect.DeepEqual(le.observedRecord, *oldLeaderElectionRecord) {
 		le.observedRecord = *oldLeaderElectionRecord
-		le.observedTime = le.clock.Now()
+		le.observedTime = time.Now()
 	}
 	if le.observedTime.Add(le.config.LeaseDuration).After(now.Time) &&
 		oldLeaderElectionRecord.HolderIdentity != le.config.Lock.Identity() {
@@ -287,7 +269,7 @@ func (le *LeaderElector) tryAcquireOrRenew() bool {
 		return false
 	}
 	le.observedRecord = leaderElectionRecord
-	le.observedTime = le.clock.Now()
+	le.observedTime = time.Now()
 	return true
 }
 
@@ -300,19 +282,3 @@ func (l *LeaderElector) maybeReportTransition() {
 		go l.config.Callbacks.OnNewLeader(l.reportedLeader)
 	}
 }
-
-// Check will determine if the current lease is expired by more than timeout.
-func (le *LeaderElector) Check(maxTolerableExpiredLease time.Duration) error {
-	if !le.IsLeader() {
-		// Currently not concerned with the case that we are hot standby
-		return nil
-	}
-	// If we are more than timeout seconds after the lease duration that is past the timeout
-	// on the lease renew. Time to start reporting ourselves as unhealthy. We should have
-	// died but conditions like deadlock can prevent this. (See #70819)
-	if le.clock.Since(le.observedTime) > le.config.LeaseDuration+maxTolerableExpiredLease {
-		return fmt.Errorf("failed election to renew leadership on lease %s", le.config.Name)
-	}
-
-	return nil
-}

tools/leaderelection/leaderelection_test.go

@@ -26,7 +26,6 @@ import (
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/util/clock"
 	fakecorev1 "k8s.io/client-go/kubernetes/typed/core/v1/fake"
 	core "k8s.io/client-go/testing"
 	rl "k8s.io/client-go/tools/leaderelection/resourcelock"
@@ -258,7 +257,6 @@ func testTryAcquireOrRenew(t *testing.T, objectType string) {
 			config:         lec,
 			observedRecord: test.observedRecord,
 			observedTime:   test.observedTime,
-			clock:          clock.RealClock{},
 		}
 
 		if test.expectSuccess != le.tryAcquireOrRenew() {

transport/round_trippers.go

@@ -129,7 +129,7 @@ func SetAuthProxyHeaders(req *http.Request, username string, groups []string, ex
 	}
 	for key, values := range extra {
 		for _, value := range values {
-			req.Header.Add("X-Remote-Extra-"+headerKeyEscape(key), value)
+			req.Header.Add("X-Remote-Extra-"+key, value)
 		}
 	}
 }
@@ -246,7 +246,7 @@ func (rt *impersonatingRoundTripper) RoundTrip(req *http.Request) (*http.Respons
 	}
 	for k, vv := range rt.impersonate.Extra {
 		for _, v := range vv {
-			req.Header.Add(ImpersonateUserExtraHeaderPrefix+headerKeyEscape(k), v)
+			req.Header.Add(ImpersonateUserExtraHeaderPrefix+k, v)
 		}
 	}
 
@@ -422,110 +422,3 @@ func (rt *debuggingRoundTripper) RoundTrip(req *http.Request) (*http.Response, e
 func (rt *debuggingRoundTripper) WrappedRoundTripper() http.RoundTripper {
 	return rt.delegatedRoundTripper
 }
-
-func legalHeaderByte(b byte) bool {
-	return int(b) < len(legalHeaderKeyBytes) && legalHeaderKeyBytes[b]
-}
-
-func shouldEscape(b byte) bool {
-	// url.PathUnescape() returns an error if any '%' is not followed by two
-	// hexadecimal digits, so we'll intentionally encode it.
-	return !legalHeaderByte(b) || b == '%'
-}
-
-func headerKeyEscape(key string) string {
-	buf := strings.Builder{}
-	for i := 0; i < len(key); i++ {
-		b := key[i]
-		if shouldEscape(b) {
-			// %-encode bytes that should be escaped:
-			// https://tools.ietf.org/html/rfc3986#section-2.1
-			fmt.Fprintf(&buf, "%%%02X", b)
-			continue
-		}
-		buf.WriteByte(b)
-	}
-	return buf.String()
-}
-
-// legalHeaderKeyBytes was copied from net/http/lex.go's isTokenTable.
-// See https://httpwg.github.io/specs/rfc7230.html#rule.token.separators
-var legalHeaderKeyBytes = [127]bool{
-	'%':  true,
-	'!':  true,
-	'#':  true,
-	'$':  true,
-	'&':  true,
-	'\'': true,
-	'*':  true,
-	'+':  true,
-	'-':  true,
-	'.':  true,
-	'0':  true,
-	'1':  true,
-	'2':  true,
-	'3':  true,
-	'4':  true,
-	'5':  true,
-	'6':  true,
-	'7':  true,
-	'8':  true,
-	'9':  true,
-	'A':  true,
-	'B':  true,
-	'C':  true,
-	'D':  true,
-	'E':  true,
-	'F':  true,
-	'G':  true,
-	'H':  true,
-	'I':  true,
-	'J':  true,
-	'K':  true,
-	'L':  true,
-	'M':  true,
-	'N':  true,
-	'O':  true,
-	'P':  true,
-	'Q':  true,
-	'R':  true,
-	'S':  true,
-	'T':  true,
-	'U':  true,
-	'W':  true,
-	'V':  true,
-	'X':  true,
-	'Y':  true,
-	'Z':  true,
-	'^':  true,
-	'_':  true,
-	'`':  true,
-	'a':  true,
-	'b':  true,
-	'c':  true,
-	'd':  true,
-	'e':  true,
-	'f':  true,
-	'g':  true,
-	'h':  true,
-	'i':  true,
-	'j':  true,
-	'k':  true,
-	'l':  true,
-	'm':  true,
-	'n':  true,
-	'o':  true,
-	'p':  true,
-	'q':  true,
-	'r':  true,
-	's':  true,
-	't':  true,
-	'u':  true,
-	'v':  true,
-	'w':  true,
-	'x':  true,
-	'y':  true,
-	'z':  true,
-	'|':  true,
-	'~':  true,
-}

transport/round_trippers_test.go

@@ -18,7 +18,6 @@ package transport
 
 import (
 	"net/http"
-	"net/url"
 	"reflect"
 	"strings"
 	"testing"
@@ -126,32 +125,6 @@ func TestImpersonationRoundTripper(t *testing.T) {
 				ImpersonateUserExtraHeaderPrefix + "Second": {"B", "b"},
 			},
 		},
-		{
-			name: "escape handling",
-			impersonationConfig: ImpersonationConfig{
-				UserName: "user",
-				Extra: map[string][]string{
-					"test.example.com/thing.thing": {"A", "a"},
-				},
-			},
-			expected: map[string][]string{
-				ImpersonateUserHeader:                                               {"user"},
-				ImpersonateUserExtraHeaderPrefix + `Test.example.com%2fthing.thing`: {"A", "a"},
-			},
-		},
-		{
-			name: "double escape handling",
-			impersonationConfig: ImpersonationConfig{
-				UserName: "user",
-				Extra: map[string][]string{
-					"test.example.com/thing.thing%20another.thing": {"A", "a"},
-				},
-			},
-			expected: map[string][]string{
-				ImpersonateUserHeader: {"user"},
-				ImpersonateUserExtraHeaderPrefix + `Test.example.com%2fthing.thing%2520another.thing`: {"A", "a"},
-			},
-		},
 	}
 
 	for _, tc := range tcs {
@@ -186,10 +159,9 @@ func TestImpersonationRoundTripper(t *testing.T) {
 
 func TestAuthProxyRoundTripper(t *testing.T) {
 	for n, tc := range map[string]struct {
-		username      string
-		groups        []string
-		extra         map[string][]string
-		expectedExtra map[string][]string
+		username string
+		groups   []string
+		extra    map[string][]string
 	}{
 		"allfields": {
 			username: "user",
@@ -198,34 +170,6 @@ func TestAuthProxyRoundTripper(t *testing.T) {
 				"one": {"alpha", "bravo"},
 				"two": {"charlie", "delta"},
 			},
-			expectedExtra: map[string][]string{
-				"one": {"alpha", "bravo"},
-				"two": {"charlie", "delta"},
-			},
-		},
-		"escaped extra": {
-			username: "user",
-			groups:   []string{"groupA", "groupB"},
-			extra: map[string][]string{
-				"one":             {"alpha", "bravo"},
-				"example.com/two": {"charlie", "delta"},
-			},
-			expectedExtra: map[string][]string{
-				"one":               {"alpha", "bravo"},
-				"example.com%2ftwo": {"charlie", "delta"},
-			},
-		},
-		"double escaped extra": {
-			username: "user",
-			groups:   []string{"groupA", "groupB"},
-			extra: map[string][]string{
-				"one": {"alpha", "bravo"},
-				"example.com/two%20three": {"charlie", "delta"},
-			},
-			expectedExtra: map[string][]string{
-				"one": {"alpha", "bravo"},
-				"example.com%2ftwo%2520three": {"charlie", "delta"},
-			},
 		},
 	} {
 		rt := &testRoundTripper{}
@@ -266,64 +210,9 @@ func TestAuthProxyRoundTripper(t *testing.T) {
 				actualExtra[extraKey] = append(actualExtra[key], values...)
 			}
 		}
-		if e, a := tc.expectedExtra, actualExtra; !reflect.DeepEqual(e, a) {
+		if e, a := tc.extra, actualExtra; !reflect.DeepEqual(e, a) {
 			t.Errorf("%s expected %v, got %v", n, e, a)
 			continue
 		}
 	}
 }
-
-// TestHeaderEscapeRoundTrip tests to see if foo == url.PathUnescape(headerEscape(foo))
-// This behavior is important for client -> API server transmission of extra values.
-func TestHeaderEscapeRoundTrip(t *testing.T) {
-	t.Parallel()
-	testCases := []struct {
-		name string
-		key  string
-	}{
-		{
-			name: "alpha",
-			key:  "alphabetical",
-		},
-		{
-			name: "alphanumeric",
-			key:  "alph4num3r1c",
-		},
-		{
-			name: "percent encoded",
-			key:  "percent%20encoded",
-		},
-		{
-			name: "almost percent encoded",
-			key:  "almost%zzpercent%xxencoded",
-		},
-		{
-			name: "illegal char & percent encoding",
-			key:  "example.com/percent%20encoded",
-		},
-		{
-			name: "weird unicode stuff",
-			key:  "example.com/ᛒᚥᛏᛖᚥᚢとロビン",
-		},
-		{
-			name: "header legal chars",
-			key:  "abc123!#$+.-_*\\^`~|'",
-		},
-		{
-			name: "legal path, illegal header",
-			key:  "@=:",
-		},
-	}
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			escaped := headerKeyEscape(tc.key)
-			unescaped, err := url.PathUnescape(escaped)
-			if err != nil {
-				t.Fatalf("url.PathUnescape(%q) returned error: %v", escaped, err)
-			}
-			if tc.key != unescaped {
-				t.Errorf("url.PathUnescape(headerKeyEscape(%q)) returned %q, wanted %q", tc.key, unescaped, tc.key)
-			}
-		})
-	}
-}

util/cert/io.go

@@ -88,8 +88,7 @@ func WriteKey(keyPath string, data []byte) error {
 // can't find one, it will generate a new key and store it there.
 func LoadOrGenerateKeyFile(keyPath string) (data []byte, wasGenerated bool, err error) {
 	loadedData, err := ioutil.ReadFile(keyPath)
-	// Call verifyKeyData to ensure the file wasn't empty/corrupt.
-	if err == nil && verifyKeyData(loadedData) {
+	if err == nil {
 		return loadedData, false, err
 	}
 	if !os.IsNotExist(err) {
@@ -182,12 +181,3 @@ func PublicKeysFromFile(file string) ([]interface{}, error) {
 	}
 	return keys, nil
 }
-
-// verifyKeyData returns true if the provided data appears to be a valid private key.
-func verifyKeyData(data []byte) bool {
-	if len(data) == 0 {
-		return false
-	}
-	_, err := ParsePrivateKeyPEM(data)
-	return err == nil
-}