Optimize Kubernetes scheme creation with configuration-based caching

Add sync.Map-based cache for runtime.Scheme objects indexed by
ClientOptions configuration. This eliminates repeated scheme creation
across different commands using the same configuration.

Changes:
- NewSchemeWithTypes() now caches schemes by configuration key
- Add schemeKey type to uniquely identify scheme configurations
- Add TestNewSchemeWithTypesCaching tests to verify caching

Impact: Reduces allocations for ~19 client creation calls across
different commands that use the same scheme configuration.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: Joeavaikath

cmd/shared/client.go

@@ -20,6 +20,7 @@ import (
 	"context"
 	"fmt"
 	"net"
+	"sync"
 	"time"
 
 	nacv1alpha1 "github.com/migtools/oadp-non-admin/api/v1alpha1"
@@ -31,6 +32,18 @@ import (
 	kbclient "sigs.k8s.io/controller-runtime/pkg/client"
 )
 
+// schemeKey uniquely identifies a scheme configuration
+type schemeKey struct {
+	hasNonAdmin bool
+	hasVelero   bool
+	hasCore     bool
+}
+
+var (
+	// Cache schemes by configuration
+	schemeCache sync.Map // map[schemeKey]*runtime.Scheme
+)
+
 // ClientOptions holds configuration for creating Kubernetes clients
 type ClientOptions struct {
 	// IncludeNonAdminTypes adds OADP NonAdmin CRD types to the scheme
@@ -122,6 +135,19 @@ func NewClientWithFullScheme(f client.Factory) (kbclient.WithWatch, error) {
 
 // NewSchemeWithTypes creates a new runtime scheme with the specified types
 func NewSchemeWithTypes(opts ClientOptions) (*runtime.Scheme, error) {
+	// Create cache key from options
+	key := schemeKey{
+		hasNonAdmin: opts.IncludeNonAdminTypes,
+		hasVelero:   opts.IncludeVeleroTypes,
+		hasCore:     opts.IncludeCoreTypes,
+	}
+
+	// Try cache first
+	if cached, ok := schemeCache.Load(key); ok {
+		return cached.(*runtime.Scheme), nil
+	}
+
+	// Create new scheme
 	scheme := runtime.NewScheme()
 
 	if opts.IncludeNonAdminTypes {
@@ -142,7 +168,9 @@ func NewSchemeWithTypes(opts ClientOptions) (*runtime.Scheme, error) {
 		}
 	}
 
-	return scheme, nil
+	// Store in cache (handles race conditions)
+	actual, _ := schemeCache.LoadOrStore(key, scheme)
+	return actual.(*runtime.Scheme), nil
 }
 
 // GetCurrentNamespace gets the current namespace from the kubeconfig context

cmd/shared/client_test.go

@@ -0,0 +1,115 @@
+/*
+Copyright 2025 The OADP CLI Contributors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package shared
+
+import (
+	"testing"
+)
+
+// TestNewSchemeWithTypesCaching verifies that schemes are cached by configuration
+func TestNewSchemeWithTypesCaching(t *testing.T) {
+	opts := ClientOptions{
+		IncludeNonAdminTypes: true,
+		IncludeVeleroTypes:   true,
+	}
+
+	scheme1, err1 := NewSchemeWithTypes(opts)
+	scheme2, err2 := NewSchemeWithTypes(opts)
+
+	if err1 != nil || err2 != nil {
+		t.Fatal("Unexpected error creating schemes")
+	}
+
+	if scheme1 != scheme2 {
+		t.Error("Expected same scheme instance for same options")
+	}
+}
+
+// TestNewSchemeWithTypesCachingDifferentOptions verifies different options yield different schemes
+func TestNewSchemeWithTypesCachingDifferentOptions(t *testing.T) {
+	opts1 := ClientOptions{
+		IncludeNonAdminTypes: true,
+		IncludeVeleroTypes:   true,
+	}
+
+	opts2 := ClientOptions{
+		IncludeNonAdminTypes: true,
+		IncludeVeleroTypes:   false,
+	}
+
+	scheme1, err1 := NewSchemeWithTypes(opts1)
+	scheme2, err2 := NewSchemeWithTypes(opts2)
+
+	if err1 != nil || err2 != nil {
+		t.Fatal("Unexpected error creating schemes")
+	}
+
+	if scheme1 == scheme2 {
+		t.Error("Expected different scheme instances for different options")
+	}
+}
+
+// TestNewSchemeWithTypes verifies that the function creates schemes with correct types
+func TestNewSchemeWithTypes(t *testing.T) {
+	tests := []struct {
+		name string
+		opts ClientOptions
+	}{
+		{
+			name: "NonAdmin types only",
+			opts: ClientOptions{
+				IncludeNonAdminTypes: true,
+			},
+		},
+		{
+			name: "Velero types only",
+			opts: ClientOptions{
+				IncludeVeleroTypes: true,
+			},
+		},
+		{
+			name: "Core types only",
+			opts: ClientOptions{
+				IncludeCoreTypes: true,
+			},
+		},
+		{
+			name: "All types",
+			opts: ClientOptions{
+				IncludeNonAdminTypes: true,
+				IncludeVeleroTypes:   true,
+				IncludeCoreTypes:     true,
+			},
+		},
+		{
+			name: "No types",
+			opts: ClientOptions{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			scheme, err := NewSchemeWithTypes(tt.opts)
+			if err != nil {
+				t.Errorf("NewSchemeWithTypes() unexpected error: %v", err)
+			}
+			if scheme == nil {
+				t.Error("NewSchemeWithTypes() returned nil scheme")
+			}
+		})
+	}
+}