Annotation documents and Environment Entity

state/apiserver/apiserver.go

 package apiserver
 
 import (
         "code.google.com/p/go.net/websocket"
         "fmt"
         "launchpad.net/juju-core/charm"
         "launchpad.net/juju-core/juju"
         "launchpad.net/juju-core/log"
         "launchpad.net/juju-core/state"
         "launchpad.net/juju-core/state/api"
@@ skipping 147 matching lines @@
         // Any user is allowed to access their own user object.
         // We check at this level rather than at the operation
         // level to stop malicious probing for current user names.
         // When we provide support for user administration,
         // this will need to be changed to allow access to
         // the administrator.
         e := r.user.entity()
         if e == nil {
                 return nil, errNotLoggedIn
         }
-        if e.EntityName() != name {
+        if r.user.entityName != name {
                 return nil, errPerm
         }
         u, err := r.srv.state.User(name)
         if err != nil {
                 return nil, err
         }
         return &srvUser{
                 root: r,
                 u:    u,
         }, nil
@@ skipping 212 matching lines @@
 // EnvironmentInfo returns information about the current environment (default
 // series and type).
 func (c *srvClient) EnvironmentInfo() (api.EnvironmentInfo, error) {
         conf, err := c.root.srv.state.EnvironConfig()
         if err != nil {
                 return api.EnvironmentInfo{}, err
         }
         info := api.EnvironmentInfo{
                 DefaultSeries: conf.DefaultSeries(),
                 ProviderType:  conf.Type(),
+                Name:          conf.Name(),
         }
         return info, nil
 }
 
 // GetAnnotations returns annotations about a given entity.
 func (c *srvClient) GetAnnotations(args params.GetAnnotations) (params.GetAnnotationsResults, error) {
-        entity, err := c.root.srv.state.Entity(args.EntityId)
+        entity, err := c.root.srv.state.Annotator(args.EntityId)
         if err != nil {
                 return params.GetAnnotationsResults{}, err
         }
-        return params.GetAnnotationsResults{Annotations: entity.Annotations()}, nil
+        ann, err := entity.Annotations()
+        if err != nil {
+                return params.GetAnnotationsResults{}, err
+        }
+        return params.GetAnnotationsResults{Annotations: ann}, nil
 }
 
 // SetAnnotation stores an annotation about a given entity.
 func (c *srvClient) SetAnnotation(args params.SetAnnotation) error {
-        entity, err := c.root.srv.state.Entity(args.EntityId)
+        entity, err := c.root.srv.state.Annotator(args.EntityId)
         if err != nil {
                 return err
         }
         return entity.SetAnnotation(args.Key, args.Value)
 }
 
 // Login logs in with the provided credentials.
 // All subsequent requests on the connection will
 // act as the authenticated user.
 func (a *srvAdmin) Login(c params.Creds) error {
@@ skipping 10 matching lines @@
 func (m *srvMachine) Watch() (params.EntityWatcherId, error) {
         w := m.m.Watch()
         if _, ok := <-w.Changes(); !ok {
                 return params.EntityWatcherId{}, statewatcher.MustErr(w)
         }
         return params.EntityWatcherId{
                 EntityWatcherId: m.root.watchers.register(w).id,
         }, nil
 }
 
-func setPassword(e state.Entity, password string) error {
+func setPassword(e state.Authenticator, password string) error {
         // Catch expected common case of mispelled
         // or missing Password parameter.
         if password == "" {
                 return fmt.Errorf("password is empty")
         }
         return e.SetPassword(password)
 }
 
 // SetPassword sets the machine's password.
 func (m *srvMachine) SetPassword(p params.Password) error {
         // Allow:
         // - the machine itself.
         // - the environment manager.
         e := m.root.user.entity()
-        allow := e.EntityName() == m.m.EntityName() ||
+        allow := m.root.user.entityName == m.m.EntityName() ||
                 isMachineWithJob(e, state.JobManageEnviron)
         if !allow {
                 return errPerm
         }
         return setPassword(m.m, p.Password)
 }
 
 // Get retrieves all the details of a unit.
 func (u *srvUnit) Get() (params.Unit, error) {
         var ru params.Unit
         ru.DeployerName, _ = u.u.DeployerName()
         // TODO add other unit attributes
         return ru, nil
 }
 
 // SetPassword sets the unit's password.
 func (u *srvUnit) SetPassword(p params.Password) error {
-        ename := u.root.user.entity().EntityName()
+        ename := u.root.user.entityName
         // Allow:
         // - the unit itself.
         // - the machine responsible for unit, if unit is principal
         // - the unit's principal unit, if unit is subordinate
         allow := ename == u.u.EntityName()
         if !allow {
                 deployerName, ok := u.u.DeployerName()
                 allow = ok && ename == deployerName
         }
         if !allow {
                 return errPerm
         }
         return setPassword(u.u, p.Password)
 }
 
 // SetPassword sets the user's password.
 func (u *srvUser) SetPassword(p params.Password) error {
         return setPassword(u.u, p.Password)
 }
 
 // Get retrieves all details of a user.
 func (u *srvUser) Get() (params.User, error) {
         return params.User{}, nil
 }
 
 // authUser holds login details. It's ok to call
 // its methods concurrently.
 type authUser struct {
-        mu      sync.Mutex
-        _entity state.Entity // logged-in entity (access only when mu is locked)
+        mu         sync.Mutex
+        _entity    state.Authenticator // logged-in entity (access only when mu is locked)

[dimitern, 2013/03/19 09:06:12]

why the underscore here? please remove.

[frankban, 2013/03/19 10:17:58]

I don't know why, _entity preexisted.
Anyway, renamed.

Also renamed the entity method to "authenticator".

+        entityName string
 }
 
 // login authenticates as entity with the given name,.
 func (u *authUser) login(st *state.State, entityName, password string) error {
         u.mu.Lock()
         defer u.mu.Unlock()
-        entity, err := st.Entity(entityName)
+        entity, err := st.Authenticator(entityName)
         if err != nil && !state.IsNotFound(err) {
                 return err
         }
         // TODO(rog) remove
         if !AuthenticationEnabled {
                 u._entity = entity
                 return nil
         }
         // We return the same error when an entity
         // does not exist as for a bad password, so that
         // we don't allow unauthenticated users to find information
         // about existing entities.
         if err != nil || !entity.PasswordValid(password) {
                 return errBadCreds
         }
         u._entity = entity
+        u.entityName = entityName
         return nil
 }
 
 // entity returns the currently logged-in entity, or nil if not
 // currently logged on.  The returned entity should not be modified
 // because it may be used concurrently.
-func (u *authUser) entity() state.Entity {
+func (u *authUser) entity() state.Authenticator {
         u.mu.Lock()
         defer u.mu.Unlock()
         return u._entity
 }
 
 // isMachineWithJob returns whether the given entity is a machine that
 // is configured to run the given job.
-func isMachineWithJob(e state.Entity, j state.MachineJob) bool {
+func isMachineWithJob(e state.Authenticator, j state.MachineJob) bool {
         m, ok := e.(*state.Machine)
         if !ok {
                 return false
         }
         for _, mj := range m.Jobs() {
                 if mj == j {
                         return true
                 }
         }
         return false
 }
 
 // isAgent returns whether the given entity is an agent.
-func isAgent(e state.Entity) bool {
+func isAgent(e state.Authenticator) bool {
         _, isUser := e.(*state.User)
         return !isUser
 }
 
 // watcher represents the interface provided by state watchers.
 type watcher interface {
         Stop() error
 }
 
 // watchers holds all the watchers for a connection.
@@ skipping 55 matching lines @@
 func (ws *watchers) stopAll() {
         ws.mu.Lock()
         defer ws.mu.Unlock()
         for _, w := range ws.ws {
                 if err := w.w.Stop(); err != nil {
                         log.Printf("state/api: error stopping %T watcher: %v", w, err)
                 }
         }
         ws.ws = make(map[string]*srvWatcher)
 }