cf service-access performance

cf/actors/broker_builder/broker_builder.go

@@ -72,25 +72,44 @@ func (builder Builder) AttachSpecificBrokerToServices(brokerName string, service
 
 func (builder Builder) GetAllServiceBrokers() ([]models.ServiceBroker, error) {
 	brokers := []models.ServiceBroker{}
+	brokerGuids := []string{}
 	var err error
 	var services models.ServiceOfferings
 
 	err = builder.brokerRepo.ListServiceBrokers(func(broker models.ServiceBroker) bool {
 		brokers = append(brokers, broker)
+		brokerGuids = append(brokerGuids, broker.Guid)
 		return true
 	})
+	if err != nil {
+		return nil, err
+	}
 
-	for index, broker := range brokers {
-		services, err = builder.serviceBuilder.GetServicesForBroker(broker.Guid)
-		if err != nil {
-			return nil, err
-		}
+	services, err = builder.serviceBuilder.GetServicesForManyBrokers(brokerGuids)
+	if err != nil {
+		return nil, err
+	}
 
-		brokers[index].Services = services
+	brokers, err = builder.attachServiceOfferingsToBrokers(services, brokers)
+	if err != nil {
+		return nil, err
 	}
+
 	return brokers, err
 }
 
+func (builder Builder) attachServiceOfferingsToBrokers(services models.ServiceOfferings, brokers []models.ServiceBroker) ([]models.ServiceBroker, error) {
+	for _, service := range services {
+		for index, broker := range brokers {
+			if broker.Guid == service.BrokerGuid {
+				brokers[index].Services = append(brokers[index].Services, service)
+				break
+			}
+		}
+	}
+	return brokers, nil
+}
+
 func (builder Builder) GetBrokerWithAllServices(brokerName string) (models.ServiceBroker, error) {
 	broker, err := builder.brokerRepo.FindByName(brokerName)
 	if err != nil {

cf/actors/broker_builder/broker_builder_test.go

@@ -181,15 +181,15 @@ var _ = Describe("Broker Builder", func() {
 
 		It("returns an error if we cannot list the services for a broker", func() {
 			brokerRepo.ServiceBrokers = []models.ServiceBroker{serviceBroker1}
-			serviceBuilder.GetServicesForBrokerReturns(nil, errors.New("Cannot find services"))
+			serviceBuilder.GetServicesForManyBrokersReturns(nil, errors.New("Cannot find services"))
 
 			_, err := brokerBuilder.GetAllServiceBrokers()
 			Expect(err).To(HaveOccurred())
 		})
 
 		It("returns all service brokers populated with their services", func() {
 			brokerRepo.ServiceBrokers = []models.ServiceBroker{serviceBroker1}
-			serviceBuilder.GetServicesForBrokerReturns(services, nil)
+			serviceBuilder.GetServicesForManyBrokersReturns(services, nil)
 
 			brokers, err := brokerBuilder.GetAllServiceBrokers()
 			Expect(err).NotTo(HaveOccurred())

cf/actors/plan_builder/fakes/fake_plan_builder.go

@@ -2,9 +2,10 @@
 package fakes
 
 import (
-	. "github.com/cloudfoundry/cli/cf/actors/plan_builder"
-	"github.com/cloudfoundry/cli/cf/models"
 	"sync"
+
+	"github.com/cloudfoundry/cli/cf/actors/plan_builder"
+	"github.com/cloudfoundry/cli/cf/models"
 )
 
 type FakePlanBuilder struct {
@@ -46,6 +47,15 @@ type FakePlanBuilder struct {
 		result1 []models.ServicePlanFields
 		result2 error
 	}
+	GetPlansForManyServicesWithOrgsStub        func([]string) ([]models.ServicePlanFields, error)
+	getPlansForManyServicesWithOrgsMutex       sync.RWMutex
+	getPlansForManyServicesWithOrgsArgsForCall []struct {
+		arg1 []string
+	}
+	getPlansForManyServicesWithOrgsReturns struct {
+		result1 []models.ServicePlanFields
+		result2 error
+	}
 	GetPlansForServiceStub        func(string) ([]models.ServicePlanFields, error)
 	getPlansForServiceMutex       sync.RWMutex
 	getPlansForServiceArgsForCall []struct {
@@ -68,10 +78,10 @@ type FakePlanBuilder struct {
 
 func (fake *FakePlanBuilder) AttachOrgsToPlans(arg1 []models.ServicePlanFields) ([]models.ServicePlanFields, error) {
 	fake.attachOrgsToPlansMutex.Lock()
-	defer fake.attachOrgsToPlansMutex.Unlock()
 	fake.attachOrgsToPlansArgsForCall = append(fake.attachOrgsToPlansArgsForCall, struct {
 		arg1 []models.ServicePlanFields
 	}{arg1})
+	fake.attachOrgsToPlansMutex.Unlock()
 	if fake.AttachOrgsToPlansStub != nil {
 		return fake.AttachOrgsToPlansStub(arg1)
 	} else {
@@ -92,6 +102,7 @@ func (fake *FakePlanBuilder) AttachOrgsToPlansArgsForCall(i int) []models.Servic
 }
 
 func (fake *FakePlanBuilder) AttachOrgsToPlansReturns(result1 []models.ServicePlanFields, result2 error) {
+	fake.AttachOrgsToPlansStub = nil
 	fake.attachOrgsToPlansReturns = struct {
 		result1 []models.ServicePlanFields
 		result2 error
@@ -100,11 +111,11 @@ func (fake *FakePlanBuilder) AttachOrgsToPlansReturns(result1 []models.ServicePl
 
 func (fake *FakePlanBuilder) AttachOrgToPlans(arg1 []models.ServicePlanFields, arg2 string) ([]models.ServicePlanFields, error) {
 	fake.attachOrgToPlansMutex.Lock()
-	defer fake.attachOrgToPlansMutex.Unlock()
 	fake.attachOrgToPlansArgsForCall = append(fake.attachOrgToPlansArgsForCall, struct {
 		arg1 []models.ServicePlanFields
 		arg2 string
 	}{arg1, arg2})
+	fake.attachOrgToPlansMutex.Unlock()
 	if fake.AttachOrgToPlansStub != nil {
 		return fake.AttachOrgToPlansStub(arg1, arg2)
 	} else {
@@ -125,6 +136,7 @@ func (fake *FakePlanBuilder) AttachOrgToPlansArgsForCall(i int) ([]models.Servic
 }
 
 func (fake *FakePlanBuilder) AttachOrgToPlansReturns(result1 []models.ServicePlanFields, result2 error) {
+	fake.AttachOrgToPlansStub = nil
 	fake.attachOrgToPlansReturns = struct {
 		result1 []models.ServicePlanFields
 		result2 error
@@ -133,11 +145,11 @@ func (fake *FakePlanBuilder) AttachOrgToPlansReturns(result1 []models.ServicePla
 
 func (fake *FakePlanBuilder) GetPlansForServiceForOrg(arg1 string, arg2 string) ([]models.ServicePlanFields, error) {
 	fake.getPlansForServiceForOrgMutex.Lock()
-	defer fake.getPlansForServiceForOrgMutex.Unlock()
 	fake.getPlansForServiceForOrgArgsForCall = append(fake.getPlansForServiceForOrgArgsForCall, struct {
 		arg1 string
 		arg2 string
 	}{arg1, arg2})
+	fake.getPlansForServiceForOrgMutex.Unlock()
 	if fake.GetPlansForServiceForOrgStub != nil {
 		return fake.GetPlansForServiceForOrgStub(arg1, arg2)
 	} else {
@@ -158,6 +170,7 @@ func (fake *FakePlanBuilder) GetPlansForServiceForOrgArgsForCall(i int) (string,
 }
 
 func (fake *FakePlanBuilder) GetPlansForServiceForOrgReturns(result1 []models.ServicePlanFields, result2 error) {
+	fake.GetPlansForServiceForOrgStub = nil
 	fake.getPlansForServiceForOrgReturns = struct {
 		result1 []models.ServicePlanFields
 		result2 error
@@ -166,10 +179,10 @@ func (fake *FakePlanBuilder) GetPlansForServiceForOrgReturns(result1 []models.Se
 
 func (fake *FakePlanBuilder) GetPlansForServiceWithOrgs(arg1 string) ([]models.ServicePlanFields, error) {
 	fake.getPlansForServiceWithOrgsMutex.Lock()
-	defer fake.getPlansForServiceWithOrgsMutex.Unlock()
 	fake.getPlansForServiceWithOrgsArgsForCall = append(fake.getPlansForServiceWithOrgsArgsForCall, struct {
 		arg1 string
 	}{arg1})
+	fake.getPlansForServiceWithOrgsMutex.Unlock()
 	if fake.GetPlansForServiceWithOrgsStub != nil {
 		return fake.GetPlansForServiceWithOrgsStub(arg1)
 	} else {
@@ -190,18 +203,52 @@ func (fake *FakePlanBuilder) GetPlansForServiceWithOrgsArgsForCall(i int) string
 }
 
 func (fake *FakePlanBuilder) GetPlansForServiceWithOrgsReturns(result1 []models.ServicePlanFields, result2 error) {
+	fake.GetPlansForServiceWithOrgsStub = nil
 	fake.getPlansForServiceWithOrgsReturns = struct {
 		result1 []models.ServicePlanFields
 		result2 error
 	}{result1, result2}
 }
 
+func (fake *FakePlanBuilder) GetPlansForManyServicesWithOrgs(arg1 []string) ([]models.ServicePlanFields, error) {
+	fake.getPlansForManyServicesWithOrgsMutex.Lock()
+	fake.getPlansForManyServicesWithOrgsArgsForCall = append(fake.getPlansForManyServicesWithOrgsArgsForCall, struct {
+		arg1 []string
+	}{arg1})
+	fake.getPlansForManyServicesWithOrgsMutex.Unlock()
+	if fake.GetPlansForManyServicesWithOrgsStub != nil {
+		return fake.GetPlansForManyServicesWithOrgsStub(arg1)
+	} else {
+		return fake.getPlansForManyServicesWithOrgsReturns.result1, fake.getPlansForManyServicesWithOrgsReturns.result2
+	}
+}
+
+func (fake *FakePlanBuilder) GetPlansForManyServicesWithOrgsCallCount() int {
+	fake.getPlansForManyServicesWithOrgsMutex.RLock()
+	defer fake.getPlansForManyServicesWithOrgsMutex.RUnlock()
+	return len(fake.getPlansForManyServicesWithOrgsArgsForCall)
+}
+
+func (fake *FakePlanBuilder) GetPlansForManyServicesWithOrgsArgsForCall(i int) []string {
+	fake.getPlansForManyServicesWithOrgsMutex.RLock()
+	defer fake.getPlansForManyServicesWithOrgsMutex.RUnlock()
+	return fake.getPlansForManyServicesWithOrgsArgsForCall[i].arg1
+}
+
+func (fake *FakePlanBuilder) GetPlansForManyServicesWithOrgsReturns(result1 []models.ServicePlanFields, result2 error) {
+	fake.GetPlansForManyServicesWithOrgsStub = nil
+	fake.getPlansForManyServicesWithOrgsReturns = struct {
+		result1 []models.ServicePlanFields
+		result2 error
+	}{result1, result2}
+}
+
 func (fake *FakePlanBuilder) GetPlansForService(arg1 string) ([]models.ServicePlanFields, error) {
 	fake.getPlansForServiceMutex.Lock()
-	defer fake.getPlansForServiceMutex.Unlock()
 	fake.getPlansForServiceArgsForCall = append(fake.getPlansForServiceArgsForCall, struct {
 		arg1 string
 	}{arg1})
+	fake.getPlansForServiceMutex.Unlock()
 	if fake.GetPlansForServiceStub != nil {
 		return fake.GetPlansForServiceStub(arg1)
 	} else {
@@ -222,6 +269,7 @@ func (fake *FakePlanBuilder) GetPlansForServiceArgsForCall(i int) string {
 }
 
 func (fake *FakePlanBuilder) GetPlansForServiceReturns(result1 []models.ServicePlanFields, result2 error) {
+	fake.GetPlansForServiceStub = nil
 	fake.getPlansForServiceReturns = struct {
 		result1 []models.ServicePlanFields
 		result2 error
@@ -230,10 +278,10 @@ func (fake *FakePlanBuilder) GetPlansForServiceReturns(result1 []models.ServiceP
 
 func (fake *FakePlanBuilder) GetPlansVisibleToOrg(arg1 string) ([]models.ServicePlanFields, error) {
 	fake.getPlansVisibleToOrgMutex.Lock()
-	defer fake.getPlansVisibleToOrgMutex.Unlock()
 	fake.getPlansVisibleToOrgArgsForCall = append(fake.getPlansVisibleToOrgArgsForCall, struct {
 		arg1 string
 	}{arg1})
+	fake.getPlansVisibleToOrgMutex.Unlock()
 	if fake.GetPlansVisibleToOrgStub != nil {
 		return fake.GetPlansVisibleToOrgStub(arg1)
 	} else {
@@ -254,10 +302,11 @@ func (fake *FakePlanBuilder) GetPlansVisibleToOrgArgsForCall(i int) string {
 }
 
 func (fake *FakePlanBuilder) GetPlansVisibleToOrgReturns(result1 []models.ServicePlanFields, result2 error) {
+	fake.GetPlansVisibleToOrgStub = nil
 	fake.getPlansVisibleToOrgReturns = struct {
 		result1 []models.ServicePlanFields
 		result2 error
 	}{result1, result2}
 }
 
-var _ PlanBuilder = new(FakePlanBuilder)
+var _ plan_builder.PlanBuilder = new(FakePlanBuilder)

cf/actors/plan_builder/plan_builder.go

@@ -11,6 +11,7 @@ type PlanBuilder interface {
 	AttachOrgToPlans([]models.ServicePlanFields, string) ([]models.ServicePlanFields, error)
 	GetPlansForServiceForOrg(string, string) ([]models.ServicePlanFields, error)
 	GetPlansForServiceWithOrgs(string) ([]models.ServicePlanFields, error)
+	GetPlansForManyServicesWithOrgs([]string) ([]models.ServicePlanFields, error)
 	GetPlansForService(string) ([]models.ServicePlanFields, error)
 	GetPlansVisibleToOrg(string) ([]models.ServicePlanFields, error)
 }
@@ -94,6 +95,19 @@ func (builder Builder) GetPlansForServiceWithOrgs(serviceGuid string) ([]models.
 	return plans, nil
 }
 
+func (builder Builder) GetPlansForManyServicesWithOrgs(serviceGuids []string) ([]models.ServicePlanFields, error) {
+	plans, err := builder.servicePlanRepo.ListPlansFromManyServices(serviceGuids)
+	if err != nil {
+		return nil, err
+	}
+
+	plans, err = builder.AttachOrgsToPlans(plans)
+	if err != nil {
+		return nil, err
+	}
+	return plans, nil
+}
+
 func (builder Builder) GetPlansVisibleToOrg(orgName string) ([]models.ServicePlanFields, error) {
 	var plansToReturn []models.ServicePlanFields
 	allPlans, err := builder.servicePlanRepo.Search(nil)
@@ -158,29 +172,49 @@ func (builder Builder) buildPlanToOrgsVisibilityMap() (map[string][]string, erro
 	if PlanToOrgsVisibilityMap == nil {
 		orgLookup := make(map[string]string)
 
-		orgs, err := builder.orgRepo.ListOrgs()
+		visibilities, err := builder.servicePlanVisibilityRepo.List()
 		if err != nil {
 			return nil, err
 		}
-		for _, org := range orgs {
-			orgLookup[org.Guid] = org.Name
-		}
 
-		visibilities, err := builder.servicePlanVisibilityRepo.List()
+		orgGuids := builder.getUniqueOrgGuidsFromVisibilities(visibilities)
+
+		orgs, err := builder.orgRepo.GetManyOrgsByGuid(orgGuids)
 		if err != nil {
 			return nil, err
 		}
 
+		for _, org := range orgs {
+			orgLookup[org.Guid] = org.Name
+		}
+
 		visMap := make(map[string][]string)
 		for _, vis := range visibilities {
 			visMap[vis.ServicePlanGuid] = append(visMap[vis.ServicePlanGuid], orgLookup[vis.OrganizationGuid])
 		}
+
 		PlanToOrgsVisibilityMap = &visMap
 	}
 
 	return *PlanToOrgsVisibilityMap, nil
 }
 
+func (builder Builder) getUniqueOrgGuidsFromVisibilities(visibilities []models.ServicePlanVisibilityFields) (orgGuids []string) {
+	for _, visibility := range visibilities {
+		found := false
+		for _, orgGuid := range orgGuids {
+			if orgGuid == visibility.OrganizationGuid {
+				found = true
+				break
+			}
+		}
+		if !found {
+			orgGuids = append(orgGuids, visibility.OrganizationGuid)
+		}
+	}
+	return
+}
+
 func (builder Builder) buildOrgToPlansVisibilityMap(planToOrgsMap map[string][]string) map[string][]string {
 	if OrgToPlansVisibilityMap == nil {
 		visMap := make(map[string][]string)