func waitForNUnitsStart(cl platform.Cluster, m platform.Member, nu int) (map[string][]util.UnitState, error) {
listUnitStates, err := cl.WaitForNActiveUnits(m, nu)
if err != nil {
return nil, fmt.Errorf("Failed to run list-units: %v", err)
}
return listUnitStates, nil
}
func waitForNUnitsSubmit(cl platform.Cluster, m platform.Member, nu int) (map[string][]util.UnitFileState, error) {
// wait until the unit gets processed up to 15 seconds
listUnitStates, err := cl.WaitForNUnitFiles(m, nu)
if err != nil {
return nil, fmt.Errorf("Failed to run list-unit-files: %v", err)
}
return listUnitStates, nil
}
func cleanUnits(cl platform.Cluster, m platform.Member, cmd string, ufs []string, nu int) (err error) {
for i := 0; i < nu; i++ {
if _, _, err := cl.Fleetctl(m, cmd, ufs[i]); err != nil {
return fmt.Errorf("Failed to %s unit: %v", cmd, err)
}
}
return nil
}
// waitForFleetdSocket returns if /var/run/fleet.sock exists, periodically
// checking for states.
func waitForFleetdSocket(cluster platform.Cluster, m0 platform.Member) (err error) {
_, err = util.WaitForState(
func() bool {
stdout, _, _ := cluster.MemberCommand(m0, "test -S /var/run/fleet.sock && echo 1")
if strings.TrimSpace(stdout) == "" {
fmt.Errorf("Fleetd is not fully started, retrying...")
return false
}
return true
},
)
if err != nil {
return fmt.Errorf("Fleetd socket not found: %v", err)
}
return nil
}
func launchUnitsCmd(cluster platform.Cluster, m platform.Member, cmd string, numUnits int) (unitFiles []string, err error) {
args := []string{cmd}
for i := 0; i < numUnits; i++ {
unitFile := fmt.Sprintf("fixtures/units/hello@%d.service", i+1)
args = append(args, unitFile)
unitFiles = append(unitFiles, path.Base(unitFile))
}
if stdout, stderr, err := cluster.Fleetctl(m, args...); err != nil {
return nil,
fmt.Errorf("Unable to %s batch of units: \nstdout: %s\nstderr: %s\nerr: %v",
cmd, stdout, stderr, err)
} else if strings.Contains(stderr, "Error") {
return nil,
fmt.Errorf("Failed to correctly %s batch of units: \nstdout: %s\nstderr: %s\nerr: %v",
cmd, stdout, stderr, err)
}
return unitFiles, nil
}
// waitForReloadConfig returns if a message "Reloading configuration" exists
// in the journal, periodically checking for the journal up to the timeout.
func waitForReloadConfig(cluster platform.Cluster, m0 platform.Member) (err error) {
_, err = util.WaitForState(
func() bool {
// NOTE: journalctl should run just simply like "journalctl -u fleet",
// without being piped with grep. Doing
// "journalctl -u fleet | grep \"Reloading configuration\"" is racy
// in a subtle way, so that it sometimes fails only on semaphoreci.
// - dpark 20160408
stdout, _, _ := cluster.MemberCommand(m0, "sudo", "journalctl --priority=info _PID=$(pidof fleetd)")
journalfleet := strings.TrimSpace(stdout)
if !strings.Contains(journalfleet, "Reloading configuration") {
fmt.Errorf("Fleetd is not fully reconfigured, retrying... entire fleet journal:\n%v", journalfleet)
return false
}
return true
},
)
if err != nil {
return fmt.Errorf("Reloading configuration log not found: %v", err)
}
return nil
}