upgrade-juju: improvements

cmd/juju/synctools.go

 package main
 
 import (
         "bytes"
         "fmt"
         "io"
         "launchpad.net/gnuflag"
         "launchpad.net/juju-core/cmd"
         "launchpad.net/juju-core/environs"
         "launchpad.net/juju-core/environs/tools"
@@ skipping 61 matching lines @@
                 return err
         }
         defer srcFile.Close()
         // We have to buffer the content, because Put requires the content
         // length, but Get only returns us a ReadCloser
         buf := &bytes.Buffer{}
         nBytes, err := io.Copy(buf, srcFile)
         if err != nil {
                 return err
         }
-        log.Infof("cmd/juju: downloaded %v (%dkB), uploading", toolsName, (nBytes+512)/1024)
+        log.Infof("downloaded %v (%dkB), uploading", toolsName, (nBytes+512)/1024)
         fmt.Fprintf(ctx.Stderr, ", download %dkB, uploading\n", (nBytes+512)/1024)
 
         if err := target.Put(toolsName, buf, nBytes); err != nil {
                 return err
         }
         return nil
 }
 
 func copyTools(
         tools []*state.Tools, source environs.StorageReader,
         target environs.Storage, dryRun bool, ctx *cmd.Context,
 ) error {
         for _, tool := range tools {
-                log.Infof("cmd/juju: copying %s from %s", tool.Binary, tool.URL)
+                log.Infof("copying %s from %s", tool.Binary, tool.URL)
                 if dryRun {
                         continue
                 }
                 if err := copyOne(tool, source, target, ctx); err != nil {
                         return err
                 }
         }
         return nil
 }
 
 func (c *SyncToolsCommand) Run(ctx *cmd.Context) error {
         officialEnviron, err := environs.NewFromAttrs(officialBucketAttrs)
         if err != nil {
-                log.Errorf("cmd/juju: failed to initialize the official bucket environment")
+                log.Errorf("failed to initialize the official bucket environment")
                 return err
         }
         fmt.Fprintf(ctx.Stderr, "listing the source bucket\n")
         sourceToolsList, err := environs.ListTools(officialEnviron, version.Current.Major)
         if err != nil {
                 return err
         }
         targetEnv, err := environs.NewFromName(c.EnvName)
         if err != nil {
-                log.Errorf("cmd/juju: unable to read %q from environment", c.EnvName)
+                log.Errorf("unable to read %q from environment", c.EnvName)
                 return err
         }
         toolsToCopy := sourceToolsList.Public
         if !c.allVersions {
-                toolsToCopy, _ = toolsToCopy.Newest()
+                _, toolsToCopy = toolsToCopy.Newest()
         }
         fmt.Fprintf(ctx.Stderr, "found %d tools in source (%d recent ones)\n",
                 len(sourceToolsList.Public), len(toolsToCopy))
         for _, tool := range toolsToCopy {
-                log.Debugf("cmd/juju: found source tool: %s", tool)
+                log.Debugf("found source tool: %s", tool)
         }
         fmt.Fprintf(ctx.Stderr, "listing target bucket\n")
         targetToolsList, err := environs.ListTools(targetEnv, version.Current.Major)
         if err != nil {
                 return err
         }
         targetTools := targetToolsList.Private
         targetStorage := targetEnv.Storage()
         if c.publicBucket {
                 targetTools = targetToolsList.Public
                 var ok bool
                 if targetStorage, ok = targetEnv.PublicStorage().(environs.Storage); !ok {
                         return fmt.Errorf("Cannot write to PublicStorage")
                 }
         }
         for _, tool := range targetTools {
-                log.Debugf("cmd/juju: found target tool: %s", tool)
+                log.Debugf("found target tool: %s", tool)
         }
         missing := toolsToCopy.Exclude(targetTools)
         fmt.Fprintf(ctx.Stdout, "found %d tools in target; %d tools to be copied\n",
                 len(targetTools), len(missing))
         err = copyTools(missing, officialEnviron.PublicStorage(), targetStorage, c.dryRun, ctx)
         if err != nil {
                 return err
         }
         fmt.Fprintf(ctx.Stderr, "copied %d tools\n", len(missing))
         return nil
 }