statecmd: don't use juju.Conn unnecessarily

state/state.go

 // The state package enables reading, observing, and changing
 // the state stored in MongoDB of a whole environment
 // managed by juju.
 package state
 
 import (
         "fmt"
         "labix.org/v2/mgo"
         "labix.org/v2/mgo/bson"
         "labix.org/v2/mgo/txn"
@@ skipping 734 matching lines @@
         err := st.units.FindId(name).One(&doc)
         if err == mgo.ErrNotFound {
                 return nil, NotFoundf("unit %q", name)
         }
         if err != nil {
                 return nil, fmt.Errorf("cannot get unit %q: %v", name, err)
         }
         return newUnit(st, &doc), nil
 }
 
+// DestroyUnits destroys the units with the specified names.
+func (st *State) DestroyUnits(names ...string) (err error) {
+        // TODO(rog) make this a transaction?
+        var errs []string
+        for _, name := range names {
+                unit, err := st.Unit(name)
+                switch {
+                case IsNotFound(err):
+                        err = fmt.Errorf("unit %q does not exist", name)
+                case err != nil:
+                case unit.Life() != Alive:
+                        continue
+                case unit.IsPrincipal():
+                        err = unit.Destroy()
+                default:
+                        err = fmt.Errorf("unit %q is a subordinate", name)
+                }
+                if err != nil {
+                        errs = append(errs, err.Error())
+                }
+        }
+        return destroyErr("units", names, errs)
+}
+
+// DestroyMachines destroys the machines with the specified ids.
+func (st *State) DestroyMachines(ids ...string) (err error) {
+        var errs []string
+        for _, id := range ids {
+                machine, err := st.Machine(id)
+                switch {
+                case IsNotFound(err):
+                        err = fmt.Errorf("machine %s does not exist", id)
+                case err != nil:
+                case machine.Life() != Alive:
+                        continue
+                default:
+                        err = machine.Destroy()
+                }
+                if err != nil {
+                        errs = append(errs, err.Error())
+                }
+        }
+        return destroyErr("machines", ids, errs)
+}
+
+func destroyErr(desc string, ids, errs []string) error {
+        if len(errs) == 0 {
+                return nil
+        }
+        msg := "some %s were not destroyed"
+        if len(errs) == len(ids) {
+                msg = "no %s were destroyed"
+        }
+        msg = fmt.Sprintf(msg, desc)
+        return fmt.Errorf("%s: %s", msg, strings.Join(errs, "; "))
+}
+
 // AssignUnit places the unit on a machine. Depending on the policy, and the
 // state of the environment, this may lead to new instances being launched
 // within the environment.
 func (st *State) AssignUnit(u *Unit, policy AssignmentPolicy) (err error) {
         if !u.IsPrincipal() {
                 return fmt.Errorf("subordinate unit %q cannot be assigned directly to a machine", u)
         }
         defer trivial.ErrorContextf(&err, "cannot assign unit %q to machine", u)
         var m *Machine
         switch policy {
@@ skipping 114 matching lines @@
                 }}
                 if err := st.runner.Run(ops, "", nil); err != nil {
                         return fmt.Errorf("cannot remove empty cleanup document: %v", err)
                 }
         }
         if err := iter.Err(); err != nil {
                 return fmt.Errorf("cannot read cleanup document: %v", err)
         }
         return nil
 }