Merge lp:~jameinel/juju-core/api-use-register-standard-facade into lp:~go-bot/juju-core/trunk

[John A Meinel]

state/apiserver/*: use RegisterStandardFacade

Lots of changes, mostly all mechanical.

The items that aren't trivially mechanical are:

 1) agent/agent.go wasn't taking a Resources, made it take one to be
 the same as the others.

 2) common/registry_test.go This is the attempt to reintroduce the "no
 unknown methods" checks. It currently fails because we have to pass in
 id="" which isn't a known Id for the Watcher Facades. Otherwise it
 works just like the old one. I need to sort out what to do here. (add
 Watchers with id ""?)

 3) state/apiserver/facades.go just imports all the types that used to
 be inlined in state/apiserver/root.go
 We could name it something else like "all", but we'll want a file like
 this somewhere, I think.

 4) root.go MethodCaller implementation
 The biggest thing here is that the Client facade is not like the
 others. I have plans to clean that up, but that will be done in a
 different branch.

 5) upgrader.go I probably shouldn't call this a fully special
 snowflake, because it isn't *as* special as Client is. But it is the
 only Facade that actually has 2 implementations, and which
 implementation gets returned is decided by the tagKind of the caller.
 It *is* special in that it doesn't use RegisterStandardFacade, though.

 6) usermanager/usermanager.go also didn't take a Resources parameter.
 I'm leaving it for now to show off what bespoke func registries look
 like. I'll happily come back later to add Resources to
 NewUserManagerAPI and switch it to RegisterStandardFacade.

 7) AllWatcher. I filed a bug about this, but we have no tests in the
 code base that the AllWatcher API facade actually exists. I believe we
 have coverage of the underlying MegaWatcher behavior. But since the
 juju CLI never used the AllWatcher, we don't even have a smoke test
 for things like "Clients can see the AllWatcher, but Agents cannot". I
 didn't improve that here, but hopefully I didn't screw up the auth
 semantics.

 8) A bunch of the watchers were using direct methods from
 srvRoot, rather than the Authorizer + Resources paradigm. So I changed
 them from using "r.requireAgent() err" to using
 !isAgent(Authorizer) bool.

 Also, all of the new*Watcher functions fit FactoryFacade directly,
 because I had to write them anyway, and the don't fit
 RegisterStandardFacade (because they actually make use of the id
 parameter).

 There is clearly a *lot* of boilerplate between these functions, but
 AFAICT every other line uses a concrete type so it would be a lot of
 reflect work to have them share code.

 isAgent is also different now, instead of doing !Client, it does (Unit
 || Machine). Mostly because that lets us create an Authorizer which can
 do *anything*, whereas the negative logic means that something which is
 a Client and an Agent would sometimes not be an Agent. (Used in the
 "grab a copy of all facades and introspect them" test.)

 9) isAgent helper changes from being something directly asking state to
 being a wrapper around the Authorizer code. And AuthClient changes from
 being !isAgent to just checking directly for whether this entity
 isUser.

https://codereview.appspot.com/100460045/

[lp:~jameinel/juju-core/api-use-register-standard-facade]

2741. By John A Meinel on 2014-05-15

finish up the isAgent changes

[John A Meinel (jameinel)]

Reviewers: mp+219670_code.launchpad.net,

Message:
Please take a look.

Description:
state/apiserver/*: use RegisterStandardFacade

Lots of changes, mostly all mechanical.

The items that aren't trivially mechanical are:

  1) agent/agent.go wasn't taking a Resources, made it take one to be
  the same as the others.

  2) common/registry_test.go This is the attempt to reintroduce the "no
  unknown methods" checks. It currently fails because we have to pass in
  id="" which isn't a known Id for the Watcher Facades. Otherwise it
  works just like the old one. I need to sort out what to do here. (add
  Watchers with id ""?)

  3) state/apiserver/facades.go just imports all the types that used to
  be inlined in state/apiserver/root.go
  We could name it something else like "all", but we'll want a file like
  this somewhere, I think.

  4) root.go MethodCaller implementation
  The biggest thing here is that the Client facade is not like the
  others. I have plans to clean that up, but that will be done in a
  different branch.

  5) upgrader.go I probably shouldn't call this a fully special
  snowflake, because it isn't *as* special as Client is. But it is the
  only Facade that actually has 2 implementations, and which
  implementation gets returned is decided by the tagKind of the caller.
  It *is* special in that it doesn't use RegisterStandardFacade, though.

  6) usermanager/usermanager.go also didn't take a Resources parameter.
  I'm leaving it for now to show off what bespoke func registries look
  like. I'll happily come back later to add Resources to
  NewUserManagerAPI and switch it to RegisterStandardFacade.

  7) AllWatcher. I filed a bug about this, but we have no tests in the
  code base that the AllWatcher API facade actually exists. I believe we
  have coverage of the underlying MegaWatcher behavior. But since the
  juju CLI never used the AllWatcher, we don't even have a smoke test
  for things like "Clients can see the AllWatcher, but Agents cannot". I
  didn't improve that here, but hopefully I didn't screw up the auth
  semantics.

  8) A bunch of the watchers were using direct methods from
  srvRoot, rather than the Authorizer + Resources paradigm. So I changed
  them from using "r.requireAgent() err" to using
  !isAgent(Authorizer) bool.

  Also, all of the new*Watcher functions fit FactoryFacade directly,
  because I had to write them anyway, and the don't fit
  RegisterStandardFacade (because they actually make use of the id
  parameter).

  There is clearly a *lot* of boilerplate between these functions, but
  AFAICT every other line uses a concrete type so it would be a lot of
  reflect work to have them share code.

  isAgent is also different now, instead of doing !Client, it does (Unit
  || Machine). Mostly because that lets us create an Authorizer which can
  do *anything*, whereas the negative logic means that something which is
  a Client and an Agent would sometimes not be an Agent. (Used in the
  "grab a copy of all facades and introspect them" test.)

  9) isAgent helper changes from being something directly asking state to
  being a wrapper around the Authorizer code. And AuthClient changes from
  being !isAge...

[John A Meinel (jameinel)]

Please take a look.

https://codereview.appspot.com/100460045/

[William Reade (fwereade)]

On 2014/05/15 09:47:15, jameinel wrote:
> Please take a look.

2) I'm not really sure about this. Can't think of anything very pleasant
really.

3) Agreed. I like "all.go" FWIW.

7) Just one test here maybe, then?

Otherwise all looking good. Other comments following.

https://codereview.appspot.com/100460045/

[William Reade (fwereade)]

https://codereview.appspot.com/100460045/diff/20001/state/apiserver/common/registry_test.go
File state/apiserver/common/registry_test.go (right):

https://codereview.appspot.com/100460045/diff/20001/state/apiserver/common/registry_test.go#newcode198
state/apiserver/common/registry_test.go:198: // Entity ?
Entity skipped because no facade is specific to a single entity?

https://codereview.appspot.com/100460045/diff/20001/state/apiserver/root.go
File state/apiserver/root.go (right):

https://codereview.appspot.com/100460045/diff/20001/state/apiserver/root.go#newcode62
state/apiserver/root.go:62: // the other ones being created on-demand.
Why is that?
I'd guess because dataDir.

https://codereview.appspot.com/100460045/diff/20001/state/apiserver/upgrader/upgrader.go
File state/apiserver/upgrader/upgrader.go (right):

https://codereview.appspot.com/100460045/diff/20001/state/apiserver/upgrader/upgrader.go#newcode28
state/apiserver/upgrader/upgrader.go:28: // returned depends on who is
calling.
We could always move the dispatching down a layer into the Upgrader
itself, if you consider this to be too icky.

https://codereview.appspot.com/100460045/

[lp:~jameinel/juju-core/api-use-register-standard-facade]

2742. By John A Meinel on 2014-05-16

Merged api-register-standard-facade into api-use-register-standard-facade.

2743. By John A Meinel on 2014-05-16

Merged api-register-standard-facade into api-use-register-standard-facade.

2744. By John A Meinel on 2014-05-16

merge api-register-standard-facade to get updated trunk and github.com/juju/errors.

Also resolve the conflict from the Upgrader fixes that were backported to trunk.

2745. By John A Meinel on 2014-05-17

Pinger is also a bit different from the other facades.

It interacts with newSrvRoot in a different way because the active Pinger
needs to trigger changes when it *isn't* called. So it does have to be
cached rather than driven on demand.

[John A Meinel (jameinel)]

Please take a look.

https://codereview.appspot.com/100460045/

[lp:~jameinel/juju-core/api-use-register-standard-facade]

2746. By John A Meinel on 2014-05-17

comment updates

2747. By John A Meinel on 2014-05-20

Merge in the api-named-resources[-datadir] so that Pinger and Client can be normal Facades.

2748. By John A Meinel on 2014-05-20

move Pinger into its own file.

There was enough Pinger facade code that I moved it into its own file, registered it,
and then simplified the existing Pinger interface.

[John A Meinel (jameinel)]

Please take a look.

https://codereview.appspot.com/100460045/

[lp:~jameinel/juju-core/api-use-register-standard-facade]

2749. By John A Meinel on 2014-05-20

Merged api-register-standard-facade into api-use-register-standard-facade.

Deal with the changes due to BaseSuite and the updates to Client and Pinger.

2750. By John A Meinel on 2014-05-20

Client is finally not special anymore. Yippee\!

2751. By John A Meinel on 2014-05-22

Strip out all of the compat functions, and make sure docstrings are kept somewhere.

[John A Meinel (jameinel)]

Please take a look.

https://codereview.appspot.com/100460045/

[lp:~jameinel/juju-core/api-use-register-standard-facade]

2752. By John A Meinel on 2014-05-22

add a docstring

[John A Meinel (jameinel)]

On 2014/05/16 10:57:15, fwereade wrote:
> On 2014/05/15 09:47:15, jameinel wrote:
> > Please take a look.

> 2) I'm not really sure about this. Can't think of anything very
pleasant really.

I handled this by registering the concrete types in a followup branch.

> 3) Agreed. I like "all.go" FWIW.

I'm using state/apiserver/facades.go

I could be happy with "state/apiserver/allfacades.go" or just all.go if
you really prefer it. But "apiserver/all.go" seems a little
underspecified to me.

> 7) Just one test here maybe, then?

I did end up finding a test, it was just the fact that Client.WatchAll()
is the actual "give me one of these" calls that I didn't realize was
around.

> Otherwise all looking good. Other comments following.

https://codereview.appspot.com/100460045/

[lp:~jameinel/juju-core/api-use-register-standard-facade]

2753. By John A Meinel on 2014-05-22

Merged api-register-standard-facade into api-use-register-standard-facade.

2754. By John A Meinel on 2014-05-22

Upgrader to have a nicer docstring and change its implementation to actually define the return type.

[John A Meinel (jameinel)]

Please take a look.

https://codereview.appspot.com/100460045/diff/20001/state/apiserver/common/registry_test.go
File state/apiserver/common/registry_test.go (right):

https://codereview.appspot.com/100460045/diff/20001/state/apiserver/common/registry_test.go#newcode198
state/apiserver/common/registry_test.go:198: // Entity ?
On 2014/05/16 10:57:24, fwereade wrote:
> Entity skipped because no facade is specific to a single entity?

All this got ripped out in the next branch, so it doesn't apply anymore.

https://codereview.appspot.com/100460045/diff/20001/state/apiserver/root.go
File state/apiserver/root.go (right):

https://codereview.appspot.com/100460045/diff/20001/state/apiserver/root.go#newcode62
state/apiserver/root.go:62: // the other ones being created on-demand.
Why is that?
On 2014/05/16 10:57:24, fwereade wrote:
> I'd guess because dataDir.

Yeah, this got fixed as well.

https://codereview.appspot.com/100460045/diff/20001/state/apiserver/upgrader/upgrader.go
File state/apiserver/upgrader/upgrader.go (right):

https://codereview.appspot.com/100460045/diff/20001/state/apiserver/upgrader/upgrader.go#newcode28
state/apiserver/upgrader/upgrader.go:28: // returned depends on who is
calling.
On 2014/05/16 10:57:24, fwereade wrote:
> We could always move the dispatching down a layer into the Upgrader
itself, if
> you consider this to be too icky.

So it is a bit odd, but since both conform to exactly the same API it is
fine. There is a small problem because of late reflection that we might
expose more of an API than we realize. I may have to come back to this
later.

https://codereview.appspot.com/100460045/

[William Reade (fwereade)]

LGTM, thanks

https://codereview.appspot.com/100460045/

Unmerged revisions

2754. By John A Meinel on 2014-05-22

Upgrader to have a nicer docstring and change its implementation to actually define the return type.

2753. By John A Meinel on 2014-05-22

Merged api-register-standard-facade into api-use-register-standard-facade.

2752. By John A Meinel on 2014-05-22

add a docstring

2751. By John A Meinel on 2014-05-22

Strip out all of the compat functions, and make sure docstrings are kept somewhere.

2750. By John A Meinel on 2014-05-20

Client is finally not special anymore. Yippee\!

2749. By John A Meinel on 2014-05-20

Merged api-register-standard-facade into api-use-register-standard-facade.

Deal with the changes due to BaseSuite and the updates to Client and Pinger.

2748. By John A Meinel on 2014-05-20

move Pinger into its own file.

There was enough Pinger facade code that I moved it into its own file, registered it,
and then simplified the existing Pinger interface.

2747. By John A Meinel on 2014-05-20

Merge in the api-named-resources[-datadir] so that Pinger and Client can be normal Facades.

2746. By John A Meinel on 2014-05-17

comment updates

2745. By John A Meinel on 2014-05-17

Pinger is also a bit different from the other facades.

It interacts with newSrvRoot in a different way because the active Pinger
needs to trigger changes when it *isn't* called. So it does have to be
cached rather than driven on demand.

=== modified file 'rpc/registry/registry.go'
--- rpc/registry/registry.go	2014-05-22 11:56:36 +0000
+++ rpc/registry/registry.go	2014-05-22 11:56:36 +0000
@@ -18,6 +18,8 @@
 	registry *registry.TypedNameVersion
 }
 
+// Register records a factory that will be returned from Get() when passed the
+// specific (name, version) pair.
 func (r *RootFromRegistry) Register(name string, version int, f Factory) {
 	err := r.registry.Register(name, version, f)
 	if err != nil {
@@ -43,7 +45,8 @@
 // The parameter names match that of the rpcreflect.Value implementation, but
 // might be better named:
 //	rootMethodName: facadeName
-//	objId: facadeVersion (will be translated from a string into an int)
+//	version: facadeVersion (will be translated from a string into an int)
+//	objId: Id for the a concrete version of the facade (used for watchers)
 //	objMethodName: methodName
 func (r *RootFromRegistry) MethodCaller(
 	rootMethodName string, version int, objId, objMethodName string,

=== modified file 'rpc/server.go'
--- rpc/server.go	2014-05-22 11:56:36 +0000
+++ rpc/server.go	2014-05-22 11:56:36 +0000
@@ -341,7 +341,7 @@
 }
 
 // Caller is a way to dynamically lookup methods from a given (rootName,
-// version, id, methodName) triplet.
+// version, id, methodName) quadruplet.
 type Caller interface {
 	// MethodCaller takes a description of a method to call, and returns an
 	// rpcreflect.MethodCaller that can be used to call the concrete method.

=== modified file 'state/apiserver/admin.go'
--- state/apiserver/admin.go	2014-05-20 08:02:01 +0000
+++ state/apiserver/admin.go	2014-05-22 11:56:36 +0000
@@ -105,7 +105,7 @@
 	}
 	logger.Debugf("hostPorts: %v", hostPorts)
 
-	a.root.rpcConn.Serve(newRoot, serverError)
+	a.root.rpcConn.ServeCaller(newRoot, serverError)
 	return params.LoginResult{hostPorts}, nil
 }
 

=== modified file 'state/apiserver/agent/agent.go'
--- state/apiserver/agent/agent.go	2014-04-01 18:33:02 +0000
+++ state/apiserver/agent/agent.go	2014-05-22 11:56:36 +0000
@@ -12,6 +12,10 @@
 	"launchpad.net/juju-core/state/apiserver/common"
 )
 
+func init() {
+	common.RegisterStandardFacade("Agent", 0, NewAPI)
+}
+
 // API implements the API provided to an agent.
 type API struct {
 	*common.PasswordChanger
@@ -22,7 +26,7 @@
 
 // NewAPI returns an object implementing an agent API
 // with the given authorizer representing the currently logged in client.
-func NewAPI(st *state.State, auth common.Authorizer) (*API, error) {
+func NewAPI(st *state.State, resources *common.Resources, auth common.Authorizer) (*API, error) {
 	// Agents are defined to be any user that's not a client user.
 	if !auth.AuthMachineAgent() && !auth.AuthUnitAgent() {
 		return nil, common.ErrPerm

=== modified file 'state/apiserver/agent/agent_test.go'
--- state/apiserver/agent/agent_test.go	2014-03-10 08:27:32 +0000
+++ state/apiserver/agent/agent_test.go	2014-05-22 11:56:36 +0000
@@ -10,6 +10,7 @@
 	"launchpad.net/juju-core/state"
 	"launchpad.net/juju-core/state/api/params"
 	"launchpad.net/juju-core/state/apiserver/agent"
+	"launchpad.net/juju-core/state/apiserver/common"
 	apiservertesting "launchpad.net/juju-core/state/apiserver/testing"
 	coretesting "launchpad.net/juju-core/testing"
 )
@@ -21,6 +22,7 @@
 type agentSuite struct {
 	jujutesting.JujuConnSuite
 
+	resources  *common.Resources
 	authorizer apiservertesting.FakeAuthorizer
 
 	machine0  *state.Machine
@@ -48,6 +50,7 @@
 	s.container, err = s.State.AddMachineInsideMachine(template, s.machine1.Id(), instance.LXC)
 	c.Assert(err, gc.IsNil)
 
+	s.resources = common.NewResources()
 	// Create a FakeAuthorizer so we can check permissions,
 	// set up assuming machine 1 has logged in.
 	s.authorizer = apiservertesting.FakeAuthorizer{
@@ -57,15 +60,19 @@
 	}
 
 	// Create a machiner API for machine 1.
-	s.agent, err = agent.NewAPI(s.State, s.authorizer)
+	s.agent, err = agent.NewAPI(s.State, s.resources, s.authorizer)
 	c.Assert(err, gc.IsNil)
 }
+func (s *agentSuite) TearDownTest(c *gc.C) {
+	s.resources.StopAll()
+	s.JujuConnSuite.TearDownTest(c)
+}
 
 func (s *agentSuite) TestAgentFailsWithNonAgent(c *gc.C) {
 	auth := s.authorizer
 	auth.MachineAgent = false
 	auth.UnitAgent = false
-	api, err := agent.NewAPI(s.State, auth)
+	api, err := agent.NewAPI(s.State, s.resources, auth)
 	c.Assert(err, gc.NotNil)
 	c.Assert(api, gc.IsNil)
 	c.Assert(err, gc.ErrorMatches, "permission denied")
@@ -75,7 +82,7 @@
 	auth := s.authorizer
 	auth.MachineAgent = false
 	auth.UnitAgent = true
-	_, err := agent.NewAPI(s.State, auth)
+	_, err := agent.NewAPI(s.State, s.resources, auth)
 	c.Assert(err, gc.IsNil)
 }
 
@@ -108,7 +115,7 @@
 	auth.MachineAgent = true
 	auth.UnitAgent = false
 	auth.Tag = s.container.Tag()
-	containerAgent, err := agent.NewAPI(s.State, auth)
+	containerAgent, err := agent.NewAPI(s.State, s.resources, auth)
 	c.Assert(err, gc.IsNil)
 
 	results = containerAgent.GetEntities(args)

=== modified file 'state/apiserver/charmrevisionupdater/updater.go'
--- state/apiserver/charmrevisionupdater/updater.go	2014-05-13 04:30:48 +0000
+++ state/apiserver/charmrevisionupdater/updater.go	2014-05-22 11:56:36 +0000
@@ -15,6 +15,10 @@
 
 var logger = loggo.GetLogger("juju.state.apiserver.charmrevisionupdater")
 
+func init() {
+	common.RegisterStandardFacade("CharmRevisionUpdater", 0, NewCharmRevisionUpdaterAPI)
+}
+
 // CharmRevisionUpdater defines the methods on the charmrevisionupdater API end point.
 type CharmRevisionUpdater interface {
 	UpdateLatestRevisions() (params.ErrorResult, error)

=== modified file 'state/apiserver/client/client.go'
--- state/apiserver/client/client.go	2014-05-20 09:42:11 +0000
+++ state/apiserver/client/client.go	2014-05-22 11:56:36 +0000
@@ -29,6 +29,10 @@
 	"launchpad.net/juju-core/version"
 )
 
+func init() {
+	common.RegisterStandardFacade("Client", 0, NewClient)
+}
+
 var logger = loggo.GetLogger("juju.state.apiserver.client")
 
 type API struct {
@@ -45,31 +49,17 @@
 	api *API
 }
 
-// NewAPI creates a new instance of the Client API.
-func NewAPI(st *state.State, resources *common.Resources, authorizer common.Authorizer) *API {
-	r := &API{
+// NewClient creates a new instance of the Client Facade.
+func NewClient(st *state.State, resources *common.Resources, authorizer common.Authorizer) (*Client, error) {
+	if !authorizer.AuthClient() {
+		return nil, common.ErrPerm
+	}
+	return &Client{api: &API{
 		state:        st,
 		auth:         authorizer,
 		resources:    resources,
 		statusSetter: common.NewStatusSetter(st, common.AuthAlways(true)),
-	}
-	r.client = &Client{
-		api: r,
-	}
-	return r
-}
-
-// Client returns an object that provides access
-// to methods accessible to non-agent clients.
-func (r *API) Client(id string) (*Client, error) {
-	if !r.auth.AuthClient() {
-		return nil, common.ErrPerm
-	}
-	if id != "" {
-		// Safeguard id for possible future use.
-		return nil, common.ErrBadId
-	}
-	return r.client, nil
+	}}, nil
 }
 
 func (c *Client) WatchAll() (params.AllWatcherId, error) {

=== modified file 'state/apiserver/common/registry_test.go'
--- state/apiserver/common/registry_test.go	2014-05-22 11:56:36 +0000
+++ state/apiserver/common/registry_test.go	2014-05-22 11:56:36 +0000
@@ -192,5 +192,36 @@
 }
 func (*facadeRegistrySuite) TestDiscardedAPIMethods(c *gc.C) {
 	allFacades := common.Facades.List()
-	c.Assert(allFacades, gc.HasLen, 0)
+	c.Assert(allFacades, gc.Not(gc.HasLen), 0)
+	// We use a FakeAuthorizer that says it is allowed to do everything, so
+	// that we can get all of the concrete Facades
+	authorizer := apiservertesting.FakeAuthorizer{
+		Tag:            "user-admin",
+		LoggedIn:       true,
+		Client:         true,
+		EnvironManager: true,
+		MachineAgent:   true,
+		UnitAgent:      true,
+		// Entity ?
+	}
+	resources := common.NewResources()
+	defer resources.StopAll()
+
+	for _, description := range allFacades {
+		for _, version := range description.Versions {
+			factory, err := common.GetFacade(description.Name, version)
+			c.Assert(err, gc.IsNil)
+			obj, err := factory(nil, resources, authorizer, "")
+			c.Assert(err, gc.IsNil)
+			value := reflect.ValueOf(obj)
+			facadeType := rpcreflect.ObjTypeOf(value.Type())
+			// We must have some methods on every object returned
+			// by a root-level method.
+			c.Assert(facadeType.MethodNames(), gc.Not(gc.HasLen), 0)
+			// We don't allow any methods that don't implement
+			// an RPC entry point.
+			c.Assert(facadeType.DiscardedMethods(), gc.HasLen, 0)
+			resources.StopAll()
+		}
+	}
 }

=== modified file 'state/apiserver/deployer/deployer.go'
--- state/apiserver/deployer/deployer.go	2014-04-02 07:29:08 +0000
+++ state/apiserver/deployer/deployer.go	2014-05-22 11:56:36 +0000
@@ -12,6 +12,10 @@
 	"launchpad.net/juju-core/state/apiserver/common"
 )
 
+func init() {
+	common.RegisterStandardFacade("Deployer", 0, NewDeployerAPI)
+}
+
 // DeployerAPI provides access to the Deployer API facade.
 type DeployerAPI struct {
 	*common.Remover

=== modified file 'state/apiserver/environment/environment.go'
--- state/apiserver/environment/environment.go	2014-01-27 03:46:28 +0000
+++ state/apiserver/environment/environment.go	2014-05-22 11:56:36 +0000
@@ -8,6 +8,10 @@
 	"launchpad.net/juju-core/state/apiserver/common"
 )
 
+func init() {
+	common.RegisterStandardFacade("Environment", 0, NewEnvironmentAPI)
+}
+
 // EnvironmentAPI implements the API used by the machine environment worker.
 type EnvironmentAPI struct {
 	*common.EnvironWatcher

=== added file 'state/apiserver/facades.go'
--- state/apiserver/facades.go	1970-01-01 00:00:00 +0000
+++ state/apiserver/facades.go	2014-05-22 11:56:36 +0000
@@ -0,0 +1,23 @@
+// Copyright 2014 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package apiserver
+
+// This file just imports all of the facades so they get registered at runtime
+import (
+	_ "launchpad.net/juju-core/state/apiserver/agent"
+	_ "launchpad.net/juju-core/state/apiserver/charmrevisionupdater"
+	_ "launchpad.net/juju-core/state/apiserver/client"
+	_ "launchpad.net/juju-core/state/apiserver/deployer"
+	_ "launchpad.net/juju-core/state/apiserver/environment"
+	_ "launchpad.net/juju-core/state/apiserver/firewaller"
+	_ "launchpad.net/juju-core/state/apiserver/keymanager"
+	_ "launchpad.net/juju-core/state/apiserver/keyupdater"
+	_ "launchpad.net/juju-core/state/apiserver/logger"
+	_ "launchpad.net/juju-core/state/apiserver/machine"
+	_ "launchpad.net/juju-core/state/apiserver/provisioner"
+	_ "launchpad.net/juju-core/state/apiserver/rsyslog"
+	_ "launchpad.net/juju-core/state/apiserver/uniter"
+	_ "launchpad.net/juju-core/state/apiserver/upgrader"
+	_ "launchpad.net/juju-core/state/apiserver/usermanager"
+)

=== modified file 'state/apiserver/firewaller/firewaller.go'
--- state/apiserver/firewaller/firewaller.go	2014-01-21 17:56:56 +0000
+++ state/apiserver/firewaller/firewaller.go	2014-05-22 11:56:36 +0000
@@ -9,6 +9,10 @@
 	"launchpad.net/juju-core/state/apiserver/common"
 )
 
+func init() {
+	common.RegisterStandardFacade("Firewaller", 0, NewFirewallerAPI)
+}
+
 // FirewallerAPI provides access to the Firewaller API facade.
 type FirewallerAPI struct {
 	*common.LifeGetter

=== modified file 'state/apiserver/keymanager/keymanager.go'
--- state/apiserver/keymanager/keymanager.go	2014-05-13 04:30:48 +0000
+++ state/apiserver/keymanager/keymanager.go	2014-05-22 11:56:36 +0000
@@ -23,6 +23,10 @@
 
 var logger = loggo.GetLogger("juju.state.apiserver.keymanager")
 
+func init() {
+	common.RegisterStandardFacade("KeyManager", 0, NewKeyManagerAPI)
+}
+
 // KeyManager defines the methods on the keymanager API end point.
 type KeyManager interface {
 	ListKeys(arg params.ListSSHKeys) (params.StringsResults, error)

=== modified file 'state/apiserver/keyupdater/authorisedkeys.go'
--- state/apiserver/keyupdater/authorisedkeys.go	2014-05-13 04:30:48 +0000
+++ state/apiserver/keyupdater/authorisedkeys.go	2014-05-22 11:56:36 +0000
@@ -13,6 +13,10 @@
 	"launchpad.net/juju-core/utils/ssh"
 )
 
+func init() {
+	common.RegisterStandardFacade("KeyUpdater", 0, NewKeyUpdaterAPI)
+}
+
 // KeyUpdater defines the methods on the keyupdater API end point.
 type KeyUpdater interface {
 	AuthorisedKeys(args params.Entities) (params.StringsResults, error)

=== modified file 'state/apiserver/logger/logger.go'
--- state/apiserver/logger/logger.go	2014-03-28 11:17:33 +0000
+++ state/apiserver/logger/logger.go	2014-05-22 11:56:36 +0000
@@ -14,6 +14,10 @@
 
 var logger = loggo.GetLogger("juju.api.logger")
 
+func init() {
+	common.RegisterStandardFacade("Logger", 0, NewLoggerAPI)
+}
+
 // Logger defines the methods on the logger API end point.  Unfortunately, the
 // api infrastructure doesn't allow interfaces to be used as an actual
 // endpoint because our rpc mechanism panics.  However, I still feel that this

=== modified file 'state/apiserver/machine/machiner.go'
--- state/apiserver/machine/machiner.go	2014-05-13 04:30:48 +0000
+++ state/apiserver/machine/machiner.go	2014-05-22 11:56:36 +0000
@@ -13,6 +13,10 @@
 	"launchpad.net/juju-core/state/apiserver/common"
 )
 
+func init() {
+	common.RegisterStandardFacade("Machiner", 0, NewMachinerAPI)
+}
+
 // MachinerAPI implements the API used by the machiner worker.
 type MachinerAPI struct {
 	*common.LifeGetter

=== added file 'state/apiserver/pinger.go'
--- state/apiserver/pinger.go	1970-01-01 00:00:00 +0000
+++ state/apiserver/pinger.go	2014-05-22 11:56:36 +0000
@@ -0,0 +1,103 @@
+// Copyright 2013 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package apiserver
+
+import (
+	"errors"
+	"time"
+
+	"launchpad.net/tomb"
+
+	"launchpad.net/juju-core/state"
+	"launchpad.net/juju-core/state/apiserver/common"
+)
+
+func init() {
+	common.RegisterStandardFacade("Pinger", 0, NewPinger)
+}
+
+// NewPinger returns an object that can be pinged by calling its Ping method.
+// If this method is not called frequently enough, the connection will be
+// dropped.
+func NewPinger(
+	st *state.State, resources *common.Resources, authorizer common.Authorizer,
+) (
+	pinger, error,
+) {
+	pingTimeout, ok := resources.Get("pingTimeout").(*pingTimeout)
+	if !ok {
+		return nullPinger{}, nil
+	}
+	return pingTimeout, nil
+}
+
+// pinger describes a type that can be pinged.
+type pinger interface {
+	Ping()
+}
+
+// pingTimeout listens for pings and will call the
+// passed action in case of a timeout. This way broken
+// or inactive connections can be closed.
+type pingTimeout struct {
+	tomb    tomb.Tomb
+	action  func()
+	timeout time.Duration
+	reset   chan struct{}
+}
+
+// newPingTimeout returns a new pingTimeout instance
+// that invokes the given action asynchronously if there
+// is more than the given timeout interval between calls
+// to its Ping method.
+func newPingTimeout(action func(), timeout time.Duration) *pingTimeout {
+	pt := &pingTimeout{
+		action:  action,
+		timeout: timeout,
+		reset:   make(chan struct{}),
+	}
+	go func() {
+		defer pt.tomb.Done()
+		pt.tomb.Kill(pt.loop())
+	}()
+	return pt
+}
+
+// Ping is used by the client heartbeat monitor and resets
+// the killer.
+func (pt *pingTimeout) Ping() {
+	select {
+	case <-pt.tomb.Dying():
+	case pt.reset <- struct{}{}:
+	}
+}
+
+// Stop terminates the ping timeout.
+func (pt *pingTimeout) Stop() error {
+	pt.tomb.Kill(nil)
+	return pt.tomb.Wait()
+}
+
+// loop waits for a reset signal, otherwise it performs
+// the initially passed action.
+func (pt *pingTimeout) loop() error {
+	timer := time.NewTimer(pt.timeout)
+	defer timer.Stop()
+	for {
+		select {
+		case <-pt.tomb.Dying():
+			return nil
+		case <-timer.C:
+			go pt.action()
+			return errors.New("ping timeout")
+		case <-pt.reset:
+			timer.Reset(pt.timeout)
+		}
+	}
+}
+
+// nullPinger implements the pinger interface but just does nothing
+type nullPinger struct{}
+
+func (nullPinger) Ping() {}

=== modified file 'state/apiserver/provisioner/provisioner.go'
--- state/apiserver/provisioner/provisioner.go	2014-05-13 12:57:53 +0000
+++ state/apiserver/provisioner/provisioner.go	2014-05-22 11:56:36 +0000
@@ -17,6 +17,10 @@
 	"launchpad.net/juju-core/utils/set"
 )
 
+func init() {
+	common.RegisterStandardFacade("Provisioner", 0, NewProvisionerAPI)
+}
+
 // ProvisionerAPI provides access to the Provisioner API facade.
 type ProvisionerAPI struct {
 	*common.Remover

=== modified file 'state/apiserver/root.go'
--- state/apiserver/root.go	2014-05-20 09:42:11 +0000
+++ state/apiserver/root.go	2014-05-22 11:56:36 +0000
@@ -4,35 +4,15 @@
 package apiserver
 
 import (
-	"errors"
+	"reflect"
 	"time"
 
-	"launchpad.net/tomb"
-
-	"launchpad.net/juju-core/names"
 	"launchpad.net/juju-core/rpc"
+	"launchpad.net/juju-core/rpc/rpcreflect"
 	"launchpad.net/juju-core/state"
-	"launchpad.net/juju-core/state/apiserver/agent"
-	"launchpad.net/juju-core/state/apiserver/charmrevisionupdater"
-	"launchpad.net/juju-core/state/apiserver/client"
 	"launchpad.net/juju-core/state/apiserver/common"
-	"launchpad.net/juju-core/state/apiserver/deployer"
-	"launchpad.net/juju-core/state/apiserver/environment"
-	"launchpad.net/juju-core/state/apiserver/firewaller"
-	"launchpad.net/juju-core/state/apiserver/keymanager"
-	"launchpad.net/juju-core/state/apiserver/keyupdater"
-	loggerapi "launchpad.net/juju-core/state/apiserver/logger"
-	"launchpad.net/juju-core/state/apiserver/machine"
-	"launchpad.net/juju-core/state/apiserver/provisioner"
-	"launchpad.net/juju-core/state/apiserver/rsyslog"
-	"launchpad.net/juju-core/state/apiserver/uniter"
-	"launchpad.net/juju-core/state/apiserver/upgrader"
-	"launchpad.net/juju-core/state/apiserver/usermanager"
-	"launchpad.net/juju-core/state/multiwatcher"
 )
 
-type clientAPI struct{ *client.API }
-
 type taggedAuthenticator interface {
 	state.Entity
 	state.Authenticator
@@ -55,12 +35,10 @@
 // srvRoot represents a single client's connection to the state
 // after it has logged in.
 type srvRoot struct {
-	clientAPI
 	srv       *Server
 	rpcConn   *rpc.Conn
 	resources *common.Resources
-
-	entity taggedAuthenticator
+	entity    taggedAuthenticator
 }
 
 // newSrvRoot creates the client's connection representation
@@ -73,8 +51,9 @@
 		resources: common.NewResources(),
 		entity:    entity,
 	}
+	// Note: Only the Client API is part of srvRoot rather than all
+	// the other ones being created on-demand. Why is that?
 	r.resources.RegisterNamed("dataDir", common.StringResource(r.srv.dataDir))
-	r.clientAPI.API = client.NewAPI(r.srv.state, r.resources, r)
 	return r
 }
 
@@ -84,276 +63,22 @@
 	r.resources.StopAll()
 }
 
-// requireAgent checks whether the current client is an agent and hence
-// may access the agent APIs.  We filter out non-agents when calling one
-// of the accessor functions (Machine, Unit, etc) which avoids us making
-// the check in every single request method.
-func (r *srvRoot) requireAgent() error {
-	if !isAgent(r.entity) {
-		return common.ErrPerm
-	}
-	return nil
-}
-
-// requireClient returns an error unless the current
-// client is a juju client user.
-func (r *srvRoot) requireClient() error {
-	if isAgent(r.entity) {
-		return common.ErrPerm
-	}
-	return nil
-}
-
-// KeyManager returns an object that provides access to the KeyManager API
-// facade. The id argument is reserved for future use and currently
-// needs to be empty.
-func (r *srvRoot) KeyManager(id string) (*keymanager.KeyManagerAPI, error) {
-	if id != "" {
-		return nil, common.ErrBadId
-	}
-	return keymanager.NewKeyManagerAPI(r.srv.state, r.resources, r)
-}
-
-// UserManager returns an object that provides access to the UserManager API
-// facade. The id argument is reserved for future use and currently
-// needs to be empty
-func (r *srvRoot) UserManager(id string) (*usermanager.UserManagerAPI, error) {
-	if id != "" {
-		return nil, common.ErrBadId
-	}
-	return usermanager.NewUserManagerAPI(r.srv.state, r)
-}
-
-// Machiner returns an object that provides access to the Machiner API
-// facade. The id argument is reserved for future use and currently
-// needs to be empty.
-func (r *srvRoot) Machiner(id string) (*machine.MachinerAPI, error) {
-	if id != "" {
-		// Safeguard id for possible future use.
-		return nil, common.ErrBadId
-	}
-	return machine.NewMachinerAPI(r.srv.state, r.resources, r)
-}
-
-// Provisioner returns an object that provides access to the
-// Provisioner API facade. The id argument is reserved for future use
-// and currently needs to be empty.
-func (r *srvRoot) Provisioner(id string) (*provisioner.ProvisionerAPI, error) {
-	if id != "" {
-		// Safeguard id for possible future use.
-		return nil, common.ErrBadId
-	}
-	return provisioner.NewProvisionerAPI(r.srv.state, r.resources, r)
-}
-
-// Uniter returns an object that provides access to the Uniter API
-// facade. The id argument is reserved for future use and currently
-// needs to be empty.
-func (r *srvRoot) Uniter(id string) (*uniter.UniterAPI, error) {
-	if id != "" {
-		// Safeguard id for possible future use.
-		return nil, common.ErrBadId
-	}
-	return uniter.NewUniterAPI(r.srv.state, r.resources, r)
-}
-
-// Firewaller returns an object that provides access to the Firewaller
-// API facade. The id argument is reserved for future use and
-// currently needs to be empty.
-func (r *srvRoot) Firewaller(id string) (*firewaller.FirewallerAPI, error) {
-	if id != "" {
-		// Safeguard id for possible future use.
-		return nil, common.ErrBadId
-	}
-	return firewaller.NewFirewallerAPI(r.srv.state, r.resources, r)
-}
-
-// Agent returns an object that provides access to the
-// agent API.  The id argument is reserved for future use and must currently
-// be empty.
-func (r *srvRoot) Agent(id string) (*agent.API, error) {
-	if id != "" {
-		return nil, common.ErrBadId
-	}
-	return agent.NewAPI(r.srv.state, r)
-}
-
-// Deployer returns an object that provides access to the Deployer API facade.
-// The id argument is reserved for future use and must be empty.
-func (r *srvRoot) Deployer(id string) (*deployer.DeployerAPI, error) {
-	if id != "" {
-		// TODO(dimitern): There is no direct test for this
-		return nil, common.ErrBadId
-	}
-	return deployer.NewDeployerAPI(r.srv.state, r.resources, r)
-}
-
-// Environment returns an object that provides access to the Environment API
-// facade. The id argument is reserved for future use and currently needs to
-// be empty.
-func (r *srvRoot) Environment(id string) (*environment.EnvironmentAPI, error) {
-	if id != "" {
-		// Safeguard id for possible future use.
-		return nil, common.ErrBadId
-	}
-	return environment.NewEnvironmentAPI(r.srv.state, r.resources, r)
-}
-
-// Rsyslog returns an object that provides access to the Rsyslog API
-// facade. The id argument is reserved for future use and currently needs to
-// be empty.
-func (r *srvRoot) Rsyslog(id string) (*rsyslog.RsyslogAPI, error) {
-	if id != "" {
-		// Safeguard id for possible future use.
-		return nil, common.ErrBadId
-	}
-	return rsyslog.NewRsyslogAPI(r.srv.state, r.resources, r)
-}
-
-// Logger returns an object that provides access to the Logger API facade.
-// The id argument is reserved for future use and must be empty.
-func (r *srvRoot) Logger(id string) (*loggerapi.LoggerAPI, error) {
-	if id != "" {
-		// TODO: There is no direct test for this
-		return nil, common.ErrBadId
-	}
-	return loggerapi.NewLoggerAPI(r.srv.state, r.resources, r)
-}
-
-// Upgrader returns an object that provides access to the Upgrader API facade.
-// The id argument is reserved for future use and must be empty.
-func (r *srvRoot) Upgrader(id string) (upgrader.Upgrader, error) {
-	if id != "" {
-		// TODO: There is no direct test for this
-		return nil, common.ErrBadId
-	}
-	// The type of upgrader we return depends on who is asking.
-	// Machines get an UpgraderAPI, units get a UnitUpgraderAPI.
-	// This is tested in the state/api/upgrader package since there
-	// are currently no direct srvRoot tests.
-	tagKind, _, err := names.ParseTag(r.GetAuthTag(), "")
-	if err != nil {
-		return nil, common.ErrPerm
-	}
-	switch tagKind {
-	case names.MachineTagKind:
-		return upgrader.NewUpgraderAPI(r.srv.state, r.resources, r)
-	case names.UnitTagKind:
-		return upgrader.NewUnitUpgraderAPI(r.srv.state, r.resources, r)
-	}
-	// Not a machine or unit.
-	return nil, common.ErrPerm
-}
-
-// KeyUpdater returns an object that provides access to the KeyUpdater API facade.
-// The id argument is reserved for future use and must be empty.
-func (r *srvRoot) KeyUpdater(id string) (*keyupdater.KeyUpdaterAPI, error) {
-	if id != "" {
-		// TODO: There is no direct test for this
-		return nil, common.ErrBadId
-	}
-	return keyupdater.NewKeyUpdaterAPI(r.srv.state, r.resources, r)
-}
-
-// CharmRevisionUpdater returns an object that provides access to the CharmRevisionUpdater API facade.
-// The id argument is reserved for future use and must be empty.
-func (r *srvRoot) CharmRevisionUpdater(id string) (*charmrevisionupdater.CharmRevisionUpdaterAPI, error) {
-	if id != "" {
-		// TODO: There is no direct test for this
-		return nil, common.ErrBadId
-	}
-	return charmrevisionupdater.NewCharmRevisionUpdaterAPI(r.srv.state, r.resources, r)
-}
-
-// NotifyWatcher returns an object that provides
-// API access to methods on a state.NotifyWatcher.
-// Each client has its own current set of watchers, stored
-// in r.resources.
-func (r *srvRoot) NotifyWatcher(id string) (*srvNotifyWatcher, error) {
-	if err := r.requireAgent(); err != nil {
-		return nil, err
-	}
-	watcher, ok := r.resources.Get(id).(state.NotifyWatcher)
-	if !ok {
-		return nil, common.ErrUnknownWatcher
-	}
-	return &srvNotifyWatcher{
-		watcher:   watcher,
-		id:        id,
-		resources: r.resources,
-	}, nil
-}
-
-// StringsWatcher returns an object that provides API access to
-// methods on a state.StringsWatcher.  Each client has its own
-// current set of watchers, stored in r.resources.
-func (r *srvRoot) StringsWatcher(id string) (*srvStringsWatcher, error) {
-	if err := r.requireAgent(); err != nil {
-		return nil, err
-	}
-	watcher, ok := r.resources.Get(id).(state.StringsWatcher)
-	if !ok {
-		return nil, common.ErrUnknownWatcher
-	}
-	return &srvStringsWatcher{
-		watcher:   watcher,
-		id:        id,
-		resources: r.resources,
-	}, nil
-}
-
-// RelationUnitsWatcher returns an object that provides API access to
-// methods on a state.RelationUnitsWatcher. Each client has its own
-// current set of watchers, stored in r.resources.
-func (r *srvRoot) RelationUnitsWatcher(id string) (*srvRelationUnitsWatcher, error) {
-	if err := r.requireAgent(); err != nil {
-		return nil, err
-	}
-	watcher, ok := r.resources.Get(id).(state.RelationUnitsWatcher)
-	if !ok {
-		return nil, common.ErrUnknownWatcher
-	}
-	return &srvRelationUnitsWatcher{
-		watcher:   watcher,
-		id:        id,
-		resources: r.resources,
-	}, nil
-}
-
-// AllWatcher returns an object that provides API access to methods on
-// a state/multiwatcher.Watcher, which watches any changes to the
-// state. Each client has its own current set of watchers, stored in
-// r.resources.
-func (r *srvRoot) AllWatcher(id string) (*srvClientAllWatcher, error) {
-	if err := r.requireClient(); err != nil {
-		return nil, err
-	}
-	watcher, ok := r.resources.Get(id).(*multiwatcher.Watcher)
-	if !ok {
-		return nil, common.ErrUnknownWatcher
-	}
-	return &srvClientAllWatcher{
-		watcher:   watcher,
-		id:        id,
-		resources: r.resources,
-	}, nil
-}
-
-// Pinger returns an object that can be pinged
-// by calling its Ping method. If this method
-// is not called frequently enough, the connection
-// will be dropped.
-func (r *srvRoot) Pinger(id string) (pinger, error) {
-	pingTimeout, ok := r.resources.Get("pingTimeout").(pinger)
-	if !ok {
-		return nullPinger{}, nil
-	}
-	return pingTimeout, nil
-}
-
-type nullPinger struct{}
-
-func (nullPinger) Ping() {}
+// MethodCaller looks up the actual API method from a given (facadeName,
+// version, objectId, MethodName) group. It returns an rpcreflect.MethodCaller
+// that has a Call() method that will invoke the concrete method on a live
+// object.
+func (r *srvRoot) MethodCaller(rootMethodName string, version int, objId, objMethodName string) (rpcreflect.MethodCaller, error) {
+	factory, err := common.GetFacade(rootMethodName, version)
+	if err != nil {
+		return rpcreflect.MethodCaller{}, err
+	}
+	facade, err := factory(r.srv.state, r.resources, r, objId)
+	if err != nil {
+		return rpcreflect.MethodCaller{}, err
+	}
+	return rpcreflect.MethodCallerFromValue(
+		reflect.ValueOf(facade), rootMethodName, version, objMethodName)
+}
 
 // AuthMachineAgent returns whether the current client is a machine agent.
 func (r *srvRoot) AuthMachineAgent() bool {
@@ -382,7 +107,8 @@
 // AuthClient returns whether the authenticated entity is a client
 // user.
 func (r *srvRoot) AuthClient() bool {
-	return !isAgent(r.entity)
+	_, isUser := r.entity.(*state.User)
+	return isUser
 }
 
 // GetAuthTag returns the tag of the authenticated entity.
@@ -394,68 +120,3 @@
 func (r *srvRoot) GetAuthEntity() state.Entity {
 	return r.entity
 }
-
-// pinger describes a type that can be pinged.
-type pinger interface {
-	Ping()
-}
-
-// pingTimeout listens for pings and will call the
-// passed action in case of a timeout. This way broken
-// or inactive connections can be closed.
-type pingTimeout struct {
-	tomb    tomb.Tomb
-	action  func()
-	timeout time.Duration
-	reset   chan struct{}
-}
-
-// newPingTimeout returns a new pingTimeout instance
-// that invokes the given action asynchronously if there
-// is more than the given timeout interval between calls
-// to its Ping method.
-func newPingTimeout(action func(), timeout time.Duration) *pingTimeout {
-	pt := &pingTimeout{
-		action:  action,
-		timeout: timeout,
-		reset:   make(chan struct{}),
-	}
-	go func() {
-		defer pt.tomb.Done()
-		pt.tomb.Kill(pt.loop())
-	}()
-	return pt
-}
-
-// Ping is used by the client heartbeat monitor and resets
-// the killer.
-func (pt *pingTimeout) Ping() {
-	select {
-	case <-pt.tomb.Dying():
-	case pt.reset <- struct{}{}:
-	}
-}
-
-// Stop terminates the ping timeout.
-func (pt *pingTimeout) Stop() error {
-	pt.tomb.Kill(nil)
-	return pt.tomb.Wait()
-}
-
-// loop waits for a reset signal, otherwise it performs
-// the initially passed action.
-func (pt *pingTimeout) loop() error {
-	timer := time.NewTimer(pt.timeout)
-	defer timer.Stop()
-	for {
-		select {
-		case <-pt.tomb.Dying():
-			return nil
-		case <-timer.C:
-			go pt.action()
-			return errors.New("ping timeout")
-		case <-pt.reset:
-			timer.Reset(pt.timeout)
-		}
-	}
-}

=== modified file 'state/apiserver/root_test.go'
--- state/apiserver/root_test.go	2014-05-22 11:56:36 +0000
+++ state/apiserver/root_test.go	2014-05-22 11:56:36 +0000
@@ -16,37 +16,6 @@
 
 var _ = gc.Suite(&rootSuite{})
 
-var allowedDiscardedMethods = []string{
-	"AuthClient",
-	"AuthEnvironManager",
-	"AuthMachineAgent",
-	"AuthOwner",
-	"AuthUnitAgent",
-	"GetAuthEntity",
-	"GetAuthTag",
-}
-
-// TODO: jam 2014-05-11 reintroduce this test once we properly have types
-// registered that can be reflected again. This was only disabled because we
-// got rid of ObjType as an exposed attribute of RootType
-// func (*rootSuite) TestDiscardedAPIMethods(c *gc.C) {
-// 	t := rpcreflect.TypeOf(apiserver.RootType)
-// 	// We must have some root-level methods.
-// 	c.Assert(t.MethodNames(), gc.Not(gc.HasLen), 0)
-// 	c.Assert(t.DiscardedMethods(), gc.DeepEquals, allowedDiscardedMethods)
-//
-// 	for _, name := range t.MethodNames() {
-// 		m, err := t.Method(name)
-// 		c.Assert(err, gc.IsNil)
-// 		// We must have some methods on every object returned
-// 		// by a root-level method.
-// 		c.Assert(m.ObjType.MethodNames(), gc.Not(gc.HasLen), 0)
-// 		// We don't allow any methods that don't implement
-// 		// an RPC entry point.
-// 		c.Assert(m.ObjType.DiscardedMethods(), gc.HasLen, 0)
-// 	}
-// }
-
 func (r *rootSuite) TestPingTimeout(c *gc.C) {
 	closedc := make(chan time.Time, 1)
 	action := func() {

=== modified file 'state/apiserver/rsyslog/rsyslog.go'
--- state/apiserver/rsyslog/rsyslog.go	2014-04-11 17:51:58 +0000
+++ state/apiserver/rsyslog/rsyslog.go	2014-05-22 11:56:36 +0000
@@ -10,6 +10,10 @@
 	"launchpad.net/juju-core/state/apiserver/common"
 )
 
+func init() {
+	common.RegisterStandardFacade("Rsyslog", 0, NewRsyslogAPI)
+}
+
 // RsyslogAPI implements the API used by the rsyslog worker.
 type RsyslogAPI struct {
 	*common.EnvironWatcher

=== modified file 'state/apiserver/uniter/uniter.go'
--- state/apiserver/uniter/uniter.go	2014-05-22 09:18:37 +0000
+++ state/apiserver/uniter/uniter.go	2014-05-22 11:56:36 +0000
@@ -18,6 +18,10 @@
 	"launchpad.net/juju-core/state/watcher"
 )
 
+func init() {
+	common.RegisterStandardFacade("Uniter", 0, NewUniterAPI)
+}
+
 // UniterAPI implements the API used by the uniter worker.
 type UniterAPI struct {
 	*common.LifeGetter

=== modified file 'state/apiserver/upgrader/upgrader.go'
--- state/apiserver/upgrader/upgrader.go	2014-04-09 12:20:55 +0000
+++ state/apiserver/upgrader/upgrader.go	2014-05-22 11:56:36 +0000
@@ -9,6 +9,7 @@
 	"github.com/juju/loggo"
 
 	"launchpad.net/juju-core/environs/config"
+	"launchpad.net/juju-core/names"
 	"launchpad.net/juju-core/state"
 	"launchpad.net/juju-core/state/api/params"
 	"launchpad.net/juju-core/state/apiserver/common"
@@ -18,6 +19,34 @@
 
 var logger = loggo.GetLogger("juju.state.apiserver.upgrader")
 
+func init() {
+	common.RegisterStandardFacade("Upgrader", 0, upgraderFacade)
+}
+
+// upgraderFacade is a bit unique vs the other API Facades, as it has two
+// implementations that actually expose the same API and which one gets
+// returned depends on who is calling.
+// Both of them conform to the exact Upgrader API, so the actual calls that are
+// available do not depend on who is currently connected.
+func upgraderFacade(st *state.State, resources *common.Resources, auth common.Authorizer) (Upgrader, error) {
+	// The type of upgrader we return depends on who is asking.
+	// Machines get an UpgraderAPI, units get a UnitUpgraderAPI.
+	// This is tested in the state/api/upgrader package since there
+	// are currently no direct srvRoot tests.
+	tagKind, _, err := names.ParseTag(auth.GetAuthTag(), "")
+	if err != nil {
+		return nil, common.ErrPerm
+	}
+	switch tagKind {
+	case names.MachineTagKind:
+		return NewUpgraderAPI(st, resources, auth)
+	case names.UnitTagKind:
+		return NewUnitUpgraderAPI(st, resources, auth)
+	}
+	// Not a machine or unit.
+	return nil, common.ErrPerm
+}
+
 type Upgrader interface {
 	WatchAPIVersion(args params.Entities) (params.NotifyWatchResults, error)
 	DesiredVersion(args params.Entities) (params.VersionResults, error)

=== modified file 'state/apiserver/usermanager/usermanager.go'
--- state/apiserver/usermanager/usermanager.go	2014-04-25 13:57:06 +0000
+++ state/apiserver/usermanager/usermanager.go	2014-05-22 11:56:36 +0000
@@ -15,6 +15,18 @@
 
 var logger = loggo.GetLogger("juju.state.apiserver.usermanager")
 
+func init() {
+	common.RegisterFacade("UserManager", 0,
+		func(
+			st *state.State, resources *common.Resources,
+			authorizer common.Authorizer, id string,
+		) (
+			interface{}, error,
+		) {
+			return NewUserManagerAPI(st, authorizer)
+		})
+}
+
 // UserManager defines the methods on the usermanager API end point.
 type UserManager interface {
 	AddUser(arg params.EntityPasswords) (params.ErrorResults, error)

=== modified file 'state/apiserver/utils.go'
--- state/apiserver/utils.go	2013-11-05 09:13:34 +0000
+++ state/apiserver/utils.go	2014-05-22 11:56:36 +0000
@@ -24,12 +24,6 @@
 	return false
 }
 
-// isAgent returns whether the given entity is an agent.
-func isAgent(e state.Authenticator) bool {
-	_, isUser := e.(*state.User)
-	return !isUser
-}
-
 func setPassword(e state.Authenticator, password string) error {
 	// Catch expected common case of misspelled
 	// or missing Password parameter.

=== modified file 'state/apiserver/watcher.go'
--- state/apiserver/watcher.go	2013-12-05 03:42:25 +0000
+++ state/apiserver/watcher.go	2014-05-22 11:56:36 +0000
@@ -10,12 +10,37 @@
 	"launchpad.net/juju-core/state/multiwatcher"
 )
 
+func init() {
+	common.RegisterFacade("AllWatcher", 0, newClientAllWatcher)
+	common.RegisterFacade("NotifyWatcher", 0, newNotifyWatcher)
+	common.RegisterFacade("StringsWatcher", 0, newStringsWatcher)
+	common.RegisterFacade("RelationUnitsWatcher", 0, newRelationUnitsWatcher)
+}
+
+// srvClientAllWatcher defines the API methods on a state/multiwatcher.Watcher,
+// which watches any changes to the state. Each client has its own current set
+// of watchers, stored in resources.
 type srvClientAllWatcher struct {
 	watcher   *multiwatcher.Watcher
 	id        string
 	resources *common.Resources
 }
 
+func newClientAllWatcher(st *state.State, resources *common.Resources, auth common.Authorizer, id string) (interface{}, error) {
+	if !auth.AuthClient() {
+		return nil, common.ErrPerm
+	}
+	watcher, ok := resources.Get(id).(*multiwatcher.Watcher)
+	if !ok {
+		return nil, common.ErrUnknownWatcher
+	}
+	return &srvClientAllWatcher{
+		watcher:   watcher,
+		id:        id,
+		resources: resources,
+	}, nil
+}
+
 func (aw *srvClientAllWatcher) Next() (params.AllWatcherNextResults, error) {
 	deltas, err := aw.watcher.Next()
 	return params.AllWatcherNextResults{
@@ -27,12 +52,33 @@
 	return w.resources.Stop(w.id)
 }
 
+// srvNotifyWatcher defines the API access to methods on a state.NotifyWatcher.
+// Each client has its own current set of watchers, stored in resources.
 type srvNotifyWatcher struct {
 	watcher   state.NotifyWatcher
 	id        string
 	resources *common.Resources
 }
 
+func isAgent(auth common.Authorizer) bool {
+	return auth.AuthMachineAgent() || auth.AuthUnitAgent()
+}
+
+func newNotifyWatcher(st *state.State, resources *common.Resources, auth common.Authorizer, id string) (interface{}, error) {
+	if !isAgent(auth) {
+		return nil, common.ErrPerm
+	}
+	watcher, ok := resources.Get(id).(state.NotifyWatcher)
+	if !ok {
+		return nil, common.ErrUnknownWatcher
+	}
+	return &srvNotifyWatcher{
+		watcher:   watcher,
+		id:        id,
+		resources: resources,
+	}, nil
+}
+
 // 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 NotifyWatcher.
@@ -52,14 +98,31 @@
 	return w.resources.Stop(w.id)
 }
 
-// srvStringsWatcher notifies about changes for all entities of a
-// given kind, sending the changes as a list of strings.
+// srvStringsWatcher defines the API for methods on a state.StringsWatcher.
+// Each client has its own current set of watchers, stored in resources.
+// srvStringsWatcher notifies about changes for all entities of a given kind,
+// sending the changes as a list of strings.
 type srvStringsWatcher struct {
 	watcher   state.StringsWatcher
 	id        string
 	resources *common.Resources
 }
 
+func newStringsWatcher(st *state.State, resources *common.Resources, auth common.Authorizer, id string) (interface{}, error) {
+	if !isAgent(auth) {
+		return nil, common.ErrPerm
+	}
+	watcher, ok := resources.Get(id).(state.StringsWatcher)
+	if !ok {
+		return nil, common.ErrUnknownWatcher
+	}
+	return &srvStringsWatcher{
+		watcher:   watcher,
+		id:        id,
+		resources: resources,
+	}, nil
+}
+
 // Next returns when a change has occured to an entity of the
 // collection being watched since the most recent call to Next
 // or the Watch call that created the srvStringsWatcher.
@@ -81,15 +144,30 @@
 	return w.resources.Stop(w.id)
 }
 
-// srvRelationUnitsWatcher notifies about units entering and leaving
-// the scope of a RelationUnit, and changes to the settings of those
-// units known to have entered.
+// srvRelationUnitsWatcher defines the API wrapping a state.RelationUnitsWatcher.
+// It notifies about units entering and leaving the scope of a RelationUnit,
+// and changes to the settings of those units known to have entered.
 type srvRelationUnitsWatcher struct {
 	watcher   state.RelationUnitsWatcher
 	id        string
 	resources *common.Resources
 }
 
+func newRelationUnitsWatcher(st *state.State, resources *common.Resources, auth common.Authorizer, id string) (interface{}, error) {
+	if !isAgent(auth) {
+		return nil, common.ErrPerm
+	}
+	watcher, ok := resources.Get(id).(state.RelationUnitsWatcher)
+	if !ok {
+		return nil, common.ErrUnknownWatcher
+	}
+	return &srvRelationUnitsWatcher{
+		watcher:   watcher,
+		id:        id,
+		resources: resources,
+	}, nil
+}
+
 // Next returns when a change has occured to an entity of the
 // collection being watched since the most recent call to Next
 // or the Watch call that created the srvRelationUnitsWatcher.