func (h *DesiredLRPHandler) DesireDesiredLRP(logger lager.Logger, w http.ResponseWriter, req *http.Request) {
logger = logger.Session("desire-lrp")
request := &models.DesireLRPRequest{}
response := &models.DesiredLRPLifecycleResponse{}
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
}
err = h.desiredLRPDB.DesireLRP(logger, request.DesiredLrp)
if err != nil {
response.Error = models.ConvertError(err)
return
}
desiredLRP, err := h.desiredLRPDB.DesiredLRPByProcessGuid(logger, request.DesiredLrp.ProcessGuid)
if err != nil {
response.Error = models.ConvertError(err)
return
}
go h.desiredHub.Emit(models.NewDesiredLRPCreatedEvent(desiredLRP))
schedulingInfo := request.DesiredLrp.DesiredLRPSchedulingInfo()
h.startInstanceRange(logger, 0, schedulingInfo.Instances, &schedulingInfo)
}
desiredLRP = &models.DesiredLRP{
ProcessGuid: "some-guid",
Domain: "some-domain",
RootFs: "some-rootfs",
Action: models.WrapAction(&models.RunAction{
Path: "true",
User: "******",
}),
}
})
Context("when receiving a DesiredLRPCreatedEvent", func() {
var expectedEvent *models.DesiredLRPCreatedEvent
BeforeEach(func() {
expectedEvent = models.NewDesiredLRPCreatedEvent(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() {
server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
handler.Subscribe_r0(logger, w, r)
close(eventStreamDone)
}))
})
Describe("Subscribe to Desired Events", func() {
ItStreamsEventsFromHub(&desiredHub)
It("migrates desired lrps down to v0", func() {
response, err := http.Get(server.URL)
Expect(err).NotTo(HaveOccurred())
reader := sse.NewReadCloser(response.Body)
desiredLRP := model_helpers.NewValidDesiredLRP("guid")
event := models.NewDesiredLRPCreatedEvent(desiredLRP)
migratedLRP := desiredLRP.VersionDownTo(format.V0)
Expect(migratedLRP).NotTo(Equal(desiredLRP))
migratedEvent := models.NewDesiredLRPCreatedEvent(migratedLRP)
desiredHub.Emit(event)
events := events.NewEventSource(reader)
actualEvent, err := events.Next()
Expect(err).NotTo(HaveOccurred())
Expect(actualEvent).To(Equal(migratedEvent))
})
})
Describe("Subscribe to Actual Events", func() {
