func (listener *ActualStateListener) Start() { listener.messageBus.Subscribe("dea.heartbeat", func(messageBody []byte) { heartbeat, err := models.NewHeartbeatFromJSON(messageBody) if err != nil { listener.logger.Info("Could not unmarshal heartbeat", map[string]string{ "Error": err.Error(), "MessageBody": string(messageBody), }) return } err = listener.store.SaveActualState(heartbeat.InstanceHeartbeats) if err != nil { listener.logger.Info("Could not put instance heartbeats in store:", map[string]string{ "Error": err.Error(), }) return } err = listener.store.BumpActualFreshness(listener.timeProvider.Time()) if err != nil { listener.logger.Info("Could not update actual freshness", map[string]string{ "Error": err.Error(), }) } }) }
func (listener *ActualStateListener) Start() { heartbeatThreshold := time.Duration(listener.config.ActualFreshnessTTL()) * time.Second listener.messageBus.Subscribe("dea.advertise", func(message *yagnats.Message) { listener.heartbeatMutex.Lock() lastReceived := listener.lastReceivedHeartbeat listener.heartbeatMutex.Unlock() if listener.timeProvider.Time().Sub(lastReceived) >= heartbeatThreshold { listener.bumpFreshness() } listener.logger.Debug("Received dea.advertise") }) listener.messageBus.Subscribe("dea.heartbeat", func(message *yagnats.Message) { listener.logger.Debug("Got a heartbeat") heartbeat, err := models.NewHeartbeatFromJSON(message.Payload) if err != nil { listener.logger.Error("Could not unmarshal heartbeat", err, map[string]string{ "MessageBody": string(message.Payload), }) return } listener.logger.Debug("Decoded the heartbeat") listener.heartbeatMutex.Lock() listener.lastReceivedHeartbeat = listener.timeProvider.Time() listener.totalReceivedHeartbeats++ listener.heartbeatsToSave = append(listener.heartbeatsToSave, heartbeat) totalReceivedHeartbeats := listener.totalReceivedHeartbeats numToSave := len(listener.heartbeatsToSave) listener.heartbeatMutex.Unlock() listener.logger.Info("Received a heartbeat", map[string]string{ "Heartbeats Pending Save": strconv.Itoa(numToSave), }) listener.metricsAccountant.TrackReceivedHeartbeats(totalReceivedHeartbeats) }) go listener.syncHeartbeats() if listener.storeUsageTracker != nil { listener.storeUsageTracker.StartTrackingUsage() listener.measureStoreUsage() } }
Describe("Ticking the simulator", func() { BeforeEach(func() { sim.NumberOfNewAppsStartingPerHB = 0 //turn this off to make these tests simpler }) It("should emit a heartbeat for each DEA by every heartbeat interval", func() { Ω(sim.HeartbeatIntervalInSeconds).Should(Equal(10)) for i := 0; i < sim.HeartbeatIntervalInSeconds; i++ { sim.TickOneSecond() } Ω(messageBus.PublishedMessages["dea.heartbeat"]).Should(HaveLen(8)) heartbeats := map[string]models.Heartbeat{} for _, message := range messageBus.PublishedMessages["dea.heartbeat"] { heartbeat, err := models.NewHeartbeatFromJSON(message.Payload) Ω(err).ShouldNot(HaveOccured()) heartbeats[heartbeat.DeaGuid] = heartbeat } for dea, apps := range sim.DEAs { Ω(heartbeats[dea].InstanceHeartbeats).Should(HaveLen(len(apps))) } }) It("should emit an advertise for each DEA by every advertise interval", func() { Ω(sim.AdvertiseIntervalInSeconds).Should(Equal(5)) for i := 0; i < sim.AdvertiseIntervalInSeconds; i++ { sim.TickOneSecond() } Ω(messageBus.PublishedMessages["dea.advertise"]).Should(HaveLen(8))