~rogpeppe/juju-core/256-more-status

« back to all changes in this revision

Viewing changes to state/state.go

statecmd: don't use juju.Conn unnecessarily

There's an associated cost when the API uses juju.Conn,
so we want to avoid it when reasonable.
This change moves some operations from juju into
state because they don't require juju.Conn's associated
Environ.

R=fwereade, dimitern
CC=
https://codereview.appspot.com/7945044

Show diffs side-by-side

added added

removed removed

Lines of Context:
752
752
        return newUnit(st, &doc), nil
753
753
}
754
754
 
 
755
// DestroyUnits destroys the units with the specified names.
 
756
func (st *State) DestroyUnits(names ...string) (err error) {
 
757
        // TODO(rog) make this a transaction?
 
758
        var errs []string
 
759
        for _, name := range names {
 
760
                unit, err := st.Unit(name)
 
761
                switch {
 
762
                case IsNotFound(err):
 
763
                        err = fmt.Errorf("unit %q does not exist", name)
 
764
                case err != nil:
 
765
                case unit.Life() != Alive:
 
766
                        continue
 
767
                case unit.IsPrincipal():
 
768
                        err = unit.Destroy()
 
769
                default:
 
770
                        err = fmt.Errorf("unit %q is a subordinate", name)
 
771
                }
 
772
                if err != nil {
 
773
                        errs = append(errs, err.Error())
 
774
                }
 
775
        }
 
776
        return destroyErr("units", names, errs)
 
777
}
 
778
 
 
779
// DestroyMachines destroys the machines with the specified ids.
 
780
func (st *State) DestroyMachines(ids ...string) (err error) {
 
781
        var errs []string
 
782
        for _, id := range ids {
 
783
                machine, err := st.Machine(id)
 
784
                switch {
 
785
                case IsNotFound(err):
 
786
                        err = fmt.Errorf("machine %s does not exist", id)
 
787
                case err != nil:
 
788
                case machine.Life() != Alive:
 
789
                        continue
 
790
                default:
 
791
                        err = machine.Destroy()
 
792
                }
 
793
                if err != nil {
 
794
                        errs = append(errs, err.Error())
 
795
                }
 
796
        }
 
797
        return destroyErr("machines", ids, errs)
 
798
}
 
799
 
 
800
func destroyErr(desc string, ids, errs []string) error {
 
801
        if len(errs) == 0 {
 
802
                return nil
 
803
        }
 
804
        msg := "some %s were not destroyed"
 
805
        if len(errs) == len(ids) {
 
806
                msg = "no %s were destroyed"
 
807
        }
 
808
        msg = fmt.Sprintf(msg, desc)
 
809
        return fmt.Errorf("%s: %s", msg, strings.Join(errs, "; "))
 
810
}
 
811
 
755
812
// AssignUnit places the unit on a machine. Depending on the policy, and the
756
813
// state of the environment, this may lead to new instances being launched
757
814
// within the environment.