state/apiserver: Split Machiner into subpackage

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)

[rog, 2013/06/05 16:30:43]

i wonder if it might not make more sense to create the Machiner
on demand, letting the machiner package itself decide whether
the given client should be allowed access to it or not.

i.e. make machiner.New return (*Machiner, error)

[dimitern, 2013/06/06 09:36:01]

How can we decide when an error should be returned?

[rog, 2013/06/06 11:32:08]

machiner.New can make the same authorization decisions as srvRoot.Machiner, no?
and return an error if it wants to decline the authorization.

[dimitern, 2013/06/06 16:17:36]

Done.

         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 {

[rog, 2013/06/05 16:30:43]

this doesn't seem right. shouldn't we check that the agent is a machine at this
point?

[dimitern, 2013/06/06 09:36:01]

AIUI we need a machine tag to check that, hence the auth checks are in the
methods themselves.

[rog, 2013/06/06 11:32:08]

this code allows a uniter to get a Machiner object. is that really right?

[dimitern, 2013/06/06 16:17:36]

Changed as suggested.

-                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)
 }
 
 // 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)
 }