func (r *RouteFetcher) subscribeToEvents(token *schema.Token) error {
r.client.SetToken(token.AccessToken)
r.logger.Info("Subscribing-to-routing-api-event-stream")
source, err := r.client.SubscribeToEventsWithMaxRetries(maxRetries)
if err != nil {
metrics.IncrementCounter(SubscribeEventsErrors)
r.logger.Error("Failed-to-subscribe-to-routing-api-event-stream: ", err)
return err
}
r.logger.Info("Successfully-subscribed-to-routing-api-event-stream")
r.eventSource.Store(source)
var event routing_api.Event
for {
event, err = source.Next()
if err != nil {
metrics.IncrementCounter(SubscribeEventsErrors)
r.logger.Error("Failed to get next event: ", err)
break
}
r.logger.Debug("received-event", lager.Data{"event": event})
r.eventChannel <- event
}
return err
}
func (r *RouteFetcher) subscribeToEvents(token *schema.Token) error {
r.client.SetToken(token.AccessToken)
source, err := r.client.SubscribeToEventsWithMaxRetries(maxRetries)
if err != nil {
metrics.IncrementCounter(SubscribeEventsErrors)
r.logger.Error("Failed to subscribe to events: ", err)
return err
}
r.logger.Info("Successfully subscribed to event stream.")
r.eventSource.Store(source)
for {
event, err := source.Next()
if err != nil {
metrics.IncrementCounter(SubscribeEventsErrors)
r.logger.Error("Failed to get next event: ", err)
break
}
r.logger.Debug("Handling event: ", lager.Data{"event": event})
r.eventChannel <- event
}
return err
}
func (r *RouteFetcher) startEventCycle() {
go func() {
useCachedToken := true
for {
r.logger.Debug("fetching-token")
token, err := r.UaaClient.FetchToken(useCachedToken)
if err != nil {
metrics.IncrementCounter(TokenFetchErrors)
r.logger.Error("failed-to-fetch-token", err)
} else {
r.logger.Debug("token-fetched-successfully")
if atomic.LoadInt32(&r.stopEventSource) == 1 {
return
}
err = r.subscribeToEvents(token)
if err != nil && err.Error() == "unauthorized" {
useCachedToken = false
} else {
useCachedToken = true
}
if atomic.LoadInt32(&r.stopEventSource) == 1 {
return
}
time.Sleep(time.Duration(r.SubscriptionRetryIntervalInSeconds) * time.Second)
}
}
}()
}
func (r *RouteFetcher) FetchRoutes() error {
r.logger.Debug("fetch-routes-started")
defer r.logger.Debug("fetch-routes-completed")
useCachedToken := true
var err error
var routes []db.Route
for count := 0; count < 2; count++ {
r.logger.Debug("fetching-token")
token, tokenErr := r.UaaClient.FetchToken(useCachedToken)
if tokenErr != nil {
metrics.IncrementCounter(TokenFetchErrors)
return tokenErr
}
r.client.SetToken(token.AccessToken)
r.logger.Debug("fetching-routes")
routes, err = r.client.Routes()
if err != nil {
if err.Error() == "unauthorized" {
useCachedToken = false
} else {
return err
}
} else {
break
}
}
if err == nil {
r.logger.Debug("refreshing-endpoints")
r.refreshEndpoints(routes)
}
return err
}
func (r *RouteFetcher) fetchRoutesWithTokenRefresh() ([]models.Route, error) {
forceUpdate := false
var err error
var routes []models.Route
for count := 0; count < 2; count++ {
r.logger.Debug("syncer-fetching-token")
token, tokenErr := r.UaaClient.FetchToken(forceUpdate)
if tokenErr != nil {
metrics.IncrementCounter(TokenFetchErrors)
return []models.Route{}, tokenErr
}
r.client.SetToken(token.AccessToken)
r.logger.Debug("syncer-fetching-routes")
routes, err = r.client.Routes()
if err != nil {
if err.Error() == "unauthorized" {
forceUpdate = true
} else {
return []models.Route{}, err
}
} else {
break
}
}
return routes, err
}
func (r *RouteFetcher) FetchRoutes() error {
useCachedToken := true
var err error
var routes []db.Route
for count := 0; count < 2; count++ {
token, tokenErr := r.TokenFetcher.FetchToken(useCachedToken)
if tokenErr != nil {
metrics.IncrementCounter(TokenFetchErrors)
return tokenErr
}
r.client.SetToken(token.AccessToken)
routes, err = r.client.Routes()
if err != nil {
if err.Error() == "unauthorized" {
useCachedToken = false
} else {
return err
}
} else {
break
}
}
if err == nil {
r.refreshEndpoints(routes)
}
return err
}
func (r *RouteFetcher) FetchRoutes() error {
r.logger.Debug("syncer-fetch-routes-started")
defer func() {
r.logger.Debug("syncer-fetch-routes-completed")
r.lock.Lock()
r.applyCachedEvents()
r.syncing = false
r.cachedEvents = nil
r.lock.Unlock()
}()
r.lock.Lock()
r.syncing = true
r.cachedEvents = []routing_api.Event{}
r.lock.Unlock()
forceUpdate := false
var err error
var routes []models.Route
for count := 0; count < 2; count++ {
r.logger.Debug("syncer-fetching-token")
token, tokenErr := r.UaaClient.FetchToken(forceUpdate)
if tokenErr != nil {
metrics.IncrementCounter(TokenFetchErrors)
return tokenErr
}
r.client.SetToken(token.AccessToken)
r.logger.Debug("syncer-fetching-routes")
routes, err = r.client.Routes()
if err != nil {
if err.Error() == "unauthorized" {
forceUpdate = true
} else {
return err
}
} else {
break
}
}
if err == nil {
r.logger.Debug("syncer-refreshing-endpoints")
r.refreshEndpoints(routes)
}
return err
}
receivedEvents[eventId] = true
}()
}
}()
httpListener, err := net.Listen("tcp", "localhost:0")
Expect(err).ToNot(HaveOccurred())
defer httpListener.Close()
httpHandler := dropsonde.InstrumentedHandler(FakeHandler{})
go http.Serve(httpListener, httpHandler)
_, err = http.Get("http://" + httpListener.Addr().String())
Expect(err).ToNot(HaveOccurred())
metrics.SendValue("TestMetric", 0, "")
metrics.IncrementCounter("TestIncrementCounter")
expectedEventTypes := []string{"HttpStartClient", "HttpStartServer", "HttpStopServer", "HttpStopClient", "ValueMetricnumCPUS", "ValueMetricTestMetric", "CounterEventTestIncrementCounter"}
for _, eventType := range expectedEventTypes {
Eventually(func() bool {
lock.RLock()
defer lock.RUnlock()
_, ok := receivedEvents[eventType]
return ok
}).Should(BeTrue(), fmt.Sprintf("missing %s", eventType))
}
heartbeatUuid := heartbeatRequest.GetIdentifier().String()
Eventually(heartbeatUuidsChan).Should(Receive(Equal(heartbeatUuid)))
func (c Counter) Increment() {
metrics.IncrementCounter(string(c))
}
func main() {
flag.Parse()
config, logger := parseConfig(*debug, *configFile, *logFilePath)
dropsonde.Initialize(config.MetronAddress, "syslog_drain_binder")
workPool, err := workpool.NewWorkPool(config.EtcdMaxConcurrentRequests)
if err != nil {
panic(err)
}
adapter := etcdstoreadapter.NewETCDStoreAdapter(config.EtcdUrls, workPool)
updateInterval := time.Duration(config.UpdateIntervalSeconds) * time.Second
politician := elector.NewElector(config.InstanceName, adapter, updateInterval, logger)
drainTTL := time.Duration(config.DrainUrlTtlSeconds) * time.Second
store := etcd_syslog_drain_store.NewEtcdSyslogDrainStore(adapter, drainTTL, logger)
ticker := time.NewTicker(updateInterval)
for {
select {
case <-cfcomponent.RegisterGoRoutineDumpSignalChannel():
cfcomponent.DumpGoRoutine()
case <-ticker.C:
if politician.IsLeader() {
err = politician.StayAsLeader()
if err != nil {
logger.Errorf("Error when staying leader: %s", err.Error())
politician.Vacate()
continue
}
} else {
err = politician.RunForElection()
if err != nil {
logger.Errorf("Error when running for leader: %s", err.Error())
politician.Vacate()
continue
}
}
logger.Debugf("Polling %s for updates", config.CloudControllerAddress)
drainUrls, err := Poll(config.CloudControllerAddress, config.BulkApiUsername, config.BulkApiPassword, config.PollingBatchSize, config.SkipCertVerify)
if err != nil {
logger.Errorf("Error when polling cloud controller: %s", err.Error())
politician.Vacate()
continue
}
metrics.IncrementCounter("pollCount")
var totalDrains int
for _, drainList := range drainUrls {
totalDrains += len(drainList)
}
metrics.SendValue("totalDrains", float64(totalDrains), "drains")
logger.Debugf("Updating drain URLs for %d application(s)", len(drainUrls))
err = store.UpdateDrains(drainUrls)
if err != nil {
logger.Errorf("Error when updating ETCD: %s", err.Error())
politician.Vacate()
continue
}
}
}
}
func (c *MetricsReporter) CaptureRegistryMessage(msg reporter.ComponentTagged) {
dropsondeMetrics.IncrementCounter("registry_message." + msg.Component())
}
BeforeEach(func() {
fakeMetricSender = fake.NewFakeMetricSender()
metricBatcher := metricbatcher.New(fakeMetricSender, time.Millisecond)
metrics.Initialize(fakeMetricSender, metricBatcher)
})
It("delegates SendValue", func() {
metrics.SendValue("metric", 42.42, "answers")
Expect(fakeMetricSender.GetValue("metric").Value).To(Equal(42.42))
Expect(fakeMetricSender.GetValue("metric").Unit).To(Equal("answers"))
})
It("delegates IncrementCounter", func() {
metrics.IncrementCounter("count")
Expect(fakeMetricSender.GetCounter("count")).To(BeEquivalentTo(1))
metrics.IncrementCounter("count")
Expect(fakeMetricSender.GetCounter("count")).To(BeEquivalentTo(2))
})
It("delegates BatchIncrementCounter", func() {
metrics.BatchIncrementCounter("count")
time.Sleep(2 * time.Millisecond)
Expect(fakeMetricSender.GetCounter("count")).To(BeEquivalentTo(1))
metrics.BatchIncrementCounter("count")
time.Sleep(2 * time.Millisecond)