state/apiserver: Implement Machiner.Watch

state/apiserver/root.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package apiserver
 
 import (
         "launchpad.net/juju-core/state"
         "launchpad.net/juju-core/state/apiserver/common"
         "launchpad.net/juju-core/state/apiserver/machiner"
         "launchpad.net/juju-core/state/multiwatcher"
 )
 
 // srvRoot represents a single client's connection to the state.
 type srvRoot struct {
         admin     *srvAdmin
         client    *srvClient
         state     *srvState
         srv       *Server
-        machiner  *machiner.Machiner
         resources *resources
 
         user authUser
 }
 
 func newStateServer(srv *Server) *srvRoot {
         r := &srvRoot{
                 srv:       srv,
                 resources: newResources(),
         }
         r.admin = &srvAdmin{
                 root: r,
         }
         r.client = &srvClient{
                 root: r,
         }
         r.state = &srvState{
                 root: r,
         }
-        r.machiner = machiner.New(r.srv.state, r.resources, 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.resources.stopAll()
 }
 
 // Admin returns an object that provides API access
@@ skipping 29 matching lines @@
         if e == nil {
                 return common.ErrNotLoggedIn
         }
         if isAgent(e) {
                 return common.ErrPerm
         }
         return nil
 }
 
 // Machiner returns an object that provides access to the Machiner API
-// facade. Version argument is reserved for future use and currently
+// facade. The id argument is reserved for future use and currently
 // needs to be empty.
-func (r *srvRoot) Machiner(version string) (*machiner.Machiner, error) {
-        if err := r.requireAgent(); err != nil {
-                return nil, err
-        }
-        if version != "" {
-                return nil, common.ErrBadVersion
-        }
-        return r.machiner, nil
+func (r *srvRoot) Machiner(id string) (*machiner.Machiner, error) {
+        if id != "" {
+                // Safeguard id for possible future use.
+                return nil, common.ErrBadId
+        }
+        return machiner.New(r.srv.state, r.resources, r)
 }
 
 // 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
@@ skipping 106 matching lines @@
         if err := r.requireClient(); err != nil {
                 return nil, err
         }
         if id != "" {
                 // Safeguard id for possible future use.
                 return nil, common.ErrBadId
         }
         return r.client, nil
 }
 
+// IsLoggedIn returns whether the user is currently logged in and
+// authenticated.
+func (r *srvRoot) IsLoggedIn() bool {
+        return r.user.authenticator() != nil
+}
+
+// AuthMachineAgent returns whether the current client is a machine agent.
+func (r *srvRoot) AuthMachineAgent() bool {
+        if !r.IsLoggedIn() {
+                return false
+        }
+        e := r.user.authenticator()
+        if _, ok := e.(*state.Machine); !ok {
+                return false
+        }
+        return true
+}
+
 // AuthOwner returns whether the authenticated user's tag matches the
 // given entity's tag.
 func (r *srvRoot) AuthOwner(entity common.Tagger) bool {
         authUser := r.user.authenticator()
         return authUser.Tag() == entity.Tag()
 }
 
 // AuthEnvironManager returns whether the authenticated user is a
 // machine with running the ManageEnviron job.
 func (r *srvRoot) AuthEnvironManager() bool {
         authUser := r.user.authenticator()
         return isMachineWithJob(authUser, state.JobManageEnviron)
 }