ECOPROJECT-3992 | feat: sizer - support hosted control plane nodes

Signed-off-by: Ronen Avraham <ravraham@redhat.com>

Author: ronenav

api/v1alpha1/openapi.yaml

@@ -1765,6 +1765,10 @@ components:
           description: Number of control plane nodes (1 for single node, 3 for HA)
           x-oapi-codegen-extra-tags:
             validate: "omitempty,oneof=1 3"
+        hostedControlPlane:
+          type: boolean
+          default: false
+          description: When true, control plane is hosted elsewhere; only worker nodes are sized.
       required:
         - clusterId
         - cpuOverCommitRatio

api/v1alpha1/spec.gen.go

@@ -152,6 +152,9 @@ func ClusterRequirementsRequestToForm(apiReq v1alpha1.ClusterRequirementsRequest
 	} else {
 		form.ControlPlaneNodeCount = int(v1alpha1.N3)
 	}
+	if apiReq.HostedControlPlane != nil {
+		form.HostedControlPlane = *apiReq.HostedControlPlane
+	}
 	return form
 }
 

api/v1alpha1/types.gen.go

@@ -56,13 +56,16 @@ func (h *ServiceHandler) CalculateAssessmentClusterRequirements(ctx context.Cont
 	}
 
 	// Validate controlPlaneNodeCount (API enum handles this in production, but tests bypass middleware)
