state/api: implement machine watching

state/api/apiserver.go

 package api
 
 import (
         "code.google.com/p/go.net/websocket"
         "fmt"
+        "launchpad.net/juju-core/log"
         "launchpad.net/juju-core/state"
+        "launchpad.net/juju-core/state/statecmd"
         statewatcher "launchpad.net/juju-core/state/watcher"
         "strconv"
         "sync"
 )
 
 // TODO(rog) remove this when the rest of the system
 // has been updated to set passwords appropriately.
 var AuthenticationEnabled = false
 
 // srvRoot represents a single client's connection to the state.
@@ skipping 45 matching lines @@
         }
         r.admin = &srvAdmin{
                 root: r,
         }
         r.client = &srvClient{
                 root: r,
         }
         return r
 }
 
+// Kill implements rpc.Killer.  It cleans up any resources that need
+// cleaning up to ensure that all outstanding requests return.
+func (r *srvRoot) Kill() {
+        r.watchers.stopAll()
+}
+
+// Admin returns an object that provides API access
+// to methods that can be called even when not
+// authenticated.
 func (r *srvRoot) Admin(id string) (*srvAdmin, error) {
         if id != "" {
                 // Safeguard id for possible future use.
                 return nil, errBadId
         }
         return r.admin, nil
 }
 
 // requireAgent checks whether the current client is an agent and hence
 // may access the agent APIs.  We filter out non-agents when calling one
@@ skipping 16 matching lines @@
         e := r.user.entity()
         if e == nil {
                 return errNotLoggedIn
         }
         if isAgent(e) {
                 return errPerm
         }
         return nil
 }
 
-// Machine returns returns an object that provides
+// Machine returns an object that provides
 // API access to methods on a state.Machine.
 func (r *srvRoot) Machine(id string) (*srvMachine, error) {
         if err := r.requireAgent(); err != nil {
                 return nil, err
         }
         m, err := r.srv.state.Machine(id)
         if err != nil {
                 return nil, err
         }
         return &srvMachine{
                 root: r,
                 m:    m,
         }, nil
 }
 
-// Unit returns returns an object that provides
+// Unit returns an object that provides
 // API access to methods on a state.Unit.
 func (r *srvRoot) Unit(name string) (*srvUnit, error) {
         if err := r.requireAgent(); err != nil {
                 return nil, err
         }
         u, err := r.srv.state.Unit(name)
         if err != nil {
                 return nil, err
         }
         return &srvUnit{
                 root: r,
                 u:    u,
         }, nil
 }
 
-// User returns returns an object that provides
+// User returns an object that provides
 // API access to methods on a state.User.
 func (r *srvRoot) User(name string) (*srvUser, error) {
         // Any user is allowed to access their own user object.
         // We check at this level rather than at the operation
         // level to stop malicious probing for current user names.
         // When we provide support for user administration,
         // this will need to be changed to allow access to
         // the administrator.
         e := r.user.entity()
         if e == nil {
@@ skipping 71 matching lines @@
         }
         for _, m := range ms {
                 instId, _ := m.InstanceId()
                 status.Machines[m.Id()] = MachineInfo{
                         InstanceId: string(instId),
                 }
         }
         return status, nil
 }
 
+// ServiceSet implements the server side of Client.ServerSet.
+func (c *srvClient) ServiceSet(p statecmd.ServiceSetParams) error {
+        return statecmd.ServiceSet(c.root.srv.state, p)
+}
+
+// ServiceSetYAML implements the server side of Client.ServerSetYAML.
+func (c *srvClient) ServiceSetYAML(p statecmd.ServiceSetYAMLParams) error {
+        return statecmd.ServiceSetYAML(c.root.srv.state, p)
+}
+
+func (c *srvClient) ServiceGet(args statecmd.ServiceGetParams) (statecmd.ServiceGetResults, error) {
+        return statecmd.ServiceGet(c.root.srv.state, args)
+}
+
+// EnvironmentInfo returns information about the current environment (default
+// series and type).
+func (c *srvClient) EnvironmentInfo() (EnvironmentInfo, error) {
+        conf, err := c.root.srv.state.EnvironConfig()
+        if err != nil {
+                return EnvironmentInfo{}, err
+        }
+        info := EnvironmentInfo{
+                DefaultSeries: conf.DefaultSeries(),
+                ProviderType:  conf.Type(),
+        }
+        return info, nil
+}
+
 type rpcCreds struct {
         EntityName string
         Password   string
 }
 
 // Login logs in with the provided credentials.
 // All subsequent requests on the connection will
 // act as the authenticated user.
 func (a *srvAdmin) Login(c rpcCreds) error {
         return a.root.user.login(a.root.srv.state, c.EntityName, c.Password)
@@ skipping 213 matching lines @@
         defer ws.mu.Unlock()
         ws.maxId++
         sw := &srvWatcher{
                 ws: ws,
                 id: strconv.FormatUint(ws.maxId, 10),
                 w:  w,
         }
         ws.ws[sw.id] = sw
         return sw
 }
+
+func (ws *watchers) stopAll() {
+        ws.mu.Lock()
+        defer ws.mu.Unlock()
+        for _, w := range ws.ws {
+                if err := w.w.Stop(); err != nil {
+                        log.Printf("state/api: error stopping %T watcher: %v", w, err)
+                }
+        }
+        ws.ws = make(map[string]*srvWatcher)
+}