all: gofmt

cmd/juju/status.go

 package main
 
 import (
         "fmt"
         "strconv"
 
         "launchpad.net/gnuflag"
         "launchpad.net/juju-core/cmd"
         "launchpad.net/juju-core/environs"
         "launchpad.net/juju-core/juju"
@@ skipping 86 matching lines @@
         machines, err := st.AllMachines()
         if err != nil {
                 return nil, err
         }
         for _, m := range machines {
                 v[m.Id()] = m
         }
         return v, nil
 }
 
-// fetchAllServices returns a map representing a mapping of service 
+// fetchAllServices returns a map representing a mapping of service
 // names to services.
 func fetchAllServices(st *state.State) (map[string]*state.Service, error) {
         v := make(map[string]*state.Service)
         services, err := st.AllServices()
         if err != nil {
                 return nil, err
         }
         for _, s := range services {
                 v[s.Name()] = s
         }
         return v, nil
 }
 
 // processMachines gathers information about machines.
 func processMachines(machines map[int]*state.Machine, instances map[string]environs.Instance) (map[int]interface{}, error) {
         r := make(map[int]interface{})
         for _, m := range machines {
                 instid, err := m.InstanceId()
                 if err, ok := err.(*state.NotFoundError); ok {
                         r[m.Id()] = map[string]interface{}{
                                 "instance-id": "pending",
                         }
                 } else if err != nil {
                         return nil, err
                 } else {
                         instance, ok := instances[instid]
                         if !ok {
                                 // Double plus ungood. There is an instance id recorded for this machine in the state,
-                                // yet the environ cannot find that id. 
+                                // yet the environ cannot find that id.
                                 return nil, fmt.Errorf("instance %s for machine %d not found", instid, m.Id())
                         }
                         r[m.Id()] = checkError(processMachine(m, instance))
                 }
         }
         return r, nil
 }
 
 func processMachine(machine *state.Machine, instance environs.Instance) (map[string]interface{}, error) {
         r := m()
@@ skipping 116 matching lines @@
 }
 
 func m() map[string]interface{} { return make(map[string]interface{}) }
 
 func checkError(m map[string]interface{}, err error) map[string]interface{} {
         if err != nil {
                 return map[string]interface{}{"status-error": err.Error()}
         }
         return m
 }