func (h *ActualLRPLifecycleHandler) CrashActualLRP(logger lager.Logger, w http.ResponseWriter, req *http.Request) {
logger = 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(logger, []*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))
}
It("returns the event", func() {
event, err := eventSource.Next()
Expect(err).NotTo(HaveOccurred())
actualLRPRemovedEvent, ok := event.(*models.ActualLRPRemovedEvent)
Expect(ok).To(BeTrue())
Expect(actualLRPRemovedEvent).To(Equal(expectedEvent))
})
})
Context("when receiving a ActualLRPCrashedEvent", func() {
var expectedEvent *models.ActualLRPCrashedEvent
BeforeEach(func() {
expectedEvent = models.NewActualLRPCrashedEvent(actualLRP)
payload, err := proto.Marshal(expectedEvent)
Expect(err).NotTo(HaveOccurred())
payload = []byte(base64.StdEncoding.EncodeToString(payload))
fakeRawEventSource.NextReturns(
sse.Event{
ID: "sup",
Name: string(expectedEvent.EventType()),
Data: payload,
},
nil,
)
})
It("returns the event", func() {