Add a CharmInfo API command.

state/api/apiclient.go

 package api
 
 import (
         "fmt"
         "launchpad.net/juju-core/charm"
         "launchpad.net/juju-core/log"
-        "launchpad.net/juju-core/state/statecmd"
+        "launchpad.net/juju-core/state/api/params"
         "launchpad.net/tomb"
         "strings"
         "sync"
 )
 
 // Machine represents the state of a machine.
 type Machine struct {
         st  *State
         id  string
-        doc rpcMachine
+        doc params.Machine
 }
 
 // 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 15 matching lines @@
 func (c *Client) Status() (*Status, error) {
         var s Status
         if err := c.st.call("Client", "", "Status", nil, &s); err != nil {
                 return nil, err
         }
         return &s, nil
 }
 
 // ServiceSet sets configuration options on a service.
 func (c *Client) ServiceSet(service string, options map[string]string) error {
-        p := statecmd.ServiceSetParams{
+        p := params.ServiceSet{
                 ServiceName: service,
                 Options:     options,
         }
         err := c.st.client.Call("Client", "", "ServiceSet", p, nil)
         return clientError(err)
 }
 
 // ServiceSetYAML sets configuration options on a service
 // given options in YAML format.
 func (c *Client) ServiceSetYAML(service string, yaml string) error {
-        p := statecmd.ServiceSetYAMLParams{
+        p := params.ServiceSetYAML{
                 ServiceName: service,
                 Config:      yaml,
         }
         err := c.st.client.Call("Client", "", "ServiceSetYAML", p, nil)
         return clientError(err)
 }
 
 // ServiceGet returns the configuration for the named service.
-func (c *Client) ServiceGet(service string) (*statecmd.ServiceGetResults, error) {
-        var results statecmd.ServiceGetResults
-        params := statecmd.ServiceGetParams{ServiceName: service}
+func (c *Client) ServiceGet(service string) (*params.ServiceGetResults, error) {
+        var results params.ServiceGetResults
+        params := params.ServiceGet{ServiceName: service}
         err := c.st.client.Call("Client", "", "ServiceGet", params, &results)
         if err != nil {
                 return nil, clientError(err)
         }
         return &results, nil
 }
 
 // ServiceExpose changes the juju-managed firewall to expose any ports that
 // were also explicitly marked by units as open.
 func (c *Client) ServiceExpose(service string) error {
-        params := statecmd.ServiceExposeParams{ServiceName: service}
+        params := params.ServiceExpose{ServiceName: service}
         err := c.st.client.Call("Client", "", "ServiceExpose", params, nil)
         if err != nil {
                 return clientError(err)
         }
         return nil
 }
 
 // ServiceUnexpose changes the juju-managed firewall to unexpose any ports that
 // were also explicitly marked by units as open.
 func (c *Client) ServiceUnexpose(service string) error {
-        params := statecmd.ServiceUnexposeParams{ServiceName: service}
+        params := params.ServiceUnexpose{ServiceName: service}
         err := c.st.client.Call("Client", "", "ServiceUnexpose", params, nil)
         if err != nil {
                 return clientError(err)
         }
         return nil
 }
 
 // CharmInfo holds information about a charm.
 type CharmInfo struct {
-        Name        string
-        Revision    int
-        Subordinate bool
-        URL         string
-        Config      *charm.Config
-        Peers       map[string]charm.Relation
-        Provides    map[string]charm.Relation
-        Requires    map[string]charm.Relation
-}
-
-// CharmInfoParams stores parameters for making the CharmInfo call.
-type CharmInfoParams struct {
-        CharmURL string
+        Revision int
+        URL      string
+        Config   *charm.Config
+        Meta     *charm.Meta
 }
 
 // CharmInfo returns information about the requested charm.
 func (c *Client) CharmInfo(charmURL string) (*CharmInfo, error) {
-        params := CharmInfoParams{CharmURL: charmURL}
+        args := params.CharmInfo{CharmURL: charmURL}
         info := new(CharmInfo)
-        err := c.st.client.Call("Client", "", "CharmInfo", params, info)
+        err := c.st.client.Call("Client", "", "CharmInfo", args, info)
         if err != nil {
                 return nil, clientError(err)
         }
         return info, nil
 }
 
 // EnvironmentInfo holds information about the Juju environment.
 type EnvironmentInfo struct {
         DefaultSeries string
         ProviderType  string
@@ skipping 18 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  params.Unit
 }
 
 // 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", &params.Creds{
                 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", &params.Password{
                 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 params.EntityWatcherId
         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", &params.Password{
                 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 != ""
 }