Update user facing messages to reference 'agent binaries' instead of …

…'tools'.
modongsongrio · May 24, 2017 · ac09806 · ac09806
1 parent 074ca56
commit ac09806
Show file tree

Hide file tree

Showing 17 changed files with 48 additions and 48 deletions.
diff --git a/cmd/juju/commands/bootstrap_test.go b/cmd/juju/commands/bootstrap_test.go
@@ -985,7 +985,7 @@ func (s *BootstrapSuite) TestInvalidLocalSource(c *gc.C) {
 			"Looking for packaged Juju agent version 1.2.0 for amd64\n",
 	)
 	c.Check(s.tw.Log(), jc.LogMatches, []jc.SimpleMessage{
-		{loggo.ERROR, "failed to bootstrap model: no matching tools available"},
+		{loggo.ERROR, "failed to bootstrap model: no matching agent binaries available"},
 	})
 }
 

diff --git a/cmd/juju/commands/upgradejuju.go b/cmd/juju/commands/upgradejuju.go
@@ -423,7 +423,7 @@ func (c *upgradeJujuCommand) initVersions(client upgradeJujuAPI, cfg *config.Con
 		// the current client version.
 		filterVersion.Major--
 	}
-	logger.Debugf("searching for tools with major: %d", filterVersion.Major)
+	logger.Debugf("searching for agent binaries with major: %d", filterVersion.Major)
 	findResult, err := client.FindTools(filterVersion.Major, -1, "", "")
 	if err != nil {
 		return nil, err

diff --git a/cmd/juju/commands/upgradejuju_test.go b/cmd/juju/commands/upgradejuju_test.go
@@ -184,35 +184,35 @@ var upgradeJujuTests = []struct {
 	currentVersion: "3.0.0-quantal-amd64",
 	agentVersion:   "3.0.0",
 	args:           []string{"--agent-version", "3.2.0"},
-	expectErr:      "no tools available",
+	expectErr:      "no agent binaries available",
 }, {
 	about:          "specified version, no matching major version",
 	tools:          []string{"4.2.0-quantal-amd64"},
 	currentVersion: "3.0.0-quantal-amd64",
 	agentVersion:   "3.0.0",
 	args:           []string{"--agent-version", "3.2.0"},
-	expectErr:      "no matching tools available",
+	expectErr:      "no matching agent binaries available",
 }, {
 	about:          "specified version, no matching minor version",
 	tools:          []string{"3.4.0-quantal-amd64"},
 	currentVersion: "3.0.0-quantal-amd64",
 	agentVersion:   "3.0.0",
 	args:           []string{"--agent-version", "3.2.0"},
-	expectErr:      "no matching tools available",
+	expectErr:      "no matching agent binaries available",
 }, {
 	about:          "specified version, no matching patch version",
 	tools:          []string{"3.2.5-quantal-amd64"},
 	currentVersion: "3.0.0-quantal-amd64",
 	agentVersion:   "3.0.0",
 	args:           []string{"--agent-version", "3.2.0"},
-	expectErr:      "no matching tools available",
+	expectErr:      "no matching agent binaries available",
 }, {
 	about:          "specified version, no matching build version",
 	tools:          []string{"3.2.0.2-quantal-amd64"},
 	currentVersion: "3.0.0-quantal-amd64",
 	agentVersion:   "3.0.0",
 	args:           []string{"--agent-version", "3.2.0"},
-	expectErr:      "no matching tools available",
+	expectErr:      "no matching agent binaries available",
 }, {
 	about:          "incompatible version (minor != 0)",
 	tools:          []string{"3.2.0-quantal-amd64"},

diff --git a/cmd/jujud/bootstrap.go b/cmd/jujud/bootstrap.go
@@ -151,7 +151,7 @@ func (c *BootstrapCommand) Run(_ *cmd.Context) error {
 		// If we have been asked for a newer version, ensure the newer
 		// tools can actually be found, or else bootstrap won't complete.
 		stream := envtools.PreferredStream(&desiredVersion, args.ControllerModelConfig.Development(), args.ControllerModelConfig.AgentStream())
-		logger.Infof("newer tools requested, looking for %v in stream %v", desiredVersion, stream)
+		logger.Infof("newer agent binaries requested, looking for %v in stream %v", desiredVersion, stream)
 		hostSeries, err := series.HostSeries()
 		if err != nil {
 			return errors.Trace(err)
@@ -163,12 +163,12 @@ func (c *BootstrapCommand) Run(_ *cmd.Context) error {
 		}
 		_, toolsErr := envtools.FindTools(env, -1, -1, stream, filter)
 		if toolsErr == nil {
-			logger.Infof("tools are available, upgrade will occur after bootstrap")
+			logger.Infof("agent binaries are available, upgrade will occur after bootstrap")
 		}
 		if errors.IsNotFound(toolsErr) {
 			// Newer tools not available, so revert to using the tools
 			// matching the current agent version.
-			logger.Warningf("newer tools for %q not available, sticking with version %q", desiredVersion, jujuversion.Current)
+			logger.Warningf("newer agent binaries for %q not available, sticking with version %q", desiredVersion, jujuversion.Current)
 			newConfigAttrs["agent-version"] = jujuversion.Current.String()
 		} else if toolsErr != nil {
 			logger.Errorf("cannot find newer tools: %v", toolsErr)
@@ -423,7 +423,7 @@ func (c *BootstrapCommand) populateTools(st *state.State, env environs.Environ)
 			Size:    tools.Size,
 			SHA256:  tools.SHA256,
 		}
-		logger.Debugf("Adding tools: %v", toolsVersion)
+		logger.Debugf("Adding agent binaries: %v", toolsVersion)
 		if err := toolstorage.Add(bytes.NewReader(data), metadata); err != nil {
 			return errors.Trace(err)
 		}

diff --git a/cmd/plugins/juju-metadata/toolsmetadata.go b/cmd/plugins/juju-metadata/toolsmetadata.go
@@ -109,7 +109,7 @@ func (c *toolsMetadataCommand) Run(context *cmd.Context) error {
 		return errors.Trace(err)
 	}
 
-	fmt.Fprintf(context.Stdout, "Finding tools in %s for stream %s.\n", c.metadataDir, c.stream)
+	fmt.Fprintf(context.Stdout, "Finding agent binaries in %s for stream %s.\n", c.metadataDir, c.stream)
 	toolsList, err := envtools.ReadList(sourceStorage, c.stream, -1, -1)
 	if err == envtools.ErrNoTools {
 		var source string

diff --git a/cmd/plugins/juju-metadata/toolsmetadata_test.go b/cmd/plugins/juju-metadata/toolsmetadata_test.go
@@ -91,8 +91,8 @@ var versionStrings = append([]string{
 var expectedOutputCommon = makeExpectedOutputCommon()
 
 func makeExpectedOutputCommon() string {
-	expected := "Finding tools in .*\n"
-	f := `.*Fetching tools from dir "{{.ToolsDir}}" to generate hash: %s` + "\n"
+	expected := "Finding agent binaries in .*\n"
+	f := `.*Fetching agent binaries from dir "{{.ToolsDir}}" to generate hash: %s` + "\n"
 
 	// Sort the global versionStrings
 	sort.Strings(versionStrings)
@@ -296,9 +296,9 @@ func (s *ToolsMetadataSuite) TestNoTools(c *gc.C) {
 	code := cmd.Main(newToolsMetadataCommand(), ctx, nil)
 	c.Assert(code, gc.Equals, 1)
 	stdout := ctx.Stdout.(*bytes.Buffer).String()
-	c.Assert(stdout, gc.Matches, ".*Finding tools in .*\n")
+	c.Assert(stdout, gc.Matches, ".*Finding agent binaries in .*\n")
 	stderr := ctx.Stderr.(*bytes.Buffer).String()
-	c.Assert(stderr, gc.Matches, "ERROR no tools available\n")
+	c.Assert(stderr, gc.Matches, "ERROR no agent binaries available\n")
 }
 
 func (s *ToolsMetadataSuite) TestPatchLevels(c *gc.C) {
@@ -318,9 +318,9 @@ func (s *ToolsMetadataSuite) TestPatchLevels(c *gc.C) {
 	c.Assert(code, gc.Equals, 0)
 	output := ctx.Stdout.(*bytes.Buffer).String()
 	expectedOutput := fmt.Sprintf(`
-Finding tools in .*
-.*Fetching tools from dir "released" to generate hash: %s
-.*Fetching tools from dir "released" to generate hash: %s
+Finding agent binaries in .*
+.*Fetching agent binaries from dir "released" to generate hash: %s
+.*Fetching agent binaries from dir "released" to generate hash: %s
 .*Writing tools/streams/v1/index2\.json
 .*Writing tools/streams/v1/index\.json
 .*Writing tools/streams/v1/com\.ubuntu\.juju-released-tools\.json

diff --git a/environs/bootstrap/bootstrap.go b/environs/bootstrap/bootstrap.go
@@ -613,7 +613,7 @@ func getBootstrapToolsVersion(possibleTools coretools.List) (coretools.List, err
 			bootstrapVersion, toolsList = compatibleVersion, compatibleTools
 		}
 	}
-	logger.Infof("picked bootstrap tools version: %s", bootstrapVersion)
+	logger.Infof("picked bootstrap agent binary version: %s", bootstrapVersion)
 	return toolsList, nil
 }
 
@@ -680,8 +680,8 @@ func setPrivateMetadataSources(metadataDir string) ([]*imagemetadata.ImageMetada
 		logger.Debugf("no agent directory found, using default agent binary metadata source: %s", tools.DefaultBaseURL)
 	} else {
 		if ending == storage.BaseToolsPath {
-			// as the specified metadataDir ended in 'tools'
-			// assume that is the only metadata to find and return
+			// As the specified metadataDir ended in 'tools'
+			// assume that is the only metadata to find and return.
 			tools.DefaultBaseURL = filepath.Dir(metadataDir)
 			logger.Debugf("setting default agent binary metadata source: %s", tools.DefaultBaseURL)
 			return nil, nil

diff --git a/environs/sync/sync.go b/environs/sync/sync.go
@@ -79,7 +79,7 @@ func SyncTools(syncContext *SyncContext) error {
 		return errors.Trace(err)
 	}
 
-	logger.Infof("listing available tools")
+	logger.Infof("listing available agent binaries")
 	if syncContext.MajorVersion == 0 && syncContext.MinorVersion == 0 {
 		syncContext.MajorVersion = jujuversion.Current.Major
 		syncContext.MinorVersion = -1
@@ -111,29 +111,29 @@ func SyncTools(syncContext *SyncContext) error {
 		return errors.Trace(err)
 	}
 
-	logger.Infof("found %d tools", len(sourceTools))
+	logger.Infof("found %d agent binaries", len(sourceTools))
 	if !syncContext.AllVersions {
 		var latest version.Number
 		latest, sourceTools = sourceTools.Newest()
-		logger.Infof("found %d recent tools (version %s)", len(sourceTools), latest)
+		logger.Infof("found %d recent agent binaries (version %s)", len(sourceTools), latest)
 	}
 	for _, tool := range sourceTools {
 		logger.Debugf("found source tool: %v", tool)
 	}
 
-	logger.Infof("listing target tools storage")
+	logger.Infof("listing target agent binaries storage")
 	targetTools, err := syncContext.TargetToolsFinder.FindTools(syncContext.MajorVersion, syncContext.Stream)
 	switch err {
 	case nil, coretools.ErrNoMatches, envtools.ErrNoTools:
 	default:
 		return errors.Trace(err)
 	}
 	for _, tool := range targetTools {
-		logger.Debugf("found target tool: %v", tool)
+		logger.Debugf("found target agent binary: %v", tool)
 	}
 
 	missing := sourceTools.Exclude(targetTools)
-	logger.Infof("found %d tools in target; %d tools to be copied", len(targetTools), len(missing))
+	logger.Infof("found %d agent binaries in target; %d agent binaries to be copied", len(targetTools), len(missing))
 	if syncContext.DryRun {
 		for _, tools := range missing {
 			logger.Infof("copying %s from %s", tools.Version, tools.URL)
@@ -145,7 +145,7 @@ func SyncTools(syncContext *SyncContext) error {
 	if err != nil {
 		return err
 	}
-	logger.Infof("copied %d tools", len(missing))
+	logger.Infof("copied %d agent binaries", len(missing))
 	return nil
 }
 
@@ -159,7 +159,7 @@ func selectSourceDatasource(syncContext *SyncContext) (simplestreams.DataSource,
 	if err != nil {
 		return nil, err
 	}
-	logger.Infof("using sync tools source: %v", sourceURL)
+	logger.Infof("source for sync of agent binaries: %v", sourceURL)
 	return simplestreams.NewURLSignedDataSource("sync tools source", sourceURL, keys.JujuPublicKey, utils.VerifySSLHostnames, simplestreams.CUSTOM_CLOUD_DATA, false), nil
 }
 
@@ -273,7 +273,7 @@ func cloneToolsForSeries(toolsInfo *BuiltAgent, stream string, series ...string)
 	if err != nil {
 		return err
 	}
-	logger.Debugf("generating tools metadata")
+	logger.Debugf("generating agent binary metadata")
 	return envtools.MergeAndWriteMetadata(metadataStore, stream, stream, targetTools, false)
 }
 
@@ -421,7 +421,7 @@ func (u StorageToolsUploader) UploadTools(toolsDir, stream string, tools *coreto
 	}
 	err := envtools.MergeAndWriteMetadata(u.Storage, toolsDir, stream, coretools.List{tools}, u.WriteMirrors)
 	if err != nil {
-		logger.Errorf("error writing tools metadata: %v", err)
+		logger.Errorf("error writing agent binary metadata: %v", err)
 		return err
 	}
 	return nil

diff --git a/environs/tools/simplestreams.go b/environs/tools/simplestreams.go
@@ -282,7 +282,7 @@ func ResolveMetadata(stor storage.StorageReader, toolsDir string, metadata []*To
 		if err != nil {
 			return errors.Annotate(err, "cannot resolve metadata")
 		}
-		logger.Infof("Fetching tools from dir %q to generate hash: %v", toolsDir, binary)
+		logger.Infof("Fetching agent binaries from dir %q to generate hash: %v", toolsDir, binary)
 		size, sha256hash, err := fetchToolsHash(stor, toolsDir, binary)
 		// Older versions of Juju only know about ppc64, not ppc64el,
 		// so if there's no metadata for ppc64, dd metadata for that arch.

diff --git a/environs/tools/storage.go b/environs/tools/storage.go
@@ -16,7 +16,7 @@ import (
 	coretools "github.com/juju/juju/tools"
 )
 
-var ErrNoTools = errors.New("no tools available")
+var ErrNoTools = errors.New("no agent binaries available")
 
 const (
 	toolPrefix = "tools/%s/juju-"
@@ -39,9 +39,9 @@ func storagePrefix(stream string) string {
 // If store contains no such tools, it returns ErrNoMatches.
 func ReadList(stor storage.StorageReader, toolsDir string, majorVersion, minorVersion int) (coretools.List, error) {
 	if minorVersion >= 0 {
-		logger.Debugf("reading v%d.%d tools", majorVersion, minorVersion)
+		logger.Debugf("reading v%d.%d agent binaries", majorVersion, minorVersion)
 	} else {
-		logger.Debugf("reading v%d.* tools", majorVersion)
+		logger.Debugf("reading v%d.* agent binaries", majorVersion)
 	}
 	storagePrefix := storagePrefix(toolsDir)
 	names, err := storage.List(stor, storagePrefix)

diff --git a/provider/azure/environ.go b/provider/azure/environ.go
@@ -495,7 +495,7 @@ func (env *azureEnviron) StartInstance(args environs.StartInstanceParams) (*envi
 	if err != nil {
 		return nil, errors.Trace(err)
 	}
-	logger.Infof("picked tools %q", selectedTools[0].Version)
+	logger.Infof("picked agent binaries %q", selectedTools[0].Version)
 
 	// Finalize the instance config, which we'll render to CustomData below.
 	if err := args.InstanceConfig.SetTools(selectedTools); err != nil {

diff --git a/provider/dummy/environs.go b/provider/dummy/environs.go
@@ -715,7 +715,7 @@ func (e *environ) Bootstrap(ctx environs.BootstrapContext, args environs.Bootstr
 		return nil, errors.New("no CA certificate in controller configuration")
 	}
 
-	logger.Infof("would pick tools from %s", availableTools)
+	logger.Infof("would pick agent binaries from %s", availableTools)
 
 	estate, err := e.state()
 	if err != nil {
@@ -992,7 +992,7 @@ func (e *environ) StartInstance(args environs.StartInstanceParams) (*environs.St
 	if args.InstanceConfig.APIInfo.Tag != names.NewMachineTag(machineId) {
 		return nil, errors.New("entity tag must match started machine")
 	}
-	logger.Infof("would pick tools from %s", args.Tools)
+	logger.Infof("would pick agent binaries from %s", args.Tools)
 	series := args.Tools.OneSeries()
 
 	idString := fmt.Sprintf("%s-%d", e.name, estate.maxId)

diff --git a/provider/lxd/environ_broker_test.go b/provider/lxd/environ_broker_test.go
@@ -47,7 +47,7 @@ func (s *environBrokerSuite) TestStartInstanceNoTools(c *gc.C) {
 	s.PatchValue(&arch.HostArch, func() string { return arch.PPC64EL })
 
 	_, err := s.Env.StartInstance(s.StartInstArgs)
-	c.Assert(err, gc.ErrorMatches, "no matching tools available")
+	c.Assert(err, gc.ErrorMatches, "no matching agent binaries available")
 }
 
 func (s *environBrokerSuite) TestStopInstances(c *gc.C) {

diff --git a/provider/oracle/environ.go b/provider/oracle/environ.go
@@ -365,7 +365,7 @@ func (o *OracleEnviron) StartInstance(args environs.StartInstanceParams) (*envir
 	if err != nil {
 		return nil, errors.Trace(err)
 	}
-	logger.Tracef("Tools: %v", tools)
+	logger.Tracef("agent binaries: %v", tools)
 	if err = args.InstanceConfig.SetTools(tools); err != nil {
 		return nil, errors.Trace(err)
 	}

diff --git a/tools/list.go b/tools/list.go
@@ -16,7 +16,7 @@ import (
 // a List is not significant.
 type List []*Tools
 
-var ErrNoMatches = errors.New("no matching tools available")
+var ErrNoMatches = errors.New("no matching agent binaries available")
 
 // String returns the versions of the tools in src, separated by semicolons.
 func (src List) String() string {

diff --git a/worker/provisioner/provisioner_test.go b/worker/provisioner/provisioner_test.go
@@ -525,9 +525,9 @@ func (s *ProvisionerSuite) TestProvisionerSetsErrorStatusWhenNoToolsAreAvailable
 	// Ensure machine error status was set, and the error matches
 	agentStatus, instanceStatus := s.waitUntilMachineNotPending(c, m)
 	c.Check(agentStatus.Status, gc.Equals, status.Error)
-	c.Check(agentStatus.Message, gc.Equals, "no matching tools available")
+	c.Check(agentStatus.Message, gc.Equals, "no matching agent binaries available")
 	c.Check(instanceStatus.Status, gc.Equals, status.ProvisioningError)
-	c.Check(instanceStatus.Message, gc.Equals, "no matching tools available")
+	c.Check(instanceStatus.Message, gc.Equals, "no matching agent binaries available")
 
 	// Restart the PA to make sure the machine is skipped again.
 	stop(c, p)

diff --git a/worker/upgrader/upgrader.go b/worker/upgrader/upgrader.go
@@ -220,7 +220,7 @@ func (u *Upgrader) loop() error {
 			if err == nil {
 				return u.newUpgradeReadyError(wantTools.Version)
 			}
-			logger.Errorf("failed to fetch tools from %q: %v", wantTools.URL, err)
+			logger.Errorf("failed to fetch agent binaries from %q: %v", wantTools.URL, err)
 		}
 		retry = retryAfter()
 	}
@@ -250,7 +250,7 @@ func (u *Upgrader) newUpgradeReadyError(newVersion version.Binary) *UpgradeReady
 }
 
 func (u *Upgrader) ensureTools(agentTools *coretools.Tools) error {
-	logger.Infof("fetching tools from %q", agentTools.URL)
+	logger.Infof("fetching agent binaries from %q", agentTools.URL)
 	// The reader MUST verify the tools' hash, so there is no
 	// need to validate the peer. We cannot anyway: see http://pad.lv/1261780.
 	resp, err := utils.GetNonValidatingHTTPClient().Get(agentTools.URL)
@@ -263,8 +263,8 @@ func (u *Upgrader) ensureTools(agentTools *coretools.Tools) error {
 	}
 	err = agenttools.UnpackTools(u.dataDir, agentTools, resp.Body)
 	if err != nil {
-		return fmt.Errorf("cannot unpack tools: %v", err)
+		return fmt.Errorf("cannot unpack agent binaries: %v", err)
 	}
-	logger.Infof("unpacked tools %s to %s", agentTools.Version, u.dataDir)
+	logger.Infof("unpacked agent binaries %s to %s", agentTools.Version, u.dataDir)
 	return nil
 }