func (h *ActualLRPLifecycleHandler) StartActualLRP(w http.ResponseWriter, req *http.Request) {
var err error
logger := h.logger.Session("start-actual-lrp")
request := &models.StartActualLRPRequest{}
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
}
before, after, err := h.db.StartActualLRP(logger, request.ActualLrpKey, request.ActualLrpInstanceKey, request.ActualLrpNetInfo)
if err != nil {
response.Error = models.ConvertError(err)
return
}
if before == nil {
go h.actualHub.Emit(models.NewActualLRPCreatedEvent(after))
} else if !before.Equal(after) {
go h.actualHub.Emit(models.NewActualLRPChangedEvent(before, after))
}
}
func (h *ActualLRPLifecycleHandler) ClaimActualLRP(w http.ResponseWriter, req *http.Request) {
var err error
logger := h.logger.Session("claim-actual-lrp")
request := &models.ClaimActualLRPRequest{}
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
}
before, after, err := h.db.ClaimActualLRP(logger, request.ProcessGuid, request.Index, request.ActualLrpInstanceKey)
if err != nil {
response.Error = models.ConvertError(err)
return
}
if !after.Equal(before) {
go h.actualHub.Emit(models.NewActualLRPChangedEvent(before, after))
}
}
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 (h *ActualLRPLifecycleHandler) FailActualLRP(w http.ResponseWriter, req *http.Request) {
var err error
logger := h.logger.Session("fail-actual-lrp")
request := &models.FailActualLRPRequest{}
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
}
before, after, err := h.db.FailActualLRP(logger, request.ActualLrpKey, request.ErrorMessage)
if err != nil {
response.Error = models.ConvertError(err)
return
}
go h.actualHub.Emit(models.NewActualLRPChangedEvent(before, after))
}
It("returns the event", func() {
event, err := eventSource.Next()
Expect(err).NotTo(HaveOccurred())
actualLRPCreatedEvent, ok := event.(*models.ActualLRPCreatedEvent)
Expect(ok).To(BeTrue())
Expect(actualLRPCreatedEvent).To(Equal(expectedEvent))
})
})
Context("when receiving a ActualLRPChangedEvent", func() {
var expectedEvent *models.ActualLRPChangedEvent
BeforeEach(func() {
expectedEvent = models.NewActualLRPChangedEvent(actualLRPGroup, actualLRPGroup)
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() {
},
}
afterActualLRP := &models.ActualLRPGroup{
Instance: &models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey(expectedProcessGuid, 1, "domain"),
ActualLRPInstanceKey: models.NewActualLRPInstanceKey(expectedInstanceGuid, "cell-id"),
ActualLRPNetInfo: models.NewActualLRPNetInfo(
expectedHost,
models.NewPortMapping(expectedExternalPort, expectedContainerPort),
models.NewPortMapping(expectedAdditionalExternalPort, expectedAdditionalContainerPort),
),
State: models.ActualLRPStateRunning,
},
}
nextEvent.Store(EventHolder{models.NewActualLRPChangedEvent(beforeActualLRP, afterActualLRP)})
})
It("should add/update the endpoint on the table", func() {
Eventually(table.AddEndpointCallCount).Should(Equal(2))
key, endpoint := table.AddEndpointArgsForCall(0)
Expect(key).To(Equal(expectedRoutingKey))
Expect(endpoint).To(Equal(routing_table.Endpoint{
InstanceGuid: expectedInstanceGuid,
Host: expectedHost,
Port: expectedExternalPort,
ContainerPort: expectedContainerPort,
}))
key, endpoint = table.AddEndpointArgsForCall(1)
AfterEach(func() {
process.Signal(os.Interrupt)
Eventually(process.Wait()).Should(Receive())
})
Describe("Actual LRP changes", func() {
var before *models.ActualLRPGroup
var after *models.ActualLRPGroup
BeforeEach(func() {
before = makeActualLRPGroup("process-guid", "instance-guid", 1, 2, 0, cc_messages.AppLRPDomain)
after = makeActualLRPGroup("process-guid", "instance-guid", 1, 3, 0, cc_messages.AppLRPDomain)
})
JustBeforeEach(func() {
nextEvent.Store(EventHolder{models.NewActualLRPChangedEvent(before, after)})
})
Context("when the crash count changes", func() {
Context("and after > before", func() {
BeforeEach(func() {
after.Instance.CrashCount = 1
after.Instance.CrashReason = "out of memory"
})
Context("and the application has the cc-app Domain", func() {
It("calls AppCrashed", func() {
Eventually(ccClient.AppCrashedCallCount).Should(Equal(1))
guid, crashed, _ := ccClient.AppCrashedArgsForCall(0)
Expect(guid).To(Equal("process-guid"))
Expect(crashed).To(Equal(cc_messages.AppCrashedRequest{