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

« back to all changes in this revision

Viewing changes to juju/conn.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:
16
16
        "launchpad.net/juju-core/trivial"
17
17
        "net/url"
18
18
        "os"
19
 
        "strings"
20
19
        "time"
21
20
)
22
21
 
288
287
        units := make([]*state.Unit, n)
289
288
        // TODO what do we do if we fail half-way through this process?
290
289
        for i := 0; i < n; i++ {
 
290
                // TODO store AssignmentPolicy in state, thus removing the need
 
291
                // for this to use conn.Environ.
291
292
                policy := conn.Environ.AssignmentPolicy()
292
293
                unit, err := svc.AddUnit()
293
294
                if err != nil {
302
303
        return units, nil
303
304
}
304
305
 
305
 
// DestroyMachines destroys the specified machines.
306
 
func (conn *Conn) DestroyMachines(ids ...string) (err error) {
307
 
        var errs []string
308
 
        for _, id := range ids {
309
 
                machine, err := conn.State.Machine(id)
310
 
                switch {
311
 
                case state.IsNotFound(err):
312
 
                        err = fmt.Errorf("machine %s does not exist", id)
313
 
                case err != nil:
314
 
                case machine.Life() != state.Alive:
315
 
                        continue
316
 
                default:
317
 
                        err = machine.Destroy()
318
 
                }
319
 
                if err != nil {
320
 
                        errs = append(errs, err.Error())
321
 
                }
322
 
        }
323
 
        return destroyErr("machines", ids, errs)
324
 
}
325
 
 
326
 
// DestroyUnits destroys the specified units.
327
 
func (conn *Conn) DestroyUnits(names ...string) (err error) {
328
 
        var errs []string
329
 
        for _, name := range names {
330
 
                unit, err := conn.State.Unit(name)
331
 
                switch {
332
 
                case state.IsNotFound(err):
333
 
                        err = fmt.Errorf("unit %q does not exist", name)
334
 
                case err != nil:
335
 
                case unit.Life() != state.Alive:
336
 
                        continue
337
 
                case unit.IsPrincipal():
338
 
                        err = unit.Destroy()
339
 
                default:
340
 
                        err = fmt.Errorf("unit %q is a subordinate", name)
341
 
                }
342
 
                if err != nil {
343
 
                        errs = append(errs, err.Error())
344
 
                }
345
 
        }
346
 
        return destroyErr("units", names, errs)
347
 
}
348
 
 
349
 
func destroyErr(desc string, ids, errs []string) error {
350
 
        if len(errs) == 0 {
351
 
                return nil
352
 
        }
353
 
        msg := "some %s were not destroyed"
354
 
        if len(errs) == len(ids) {
355
 
                msg = "no %s were destroyed"
356
 
        }
357
 
        msg = fmt.Sprintf(msg, desc)
358
 
        return fmt.Errorf("%s: %s", msg, strings.Join(errs, "; "))
359
 
}
360
 
 
361
306
// Resolved marks the unit as having had any previous state transition
362
307
// problems resolved, and informs the unit that it may attempt to
363
308
// reestablish normal workflow. The retryHooks parameter informs