func NewEventFromBBS(bbsEvent models.Event) (receptor.Event, error) {
switch bbsEvent := bbsEvent.(type) {
case *models.ActualLRPCreatedEvent:
actualLRP, evacuating := bbsEvent.ActualLrpGroup.Resolve()
return receptor.NewActualLRPCreatedEvent(serialization.ActualLRPProtoToResponse(actualLRP, evacuating)), nil
case *models.ActualLRPChangedEvent:
before, evacuating := bbsEvent.Before.Resolve()
after, evacuating := bbsEvent.After.Resolve()
return receptor.NewActualLRPChangedEvent(
serialization.ActualLRPProtoToResponse(before, evacuating),
serialization.ActualLRPProtoToResponse(after, evacuating),
), nil
case *models.ActualLRPRemovedEvent:
actualLRP, evacuating := bbsEvent.ActualLrpGroup.Resolve()
return receptor.NewActualLRPRemovedEvent(serialization.ActualLRPProtoToResponse(actualLRP, evacuating)), nil
case *models.DesiredLRPCreatedEvent:
return receptor.NewDesiredLRPCreatedEvent(serialization.DesiredLRPProtoToResponse(bbsEvent.DesiredLrp)), nil
case *models.DesiredLRPChangedEvent:
return receptor.NewDesiredLRPChangedEvent(
serialization.DesiredLRPProtoToResponse(bbsEvent.Before),
serialization.DesiredLRPProtoToResponse(bbsEvent.After),
), nil
case *models.DesiredLRPRemovedEvent:
return receptor.NewDesiredLRPRemovedEvent(serialization.DesiredLRPProtoToResponse(bbsEvent.DesiredLrp)), nil
}
return nil, fmt.Errorf("unknown event type: %#v", bbsEvent)
}
func (h *DesiredLRPHandler) Get(w http.ResponseWriter, r *http.Request) {
processGuid := r.FormValue(":process_guid")
logger := h.logger.Session("get", lager.Data{
"ProcessGuid": processGuid,
})
if processGuid == "" {
err := errors.New("process_guid missing from request")
logger.Error("missing-process-guid", err)
writeBadRequestResponse(w, receptor.InvalidRequest, err)
return
}
desiredLRP, err := h.bbs.DesiredLRPByProcessGuid(processGuid)
if e, ok := err.(*models.Error); ok && e.Equal(models.ErrResourceNotFound) {
writeDesiredLRPNotFoundResponse(w, processGuid)
return
}
if err != nil {
logger.Error("unknown-error", err)
writeUnknownErrorResponse(w, err)
return
}
writeJSONResponse(w, http.StatusOK, serialization.DesiredLRPProtoToResponse(desiredLRP))
}
func writeDesiredLRPProtoResponse(w http.ResponseWriter, logger lager.Logger, desiredLRPs []*models.DesiredLRP, err error) {
if err != nil {
logger.Error("failed-to-fetch-desired-lrps", err)
writeUnknownErrorResponse(w, err)
return
}
responses := make([]receptor.DesiredLRPResponse, 0, len(desiredLRPs))
for _, desiredLRP := range desiredLRPs {
responses = append(responses, serialization.DesiredLRPProtoToResponse(desiredLRP))
}
writeJSONResponse(w, http.StatusOK, responses)
}
It("receives events", func() {
By("creating a DesiredLRP")
err := legacyBBS.DesireLRP(logger, oldDesiredLRP)
Expect(err).NotTo(HaveOccurred())
desiredLRP, err := bbsClient.DesiredLRPByProcessGuid(oldDesiredLRP.ProcessGuid)
Expect(err).NotTo(HaveOccurred())
var event receptor.Event
Eventually(events).Should(Receive(&event))
desiredLRPCreatedEvent, ok := event.(receptor.DesiredLRPCreatedEvent)
Expect(ok).To(BeTrue())
actualJSON, _ := json.Marshal(desiredLRPCreatedEvent.DesiredLRPResponse)
expectedJSON, _ := json.Marshal(serialization.DesiredLRPProtoToResponse(desiredLRP))
Expect(actualJSON).To(MatchJSON(expectedJSON))
By("updating an existing DesiredLRP")
routeMessage := json.RawMessage([]byte(`[{"port":8080,"hostnames":["new-route"]}]`))
newRoutes := map[string]*json.RawMessage{
"cf-router": &routeMessage,
}
err = legacyBBS.UpdateDesiredLRP(logger, oldDesiredLRP.ProcessGuid, oldmodels.DesiredLRPUpdate{Routes: newRoutes})
Expect(err).NotTo(HaveOccurred())
Eventually(events).Should(Receive(&event))
desiredLRPChangedEvent, ok := event.(receptor.DesiredLRPChangedEvent)
Expect(ok).To(BeTrue())
Expect(desiredLRPChangedEvent.After.Routes).To(Equal(receptor.RoutingInfo(newRoutes)))
BeforeEach(func() {
fakeRawEventSource = new(fake_receptor.FakeRawEventSource)
eventSource = receptor.NewEventSource(fakeRawEventSource)
})
Describe("Next", func() {
Describe("Desired LRP events", func() {
var desiredLRPResponse receptor.DesiredLRPResponse
BeforeEach(func() {
desiredLRPResponse = serialization.DesiredLRPProtoToResponse(
&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 receptor.DesiredLRPCreatedEvent
BeforeEach(func() {
expectedEvent = receptor.NewDesiredLRPCreatedEvent(desiredLRPResponse)
payload, err := json.Marshal(expectedEvent)
Expect(err).NotTo(HaveOccurred())
response := &http.Response{}
Eventually(responseChan).Should(Receive(&response))
reader := sse.NewReadCloser(response.Body)
desiredLRP := &models.DesiredLRP{
ProcessGuid: "some-guid",
Domain: "some-domain",
RootFs: "some-rootfs",
Action: models.WrapAction(&models.RunAction{
Path: "true",
User: "******",
}),
}
eventChannel <- models.NewDesiredLRPCreatedEvent(desiredLRP)
data, err := json.Marshal(receptor.NewDesiredLRPCreatedEvent(serialization.DesiredLRPProtoToResponse(desiredLRP)))
Expect(err).NotTo(HaveOccurred())
event, err := reader.Next()
Expect(err).NotTo(HaveOccurred())
Expect(event.ID).To(Equal("0"))
Expect(event.Name).To(Equal(string(receptor.EventTypeDesiredLRPCreated)))
Expect(event.Data).To(MatchJSON(data))
actualLRP := models.NewUnclaimedActualLRP(models.NewActualLRPKey("some-guid", 3, "some-domain"), 0)
actualLRPGroup := &models.ActualLRPGroup{Instance: actualLRP}
eventChannel <- models.NewActualLRPCreatedEvent(actualLRPGroup)
data, err = json.Marshal(receptor.NewActualLRPCreatedEvent(serialization.ActualLRPProtoToResponse(actualLRP, false)))
Expect(err).NotTo(HaveOccurred())
lrpRequest = newValidDesiredLRPCreateRequest()
err := client.CreateDesiredLRP(lrpRequest)
Expect(err).NotTo(HaveOccurred())
desiredLRP, err = bbsClient.DesiredLRPByProcessGuid(lrpRequest.ProcessGuid)
Expect(err).NotTo(HaveOccurred())
lrpResponse, getErr = client.GetDesiredLRP(lrpRequest.ProcessGuid)
})
It("responds without an error", func() {
Expect(getErr).NotTo(HaveOccurred())
})
It("fetches the desired lrp with the matching process guid", func() {
expectedLRPResponse := serialization.DesiredLRPProtoToResponse(desiredLRP)
actualJSON, err := json.Marshal(lrpResponse)
Expect(err).NotTo(HaveOccurred())
expectedJSON, err := json.Marshal(expectedLRPResponse)
Expect(err).NotTo(HaveOccurred())
Expect(actualJSON).To(MatchJSON(expectedJSON))
})
})
Describe("PUT /v1/desired_lrps/:process_guid", func() {
var updateErr error
instances := 6
annotation := "update-annotation"
rawMessage := json.RawMessage([]byte(`[{"port":8080,"hostnames":["updated-route"]}]`))
