refactor: simplify OpenFL-only code paths in server and client files

Remove unnecessary framework switch statements and embed.FS variables
since federatedLearningServer() and clusterWorkload() are now only
called for the OpenFL path.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Signed-off-by: Meng Yan <myan@redhat.com>

Author: yanmxa

federated-learning-controller/internal/controller/federatedlearning_client.go

@@ -2,7 +2,6 @@ package controller
 
 import (
 	"context"
-	"embed"
 	"fmt"
 	"net"
 	"reflect"
@@ -334,43 +333,35 @@ func (r *FederatedLearningReconciler) clusterWorkload(ctx context.Context, insta
 		obsSidecarImage = instance.ObjectMeta.Annotations[v1alpha1.AnnotationSidecarImage]
 	}
 
-	var clientParams any
-	var clientFS embed.FS
+	host, port, err := net.SplitHostPort(serverAddress)
+	if err != nil {
+		return fmt.Errorf("failed to parse server address: %w", err)
+	}
+	portUint, err := strconv.ParseUint(port, 10, 16)
+	if err != nil {
+		return fmt.Errorf("failed to parse server port: %w", err)
+	}
+	modelDir, _, err := getDirFile(instance.Spec.Server.Storage.ModelPath)
+	if err != nil {
+		return err
+	}
 
-	switch instance.Spec.Framework {
-	case flv1alpha1.OpenFL:
-		clientFS = manifests.OpenFLClientFiles
-		host, port, err := net.SplitHostPort(serverAddress)
-		if err != nil {
-			return fmt.Errorf("failed to parse server address: %w", err)
-		}
-		portUint, err := strconv.ParseUint(port, 10, 16)
-		if err != nil {
-			return fmt.Errorf("failed to parse server port: %w", err)
-		}
-		modelDir, _, err := getDirFile(instance.Spec.Server.Storage.ModelPath)
-		if err != nil {
-			return err
-		}
-		clientParams = &manifests.OpenFLClientParams{
-			ManifestName:       instance.Name,
-			ManifestNamespace:  clusterName,
-			ClientJobNamespace: instance.Namespace,
-			ClientJobName:      fmt.Sprintf("%s-client", instance.Name),
-			ClientJobImage:     instance.Spec.Client.Image,
-			ClientDataPath:     dataConfig,
-			ServerIP:           host,
-			ServerPort:         uint16(portUint),
-			ModelDir:           modelDir,
-			ObsSidecarImage:    obsSidecarImage,
-			ClientName:         clusterName,
-			NumberOfRounds:     instance.Spec.Server.Rounds,
-		}
-	default:
-		return fmt.Errorf("unsupported framework: %s", instance.Spec.Framework)
+	clientParams := &manifests.OpenFLClientParams{
+		ManifestName:       instance.Name,
+		ManifestNamespace:  clusterName,
+		ClientJobNamespace: instance.Namespace,
+		ClientJobName:      fmt.Sprintf("%s-client", instance.Name),
+		ClientJobImage:     instance.Spec.Client.Image,
+		ClientDataPath:     dataConfig,
+		ServerIP:           host,
+		ServerPort:         uint16(portUint),
+		ModelDir:           modelDir,
+		ObsSidecarImage:    obsSidecarImage,
+		ClientName:         clusterName,
+		NumberOfRounds:     instance.Spec.Server.Rounds,
 	}
 
-	render, deployer := applier.NewRenderer(clientFS), applier.NewDeployer(r.Client)
+	render, deployer := applier.NewRenderer(manifests.OpenFLClientFiles), applier.NewDeployer(r.Client)
 	unstructuredObjects, err := render.Render("", "", func(profile string) (interface{}, error) {
 		return clientParams, nil
 	})

federated-learning-controller/internal/controller/federatedlearning_server.go

@@ -2,7 +2,6 @@ package controller
 
 import (
 	"context"
-	"embed"
 	"fmt"
 	"sort"
 	"strings"
@@ -120,43 +119,36 @@ func (r *FederatedLearningReconciler) federatedLearningServer(ctx context.Contex
 		obsSidecarImage = instance.ObjectMeta.Annotations[v1alpha1.AnnotationSidecarImage]
 	}
 
-	var serverParams any
-	var serverFS embed.FS
+	clusters, err := r.getDecidedClusters(ctx, instance)
+	if err != nil {
+		return err
+	}
+	sort.Strings(clusters)
+	log.Infof("clusters: %+v", clusters)
 
-	switch instance.Spec.Framework {
-	case flv1alpha1.OpenFL:
-		serverFS = manifests.OpenFLServerFiles
-		clusters, err := r.getDecidedClusters(ctx, instance)
-		if err != nil {
-			return err
-		}
-		sort.Strings(clusters)
-		log.Infof("clusters: %+v", clusters)
-		// determine endpoint info (IP and port) prior to rendering, especially for NodePort
-		listenerIP, listenerPort, err := r.determineEndpointInfo(ctx, instance)
-		if err != nil {
-			return err
-		}
-		serverParams = &manifests.OpenFLServerParams{
-			Namespace:         instance.Namespace,
-			Name:              getSeverName(instance.Name),
-			Image:             instance.Spec.Server.Image,
-			NumberOfRounds:    instance.Spec.Server.Rounds,
-			StorageVolumeName: instance.Spec.Server.Storage.Name,
-			ListenerType:      string(instance.Spec.Server.Listeners[0].Type),
-			ListenerIP:        listenerIP,
-			ListenerPort:      listenerPort,
-			CreateService:     createService,
-			ModelDir:          modelDir,
-			ObsSidecarImage:   obsSidecarImage,
-			Collaborators:     strings.Join(clusters, ","),
-		}
-		log.Infof("server params: %+v", serverParams)
-	default:
-		return fmt.Errorf("unsupported framework: %s", instance.Spec.Framework)
+	// determine endpoint info (IP and port) prior to rendering, especially for NodePort
+	listenerIP, listenerPort, err := r.determineEndpointInfo(ctx, instance)
+	if err != nil {
+		return err
+	}
+
+	serverParams := &manifests.OpenFLServerParams{
+		Namespace:         instance.Namespace,
+		Name:              getSeverName(instance.Name),
+		Image:             instance.Spec.Server.Image,
+		NumberOfRounds:    instance.Spec.Server.Rounds,
+		StorageVolumeName: instance.Spec.Server.Storage.Name,
+		ListenerType:      string(instance.Spec.Server.Listeners[0].Type),
+		ListenerIP:        listenerIP,
+		ListenerPort:      listenerPort,
+		CreateService:     createService,
+		ModelDir:          modelDir,
+		ObsSidecarImage:   obsSidecarImage,
+		Collaborators:     strings.Join(clusters, ","),
 	}
+	log.Infof("server params: %+v", serverParams)
 
-	render, deployer := applier.NewRenderer(serverFS), applier.NewDeployer(r.Client)
+	render, deployer := applier.NewRenderer(manifests.OpenFLServerFiles), applier.NewDeployer(r.Client)
 	unstructuredObjects, err := render.Render("", "", func(profile string) (interface{}, error) {
 		return serverParams, nil
 	})