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

* remove cache reader marshal/unmarshal
* adding seperation between types and unstructured types in the cache

Author: Shawn Hurley

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"
@@ -38,13 +39,14 @@ func NewInformersMap(config *rest.Config,
 	mapper meta.RESTMapper,
 	resync time.Duration) *InformersMap {
 	ip := &InformersMap{
-		config:         config,
-		Scheme:         scheme,
-		mapper:         mapper,
-		informersByGVK: make(map[schema.GroupVersionKind]*MapEntry),
-		codecs:         serializer.NewCodecFactory(scheme),
-		paramCodec:     runtime.NewParameterCodec(scheme),
-		resync:         resync,
+		config:                    config,
+		Scheme:                    scheme,
+		mapper:                    mapper,
+		informersByGVK:            make(map[schema.GroupVersionKind]*MapEntry),
+		unstructuredInformerByGVK: make(map[schema.GroupVersionKind]*MapEntry),
+		codecs:     serializer.NewCodecFactory(scheme),
+		paramCodec: runtime.NewParameterCodec(scheme),
+		resync:     resync,
 	}
 	return ip
 }
@@ -73,6 +75,10 @@ type InformersMap struct {
 	// informersByGVK is the cache of informers keyed by groupVersionKind
 	informersByGVK map[schema.GroupVersionKind]*MapEntry
 
+	// unstructuredInformerByGVK is a cache of informers for unstructured types
+	// keyed by groupVersionKind
+	unstructuredInformerByGVK map[schema.GroupVersionKind]*MapEntry
+
 	// codecs is used to create a new REST client
 	codecs serializer.CodecFactory
 
@@ -87,6 +93,8 @@ type InformersMap struct {
 
 	// mu guards access to the map
 	mu sync.RWMutex
+	// mu guards access to the unstructured map
+	unstructuredMu sync.RWMutex
 
 	// start is true if the informers have been started
 	started bool
@@ -96,7 +104,9 @@ type InformersMap struct {
 func (ip *InformersMap) Start(stop <-chan struct{}) error {
 	func() {
 		ip.mu.Lock()
+		ip.unstructuredMu.Lock()
 		defer ip.mu.Unlock()
+		defer ip.unstructuredMu.Unlock()
 
 		// Set the stop channel so it can be passed to informers that are added later
 		ip.stop = stop
@@ -106,6 +116,11 @@ func (ip *InformersMap) Start(stop <-chan struct{}) error {
 			go informer.Informer.Run(stop)
 		}
 
+		// Start each unstructured informer
+		for _, informer := range ip.unstructuredInformerByGVK {
+			go informer.Informer.Run(stop)
+		}
+
 		// Set started to true so we immediately start any informers added later.
 		ip.started = true
 	}()
@@ -115,23 +130,36 @@ func (ip *InformersMap) Start(stop <-chan struct{}) error {
 
 // WaitForCacheSync waits until all the caches have been synced
 func (ip *InformersMap) WaitForCacheSync(stop <-chan struct{}) bool {
-	syncedFuncs := make([]cache.InformerSynced, 0, len(ip.informersByGVK))
+	syncedFuncs := make([]cache.InformerSynced, 0, len(ip.informersByGVK)+len(ip.unstructuredInformerByGVK))
 	for _, informer := range ip.informersByGVK {
 		syncedFuncs = append(syncedFuncs, informer.Informer.HasSynced)
 	}
+	for _, informer := range ip.unstructuredInformerByGVK {
+		syncedFuncs = append(syncedFuncs, informer.Informer.HasSynced)
+	}
 	return cache.WaitForCacheSync(stop, syncedFuncs...)
 }
 
+func (ip *InformersMap) getMapEntry(gvk schema.GroupVersionKind, isUnstructured bool) (*MapEntry, bool) {
+	if isUnstructured {
+		ip.unstructuredMu.RLock()
+		defer ip.unstructuredMu.RUnlock()
+		i, ok := ip.unstructuredInformerByGVK[gvk]
+		return i, ok
+	}
+	ip.mu.RLock()
+	defer ip.mu.RUnlock()
+	i, ok := ip.informersByGVK[gvk]
+	return i, ok
+
+}
+
 // Get will create a new Informer and add it to the map of InformersMap if none exists.  Returns
 // the Informer from the map.
 func (ip *InformersMap) Get(gvk schema.GroupVersionKind, obj runtime.Object) (*MapEntry, error) {
+	_, isUnstructured := obj.(*unstructured.Unstructured)
 	// Return the informer if it is found
-	i, ok := func() (*MapEntry, bool) {
-		ip.mu.RLock()
-		defer ip.mu.RUnlock()
-		i, ok := ip.informersByGVK[gvk]
-		return i, ok
-	}()
+	i, ok := ip.getMapEntry(gvk, isUnstructured)
 	if ok {
 		return i, nil
 	}
@@ -140,21 +168,27 @@ func (ip *InformersMap) Get(gvk schema.GroupVersionKind, obj runtime.Object) (*M
 	// need to be locked
 	var sync bool
 	i, err := func() (*MapEntry, error) {
-		ip.mu.Lock()
-		defer ip.mu.Unlock()
-
-		// Check the cache to see if we already have an Informer.  If we do, return the Informer.
+		var ok bool
+		var i *MapEntry
+		// Check the caches to see if we already have an Informer.  If we do, return the Informer.
 		// This is for the case where 2 routines tried to get the informer when it wasn't in the map
 		// so neither returned early, but the first one created it.
-		var ok bool
-		i, ok := ip.informersByGVK[gvk]
+		if isUnstructured {
+			ip.unstructuredMu.Lock()
+			defer ip.unstructuredMu.Unlock()
+			i, ok = ip.unstructuredInformerByGVK[gvk]
+		} else {
+			ip.mu.Lock()
+			defer ip.mu.Unlock()
+			i, ok = ip.informersByGVK[gvk]
+		}
 		if ok {
 			return i, nil
 		}
 
 		// 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,26 +225,34 @@ 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) {
-	// Construct a RESTClient for the groupVersionKind that we will use to
-	// talk to the apiserver.
-	client, err := apiutil.RESTClientForGVK(gvk, ip.config, ip.codecs)
-	if err != nil {
-		return nil, err
-	}
-
+func (ip *InformersMap) newListWatch(gvk schema.GroupVersionKind, isUnstructured bool) (*cache.ListWatch, error) {
 	// Kubernetes APIs work against Resources, not GroupVersionKinds.  Map the
 	// groupVersionKind to the Resource API we will use.
 	mapping, err := ip.mapper.RESTMapping(gvk.GroupKind(), gvk.Version)
 	if err != nil {
 		return nil, err
 	}
 
-	// Get a listObject for listing that the ListWatch can DeepCopy
-	listGVK := gvk.GroupVersion().WithKind(gvk.Kind + "List")
-	listObj, err := ip.Scheme.New(listGVK)
-	if err != nil {
-		return nil, err
+	// Construct a RESTClient for the groupVersionKind that we will use to
+	// talk to the apiserver.
+	var client rest.Interface
+	var listObj runtime.Object
+	if isUnstructured {
+		listObj = &unstructured.UnstructuredList{}
+		client, err = apiutil.RESTUnstructuredClientForGVK(gvk, ip.config)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		client, err = apiutil.RESTClientForGVK(gvk, ip.config, ip.codecs)
+		if err != nil {
+			return nil, err
+		}
+		listGVK := gvk.GroupVersion().WithKind(gvk.Kind + "List")
+		listObj, err = ip.Scheme.New(listGVK)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	// Create a new ListWatch for the obj

pkg/client/apiutil/apimachinery.go

@@ -20,10 +20,12 @@ 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/kubernetes/scheme"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/restmapper"
 )
@@ -65,6 +67,29 @@ func GVKForObject(obj runtime.Object, scheme *runtime.Scheme) (schema.GroupVersi
 // RESTClientForGVK constructs a new rest.Interface capable of accessing the resource associated
 // with the given GroupVersionKind.
 func RESTClientForGVK(gvk schema.GroupVersionKind, baseConfig *rest.Config, codecs serializer.CodecFactory) (rest.Interface, error) {
+	cfg := createRestConfig(gvk, baseConfig)
+	cfg.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: codecs}
+	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) {
+	cfg := createRestConfig(gvk, baseConfig)
+	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)
+
+	return rest.RESTClientFor(cfg)
+}
+
+//createRestConfig copies the base config and updates needed fields for a new rest config
+func createRestConfig(gvk schema.GroupVersionKind, baseConfig *rest.Config) *rest.Config {
 	gv := gvk.GroupVersion()
 
 	cfg := rest.CopyConfig(baseConfig)
@@ -74,9 +99,9 @@ func RESTClientForGVK(gvk schema.GroupVersionKind, baseConfig *rest.Config, code
 	} else {
 		cfg.APIPath = "/apis"
 	}
-	cfg.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: codecs}
 	if cfg.UserAgent == "" {
 		cfg.UserAgent = rest.DefaultKubernetesUserAgent()
 	}
-	return rest.RESTClientFor(cfg)
+	return 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"
@@ -60,11 +61,12 @@ func New(config *rest.Config, options Options) (Client, error) {
 
 	c := &client{
 		cache: clientCache{
-			config:         config,
-			scheme:         options.Scheme,
-			mapper:         options.Mapper,
-			codecs:         serializer.NewCodecFactory(options.Scheme),
-			resourceByType: make(map[reflect.Type]*resourceMeta),
+			config:                    config,
+			scheme:                    options.Scheme,
+			mapper:                    options.Mapper,
+			codecs:                    serializer.NewCodecFactory(options.Scheme),
+			resourceByType:            make(map[reflect.Type]*resourceMeta),
+			unstructuredResourceByGVK: 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 metadata for unstructured
+	unstructuredResourceByGVK 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) getUnstructuredResourceByGVK(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.unstructuredResourceByGVK[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.unstructuredResourceByGVK[obj.GetObjectKind().GroupVersionKind()] = r
+	return r, err
+}
+
+func (c *clientCache) getResourceByType(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.getUnstructuredResourceByGVK(obj)
+	}
+	return c.getResourceByType(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)