Merge pull request #32 from 3scale-sre/feat/runtimeconfig

feat: centralize scheme configuration via runtimeconfig

Author: 3scale-robot

README.md

@@ -207,10 +207,13 @@ template := resource.NewTemplateFromObjectFunction(func() *appsv1.Deployment {
 Set a global default scheme to avoid passing it to every constructor:
 
 ```go
-import myscheme "github.com/myorg/myoperator/pkg/scheme"
+import (
+    myscheme "github.com/myorg/myoperator/pkg/scheme"
+    "github.com/3scale-sre/basereconciler/runtimeconfig"
+)
 
 func init() {
-    resource.Scheme = myscheme.Scheme  // Now used by default for all templates
+    runtimeconfig.SetDefaultScheme(myscheme.Scheme)  // Now used by default for all templates
 }
 ```
 

reconciler/reconciler.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/3scale-sre/basereconciler/config"
 	"github.com/3scale-sre/basereconciler/resource"
+	"github.com/3scale-sre/basereconciler/runtimeconfig"
 	"github.com/3scale-sre/basereconciler/util"
 	"github.com/go-logr/logr"
 	corev1 "k8s.io/api/core/v1"
@@ -136,6 +137,7 @@ type Reconciler struct {
 
 // NewFromManager returns a new Reconciler from a controller-runtime manager.Manager
 func NewFromManager(mgr manager.Manager) *Reconciler {
+	runtimeconfig.EnsureDefaultScheme(mgr.GetScheme())
 	return &Reconciler{Client: mgr.GetClient(), Scheme: mgr.GetScheme(), Log: logr.Discard(), mgr: mgr}
 }
 

resource/doc.go

@@ -165,14 +165,17 @@
 //
 // # Scheme Management
 //
-// The package provides a convenient default scheme (resource.Scheme) that is used for GVK inference
-// when no explicit scheme is provided to template constructors. This defaults to the standard
-// Kubernetes scheme but can be overridden globally:
+// The package uses a convenient shared default scheme, managed by the runtimeconfig package, for
+// GVK inference when no explicit scheme is provided to template constructors. This defaults to the
+// standard Kubernetes scheme but can be overridden globally:
 //
-//	import myscheme "github.com/myorg/myoperator/pkg/scheme"
+//	import (
+//	    myscheme "github.com/myorg/myoperator/pkg/scheme"
+//	    "github.com/3scale-sre/basereconciler/runtimeconfig"
+//	)
 //
 //	func init() {
-//		resource.Scheme = myscheme.Scheme
+//		runtimeconfig.SetDefaultScheme(myscheme.Scheme)
 //	}
 //
 // This eliminates the need to pass scheme parameters to every template constructor while still
@@ -204,7 +207,7 @@
 //	import myscheme "github.com/myorg/myoperator/pkg/scheme"
 //
 //	func init() {
-//		resource.Scheme = myscheme.Scheme  // Now all templates use this by default
+//		runtimeconfig.SetDefaultScheme(myscheme.Scheme)  // Now all templates use this by default
 //	}
 //
 // Reconcile Resource (operation type determined by template configuration):
@@ -213,8 +216,8 @@
 //
 // # Advanced Features
 //
-// Default Scheme Management: Global default scheme (resource.Scheme) eliminates the need
-// to pass scheme parameters to every constructor while still allowing per-call overrides.
+// Default Scheme Management: Global default scheme via runtimeconfig eliminates the need to pass
+// scheme parameters to every constructor while still allowing per-call overrides.
 //
 // Automatic GVK Inference: Templates automatically determine their resource type from
 // the generic type parameter, reducing boilerplate and preventing mismatches.

resource/scheme.go

@@ -1,49 +1,13 @@
 package resource
 
 import (
+	"github.com/3scale-sre/basereconciler/runtimeconfig"
 	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/client-go/kubernetes/scheme"
 )
 
-// Scheme is the default runtime scheme used for GVK inference when no explicit scheme is provided
-// to template constructors (NewTemplate, NewTemplateFromObjectFunction) or other functions that
-// require scheme information.
-//
-// By default, this is set to the standard Kubernetes scheme (scheme.Scheme from client-go) which
-// includes all core Kubernetes types (Pod, Service, Deployment, etc.).
-//
-// Users can override this globally to include custom resources or use a different scheme:
-//
-//	import myscheme "github.com/myorg/myoperator/pkg/scheme"
-//
-//	func init() {
-//		resource.Scheme = myscheme.Scheme
-//	}
-//
-// This provides a convenient way to avoid passing the scheme parameter to every template constructor
-// while still allowing per-call overrides when needed.
-var Scheme *runtime.Scheme = scheme.Scheme
-
 // GetScheme returns the appropriate runtime scheme to use for GVK inference and other operations.
-// If explicit schemes are provided, it returns the first one. Otherwise, it returns the package
-// default scheme (resource.Scheme).
-//
-// This function is used internally by template constructors and other functions that need scheme
-// access, providing a consistent way to handle both explicit and default scheme scenarios.
-//
-// Examples:
-//
-//	// Uses the default scheme (resource.Scheme)
-//	scheme := GetScheme()
-//
-//	// Uses the provided scheme, ignoring the default
-//	scheme := GetScheme(myCustomScheme)
-//
-//	// Multiple schemes provided, uses the first one
-//	scheme := GetScheme(scheme1, scheme2) // Returns scheme1
+// If explicit schemes are provided, it returns the first one. Otherwise, it returns the shared
+// default scheme managed by the runtimeconfig package.
 func GetScheme(s ...*runtime.Scheme) *runtime.Scheme {
-	if len(s) > 0 {
-		return s[0]
-	}
-	return Scheme
+	return runtimeconfig.SelectScheme(s...)
 }

resource/template.go

@@ -6,6 +6,7 @@ import (
 	"reflect"
 
 	"github.com/3scale-sre/basereconciler/config"
+	"github.com/3scale-sre/basereconciler/runtimeconfig"
 	"github.com/3scale-sre/basereconciler/util"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -54,7 +55,7 @@ type TemplateInterface interface {
 	// GetGVK returns the GVK of the resource this template describes.
 	// If the template's GVK field is already set, it returns that value.
 	// Otherwise, it infers the GVK from the generic type T using the provided scheme,
-	// or the package default scheme (resource.Scheme) if no scheme is provided.
+	// or the package default scheme if no scheme is provided.
 	GetGVK(s ...*runtime.Scheme) schema.GroupVersionKind
 }
 
@@ -156,15 +157,15 @@ type Template[T client.Object] struct {
 // The template is enabled by default and automatically infers its GVK from the generic type T.
 //
 // Scheme handling:
-//   - If no scheme is provided, uses the package default (resource.Scheme)
+//   - If no scheme is provided, uses the shared default scheme managed by runtimeconfig
 //   - If a scheme is provided, uses that specific scheme for GVK inference
 //   - This allows for both convenient defaults and explicit overrides when needed
 func NewTemplate[T client.Object](tb TemplateBuilderFunction[T], scheme ...*runtime.Scheme) *Template[T] {
 	return &Template[T]{
 		TemplateBuilder: tb,
 		// default to true - resources should exist unless explicitly disabled
 		IsEnabled: true,
-		GVK:       inferGVKFromType[T](GetScheme(scheme...)),
+		GVK:       inferGVKFromType[T](runtimeconfig.SelectScheme(scheme...)),
 	}
 }
 
@@ -174,7 +175,7 @@ func NewTemplate[T client.Object](tb TemplateBuilderFunction[T], scheme ...*runt
 // from the generic type T.
 //
 // Scheme handling:
-//   - If no scheme is provided, uses the package default (resource.Scheme)
+//   - If no scheme is provided, uses the shared default scheme managed by runtimeconfig
 //   - If a scheme is provided, uses that specific scheme for GVK inference
 //   - This allows for both convenient defaults and explicit overrides when needed
 //
@@ -188,7 +189,7 @@ func NewTemplateFromObjectFunction[T client.Object](fn func() T, scheme ...*runt
 		TemplateBuilder: func(client.Object) (T, error) { return fn(), nil },
 		// default to true - resources should exist unless explicitly disabled
 		IsEnabled: true,
-		GVK:       inferGVKFromType[T](GetScheme(scheme...)),
+		GVK:       inferGVKFromType[T](runtimeconfig.SelectScheme(scheme...)),
 	}
 }
 
@@ -263,7 +264,7 @@ func (t *Template[T]) GetGVK(s ...*runtime.Scheme) schema.GroupVersionKind {
 	if t.GVK != (schema.GroupVersionKind{}) {
 		return t.GVK
 	}
-	gvk := inferGVKFromType[T](GetScheme(s...))
+	gvk := inferGVKFromType[T](runtimeconfig.SelectScheme(s...))
 	return gvk
 }
 

runtimeconfig/scheme.go

@@ -0,0 +1,58 @@
+package runtimeconfig
+
+import (
+	"sync"
+
+	"k8s.io/apimachinery/pkg/runtime"
+	clientgoscheme "k8s.io/client-go/kubernetes/scheme"
+)
+
+var (
+	schemeMu      sync.RWMutex
+	defaultScheme *runtime.Scheme = clientgoscheme.Scheme
+	schemeFrozen  bool
+)
+
+// DefaultScheme returns the current shared runtime scheme used across the basereconciler
+// packages. It is safe for concurrent use.
+func DefaultScheme() *runtime.Scheme {
+	schemeMu.RLock()
+	defer schemeMu.RUnlock()
+	return defaultScheme
+}
+
+// SetDefaultScheme overrides the shared runtime scheme. Once set, the scheme becomes frozen
+// and subsequent calls to EnsureDefaultScheme will not replace it. Passing a nil scheme is a no-op.
+func SetDefaultScheme(s *runtime.Scheme) {
+	if s == nil {
+		return
+	}
+	schemeMu.Lock()
+	defaultScheme = s
+	schemeFrozen = true
+	schemeMu.Unlock()
+}
+
+// EnsureDefaultScheme sets the shared runtime scheme only if it has not been customized yet.
+// This provides a first-one-wins behaviour that is useful when wiring a reconciler from a
+// controller-runtime manager. Passing a nil scheme is a no-op.
+func EnsureDefaultScheme(s *runtime.Scheme) {
+	if s == nil {
+		return
+	}
+	schemeMu.Lock()
+	if !schemeFrozen {
+		defaultScheme = s
+		schemeFrozen = true
+	}
+	schemeMu.Unlock()
+}
+
+// SelectScheme returns the first non-nil scheme from the provided list. If none are supplied,
+// it falls back to the shared default scheme.
+func SelectScheme(explicit ...*runtime.Scheme) *runtime.Scheme {
+	if len(explicit) > 0 && explicit[0] != nil {
+		return explicit[0]
+	}
+	return DefaultScheme()
+}

test/api/v1alpha1/example.com_tests.yaml

@@ -25,6 +25,7 @@ import (
 	"time"
 
 	"github.com/3scale-sre/basereconciler/reconciler"
+	"github.com/3scale-sre/basereconciler/runtimeconfig"
 	"github.com/goombaio/namegenerator"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
@@ -61,6 +62,11 @@ func TestAPIs(t *testing.T) {
 	RunSpecs(t, "Controller Suite")
 }
 
+func init() {
+	utilruntime.Must(v1alpha1.AddToScheme(scheme.Scheme))
+	runtimeconfig.SetDefaultScheme(scheme.Scheme)
+}
+
 var _ = BeforeSuite(func() {
 	logf.SetLogger(zap.New(zap.WriteTo(GinkgoWriter), zap.UseDevMode(true)))
 
@@ -80,10 +86,8 @@ var _ = BeforeSuite(func() {
 	Expect(err).NotTo(HaveOccurred())
 	Expect(cfg).NotTo(BeNil())
 
-	utilruntime.Must(v1alpha1.AddToScheme(scheme.Scheme))
-
 	mgr, err := ctrl.NewManager(cfg, ctrl.Options{
-		Scheme: scheme.Scheme,
+		Scheme: runtimeconfig.DefaultScheme(),
 		// Disable the metrics port to allow running the
 		// test suite in parallel
 		Metrics: metricsserver.Options{BindAddress: "0"},