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 (w *watcher) watchActual(logger lager.Logger) (chan<- bool, <-chan error) { return w.bbs.WatchForActualLRPChanges(logger, func(created models.ActualLRP, evacuating bool) { logger.Debug("handling-actual-create") w.hub.Emit(receptor.NewActualLRPCreatedEvent(serialization.ActualLRPToResponse(created, evacuating))) }, func(changed models.ActualLRPChange, evacuating bool) { logger.Debug("handling-actual-change") w.hub.Emit(receptor.NewActualLRPChangedEvent( serialization.ActualLRPToResponse(changed.Before, evacuating), serialization.ActualLRPToResponse(changed.After, evacuating), )) }, func(deleted models.ActualLRP, evacuating bool) { logger.Debug("handling-actual-delete") w.hub.Emit(receptor.NewActualLRPRemovedEvent(serialization.ActualLRPToResponse(deleted, evacuating))) }) }
BeforeEach(func() { actualLRPResponse = serialization.ActualLRPProtoToResponse( &models.ActualLRP{ ActualLRPKey: models.NewActualLRPKey("some-guid", 0, "some-domain"), State: models.ActualLRPStateUnclaimed, Since: 1, }, false, ) }) Context("when receiving a ActualLRPCreatedEvent", func() { var expectedEvent receptor.ActualLRPCreatedEvent BeforeEach(func() { expectedEvent = receptor.NewActualLRPCreatedEvent(actualLRPResponse) payload, err := json.Marshal(expectedEvent) Expect(err).NotTo(HaveOccurred()) fakeRawEventSource.NextReturns( sse.Event{ ID: "sup", Name: string(expectedEvent.EventType()), Data: payload, }, nil, ) }) It("returns the event", func() { event, err := eventSource.Next()
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() { response := &http.Response{} Eventually(responseChan).Should(Receive(&response))