upgrader: add Upgrader.DesiredVersion

state/apiserver/upgrader/upgrader.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package upgrader
 
 import (
         "errors"
 
         "launchpad.net/juju-core/environs"
+        "launchpad.net/juju-core/environs/config"
         envtools "launchpad.net/juju-core/environs/tools"
         "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"
         agenttools "launchpad.net/juju-core/tools"
         "launchpad.net/juju-core/version"
 )
 
 // UpgraderAPI provides access to the Upgrader API facade.
@@ skipping 62 matching lines @@
                 Number: agentVersion,
                 Series: existingTools.Version.Series,
                 Arch:   existingTools.Version.Arch,
         }
         // TODO(jam): Avoid searching the provider for every machine
         // that wants to upgrade. The information could just be cached
         // in state, or even in the API servers
         return envtools.FindExactTools(env, requested)
 }
 
+func (u *UpgraderAPI) getGlobalAgentVersion() (version.Number, *config.Config, error) {

[rog, 2013/08/29 14:48:50]

Thanks for doing this - even though the values needed are slightly different
in both cases, I think it looks nicer with it factored out.

+        // Get the Agent Version requested in the Environment Config
+        cfg, err := u.st.EnvironConfig()
+        if err != nil {
+                return version.Number{}, nil, err
+        }
+        agentVersion, ok := cfg.AgentVersion()
+        if !ok {
+                return version.Number{}, nil, errors.New("agent version not set in environment config")
+        }
+        return agentVersion, cfg, nil
+}
+
 // DesiredVersion reports the Agent Version that we want that agent to be running
 func (u *UpgraderAPI) DesiredVersion(args params.Entities) (params.AgentVersionResults, error) {
         results := make([]params.AgentVersionResult, len(args.Entities))
         if len(args.Entities) == 0 {
                 return params.AgentVersionResults{}, nil
         }
-        // For now, all agents get the same proposed version
-        cfg, err := u.st.EnvironConfig()
+        agentVersion, _, err := u.getGlobalAgentVersion()
         if err != nil {
-                return params.AgentVersionResults{}, err
-        }
-        agentVersion, ok := cfg.AgentVersion()
-        if !ok {
-                return params.AgentVersionResults{}, errors.New("agent version not set in environment config")
+                return params.AgentVersionResults{}, common.ServerError(err)
         }
         for i, entity := range args.Entities {
                 err := common.ErrPerm
                 if u.authorizer.AuthOwner(entity.Tag) {
                         results[i].Version = &agentVersion
                         err = nil
                 }
                 results[i].Error = common.ServerError(err)
         }
         return params.AgentVersionResults{results}, nil
 }
 
 // Tools finds the Tools necessary for the given agents.
 func (u *UpgraderAPI) Tools(args params.Entities) (params.AgentToolsResults, error) {
         results := make([]params.AgentToolsResult, len(args.Entities))
         if len(args.Entities) == 0 {
                 return params.AgentToolsResults{}, nil
         }
-        // For now, all agents get the same proposed version
-        cfg, err := u.st.EnvironConfig()
+        agentVersion, cfg, err := u.getGlobalAgentVersion()
         if err != nil {
-                return params.AgentToolsResults{}, err
-        }
-        agentVersion, ok := cfg.AgentVersion()
-        if !ok {
-                return params.AgentToolsResults{}, errors.New("agent version not set in environment config")
+                return params.AgentToolsResults{}, common.ServerError(err)
         }
         env, err := environs.New(cfg)
         if err != nil {
                 return params.AgentToolsResults{}, err
         }
         for i, entity := range args.Entities {
                 agentTools, err := u.oneAgentTools(entity.Tag, agentVersion, env)
                 if err == nil {
                         results[i].Tools = agentTools
                 }
@@ skipping 29 matching lines @@
         entity0, err := u.st.FindEntity(tag)
         if err != nil {
                 return nil, err
         }
         entity, ok := entity0.(state.AgentTooler)
         if !ok {
                 return nil, common.NotSupportedError(tag, "agent tools")
         }
         return entity, nil
 }