func (h *DesiredLRPHandler) UpdateDesiredLRP(logger lager.Logger, w http.ResponseWriter, req *http.Request) {
logger = logger.Session("update-desired-lrp")
request := &models.UpdateDesiredLRPRequest{}
response := &models.DesiredLRPLifecycleResponse{}
defer func() { exitIfUnrecoverable(logger, h.exitChan, response.Error) }()
defer writeResponse(w, response)
err := parseRequest(logger, req, request)
if err != nil {
logger.Error("failed-parsing-request", err)
response.Error = models.ConvertError(err)
return
}
logger = logger.WithData(lager.Data{"guid": request.ProcessGuid})
logger.Debug("updating-desired-lrp")
beforeDesiredLRP, err := h.desiredLRPDB.UpdateDesiredLRP(logger, request.ProcessGuid, request.Update)
if err != nil {
logger.Debug("failed-updating-desired-lrp")
response.Error = models.ConvertError(err)
return
}
logger.Debug("completed-updating-desired-lrp")
desiredLRP, err := h.desiredLRPDB.DesiredLRPByProcessGuid(logger, request.ProcessGuid)
if err != nil {
logger.Error("failed-fetching-desired-lrp", err)
return
}
if request.Update.Instances != nil {
logger.Debug("updating-lrp-instances")
previousInstanceCount := beforeDesiredLRP.Instances
requestedInstances := *request.Update.Instances - previousInstanceCount
logger = logger.WithData(lager.Data{"instances_delta": requestedInstances})
if requestedInstances > 0 {
logger.Debug("increasing-the-instances")
schedulingInfo := desiredLRP.DesiredLRPSchedulingInfo()
h.startInstanceRange(logger, previousInstanceCount, *request.Update.Instances, &schedulingInfo)
}
if requestedInstances < 0 {
logger.Debug("decreasing-the-instances")
numExtraActualLRP := previousInstanceCount + requestedInstances
h.stopInstancesFrom(logger, request.ProcessGuid, int(numExtraActualLRP))
}
}
go h.desiredHub.Emit(models.NewDesiredLRPChangedEvent(beforeDesiredLRP, desiredLRP))
}
It("returns the event", func() {
event, err := eventSource.Next()
Expect(err).NotTo(HaveOccurred())
desiredLRPCreateEvent, ok := event.(*models.DesiredLRPCreatedEvent)
Expect(ok).To(BeTrue())
Expect(desiredLRPCreateEvent).To(Equal(expectedEvent))
})
})
Context("when receiving a DesiredLRPChangedEvent", func() {
var expectedEvent *models.DesiredLRPChangedEvent
BeforeEach(func() {
expectedEvent = models.NewDesiredLRPChangedEvent(desiredLRP, desiredLRP)
payload, err := proto.Marshal(expectedEvent)
Expect(err).NotTo(HaveOccurred())
payload = []byte(base64.StdEncoding.EncodeToString(payload))
fakeRawEventSource.NextReturns(
sse.Event{
ID: "hi",
Name: string(expectedEvent.EventType()),
Data: payload,
},
nil,
)
})
It("returns the event", func() {