feat: moved to multicluster-provider

cmd/gateway.go

@@ -65,7 +65,7 @@ func initializeSentry(ctx context.Context, log *logger.Logger) error {
 		defaultCfg.Image.Name, defaultCfg.Image.Tag,
 	)
 	if err != nil {
-		log.Fatal().Err(err).Msg("Sentry init failed")
+		return fmt.Errorf("sentry init failed: %w", err)
 	}
 
 	defer openmfpcontext.Recover(log)
@@ -76,14 +76,14 @@ func initializeTracing(ctx context.Context, log *logger.Logger) (func(ctx contex
 	if defaultCfg.Tracing.Enabled {
 		shutdown, err := traces.InitProvider(ctx, defaultCfg.Tracing.Collector)
 		if err != nil {
-			log.Fatal().Err(err).Msg("unable to start gRPC-Sidecar TracerProvider")
+			return nil, fmt.Errorf("unable to start gRPC-Sidecar TracerProvider: %w", err)
 		}
 		return shutdown, nil
 	}
 
 	shutdown, err := traces.InitLocalProvider(ctx, defaultCfg.Tracing.Collector, false)
 	if err != nil {
-		log.Fatal().Err(err).Msg("unable to start local TracerProvider")
+		return nil, fmt.Errorf("unable to start local TracerProvider: %w", err)
 	}
 	return shutdown, nil
 }

cmd/listener.go

@@ -3,6 +3,7 @@ package cmd
 import (
 	"context"
 	"crypto/tls"
+	"errors"
 
 	kcpapis "github.com/kcp-dev/kcp/sdk/apis/apis/v1alpha1"
 	kcpcore "github.com/kcp-dev/kcp/sdk/apis/core/v1alpha1"
@@ -77,7 +78,20 @@ var listenCmd = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		log.Info().Str("LogLevel", log.GetLevel().String()).Msg("Starting the Listener...")
 
-		ctx := ctrl.SetupSignalHandler()
+		// Set up signal handler and create a cancellable context for coordinated shutdown
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+		// Error channel to distinguish error-triggered shutdown from normal signals
+		errCh := make(chan error, 1)
+
+		// Set up signal handling
+		signalCtx := ctrl.SetupSignalHandler()
+		go func() {
+			<-signalCtx.Done()
+			log.Info().Msg("received shutdown signal, initiating graceful shutdown")
+			cancel()
+		}()
+
 		restCfg := ctrl.GetConfigOrDie()
 
 		mgrOpts := ctrl.Options{
@@ -105,23 +119,32 @@ var listenCmd = &cobra.Command{
 		}
 
 		// Create the appropriate reconciler based on configuration
-		var reconcilerInstance reconciler.CustomReconciler
+		var reconcilerInstance reconciler.ControllerProvider
 		if appCfg.EnableKcp {
-			kcpReconciler, err := kcp.NewKCPReconciler(appCfg, reconcilerOpts, log)
+			kcpManager, err := kcp.NewKCPManager(appCfg, reconcilerOpts, log)
 			if err != nil {
-				log.Fatal().Err(err).Msg("unable to create KCP reconciler")
+				log.Fatal().Err(err).Msg("unable to create KCP manager")
 			}
+			reconcilerInstance = kcpManager
 
 			// Start virtual workspace watching if path is configured
 			if appCfg.Listener.VirtualWorkspacesConfigPath != "" {
 				go func() {
-					if err := kcpReconciler.StartVirtualWorkspaceWatching(ctx, appCfg.Listener.VirtualWorkspacesConfigPath); err != nil {
-						log.Fatal().Err(err).Msg("failed to start virtual workspace watching")
+					if err := kcpManager.StartVirtualWorkspaceWatching(ctx, appCfg.Listener.VirtualWorkspacesConfigPath); err != nil {
+						if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
+							log.Info().Msg("virtual workspace watching stopped due to context cancellation")
+							cancel()
+						} else {
+							log.Error().Err(err).Msg("virtual workspace watching failed, initiating graceful shutdown")
+							select {
+							case errCh <- err:
+							default:
+							}
+							cancel()
+						}
 					}
 				}()
 			}
-
-			reconcilerInstance = kcpReconciler
 		} else {
 			ioHandler, err := workspacefile.NewIOHandler(appCfg.OpenApiDefinitionsPath)
 			if err != nil {
@@ -135,14 +158,25 @@ var listenCmd = &cobra.Command{
 		}
 
 		// Setup reconciler with its own manager and start everything
+		// Use the original context for the manager - it will be cancelled if watcher fails
 		if err := startManagerWithReconciler(ctx, reconcilerInstance); err != nil {
 			log.Fatal().Err(err).Msg("failed to start manager with reconciler")
 		}
+
+		// Determine exit reason: error-triggered vs. normal signal
+		select {
+		case err := <-errCh:
+			if err != nil {
+				log.Fatal().Err(err).Msg("exiting due to critical component failure")
+			}
+		default:
+			log.Info().Msg("graceful shutdown complete")
+		}
 	},
 }
 
 // startManagerWithReconciler handles the common manager setup and start operations
-func startManagerWithReconciler(ctx context.Context, reconciler reconciler.CustomReconciler) error {
+func startManagerWithReconciler(ctx context.Context, reconciler reconciler.ControllerProvider) error {
 	mgr := reconciler.GetManager()
 
 	if err := reconciler.SetupWithManager(mgr); err != nil {

cmd/root.go

@@ -78,6 +78,7 @@ func initConfig() {
 	// Gateway URL
 	v.SetDefault("gateway-url-virtual-workspace-prefix", "virtual-workspace")
 	v.SetDefault("gateway-url-default-kcp-workspace", "root")
+	v.SetDefault("gateway-url-kcp-workspace-pattern", "root:orgs:{org}")
 	v.SetDefault("gateway-url-graphql-suffix", "graphql")
 }
 

common/auth/export_test.go

@@ -0,0 +1,6 @@
+package auth
+
+// ExtractCAFromKubeconfigB64ForTest exposes the extractCAFromKubeconfigB64 method for testing
+func (m *MetadataInjector) ExtractCAFromKubeconfigB64ForTest(kubeconfigB64 string) []byte {
+	return m.extractCAFromKubeconfigB64(kubeconfigB64)
+}

common/auth/metadata_injector_test.go

@@ -623,3 +623,97 @@ users:
 		assert.Nil(t, result)
 	})
 }
+
+func TestMetadataInjector_ExtractCAFromKubeconfigB64(t *testing.T) {
+	log := testlogger.New().HideLogOutput().Logger
+	injector := NewMetadataInjector(log, nil)
+
+	tests := []struct {
+		name           string
+		kubeconfigB64  string
+		expectedResult bool // true if CA data should be extracted, false if nil
+		expectError    bool // true if we expect a warning to be logged
+	}{
+		{
+			name: "valid_kubeconfig_with_ca_data",
+			kubeconfigB64: base64.StdEncoding.EncodeToString([]byte(`
+apiVersion: v1
+kind: Config
+clusters:
+- cluster:
+    certificate-authority-data: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0t
+    server: https://example.com
+  name: test-cluster
+contexts:
+- context:
+    cluster: test-cluster
+    user: test-user
+  name: test-context
+current-context: test-context
+users:
+- name: test-user
+  user:
+    token: test-token
+`)),
+			expectedResult: true,
+			expectError:    false,
+		},
+		{
+			name: "valid_kubeconfig_without_ca_data",
+			kubeconfigB64: base64.StdEncoding.EncodeToString([]byte(`
+apiVersion: v1
+kind: Config
+clusters:
+- cluster:
+    server: https://example.com
+  name: test-cluster
+contexts:
+- context:
+    cluster: test-cluster
+    user: test-user
+  name: test-context
+current-context: test-context
+users:
+- name: test-user
+  user:
+    token: test-token
+`)),
+			expectedResult: false,
+			expectError:    false,
+		},
+		{
+			name:           "invalid_base64",
+			kubeconfigB64:  "invalid-base64-!@#$%",
+			expectedResult: false,
+			expectError:    true,
+		},
+		{
+			name:           "empty_string",
+			kubeconfigB64:  "",
+			expectedResult: false,
+			expectError:    false,
+		},
+		{
+			name: "invalid_yaml_content",
+			kubeconfigB64: base64.StdEncoding.EncodeToString([]byte(`
+invalid yaml content
+not a kubeconfig
+`)),
+			expectedResult: false,
+			expectError:    false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := injector.ExtractCAFromKubeconfigB64ForTest(tt.kubeconfigB64)
+
+			if tt.expectedResult {
+				assert.NotNil(t, result, "Expected CA data to be extracted")
+				assert.Greater(t, len(result), 0, "Expected non-empty CA data")
+			} else {
+				assert.Nil(t, result, "Expected no CA data to be extracted")
+			}
+		})
+	}
+}

common/config/config.go

@@ -9,6 +9,7 @@ type Config struct {
 	Url struct {
 		VirtualWorkspacePrefix string `mapstructure:"gateway-url-virtual-workspace-prefix"`
 		DefaultKcpWorkspace    string `mapstructure:"gateway-url-default-kcp-workspace"`
+		KcpWorkspacePattern    string `mapstructure:"gateway-url-kcp-workspace-pattern"`
 		GraphqlSuffix          string `mapstructure:"gateway-url-graphql-suffix"`
 	} `mapstructure:",squash"`