// Until we get a successful response from garden,
// periodically emit metrics saying how long we've been trying
// while retrying the connection indefinitely.
func waitForGarden(logger lager.Logger, gardenClient GardenClient.Client, clock clock.Clock) error {
pingStart := clock.Now()
logger = logger.Session("wait-for-garden", lager.Data{"initialTime:": pingStart})
pingRequest := clock.NewTimer(0)
pingResponse := make(chan error)
heartbeatTimer := clock.NewTimer(StalledMetricHeartbeatInterval)
for {
select {
case <-pingRequest.C():
go func() {
logger.Info("ping-garden", lager.Data{"wait-time-ns:": clock.Since(pingStart)})
pingResponse <- gardenClient.Ping()
}()
case err := <-pingResponse:
switch err.(type) {
case nil:
logger.Info("ping-garden-success", lager.Data{"wait-time-ns:": clock.Since(pingStart)})
// send 0 to indicate ping responded successfully
stalledDuration.Send(0)
return nil
case garden.UnrecoverableError:
logger.Error("failed-to-ping-garden-with-unrecoverable-error", err)
return err
default:
logger.Error("failed-to-ping-garden", err)
pingRequest.Reset(PingGardenInterval)
}
case <-heartbeatTimer.C():
logger.Info("emitting-stalled-garden-heartbeat", lager.Data{"wait-time-ns:": clock.Since(pingStart)})
stalledDuration.Send(clock.Since(pingStart))
heartbeatTimer.Reset(StalledMetricHeartbeatInterval)
}
}
}
func NewFakeTicker(clock clock.Clock, d time.Duration) clock.Ticker {
channel := make(chan time.Time)
timer := clock.NewTimer(d)
go func() {
for {
time := <-timer.C()
timer.Reset(d)
channel <- time
}
}()
return &fakeTicker{
clock: clock,
duration: d,
channel: channel,
timer: timer,
}
}