state/api: implement APIHostPorts methods

state/api/uniter/relationunit.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package uniter
 
 import (
         "fmt"
 
         "launchpad.net/juju-core/names"
         "launchpad.net/juju-core/state/api/params"
@@ skipping 57 matching lines @@
 // settings, because uniter only uses this to supply the unit's private
 // address, but this is not done at the server-side by the API.
 func (ru *RelationUnit) EnterScope() error {
         var result params.ErrorResults
         args := params.RelationUnits{
                 RelationUnits: []params.RelationUnit{{
                         Relation: ru.relation.tag,
                         Unit:     ru.unit.tag,
                 }},
         }
-        err := ru.st.caller.Call("Uniter", "", "EnterScope", args, &result)
+        err := ru.st.call("EnterScope", args, &result)
         if err != nil {
                 return err
         }
         return result.OneError()
 }
 
 // LeaveScope signals that the unit has left its scope in the relation.
 // After the unit has left its relation scope, it is no longer a member
 // of the relation; if the relation is dying when its last member unit
 // leaves, it is removed immediately. It is not an error to leave a scope
 // that the unit is not, or never was, a member of.
 func (ru *RelationUnit) LeaveScope() error {
         var result params.ErrorResults
         args := params.RelationUnits{
                 RelationUnits: []params.RelationUnit{{
                         Relation: ru.relation.tag,
                         Unit:     ru.unit.tag,
                 }},
         }
-        err := ru.st.caller.Call("Uniter", "", "LeaveScope", args, &result)
+        err := ru.st.call("LeaveScope", args, &result)
         if err != nil {
                 return err
         }
         return result.OneError()
 }
 
 // Settings returns a Settings which allows access to the unit's settings
 // within the relation.
 func (ru *RelationUnit) Settings() (*Settings, error) {
         var results params.RelationSettingsResults
         args := params.RelationUnits{
                 RelationUnits: []params.RelationUnit{{
                         Relation: ru.relation.tag,
                         Unit:     ru.unit.tag,
                 }},
         }
-        err := ru.st.caller.Call("Uniter", "", "ReadSettings", args, &results)
+        err := ru.st.call("ReadSettings", args, &results)
         if err != nil {
                 return nil, err
         }
         if len(results.Results) != 1 {
                 return nil, fmt.Errorf("expected one result, got %d", len(results.Results))
         }
         result := results.Results[0]
         if result.Error != nil {
                 return nil, result.Error
         }
@@ skipping 10 matching lines @@
 func (ru *RelationUnit) ReadSettings(uname string) (params.RelationSettings, error) {
         tag := names.UnitTag(uname)
         var results params.RelationSettingsResults
         args := params.RelationUnitPairs{
                 RelationUnitPairs: []params.RelationUnitPair{{
                         Relation:   ru.relation.tag,
                         LocalUnit:  ru.unit.tag,
                         RemoteUnit: tag,
                 }},
         }
-        err := ru.st.caller.Call("Uniter", "", "ReadRemoteSettings", args, &results)
+        err := ru.st.call("ReadRemoteSettings", args, &results)
         if err != nil {
                 return nil, err
         }
         if len(results.Results) != 1 {
                 return nil, fmt.Errorf("expected one result, got %d", len(results.Results))
         }
         result := results.Results[0]
         if result.Error != nil {
                 return nil, result.Error
         }
         return result.Settings, nil
 }
 
 // Watch returns a watcher that notifies of changes to counterpart
 // units in the relation.
 func (ru *RelationUnit) Watch() (watcher.RelationUnitsWatcher, error) {
         var results params.RelationUnitsWatchResults
         args := params.RelationUnits{
                 RelationUnits: []params.RelationUnit{{
                         Relation: ru.relation.tag,
                         Unit:     ru.unit.tag,
                 }},
         }
-        err := ru.st.caller.Call("Uniter", "", "WatchRelationUnits", args, &results)
+        err := ru.st.call("WatchRelationUnits", args, &results)
         if err != nil {
                 return nil, err
         }
         if len(results.Results) != 1 {
                 return nil, fmt.Errorf("expected one result, got %d", len(results.Results))
         }
         result := results.Results[0]
         if result.Error != nil {
                 return nil, result.Error
         }
         w := watcher.NewRelationUnitsWatcher(ru.st.caller, result)
         return w, nil
 }