Fix teardown to clean up operator namespace

internal/component/component.go

@@ -5,7 +5,8 @@ import "fmt"
 type Component int
 
 const (
-	All Component = iota
+	Both Component = iota
+	All
 	Central
 	SecuredCluster
 	Operator
@@ -14,7 +15,9 @@ const (
 func FromArgs(args []string) (Component, error) {
 	if len(args) > 0 {
 		switch args[0] {
-		case "both", "all":
+		case "both":
+			return Both, nil
+		case "all":
 			return All, nil
 		case "central":
 			return Central, nil
@@ -31,8 +34,10 @@ func FromArgs(args []string) (Component, error) {
 
 func (c Component) String() string {
 	switch c {
-	case All:
+	case Both:
 		return "Central and Secured Cluster"
+	case All:
+		return "Central, Secured Cluster, and Operator"
 	case Central:
 		return "Central"
 	case SecuredCluster:
@@ -45,27 +50,17 @@ func (c Component) String() string {
 }
 
 func (c Component) IncludesCentral() bool {
-	if c == SecuredCluster || c == Operator {
-		return false
-	}
-	return true
+	return c == Both || c == All || c == Central
 }
 
 func (c Component) IncludesSensor() bool {
-	if c == Central || c == Operator {
-		return false
-	}
-	return true
-}
-
-func (c Component) IncludesOperator() bool {
-	return c == Operator || c == All
+	return c == Both || c == All || c == SecuredCluster
 }
 
 func (c Component) IncludesOperatorExplicitly() bool {
 	return c == Operator
 }
 
 func (c Component) IncludesBothCentralAndSensor() bool {
-	return c == Central || c == SecuredCluster || c == All
+	return c == Both || c == All
 }

internal/deployer/deploy_via_operator.go

@@ -87,7 +87,7 @@ func (d *Deployer) ensureOperatorDeployed(ctx context.Context) error {
 				return fmt.Errorf("failed to deploy operator via OLM: %w", err)
 			}
 		} else {
-			if err := d.deployOperator(ctx); err != nil {
+			if err := d.deployOperatorNonOLM(ctx); err != nil {
 				return fmt.Errorf("failed to deploy operator: %w", err)
 			}
 		}
@@ -100,10 +100,6 @@ func (d *Deployer) ensureOperatorDeployed(ctx context.Context) error {
 func (d *Deployer) deployCentralOperator(ctx context.Context, resources, exposure string) error {
 	d.logger.Info("🚀 Deploying Central via Operator...")
 
-	if err := d.ensureOperatorDeployed(ctx); err != nil {
-		return err
-	}
-
 	if err := d.prepareNamespace(ctx, d.centralNamespace); err != nil {
 		return fmt.Errorf("failed to prepare namespace: %w", err)
 	}
@@ -604,10 +600,6 @@ func (d *Deployer) configureCentralEndpoint(ctx context.Context, exposure string
 func (d *Deployer) deploySecuredClusterOperator(ctx context.Context, resources string) error {
 	d.logger.Info("🚀 Deploying SecuredCluster via Operator...")
 
-	if err := d.ensureOperatorDeployed(ctx); err != nil {
-		return err
-	}
-
 	if err := d.prepareNamespace(ctx, d.sensorNamespace); err != nil {
 		return fmt.Errorf("failed to prepare namespace: %w", err)
 	}

internal/deployer/deployer.go

@@ -8,6 +8,7 @@ import (
 	"os"
 	"os/exec"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/fatih/color"
@@ -571,9 +572,19 @@ func (d *Deployer) Deploy(ctx context.Context, components component.Component, r
 
 	d.logger.Infof("Initiating deployment of %s", components)
 
-	if components.IncludesOperator() {
+	// If only deploying operator, use the operator-only flow
+	if components.IncludesOperatorExplicitly() {
 		return d.deployOperatorOnly(ctx)
 	}
+
+	// Deploy operator first if needed (unless using Helm)
+	// Operator is required for central/sensor deployments when not using Helm
+	if !d.useHelm {
+		if err := d.ensureOperatorDeployed(ctx); err != nil {
+			return fmt.Errorf("failed to deploy operator: %w", err)
+		}
+	}
+
 	if components.IncludesCentral() {
 		if err := d.deployCentral(ctx, resources, exposure); err != nil {
 			return fmt.Errorf("failed to deploy central: %w", err)
@@ -660,11 +671,40 @@ func (d *Deployer) Teardown(ctx context.Context, components component.Component)
 		return d.teardownCentral(ctx)
 	case component.SecuredCluster:
 		return d.teardownSecuredCluster(ctx)
-	case component.All:
-		if err := d.teardownSecuredCluster(ctx); err != nil {
-			d.logger.Warningf("Error tearing down secured cluster: %v", err)
+	case component.Both, component.All:
+		// Tear down components in parallel for better performance
+		var wg sync.WaitGroup
+
+		// Always tear down central and sensor
+		wg.Add(2)
+
+		go func() {
+			defer wg.Done()
+			if err := d.teardownSecuredCluster(ctx); err != nil {
+				d.logger.Warningf("Error tearing down secured cluster: %v", err)
+			}
+		}()
+
+		go func() {
+			defer wg.Done()
+			if err := d.teardownCentral(ctx); err != nil {
+				d.logger.Warningf("Error tearing down central: %v", err)
+			}
+		}()
+
+		// For 'all', also tear down the operator in parallel
+		if components == component.All {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				if err := d.teardownOperator(ctx); err != nil {
+					d.logger.Warningf("Error tearing down operator: %v", err)
+				}
+			}()
 		}
-		return d.teardownCentral(ctx)
+
+		wg.Wait()
+		return nil
 	default:
 		return fmt.Errorf("unknown component: %s", components)
 	}

internal/deployer/operator.go

@@ -24,8 +24,8 @@ const (
 	operatorDeploymentName  = "rhacs-operator-controller-manager"
 )
 
-// deployOperator deploys the RHACS operator
-func (d *Deployer) deployOperator(ctx context.Context) error {
+// deployOperatorNonOLM deploys the RHACS operator without OLM
+func (d *Deployer) deployOperatorNonOLM(ctx context.Context) error {
 	d.logger.Infof("Operator tag: %s", d.operatorTag)
 	if d.useKonflux {
 		if err := d.ensureKonfluxImageRewriting(ctx); err != nil {
@@ -396,6 +396,7 @@ metadata:
   name: %s
   labels:
     name: %s
+    app.kubernetes.io/managed-by: roxie
 `, operatorNamespace, operatorNamespace)
 
 	_, err := d.runKubectl(ctx, KubectlOptions{
@@ -634,3 +635,17 @@ func (d *Deployer) teardownOperatorNonOLM(ctx context.Context) error {
 	d.logger.Success("✓ Non-OLM operator resources removed")
 	return nil
 }
+
+// teardownOperator removes the operator if it exists, detecting the deployment mode automatically.
+func (d *Deployer) teardownOperator(ctx context.Context) error {
+	operatorExists, operatorMode := d.detectOperatorDeploymentMode(ctx)
+	if !operatorExists {
+		d.logger.Dim("No operator deployment found, skipping operator teardown")
+		return nil
+	}
+
+	if operatorMode == OperatorModeOLM {
+		return d.teardownOperatorOLM(ctx)
+	}
+	return d.teardownOperatorNonOLM(ctx)
+}