Start new informers if they have not been started yet

On-behalf-of: SAP <marvin.beckers@sap.com>
Signed-off-by: Marvin Beckers <marvin@kubermatic.com>

Author: embik

examples/apiexport/main.go

@@ -121,7 +121,7 @@ func main() {
 					return reconcile.Result{}, fmt.Errorf("failed to get configmap: %w", err)
 				}
 
-				log.Info("Reconciling configmap", "name", s.Name, "uuid", s.UID)
+				log.Info("Reconciling ConfigMap", "name", s.Name, "uuid", s.UID)
 
 				return reconcile.Result{}, nil
 			},

virtualworkspace/cache.go

@@ -52,13 +52,10 @@ func (c *scopedCache) IndexField(ctx context.Context, obj client.Object, field s
 
 // Get returns a single object from the cache.
 func (c *scopedCache) Get(ctx context.Context, key client.ObjectKey, obj client.Object, opts ...client.GetOption) error {
-	inf, gvk, scope, found, err := c.base.getSharedInformer(obj)
+	inf, gvk, scope, err := c.base.getSharedInformer(obj)
 	if err != nil {
 		return fmt.Errorf("failed to get informer for %T %s: %w", obj, obj.GetObjectKind().GroupVersionKind(), err)
 	}
-	if !found {
-		return fmt.Errorf("no informer found for %T %s", obj, obj.GetObjectKind().GroupVersionKind())
-	}
 
 	cr := cacheReader{
 		indexer:          inf.GetIndexer(),
@@ -73,13 +70,10 @@ func (c *scopedCache) Get(ctx context.Context, key client.ObjectKey, obj client.
 
 // List returns a list of objects from the cache.
 func (c *scopedCache) List(ctx context.Context, list client.ObjectList, opts ...client.ListOption) error {
-	inf, gvk, scope, found, err := c.base.getSharedInformer(list)
+	inf, gvk, scope, err := c.base.getSharedInformer(list)
 	if err != nil {
 		return fmt.Errorf("failed to get informer for %T %s: %w", list, list.GetObjectKind().GroupVersionKind(), err)
 	}
-	if !found {
-		return fmt.Errorf("no informer found for %T %s", list, list.GetObjectKind().GroupVersionKind())
-	}
 
 	cr := cacheReader{
 		indexer:          inf.GetIndexer(),

virtualworkspace/provider.go

@@ -109,7 +109,7 @@ func (p *Provider) Run(ctx context.Context, mgr mcmanager.Manager) error {
 	if err != nil {
 		return fmt.Errorf("failed to get logical cluster informer: %w", err)
 	}
-	shInf, _, _, _, err := p.cache.getSharedInformer(p.object)
+	shInf, _, _, err := p.cache.getSharedInformer(p.object)
 	if err != nil {
 		return fmt.Errorf("failed to get shared informer: %w", err)
 	}

virtualworkspace/wildcard.go

@@ -43,7 +43,7 @@ import (
 // WildcardCache is a cache that operates on a /clusters/* endpoint.
 type WildcardCache interface {
 	cache.Cache
-	getSharedInformer(obj runtime.Object) (k8scache.SharedIndexInformer, schema.GroupVersionKind, apimeta.RESTScopeName, bool, error)
+	getSharedInformer(obj runtime.Object) (k8scache.SharedIndexInformer, schema.GroupVersionKind, apimeta.RESTScopeName, error)
 }
 
 // NewWildcardCache returns a cache.Cache that handles multi-cluster watches
@@ -80,6 +80,8 @@ func NewWildcardCache(config *rest.Config, opts cache.Options) (WildcardCache, e
 			Unstructured: make(map[schema.GroupVersionKind]k8scache.SharedIndexInformer),
 			Metadata:     make(map[schema.GroupVersionKind]k8scache.SharedIndexInformer),
 		},
+
+		readerFailOnMissingInformer: opts.ReaderFailOnMissingInformer,
 	}
 
 	opts.NewInformer = func(watcher k8scache.ListerWatcher, obj runtime.Object, duration time.Duration, indexers k8scache.Indexers) k8scache.SharedIndexInformer {
@@ -121,25 +123,60 @@ type wildcardCache struct {
 	scheme  *runtime.Scheme
 	mapper  apimeta.RESTMapper
 	tracker informerTracker
+
+	readerFailOnMissingInformer bool
 }
 
-func (c *wildcardCache) getSharedInformer(obj runtime.Object) (k8scache.SharedIndexInformer, schema.GroupVersionKind, apimeta.RESTScopeName, bool, error) {
+func (c *wildcardCache) getSharedInformer(obj runtime.Object) (k8scache.SharedIndexInformer, schema.GroupVersionKind, apimeta.RESTScopeName, error) {
 	gvk, err := apiutil.GVKForObject(obj, c.scheme)
 	if err != nil {
-		return nil, gvk, "", false, err
+		return nil, gvk, "", fmt.Errorf("failed to get GVK for object: %w", err)
 	}
 
+	// We need the non-list GVK, so chop off the "List" from the end of the kind.
+	gvk.Kind = strings.TrimSuffix(gvk.Kind, "List")
+
 	mapping, err := c.mapper.RESTMapping(gvk.GroupKind(), gvk.Version)
 	if err != nil {
-		return nil, gvk, "", false, err
+		return nil, gvk, "", fmt.Errorf("failed to get REST mapping: %w", err)
 	}
 
 	infs := c.tracker.informersByType(obj)
 	c.tracker.lock.RLock()
 	inf, ok := infs[gvk]
 	c.tracker.lock.RUnlock()
 
-	return inf, gvk, mapping.Scope.Name(), ok, nil
+	// we need to create a new informer here.
+	if !ok {
+		// we have been instructed to fail if the informer is missing.
+		if c.readerFailOnMissingInformer {
+			return nil, gvk, "", &cache.ErrResourceNotCached{}
+		}
+
+		// Let's generate a new object from the chopped GVK, since the original obj might be of *List type.
+		o, err := c.scheme.New(gvk)
+		if err != nil {
+			return nil, gvk, "", fmt.Errorf("failed to create object for GVK: %w", err)
+		}
+
+		// Call GetInformer, but we don't care about the output. We just need to make sure that our NewInformer
+		// func has been called, which registers the new informer in our tracker.
+		if _, err := c.Cache.GetInformer(context.TODO(), o.(client.Object)); err != nil {
+			return nil, gvk, "", fmt.Errorf("failed to create informer: %w", err)
+		}
+
+		// Now we should be able to find the informer.
+		infs := c.tracker.informersByType(obj)
+		c.tracker.lock.RLock()
+		inf, ok = infs[gvk]
+		c.tracker.lock.RUnlock()
+
+		if !ok {
+			return nil, gvk, "", fmt.Errorf("failed to find newly started informer for %v", gvk)
+		}
+	}
+
+	return inf, gvk, mapping.Scope.Name(), nil
 }
 
 // IndexField adds an index for the given object kind.