Adding ability for clients, cache and watcher to work with unstructured

Author: Shawn Hurley

pkg/cache/internal/cache_reader.go

@@ -18,11 +18,13 @@ package internal
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"reflect"
 
 	"k8s.io/apimachinery/pkg/api/errors"
 	apimeta "k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/fields"
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -73,6 +75,21 @@ func (c *CacheReader) Get(_ context.Context, key client.ObjectKey, out runtime.O
 	// TODO(directxman12): revisit the decision to always deepcopy
 	obj = obj.(runtime.Object).DeepCopyObject()
 
+	// If out is supposed to be unstructured handle correctly.
+	if o, ok := out.(*unstructured.Unstructured); ok {
+		//Encode the obj to a map[string]interface and et the out.Object
+		b, err := json.Marshal(obj)
+		if err != nil {
+			return err
+		}
+		err = json.Unmarshal(b, o)
+		if err != nil {
+			return err
+		}
+		o.SetGroupVersionKind(c.groupVersionKind)
+		return nil
+	}
+
 	// Copy the value of the item in the cache to the returned value
 	// TODO(directxman12): this is a terrible hack, pls fix (we should have deepcopyinto)
 	outVal := reflect.ValueOf(out)

pkg/cache/internal/informers_map.go

@@ -23,6 +23,7 @@ import (
 
 	"k8s.io/apimachinery/pkg/api/meta"
 	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/runtime/serializer"
@@ -151,10 +152,11 @@ func (ip *InformersMap) Get(gvk schema.GroupVersionKind, obj runtime.Object) (*M
 		if ok {
 			return i, nil
 		}
+		_, isUnstructured := obj.(*unstructured.Unstructured)
 
 		// Create a NewSharedIndexInformer and add it to the map.
 		var lw *cache.ListWatch
-		lw, err := ip.newListWatch(gvk)
+		lw, err := ip.newListWatch(gvk, isUnstructured)
 		if err != nil {
 			return nil, err
 		}
@@ -191,10 +193,17 @@ func (ip *InformersMap) Get(gvk schema.GroupVersionKind, obj runtime.Object) (*M
 }
 
 // newListWatch returns a new ListWatch object that can be used to create a SharedIndexInformer.
-func (ip *InformersMap) newListWatch(gvk schema.GroupVersionKind) (*cache.ListWatch, error) {
+func (ip *InformersMap) newListWatch(gvk schema.GroupVersionKind, isUnstructured bool) (*cache.ListWatch, error) {
 	// Construct a RESTClient for the groupVersionKind that we will use to
 	// talk to the apiserver.
-	client, err := apiutil.RESTClientForGVK(gvk, ip.config, ip.codecs)
+	var client rest.Interface
+	var err error
+	if isUnstructured {
+		client, err = apiutil.RESTUnstructuredClientForGVK(gvk, ip.config)
+	} else {
+		client, err = apiutil.RESTClientForGVK(gvk, ip.config, ip.codecs)
+
+	}
 	if err != nil {
 		return nil, err
 	}

pkg/client/apiutil/apimachinery.go

@@ -4,11 +4,13 @@ import (
 	"fmt"
 
 	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/discovery"
 	"k8s.io/client-go/dynamic"
+	"k8s.io/client-go/kubernetes/scheme"
 	"k8s.io/client-go/rest"
 )
 
@@ -64,3 +66,30 @@ func RESTClientForGVK(gvk schema.GroupVersionKind, baseConfig *rest.Config, code
 	}
 	return rest.RESTClientFor(cfg)
 }
+
+// RESTUnstructuredClientForGVK constructs a new rest.Interface for accessing unstructured resources.
+func RESTUnstructuredClientForGVK(gvk schema.GroupVersionKind, baseConfig *rest.Config) (rest.Interface, error) {
+	gv := gvk.GroupVersion()
+
+	cfg := rest.CopyConfig(baseConfig)
+	cfg.GroupVersion = &gv
+	if gvk.Group == "" {
+		cfg.APIPath = "/api"
+	} else {
+		cfg.APIPath = "/apis"
+	}
+	var jsonInfo runtime.SerializerInfo
+	for _, info := range scheme.Codecs.SupportedMediaTypes() {
+		if info.MediaType == runtime.ContentTypeJSON {
+			jsonInfo = info
+			break
+		}
+	}
+	jsonInfo.Serializer = unstructured.UnstructuredJSONScheme
+
+	cfg.NegotiatedSerializer = serializer.NegotiatedSerializerWrapper(jsonInfo)
+	if cfg.UserAgent == "" {
+		cfg.UserAgent = rest.DefaultKubernetesUserAgent()
+	}
+	return rest.RESTClientFor(cfg)
+}

pkg/client/client.go

@@ -23,6 +23,7 @@ import (
 
 	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	"k8s.io/client-go/rest"
@@ -65,6 +66,7 @@ func New(config *rest.Config, options Options) (Client, error) {
 			mapper:         options.Mapper,
 			codecs:         serializer.NewCodecFactory(options.Scheme),
 			resourceByType: make(map[reflect.Type]*resourceMeta),
+			resourceByGVK:  make(map[schema.GroupVersionKind]*resourceMeta),
 		},
 		paramCodec: runtime.NewParameterCodec(options.Scheme),
 	}

pkg/client/client_cache.go

@@ -23,6 +23,7 @@ import (
 
 	"k8s.io/apimachinery/pkg/api/meta"
 	"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/runtime/serializer"
@@ -46,7 +47,10 @@ type clientCache struct {
 
 	// resourceByType caches type metadata
 	resourceByType map[reflect.Type]*resourceMeta
-	mu             sync.RWMutex
+	// resourceByGVK caches type metadat for unstructured
+	resourceByGVK map[schema.GroupVersionKind]*resourceMeta
+	muByType      sync.RWMutex
+	muByGVK       sync.RWMutex
 }
 
 // newResource maps obj to a Kubernetes Resource and constructs a client for that Resource.
@@ -73,24 +77,44 @@ func (c *clientCache) newResource(obj runtime.Object) (*resourceMeta, error) {
 	return &resourceMeta{Interface: client, mapping: mapping, gvk: gvk}, nil
 }
 
-// getResource returns the resource meta information for the given type of object.
-// If the object is a list, the resource represents the item's type instead.
-func (c *clientCache) getResource(obj runtime.Object) (*resourceMeta, error) {
+func (c *clientCache) handleResourceByGVK(obj runtime.Object) (*resourceMeta, error) {
+	// It's better to do creation work twice than to not let multiple
+	// people make requests at once
+	c.muByGVK.RLock()
+	r, known := c.resourceByGVK[obj.GetObjectKind().GroupVersionKind()]
+	c.muByGVK.RUnlock()
+
+	if known {
+		return r, nil
+	}
+
+	// Initialize a new Client
+	c.muByGVK.Lock()
+	defer c.muByGVK.Unlock()
+	r, err := c.newResource(obj)
+	if err != nil {
+		return nil, err
+	}
+	c.resourceByGVK[obj.GetObjectKind().GroupVersionKind()] = r
+	return r, err
+}
+
+func (c *clientCache) handleResourceByType(obj runtime.Object) (*resourceMeta, error) {
 	typ := reflect.TypeOf(obj)
 
 	// It's better to do creation work twice than to not let multiple
 	// people make requests at once
-	c.mu.RLock()
+	c.muByType.RLock()
 	r, known := c.resourceByType[typ]
-	c.mu.RUnlock()
+	c.muByType.RUnlock()
 
 	if known {
 		return r, nil
 	}
 
 	// Initialize a new Client
-	c.mu.Lock()
-	defer c.mu.Unlock()
+	c.muByType.Lock()
+	defer c.muByType.Unlock()
 	r, err := c.newResource(obj)
 	if err != nil {
 		return nil, err
@@ -99,6 +123,16 @@ func (c *clientCache) getResource(obj runtime.Object) (*resourceMeta, error) {
 	return r, err
 }
 
+// getResource returns the resource meta information for the given type of object.
+// If the object is a list, the resource represents the item's type instead.
+func (c *clientCache) getResource(obj runtime.Object) (*resourceMeta, error) {
+	_, isUnstructured := obj.(*unstructured.Unstructured)
+	if isUnstructured {
+		return c.handleResourceByGVK(obj)
+	}
+	return c.handleResourceByType(obj)
+}
+
 // getObjMeta returns objMeta containing both type and object metadata and state
 func (c *clientCache) getObjMeta(obj runtime.Object) (*objMeta, error) {
 	r, err := c.getResource(obj)