rebase: update kubernetes to v1.25.0

update kubernetes to latest v1.25.0
release.

Signed-off-by: Madhu Rajanna <madhupr007@gmail.com>

vendor/k8s.io/apimachinery/pkg/runtime/allocator.go

@@ -24,12 +24,14 @@ import (
 // by caching created but unused items for later reuse, relieving pressure on the garbage collector.
 //
 // Usage:
-//  memoryAllocator := runtime.AllocatorPool.Get().(*runtime.Allocator)
-//  defer runtime.AllocatorPool.Put(memoryAllocator)
+//
+//	memoryAllocator := runtime.AllocatorPool.Get().(*runtime.Allocator)
+//	defer runtime.AllocatorPool.Put(memoryAllocator)
 //
 // A note for future:
-//  consider introducing multiple pools for storing buffers of different sizes
-//  perhaps this could allow us to be more efficient.
+//
+//	consider introducing multiple pools for storing buffers of different sizes
+//	perhaps this could allow us to be more efficient.
 var AllocatorPool = sync.Pool{
 	New: func() interface{} {
 		return &Allocator{}
@@ -58,7 +60,7 @@ func (a *Allocator) Allocate(n uint64) []byte {
 	}
 	// grow the buffer
 	size := uint64(2*cap(a.buf)) + n
-	a.buf = make([]byte, size, size)
+	a.buf = make([]byte, size)
 	a.buf = a.buf[:n]
 	return a.buf
 }
@@ -70,5 +72,5 @@ type SimpleAllocator struct{}
 var _ MemoryAllocator = &SimpleAllocator{}
 
 func (sa *SimpleAllocator) Allocate(n uint64) []byte {
-	return make([]byte, n, n)
+	return make([]byte, n)
 }

vendor/k8s.io/apimachinery/pkg/runtime/codec.go

@@ -344,14 +344,15 @@ func NewMultiGroupVersioner(gv schema.GroupVersion, groupKinds ...schema.GroupKi
 // Incoming kinds that match the provided groupKinds are preferred.
 // Kind may be empty in the provided group kind, in which case any kind will match.
 // Examples:
-//   gv=mygroup/__internal, groupKinds=mygroup/Foo, anothergroup/Bar
-//   KindForGroupVersionKinds(yetanother/v1/Baz, anothergroup/v1/Bar) -> mygroup/__internal/Bar (matched preferred group/kind)
 //
-//   gv=mygroup/__internal, groupKinds=mygroup, anothergroup
-//   KindForGroupVersionKinds(yetanother/v1/Baz, anothergroup/v1/Bar) -> mygroup/__internal/Bar (matched preferred group)
+//	gv=mygroup/__internal, groupKinds=mygroup/Foo, anothergroup/Bar
+//	KindForGroupVersionKinds(yetanother/v1/Baz, anothergroup/v1/Bar) -> mygroup/__internal/Bar (matched preferred group/kind)
 //
-//   gv=mygroup/__internal, groupKinds=mygroup, anothergroup
-//   KindForGroupVersionKinds(yetanother/v1/Baz, yetanother/v1/Bar) -> mygroup/__internal/Baz (no preferred group/kind match, uses first kind in list)
+//	gv=mygroup/__internal, groupKinds=mygroup, anothergroup
+//	KindForGroupVersionKinds(yetanother/v1/Baz, anothergroup/v1/Bar) -> mygroup/__internal/Bar (matched preferred group)
+//
+//	gv=mygroup/__internal, groupKinds=mygroup, anothergroup
+//	KindForGroupVersionKinds(yetanother/v1/Baz, yetanother/v1/Bar) -> mygroup/__internal/Baz (no preferred group/kind match, uses first kind in list)
 func NewCoercingMultiGroupVersioner(gv schema.GroupVersion, groupKinds ...schema.GroupKind) GroupVersioner {
 	return multiGroupVersioner{target: gv, acceptedGroupKinds: groupKinds, coerce: true}
 }

vendor/k8s.io/apimachinery/pkg/runtime/codec_check.go

@@ -30,7 +30,7 @@ import (
 // TODO: verify that the correct external version is chosen on encode...
 func CheckCodec(c Codec, internalType Object, externalTypes ...schema.GroupVersionKind) error {
 	if _, err := Encode(c, internalType); err != nil {
-		return fmt.Errorf("Internal type not encodable: %v", err)
+		return fmt.Errorf("internal type not encodable: %v", err)
 	}
 	for _, et := range externalTypes {
 		typeMeta := TypeMeta{

vendor/k8s.io/apimachinery/pkg/runtime/converter.go

@@ -237,7 +237,7 @@ func (c *fromUnstructuredContext) pushKey(key string) {
 func (c *unstructuredConverter) FromUnstructuredWithValidation(u map[string]interface{}, obj interface{}, returnUnknownFields bool) error {
 	t := reflect.TypeOf(obj)
 	value := reflect.ValueOf(obj)
-	if t.Kind() != reflect.Ptr || value.IsNil() {
+	if t.Kind() != reflect.Pointer || value.IsNil() {
 		return fmt.Errorf("FromUnstructured requires a non-nil pointer to an object, got %v", t)
 	}
 
@@ -291,7 +291,7 @@ func fromUnstructured(sv, dv reflect.Value, ctx *fromUnstructuredContext) error
 	st, dt := sv.Type(), dv.Type()
 
 	switch dt.Kind() {
-	case reflect.Map, reflect.Slice, reflect.Ptr, reflect.Struct, reflect.Interface:
+	case reflect.Map, reflect.Slice, reflect.Pointer, reflect.Struct, reflect.Interface:
 		// Those require non-trivial conversion.
 	default:
 		// This should handle all simple types.
@@ -353,7 +353,7 @@ func fromUnstructured(sv, dv reflect.Value, ctx *fromUnstructuredContext) error
 		return mapFromUnstructured(sv, dv, ctx)
 	case reflect.Slice:
 		return sliceFromUnstructured(sv, dv, ctx)
-	case reflect.Ptr:
+	case reflect.Pointer:
 		return pointerFromUnstructured(sv, dv, ctx)
 	case reflect.Struct:
 		return structFromUnstructured(sv, dv, ctx)
@@ -496,13 +496,13 @@ func sliceFromUnstructured(sv, dv reflect.Value, ctx *fromUnstructuredContext) e
 func pointerFromUnstructured(sv, dv reflect.Value, ctx *fromUnstructuredContext) error {
 	st, dt := sv.Type(), dv.Type()
 
-	if st.Kind() == reflect.Ptr && sv.IsNil() {
+	if st.Kind() == reflect.Pointer && sv.IsNil() {
 		dv.Set(reflect.Zero(dt))
 		return nil
 	}
 	dv.Set(reflect.New(dt.Elem()))
 	switch st.Kind() {
-	case reflect.Ptr, reflect.Interface:
+	case reflect.Pointer, reflect.Interface:
 		return fromUnstructured(sv.Elem(), dv.Elem(), ctx)
 	default:
 		return fromUnstructured(sv, dv.Elem(), ctx)
@@ -579,7 +579,7 @@ func (c *unstructuredConverter) ToUnstructured(obj interface{}) (map[string]inte
 	} else {
 		t := reflect.TypeOf(obj)
 		value := reflect.ValueOf(obj)
-		if t.Kind() != reflect.Ptr || value.IsNil() {
+		if t.Kind() != reflect.Pointer || value.IsNil() {
 			return nil, fmt.Errorf("ToUnstructured requires a non-nil pointer to an object, got %v", t)
 		}
 		u = map[string]interface{}{}
@@ -686,7 +686,7 @@ func toUnstructured(sv, dv reflect.Value) error {
 		return mapToUnstructured(sv, dv)
 	case reflect.Slice:
 		return sliceToUnstructured(sv, dv)
-	case reflect.Ptr:
+	case reflect.Pointer:
 		return pointerToUnstructured(sv, dv)
 	case reflect.Struct:
 		return structToUnstructured(sv, dv)
@@ -790,7 +790,7 @@ func isZero(v reflect.Value) bool {
 	case reflect.Map, reflect.Slice:
 		// TODO: It seems that 0-len maps are ignored in it.
 		return v.IsNil() || v.Len() == 0
-	case reflect.Ptr, reflect.Interface:
+	case reflect.Pointer, reflect.Interface:
 		return v.IsNil()
 	}
 	return false

vendor/k8s.io/apimachinery/pkg/runtime/generated.proto

@@ -31,32 +31,37 @@ option go_package = "k8s.io/apimachinery/pkg/runtime";
 // various plugin types.
 //
 // // Internal package:
-// type MyAPIObject struct {
-// 	runtime.TypeMeta `json:",inline"`
-// 	MyPlugin runtime.Object `json:"myPlugin"`
-// }
-// type PluginA struct {
-// 	AOption string `json:"aOption"`
-// }
+//
+// 	type MyAPIObject struct {
+// 		runtime.TypeMeta `json:",inline"`
+// 		MyPlugin runtime.Object `json:"myPlugin"`
+// 	}
+//
+// 	type PluginA struct {
+// 		AOption string `json:"aOption"`
+// 	}
 //
 // // External package:
-// type MyAPIObject struct {
-// 	runtime.TypeMeta `json:",inline"`
-// 	MyPlugin runtime.RawExtension `json:"myPlugin"`
-// }
-// type PluginA struct {
-// 	AOption string `json:"aOption"`
-// }
+//
+// 	type MyAPIObject struct {
+// 		runtime.TypeMeta `json:",inline"`
+// 		MyPlugin runtime.RawExtension `json:"myPlugin"`
+// 	}
+//
+// 	type PluginA struct {
+// 		AOption string `json:"aOption"`
+// 	}
 //
 // // On the wire, the JSON will look something like this:
-// {
-// 	"kind":"MyAPIObject",
-// 	"apiVersion":"v1",
-// 	"myPlugin": {
-// 		"kind":"PluginA",
-// 		"aOption":"foo",
-// 	},
-// }
+//
+// 	{
+// 		"kind":"MyAPIObject",
+// 		"apiVersion":"v1",
+// 		"myPlugin": {
+// 			"kind":"PluginA",
+// 			"aOption":"foo",
+// 		},
+// 	}
 //
 // So what happens? Decode first uses json or yaml to unmarshal the serialized data into
 // your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked.
@@ -78,10 +83,12 @@ message RawExtension {
 
 // TypeMeta is shared by all top level objects. The proper way to use it is to inline it in your type,
 // like this:
-// type MyAwesomeAPIObject struct {
-//      runtime.TypeMeta    `json:",inline"`
-//      ... // other fields
-// }
+//
+// 	type MyAwesomeAPIObject struct {
+// 	     runtime.TypeMeta    `json:",inline"`
+// 	     ... // other fields
+// 	}
+//
 // func (obj *MyAwesomeAPIObject) SetGroupVersionKind(gvk *metav1.GroupVersionKind) { metav1.UpdateTypeMeta(obj,gvk) }; GroupVersionKind() *GroupVersionKind
 //
 // TypeMeta is provided here for convenience. You may use it directly from this package or define

vendor/k8s.io/apimachinery/pkg/runtime/schema/group_version.go

@@ -191,7 +191,8 @@ func (gv GroupVersion) Identifier() string {
 // if none of the options match the group. It prefers a match to group and version over just group.
 // TODO: Move GroupVersion to a package under pkg/runtime, since it's used by scheme.
 // TODO: Introduce an adapter type between GroupVersion and runtime.GroupVersioner, and use LegacyCodec(GroupVersion)
-//   in fewer places.
+//
+//	in fewer places.
 func (gv GroupVersion) KindForGroupVersionKinds(kinds []GroupVersionKind) (target GroupVersionKind, ok bool) {
 	for _, gvk := range kinds {
 		if gvk.Group == gv.Group && gvk.Version == gv.Version {
@@ -239,7 +240,8 @@ func (gv GroupVersion) WithResource(resource string) GroupVersionResource {
 // GroupVersions can be used to represent a set of desired group versions.
 // TODO: Move GroupVersions to a package under pkg/runtime, since it's used by scheme.
 // TODO: Introduce an adapter type between GroupVersions and runtime.GroupVersioner, and use LegacyCodec(GroupVersion)
-//   in fewer places.
+//
+//	in fewer places.
 type GroupVersions []GroupVersion
 
 // Identifier implements runtime.GroupVersioner interface.

vendor/k8s.io/apimachinery/pkg/runtime/scheme.go

@@ -118,7 +118,8 @@ func (s *Scheme) Converter() *conversion.Converter {
 // API group and version that would never be updated.
 //
 // TODO: there is discussion about removing unversioned and replacing it with objects that are manifest into
-//   every version with particular schemas. Resolve this method at that point.
+//
+//	every version with particular schemas. Resolve this method at that point.
 func (s *Scheme) AddUnversionedTypes(version schema.GroupVersion, types ...Object) {
 	s.addObservedVersion(version)
 	s.AddKnownTypes(version, types...)
@@ -141,7 +142,7 @@ func (s *Scheme) AddKnownTypes(gv schema.GroupVersion, types ...Object) {
 	s.addObservedVersion(gv)
 	for _, obj := range types {
 		t := reflect.TypeOf(obj)
-		if t.Kind() != reflect.Ptr {
+		if t.Kind() != reflect.Pointer {
 			panic("All types must be pointers to structs.")
 		}
 		t = t.Elem()
@@ -159,7 +160,7 @@ func (s *Scheme) AddKnownTypeWithName(gvk schema.GroupVersionKind, obj Object) {
 	if len(gvk.Version) == 0 {
 		panic(fmt.Sprintf("version is required on all types: %s %v", gvk, t))
 	}
-	if t.Kind() != reflect.Ptr {
+	if t.Kind() != reflect.Pointer {
 		panic("All types must be pointers to structs.")
 	}
 	t = t.Elem()
@@ -462,7 +463,7 @@ func (s *Scheme) convertToVersion(copy bool, in Object, target GroupVersioner) (
 	} else {
 		// determine the incoming kinds with as few allocations as possible.
 		t = reflect.TypeOf(in)
-		if t.Kind() != reflect.Ptr {
+		if t.Kind() != reflect.Pointer {
 			return nil, fmt.Errorf("only pointer types may be converted: %v", t)
 		}
 		t = t.Elem()

vendor/k8s.io/apimachinery/pkg/runtime/serializer/codec_factory.go

@@ -259,7 +259,8 @@ func (f CodecFactory) SupportedMediaTypes() []runtime.SerializerInfo {
 // invoke CodecForVersions. Callers that need only to read data should use UniversalDecoder().
 //
 // TODO: make this call exist only in pkg/api, and initialize it with the set of default versions.
-//   All other callers will be forced to request a Codec directly.
+//
+//	All other callers will be forced to request a Codec directly.
 func (f CodecFactory) LegacyCodec(version ...schema.GroupVersion) runtime.Codec {
 	return versioning.NewDefaultingCodecForScheme(f.scheme, f.legacySerializer, f.universal, schema.GroupVersions(version), runtime.InternalGroupVersioner)
 }

vendor/k8s.io/apimachinery/pkg/runtime/types.go

@@ -21,10 +21,12 @@ package runtime
 
 // TypeMeta is shared by all top level objects. The proper way to use it is to inline it in your type,
 // like this:
-// type MyAwesomeAPIObject struct {
-//      runtime.TypeMeta    `json:",inline"`
-//      ... // other fields
-// }
+//
+//	type MyAwesomeAPIObject struct {
+//	     runtime.TypeMeta    `json:",inline"`
+//	     ... // other fields
+//	}
+//
 // func (obj *MyAwesomeAPIObject) SetGroupVersionKind(gvk *metav1.GroupVersionKind) { metav1.UpdateTypeMeta(obj,gvk) }; GroupVersionKind() *GroupVersionKind
 //
 // TypeMeta is provided here for convenience. You may use it directly from this package or define
@@ -53,32 +55,37 @@ const (
 // various plugin types.
 //
 // // Internal package:
-// type MyAPIObject struct {
-// 	runtime.TypeMeta `json:",inline"`
-//	MyPlugin runtime.Object `json:"myPlugin"`
-// }
-// type PluginA struct {
-//	AOption string `json:"aOption"`
-// }
+//
+//	type MyAPIObject struct {
+//		runtime.TypeMeta `json:",inline"`
+//		MyPlugin runtime.Object `json:"myPlugin"`
+//	}
+//
+//	type PluginA struct {
+//		AOption string `json:"aOption"`
+//	}
 //
 // // External package:
-// type MyAPIObject struct {
-// 	runtime.TypeMeta `json:",inline"`
-//	MyPlugin runtime.RawExtension `json:"myPlugin"`
-// }
-// type PluginA struct {
-//	AOption string `json:"aOption"`
-// }
+//
+//	type MyAPIObject struct {
+//		runtime.TypeMeta `json:",inline"`
+//		MyPlugin runtime.RawExtension `json:"myPlugin"`
+//	}
+//
+//	type PluginA struct {
+//		AOption string `json:"aOption"`
+//	}
 //
 // // On the wire, the JSON will look something like this:
-// {
-//	"kind":"MyAPIObject",
-//	"apiVersion":"v1",
-//	"myPlugin": {
-//		"kind":"PluginA",
-//		"aOption":"foo",
-//	},
-// }
+//
+//	{
+//		"kind":"MyAPIObject",
+//		"apiVersion":"v1",
+//		"myPlugin": {
+//			"kind":"PluginA",
+//			"aOption":"foo",
+//		},
+//	}
 //
 // So what happens? Decode first uses json or yaml to unmarshal the serialized data into
 // your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked.