func ConfigureCapacity(
gardenClient garden_client.Client,
memoryMBFlag string,
diskMBFlag string,
) (executor.ExecutorResources, error) {
gardenCapacity, err := gardenClient.Capacity()
if err != nil {
return executor.ExecutorResources{}, err
}
memory, err := memoryInMB(gardenCapacity, memoryMBFlag)
if err != nil {
return executor.ExecutorResources{}, err
}
disk, err := diskInMB(gardenCapacity, diskMBFlag)
if err != nil {
return executor.ExecutorResources{}, err
}
return executor.ExecutorResources{
MemoryMB: memory,
DiskMB: disk,
Containers: int(gardenCapacity.MaxContainers),
}, nil
}
func destroyAllContainers(client client.Client) {
containers, err := client.Containers(nil)
Ω(err).ShouldNot(HaveOccurred(), "Error while listing containers")
for _, container := range containers {
err = client.Destroy(container.Handle())
Ω(err).ShouldNot(HaveOccurred(), fmt.Sprintf("Error while destroying container %+v", container.Handle()))
}
}
// 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)
}
}
}