Continued development of the machine state.

state/state.go

 // launchpad.net/juju/state
 //
 // Copyright (c) 2011-2012 Canonical Ltd.
 
 // The state package enables reading, observing, and changing
 // the state stored in ZooKeeper of a whole environment
 // managed by juju.
 package state
 
 import (
@@ skipping 20 matching lines @@
         key := strings.Split(path, "/")[2]
         addMachine := func(t *topology) error {
                 return t.AddMachine(key)
         }
         if err = retryTopologyChange(s.zk, addMachine); err != nil {
                 return nil, err
         }
         return &Machine{s, key}, nil
 }
 
+// RemoveMachine removes the machine with the given id.
+func (s *State) RemoveMachine(id int) error {
+        key := machineKey(id)
+        removeMachine := func(t *topology) error {
+                if !t.HasMachine(key) {
+                        return fmt.Errorf("machine not found")
+                }
+                hasUnits, err := t.MachineHasUnits(key)
+                if err != nil {
+                        return err
+                }
+                if hasUnits {
+                        return fmt.Errorf("machine has units")
+                }
+                return t.RemoveMachine(key)
+        }
+        if err := retryTopologyChange(s.zk, removeMachine); err != nil {
+                return fmt.Errorf("can't remove machine %d: %v", id, err)
+        }
+        return zkRemoveTree(s.zk, fmt.Sprintf("/machines/%s", key))
+}
+
+// Machine returns the machine with the given id.
+func (s *State) Machine(id int) (*Machine, error) {
+        key := machineKey(id)
+        topology, err := readTopology(s.zk)
+        if err != nil {
+                return nil, err
+        }
+        if !topology.HasMachine(key) {
+                return nil, fmt.Errorf("machine %d not found", id)
+        }
+        return &Machine{s, key}, nil
+}
+
+// AllMachines returns all machines in the environment.
+func (s *State) AllMachines() ([]*Machine, error) {
+        topology, err := readTopology(s.zk)
+        if err != nil {
+                return nil, err
+        }
+        machines := []*Machine{}
+        for _, key := range topology.MachineKeys() {
+                machines = append(machines, &Machine{s, key})
+        }
+        return machines, nil
+}
+
 // AddCharm adds the ch charm with curl to the state.
 // bundleUrl must be set to a URL where the bundle for ch
 // may be downloaded from.
 // On success the newly added charm state is returned.
 func (s *State) AddCharm(ch charm.Charm, curl *charm.URL, bundleURL *url.URL) (*Charm, error) {
         data := &charmData{
                 Meta:      ch.Meta(),
                 Config:    ch.Config(),
                 BundleURL: bundleURL.String(),
         }
@@ skipping 165 matching lines @@
         // TODO Create node for bootstrap machine.
 
         // TODO Setup default global settings information.
 
         // Finally creation of /initialized as marker.
         if _, err := s.zk.Create("/initialized", "", 0, zkPermAll); err != nil {
                 return err
         }
         return nil
 }