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}))