manager: use our RESTMapper

Switch to using our caching RESTMapper in the manager. If one of our
controllers encounters a Kind that was added to the apiserver after the
manager retrieved and cached the API discovery document, it won't be
able to work with it because this new Kind is not in the cache. We need
to invalidate and flush the cache in this scenario.

Signed-off-by: Andy Goldstein <[email protected]>

Author: ncdc

cmd/clusterctl/clientcmd/configutil.go

@@ -56,8 +56,13 @@ func NewControllerRuntimeClient(kubeconfigPath string, overrides clientcmd.Confi
 		return nil, err
 	}
 
+	mapper, err := restmapper.NewCached(config)
+	if err != nil {
+		return nil, err
+	}
+
 	return client.New(config, client.Options{
-		Mapper: restmapper.NewCached(config),
+		Mapper: mapper,
 	})
 }
 

main.go

@@ -27,6 +27,7 @@ import (
 	"k8s.io/klog/klogr"
 	clusterv1 "sigs.k8s.io/cluster-api/api/v1alpha2"
 	"sigs.k8s.io/cluster-api/controllers"
+	"sigs.k8s.io/cluster-api/util/restmapper"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/controller"
 	// +kubebuilder:scaffold:imports
@@ -99,6 +100,7 @@ func main() {
 	mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{
 		Scheme:             scheme,
 		MetricsBindAddress: metricsAddr,
+		MapperProvider:     restmapper.NewCached,
 		LeaderElection:     enableLeaderElection,
 		Namespace:          watchNamespace,
 		SyncPeriod:         &syncPeriod,

util/restmapper/cached.go

@@ -27,28 +27,28 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/log"
 )
 
-func NewCached(config *rest.Config) meta.RESTMapper {
+func NewCached(config *rest.Config) (meta.RESTMapper, error) {
 	c := &cached{
 		limiter: rate.NewLimiter(rate.Limit(1), 2),
 		factory: func() (meta.RESTMapper, error) {
 			return apiutil.NewDiscoveryRESTMapper(config)
 		},
 	}
-	c.flush()
-	return c
+	return c, c.flush()
 }
 
 type cached struct {
-	sync.Mutex
-
 	limiter *rate.Limiter
 	factory func() (meta.RESTMapper, error)
-	mapper  meta.RESTMapper
+
+	// lock guards mapper
+	lock   sync.Mutex
+	mapper meta.RESTMapper
 }
 
 func (c *cached) flush() error {
-	c.Lock()
-	defer c.Unlock()
+	c.lock.Lock()
+	defer c.lock.Unlock()
 
 	var err error
 	if c.mapper == nil || c.limiter.Allow() {