state/apiserver: new package

state/api/apiclient.go

 package api
 
 import (
         "fmt"
         "launchpad.net/juju-core/log"
         "launchpad.net/juju-core/state/statecmd"
         "launchpad.net/tomb"
         "strings"
         "sync"
 )
 
 // Machine represents the state of a machine.
 type Machine struct {
         st  *State
         id  string
-        doc RpcMachine
+        doc RPCMachine
 }
 
 // Client represents the client-accessible part of the state.
 type Client struct {
         st *State
 }
 
 // Client returns an object that can be used
 // to access client-specific functionality.
 func (st *State) Client() *Client {
@@ skipping 99 matching lines @@
         if err := m.Refresh(); err != nil {
                 return nil, err
         }
         return m, nil
 }
 
 // Unit represents the state of a service unit.
 type Unit struct {
         st   *State
         name string
-        doc  RpcUnit
+        doc  RPCUnit
 }
 
 // Unit returns a unit by name.
 func (st *State) Unit(name string) (*Unit, error) {
         u := &Unit{
                 st:   st,
                 name: name,
         }
         if err := u.Refresh(); err != nil {
                 return nil, err
         }
         return u, nil
 }
 
 // Login authenticates as the entity with the given name and password.
 // Subsequent requests on the state will act as that entity.
 // This method is usually called automatically by Open.
 func (st *State) Login(entityName, password string) error {
-        return st.call("Admin", "", "Login", &RpcCreds{
+        return st.call("Admin", "", "Login", &RPCCreds{
                 EntityName: entityName,
                 Password:   password,
         }, nil)
 }
 
 // Id returns the machine id.
 func (m *Machine) Id() string {
         return m.id
 }
 
@@ skipping 22 matching lines @@
 }
 
 // InstanceId returns the provider specific instance id for this machine
 // and whether it has been set.
 func (m *Machine) InstanceId() (string, bool) {
         return m.doc.InstanceId, m.doc.InstanceId != ""
 }
 
 // SetPassword sets the password for the machine's agent.
 func (m *Machine) SetPassword(password string) error {
-        return m.st.call("Machine", m.id, "SetPassword", &RpcPassword{
+        return m.st.call("Machine", m.id, "SetPassword", &RPCPassword{
                 Password: password,
         }, nil)
 }
 
 func (m *Machine) Watch() *EntityWatcher {
         return newEntityWatcher(m.st, "Machine", m.id)
 }
 
 type EntityWatcher struct {
         tomb  tomb.Tomb
@@ skipping 14 matching lines @@
         go func() {
                 defer w.tomb.Done()
                 defer close(w.out)
                 defer w.wg.Wait() // Wait for watcher to be stopped.
                 w.tomb.Kill(w.loop())
         }()
         return w
 }
 
 func (w *EntityWatcher) loop() error {
-        var id RpcEntityWatcherId
+        var id RPCEntityWatcherId
         if err := w.st.call(w.etype, w.eid, "Watch", nil, &id); err != nil {
                 return err
         }
         callWatch := func(request string) error {
                 return w.st.call("EntityWatcher", id.EntityWatcherId, request, nil, nil)
         }
         w.wg.Add(1)
         go func() {
                 // When the EntityWatcher has been stopped, we send a
                 // Stop request to the server, which will remove the
@@ skipping 50 matching lines @@
 }
 
 // Refresh refreshes the contents of the Unit from the underlying
 // state. TODO(rog) It returns a NotFoundError if the unit has been removed.
 func (u *Unit) Refresh() error {
         return u.st.call("Unit", u.name, "Get", nil, &u.doc)
 }
 
 // SetPassword sets the password for the unit's agent.
 func (u *Unit) SetPassword(password string) error {
-        return u.st.call("Unit", u.name, "SetPassword", &RpcPassword{
+        return u.st.call("Unit", u.name, "SetPassword", &RPCPassword{
                 Password: password,
         }, nil)
 }
 
 // UnitEntityName returns the entity name for the
 // unit with the given name.
 func UnitEntityName(unitName string) string {
         return "unit-" + strings.Replace(unitName, "/", "-", -1)
 }
 
 // EntityName returns a name identifying the unit that is safe to use
 // as a file name.  The returned name will be different from other
 // EntityName values returned by any other entities from the same state.
 func (u *Unit) EntityName() string {
         return UnitEntityName(u.name)
 }
 
 // DeployerName returns the entity name of the agent responsible for deploying
 // the unit. If no such entity can be determined, false is returned.
 func (u *Unit) DeployerName() (string, bool) {
         return u.doc.DeployerName, u.doc.DeployerName != ""
 }
 
-type RpcCreds struct {
+// RPCCreds is used in the API protocol.
+type RPCCreds struct {
         EntityName string
         Password   string
 }
 
-type RpcMachine struct {
+// RPCMachine is used in the API protocol.
+type RPCMachine struct {
         InstanceId string
 }
 
-type RpcEntityWatcherId struct {
+// RPCEntityWatcherId is used in the API protocol.
+type RPCEntityWatcherId struct {
         EntityWatcherId string
 }
 
-type RpcPassword struct {
+// RPCPassword is used in the API protocol.
+type RPCPassword struct {
         Password string
 }
 
-type RpcUnit struct {
+// RPCUnit is used in the API protocol.
+type RPCUnit struct {
         DeployerName string
         // TODO(rog) other unit attributes.
 }
 
-type RpcUser struct {
+// RPCUser is used in the API protocol.
+type RPCUser struct {
         // This is a placeholder for any information
         // that may be associated with a user in the
         // future.
 }