func (h *ActualLRPLifecycleHandler) CrashActualLRP(w http.ResponseWriter, req *http.Request) {
logger := h.logger.Session("crash-actual-lrp")
request := &models.CrashActualLRPRequest{}
response := &models.ActualLRPLifecycleResponse{}
defer func() { exitIfUnrecoverable(logger, h.exitChan, response.Error) }()
defer writeResponse(w, response)
err := parseRequest(logger, req, request)
if err != nil {
response.Error = models.ConvertError(err)
return
}
actualLRPKey := request.ActualLrpKey
actualLRPInstanceKey := request.ActualLrpInstanceKey
before, after, shouldRestart, err := h.db.CrashActualLRP(logger, actualLRPKey, actualLRPInstanceKey, request.ErrorMessage)
if err != nil {
response.Error = models.ConvertError(err)
return
}
if shouldRestart {
desiredLRP, err := h.desiredLRPDB.DesiredLRPByProcessGuid(logger, actualLRPKey.ProcessGuid)
if err != nil {
logger.Error("failed-fetching-desired-lrp", err)
response.Error = models.ConvertError(err)
return
}
schedInfo := desiredLRP.DesiredLRPSchedulingInfo()
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([]*auctioneer.LRPStartRequest{&startRequest})
logger.Info("finished-lrp-auction-request", lager.Data{"app_guid": schedInfo.ProcessGuid, "index": int(actualLRPKey.Index)})
if err != nil {
logger.Error("failed-requesting-auction", err)
response.Error = models.ConvertError(err)
return
}
}
actualLRP, _ := after.Resolve()
go h.actualHub.Emit(models.NewActualLRPCrashedEvent(actualLRP))
go h.actualHub.Emit(models.NewActualLRPChangedEvent(before, after))
}
func (db *ETCDDB) startInstanceRange(logger lager.Logger, lower, upper int32, schedulingInfo *models.DesiredLRPSchedulingInfo) {
logger = logger.Session("start-instance-range", lager.Data{"lower": lower, "upper": upper})
logger.Info("starting")
defer logger.Info("complete")
keys := make([]*models.ActualLRPKey, upper-lower)
i := 0
for actualIndex := lower; actualIndex < upper; actualIndex++ {
key := models.NewActualLRPKey(schedulingInfo.ProcessGuid, int32(actualIndex), schedulingInfo.Domain)
keys[i] = &key
i++
}
createdIndices := db.createUnclaimedActualLRPs(logger, keys)
start := auctioneer.NewLRPStartRequestFromSchedulingInfo(schedulingInfo, createdIndices...)
err := db.auctioneerClient.RequestLRPAuctions([]*auctioneer.LRPStartRequest{&start})
if err != nil {
logger.Error("failed-to-request-auction", err)
}
}
func (db *ETCDDB) requestLRPAuctionForLRPKey(logger lager.Logger, key *models.ActualLRPKey) error {
schedulingInfo, _, err := db.rawDesiredLRPSchedulingInfo(logger, key.ProcessGuid)
bbsErr := models.ConvertError(err)
if bbsErr != nil {
if bbsErr.Type == models.Error_ResourceNotFound {
_, err := db.client.Delete(ActualLRPSchemaPath(key.ProcessGuid, key.Index), false)
if err != nil {
logger.Error("failed-to-delete-actual", err)
return models.ErrUnknownError
}
return err
} else {
return err
}
}
lrpStart := auctioneer.NewLRPStartRequestFromSchedulingInfo(schedulingInfo, int(key.Index))
err = db.auctioneerClient.RequestLRPAuctions([]*auctioneer.LRPStartRequest{&lrpStart})
if err != nil {
logger.Error("failed-to-request-auction", err)
return models.ErrUnknownError
}
return nil
}
Expect(*actualLRPKey).To(Equal(actual.ActualLRPKey))
Expect(*actualLRPInstanceKey).To(Equal(actual.ActualLRPInstanceKey))
Expect(*actualLrpNetInfo).To(Equal(actual.ActualLRPNetInfo))
Expect(ttl).To(BeEquivalentTo(60))
})
It("unclaims the lrp and requests an auction", func() {
Expect(fakeActualLRPDB.UnclaimActualLRPCallCount()).To(Equal(1))
_, actualLRPKey, actualLRPInstanceKey, actualLrpNetInfo, ttl := fakeEvacuationDB.EvacuateActualLRPArgsForCall(0)
Expect(*actualLRPKey).To(Equal(actual.ActualLRPKey))
Expect(*actualLRPInstanceKey).To(Equal(actual.ActualLRPInstanceKey))
Expect(*actualLrpNetInfo).To(Equal(actual.ActualLRPNetInfo))
Expect(ttl).To(BeEquivalentTo(60))
schedulingInfo := desiredLRP.DesiredLRPSchedulingInfo()
expectedStartRequest := auctioneer.NewLRPStartRequestFromSchedulingInfo(&schedulingInfo, int(actual.Index))
Expect(fakeAuctioneerClient.RequestLRPAuctionsCallCount()).To(Equal(1))
startRequests := fakeAuctioneerClient.RequestLRPAuctionsArgsForCall(0)
Expect(startRequests).To(Equal([]*auctioneer.LRPStartRequest{&expectedStartRequest}))
})
It("emits events to the hub", func() {
Eventually(actualHub.EmitCallCount).Should(Equal(2))
for i := 0; i < actualHub.EmitCallCount(); i++ {
switch event := actualHub.EmitArgsForCall(i).(type) {
case *models.ActualLRPCreatedEvent:
Expect(event.ActualLrpGroup).To(Equal(&models.ActualLRPGroup{Evacuating: afterActual}))
case *models.ActualLRPChangedEvent:
Expect(event.Before).To(Equal(&models.ActualLRPGroup{Instance: actual}))
