environs/config: more restrictive New

state/state.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 // The state package enables reading, observing, and changing
 // the state stored in MongoDB of a whole environment
 // managed by juju.
 package state
 
 import (
         "fmt"
@@ skipping 456 matching lines @@
         return newMachine(st, mdoc), nil
 }
 
 // FindEntity returns the entity with the given tag.
 //
 // The returned value can be of type *Machine, *Unit,
 // *User, *Service or *Environment, depending
 // on the tag.
 func (st *State) FindEntity(tag string) (Entity, error) {
         kind, id, err := names.ParseTag(tag, "")
-        // TODO(fwereade): when lp:1199352 (relation lacks Tag) is fixed, add
-        // support for relation entities here.
         switch kind {
         case names.MachineTagKind:
                 return st.Machine(id)
         case names.UnitTagKind:
                 return st.Unit(id)
         case names.UserTagKind:
                 return st.User(id)
         case names.ServiceTagKind:
                 return st.Service(id)
         case names.EnvironTagKind:
                 conf, err := st.EnvironConfig()
                 if err != nil {
                         return nil, err
                 }
                 // Return an invalid entity error if the requested environment is not
                 // the current one.
                 if id != conf.Name() {
                         return nil, errors.NotFoundf("environment %q", id)
                 }
                 return st.Environment()
         case names.RelationTagKind:
-                relId, err := strconv.Atoi(id)
-                if err != nil {
-                        return nil, errors.NotFoundf("relation %s", id)
-                }
-                return st.Relation(relId)
+                return st.KeyRelation(id)
         }
         return nil, err
 }
 
 // parseTag, given an entity tag, returns the collection name and id
 // of the entity document.
 func (st *State) parseTag(tag string) (coll string, id string, err error) {
         kind, id, err := names.ParseTag(tag, "")
         if err != nil {
                 return "", "", err
@@ skipping 677 matching lines @@
 func tagForGlobalKey(key string) (string, bool) {
         if len(key) < 3 || key[1] != '#' {
                 return "", false
         }
         p, ok := tagPrefix[key[0]]
         if !ok {
                 return "", false
         }
         return p + key[2:], true
 }