upgrade-juju: improvements

environs/tools.go

 package environs
 
 import (
         "fmt"
         "launchpad.net/juju-core/environs/tools"
         "launchpad.net/juju-core/log"
         "launchpad.net/juju-core/state"
         "launchpad.net/juju-core/version"
 )
 
 // ToolsList holds a list of available tools.  Private tools take
 // precedence over public tools, even if they have a lower
 // version number.
 type ToolsList struct {
         Private tools.List
         Public  tools.List
 }
 
 // ListTools returns a ToolsList holding all the tools
 // available in the given environment that have the
 // given major version.
 func ListTools(env Environ, majorVersion int) (*ToolsList, error) {
         private, err := tools.ReadList(env.Storage(), majorVersion)
-        if err != nil && err != tools.ErrNoMatches {
+        if err != nil && !isToolsError(err) {
                 return nil, err
         }
         public, err := tools.ReadList(env.PublicStorage(), majorVersion)
-        if err != nil && err != tools.ErrNoMatches {
+        if err != nil && !isToolsError(err) {
                 return nil, err
         }
         return &ToolsList{
                 Private: private,
                 Public:  public,
         }, nil
 }
 
 // BestTools returns the most recent version
 // from the set of tools in the ToolsList that are
 // compatible with the given version, using flags
 // to determine possible candidates.
 // It returns nil if no such tools are found.
 func BestTools(list *ToolsList, vers version.Binary, flags ToolsSearchFlags) *state.Tools {
         if flags&CompatVersion == 0 {
                 panic("CompatVersion not implemented")
         }
         if tools := bestTools(list.Private, vers, flags); tools != nil {
                 return tools
         }
         return bestTools(list.Public, vers, flags)
 }
 
 // bestTools is like BestTools but operates on a single list of tools.
 func bestTools(toolsList []*state.Tools, vers version.Binary, flags ToolsSearchFlags) *state.Tools {
         var bestTools *state.Tools
         allowDev := vers.IsDev() || flags&DevVersion != 0
         allowHigher := flags&HighestVersion != 0
-        log.Debugf("finding best tools for version: %v", vers)
+        log.Debugf("environs: finding best tools for version %v (dev=%v)", vers, allowDev)
         for _, t := range toolsList {
-                log.Debugf("checking tools %v", t)
+                log.Debugf("environs: checking tools %v", t)
                 if t.Major != vers.Major ||
                         t.Series != vers.Series ||
                         t.Arch != vers.Arch ||
                         !allowDev && t.IsDev() ||
                         !allowHigher && vers.Number.Less(t.Number) {
                         continue
                 }
                 if bestTools == nil || bestTools.Number.Less(t.Number) {
+                        log.Debugf("environs: new best tools found: %v", t)
                         bestTools = t
                 }
         }
         return bestTools
 }
 
 // ToolsSearchFlags gives options when searching
 // for tools.
 type ToolsSearchFlags int
 
@@ skipping 24 matching lines @@
         toolsList, err := ListTools(env, vers.Major)
         if err != nil {
                 return nil, err
         }
         tools := BestTools(toolsList, vers, flags)
         if tools == nil {
                 return tools, &NotFoundError{fmt.Errorf("no compatible tools found")}
         }
         return tools, nil
 }
+
+// FindAvailableTools returns a tools.List containing all tools with a given
+// major version number available in the environment.
+// If *any* tools are present in private storage, *only* tools from private
+// storage are available.
+// If *no* tools are present in private storage, *only* tools from public
+// storage are available.
+// If no *available* tools have the supplied major version number, the function
+// returns a *NotFoundError.
+func FindAvailableTools(environ Environ, majorVersion int) (list tools.List, err error) {
+        defer convertToolsError(&err)
+        list, err = tools.ReadList(environ.Storage(), majorVersion)
+        if err == tools.ErrNoTools {
+                list, err = tools.ReadList(environ.PublicStorage(), majorVersion)
+        }
+        return list, err
+}
+
+// FindExactTools returns only the tools that match the supplied version.
+// TODO(fwereade) this should not exist: it's used by cmd/jujud/Upgrader,
+// which needs to run on every agent and must absolutely *not* in general
+// have access to an Environ.
+func FindExactTools(environ Environ, vers version.Binary) (t *state.Tools, err error) {
+        defer convertToolsError(&err)
+        list, err := FindAvailableTools(environ, vers.Major)
+        if err != nil {
+                return nil, err
+        }
+        list, err = list.Match(tools.Filter{
+                Number: vers.Number,
+                Series: vers.Series,
+                Arch:   vers.Arch,
+        })
+        if err != nil {
+                return nil, err
+        }
+        return list[0], nil
+}
+
+func isToolsError(err error) bool {
+        switch err {
+        case tools.ErrNoTools, tools.ErrNoMatches:
+                return true
+        }
+        return false
+}
+
+func convertToolsError(err *error) {
+        if isToolsError(*err) {
+                *err = &NotFoundError{*err}
+        }
+}