Use scheduling info instead of the whole desiredLRP

client.go

@@ -169,6 +169,9 @@ type ExternalDesiredLRPClient interface {
 	// Returns all DesiredLRPSchedulingInfos that match the given DesiredLRPFilter
 	DesiredLRPSchedulingInfos(lager.Logger, string, models.DesiredLRPFilter) ([]*models.DesiredLRPSchedulingInfo, error)
 
+	//Returns the DesiredLRPSchedulingInfo that matches the given process guid
+	DesiredLRPSchedulingInfoByProcessGuid(logger lager.Logger, traceID string, processGuid string) (*models.DesiredLRPSchedulingInfo, error)
+
 	// Returns all DesiredLRPRoutingInfos that match the given DesiredLRPFilter
 	DesiredLRPRoutingInfos(lager.Logger, string, models.DesiredLRPFilter) ([]*models.DesiredLRP, error)
 
@@ -627,6 +630,19 @@ func (c *client) DesiredLRPSchedulingInfos(logger lager.Logger, traceID string,
 	return response.DesiredLrpSchedulingInfos, response.Error.ToError()
 }
 
+func (c *client) DesiredLRPSchedulingInfoByProcessGuid(logger lager.Logger, traceID string, processGuid string) (*models.DesiredLRPSchedulingInfo, error) {
+	request := models.DesiredLRPByProcessGuidRequest{
+		ProcessGuid: processGuid,
+	}
+	response := models.DesiredLRPSchedulingInfoByProcessGuidResponse{}
+	err := c.doRequest(logger, traceID, DesiredLRPSchedulingInfoByProcessGuid_r0, nil, nil, &request, &response)
+	if err != nil {
+		return nil, err
+	}
+
+	return response.DesiredLrpSchedulingInfo, response.Error.ToError()
+}
+
 func (c *client) DesiredLRPRoutingInfos(logger lager.Logger, traceID string, filter models.DesiredLRPFilter) ([]*models.DesiredLRP, error) {
 	request := models.DesiredLRPsRequest{
 		ProcessGuids: filter.ProcessGuids,

cmd/bbs/desired_lrp_test.go

@@ -15,10 +15,12 @@ import (
 
 var _ = Describe("DesiredLRP API", func() {
 	var (
-		desiredLRPs         map[string][]*models.DesiredLRP
-		schedulingInfos     []*models.DesiredLRPSchedulingInfo
-		expectedDesiredLRPs []*models.DesiredLRP
-		actualDesiredLRPs   []*models.DesiredLRP
+		desiredLRPs            map[string][]*models.DesiredLRP
+		schedulingInfos        []*models.DesiredLRPSchedulingInfo
+		routingInfos           []*models.DesiredLRP
+		expectedSchedulingInfo models.DesiredLRPSchedulingInfo
+		expectedDesiredLRPs    []*models.DesiredLRP
+		actualDesiredLRPs      []*models.DesiredLRP
 
 		filter models.DesiredLRPFilter
 
@@ -199,6 +201,77 @@ var _ = Describe("DesiredLRP API", func() {
 		})
 	})
 
+	Describe("DesiredLRPSchedulingInfoByProcessGuid", func() {
+		var schedulingInfoByProcessGuid *models.DesiredLRPSchedulingInfo
+
+		JustBeforeEach(func() {
+			expectedSchedulingInfo = desiredLRPs["domain-1"][0].DesiredLRPSchedulingInfo()
+			schedulingInfoByProcessGuid, getErr = client.DesiredLRPSchedulingInfoByProcessGuid(logger, "some-trace-id", expectedSchedulingInfo.GetProcessGuid())
+			schedulingInfoByProcessGuid.ModificationTag.Epoch = "epoch"
+		})
+
+		It("responds without error", func() {
+			Expect(getErr).ToNot(HaveOccurred())
+		})
+
+		It("returns the correct desired lrp scheduling info", func() {
+			Expect(*schedulingInfoByProcessGuid).To(Equal(expectedSchedulingInfo))
+		})
+	})
+
+	Describe("DesiredLRPRoutingInfos", func() {
+		JustBeforeEach(func() {
+			routingInfos, getErr = client.DesiredLRPRoutingInfos(logger, "some-trace-id", filter)
+			for _, routingInfo := range routingInfos {
+				routingInfo.ModificationTag.Epoch = "epoch"
+			}
+		})
+
+		It("responds without error", func() {
+			Expect(getErr).NotTo(HaveOccurred())
+		})
+
+		It("has the correct number of responses", func() {
+			Expect(routingInfos).To(HaveLen(5))
+		})
+
+		Context("when not filtering", func() {
+			It("returns all routing infos from the bbs", func() {
+				expectedRoutingInfos := []*models.DesiredLRP{}
+				for _, domainLRPs := range desiredLRPs {
+					for _, lrp := range domainLRPs {
+						routingInfo := lrp.DesiredLRPRoutingInfo()
+						expectedRoutingInfos = append(expectedRoutingInfos, &routingInfo)
+					}
+				}
+				Expect(routingInfos).To(ConsistOf(expectedRoutingInfos))
+			})
+		})
+
+		Context("when filtering by process guids", func() {
+			BeforeEach(func() {
+				guids := []string{
+					"guid-1-for-domain-1",
+					"guid-2-for-domain-2",
+				}
+
+				filter = models.DesiredLRPFilter{ProcessGuids: guids}
+			})
+
+			It("returns only the routing infos in the requested process guids", func() {
+				Expect(routingInfos).To(HaveLen(2))
+
+				routingInfo1 := desiredLRPs["domain-1"][1].DesiredLRPRoutingInfo()
+				routingInfo2 := desiredLRPs["domain-2"][2].DesiredLRPRoutingInfo()
+				expectedRoutingInfos := []*models.DesiredLRP{
+					&routingInfo1,
+					&routingInfo2,
+				}
+				Expect(routingInfos).To(ConsistOf(expectedRoutingInfos))
+			})
+		})
+	})
+
 	Describe("DesireLRP", func() {
 		var (
 			desiredLRP         *models.DesiredLRP

controllers/actual_lrp_lifecycle_controller.go

@@ -204,14 +204,13 @@ func (h *ActualLRPLifecycleController) CrashActualLRP(ctx context.Context, logge
 		return nil
 	}
 
-	desiredLRP, err := h.desiredLRPDB.DesiredLRPByProcessGuid(ctx, logger, actualLRPKey.ProcessGuid)
+	schedInfo, err := h.desiredLRPDB.DesiredLRPSchedulingInfoByProcessGuid(ctx, logger, actualLRPKey.ProcessGuid)
 	if err != nil {
 		logger.Error("failed-fetching-desired-lrp", err)
 		return err
 	}
 
-	schedInfo := desiredLRP.DesiredLRPSchedulingInfo()
-	startRequest := auctioneer.NewLRPStartRequestFromSchedulingInfo(&schedInfo, int(actualLRPKey.Index))
+	startRequest := auctioneer.NewLRPStartRequestFromSchedulingInfo(schedInfo, int(actualLRPKey.Index))
 	logger.Info("start-lrp-auction-request", lager.Data{"app_guid": schedInfo.ProcessGuid, "index": int(actualLRPKey.Index)})
 	err = h.auctioneerClient.RequestLRPAuctions(logger, trace.RequestIdFromContext(ctx), []*auctioneer.LRPStartRequest{&startRequest})
 	logger.Info("finished-lrp-auction-request", lager.Data{"app_guid": schedInfo.ProcessGuid, "index": int(actualLRPKey.Index)})

controllers/actual_lrp_lifecycle_controller_test.go

@@ -619,7 +619,8 @@ var _ = Describe("ActualLRP Lifecycle Controller", func() {
 				MaxPids:     100,
 			}
 
-			fakeDesiredLRPDB.DesiredLRPByProcessGuidReturns(desiredLRP, nil)
+			schedInfo := desiredLRP.DesiredLRPSchedulingInfo()
+			fakeDesiredLRPDB.DesiredLRPSchedulingInfoByProcessGuidReturns(&schedInfo, nil)
 		})
 
 		It("responds with no error", func() {
@@ -666,8 +667,8 @@ var _ = Describe("ActualLRP Lifecycle Controller", func() {
 					err = controller.CrashActualLRP(context.WithValue(ctx, trace.RequestIdHeader, traceId), logger, &actualLRPKey, &beforeInstanceKey, errorMessage)
 					Expect(err).NotTo(HaveOccurred())
 
-					Expect(fakeDesiredLRPDB.DesiredLRPByProcessGuidCallCount()).To(Equal(1))
-					_, _, processGuid := fakeDesiredLRPDB.DesiredLRPByProcessGuidArgsForCall(0)
+					Expect(fakeDesiredLRPDB.DesiredLRPSchedulingInfoByProcessGuidCallCount()).To(Equal(1))
+					_, _, processGuid := fakeDesiredLRPDB.DesiredLRPSchedulingInfoByProcessGuidArgsForCall(0)
 					Expect(processGuid).To(Equal("process-guid"))
 
 					Expect(fakeAuctioneerClient.RequestLRPAuctionsCallCount()).To(Equal(1))
@@ -735,7 +736,7 @@ var _ = Describe("ActualLRP Lifecycle Controller", func() {
 
 			Context("when fetching the desired lrp fails", func() {
 				JustBeforeEach(func() {
-					fakeDesiredLRPDB.DesiredLRPByProcessGuidReturns(nil, errors.New("error occured"))
+					fakeDesiredLRPDB.DesiredLRPSchedulingInfoByProcessGuidReturns(nil, errors.New("error occured"))
 				})
 
 				It("fails and does not request an auction", func() {
@@ -876,7 +877,8 @@ var _ = Describe("ActualLRP Lifecycle Controller", func() {
 						Routes:      routes,
 					}
 
-					fakeDesiredLRPDB.DesiredLRPByProcessGuidReturns(desiredLRP, nil)
+					schedInfo := desiredLRP.DesiredLRPSchedulingInfo()
+					fakeDesiredLRPDB.DesiredLRPSchedulingInfoByProcessGuidReturns(&schedInfo, nil)
 				})
 
 				It("returns the error to the caller", func() {

controllers/evacuation_controller.go

@@ -384,14 +384,13 @@ func (h *EvacuationController) EvacuateStoppedActualLRP(ctx context.Context, log
 }
 
 func (h *EvacuationController) requestAuction(ctx context.Context, logger lager.Logger, lrpKey *models.ActualLRPKey) {
-	desiredLRP, err := h.desiredLRPDB.DesiredLRPByProcessGuid(ctx, logger, lrpKey.ProcessGuid)
+	schedInfo, err := h.desiredLRPDB.DesiredLRPSchedulingInfoByProcessGuid(ctx, logger, lrpKey.ProcessGuid)
 	if err != nil {
-		logger.Error("failed-fetching-desired-lrp", err)
+		logger.Error("failed-fetching-desired-lrp-scheduling-info", err)
 		return
 	}
 
-	schedInfo := desiredLRP.DesiredLRPSchedulingInfo()
-	startRequest := auctioneer.NewLRPStartRequestFromSchedulingInfo(&schedInfo, int(lrpKey.Index))
+	startRequest := auctioneer.NewLRPStartRequestFromSchedulingInfo(schedInfo, int(lrpKey.Index))
 	err = h.auctioneerClient.RequestLRPAuctions(logger, trace.RequestIdFromContext(ctx), []*auctioneer.LRPStartRequest{&startRequest})
 	if err != nil {
 		logger.Error("failed-requesting-auction", err)

controllers/evacuation_controller_test.go

@@ -231,8 +231,8 @@ var _ = Describe("Evacuation Controller", func() {
 
 		BeforeEach(func() {
 			desiredLRP = model_helpers.NewValidDesiredLRP("the-guid")
-			fakeDesiredLRPDB.DesiredLRPByProcessGuidReturns(desiredLRP, nil)
-
+			schedInfo := desiredLRP.DesiredLRPSchedulingInfo()
+			fakeDesiredLRPDB.DesiredLRPSchedulingInfoByProcessGuidReturns(&schedInfo, nil)
 			actualLRP = model_helpers.NewValidActualLRP("process-guid", 1)
 			actualLRP.State = models.ActualLRPStateClaimed
 			fakeActualLRPDB.ActualLRPsReturns([]*models.ActualLRP{actualLRP}, nil)
@@ -260,8 +260,8 @@ var _ = Describe("Evacuation Controller", func() {
 			_, _, key := fakeActualLRPDB.UnclaimActualLRPArgsForCall(0)
 			Expect(key).To(Equal(lrpKey))
 
-			Expect(fakeDesiredLRPDB.DesiredLRPByProcessGuidCallCount()).To(Equal(1))
-			_, _, guid := fakeDesiredLRPDB.DesiredLRPByProcessGuidArgsForCall(0)
+			Expect(fakeDesiredLRPDB.DesiredLRPSchedulingInfoByProcessGuidCallCount()).To(Equal(1))
+			_, _, guid := fakeDesiredLRPDB.DesiredLRPSchedulingInfoByProcessGuidArgsForCall(0)
 			Expect(guid).To(Equal("process-guid"))
 
 			expectedStartRequest := auctioneer.NewLRPStartRequestFromModel(desiredLRP, int(actualLRP.Index))
@@ -359,7 +359,7 @@ var _ = Describe("Evacuation Controller", func() {
 
 		Context("when looking up the desired lrp to auction fails", func() {
 			BeforeEach(func() {
-				fakeDesiredLRPDB.DesiredLRPByProcessGuidReturns(nil, errors.New("error fetching desired lrp"))
+				fakeDesiredLRPDB.DesiredLRPSchedulingInfoByProcessGuidReturns(nil, errors.New("error fetching desired lrp"))
 			})
 
 			It("does not error and tells the caller to not keep the lrp container", func() {
@@ -749,7 +749,8 @@ var _ = Describe("Evacuation Controller", func() {
 			fakeActualLRPDB.UnclaimActualLRPReturns(actual, unclaimedActualLRP, nil)
 
 			desiredLRP = model_helpers.NewValidDesiredLRP("the-guid")
-			fakeDesiredLRPDB.DesiredLRPByProcessGuidReturns(desiredLRP, nil)
+			schedInfo := desiredLRP.DesiredLRPSchedulingInfo()
+			fakeDesiredLRPDB.DesiredLRPSchedulingInfoByProcessGuidReturns(&schedInfo, nil)
 		})
 
 		JustBeforeEach(func() {
@@ -1288,9 +1289,9 @@ var _ = Describe("Evacuation Controller", func() {
 					})
 				})
 
-				Context("when fetching the desired lrp fails", func() {
+				Context("when fetching the desired lrp scheduling info fails", func() {
 					BeforeEach(func() {
-						fakeDesiredLRPDB.DesiredLRPByProcessGuidReturns(nil, errors.New("jolly rancher beer :/"))
+						fakeDesiredLRPDB.DesiredLRPSchedulingInfoByProcessGuidReturns(nil, errors.New("jolly rancher beer :/"))
 					})
 
 					It("does not return an error and keeps the container", func() {