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 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 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 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 {
                 return nil, errNotLoggedIn
         }
         if e.EntityName() != name {
                 return nil, errPerm
         }
         u, err := r.srv.state.User(name)
         if err != nil {
                 return nil, err
         }
         return &srvUser{
                 root: r,
                 u:    u,
         }, nil
 }
 
+// EntityWatcher returns an object that provides
+// API access to methods on a state.EntityWatcher.
+// Each client has its own current set of watchers, stored
+// in r.watchers.
 func (r *srvRoot) EntityWatcher(id string) (srvEntityWatcher, error) {

[dimitern, 2013/02/21 11:23:29]

Comment here please?

[fwereade, 2013/02/25 09:03:43]

+1

[rog, 2013/02/25 10:50:00]

done. added comments to some other methods too.

[fwereade, 2013/02/25 11:24:13]

<3

         if err := r.requireAgent(); err != nil {
                 return srvEntityWatcher{}, err
         }
         w := r.watchers.get(id)
         if w == nil {
                 return srvEntityWatcher{}, errUnknownWatcher
         }
         if _, ok := w.w.(*state.EntityWatcher); !ok {
                 return srvEntityWatcher{}, errUnknownWatcher
         }
         return srvEntityWatcher{w}, nil
 }
 
+// Client returns an object that provides access
+// to methods accessible to non-agent clients.
+func (r *srvRoot) Client(id string) (*srvClient, error) {
+        if err := r.requireClient(); err != nil {
+                return nil, err
+        }
+        if id != "" {
+                // Safeguard id for possible future use.
+                return nil, errBadId
+        }
+        return r.client, nil
+}
+
 type srvEntityWatcher struct {
         *srvWatcher
 }
 
+// Next returns when a change has occurred to the
+// entity being watched since the most recent call to Next
+// or the Watch call that created the EntityWatcher.
 func (w srvEntityWatcher) Next() error {
         if _, ok := <-w.w.(*state.EntityWatcher).Changes(); ok {
                 return nil
         }
         err := w.w.Err()
         if err == nil {
                 err = errStoppedWatcher
         }
         return err
-}
-
-func (r *srvRoot) Client(id string) (*srvClient, error) {
-        if err := r.requireClient(); err != nil {
-                return nil, err
-        }
-        if id != "" {
-                // Safeguard id for possible future use.
-                return nil, errBadId
-        }
-        return r.client, nil
 }
 
 func (c *srvClient) Status() (Status, error) {
         ms, err := c.root.srv.state.AllMachines()
         if err != nil {
                 return Status{}, err
         }
         status := Status{
                 Machines: make(map[string]MachineInfo),
         }
         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.
@@ skipping 24 matching lines @@
         return rpcEntityWatcherId{
                 EntityWatcherId: m.root.watchers.register(w).id,
         }, nil
 }
 
 type rpcPassword struct {
         Password string
 }
 
 func setPassword(e state.AuthEntity, password string) error {
         // Catch expected common case of mispelled

[dimitern, 2013/02/21 11:23:29]

why misspelled? it only checks for empty one.

[rog, 2013/02/25 10:50:00]

if the caller sends a message with a field named "Passwd", we'll see it here as
an empty password field.

         // or missing Password parameter.
         if password == "" {
                 return fmt.Errorf("password is empty")
         }
         return e.SetPassword(password)
 }
 
 // SetPassword sets the machine's password.
 func (m *srvMachine) SetPassword(p rpcPassword) error {
         // Allow:
@@ skipping 109 matching lines @@
         }
         return false
 }
 
 // isAgent returns whether the given entity is an agent.
 func isAgent(e state.AuthEntity) bool {
         _, isUser := e.(*state.User)
         return !isUser
 }
 
+// watcher represents the interface provided by state watchers.
 type watcher interface {
         Stop() error
         Err() error

[dimitern, 2013/02/21 11:23:29]

Is there a special reason no to implement Error() instead? Seems useful to be
able to handle watchers as errors in some cases.

[fwereade, 2013/02/25 09:03:43]

Eww! Please don't do that. They're totally different things and no good will
come of conflating them IMO.

[rog, 2013/02/25 10:50:00]

this interface reflects the existing interface common to all state watcher
implementations - i'm not implementing it here.

 }
 
 // watchers holds all the watchers for a connection.
 type watchers struct {
         mu    sync.Mutex
         maxId uint64
         ws    map[string]*srvWatcher
 }
 
-// srvWatcher holds the details of a watcher.
-// It also implements the Stop RPC method
-// for all watchers.
+// srvWatcher holds the details of a watcher.  It also implements the
+// Stop RPC method for all watchers.
 type srvWatcher struct {
         ws *watchers
         w  watcher
         id string
 }
 
+// Stop stops the given watcher. It causes any outstanding
+// Next calls to return a CodeStopped error.
+// Any subsequent Next calls will return a CodeNotFound
+// error because the watcher will no longer exist.
 func (w *srvWatcher) Stop() error {
         err := w.w.Stop()
         w.ws.mu.Lock()
         defer w.ws.mu.Unlock()
         delete(w.ws.ws, w.id)
         return err
 }
 
 func newWatchers() *watchers {
         return &watchers{
@@ skipping 16 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)
+}