apiserver/uniter: Service-related API calls

state/apiserver/uniter/uniter.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 // The uniter package implements the API interface
 // used by the uniter worker.
 package uniter
 
 import (
-        "fmt"
-
         "launchpad.net/juju-core/charm"
         "launchpad.net/juju-core/names"
         "launchpad.net/juju-core/state"
         "launchpad.net/juju-core/state/api/params"
         "launchpad.net/juju-core/state/apiserver/common"
         "launchpad.net/juju-core/state/watcher"
 )
 
 // UniterAPI implements the API used by the uniter worker.
 type UniterAPI struct {
@@ skipping 25 matching lines @@
                 }
                 return func(tag string) bool {
                         return tag == names.ServiceTag(unit.ServiceName())
                 }, nil
         }
         getCanAccessUnitOrService := func() (common.AuthFunc, error) {
                 // These errors here are ignored: they're always nil.
                 canAccessService, _ := getCanAccessService()
                 canAccessUnit, _ := getCanAccessUnit()
                 return func(tag string) bool {
-                        if !canAccessService(tag) {

[rog, 2013/08/13 15:14:26]

return canAccessUnit(tag) || canAccessService(tag)

[dimitern, 2013/08/13 15:20:19]

Done.

-                                return canAccessUnit(tag)
-                        }
-                        return true
+                        return canAccessService(tag) || canAccessUnit(tag)
                 }, nil
         }
         return &UniterAPI{
                 LifeGetter:                common.NewLifeGetter(st, getCanAccessUnitOrService),
                 StatusSetter:              common.NewStatusSetter(st, getCanAccessUnit),
                 DeadEnsurer:               common.NewDeadEnsurer(st, getCanAccessUnit),
                 AgentEntityWatcher:        common.NewAgentEntityWatcher(st, resources, getCanAccessUnitOrService),
                 st:                        st,
                 auth:                      authorizer,
                 resources:                 resources,
                 getCanAccessUnit:          getCanAccessUnit,
                 getCanAccessService:       getCanAccessService,
                 getCanAccessUnitOrService: getCanAccessUnitOrService,
         }, nil
 }
 
-func (u *UniterAPI) getUnitOrService(tag string) (state.Entity, error) {
-        kind, err := names.TagKind(tag)
-        if err != nil {
-                // Invalid tags might indicate something security related.
-                return nil, common.ErrPerm
-        }
-        if kind != names.UnitTagKind && kind != names.ServiceTagKind {
-                return nil, fmt.Errorf("%q is not a unit or a service tag", tag)
-        }
-        return u.st.FindEntity(tag)
-}
-
 func (u *UniterAPI) getUnit(tag string) (*state.Unit, error) {
-        entity, err := u.getUnitOrService(tag)
+        entity, err := u.st.FindEntity(tag)
         if err != nil {
                 return nil, err
         }
         return entity.(*state.Unit), nil
 }
 
 func (u *UniterAPI) getService(tag string) (*state.Service, error) {
-        entity, err := u.getUnitOrService(tag)
+        entity, err := u.st.FindEntity(tag)
         if err != nil {
                 return nil, err
         }
         return entity.(*state.Service), nil
 }
 
 // PublicAddress returns for each given unit, a pair of the public
 // address of the unit and whether it's valid.
 func (u *UniterAPI) PublicAddress(args params.Entities) (params.StringBoolResults, error) {
         result := params.StringBoolResults{
@@ skipping 191 matching lines @@
         result := params.StringBoolResults{
                 Results: make([]params.StringBoolResult, len(args.Entities)),
         }
         canAccess, err := u.getCanAccessUnitOrService()
         if err != nil {
                 return params.StringBoolResults{}, err
         }
         for i, entity := range args.Entities {
                 err := common.ErrPerm
                 if canAccess(entity.Tag) {
-                        var unitOrService interface{}
-                        unitOrService, err = u.getUnitOrService(entity.Tag)
+                        var unitOrService state.Entity
+                        unitOrService, err = u.st.FindEntity(entity.Tag)
                         if err == nil {
                                 charmURLer := unitOrService.(interface {
                                         CharmURL() (*charm.URL, bool)
                                 })
                                 curl, ok := charmURLer.CharmURL()
                                 result.Results[i].Result = curl.String()
                                 result.Results[i].Ok = ok
                         }
                 }
                 result.Results[i].Error = common.ServerError(err)
@@ skipping 191 matching lines @@
 // GetCharmBundleSha256
 // RelationSetDying
 // RelationIsImplicit
 // GetRelation
 // GetRelationSettings
 // RelationEnterScope
 // RelationLeaveScope
 // WatchRelation
 // EndpointImplementedBy
 // EnvironUUID