Add output for ensure-availability command.

state/apiserver/client/client.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package client
 
 import (
         "fmt"
         "net/url"
         "os"
+        "sort"
         "strings"
 
         "github.com/juju/errors"
         "github.com/juju/loggo"
 
         "launchpad.net/juju-core/charm"
         "launchpad.net/juju-core/environs"
         "launchpad.net/juju-core/environs/config"
         "launchpad.net/juju-core/environs/manual"
         envtools "launchpad.net/juju-core/environs/tools"
@@ skipping 1043 matching lines @@
 }
 
 // APIHostPorts returns the API host/port addresses stored in state.
 func (c *Client) APIHostPorts() (result params.APIHostPortsResult, err error) {
         if result.Servers, err = c.api.state.APIHostPorts(); err != nil {
                 return params.APIHostPortsResult{}, err
         }
         return result, nil
 }
 
+// sortable slice of machine ids
+type machineIdSlice []string
+
+func (ms machineIdSlice) Len() int      { return len(ms) }
+func (ms machineIdSlice) Swap(i, j int) { ms[i], ms[j] = ms[j], ms[i] }
+func (ms machineIdSlice) Less(i, j int) bool {
+        return state.MachineIdLessThan(ms[i], ms[j])
+}
+
+// Generate an EnsureAvailabilityResult structure from before and after
+// StateServerInfo.
+func ensureAvailabilityResultFromSSI(SSIBefore, SSIAfter *state.StateServerInfo) params.EnsureAvailabilityResult {

[fwereade, 2014/06/02 09:50:03]

it's jarring to have vars with uppercase at the beginning. ssiBefore, ssiAfter?

+        result := params.EnsureAvailabilityResult{}
+
+        before := SSIBefore.MachineIds
+        after := SSIAfter.MachineIds
+
+        sort.Sort(machineIdSlice(before))
+        sort.Sort(machineIdSlice(after))
+
+        lnB := len(before)
+        lnA := len(after)
+
+        i := 0
+        j := 0
+        for i < lnB && j < lnA {
+                if before[i] == after[j] {
+                        result.Maintained = append(
+                                result.Maintained,
+                                before[i])
+                        i++
+                        j++
+                } else if state.MachineIdLessThan(before[i], after[j]) {
+                        result.Removed = append(
+                                result.Removed,
+                                before[i])
+                        i++
+                } else if state.MachineIdLessThan(after[j], before[i]) {
+                        result.Added = append(
+                                result.Added,
+                                after[j])
+                        j++
+                }
+        }
+        if i < lnB {
+                result.Removed = append(
+                        result.Removed,
+                        before[i:]...)
+        }
+        if j < lnA {
+                result.Added = append(
+                        result.Added,
+                        after[j:]...)
+        }
+        return result

[fwereade, 2014/06/02 09:50:03]

I feel we could probably do this more easily with some set.Strings~s?

+}
+
 // EnsureAvailability ensures the availability of Juju state servers.
-func (c *Client) EnsureAvailability(args params.EnsureAvailability) error {
+func (c *Client) EnsureAvailability(args params.EnsureAvailability) (params.EnsureAvailabilityResult, error) {

[fwereade, 2014/06/02 09:50:03]

Grar. Nate, have we yet released a stable with this API? It ought to be both
accepting and returning bulk args.

(note: I'm easy on how we indicate "the current environment", I'd prefer a
special magic string that can't be confused for an environ tag, but I think we
still want to specify it)

         series := args.Series
+        ssiBefore, err := c.api.state.StateServerInfo()
+        if err != nil {
+                return params.EnsureAvailabilityResult{}, err
+        }
+
         if series == "" {
-                ssi, err := c.api.state.StateServerInfo()
-                if err != nil {
-                        return err
-                }
                 // We should always have at least one voting machine
                 // If we *really* wanted we could just pick whatever series is
                 // in the majority, but really, if we always copy the value of
                 // the first one, then they'll stay in sync.
-                if len(ssi.VotingMachineIds) == 0 {
+                if len(ssiBefore.VotingMachineIds) == 0 {
                         // Better than a panic()?
-                        return fmt.Errorf("internal error, failed to find any voting machines")
+                        return params.EnsureAvailabilityResult{}, fmt.Errorf("internal error, failed to find any voting machines")
                 }
-                templateMachine, err := c.api.state.Machine(ssi.VotingMachineIds[0])
+                templateMachine, err := c.api.state.Machine(ssiBefore.VotingMachineIds[0])
                 if err != nil {
-                        return err
+                        return params.EnsureAvailabilityResult{}, err
                 }
                 series = templateMachine.Series()
         }
-        return c.api.state.EnsureAvailability(args.NumStateServers, args.Constraints, series)
+        err = c.api.state.EnsureAvailability(args.NumStateServers, args.Constraints, series)
+        if err != nil {
+                return params.EnsureAvailabilityResult{}, err
+        }
+
+        ssiAfter, err := c.api.state.StateServerInfo()
+        if err != nil {
+                return params.EnsureAvailabilityResult{}, err
+        }
+        return ensureAvailabilityResultFromSSI(ssiBefore, ssiAfter), nil
 }