refactor: separate workload class from placement driver

internal/controller/components.go

@@ -14,12 +14,12 @@ import (
 type ComponentName string
 
 const (
-	Scheduler ComponentName = "scheduler"
-	PodWorker ComponentName = "pod-worker"
-	VMWorker  ComponentName = "vm-worker"
+	Scheduler         ComponentName = "scheduler"
+	KubernetesWorker  ComponentName = "kubernetes-worker"
+	OpenSandboxWorker ComponentName = "opensandbox-worker"
 )
 
-var defaultComponents = []ComponentName{Scheduler, PodWorker, VMWorker}
+var defaultComponents = []ComponentName{Scheduler, KubernetesWorker, OpenSandboxWorker}
 
 // Selection parses --components. An empty value enables all components.
 type Selection []ComponentName
@@ -31,6 +31,12 @@ func ParseSelection(value string) (Selection, error) {
 	var selected Selection
 	for _, raw := range strings.Split(value, ",") {
 		name := ComponentName(strings.TrimSpace(raw))
+		switch name {
+		case "pod-worker":
+			name = KubernetesWorker
+		case "vm-worker":
+			name = OpenSandboxWorker
+		}
 		if !slices.Contains(defaultComponents, name) {
 			return nil, fmt.Errorf("unknown controller component %q", name)
 		}

internal/controller/components_test.go

@@ -13,18 +13,18 @@ func TestParseSelectionDefaultsToAll(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		if len(selection) != 3 || selection[0] != Scheduler || selection[1] != PodWorker || selection[2] != VMWorker {
+		if len(selection) != 3 || selection[0] != Scheduler || selection[1] != KubernetesWorker || selection[2] != OpenSandboxWorker {
 			t.Fatalf("selection = %v", selection)
 		}
 	}
 }
 
 func TestParseSelectionAllowsOneOrMoreComponents(t *testing.T) {
-	selection, err := ParseSelection("vm-worker,scheduler,vm-worker")
+	selection, err := ParseSelection("opensandbox-worker,scheduler,opensandbox-worker")
 	if err != nil {
 		t.Fatal(err)
 	}
-	if len(selection) != 2 || selection[0] != VMWorker || selection[1] != Scheduler {
+	if len(selection) != 2 || selection[0] != OpenSandboxWorker || selection[1] != Scheduler {
 		t.Fatalf("selection = %v", selection)
 	}
 	if _, err := ParseSelection("webhook"); err == nil {
@@ -32,6 +32,16 @@ func TestParseSelectionAllowsOneOrMoreComponents(t *testing.T) {
 	}
 }
 
+func TestParseSelectionNormalizesLegacyWorkerNames(t *testing.T) {
+	selection, err := ParseSelection("pod-worker,vm-worker")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(selection) != 2 || selection[0] != KubernetesWorker || selection[1] != OpenSandboxWorker {
+		t.Fatalf("selection = %v", selection)
+	}
+}
+
 type componentFunc func(context.Context) error
 
 func (f componentFunc) Run(ctx context.Context) error { return f(ctx) }
@@ -45,14 +55,14 @@ func TestRunStartsSelectedComponentsAndCancelsPeers(t *testing.T) {
 			started <- Scheduler
 			return errors.New("poll failed")
 		}),
-		PodWorker: componentFunc(func(ctx context.Context) error {
-			started <- PodWorker
+		KubernetesWorker: componentFunc(func(ctx context.Context) error {
+			started <- KubernetesWorker
 			<-ctx.Done()
 			once.Do(func() { close(peerStopped) })
 			return ctx.Err()
 		}),
 	}
-	err := Run(context.Background(), Selection{Scheduler, PodWorker}, registry)
+	err := Run(context.Background(), Selection{Scheduler, KubernetesWorker}, registry)
 	if err == nil || !errors.Is(err, context.Canceled) && err.Error() != "component scheduler: poll failed" {
 		t.Fatalf("Run() error = %v", err)
 	}