cmd/juju/ensureavailability: default to 3 servers

state/addmachine.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package state
 
 import (
         "fmt"
         "strconv"
 
         "labix.org/v2/mgo/bson"
@@ skipping 479 matching lines @@
                         {"$addToSet", bson.D{{"votingmachineids", bson.D{{"$each", newVotingIds}}}}},
                 },
         }}
         return ops, nil
 }
 
 // EnsureAvailability adds state server machines as necessary to make
 // the number of live state servers equal to numStateServers. The given
 // constraints and series will be attached to any new machines.
 func (st *State) EnsureAvailability(numStateServers int, cons constraints.Value, series string) error {
-        if numStateServers%2 != 1 || numStateServers <= 0 {
-                return fmt.Errorf("number of state servers must be odd and greater than zero")
+        if numStateServers < 0 || (numStateServers != 0 && numStateServers%2 != 1) {
+                return fmt.Errorf("number of state servers must be odd and non-negative")
         }
         if numStateServers > replicaset.MaxPeers {
                 return fmt.Errorf("state server count is too large (allowed %d)", replicaset.MaxPeers)
         }
         for i := 0; i < 5; i++ {
                 currentInfo, err := st.StateServerInfo()
                 if err != nil {
                         return err
                 }
-                if len(currentInfo.VotingMachineIds) > numStateServers {
+                desiredStateServerCount := numStateServers
+                if desiredStateServerCount == 0 {
+                        desiredStateServerCount = len(currentInfo.VotingMachineIds)
+                        if desiredStateServerCount <= 1 {
+                                desiredStateServerCount = 3
+                        }
+                }
+                if len(currentInfo.VotingMachineIds) > desiredStateServerCount {
                         return fmt.Errorf("cannot reduce state server count")
                 }
 
                 intent, err := st.ensureAvailabilityIntentions(currentInfo)
                 if err != nil {
                         return err
                 }
                 voteCount := 0
                 for _, m := range intent.maintain {
                         if m.WantsVote() {
                                 voteCount++
                         }
                 }
-                if voteCount == numStateServers && len(intent.remove) == 0 {
+                if voteCount == desiredStateServerCount && len(intent.remove) == 0 {
                         return nil
                 }
                 // Promote as many machines as we can to fulfil the shortfall.
-                if n := numStateServers - voteCount; n < len(intent.promote) {
+                if n := desiredStateServerCount - voteCount; n < len(intent.promote) {
                         intent.promote = intent.promote[:n]
                 }
                 voteCount += len(intent.promote)
-                intent.newCount = numStateServers - voteCount
+                intent.newCount = desiredStateServerCount - voteCount
                 logger.Infof("%d new machines; promoting %v", intent.newCount, intent.promote)
                 ops, err := st.ensureAvailabilityIntentionOps(intent, currentInfo, cons, series)
                 if err != nil {
                         return err
                 }
                 err = st.runTransaction(ops)
                 if err == nil {
                         return nil
                 }
                 if err != txn.ErrAborted {
@@ skipping 142 matching lines @@
                 Update: bson.D{
                         {"$pull", bson.D{{"jobs", JobManageEnviron}}},
                         {"$set", bson.D{{"novote", false}}},
                 },
         }, {
                 C:      m.st.stateServers.Name,
                 Id:     environGlobalKey,
                 Update: bson.D{{"$pull", bson.D{{"machineids", m.doc.Id}}}},
         }}
 }