-	if request.Body.ControlPlaneNodeCount != nil {
-		count := int(*request.Body.ControlPlaneNodeCount)
-		if count != 1 && count != 3 {
-			logger.Error(fmt.Errorf("invalid controlPlaneNodeCount: %d", count)).Log()
-			return server.CalculateAssessmentClusterRequirements400JSONResponse{
-				Message: fmt.Sprintf("invalid controlPlaneNodeCount: %d", count),
-			}, nil
+	// Skip when hosted control plane; those fields are ignored.
+	if request.Body.HostedControlPlane == nil || !*request.Body.HostedControlPlane {
+		if request.Body.ControlPlaneNodeCount != nil {
+			count := int(*request.Body.ControlPlaneNodeCount)
+			if count != 1 && count != 3 {
+				logger.Error(fmt.Errorf("invalid controlPlaneNodeCount: %d", count)).Log()
+				return server.CalculateAssessmentClusterRequirements400JSONResponse{
+					Message: fmt.Sprintf("invalid controlPlaneNodeCount: %d", count),
+				}, nil
+			}
 		}
 	}
 

internal/handlers/v1alpha1/mappers/inbound.go

@@ -354,6 +354,44 @@ var _ = Describe("sizer handler", func() {
 				Expect(successResp.ResourceConsumption.Memory).To(Equal(200.0))
 			})
 
+			It("returns 200 with hostedControlPlane true and zero control plane nodes in response", func() {
+				hostedTrue := true
+				invalidCount := api.ClusterRequirementsRequestControlPlaneNodeCount(2)
+				request := &api.ClusterRequirementsRequest{
+					ClusterId:             clusterID,
+					CpuOverCommitRatio:    api.CpuOneToFour,
+					MemoryOverCommitRatio: api.MemoryOneToTwo,
+					WorkerNodeCPU:         8,
+					WorkerNodeMemory:      16,
+					HostedControlPlane:    &hostedTrue,
+					ControlPlaneNodeCount: &invalidCount,
+				}
+
+				mockStore.assessments[assessmentID] = createTestAssessment(assessmentID, user.Username, user.Organization, clusterID)
+				testServer = createTestSizerServer(createTestSizerResponse(4, 4, 0, 40, 80), http.StatusOK, false)
+				sizerClient = client.NewSizerClient(testServer.URL, 5*time.Second)
+				handler = handlers.NewServiceHandler(
+					nil,
+					service.NewAssessmentService(mockStore, nil),
+					nil,
+					service.NewSizerService(sizerClient, mockStore),
+					nil,
+				)
+
+				resp, err := handler.CalculateAssessmentClusterRequirements(ctx, server.CalculateAssessmentClusterRequirementsRequestObject{
+					Id:   assessmentID,
+					Body: request,
+				})
+
+				Expect(err).To(BeNil())
+				Expect(resp).NotTo(BeNil())
+				successResp, ok := resp.(server.CalculateAssessmentClusterRequirements200JSONResponse)
+				Expect(ok).To(BeTrue())
+				Expect(successResp.ClusterSizing.ControlPlaneNodes).To(Equal(0))
+				Expect(successResp.ClusterSizing.WorkerNodes).To(Equal(6))
+				Expect(successResp.ClusterSizing.TotalNodes).To(Equal(6))
+			})
+
 			intPtr := func(v int) *int { return &v }
 			cases := []struct {
 				name    string

internal/handlers/v1alpha1/sizer.go

@@ -235,6 +235,7 @@ type ClusterRequirementsRequestForm struct {
 	ControlPlaneCPU         int
 	ControlPlaneMemory      int
 	ControlPlaneNodeCount   int
+	HostedControlPlane      bool
 }
 
 type ClusterRequirementsResponseForm struct {

internal/handlers/v1alpha1/sizer_test.go

@@ -173,7 +173,8 @@ func (s *SizerService) CalculateClusterRequirements(
 		return nil, NewErrInvalidClusterInventory(req.ClusterID, "cluster has no VMs or no CPU/Memory resources and cannot be used for migration planning")
 	}
 
-	includeControlPlane := true
+	includeControlPlane := !req.HostedControlPlane
+	effectiveCPNodeCount := effectiveControlPlaneNodeCount(req)
 	controlPlaneSchedulable := req.ControlPlaneSchedulable
 
 	controlPlaneCPU := req.ControlPlaneCPU
@@ -201,7 +202,8 @@ func (s *SizerService) CalculateClusterRequirements(
 		WithString("worker_node_effective_cpu", fmt.Sprintf("%.2f", effectiveCPU)).
 		WithInt("worker_node_memory", req.WorkerNodeMemory).
 		WithBool("control_plane_schedulable", controlPlaneSchedulable).
-		WithInt("control_plane_node_count", req.ControlPlaneNodeCount).
+		WithBool("hosted_control_plane", req.HostedControlPlane).
+		WithInt("control_plane_node_count", effectiveCPNodeCount).
 		Build()
 
 	// Use effective CPU for all calculations
@@ -255,7 +257,7 @@ func (s *SizerService) CalculateClusterRequirements(
 		controlPlaneSchedulable,
 		controlPlaneCPU,
 		controlPlaneMemory,
-		req.ControlPlaneNodeCount,
+		effectiveCPNodeCount,
 	)
 
 	// Call sizer service
@@ -268,7 +270,7 @@ func (s *SizerService) CalculateClusterRequirements(
 		return nil, fmt.Errorf("sizer service returned empty response")
 	}
 
-	transformed := s.transformSizerResponse(sizerResponse, req.ControlPlaneNodeCount)
+	transformed := s.transformSizerResponse(sizerResponse, effectiveCPNodeCount)
 
 	if transformed.ClusterSizing.TotalNodes > MaxNodeCount {
 		minNodeCPU, minNodeMemory := s.calculateMinimumNodeSize(
@@ -506,6 +508,13 @@ func (s *SizerService) formatNodeSizeError(workerCPU, workerMemory, inventoryCPU
 	return NewErrInvalidRequest(message)
 }
 
+func effectiveControlPlaneNodeCount(req *mappers.ClusterRequirementsRequestForm) int {
+	if req.HostedControlPlane {
+		return 0
+	}
+	return req.ControlPlaneNodeCount
+}
+
 // buildSizerPayload transforms batched services into sizer API format
 func (s *SizerService) buildSizerPayload(
 	services []BatchedService,

internal/service/mappers/inbound.go

@@ -296,6 +296,46 @@ var _ = Describe("sizer service", func() {
 				Expect(result).NotTo(BeNil())
 			})
 
+			It("successfully handles hosted control plane (worker nodes only)", func() {
+				request.HostedControlPlane = true
+				assessment := createTestAssessment(assessmentID, clusterID, 10, 40, 80)
+				mockStore.assessments[assessmentID] = assessment
+
+				var sizerPayload client.SizerRequest
+				testServer = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+					if r.URL.Path == "/api/v1/size/custom" && r.Method == http.MethodPost {
+						Expect(json.NewDecoder(r.Body).Decode(&sizerPayload)).To(Succeed())
+					}
+					if r.URL.Path == "/health" {
+						w.WriteHeader(http.StatusOK)
+						return
+					}
+					if r.URL.Path == "/api/v1/size/custom" {
+						w.Header().Set("Content-Type", "application/json")
+						w.WriteHeader(http.StatusOK)
+						_ = json.NewEncoder(w).Encode(createTestSizerResponse(4, 4, 0, 40, 80))
+						return
+					}
+					w.WriteHeader(http.StatusNotFound)
+				}))
+				sizerClient = client.NewSizerClient(testServer.URL, 5*time.Second)
+				sizerService = service.NewSizerService(sizerClient, mockStore)
+
+				result, err := sizerService.CalculateClusterRequirements(ctx, assessmentID, request)
+
+				Expect(err).To(BeNil())
+				Expect(result).NotTo(BeNil())
+				Expect(result.ClusterSizing.ControlPlaneNodes).To(Equal(0))
+				Expect(result.ClusterSizing.WorkerNodes).To(Equal(6))
+				Expect(result.ClusterSizing.TotalNodes).To(Equal(6))
+				Expect(result.ClusterSizing.FailoverNodes).To(Equal(2))
+
+				Expect(sizerPayload.MachineSets).To(HaveLen(1))
+				Expect(sizerPayload.MachineSets[0].Name).To(Equal("worker"))
+				Expect(sizerPayload.Workloads).To(HaveLen(1))
+				Expect(sizerPayload.Workloads[0].Name).To(Equal("vm-workload"))
+			})
+
 			It("successfully handles different over-commit ratios", func() {
 				cpuRatios := []string{"1:1", "1:2", "1:4", "1:6"}
 				memoryRatios := []string{"1:1", "1:2", "1:4"}