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))
}
}
})
Describe("Actual LRP Events", func() {
var actualLRPGroup *models.ActualLRPGroup
var actualLRP *models.ActualLRP
BeforeEach(func() {
actualLRP = models.NewUnclaimedActualLRP(models.NewActualLRPKey("some-guid", 0, "some-domain"), 1)
actualLRPGroup = models.NewRunningActualLRPGroup(actualLRP)
})
Context("when receiving a ActualLRPCreatedEvent", func() {
var expectedEvent *models.ActualLRPCreatedEvent
BeforeEach(func() {
expectedEvent = models.NewActualLRPCreatedEvent(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() {
State: models.ActualLRPStateRunning,
}
actualLRPGroup = &models.ActualLRPGroup{
Instance: actualLRP,
}
actualLRPRoutingInfo = &routing_table.ActualLRPRoutingInfo{
ActualLRP: actualLRP,
Evacuating: false,
}
})
JustBeforeEach(func() {
table.AddEndpointReturns(dummyMessagesToEmit)
nextEvent.Store(EventHolder{models.NewActualLRPCreatedEvent(actualLRPGroup)})
})
It("should add/update the endpoints on the table", func() {
Eventually(table.AddEndpointCallCount).Should(Equal(2))
keys := routing_table.RoutingKeysFromActual(actualLRP)
endpoints, err := routing_table.EndpointsFromActual(actualLRPRoutingInfo)
Expect(err).NotTo(HaveOccurred())
key, endpoint := table.AddEndpointArgsForCall(0)
Expect(keys).To(ContainElement(key))
Expect(endpoint).To(Equal(endpoints[key.ContainerPort]))
key, endpoint = table.AddEndpointArgsForCall(1)
Expect(keys).To(ContainElement(key))
}),
}
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())
event, err = reader.Next()
Expect(err).NotTo(HaveOccurred())
Expect(event.ID).To(Equal("1"))
Expect(event.Name).To(Equal(string(receptor.EventTypeActualLRPCreated)))
Expect(event.Data).To(MatchJSON(data))
eventChannel <- eventfakes.FakeEvent{"B"}
close(done)
})
It("returns Content-Type as text/event-stream", func() {