Support manifest service parameters

api/actions/manifest/applier.go

@@ -175,15 +175,12 @@ func (a *Applier) deleteAppDestinations(
 	existingAppRoutes map[string]repositories.RouteRecord,
 ) error {
 	for _, route := range existingAppRoutes {
-		existingDestinations := route.Destinations
-
 		for _, destination := range route.Destinations {
 			if destination.AppGUID != appGUID {
 				continue
 			}
 
-			var err error
-			existingDestinations, err = a.deleteAppDestination(ctx, authInfo, route, destination.GUID, existingDestinations)
+			err := a.deleteAppDestination(ctx, authInfo, route, destination.GUID)
 			if err != nil {
 				return err
 			}
@@ -192,65 +189,62 @@ func (a *Applier) deleteAppDestinations(
 	return nil
 }
 
-func (a *Applier) deleteAppDestination(ctx context.Context, authInfo authorization.Info, route repositories.RouteRecord, destinationGUID string, existingDestinations []repositories.DestinationRecord) ([]repositories.DestinationRecord, error) {
-	route, err := a.routeRepo.RemoveDestinationFromRoute(ctx, authInfo, repositories.RemoveDestinationMessage{
+func (a *Applier) deleteAppDestination(ctx context.Context, authInfo authorization.Info, route repositories.RouteRecord, destinationGUID string) error {
+	_, err := a.routeRepo.RemoveDestinationFromRoute(ctx, authInfo, repositories.RemoveDestinationMessage{
 		RouteGUID: route.GUID,
 		SpaceGUID: route.SpaceGUID,
 		GUID:      destinationGUID,
 	})
-	if err != nil {
-		return nil, err
-	}
-
-	return route.Destinations, nil
+	return err
 }
 
 func (a *Applier) applyServices(ctx context.Context, authInfo authorization.Info, appInfo payloads.ManifestApplication, appState AppState) error {
-	desiredServiceNames := map[string]bool{}
+	manifestServiceNames := map[string]bool{}
 	for _, s := range appInfo.Services {
-		desiredServiceNames[s.Name] = true
+		manifestServiceNames[s.Name] = true
 	}
 	for serviceName := range appState.ServiceBindings {
-		delete(desiredServiceNames, serviceName)
+		delete(manifestServiceNames, serviceName)
 	}
 
-	if len(desiredServiceNames) == 0 {
+	if len(manifestServiceNames) == 0 {
 		return nil
 	}
 
 	serviceInstances, err := a.serviceInstanceRepo.ListServiceInstances(ctx, authInfo, repositories.ListServiceInstanceMessage{
-		Names: slices.Collect(maps.Keys(desiredServiceNames)),
+		Names: slices.Collect(maps.Keys(manifestServiceNames)),
 	})
 	if err != nil {
 		return err
 	}
 
-	serviceNameToServiceInstance := map[string]repositories.ServiceInstanceRecord{}
+	serviceGUIDToInstanceRecord := map[string]repositories.ServiceInstanceRecord{}
 	for _, serviceInstance := range serviceInstances {
-		serviceNameToServiceInstance[serviceInstance.Name] = serviceInstance
+		serviceGUIDToInstanceRecord[serviceInstance.Name] = serviceInstance
 	}
 
-	serviceNameToServiceBinding := map[string]*string{}
-	for _, manifestService := range appInfo.Services {
-		serviceNameToServiceBinding[manifestService.Name] = manifestService.BindingName
-	}
-
-	for serviceName := range desiredServiceNames {
-		serviceInstance, ok := serviceNameToServiceInstance[serviceName]
+	for manifestServiceName := range manifestServiceNames {
+		serviceInstanceRecord, ok := serviceGUIDToInstanceRecord[manifestServiceName]
 		if !ok {
 			return apierrors.NewNotFoundError(
 				nil,
 				repositories.ServiceInstanceResourceType,
 				"application", appInfo.Name,
-				"service", serviceName,
+				"service", manifestServiceName,
 			)
 		}
 
-		_, err := a.serviceBindingRepo.CreateServiceBinding(ctx, authInfo, repositories.CreateServiceBindingMessage{
-			Name:                serviceNameToServiceBinding[serviceName],
-			ServiceInstanceGUID: serviceInstance.GUID,
+		manifestService, err := getManifestService(appInfo, manifestServiceName)
+		if err != nil {
+			return apierrors.NewUnknownError(err)
+		}
+
+		_, err = a.serviceBindingRepo.CreateServiceBinding(ctx, authInfo, repositories.CreateServiceBindingMessage{
+			Name:                manifestService.BindingName,
+			ServiceInstanceGUID: serviceInstanceRecord.GUID,
 			AppGUID:             appState.App.GUID,
 			SpaceGUID:           appState.App.SpaceGUID,
+			Parameters:          manifestService.Parameters,
 		})
 		if err != nil {
 			return err
@@ -260,6 +254,16 @@ func (a *Applier) applyServices(ctx context.Context, authInfo authorization.Info
 	return nil
 }
 
+func getManifestService(manifestApp payloads.ManifestApplication, serviceName string) (payloads.ManifestApplicationService, error) {
+	for _, manifestService := range manifestApp.Services {
+		if manifestService.Name == serviceName {
+			return manifestService, nil
+		}
+	}
+
+	return payloads.ManifestApplicationService{}, fmt.Errorf("service %q not found in app %q manifest", serviceName, manifestApp.Name)
+}
+
 func splitRoute(route string) (string, string, string) {
 	parts := strings.SplitN(route, ".", 2)
 	hostName := parts[0]

api/actions/manifest/applier_test.go

@@ -509,6 +509,30 @@ var _ = Describe("Applier", func() {
 			})
 		})
 
+		When("the manifest service has parameters", func() {
+			BeforeEach(func() {
+				appInfo.Services = []payloads.ManifestApplicationService{
+					{
+						Name: "service-name",
+						Parameters: map[string]any{
+							"binding-param": "binding-param-value",
+						},
+					},
+					{Name: "already-bound-service-name"},
+				}
+			})
+
+			It("uses them when creating the binding", func() {
+				Expect(applierErr).NotTo(HaveOccurred())
+
+				Expect(serviceBindingRepo.CreateServiceBindingCallCount()).To(Equal(1))
+				_, _, createMsg := serviceBindingRepo.CreateServiceBindingArgsForCall(0)
+				Expect(createMsg.Parameters).To(Equal(map[string]any{
+					"binding-param": "binding-param-value",
+				}))
+			})
+		})
+
 		When("listing service instances fails", func() {
 			BeforeEach(func() {
 				serviceInstanceRepo.ListServiceInstancesReturns(nil, errors.New("list-services-err"))

api/handlers/space_manifest_test.go

@@ -71,6 +71,14 @@ var _ = Describe("SpaceManifest", func() {
 						Memory:                       tools.PtrTo("256M"),
 						Timeout:                      tools.PtrTo[int32](10),
 					}},
+					Services: []payloads.ManifestApplicationService{
+						{
+							Name: "my-service",
+							Parameters: map[string]any{
+								"binding-param": "binding-param-value",
+							},
+						},
+					},
 				}},
 			})
 		})
@@ -104,6 +112,13 @@ var _ = Describe("SpaceManifest", func() {
 			Expect(payload.Applications[0].Processes[0].Instances).To(PointTo(BeEquivalentTo(1)))
 			Expect(payload.Applications[0].Processes[0].Memory).To(PointTo(Equal("256M")))
 			Expect(payload.Applications[0].Processes[0].Timeout).To(PointTo(Equal(int32(10))))
+
+			Expect(payload.Applications[0].Services).To(ConsistOf(payloads.ManifestApplicationService{
+				Name: "my-service",
+				Parameters: map[string]any{
+					"binding-param": "binding-param-value",
+				},
+			}))
 		})
 
 		When("the manifest is invalid", func() {

api/payloads/manifest.go

@@ -68,8 +68,9 @@ type ManifestApplicationProcess struct {
 }
 
 type ManifestApplicationService struct {
-	Name        string  `json:"name" yaml:"name"`
-	BindingName *string `json:"binding_name" yaml:"binding_name"`
+	Name        string         `json:"name" yaml:"name"`
+	BindingName *string        `json:"binding_name" yaml:"binding_name"`
+	Parameters  map[string]any `json:"parameters" yaml:"parameters"`
 }
 
 func (s *ManifestApplicationService) UnmarshalYAML(value *yaml.Node) error {

tests/assets/sample-broker-golang/main.go

@@ -1,10 +1,12 @@
 package main
 
 import (
+	"bytes"
 	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
+	"io"
 	"net/http"
 	"os"
 	"strings"
@@ -218,7 +220,14 @@ func getOperation(r *http.Request) (string, error) {
 }
 
 func logRequest(r *http.Request) {
-	log(fmt.Sprintf("%s %v", r.Method, r.URL))
+	bodyBytes, err := io.ReadAll(r.Body)
+	if err != nil {
+		log(fmt.Sprintf("failed to read request %s %v body: %v", r.Method, r.URL, err))
+	}
+
+	r.Body = io.NopCloser(bytes.NewReader(bodyBytes))
+
+	log(fmt.Sprintf("%s %v\nBody: %s", r.Method, r.URL, string(bodyBytes)))
 }
 
 func log(s string) {