func (s *startRequests) Add(logger lager.Logger, actual *models.ActualLRPKey) {
s.Lock()
defer s.Unlock()
desiredLRP, found := s.desiredMap[actual.ProcessGuid]
if !found {
logger.Info("failed-to-find-desired-lrp-for-stale-unclaimed-actual-lrp", lager.Data{"actual_lrp": actual})
return
}
start, found := s.startMap[desiredLRP.ProcessGuid]
if !found {
startRequest := auctioneer.NewLRPStartRequestFromModel(desiredLRP, int(actual.Index))
start = &startRequest
} else {
start.Indices = append(start.Indices, int(actual.Index))
}
logger.Info("adding-start-auction", lager.Data{"process_guid": desiredLRP.ProcessGuid, "index": actual.Index})
s.startMap[desiredLRP.ProcessGuid] = start
s.instanceCount++
}
desiredLRP1, desiredLRP2 models.DesiredLRPSchedulingInfo
unclaimingActualLRP1 *models.ActualLRP
unclaimingActualLRP2 *models.ActualLRP
cellID string
cellSet models.CellSet
controller *controllers.LRPConvergenceController
)
BeforeEach(func() {
fakeLRPDB = new(dbfakes.FakeLRPDB)
fakeAuctioneerClient = new(auctioneerfakes.FakeClient)
logger = lagertest.NewTestLogger("test")
request1 := auctioneer.NewLRPStartRequestFromModel(model_helpers.NewValidDesiredLRP("to-auction-1"), 1, 2)
request2 := auctioneer.NewLRPStartRequestFromModel(model_helpers.NewValidDesiredLRP("to-auction-2"), 0, 4)
retiringActualLRP1 = model_helpers.NewValidActualLRP("to-retire-1", 0)
retiringActualLRP2 = model_helpers.NewValidActualLRP("to-retire-2", 1)
keysToRetire = []*models.ActualLRPKey{&retiringActualLRP1.ActualLRPKey, &retiringActualLRP2.ActualLRPKey}
desiredLRP1 = model_helpers.NewValidDesiredLRP("to-unclaim-1").DesiredLRPSchedulingInfo()
unclaimingActualLRP1 = model_helpers.NewValidActualLRP("to-unclaim-1", 0)
desiredLRP2 = model_helpers.NewValidDesiredLRP("to-unclaim-2").DesiredLRPSchedulingInfo()
unclaimingActualLRP2 = model_helpers.NewValidActualLRP("to-unclaim-2", 1)
keysWithMissingCells = []*models.ActualLRPKeyWithSchedulingInfo{
{Key: &unclaimingActualLRP1.ActualLRPKey, SchedulingInfo: &desiredLRP1},
{Key: &unclaimingActualLRP2.ActualLRPKey, SchedulingInfo: &desiredLRP2},
}
response := models.EvacuationResponse{}
err := response.Unmarshal(responseRecorder.Body.Bytes())
Expect(err).NotTo(HaveOccurred())
Expect(response.KeepContainer).To(BeFalse())
Expect(response.Error).To(BeNil())
Expect(fakeActualLRPDB.UnclaimActualLRPCallCount()).To(Equal(1))
_, lrpKey := fakeActualLRPDB.UnclaimActualLRPArgsForCall(0)
Expect(lrpKey.ProcessGuid).To(Equal("process-guid"))
Expect(lrpKey.Index).To(BeEquivalentTo(1))
Expect(fakeDesiredLRPDB.DesiredLRPByProcessGuidCallCount()).To(Equal(1))
_, guid := fakeDesiredLRPDB.DesiredLRPByProcessGuidArgsForCall(0)
Expect(guid).To(Equal("process-guid"))
expectedStartRequest := auctioneer.NewLRPStartRequestFromModel(desiredLRP, int(actual.Index))
Expect(fakeAuctioneerClient.RequestLRPAuctionsCallCount()).To(Equal(1))
_, startRequests := fakeAuctioneerClient.RequestLRPAuctionsArgsForCall(0)
Expect(startRequests).To(Equal([]*auctioneer.LRPStartRequest{&expectedStartRequest}))
})
Context("when the DB returns an unrecoverable error", func() {
BeforeEach(func() {
fakeEvacuationDB.RemoveEvacuatingActualLRPReturns(models.NewUnrecoverableError(nil))
})
It("logs and writes to the exit channel", func() {
Eventually(logger).Should(gbytes.Say("unrecoverable-error"))
Eventually(exitCh).Should(Receive())
})
})
Expect(reportedDuration.Unit).To(Equal("nanos"))
Expect(reportedDuration.Value).NotTo(BeZero())
})
})
It("returns start requests for stale unclaimed actual LRPs", func() {
startRequests, _, _ := sqlDB.ConvergeLRPs(logger, cellSet)
By("fresh domain", func() {
Expect(startRequests).NotTo(BeEmpty())
processGuid := "desired-with-stale-actuals" + "-" + freshDomain
desiredLRP, err := sqlDB.DesiredLRPByProcessGuid(logger, processGuid)
Expect(err).NotTo(HaveOccurred())
lrpStartRequest := auctioneer.NewLRPStartRequestFromModel(desiredLRP, 0, 1)
for _, startRequest := range startRequests {
sort.Ints(startRequest.Indices)
}
Expect(startRequests).To(ContainElement(BeActualLRPStartRequest(lrpStartRequest)))
})
By("expired domain", func() {
Expect(startRequests).NotTo(BeEmpty())
processGuid := "desired-with-stale-actuals" + "-" + expiredDomain
desiredLRP, err := sqlDB.DesiredLRPByProcessGuid(logger, processGuid)
Expect(err).NotTo(HaveOccurred())