func getUnitStatePage(cAPI client.API, machineID, unitName string, tok PageToken) (*schema.UnitStatePage, error) {
states, err := cAPI.UnitStates()
if err != nil {
return nil, err
}
var filtered []*schema.UnitState
for _, us := range states {
if machineID != "" && machineID != us.MachineID {
continue
}
if unitName != "" && unitName != us.Name {
continue
}
filtered = append(filtered, us)
}
items, next := extractUnitStatePageData(filtered, tok)
page := schema.UnitStatePage{
States: items,
}
if next != nil {
page.NextPageToken = next.Encode()
}
return &page, nil
}
func getMachinePage(cAPI client.API, tok PageToken) (*schema.MachinePage, error) {
all, err := cAPI.Machines()
if err != nil {
return nil, err
}
page := extractMachinePage(all, tok)
return page, nil
}
func getMachines(client fleetClient.API, outMachines map[string]string) error {
machines, err := client.Machines()
if err != nil {
return err
}
for _, machine := range machines {
outMachines[machine.ID] = machine.PublicIP
}
return nil
}
func fleetUnitHealthHandler(fleetAPIClient client.API, checker fleetUnitHealthChecker) func(w http.ResponseWriter, r *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
checks := []fthealth.Check{}
unitStates, err := fleetAPIClient.UnitStates()
if err != nil {
panic(err)
}
for _, unitState := range unitStates {
checks = append(checks, newFleetUnitHealthCheck(*unitState, checker))
}
fthealth.HandlerParallel("Coco Fleet Unit Healthcheck", "Checks the health of all fleet units", checks...)(w, r)
}
}
func waitForSystemdState(client client.API, unit string, allowedStates []string) error {
seenDesiredState := 0
for {
states, err := client.UnitStates()
if err != nil {
return maskAny(err)
}
found := false
seenDesired := false
for _, state := range states {
if state.Name == unit {
found = true
for _, allowedState := range allowedStates {
if allowedState == state.SystemdActiveState {
seenDesired = true
}
}
}
}
if found && !seenDesired {
seenDesiredState = 0
} else {
seenDesiredState++
}
if seenDesiredState > 5 {
return nil
}
time.Sleep(500 * time.Millisecond)
}
return nil
}
func getUnitPage(cAPI client.API, tok PageToken) (*schema.UnitPage, error) {
units, err := cAPI.Units()
if err != nil {
return nil, err
}
items, next := extractUnitPageData(units, tok)
page := schema.UnitPage{
Units: items,
}
if next != nil {
page.NextPageToken = next.Encode()
}
return &page, nil
}
func TestNullAPI(test *testing.T) {
var api client.API = new(nullAPI)
// all the methods return errors, all the time.
if _, err := api.Machines(); err == nil {
test.Error("Machines() did not return an error")
}
if _, err := api.Unit("foo"); err == nil {
test.Error("Unit() did not return an error")
}
if _, err := api.Units(); err == nil {
test.Error("Units() did not return an error")
}
if _, err := api.UnitStates(); err == nil {
test.Error("UnitStates() did not return an error")
}
if err := api.SetUnitTargetState("foo", "bar"); err == nil {
test.Error("SetUnitTargetState() did not return an error")
}
if err := api.CreateUnit(nil); err == nil {
test.Error("CreateUnit() did not return an error")
}
if err := api.DestroyUnit("foo"); err == nil {
test.Error("DestroyUnit() did not return an error")
}
}