Merge lp:~wallyworld/juju-core/verbose-metadata-validation into lp:~go-bot/juju-core/trunk

[Ian Booth]

Add metadata to simplestreams validation

juju metadata validate-[images|tools] now prints
metadata to show how the lookup was performed.
Along the way, drive by fixes were done to delete
old code and improve existing code associated with
simplestreams.

Add metadata to simplestreams validation

juju metadata validate-[images|tools] now prints
metadata to show how the lookup was performed.
Along the way, drive by fixes were done to delete
old code and improve existing code associated with
simplestreams.

A picture is worth 1000 words:

ian@wallyworld:~$ juju metadata validate-images
ImageIds:
- ami-99999af0
- ami-0d9c9f64
- ami-6f969506
- ami-0b9c9f62
- ami-359c9f5c
- ami-a18c8fc8
Region: us-east-1
Resolve Metadata:
  source: default cloud images
  signed: true
  indexURL: http://cloud-images.ubuntu.com/releases/streams/v1/index.sjson
ian@wallyworld:~$ juju metadata validate-tools
Matching Tools Versions:
- 1.17.4-precise-amd64
- 1.17.4-precise-i386
Resolve Metadata:
  source: default simplestreams
  signed: false
  indexURL: https://streams.canonical.com/juju/tools/streams/v1/index.json
  mirrorURL: https://juju-dist.s3.amazonaws.com/tools

https://codereview.appspot.com/70960044/

[Ian Booth (wallyworld)]

Reviewers: mp+209162_code.launchpad.net,

Message:
Please take a look.

Description:
Add metadata to simplestreams validation

juju metadata validate-[images|tools] now prints
metadata to show how the lookup was performed.
Along the way, drive by fixes were done to delete
old code and improve existing code associated with
simplestreams.

A picture is worth 1000 words:

ian@wallyworld:~$ juju metadata validate-images
ImageIds:
- ami-99999af0
- ami-0d9c9f64
- ami-6f969506

- ami-0b9c9f62

- ami-359c9f5c

- ami-a18c8fc8

Region: us-east-1

Resolve Metadata:

   source: default cloud images

   signed: true

   indexURL:
http://cloud-images.ubuntu.com/releases/streams/v1/index.sjson

ian@wallyworld:~$ juju metadata validate-tools
Matching Tools Versions:
- 1.17.4-precise-amd64
- 1.17.4-precise-i386
Resolve Metadata:
   source: default simplestreams
   signed: false
   indexURL:
https://streams.canonical.com/juju/tools/streams/v1/index.json
   mirrorURL: https://juju-dist.s3.amazonaws.com/tools

https://code.launchpad.net/~wallyworld/juju-core/verbose-metadata-validation/+merge/209162

(do not edit description out of merge proposal)

Please review this at https://codereview.appspot.com/70960044/

Affected files (+330, -361 lines):
   A [revision details]
   M cmd/plugins/juju-metadata/toolsmetadata.go
   M cmd/plugins/juju-metadata/validateimagemetadata.go
   M cmd/plugins/juju-metadata/validateimagemetadata_test.go
   M cmd/plugins/juju-metadata/validatetoolsmetadata.go
   M cmd/plugins/juju-metadata/validatetoolsmetadata_test.go
   M environs/bootstrap/bootstrap_test.go
   M environs/imagemetadata/generate.go
   M environs/imagemetadata/generate_test.go
   M environs/imagemetadata/simplestreams.go
   M environs/imagemetadata/simplestreams_test.go
   M environs/imagemetadata/testing/testing.go
   M environs/imagemetadata/urls.go
   M environs/imagemetadata/validation.go
   M environs/imagemetadata/validation_test.go
   M environs/instances/image_test.go
   M environs/simplestreams/datasource.go
   M environs/simplestreams/datasource_test.go
   M environs/simplestreams/simplestreams.go
   M environs/simplestreams/simplestreams_test.go
   M environs/storage/storage.go
   M environs/storage/storage_test.go
   M environs/sync/sync.go
   D environs/tools/boilerplate.go
   M environs/tools/simplestreams.go
   M environs/tools/simplestreams_test.go
   M environs/tools/testing/testing.go
   M environs/tools/tools.go
   M environs/tools/urls.go
   M environs/tools/validation.go
   M environs/tools/validation_test.go
   M provider/azure/environ.go
   M provider/azure/instancetype.go
   M provider/azure/instancetype_test.go
   M provider/common/mock_test.go
   M provider/dummy/environs.go
   M provider/ec2/ec2.go
   M provider/ec2/image.go
   M provider/ec2/image_test.go
   M provider/ec2/local_test.go
   M provider/local/environ.go
   M provider/maas/environ.go
   M provider/manual/environ.go
   M provider/openstack/image.go
   M provider/openstack/local_test.go
   M provider/openstack/provider.go

[Ian Booth (wallyworld)]

Please take a look.

https://codereview.appspot.com/70960044/

[Tim Penhey (thumper)]

On 2014/03/04 05:51:30, wallyworld wrote:
> Please take a look.

LGTM - although was wondering why the resolve information wasn't
encapsulated in the error rather than a separate parameter.

https://codereview.appspot.com/70960044/

[Tim Penhey (thumper)]

On 2014/03/05 01:54:16, thumper wrote:
> On 2014/03/04 05:51:30, wallyworld wrote:
> > Please take a look.

> LGTM - although was wondering why the resolve information wasn't
encapsulated in
> the error rather than a separate parameter.

Ah, we show the resolution info on success as well. nm.

https://codereview.appspot.com/70960044/

=== modified file 'cmd/plugins/juju-metadata/toolsmetadata.go'
--- cmd/plugins/juju-metadata/toolsmetadata.go	2014-01-31 00:14:11 +0000
+++ cmd/plugins/juju-metadata/toolsmetadata.go	2014-03-04 05:51:00 +0000
@@ -5,9 +5,6 @@
 
 import (
 	"fmt"
-	"net/url"
-	"path"
-	"strings"
 
 	"github.com/loggo/loggo"
 	"launchpad.net/gnuflag"
@@ -60,19 +57,12 @@
 	const minorVersion = -1
 	toolsList, err := envtools.ReadList(sourceStorage, version.Current.Major, minorVersion)
 	if err == envtools.ErrNoTools {
-		source := envtools.DefaultBaseURL
-		var u *url.URL
-		u, err = url.Parse(source)
+		var source string
+		source, err = envtools.ToolsURL(envtools.DefaultBaseURL)
 		if err != nil {
-			return fmt.Errorf("invalid tools source %s: %v", source, err)
-		}
-		if u.Scheme == "" {
-			source = "file://" + source
-			if !strings.HasSuffix(source, "/"+storage.BaseToolsPath) {
-				source = path.Join(source, storage.BaseToolsPath)
-			}
-		}
-		sourceDataSource := simplestreams.NewURLDataSource(source, simplestreams.VerifySSLHostnames)
+			return err
+		}
+		sourceDataSource := simplestreams.NewURLDataSource("local source", source, simplestreams.VerifySSLHostnames)
 		toolsList, err = envtools.FindToolsForCloud(
 			[]simplestreams.DataSource{sourceDataSource}, simplestreams.CloudSpec{},
 			version.Current.Major, minorVersion, coretools.Filter{})

=== modified file 'cmd/plugins/juju-metadata/validateimagemetadata.go'
--- cmd/plugins/juju-metadata/validateimagemetadata.go	2014-02-13 02:46:58 +0000
+++ cmd/plugins/juju-metadata/validateimagemetadata.go	2014-03-04 05:51:00 +0000
@@ -22,6 +22,7 @@
 // ValidateImageMetadataCommand
 type ValidateImageMetadataCommand struct {
 	cmd.EnvCommandBase
+	out          cmd.Output
 	providerType string
 	metadataDir  string
 	series       string
@@ -79,6 +80,7 @@
 
 func (c *ValidateImageMetadataCommand) SetFlags(f *gnuflag.FlagSet) {
 	c.EnvCommandBase.SetFlags(f)
+	c.out.AddFlags(f, "smart", cmd.DefaultFormatters)
 	f.StringVar(&c.providerType, "p", "", "the provider type eg ec2, openstack")
 	f.StringVar(&c.metadataDir, "d", "", "directory where metadata files are found")
 	f.StringVar(&c.series, "s", "", "the series for which to validate (overrides env config series)")
@@ -180,26 +182,43 @@
 		if _, err := os.Stat(dir); err != nil {
 			return err
 		}
-		params.Sources = []simplestreams.DataSource{simplestreams.NewURLDataSource("file://"+dir, simplestreams.VerifySSLHostnames)}
+		params.Sources = []simplestreams.DataSource{
+			simplestreams.NewURLDataSource(
+				"local metadata directory", "file://"+dir, simplestreams.VerifySSLHostnames),
+		}
 	}
 	params.Stream = c.stream
 
-	image_ids, err := imagemetadata.ValidateImageMetadata(params)
+	image_ids, resolveInfo, err := imagemetadata.ValidateImageMetadata(params)
 	if err != nil {
+		if resolveInfo != nil {
+			metadata := map[string]interface{}{
+				"Resolve Metadata": *resolveInfo,
+			}
+			if metadataYaml, yamlErr := cmd.FormatYaml(metadata); yamlErr == nil {
+				err = fmt.Errorf("%v\n%v", err, string(metadataYaml))
+			}
+		}
 		return err
 	}
-
 	if len(image_ids) > 0 {
-		fmt.Fprintf(context.Stdout, "matching image ids for region %q:\n%s\n", params.Region, strings.Join(image_ids, "\n"))
+		metadata := map[string]interface{}{
+			"ImageIds":         image_ids,
+			"Region":           params.Region,
+			"Resolve Metadata": *resolveInfo,
+		}
+		c.out.Write(context, metadata)
 	} else {
-		var urls []string
+		var sources []string
 		for _, s := range params.Sources {
 			url, err := s.URL("")
-			if err != nil {
-				urls = append(urls, url)
+			if err == nil {
+				sources = append(sources, fmt.Sprintf("- %s (%s)", s.Description(), url))
 			}
 		}
-		return fmt.Errorf("no matching image ids for region %s using URLs:\n%s", params.Region, strings.Join(urls, "\n"))
+		return fmt.Errorf(
+			"no matching image ids for region %s using sources:\n%s",
+			params.Region, strings.Join(sources, "\n"))
 	}
 	return nil
 }

=== modified file 'cmd/plugins/juju-metadata/validateimagemetadata_test.go'
--- cmd/plugins/juju-metadata/validateimagemetadata_test.go	2014-01-29 02:09:39 +0000
+++ cmd/plugins/juju-metadata/validateimagemetadata_test.go	2014-03-04 05:51:00 +0000
@@ -133,7 +133,9 @@
 	c.Assert(code, gc.Equals, 0)
 	errOut := ctx.Stdout.(*bytes.Buffer).String()
 	strippedOut := strings.Replace(errOut, "\n", "", -1)
-	c.Check(strippedOut, gc.Matches, `matching image ids for region "us-east-1":.*`)
+	c.Check(
+		strippedOut, gc.Matches,
+		`ImageIds:.*"1234".*Region:.*us-east-1.*Resolve Metadata:.*source: local metadata directory.*`)
 }
 
 func (s *ValidateImageMetadataSuite) TestEc2LocalMetadataUsingEnvironment(c *gc.C) {
@@ -169,7 +171,9 @@
 	c.Assert(code, gc.Equals, 0)
 	errOut := ctx.Stdout.(*bytes.Buffer).String()
 	strippedOut := strings.Replace(errOut, "\n", "", -1)
-	c.Check(strippedOut, gc.Matches, `matching image ids for region "us-west-1":.*`)
+	c.Check(
+		strippedOut, gc.Matches,
+		`ImageIds:.*"1234".*Region:.*us-west-1.*Resolve Metadata:.*source: local metadata directory.*`)
 }
 
 func (s *ValidateImageMetadataSuite) TestEc2LocalMetadataNoMatch(c *gc.C) {
@@ -187,6 +191,9 @@
 			"-u", "https://ec2.region.amazonaws.com", "-d", s.metadataDir},
 	)
 	c.Assert(code, gc.Equals, 1)
+	errOut := ctx.Stderr.(*bytes.Buffer).String()
+	strippedOut := strings.Replace(errOut, "\n", "", -1)
+	c.Check(strippedOut, gc.Matches, `.*Resolve Metadata:.*`)
 }
 
 func (s *ValidateImageMetadataSuite) TestOpenstackLocalMetadataWithManualParams(c *gc.C) {
@@ -200,7 +207,9 @@
 	c.Assert(code, gc.Equals, 0)
 	errOut := ctx.Stdout.(*bytes.Buffer).String()
 	strippedOut := strings.Replace(errOut, "\n", "", -1)
-	c.Check(strippedOut, gc.Matches, `matching image ids for region "region-2":.*`)
+	c.Check(
+		strippedOut, gc.Matches,
+		`ImageIds:.*"1234".*Region:.*region-2.*Resolve Metadata:.*source: local metadata directory.*`)
 }
 
 func (s *ValidateImageMetadataSuite) TestOpenstackLocalMetadataNoMatch(c *gc.C) {
@@ -212,10 +221,16 @@
 			"-u", "some-auth-url", "-d", s.metadataDir},
 	)
 	c.Assert(code, gc.Equals, 1)
+	errOut := ctx.Stderr.(*bytes.Buffer).String()
+	strippedOut := strings.Replace(errOut, "\n", "", -1)
+	c.Check(strippedOut, gc.Matches, `.*Resolve Metadata:.*`)
 	code = cmd.Main(
 		&ValidateImageMetadataCommand{}, ctx, []string{
 			"-p", "openstack", "-s", "raring", "-r", "region-3",
 			"-u", "some-auth-url", "-d", s.metadataDir},
 	)
 	c.Assert(code, gc.Equals, 1)
+	errOut = ctx.Stderr.(*bytes.Buffer).String()
+	strippedOut = strings.Replace(errOut, "\n", "", -1)
+	c.Check(strippedOut, gc.Matches, `.*Resolve Metadata:.*`)
 }

=== modified file 'cmd/plugins/juju-metadata/validatetoolsmetadata.go'
--- cmd/plugins/juju-metadata/validatetoolsmetadata.go	2014-02-28 03:05:47 +0000
+++ cmd/plugins/juju-metadata/validatetoolsmetadata.go	2014-03-04 05:51:00 +0000
@@ -21,6 +21,7 @@
 // ValidateToolsMetadataCommand
 type ValidateToolsMetadataCommand struct {
 	cmd.EnvCommandBase
+	out          cmd.Output
 	providerType string
 	metadataDir  string
 	series       string
@@ -100,6 +101,7 @@
 
 func (c *ValidateToolsMetadataCommand) SetFlags(f *gnuflag.FlagSet) {
 	c.EnvCommandBase.SetFlags(f)
+	c.out.AddFlags(f, "smart", cmd.DefaultFormatters)
 	f.StringVar(&c.providerType, "p", "", "the provider type eg ec2, openstack")
 	f.StringVar(&c.metadataDir, "d", "", "directory where metadata files are found")
 	f.StringVar(&c.series, "s", "", "the series for which to validate (overrides env config series)")
@@ -191,30 +193,48 @@
 		if _, err := os.Stat(c.metadataDir); err != nil {
 			return err
 		}
-		params.Sources = []simplestreams.DataSource{simplestreams.NewURLDataSource("file://"+c.metadataDir, simplestreams.VerifySSLHostnames)}
+		toolsURL, err := tools.ToolsURL(c.metadataDir)
+		if err != nil {
+			return err
+		}
+		params.Sources = []simplestreams.DataSource{simplestreams.NewURLDataSource(
+			"local metadata directory", toolsURL, simplestreams.VerifySSLHostnames),
+		}
 	}
 
-	versions, err := tools.ValidateToolsMetadata(&tools.ToolsMetadataLookupParams{
+	versions, resolveInfo, err := tools.ValidateToolsMetadata(&tools.ToolsMetadataLookupParams{
 		MetadataLookupParams: *params,
 		Version:              c.exactVersion,
 		Major:                c.major,
 		Minor:                c.minor,
 	})
 	if err != nil {
+		if resolveInfo != nil {
+			metadata := map[string]interface{}{
+				"Resolve Metadata": *resolveInfo,
+			}
+			if metadataYaml, yamlErr := cmd.FormatYaml(metadata); yamlErr == nil {
+				err = fmt.Errorf("%v\n%v", err, string(metadataYaml))
+			}
+		}
 		return err
 	}
 
 	if len(versions) > 0 {
-		fmt.Fprintf(context.Stdout, "matching tools versions:\n%s\n", strings.Join(versions, "\n"))
+		metadata := map[string]interface{}{
+			"Matching Tools Versions": versions,
+			"Resolve Metadata":        *resolveInfo,
+		}
+		c.out.Write(context, metadata)
 	} else {
-		var urls []string
+		var sources []string
 		for _, s := range params.Sources {
 			url, err := s.URL("")
-			if err != nil {
-				urls = append(urls, url)
+			if err == nil {
+				sources = append(sources, fmt.Sprintf("- %s (%s)", s.Description(), url))
 			}
 		}
-		return fmt.Errorf("no matching tools using URLs:\n%s", strings.Join(urls, "\n"))
+		return fmt.Errorf("no matching tools using sources:\n%s", strings.Join(sources, "\n"))
 	}
 	return nil
 }

=== modified file 'cmd/plugins/juju-metadata/validatetoolsmetadata_test.go'
--- cmd/plugins/juju-metadata/validatetoolsmetadata_test.go	2014-01-22 22:48:54 +0000
+++ cmd/plugins/juju-metadata/validatetoolsmetadata_test.go	2014-03-04 05:51:00 +0000
@@ -11,9 +11,8 @@
 	gc "launchpad.net/gocheck"
 
 	"launchpad.net/juju-core/cmd"
-	"launchpad.net/juju-core/environs/simplestreams"
+	"launchpad.net/juju-core/environs/filestorage"
 	"launchpad.net/juju-core/environs/tools"
-	"launchpad.net/juju-core/juju/osenv"
 	coretesting "launchpad.net/juju-core/testing"
 	"launchpad.net/juju-core/testing/testbase"
 	"launchpad.net/juju-core/version"
@@ -21,7 +20,8 @@
 
 type ValidateToolsMetadataSuite struct {
 	testbase.LoggingSuite
-	home *coretesting.FakeHome
+	home        *coretesting.FakeHome
+	metadataDir string
 }
 
 var _ = gc.Suite(&ValidateToolsMetadataSuite{})
@@ -72,16 +72,14 @@
 }
 
 func (s *ValidateToolsMetadataSuite) makeLocalMetadata(c *gc.C, version, region, series, endpoint string) error {
-	tm := tools.ToolsMetadata{
+	tm := []*tools.ToolsMetadata{{
 		Version: version,
 		Arch:    "amd64",
 		Release: series,
-	}
-	cloudSpec := simplestreams.CloudSpec{
-		Region:   region,
-		Endpoint: endpoint,
-	}
-	_, err := tools.MakeBoilerplate(&tm, &cloudSpec, false)
+	}}
+	targetStorage, err := filestorage.NewFileStorageWriter(s.metadataDir, filestorage.UseDefaultTmpDir)
+	c.Assert(err, gc.IsNil)
+	err = tools.WriteMetadata(targetStorage, tm, false)
 	if err != nil {
 		return err
 	}
@@ -91,6 +89,7 @@
 func (s *ValidateToolsMetadataSuite) SetUpTest(c *gc.C) {
 	s.LoggingSuite.SetUpTest(c)
 	s.home = coretesting.MakeFakeHome(c, metadataTestEnvConfig)
+	s.metadataDir = c.MkDir()
 	restore := testbase.PatchEnvironment("AWS_ACCESS_KEY_ID", "access")
 	s.AddCleanup(func(*gc.C) { restore() })
 	restore = testbase.PatchEnvironment("AWS_SECRET_ACCESS_KEY", "secret")
@@ -114,14 +113,13 @@
 func (s *ValidateToolsMetadataSuite) TestEc2LocalMetadataUsingEnvironment(c *gc.C) {
 	s.setupEc2LocalMetadata(c, "us-east-1")
 	ctx := coretesting.Context(c)
-	metadataDir := osenv.JujuHomePath("")
 	code := cmd.Main(
-		&ValidateToolsMetadataCommand{}, ctx, []string{"-e", "ec2", "-j", "1.11.4", "-d", metadataDir},
+		&ValidateToolsMetadataCommand{}, ctx, []string{"-e", "ec2", "-j", "1.11.4", "-d", s.metadataDir},
 	)
 	c.Assert(code, gc.Equals, 0)
 	errOut := ctx.Stdout.(*bytes.Buffer).String()
 	strippedOut := strings.Replace(errOut, "\n", "", -1)
-	c.Check(strippedOut, gc.Matches, `matching tools versions:.*`)
+	c.Check(strippedOut, gc.Matches, `Matching Tools Versions:.*Resolve Metadata.*`)
 }
 
 func (s *ValidateToolsMetadataSuite) TestEc2LocalMetadataUsingIncompleteEnvironment(c *gc.C) {
@@ -141,123 +139,121 @@
 func (s *ValidateToolsMetadataSuite) TestEc2LocalMetadataWithManualParams(c *gc.C) {
 	s.setupEc2LocalMetadata(c, "us-west-1")
 	ctx := coretesting.Context(c)
-	metadataDir := osenv.JujuHomePath("")
 	code := cmd.Main(
 		&ValidateToolsMetadataCommand{}, ctx, []string{
 			"-p", "ec2", "-s", "precise", "-r", "us-west-1", "-j", "1.11.4",
-			"-u", "https://ec2.us-west-1.amazonaws.com", "-d", metadataDir},
+			"-u", "https://ec2.us-west-1.amazonaws.com", "-d", s.metadataDir},
 	)
 	c.Assert(code, gc.Equals, 0)
 	errOut := ctx.Stdout.(*bytes.Buffer).String()
 	strippedOut := strings.Replace(errOut, "\n", "", -1)
-	c.Check(strippedOut, gc.Matches, `matching tools versions:.*`)
+	c.Check(strippedOut, gc.Matches, `Matching Tools Versions:.*Resolve Metadata.*`)
 }
 
 func (s *ValidateToolsMetadataSuite) TestEc2LocalMetadataNoMatch(c *gc.C) {
 	s.setupEc2LocalMetadata(c, "us-east-1")
 	ctx := coretesting.Context(c)
-	metadataDir := osenv.JujuHomePath("")
 	code := cmd.Main(
 		&ValidateToolsMetadataCommand{}, ctx, []string{
 			"-p", "ec2", "-s", "raring", "-r", "us-west-1",
-			"-u", "https://ec2.us-west-1.amazonaws.com", "-d", metadataDir},
+			"-u", "https://ec2.us-west-1.amazonaws.com", "-d", s.metadataDir},
 	)
 	c.Assert(code, gc.Equals, 1)
 	code = cmd.Main(
 		&ValidateToolsMetadataCommand{}, ctx, []string{
 			"-p", "ec2", "-s", "precise", "-r", "region",
-			"-u", "https://ec2.region.amazonaws.com", "-d", metadataDir},
+			"-u", "https://ec2.region.amazonaws.com", "-d", s.metadataDir},
 	)
 	c.Assert(code, gc.Equals, 1)
+	errOut := ctx.Stderr.(*bytes.Buffer).String()
+	strippedOut := strings.Replace(errOut, "\n", "", -1)
+	c.Check(strippedOut, gc.Matches, `.*Resolve Metadata:.*`)
 }
 
 func (s *ValidateToolsMetadataSuite) TestOpenstackLocalMetadataWithManualParams(c *gc.C) {
 	s.makeLocalMetadata(c, "1.11.4", "region-2", "raring", "some-auth-url")
 	ctx := coretesting.Context(c)
-	metadataDir := osenv.JujuHomePath("")
 	code := cmd.Main(
 		&ValidateToolsMetadataCommand{}, ctx, []string{
 			"-p", "openstack", "-s", "raring", "-r", "region-2", "-j", "1.11.4",
-			"-u", "some-auth-url", "-d", metadataDir},
+			"-u", "some-auth-url", "-d", s.metadataDir},
 	)
 	c.Assert(code, gc.Equals, 0)
 	errOut := ctx.Stdout.(*bytes.Buffer).String()
 	strippedOut := strings.Replace(errOut, "\n", "", -1)
-	c.Check(strippedOut, gc.Matches, `matching tools versions:.*`)
+	c.Check(strippedOut, gc.Matches, `Matching Tools Versions:.*Resolve Metadata.*`)
 }
 
 func (s *ValidateToolsMetadataSuite) TestOpenstackLocalMetadataNoMatch(c *gc.C) {
 	s.makeLocalMetadata(c, "1.11.4", "region-2", "raring", "some-auth-url")
 	ctx := coretesting.Context(c)
-	metadataDir := osenv.JujuHomePath("")
 	code := cmd.Main(
 		&ValidateToolsMetadataCommand{}, ctx, []string{
 			"-p", "openstack", "-s", "precise", "-r", "region-2",
-			"-u", "some-auth-url", "-d", metadataDir},
+			"-u", "some-auth-url", "-d", s.metadataDir},
 	)
 	c.Assert(code, gc.Equals, 1)
 	code = cmd.Main(
 		&ValidateToolsMetadataCommand{}, ctx, []string{
 			"-p", "openstack", "-s", "raring", "-r", "region-3",
-			"-u", "some-auth-url", "-d", metadataDir},
+			"-u", "some-auth-url", "-d", s.metadataDir},
 	)
 	c.Assert(code, gc.Equals, 1)
+	errOut := ctx.Stderr.(*bytes.Buffer).String()
+	strippedOut := strings.Replace(errOut, "\n", "", -1)
+	c.Check(strippedOut, gc.Matches, `.*Resolve Metadata:.*`)
 }
 
 func (s *ValidateToolsMetadataSuite) TestDefaultVersion(c *gc.C) {
 	s.makeLocalMetadata(c, version.Current.Number.String(), "region-2", "raring", "some-auth-url")
 	ctx := coretesting.Context(c)
-	metadataDir := osenv.JujuHomePath("")
 	code := cmd.Main(
 		&ValidateToolsMetadataCommand{}, ctx, []string{
 			"-p", "openstack", "-s", "raring", "-r", "region-2",
-			"-u", "some-auth-url", "-d", metadataDir},
+			"-u", "some-auth-url", "-d", s.metadataDir},
 	)
 	c.Assert(code, gc.Equals, 0)
 	errOut := ctx.Stdout.(*bytes.Buffer).String()
 	strippedOut := strings.Replace(errOut, "\n", "", -1)
-	c.Check(strippedOut, gc.Matches, `matching tools versions:.*`)
+	c.Check(strippedOut, gc.Matches, `Matching Tools Versions:.*Resolve Metadata.*`)
 }
 
 func (s *ValidateToolsMetadataSuite) TestMajorVersionMatch(c *gc.C) {
 	s.makeLocalMetadata(c, "1.11.4", "region-2", "raring", "some-auth-url")
 	ctx := coretesting.Context(c)
-	metadataDir := osenv.JujuHomePath("")
 	code := cmd.Main(
 		&ValidateToolsMetadataCommand{}, ctx, []string{
 			"-p", "openstack", "-s", "raring", "-r", "region-2",
-			"-u", "some-auth-url", "-d", metadataDir, "-m", "1"},
+			"-u", "some-auth-url", "-d", s.metadataDir, "-m", "1"},
 	)
 	c.Assert(code, gc.Equals, 0)
 	errOut := ctx.Stdout.(*bytes.Buffer).String()
 	strippedOut := strings.Replace(errOut, "\n", "", -1)
-	c.Check(strippedOut, gc.Matches, `matching tools versions:.*`)
+	c.Check(strippedOut, gc.Matches, `Matching Tools Versions:.*Resolve Metadata.*`)
 }
 
 func (s *ValidateToolsMetadataSuite) TestMajorMinorVersionMatch(c *gc.C) {
 	s.makeLocalMetadata(c, "1.12.1", "region-2", "raring", "some-auth-url")
 	ctx := coretesting.Context(c)
-	metadataDir := osenv.JujuHomePath("")
 	code := cmd.Main(
 		&ValidateToolsMetadataCommand{}, ctx, []string{
 			"-p", "openstack", "-s", "raring", "-r", "region-2",
-			"-u", "some-auth-url", "-d", metadataDir, "-m", "1.12"},
+			"-u", "some-auth-url", "-d", s.metadataDir, "-m", "1.12"},
 	)
 	c.Assert(code, gc.Equals, 0)
 	errOut := ctx.Stdout.(*bytes.Buffer).String()
 	strippedOut := strings.Replace(errOut, "\n", "", -1)
-	c.Check(strippedOut, gc.Matches, `matching tools versions:.*`)
+	c.Check(strippedOut, gc.Matches, `Matching Tools Versions:.*Resolve Metadata.*`)
 }
 
 func (s *ValidateToolsMetadataSuite) TestJustDirectory(c *gc.C) {
 	s.makeLocalMetadata(c, version.Current.Number.String(), "region-2", "raring", "some-auth-url")
 	ctx := coretesting.Context(c)
-	metadataDir := osenv.JujuHomePath("")
 	code := cmd.Main(
-		&ValidateToolsMetadataCommand{}, ctx, []string{"-s", "raring", "-d", metadataDir},
+		&ValidateToolsMetadataCommand{}, ctx, []string{"-s", "raring", "-d", s.metadataDir},
 	)
 	c.Assert(code, gc.Equals, 0)
 	errOut := ctx.Stdout.(*bytes.Buffer).String()
 	strippedOut := strings.Replace(errOut, "\n", "", -1)
-	c.Check(strippedOut, gc.Matches, `matching tools versions:.*`)
+	c.Check(strippedOut, gc.Matches, `Matching Tools Versions:.*Resolve Metadata.*`)
 }

=== modified file 'environs/bootstrap/bootstrap_test.go'
--- environs/bootstrap/bootstrap_test.go	2014-02-13 02:46:58 +0000
+++ environs/bootstrap/bootstrap_test.go	2014-03-04 05:51:00 +0000
@@ -218,7 +218,8 @@
 // GetToolsSources returns a list of sources which are used to search for simplestreams tools metadata.
 func (e *bootstrapEnviron) GetToolsSources() ([]simplestreams.DataSource, error) {
 	// Add the simplestreams source off the control bucket.
-	return []simplestreams.DataSource{storage.NewStorageSimpleStreamsDataSource(e.Storage(), storage.BaseToolsPath)}, nil
+	return []simplestreams.DataSource{
+		storage.NewStorageSimpleStreamsDataSource("cloud storage", e.Storage(), storage.BaseToolsPath)}, nil
 }
 
 func newEnviron(name string, defaultKeys bool) *bootstrapEnviron {

=== modified file 'environs/imagemetadata/generate.go'
--- environs/imagemetadata/generate.go	2014-01-21 22:26:08 +0000
+++ environs/imagemetadata/generate.go	2014-03-04 05:51:00 +0000
@@ -34,9 +34,9 @@
 // readMetadata reads the image metadata from metadataStore.
 func readMetadata(metadataStore storage.Storage) ([]*ImageMetadata, error) {
 	// Read any existing metadata so we can merge the new tools metadata with what's there.
-	dataSource := storage.NewStorageSimpleStreamsDataSource(metadataStore, storage.BaseImagesPath)
+	dataSource := storage.NewStorageSimpleStreamsDataSource("existing metadata", metadataStore, storage.BaseImagesPath)
 	imageConstraint := NewImageConstraint(simplestreams.LookupParams{})
-	existingMetadata, err := Fetch(
+	existingMetadata, _, err := Fetch(
 		[]simplestreams.DataSource{dataSource}, simplestreams.DefaultIndexPath, imageConstraint, false)
 	if err != nil && !errors.IsNotFoundError(err) {
 		return nil, err

=== modified file 'environs/imagemetadata/generate_test.go'
--- environs/imagemetadata/generate_test.go	2014-01-21 22:26:08 +0000
+++ environs/imagemetadata/generate_test.go	2014-03-04 05:51:00 +0000
@@ -28,8 +28,8 @@
 		Series:    []string{series},
 		Arches:    []string{arch},
 	})
-	dataSource := storage.NewStorageSimpleStreamsDataSource(stor, "images")
-	metadata, err := imagemetadata.Fetch(
+	dataSource := storage.NewStorageSimpleStreamsDataSource("test datasource", stor, "images")
+	metadata, _, err := imagemetadata.Fetch(
 		[]simplestreams.DataSource{dataSource}, simplestreams.DefaultIndexPath, cons, false)
 	c.Assert(err, gc.IsNil)
 	c.Assert(metadata, gc.HasLen, 1)

=== modified file 'environs/imagemetadata/simplestreams.go'
--- environs/imagemetadata/simplestreams.go	2014-02-28 03:05:47 +0000
+++ environs/imagemetadata/simplestreams.go	2014-03-04 05:51:00 +0000
@@ -164,22 +164,24 @@
 // The base URL locations are as specified - the first location which has a file is the one used.
 // Signed data is preferred, but if there is no signed data available and onlySigned is false,
 // then unsigned data is used.
-func Fetch(sources []simplestreams.DataSource, indexPath string, cons *ImageConstraint, onlySigned bool) ([]*ImageMetadata, error) {
+func Fetch(
+	sources []simplestreams.DataSource, indexPath string, cons *ImageConstraint,
+	onlySigned bool) ([]*ImageMetadata, *simplestreams.ResolveInfo, error) {
 	params := simplestreams.ValueParams{
 		DataType:      ImageIds,
 		FilterFunc:    appendMatchingImages,
 		ValueTemplate: ImageMetadata{},
 		PublicKey:     simplestreamsImagesPublicKey,
 	}
-	items, err := simplestreams.GetMetadata(sources, indexPath, cons, onlySigned, params)
+	items, resolveInfo, err := simplestreams.GetMetadata(sources, indexPath, cons, onlySigned, params)
 	if err != nil {
-		return nil, err
+		return nil, resolveInfo, err
 	}
 	metadata := make([]*ImageMetadata, len(items))
 	for i, md := range items {
 		metadata[i] = md.(*ImageMetadata)
 	}
-	return metadata, nil
+	return metadata, resolveInfo, nil
 }
 
 type imageKey struct {

=== modified file 'environs/imagemetadata/simplestreams_test.go'
--- environs/imagemetadata/simplestreams_test.go	2014-01-29 00:14:51 +0000
+++ environs/imagemetadata/simplestreams_test.go	2014-03-04 05:51:00 +0000
@@ -66,7 +66,8 @@
 func registerSimpleStreamsTests() {
 	gc.Suite(&simplestreamsSuite{
 		LocalLiveSimplestreamsSuite: sstesting.LocalLiveSimplestreamsSuite{
-			Source:        simplestreams.NewURLDataSource("test:", simplestreams.VerifySSLHostnames),
+			Source: simplestreams.NewURLDataSource(
+				"test roundtripper", "test:", simplestreams.VerifySSLHostnames),
 			RequireSigned: false,
 			DataType:      imagemetadata.ImageIds,
 			ValidConstraint: imagemetadata.NewImageConstraint(simplestreams.LookupParams{
@@ -84,7 +85,7 @@
 
 func registerLiveSimpleStreamsTests(baseURL string, validImageConstraint simplestreams.LookupConstraint, requireSigned bool) {
 	gc.Suite(&sstesting.LocalLiveSimplestreamsSuite{
-		Source:          simplestreams.NewURLDataSource(baseURL, simplestreams.VerifySSLHostnames),
+		Source:          simplestreams.NewURLDataSource("test", baseURL, simplestreams.VerifySSLHostnames),
 		RequireSigned:   requireSigned,
 		DataType:        imagemetadata.ImageIds,
 		ValidConstraint: validImageConstraint,
@@ -265,7 +266,11 @@
 			Series:    []string{"precise"},
 			Arches:    t.arches,
 		})
-		images, err := imagemetadata.Fetch([]simplestreams.DataSource{s.Source}, simplestreams.DefaultIndexPath, imageConstraint, s.RequireSigned)
+		// Add invalid datasource and check later that resolveInfo is correct.
+		invalidSource := simplestreams.NewURLDataSource("invalid", "file://invalid", simplestreams.VerifySSLHostnames)
+		images, resolveInfo, err := imagemetadata.Fetch(
+			[]simplestreams.DataSource{invalidSource, s.Source}, simplestreams.DefaultIndexPath,
+			imageConstraint, s.RequireSigned)
 		if !c.Check(err, gc.IsNil) {
 			continue
 		}
@@ -273,6 +278,12 @@
 			testImage.Version = t.version
 		}
 		c.Check(images, gc.DeepEquals, t.images)
+		c.Check(resolveInfo, gc.DeepEquals, &simplestreams.ResolveInfo{
+			Source:    "test roundtripper",
+			Signed:    s.RequireSigned,
+			IndexURL:  "test:/streams/v1/index.json",
+			MirrorURL: "",
+		})
 	}
 }
 
@@ -364,28 +375,34 @@
 }
 
 func (s *signedSuite) TestSignedImageMetadata(c *gc.C) {
-	signedSource := simplestreams.NewURLDataSource("signedtest://host/signed", simplestreams.VerifySSLHostnames)
+	signedSource := simplestreams.NewURLDataSource("test", "signedtest://host/signed", simplestreams.VerifySSLHostnames)
 	imageConstraint := imagemetadata.NewImageConstraint(simplestreams.LookupParams{
 		CloudSpec: simplestreams.CloudSpec{"us-east-1", "https://ec2.us-east-1.amazonaws.com"},
 		Series:    []string{"precise"},
 		Arches:    []string{"amd64"},
 	})
-	images, err := imagemetadata.Fetch(
+	images, resolveInfo, err := imagemetadata.Fetch(
 		[]simplestreams.DataSource{signedSource}, simplestreams.DefaultIndexPath, imageConstraint, true)
 	c.Assert(err, gc.IsNil)
 	c.Assert(len(images), gc.Equals, 1)
 	c.Assert(images[0].Id, gc.Equals, "ami-123456")
+	c.Check(resolveInfo, gc.DeepEquals, &simplestreams.ResolveInfo{
+		Source:    "test",
+		Signed:    true,
+		IndexURL:  "signedtest://host/signed/streams/v1/index.sjson",
+		MirrorURL: "",
+	})
 }
 
 func (s *signedSuite) TestSignedImageMetadataInvalidSignature(c *gc.C) {
-	signedSource := simplestreams.NewURLDataSource("signedtest://host/signed", simplestreams.VerifySSLHostnames)
+	signedSource := simplestreams.NewURLDataSource("test", "signedtest://host/signed", simplestreams.VerifySSLHostnames)
 	imageConstraint := imagemetadata.NewImageConstraint(simplestreams.LookupParams{
 		CloudSpec: simplestreams.CloudSpec{"us-east-1", "https://ec2.us-east-1.amazonaws.com"},
 		Series:    []string{"precise"},
 		Arches:    []string{"amd64"},
 	})
 	imagemetadata.SetSigningPublicKey(s.origKey)
-	_, err := imagemetadata.Fetch(
+	_, _, err := imagemetadata.Fetch(
 		[]simplestreams.DataSource{signedSource}, simplestreams.DefaultIndexPath, imageConstraint, true)
 	c.Assert(err, gc.ErrorMatches, "cannot read index data.*")
 }

=== modified file 'environs/imagemetadata/testing/testing.go'
--- environs/imagemetadata/testing/testing.go	2014-01-21 22:26:08 +0000
+++ environs/imagemetadata/testing/testing.go	2014-03-04 05:51:00 +0000
@@ -27,7 +27,7 @@
 
 // ParseMetadataFromStorage loads ImageMetadata from the specified storage reader.
 func ParseMetadataFromStorage(c *gc.C, stor storage.StorageReader) []*imagemetadata.ImageMetadata {
-	source := storage.NewStorageSimpleStreamsDataSource(stor, "images")
+	source := storage.NewStorageSimpleStreamsDataSource("test storage reader", stor, "images")
 
 	// Find the simplestreams index file.
 	params := simplestreams.ValueParams{

=== modified file 'environs/imagemetadata/urls.go'
--- environs/imagemetadata/urls.go	2014-01-29 06:45:16 +0000
+++ environs/imagemetadata/urls.go	2014-03-04 05:51:00 +0000
@@ -31,7 +31,7 @@
 		if !config.SSLHostnameVerification() {
 			verify = simplestreams.NoVerifySSLHostnames
 		}
-		sources = append(sources, simplestreams.NewURLDataSource(userURL, verify))
+		sources = append(sources, simplestreams.NewURLDataSource("image-metadata-url", userURL, verify))
 	}
 	if custom, ok := env.(SupportsCustomSources); ok {
 		customSources, err := custom.GetImageSources()
@@ -46,7 +46,7 @@
 		return nil, err
 	}
 	if defaultURL != "" {
-		sources = append(sources, simplestreams.NewURLDataSource(defaultURL, simplestreams.VerifySSLHostnames))
+		sources = append(sources, simplestreams.NewURLDataSource("default cloud images", defaultURL, simplestreams.VerifySSLHostnames))
 	}
 	return sources, nil
 }

=== modified file 'environs/imagemetadata/validation.go'
--- environs/imagemetadata/validation.go	2014-01-29 06:45:16 +0000
+++ environs/imagemetadata/validation.go	2014-03-04 05:51:00 +0000
@@ -11,21 +11,21 @@
 
 // ValidateImageMetadata attempts to load image metadata for the specified cloud attributes and stream
 // and returns any image ids found, or an error if the metadata could not be loaded.
-func ValidateImageMetadata(params *simplestreams.MetadataLookupParams) ([]string, error) {
+func ValidateImageMetadata(params *simplestreams.MetadataLookupParams) ([]string, *simplestreams.ResolveInfo, error) {
 	if params.Series == "" {
-		return nil, fmt.Errorf("required parameter series not specified")
+		return nil, nil, fmt.Errorf("required parameter series not specified")
 	}
 	if params.Region == "" {
-		return nil, fmt.Errorf("required parameter region not specified")
+		return nil, nil, fmt.Errorf("required parameter region not specified")
 	}
 	if params.Endpoint == "" {
-		return nil, fmt.Errorf("required parameter endpoint not specified")
+		return nil, nil, fmt.Errorf("required parameter endpoint not specified")
 	}
 	if len(params.Architectures) == 0 {
-		return nil, fmt.Errorf("required parameter arches not specified")
+		return nil, nil, fmt.Errorf("required parameter arches not specified")
 	}
 	if len(params.Sources) == 0 {
-		return nil, fmt.Errorf("required parameter sources not specified")
+		return nil, nil, fmt.Errorf("required parameter sources not specified")
 	}
 	imageConstraint := NewImageConstraint(simplestreams.LookupParams{
 		CloudSpec: simplestreams.CloudSpec{params.Region, params.Endpoint},
@@ -33,16 +33,16 @@
 		Arches:    params.Architectures,
 		Stream:    params.Stream,
 	})
-	matchingImages, err := Fetch(params.Sources, simplestreams.DefaultIndexPath, imageConstraint, false)
+	matchingImages, resolveInfo, err := Fetch(params.Sources, simplestreams.DefaultIndexPath, imageConstraint, false)
 	if err != nil {
-		return nil, err
+		return nil, resolveInfo, err
 	}
 	if len(matchingImages) == 0 {
-		return nil, fmt.Errorf("no matching images found for constraint %+v", imageConstraint)
+		return nil, resolveInfo, fmt.Errorf("no matching images found for constraint %+v", imageConstraint)
 	}
 	image_ids := make([]string, len(matchingImages))
 	for i, im := range matchingImages {
 		image_ids[i] = im.Id
 	}
-	return image_ids, nil
+	return image_ids, resolveInfo, nil
 }

=== modified file 'environs/imagemetadata/validation_test.go'
--- environs/imagemetadata/validation_test.go	2014-01-29 06:45:16 +0000
+++ environs/imagemetadata/validation_test.go	2014-03-04 05:51:00 +0000
@@ -4,6 +4,7 @@
 package imagemetadata_test
 
 import (
+	"path"
 	"path/filepath"
 
 	gc "launchpad.net/gocheck"
@@ -57,11 +58,17 @@
 		Endpoint:      "some-auth-url",
 		Stream:        stream,
 		Sources: []simplestreams.DataSource{
-			simplestreams.NewURLDataSource("file://"+metadataPath, simplestreams.VerifySSLHostnames)},
+			simplestreams.NewURLDataSource("test", "file://"+metadataPath, simplestreams.VerifySSLHostnames)},
 	}
-	imageIds, err := imagemetadata.ValidateImageMetadata(params)
+	imageIds, resolveInfo, err := imagemetadata.ValidateImageMetadata(params)
 	c.Assert(err, gc.IsNil)
 	c.Assert(imageIds, gc.DeepEquals, []string{"1234"})
+	c.Check(resolveInfo, gc.DeepEquals, &simplestreams.ResolveInfo{
+		Source:    "test",
+		Signed:    false,
+		IndexURL:  "file://" + path.Join(metadataPath, "streams/v1/index.json"),
+		MirrorURL: "",
+	})
 }
 
 func (s *ValidateSuite) TestMatch(c *gc.C) {
@@ -79,9 +86,9 @@
 		Endpoint:      "some-auth-url",
 		Stream:        stream,
 		Sources: []simplestreams.DataSource{
-			simplestreams.NewURLDataSource("file://"+s.metadataDir, simplestreams.VerifySSLHostnames)},
+			simplestreams.NewURLDataSource("test", "file://"+s.metadataDir, simplestreams.VerifySSLHostnames)},
 	}
-	_, err := imagemetadata.ValidateImageMetadata(params)
+	_, _, err := imagemetadata.ValidateImageMetadata(params)
 	c.Assert(err, gc.Not(gc.IsNil))
 }
 

=== modified file 'environs/instances/image_test.go'
--- environs/instances/image_test.go	2014-01-29 00:14:51 +0000
+++ environs/instances/image_test.go	2014-03-04 05:51:00 +0000
@@ -240,7 +240,8 @@
 			Stream:    t.stream,
 		})
 		imageMeta, err := imagemetadata.GetLatestImageIdMetadata(
-			[]byte(jsonImagesContent), simplestreams.NewURLDataSource("some-url", simplestreams.VerifySSLHostnames), cons)
+			[]byte(jsonImagesContent),
+			simplestreams.NewURLDataSource("test", "some-url", simplestreams.VerifySSLHostnames), cons)
 		c.Assert(err, gc.IsNil)
 		var images []Image
 		for _, imageMetadata := range imageMeta {

=== modified file 'environs/simplestreams/datasource.go'
--- environs/simplestreams/datasource.go	2013-10-17 22:48:19 +0000
+++ environs/simplestreams/datasource.go	2014-03-04 05:51:00 +0000
@@ -15,6 +15,9 @@
 
 // A DataSource retrieves simplestreams metadata.
 type DataSource interface {
+	// Description describes the origin of this datasource.
+	// eg tools-metadata-url, cloud storage, keystone catalog etc.
+	Description() string
 	// Fetch loads the data at the specified relative path. It returns a reader from which
 	// the data can be retrieved as well as the full URL of the file. The full URL is typically
 	// used in log messages to help diagnose issues accessing the data.
@@ -43,20 +46,27 @@
 
 // A urlDataSource retrieves data from an HTTP URL.
 type urlDataSource struct {
+	description          string
 	baseURL              string
 	hostnameVerification SSLHostnameVerification
 }
 
 // NewURLDataSource returns a new datasource reading from the specified baseURL.
-func NewURLDataSource(baseURL string, verify SSLHostnameVerification) DataSource {
+func NewURLDataSource(description, baseURL string, verify SSLHostnameVerification) DataSource {
 	return &urlDataSource{
+		description:          description,
 		baseURL:              baseURL,
 		hostnameVerification: verify,
 	}
 }
 
+// Description is defined in simplestreams.DataSource.
+func (u *urlDataSource) Description() string {
+	return u.description
+}
+
 func (u *urlDataSource) GoString() string {
-	return fmt.Sprintf("urlDataSource(%q)", u.baseURL)
+	return fmt.Sprintf("%v: urlDataSource(%q)", u.description, u.baseURL)
 }
 
 // urlJoin returns baseURL + relpath making sure to have a '/' inbetween them

=== modified file 'environs/simplestreams/datasource_test.go'
--- environs/simplestreams/datasource_test.go	2013-09-17 09:18:36 +0000
+++ environs/simplestreams/datasource_test.go	2014-03-04 05:51:00 +0000
@@ -24,7 +24,7 @@
 }
 
 func (s *datasourceSuite) TestFetch(c *gc.C) {
-	ds := simplestreams.NewURLDataSource("test:", simplestreams.VerifySSLHostnames)
+	ds := simplestreams.NewURLDataSource("test", "test:", simplestreams.VerifySSLHostnames)
 	rc, url, err := ds.Fetch("streams/v1/tools_metadata.json")
 	c.Assert(err, gc.IsNil)
 	defer rc.Close()
@@ -36,7 +36,7 @@
 }
 
 func (s *datasourceSuite) TestURL(c *gc.C) {
-	ds := simplestreams.NewURLDataSource("foo", simplestreams.VerifySSLHostnames)
+	ds := simplestreams.NewURLDataSource("test", "foo", simplestreams.VerifySSLHostnames)
 	url, err := ds.URL("bar")
 	c.Assert(err, gc.IsNil)
 	c.Assert(url, gc.Equals, "foo/bar")
@@ -64,7 +64,7 @@
 }
 
 func (s *datasourceHTTPSSuite) TestNormalClientFails(c *gc.C) {
-	ds := simplestreams.NewURLDataSource(s.Server.URL, simplestreams.VerifySSLHostnames)
+	ds := simplestreams.NewURLDataSource("test", s.Server.URL, simplestreams.VerifySSLHostnames)
 	url, err := ds.URL("bar")
 	c.Assert(err, gc.IsNil)
 	c.Check(url, gc.Equals, s.Server.URL+"/bar")
@@ -76,7 +76,7 @@
 }
 
 func (s *datasourceHTTPSSuite) TestNonVerifyingClientSucceeds(c *gc.C) {
-	ds := simplestreams.NewURLDataSource(s.Server.URL, simplestreams.NoVerifySSLHostnames)
+	ds := simplestreams.NewURLDataSource("test", s.Server.URL, simplestreams.NoVerifySSLHostnames)
 	url, err := ds.URL("bar")
 	c.Assert(err, gc.IsNil)
 	c.Check(url, gc.Equals, s.Server.URL+"/bar")

=== modified file 'environs/simplestreams/simplestreams.go'
--- environs/simplestreams/simplestreams.go	2014-02-25 04:47:53 +0000
+++ environs/simplestreams/simplestreams.go	2014-03-04 05:51:00 +0000
@@ -30,6 +30,13 @@
 
 var logger = loggo.GetLogger("juju.environs.simplestreams")
 
+type ResolveInfo struct {
+	Source    string `yaml:"source" json:"source"`
+	Signed    bool   `yaml:"signed" json:"signed"`
+	IndexURL  string `yaml:"indexURL" json:"indexURL"`
+	MirrorURL string `yaml:"mirrorURL,omitempty" json:"mirrorURL,omitempty"`
+}
+
 // CloudSpec uniquely defines a specific cloud deployment.
 type CloudSpec struct {
 	Region   string `json:"region"`
@@ -422,12 +429,14 @@
 // GetMetadata returns metadata records matching the specified constraint,looking in each source for signed metadata.
 // If onlySigned is false and no signed metadata is found in a source, the source is used to look for unsigned metadata.
 // Each source is tried in turn until at least one signed (or unsigned) match is found.
-func GetMetadata(sources []DataSource, baseIndexPath string, cons LookupConstraint, onlySigned bool, params ValueParams) (items []interface{}, err error) {
+func GetMetadata(
+	sources []DataSource, baseIndexPath string, cons LookupConstraint, onlySigned bool,
+	params ValueParams) (items []interface{}, resolveInfo *ResolveInfo, err error) {
 	for _, source := range sources {
-		items, err = getMaybeSignedMetadata(source, baseIndexPath, cons, true, params)
+		items, resolveInfo, err = getMaybeSignedMetadata(source, baseIndexPath, cons, true, params)
 		// If no items are found using signed metadata, check unsigned.
 		if err != nil && len(items) == 0 && !onlySigned {
-			items, err = getMaybeSignedMetadata(source, baseIndexPath, cons, false, params)
+			items, resolveInfo, err = getMaybeSignedMetadata(source, baseIndexPath, cons, false, params)
 		}
 		if err == nil {
 			break
@@ -437,11 +446,14 @@
 		// no matching products is an internal error only
 		err = nil
 	}
-	return items, err
+	return items, resolveInfo, err
 }
 
 // getMaybeSignedMetadata returns metadata records matching the specified constraint.
-func getMaybeSignedMetadata(source DataSource, baseIndexPath string, cons LookupConstraint, signed bool, params ValueParams) ([]interface{}, error) {
+func getMaybeSignedMetadata(source DataSource, baseIndexPath string, cons LookupConstraint,
+	signed bool, params ValueParams) ([]interface{}, *ResolveInfo, error) {
+
+	resolveInfo := &ResolveInfo{}
 	indexPath := baseIndexPath + UnsignedSuffix
 	if signed {
 		indexPath = baseIndexPath + signedSuffix
@@ -453,25 +465,31 @@
 		// So the best we can do is use the relative path for the URL when logging messages.
 		indexURL = indexPath
 	}
+	resolveInfo.Source = source.Description()
+	resolveInfo.Signed = signed
+	resolveInfo.IndexURL = indexURL
 	indexRef, err := GetIndexWithFormat(source, indexPath, "index:1.0", signed, cons.Params().CloudSpec, params)
 	if err != nil {
 		if errors.IsNotFoundError(err) || errors.IsUnauthorizedError(err) {
 			logger.Debugf("cannot load index %q: %v", indexURL, err)
 		}
-		return nil, err
+		return nil, resolveInfo, err
 	}
 	logger.Debugf("read metadata index at %q", indexURL)
 	items, err = indexRef.getLatestMetadataWithFormat(cons, "products:1.0", signed)
 	if err != nil {
 		if errors.IsNotFoundError(err) {
 			logger.Debugf("skipping index because of error getting latest metadata %q: %v", indexURL, err)
-			return nil, err
+			return nil, resolveInfo, err
 		}
 		if _, ok := err.(*noMatchingProductsError); ok {
 			logger.Debugf("%v", err)
 		}
 	}
-	return items, err
+	if indexRef.Source.Description() == "mirror" {
+		resolveInfo.MirrorURL = indexRef.Source.(*urlDataSource).baseURL
+	}
+	return items, resolveInfo, err
 }
 
 // fetchData gets all the data from the given source located at the specified path.
@@ -534,7 +552,7 @@
 			source, mirrors, params.DataType, params.MirrorContentId, cloudSpec, requireSigned, params.PublicKey)
 		if err == nil {
 			logger.Debugf("using mirrored products path: %s", path.Join(mirrorInfo.MirrorURL, mirrorInfo.Path))
-			indexRef.Source = NewURLDataSource(mirrorInfo.MirrorURL, VerifySSLHostnames)
+			indexRef.Source = NewURLDataSource("mirror", mirrorInfo.MirrorURL, VerifySSLHostnames)
 			indexRef.MirroredProductsPath = mirrorInfo.Path
 		} else {
 			logger.Debugf("no mirror information available for %s: %v", cloudSpec, err)

=== modified file 'environs/simplestreams/simplestreams_test.go'
--- environs/simplestreams/simplestreams_test.go	2014-02-11 03:40:13 +0000
+++ environs/simplestreams/simplestreams_test.go	2014-03-04 05:51:00 +0000
@@ -27,7 +27,7 @@
 func registerSimpleStreamsTests() {
 	gc.Suite(&simplestreamsSuite{
 		LocalLiveSimplestreamsSuite: sstesting.LocalLiveSimplestreamsSuite{
-			Source:        simplestreams.NewURLDataSource("test:", simplestreams.VerifySSLHostnames),
+			Source:        simplestreams.NewURLDataSource("test", "test:", simplestreams.VerifySSLHostnames),
 			RequireSigned: false,
 			DataType:      "image-ids",
 			ValidConstraint: sstesting.NewTestConstraint(simplestreams.LookupParams{
@@ -316,7 +316,7 @@
 func (s *simplestreamsSuite) TestGetMetadataNoMatching(c *gc.C) {
 	source := &countingSource{
 		DataSource: simplestreams.NewURLDataSource(
-			"test:/daily", simplestreams.VerifySSLHostnames,
+			"test", "test:/daily", simplestreams.VerifySSLHostnames,
 		),
 	}
 	sources := []simplestreams.DataSource{source, source, source}
@@ -330,7 +330,7 @@
 		Arches: []string{"not-a-real-arch"}, // never matches
 	})
 
-	items, err := simplestreams.GetMetadata(
+	items, resolveInfo, err := simplestreams.GetMetadata(
 		sources,
 		simplestreams.DefaultIndexPath,
 		constraint,
@@ -339,6 +339,12 @@
 	)
 	c.Assert(err, gc.IsNil)
 	c.Assert(items, gc.HasLen, 0)
+	c.Assert(resolveInfo, gc.DeepEquals, &simplestreams.ResolveInfo{
+		Source:    "test",
+		Signed:    false,
+		IndexURL:  "test:/daily/streams/v1/index.json",
+		MirrorURL: "",
+	})
 
 	// There should be 2 calls to each data-source:
 	// one for .sjson, one for .json.

=== modified file 'environs/storage/storage.go'
--- environs/storage/storage.go	2014-01-09 05:27:24 +0000
+++ environs/storage/storage.go	2014-03-04 05:51:00 +0000
@@ -72,9 +72,10 @@
 
 // A storageSimpleStreamsDataSource retrieves data from a StorageReader.
 type storageSimpleStreamsDataSource struct {
-	basePath   string
-	storage    StorageReader
-	allowRetry bool
+	description string
+	basePath    string
+	storage     StorageReader
+	allowRetry  bool
 }
 
 // TestingGetAllowRetry is used in tests which need to see if allowRetry has been
@@ -87,8 +88,8 @@
 }
 
 // NewStorageSimpleStreamsDataSource returns a new datasource reading from the specified storage.
-func NewStorageSimpleStreamsDataSource(storage StorageReader, basePath string) simplestreams.DataSource {
-	return &storageSimpleStreamsDataSource{basePath, storage, false}
+func NewStorageSimpleStreamsDataSource(description string, storage StorageReader, basePath string) simplestreams.DataSource {
+	return &storageSimpleStreamsDataSource{description, basePath, storage, false}
 }
 
 func (s *storageSimpleStreamsDataSource) relpath(storagePath string) string {
@@ -99,6 +100,11 @@
 	return relpath
 }
 
+// Description is defined in simplestreams.DataSource.
+func (s *storageSimpleStreamsDataSource) Description() string {
+	return s.description
+}
+
 // Fetch is defined in simplestreams.DataSource.
 func (s *storageSimpleStreamsDataSource) Fetch(path string) (io.ReadCloser, string, error) {
 	relpath := s.relpath(path)

=== modified file 'environs/storage/storage_test.go'
--- environs/storage/storage_test.go	2014-02-13 02:46:58 +0000
+++ environs/storage/storage_test.go	2014-03-04 05:51:00 +0000
@@ -57,7 +57,7 @@
 func (s *datasourceSuite) TestFetch(c *gc.C) {
 	sampleData := "hello world"
 	s.stor.Put("foo/bar/data.txt", bytes.NewReader([]byte(sampleData)), int64(len(sampleData)))
-	ds := storage.NewStorageSimpleStreamsDataSource(s.stor, "")
+	ds := storage.NewStorageSimpleStreamsDataSource("test datasource", s.stor, "")
 	rc, url, err := ds.Fetch("foo/bar/data.txt")
 	c.Assert(err, gc.IsNil)
 	defer rc.Close()
@@ -69,7 +69,7 @@
 func (s *datasourceSuite) TestFetchWithBasePath(c *gc.C) {
 	sampleData := "hello world"
 	s.stor.Put("base/foo/bar/data.txt", bytes.NewReader([]byte(sampleData)), int64(len(sampleData)))
-	ds := storage.NewStorageSimpleStreamsDataSource(s.stor, "base")
+	ds := storage.NewStorageSimpleStreamsDataSource("test datasource", s.stor, "base")
 	rc, url, err := ds.Fetch("foo/bar/data.txt")
 	c.Assert(err, gc.IsNil)
 	defer rc.Close()
@@ -80,7 +80,7 @@
 
 func (s *datasourceSuite) TestFetchWithRetry(c *gc.C) {
 	stor := &fakeStorage{shouldRetry: true}
-	ds := storage.NewStorageSimpleStreamsDataSource(stor, "base")
+	ds := storage.NewStorageSimpleStreamsDataSource("test datasource", stor, "base")
 	ds.SetAllowRetry(true)
 	_, _, err := ds.Fetch("foo/bar/data.txt")
 	c.Assert(err, gc.ErrorMatches, "an error")
@@ -92,7 +92,7 @@
 	// NB shouldRetry below is true indicating the fake storage is capable of
 	// retrying, not that it will retry.
 	stor := &fakeStorage{shouldRetry: true}
-	ds := storage.NewStorageSimpleStreamsDataSource(stor, "base")
+	ds := storage.NewStorageSimpleStreamsDataSource("test datasource", stor, "base")
 	_, _, err := ds.Fetch("foo/bar/data.txt")
 	c.Assert(err, gc.ErrorMatches, "an error")
 	c.Assert(stor.getName, gc.Equals, "base/foo/bar/data.txt")
@@ -102,7 +102,7 @@
 func (s *datasourceSuite) TestURL(c *gc.C) {
 	sampleData := "hello world"
 	s.stor.Put("bar/data.txt", bytes.NewReader([]byte(sampleData)), int64(len(sampleData)))
-	ds := storage.NewStorageSimpleStreamsDataSource(s.stor, "")
+	ds := storage.NewStorageSimpleStreamsDataSource("test datasource", s.stor, "")
 	url, err := ds.URL("bar")
 	c.Assert(err, gc.IsNil)
 	expectedURL, _ := s.stor.URL("bar")
@@ -112,7 +112,7 @@
 func (s *datasourceSuite) TestURLWithBasePath(c *gc.C) {
 	sampleData := "hello world"
 	s.stor.Put("base/bar/data.txt", bytes.NewReader([]byte(sampleData)), int64(len(sampleData)))
-	ds := storage.NewStorageSimpleStreamsDataSource(s.stor, "base")
+	ds := storage.NewStorageSimpleStreamsDataSource("test datasource", s.stor, "base")
 	url, err := ds.URL("bar")
 	c.Assert(err, gc.IsNil)
 	expectedURL, _ := s.stor.URL("base/bar")

=== modified file 'environs/sync/sync.go'
--- environs/sync/sync.go	2014-01-30 14:11:27 +0000
+++ environs/sync/sync.go	2014-03-04 05:51:00 +0000
@@ -140,7 +140,7 @@
 		return nil, err
 	}
 	logger.Infof("using sync tools source: %v", sourceURL)
-	return simplestreams.NewURLDataSource(sourceURL, simplestreams.VerifySSLHostnames), nil
+	return simplestreams.NewURLDataSource("sync tools source", sourceURL, simplestreams.VerifySSLHostnames), nil
 }
 
 // copyTools copies a set of tools from the source to the target.

=== removed file 'environs/tools/boilerplate.go'
--- environs/tools/boilerplate.go	2014-01-22 22:48:54 +0000
+++ environs/tools/boilerplate.go	1970-01-01 00:00:00 +0000
@@ -1,153 +0,0 @@
-// Copyright 2013 Canonical Ltd.
-// Licensed under the AGPLv3, see LICENCE file for details.
-
-package tools
-
-import (
-	"bytes"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"text/template"
-	"time"
-
-	"launchpad.net/juju-core/environs/simplestreams"
-	"launchpad.net/juju-core/juju/osenv"
-)
-
-const (
-	defaultIndexFileName = "index.json"
-	defaultToolsFileName = "toolsmetadata.json"
-	streamsDir           = "streams/v1"
-)
-
-// Boilerplate generates some basic simplestreams metadata using the specified cloud and tools details.
-func Boilerplate(tm *ToolsMetadata, cloudSpec *simplestreams.CloudSpec) ([]string, error) {
-	return MakeBoilerplate(tm, cloudSpec, true)
-}
-
-// MakeBoilerplate exists so it can be called by tests. See Boilerplate above. It provides an option to retain
-// the streams directories when writing the generated metadata files.
-func MakeBoilerplate(tm *ToolsMetadata, cloudSpec *simplestreams.CloudSpec, flattenPath bool) ([]string, error) {
-	indexFileName := defaultIndexFileName
-	toolsFileName := defaultToolsFileName
-	now := time.Now()
-	imparams := toolsMetadataParams{
-		ToolsBinarySize:   tm.Size,
-		ToolsBinaryPath:   tm.Path,
-		ToolsBinarySHA256: tm.SHA256,
-		Version:           tm.Version,
-		Arch:              tm.Arch,
-		Series:            tm.Release,
-		Region:            cloudSpec.Region,
-		URL:               cloudSpec.Endpoint,
-		Path:              streamsDir,
-		ToolsFileName:     toolsFileName,
-		Updated:           now.Format(time.RFC1123Z),
-		VersionKey:        now.Format("20060102"),
-	}
-
-	var err error
-	imparams.SeriesVersion, err = simplestreams.SeriesVersion(tm.Release)
-	if err != nil {
-		return nil, fmt.Errorf("invalid series %q", tm.Release)
-	}
-
-	if !flattenPath {
-		streamsPath := osenv.JujuHomePath(streamsDir)
-		if err := os.MkdirAll(streamsPath, 0755); err != nil {
-			return nil, err
-		}
-		indexFileName = filepath.Join(streamsDir, indexFileName)
-		toolsFileName = filepath.Join(streamsDir, toolsFileName)
-	}
-	err = writeJsonFile(imparams, indexFileName, indexBoilerplate)
-	if err != nil {
-		return nil, err
-	}
-	err = writeJsonFile(imparams, toolsFileName, productBoilerplate)
-	if err != nil {
-		return nil, err
-	}
-	return []string{indexFileName, toolsFileName}, nil
-}
-
-type toolsMetadataParams struct {
-	ToolsBinaryPath   string
-	ToolsBinarySize   int64
-	ToolsBinarySHA256 string
-	Region            string
-	URL               string
-	Updated           string
-	Arch              string
-	Path              string
-	Series            string
-	SeriesVersion     string
-	Version           string
-	VersionKey        string
-	ToolsFileName     string
-}
-
-func writeJsonFile(imparams toolsMetadataParams, filename, boilerplate string) error {
-	t := template.Must(template.New("").Parse(boilerplate))
-	var metadata bytes.Buffer
-	if err := t.Execute(&metadata, imparams); err != nil {
-		panic(fmt.Errorf("cannot generate %s metdata: %v", filename, err))
-	}
-	data := metadata.Bytes()
-	path := osenv.JujuHomePath(filename)
-	if err := ioutil.WriteFile(path, data, 0666); err != nil {
-		return err
-	}
-	return nil
-}
-
-var indexBoilerplate = `
-{
- "index": {
-   "com.ubuntu.juju:custom": {
-     "updated": "{{.Updated}}",
-     "cloudname": "custom",
-     "datatype": "content-download",
-     "format": "products:1.0",
-     "products": [
-       "com.ubuntu.juju:{{.SeriesVersion}}:{{.Arch}}"
-     ],
-     "path": "{{.Path}}/{{.ToolsFileName}}"
-   }
- },
- "updated": "{{.Updated}}",
- "format": "index:1.0"
-}
-`
-
-var productBoilerplate = `
-{
-  "content_id": "com.ubuntu.juju:custom",
-  "format": "products:1.0",
-  "updated": "{{.Updated}}",
-  "datatype": "content-download",
-  "products": {
-    "com.ubuntu.juju:{{.SeriesVersion}}:{{.Arch}}": {
-      "release": "{{.Series}}",
-      "arch": "{{.Arch}}",
-      "versions": {
-        "{{.VersionKey}}": {
-          "items": {
-            "{{.Series}}{{.Version}}": {
-              "version": "{{.Version}}",
-              "size": {{.ToolsBinarySize}},
-              "path": "{{.ToolsBinaryPath}}",
-              "ftype": "tar.gz",
-              "sha256": "{{.ToolsBinarySHA256}}"
-            }
-          },
-          "pubname": "juju-{{.Series}}-{{.Arch}}-{{.VersionKey}}",
-          "label": "custom"
-        }
-      }
-    }
-  }
-}
-`

=== modified file 'environs/tools/simplestreams.go'
--- environs/tools/simplestreams.go	2014-01-30 06:21:03 +0000
+++ environs/tools/simplestreams.go	2014-03-04 05:51:00 +0000
@@ -102,9 +102,8 @@
 }
 
 // NewVersionedToolsConstraint returns a ToolsConstraint for a tools with a specific version.
-func NewVersionedToolsConstraint(vers string, params simplestreams.LookupParams) *ToolsConstraint {
-	versNum := version.MustParse(vers)
-	return &ToolsConstraint{LookupParams: params, Version: versNum}
+func NewVersionedToolsConstraint(vers version.Number, params simplestreams.LookupParams) *ToolsConstraint {
+	return &ToolsConstraint{LookupParams: params, Version: vers}
 }
 
 // NewGeneralToolsConstraint returns a ToolsConstraint for tools with matching major/minor version numbers.
@@ -168,7 +167,10 @@
 // The base URL locations are as specified - the first location which has a file is the one used.
 // Signed data is preferred, but if there is no signed data available and onlySigned is false,
 // then unsigned data is used.
-func Fetch(sources []simplestreams.DataSource, indexPath string, cons *ToolsConstraint, onlySigned bool) ([]*ToolsMetadata, error) {
+func Fetch(
+	sources []simplestreams.DataSource, indexPath string, cons *ToolsConstraint,
+	onlySigned bool) ([]*ToolsMetadata, *simplestreams.ResolveInfo, error) {
+
 	params := simplestreams.ValueParams{
 		DataType:        ContentDownload,
 		FilterFunc:      appendMatchingTools,
@@ -176,15 +178,15 @@
 		ValueTemplate:   ToolsMetadata{},
 		PublicKey:       simplestreamsToolsPublicKey,
 	}
-	items, err := simplestreams.GetMetadata(sources, indexPath, cons, onlySigned, params)
+	items, resolveInfo, err := simplestreams.GetMetadata(sources, indexPath, cons, onlySigned, params)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	metadata := make([]*ToolsMetadata, len(items))
 	for i, md := range items {
 		metadata[i] = md.(*ToolsMetadata)
 	}
-	return metadata, nil
+	return metadata, resolveInfo, nil
 }
 
 // appendMatchingTools updates matchingTools with tools metadata records from tools which belong to the
@@ -311,12 +313,13 @@
 
 // ReadMetadata returns the tools metadata from the given storage.
 func ReadMetadata(store storage.StorageReader) ([]*ToolsMetadata, error) {
-	dataSource := storage.NewStorageSimpleStreamsDataSource(store, storage.BaseToolsPath)
+	dataSource := storage.NewStorageSimpleStreamsDataSource("existing metadata", store, storage.BaseToolsPath)
 	toolsConstraint, err := makeToolsConstraint(simplestreams.CloudSpec{}, -1, -1, coretools.Filter{})
 	if err != nil {
 		return nil, err
 	}
-	metadata, err := Fetch([]simplestreams.DataSource{dataSource}, simplestreams.DefaultIndexPath, toolsConstraint, false)
+	metadata, _, err := Fetch(
+		[]simplestreams.DataSource{dataSource}, simplestreams.DefaultIndexPath, toolsConstraint, false)
 	if err != nil && !errors.IsNotFoundError(err) {
 		return nil, err
 	}

=== modified file 'environs/tools/simplestreams_test.go'
--- environs/tools/simplestreams_test.go	2014-01-30 06:21:03 +0000
+++ environs/tools/simplestreams_test.go	2014-03-04 05:51:00 +0000
@@ -62,7 +62,7 @@
 			t.Fatalf("Unknown vendor %s. Must be one of %s", *vendor, keys)
 		}
 		registerLiveSimpleStreamsTests(testData.baseURL,
-			tools.NewVersionedToolsConstraint("1.13.0", simplestreams.LookupParams{
+			tools.NewVersionedToolsConstraint(version.MustParse("1.13.0"), simplestreams.LookupParams{
 				CloudSpec: testData.validCloudSpec,
 				Series:    []string{version.Current.Series},
 				Arches:    []string{"amd64"},
@@ -74,10 +74,10 @@
 func registerSimpleStreamsTests() {
 	gc.Suite(&simplestreamsSuite{
 		LocalLiveSimplestreamsSuite: sstesting.LocalLiveSimplestreamsSuite{
-			Source:        simplestreams.NewURLDataSource("test:", simplestreams.VerifySSLHostnames),
+			Source:        simplestreams.NewURLDataSource("test", "test:", simplestreams.VerifySSLHostnames),
 			RequireSigned: false,
 			DataType:      tools.ContentDownload,
-			ValidConstraint: tools.NewVersionedToolsConstraint("1.13.0", simplestreams.LookupParams{
+			ValidConstraint: tools.NewVersionedToolsConstraint(version.MustParse("1.13.0"), simplestreams.LookupParams{
 				CloudSpec: simplestreams.CloudSpec{
 					Region:   "us-east-1",
 					Endpoint: "https://ec2.us-east-1.amazonaws.com",
@@ -92,7 +92,7 @@
 
 func registerLiveSimpleStreamsTests(baseURL string, validToolsConstraint simplestreams.LookupConstraint, requireSigned bool) {
 	gc.Suite(&sstesting.LocalLiveSimplestreamsSuite{
-		Source:          simplestreams.NewURLDataSource(baseURL, simplestreams.VerifySSLHostnames),
+		Source:          simplestreams.NewURLDataSource("test", baseURL, simplestreams.VerifySSLHostnames),
 		RequireSigned:   requireSigned,
 		DataType:        tools.ContentDownload,
 		ValidConstraint: validToolsConstraint,
@@ -238,14 +238,18 @@
 				Arches:    t.arches,
 			})
 		} else {
-			toolsConstraint = tools.NewVersionedToolsConstraint(t.version, simplestreams.LookupParams{
-				CloudSpec: simplestreams.CloudSpec{"us-east-1", "https://ec2.us-east-1.amazonaws.com"},
-				Series:    []string{t.series},
-				Arches:    t.arches,
-			})
+			toolsConstraint = tools.NewVersionedToolsConstraint(version.MustParse(t.version),
+				simplestreams.LookupParams{
+					CloudSpec: simplestreams.CloudSpec{"us-east-1", "https://ec2.us-east-1.amazonaws.com"},
+					Series:    []string{t.series},
+					Arches:    t.arches,
+				})
 		}
-		tools, err := tools.Fetch(
-			[]simplestreams.DataSource{s.Source}, simplestreams.DefaultIndexPath, toolsConstraint, s.RequireSigned)
+		// Add invalid datasource and check later that resolveInfo is correct.
+		invalidSource := simplestreams.NewURLDataSource("invalid", "file://invalid", simplestreams.VerifySSLHostnames)
+		tools, resolveInfo, err := tools.Fetch(
+			[]simplestreams.DataSource{invalidSource, s.Source},
+			simplestreams.DefaultIndexPath, toolsConstraint, s.RequireSigned)
 		if !c.Check(err, gc.IsNil) {
 			continue
 		}
@@ -254,6 +258,12 @@
 			c.Assert(err, gc.IsNil)
 		}
 		c.Check(tools, gc.DeepEquals, t.tools)
+		c.Check(resolveInfo, gc.DeepEquals, &simplestreams.ResolveInfo{
+			Source:    "test",
+			Signed:    s.RequireSigned,
+			IndexURL:  "test:/streams/v1/index.json",
+			MirrorURL: "",
+		})
 	}
 }
 
@@ -263,7 +273,7 @@
 		Series:    []string{"precise"},
 		Arches:    []string{"amd64"},
 	})
-	toolsMetadata, err := tools.Fetch(
+	toolsMetadata, resolveInfo, err := tools.Fetch(
 		[]simplestreams.DataSource{s.Source}, simplestreams.DefaultIndexPath, toolsConstraint, s.RequireSigned)
 	c.Assert(err, gc.IsNil)
 	c.Assert(len(toolsMetadata), gc.Equals, 1)
@@ -280,6 +290,12 @@
 	}
 	c.Assert(err, gc.IsNil)
 	c.Assert(toolsMetadata[0], gc.DeepEquals, expectedMetadata)
+	c.Assert(resolveInfo, gc.DeepEquals, &simplestreams.ResolveInfo{
+		Source:    "test",
+		Signed:    s.RequireSigned,
+		IndexURL:  "test:/streams/v1/index.json",
+		MirrorURL: "test:/",
+	})
 }
 
 func assertMetadataMatches(c *gc.C, storageDir string, toolList coretools.List, metadata []*tools.ToolsMetadata) {
@@ -396,7 +412,7 @@
 var _ = gc.Suite(&productSpecSuite{})
 
 func (s *productSpecSuite) TestId(c *gc.C) {
-	toolsConstraint := tools.NewVersionedToolsConstraint("1.13.0", simplestreams.LookupParams{
+	toolsConstraint := tools.NewVersionedToolsConstraint(version.MustParse("1.13.0"), simplestreams.LookupParams{
 		Series: []string{"precise"},
 		Arches: []string{"amd64"},
 	})
@@ -406,7 +422,7 @@
 }
 
 func (s *productSpecSuite) TestIdMultiArch(c *gc.C) {
-	toolsConstraint := tools.NewVersionedToolsConstraint("1.11.3", simplestreams.LookupParams{
+	toolsConstraint := tools.NewVersionedToolsConstraint(version.MustParse("1.11.3"), simplestreams.LookupParams{
 		Series: []string{"precise"},
 		Arches: []string{"amd64", "arm"},
 	})
@@ -418,7 +434,7 @@
 }
 
 func (s *productSpecSuite) TestIdMultiSeries(c *gc.C) {
-	toolsConstraint := tools.NewVersionedToolsConstraint("1.11.3", simplestreams.LookupParams{
+	toolsConstraint := tools.NewVersionedToolsConstraint(version.MustParse("1.11.3"), simplestreams.LookupParams{
 		Series: []string{"precise", "raring"},
 		Arches: []string{"amd64"},
 	})
@@ -752,17 +768,23 @@
 }
 
 func (s *signedSuite) TestSignedToolsMetadata(c *gc.C) {
-	signedSource := simplestreams.NewURLDataSource("signedtest://host/signed", simplestreams.VerifySSLHostnames)
-	toolsConstraint := tools.NewVersionedToolsConstraint("1.13.0", simplestreams.LookupParams{
+	signedSource := simplestreams.NewURLDataSource("test", "signedtest://host/signed", simplestreams.VerifySSLHostnames)
+	toolsConstraint := tools.NewVersionedToolsConstraint(version.MustParse("1.13.0"), simplestreams.LookupParams{
 		CloudSpec: simplestreams.CloudSpec{"us-east-1", "https://ec2.us-east-1.amazonaws.com"},
 		Series:    []string{"precise"},
 		Arches:    []string{"amd64"},
 	})
-	toolsMetadata, err := tools.Fetch(
+	toolsMetadata, resolveInfo, err := tools.Fetch(
 		[]simplestreams.DataSource{signedSource}, simplestreams.DefaultIndexPath, toolsConstraint, true)
 	c.Assert(err, gc.IsNil)
 	c.Assert(len(toolsMetadata), gc.Equals, 1)
 	c.Assert(toolsMetadata[0].Path, gc.Equals, "tools/releases/20130806/juju-1.13.1-precise-amd64.tgz")
+	c.Assert(resolveInfo, gc.DeepEquals, &simplestreams.ResolveInfo{
+		Source:    "test",
+		Signed:    true,
+		IndexURL:  "signedtest://host/signed/streams/v1/index.sjson",
+		MirrorURL: "",
+	})
 }
 
 var unsignedIndex = `

=== modified file 'environs/tools/testing/testing.go'
--- environs/tools/testing/testing.go	2014-01-30 14:11:27 +0000
+++ environs/tools/testing/testing.go	2014-03-04 05:51:00 +0000
@@ -83,7 +83,7 @@
 
 // ParseMetadataFromStorage loads ToolsMetadata from the specified storage reader.
 func ParseMetadataFromStorage(c *gc.C, stor storage.StorageReader, expectMirrors bool) []*tools.ToolsMetadata {
-	source := storage.NewStorageSimpleStreamsDataSource(stor, "tools")
+	source := storage.NewStorageSimpleStreamsDataSource("test storage reader", stor, "tools")
 	params := simplestreams.ValueParams{
 		DataType:      tools.ContentDownload,
 		ValueTemplate: tools.ToolsMetadata{},

=== modified file 'environs/tools/tools.go'
--- environs/tools/tools.go	2014-02-28 03:05:47 +0000
+++ environs/tools/tools.go	2014-03-04 05:51:00 +0000
@@ -32,7 +32,7 @@
 		if majorMismatch || minorMismacth {
 			return nil, coretools.ErrNoMatches
 		}
-		toolsConstraint = NewVersionedToolsConstraint(filter.Number.String(),
+		toolsConstraint = NewVersionedToolsConstraint(filter.Number,
 			simplestreams.LookupParams{CloudSpec: cloudSpec})
 	} else {
 		toolsConstraint = NewGeneralToolsConstraint(majorVersion, minorVersion, filter.Released,
@@ -117,7 +117,7 @@
 	if err != nil {
 		return nil, err
 	}
-	toolsMetadata, err := Fetch(sources, simplestreams.DefaultIndexPath, toolsConstraint, false)
+	toolsMetadata, _, err := Fetch(sources, simplestreams.DefaultIndexPath, toolsConstraint, false)
 	if err != nil {
 		if errors.IsNotFoundError(err) {
 			err = ErrNoTools

=== modified file 'environs/tools/urls.go'
--- environs/tools/urls.go	2014-01-20 23:32:00 +0000
+++ environs/tools/urls.go	2014-03-04 05:51:00 +0000
@@ -39,7 +39,7 @@
 		if !config.SSLHostnameVerification() {
 			verify = simplestreams.NoVerifySSLHostnames
 		}
-		sources = append(sources, simplestreams.NewURLDataSource(userURL, verify))
+		sources = append(sources, simplestreams.NewURLDataSource("tools-metadata-url", userURL, verify))
 	}
 	if custom, ok := env.(SupportsCustomSources); ok {
 		customSources, err := custom.GetToolsSources()
@@ -54,7 +54,7 @@
 		return nil, err
 	}
 	if defaultURL != "" {
-		sources = append(sources, simplestreams.NewURLDataSource(defaultURL, simplestreams.VerifySSLHostnames))
+		sources = append(sources, simplestreams.NewURLDataSource("default simplestreams", defaultURL, simplestreams.VerifySSLHostnames))
 	}
 	for _, source := range sources {
 		source.SetAllowRetry(allowRetry)

=== modified file 'environs/tools/validation.go'
--- environs/tools/validation.go	2013-09-20 18:46:47 +0000
+++ environs/tools/validation.go	2014-03-04 05:51:00 +0000
@@ -20,12 +20,12 @@
 
 // ValidateToolsMetadata attempts to load tools metadata for the specified cloud attributes and returns
 // any tools versions found, or an error if the metadata could not be loaded.
-func ValidateToolsMetadata(params *ToolsMetadataLookupParams) ([]string, error) {
+func ValidateToolsMetadata(params *ToolsMetadataLookupParams) ([]string, *simplestreams.ResolveInfo, error) {
 	if len(params.Architectures) == 0 {
-		return nil, fmt.Errorf("required parameter arches not specified")
+		return nil, nil, fmt.Errorf("required parameter arches not specified")
 	}
 	if len(params.Sources) == 0 {
-		return nil, fmt.Errorf("required parameter sources not specified")
+		return nil, nil, fmt.Errorf("required parameter sources not specified")
 	}
 	if params.Version == "" && params.Major == 0 {
 		params.Version = version.Current.Number.String()
@@ -38,23 +38,27 @@
 			Arches:    params.Architectures,
 		})
 	} else {
-		toolsConstraint = NewVersionedToolsConstraint(params.Version, simplestreams.LookupParams{
+		versNum, err := version.Parse(params.Version)
+		if err != nil {
+			return nil, nil, err
+		}
+		toolsConstraint = NewVersionedToolsConstraint(versNum, simplestreams.LookupParams{
 			CloudSpec: simplestreams.CloudSpec{params.Region, params.Endpoint},
 			Series:    []string{params.Series},
 			Arches:    params.Architectures,
 		})
 	}
-	matchingTools, err := Fetch(params.Sources, simplestreams.DefaultIndexPath, toolsConstraint, false)
+	matchingTools, resolveInfo, err := Fetch(params.Sources, simplestreams.DefaultIndexPath, toolsConstraint, false)
 	if err != nil {
-		return nil, err
+		return nil, resolveInfo, err
 	}
 	if len(matchingTools) == 0 {
-		return nil, fmt.Errorf("no matching tools found for constraint %+v", toolsConstraint)
+		return nil, resolveInfo, fmt.Errorf("no matching tools found for constraint %+v", toolsConstraint)
 	}
 	versions := make([]string, len(matchingTools))
 	for i, tm := range matchingTools {
 		vers := version.Binary{version.MustParse(tm.Version), tm.Release, tm.Arch}
 		versions[i] = vers.String()
 	}
-	return versions, nil
+	return versions, resolveInfo, nil
 }

=== modified file 'environs/tools/validation_test.go'
--- environs/tools/validation_test.go	2014-01-22 22:48:54 +0000
+++ environs/tools/validation_test.go	2014-03-04 05:51:00 +0000
@@ -4,23 +4,24 @@
 package tools
 
 import (
+	"path"
+
 	gc "launchpad.net/gocheck"
 
+	"launchpad.net/juju-core/environs/filestorage"
 	"launchpad.net/juju-core/environs/simplestreams"
-	"launchpad.net/juju-core/juju/osenv"
-	coretesting "launchpad.net/juju-core/testing"
 	"launchpad.net/juju-core/testing/testbase"
 )
 
 type ValidateSuite struct {
 	testbase.LoggingSuite
-	home *coretesting.FakeHome
+	metadataDir string
 }
 
 var _ = gc.Suite(&ValidateSuite{})
 
-func (s *ValidateSuite) makeLocalMetadata(c *gc.C, version, region, series, endpoint string) error {
-	tm := ToolsMetadata{
+func (s *ValidateSuite) makeLocalMetadata(c *gc.C, version, series string) error {
+	tm := []*ToolsMetadata{{
 		Version:  version,
 		Release:  series,
 		Arch:     "amd64",
@@ -28,31 +29,26 @@
 		Size:     1234,
 		FileType: "tar.gz",
 		SHA256:   "f65a92b3b41311bdf398663ee1c5cd0c",
-	}
-	cloudSpec := simplestreams.CloudSpec{
-		Region:   region,
-		Endpoint: endpoint,
-	}
-	_, err := MakeBoilerplate(&tm, &cloudSpec, false)
-	if err != nil {
-		return err
-	}
+	}}
+
+	stor, err := filestorage.NewFileStorageWriter(s.metadataDir, filestorage.UseDefaultTmpDir)
+	c.Assert(err, gc.IsNil)
+	err = WriteMetadata(stor, tm, false)
+	c.Assert(err, gc.IsNil)
 	return nil
 }
 
 func (s *ValidateSuite) SetUpTest(c *gc.C) {
 	s.LoggingSuite.SetUpTest(c)
-	s.home = coretesting.MakeEmptyFakeHome(c)
+	s.metadataDir = c.MkDir()
 }
 
-func (s *ValidateSuite) TearDownTest(c *gc.C) {
-	s.home.Restore()
-	s.LoggingSuite.TearDownTest(c)
+func (s *ValidateSuite) toolsURL() string {
+	return "file://" + path.Join(s.metadataDir, "tools")
 }
 
 func (s *ValidateSuite) TestExactVersionMatch(c *gc.C) {
-	s.makeLocalMetadata(c, "1.11.2", "region-2", "raring", "some-auth-url")
-	metadataDir := osenv.JujuHomePath("")
+	s.makeLocalMetadata(c, "1.11.2", "raring")
 	params := &ToolsMetadataLookupParams{
 		Version: "1.11.2",
 		MetadataLookupParams: simplestreams.MetadataLookupParams{
@@ -60,17 +56,23 @@
 			Series:        "raring",
 			Architectures: []string{"amd64"},
 			Endpoint:      "some-auth-url",
-			Sources:       []simplestreams.DataSource{simplestreams.NewURLDataSource("file://"+metadataDir, simplestreams.VerifySSLHostnames)},
+			Sources: []simplestreams.DataSource{
+				simplestreams.NewURLDataSource("test", s.toolsURL(), simplestreams.VerifySSLHostnames)},
 		},
 	}
-	versions, err := ValidateToolsMetadata(params)
+	versions, resolveInfo, err := ValidateToolsMetadata(params)
 	c.Assert(err, gc.IsNil)
 	c.Assert(versions, gc.DeepEquals, []string{"1.11.2-raring-amd64"})
+	c.Check(resolveInfo, gc.DeepEquals, &simplestreams.ResolveInfo{
+		Source:    "test",
+		Signed:    false,
+		IndexURL:  "file://" + path.Join(s.metadataDir, "tools/streams/v1/index.json"),
+		MirrorURL: "",
+	})
 }
 
 func (s *ValidateSuite) TestMajorVersionMatch(c *gc.C) {
-	s.makeLocalMetadata(c, "1.11.2", "region-2", "raring", "some-auth-url")
-	metadataDir := osenv.JujuHomePath("")
+	s.makeLocalMetadata(c, "1.11.2", "raring")
 	params := &ToolsMetadataLookupParams{
 		Major: 1,
 		Minor: -1,
@@ -79,17 +81,23 @@
 			Series:        "raring",
 			Architectures: []string{"amd64"},
 			Endpoint:      "some-auth-url",
-			Sources:       []simplestreams.DataSource{simplestreams.NewURLDataSource("file://"+metadataDir, simplestreams.VerifySSLHostnames)},
+			Sources: []simplestreams.DataSource{
+				simplestreams.NewURLDataSource("test", s.toolsURL(), simplestreams.VerifySSLHostnames)},
 		},
 	}
-	versions, err := ValidateToolsMetadata(params)
+	versions, resolveInfo, err := ValidateToolsMetadata(params)
 	c.Assert(err, gc.IsNil)
 	c.Assert(versions, gc.DeepEquals, []string{"1.11.2-raring-amd64"})
+	c.Check(resolveInfo, gc.DeepEquals, &simplestreams.ResolveInfo{
+		Source:    "test",
+		Signed:    false,
+		IndexURL:  "file://" + path.Join(s.metadataDir, "tools/streams/v1/index.json"),
+		MirrorURL: "",
+	})
 }
 
 func (s *ValidateSuite) TestMajorMinorVersionMatch(c *gc.C) {
-	s.makeLocalMetadata(c, "1.11.2", "region-2", "raring", "some-auth-url")
-	metadataDir := osenv.JujuHomePath("")
+	s.makeLocalMetadata(c, "1.11.2", "raring")
 	params := &ToolsMetadataLookupParams{
 		Major: 1,
 		Minor: 11,
@@ -98,17 +106,23 @@
 			Series:        "raring",
 			Architectures: []string{"amd64"},
 			Endpoint:      "some-auth-url",
-			Sources:       []simplestreams.DataSource{simplestreams.NewURLDataSource("file://"+metadataDir, simplestreams.VerifySSLHostnames)},
+			Sources: []simplestreams.DataSource{
+				simplestreams.NewURLDataSource("test", s.toolsURL(), simplestreams.VerifySSLHostnames)},
 		},
 	}
-	versions, err := ValidateToolsMetadata(params)
+	versions, resolveInfo, err := ValidateToolsMetadata(params)
 	c.Assert(err, gc.IsNil)
 	c.Assert(versions, gc.DeepEquals, []string{"1.11.2-raring-amd64"})
+	c.Check(resolveInfo, gc.DeepEquals, &simplestreams.ResolveInfo{
+		Source:    "test",
+		Signed:    false,
+		IndexURL:  "file://" + path.Join(s.metadataDir, "tools/streams/v1/index.json"),
+		MirrorURL: "",
+	})
 }
 
 func (s *ValidateSuite) TestNoMatch(c *gc.C) {
-	s.makeLocalMetadata(c, "1.11.2", "region-2", "raring", "some-auth-url")
-	metadataDir := osenv.JujuHomePath("")
+	s.makeLocalMetadata(c, "1.11.2", "raring")
 	params := &ToolsMetadataLookupParams{
 		Version: "1.11.2",
 		MetadataLookupParams: simplestreams.MetadataLookupParams{
@@ -116,9 +130,10 @@
 			Series:        "precise",
 			Architectures: []string{"amd64"},
 			Endpoint:      "some-auth-url",
-			Sources:       []simplestreams.DataSource{simplestreams.NewURLDataSource("file://"+metadataDir, simplestreams.VerifySSLHostnames)},
+			Sources: []simplestreams.DataSource{
+				simplestreams.NewURLDataSource("test", s.toolsURL(), simplestreams.VerifySSLHostnames)},
 		},
 	}
-	_, err := ValidateToolsMetadata(params)
+	_, _, err := ValidateToolsMetadata(params)
 	c.Assert(err, gc.Not(gc.IsNil))
 }

=== modified file 'provider/azure/environ.go'
--- provider/azure/environ.go	2014-02-18 03:18:16 +0000
+++ provider/azure/environ.go	2014-03-04 05:51:00 +0000
@@ -860,9 +860,9 @@
 // GetImageSources returns a list of sources which are used to search for simplestreams image metadata.
 func (env *azureEnviron) GetImageSources() ([]simplestreams.DataSource, error) {
 	sources := make([]simplestreams.DataSource, 1+len(baseURLs))
-	sources[0] = storage.NewStorageSimpleStreamsDataSource(env.Storage(), storage.BaseImagesPath)
+	sources[0] = storage.NewStorageSimpleStreamsDataSource("cloud storage", env.Storage(), storage.BaseImagesPath)
 	for i, url := range baseURLs {
-		sources[i+1] = simplestreams.NewURLDataSource(url, simplestreams.VerifySSLHostnames)
+		sources[i+1] = simplestreams.NewURLDataSource("Azure base URL", url, simplestreams.VerifySSLHostnames)
 	}
 	return sources, nil
 }
@@ -871,7 +871,7 @@
 func (env *azureEnviron) GetToolsSources() ([]simplestreams.DataSource, error) {
 	// Add the simplestreams source off the control bucket.
 	sources := []simplestreams.DataSource{
-		storage.NewStorageSimpleStreamsDataSource(env.Storage(), storage.BaseToolsPath)}
+		storage.NewStorageSimpleStreamsDataSource("cloud storage", env.Storage(), storage.BaseToolsPath)}
 	return sources, nil
 }
 

=== modified file 'provider/azure/instancetype.go'
--- provider/azure/instancetype.go	2014-01-29 06:45:16 +0000
+++ provider/azure/instancetype.go	2014-03-04 05:51:00 +0000
@@ -142,7 +142,7 @@
 		return nil, err
 	}
 	indexPath := simplestreams.DefaultIndexPath
-	images, err := fetchImageMetadata(sources, indexPath, constraint, signedImageDataOnly)
+	images, _, err := fetchImageMetadata(sources, indexPath, constraint, signedImageDataOnly)
 	if len(images) == 0 || errors.IsNotFoundError(err) {
 		return nil, fmt.Errorf("no OS images found for location %q, series %q, architectures %q (and endpoint: %q)", location, series, arches, endpoint)
 	} else if err != nil {

=== modified file 'provider/azure/instancetype_test.go'
--- provider/azure/instancetype_test.go	2014-01-29 06:45:16 +0000
+++ provider/azure/instancetype_test.go	2014-03-04 05:51:00 +0000
@@ -482,8 +482,9 @@
 // It returns a cleanup function, which you must call when done.
 func patchFetchImageMetadata(cannedResponse []*imagemetadata.ImageMetadata, cannedError error) func() {
 	original := fetchImageMetadata
-	fetchImageMetadata = func([]simplestreams.DataSource, string, *imagemetadata.ImageConstraint, bool) ([]*imagemetadata.ImageMetadata, error) {
-		return cannedResponse, cannedError
+	fetchImageMetadata = func([]simplestreams.DataSource, string, *imagemetadata.ImageConstraint, bool) (
+		[]*imagemetadata.ImageMetadata, *simplestreams.ResolveInfo, error) {
+		return cannedResponse, nil, cannedError
 	}
 	return func() { fetchImageMetadata = original }
 }

=== modified file 'provider/common/mock_test.go'
--- provider/common/mock_test.go	2013-10-15 04:38:40 +0000
+++ provider/common/mock_test.go	2014-03-04 05:51:00 +0000
@@ -72,7 +72,7 @@
 	if env.getToolsSources != nil {
 		return env.getToolsSources()
 	}
-	datasource := storage.NewStorageSimpleStreamsDataSource(env.Storage(), storage.BaseToolsPath)
+	datasource := storage.NewStorageSimpleStreamsDataSource("test cloud storage", env.Storage(), storage.BaseToolsPath)
 	return []simplestreams.DataSource{datasource}, nil
 }
 

=== modified file 'provider/dummy/environs.go'
--- provider/dummy/environs.go	2014-02-20 08:23:40 +0000
+++ provider/dummy/environs.go	2014-03-04 05:51:00 +0000
@@ -529,13 +529,13 @@
 // GetImageSources returns a list of sources which are used to search for simplestreams image metadata.
 func (e *environ) GetImageSources() ([]simplestreams.DataSource, error) {
 	return []simplestreams.DataSource{
-		storage.NewStorageSimpleStreamsDataSource(e.Storage(), storage.BaseImagesPath)}, nil
+		storage.NewStorageSimpleStreamsDataSource("cloud storage", e.Storage(), storage.BaseImagesPath)}, nil
 }
 
 // GetToolsSources returns a list of sources which are used to search for simplestreams tools metadata.
 func (e *environ) GetToolsSources() ([]simplestreams.DataSource, error) {
 	return []simplestreams.DataSource{
-		storage.NewStorageSimpleStreamsDataSource(e.Storage(), storage.BaseToolsPath)}, nil
+		storage.NewStorageSimpleStreamsDataSource("cloud storage", e.Storage(), storage.BaseToolsPath)}, nil
 }
 
 func (e *environ) Bootstrap(ctx environs.BootstrapContext, cons constraints.Value) error {

=== modified file 'provider/ec2/ec2.go'
--- provider/ec2/ec2.go	2014-02-28 03:05:47 +0000
+++ provider/ec2/ec2.go	2014-03-04 05:51:00 +0000
@@ -1057,7 +1057,7 @@
 func (e *environ) GetImageSources() ([]simplestreams.DataSource, error) {
 	// Add the simplestreams source off the control bucket.
 	sources := []simplestreams.DataSource{
-		storage.NewStorageSimpleStreamsDataSource(e.Storage(), storage.BaseImagesPath)}
+		storage.NewStorageSimpleStreamsDataSource("cloud storage", e.Storage(), storage.BaseImagesPath)}
 	return sources, nil
 }
 
@@ -1065,6 +1065,6 @@
 func (e *environ) GetToolsSources() ([]simplestreams.DataSource, error) {
 	// Add the simplestreams source off the control bucket.
 	sources := []simplestreams.DataSource{
-		storage.NewStorageSimpleStreamsDataSource(e.Storage(), storage.BaseToolsPath)}
+		storage.NewStorageSimpleStreamsDataSource("cloud storage", e.Storage(), storage.BaseToolsPath)}
 	return sources, nil
 }

=== modified file 'provider/ec2/image.go'
--- provider/ec2/image.go	2014-01-29 00:14:51 +0000
+++ provider/ec2/image.go	2014-03-04 05:51:00 +0000
@@ -48,7 +48,7 @@
 		Arches:    ic.Arches,
 		Stream:    stream,
 	})
-	matchingImages, err := imagemetadata.Fetch(
+	matchingImages, _, err := imagemetadata.Fetch(
 		sources, simplestreams.DefaultIndexPath, imageConstraint, signedImageDataOnly)
 	if err != nil {
 		return nil, err

=== modified file 'provider/ec2/image_test.go'
--- provider/ec2/image_test.go	2014-02-14 01:03:03 +0000
+++ provider/ec2/image_test.go	2014-03-04 05:51:00 +0000
@@ -128,7 +128,8 @@
 		c.Logf("test %d", i)
 		stor := ebsStorage
 		spec, err := findInstanceSpec(
-			[]simplestreams.DataSource{simplestreams.NewURLDataSource("test:", simplestreams.VerifySSLHostnames)},
+			[]simplestreams.DataSource{
+				simplestreams.NewURLDataSource("test", "test:", simplestreams.VerifySSLHostnames)},
 			"released",
 			&instances.InstanceConstraint{
 				Region:      "test",
@@ -169,7 +170,8 @@
 	for i, t := range findInstanceSpecErrorTests {
 		c.Logf("test %d", i)
 		_, err := findInstanceSpec(
-			[]simplestreams.DataSource{simplestreams.NewURLDataSource("test:", simplestreams.VerifySSLHostnames)},
+			[]simplestreams.DataSource{
+				simplestreams.NewURLDataSource("test", "test:", simplestreams.VerifySSLHostnames)},
 			"released",
 			&instances.InstanceConstraint{
 				Region:      "test",

=== modified file 'provider/ec2/local_test.go'
--- provider/ec2/local_test.go	2014-02-20 08:23:40 +0000
+++ provider/ec2/local_test.go	2014-03-04 05:51:00 +0000
@@ -383,7 +383,7 @@
 	params.Endpoint = "https://ec2.endpoint.com"
 	params.Sources, err = imagemetadata.GetMetadataSources(env)
 	c.Assert(err, gc.IsNil)
-	image_ids, err := imagemetadata.ValidateImageMetadata(params)
+	image_ids, _, err := imagemetadata.ValidateImageMetadata(params)
 	c.Assert(err, gc.IsNil)
 	sort.Strings(image_ids)
 	c.Assert(image_ids, gc.DeepEquals, []string{"ami-00000033", "ami-00000034", "ami-00000035"})

=== modified file 'provider/local/environ.go'
--- provider/local/environ.go	2014-02-28 09:13:21 +0000
+++ provider/local/environ.go	2014-03-04 05:51:00 +0000
@@ -65,7 +65,7 @@
 func (e *localEnviron) GetToolsSources() ([]simplestreams.DataSource, error) {
 	// Add the simplestreams source off the control bucket.
 	return []simplestreams.DataSource{
-		storage.NewStorageSimpleStreamsDataSource(e.Storage(), storage.BaseToolsPath)}, nil
+		storage.NewStorageSimpleStreamsDataSource("cloud storage", e.Storage(), storage.BaseToolsPath)}, nil
 }
 
 // Name is specified in the Environ interface.

=== modified file 'provider/maas/environ.go'
--- provider/maas/environ.go	2013-12-19 09:15:40 +0000
+++ provider/maas/environ.go	2014-03-04 05:51:00 +0000
@@ -421,12 +421,12 @@
 func (e *maasEnviron) GetImageSources() ([]simplestreams.DataSource, error) {
 	// Add the simplestreams source off the control bucket.
 	return []simplestreams.DataSource{
-		storage.NewStorageSimpleStreamsDataSource(e.Storage(), storage.BaseImagesPath)}, nil
+		storage.NewStorageSimpleStreamsDataSource("cloud storage", e.Storage(), storage.BaseImagesPath)}, nil
 }
 
 // GetToolsSources returns a list of sources which are used to search for simplestreams tools metadata.
 func (e *maasEnviron) GetToolsSources() ([]simplestreams.DataSource, error) {
 	// Add the simplestreams source off the control bucket.
 	return []simplestreams.DataSource{
-		storage.NewStorageSimpleStreamsDataSource(e.Storage(), storage.BaseToolsPath)}, nil
+		storage.NewStorageSimpleStreamsDataSource("cloud storage", e.Storage(), storage.BaseToolsPath)}, nil
 }

=== modified file 'provider/manual/environ.go'
--- provider/manual/environ.go	2014-02-20 08:23:40 +0000
+++ provider/manual/environ.go	2014-03-04 05:51:00 +0000
@@ -200,7 +200,7 @@
 func (e *manualEnviron) GetToolsSources() ([]simplestreams.DataSource, error) {
 	// Add the simplestreams source off private storage.
 	return []simplestreams.DataSource{
-		storage.NewStorageSimpleStreamsDataSource(e.Storage(), storage.BaseToolsPath),
+		storage.NewStorageSimpleStreamsDataSource("cloud storage", e.Storage(), storage.BaseToolsPath),
 	}, nil
 }
 

=== modified file 'provider/openstack/image.go'
--- provider/openstack/image.go	2014-01-29 06:45:16 +0000
+++ provider/openstack/image.go	2014-03-04 05:51:00 +0000
@@ -43,7 +43,7 @@
 		return nil, err
 	}
 	// TODO (wallyworld): use an env parameter (default true) to mandate use of only signed image metadata.
-	matchingImages, err := imagemetadata.Fetch(sources, simplestreams.DefaultIndexPath, imageConstraint, false)
+	matchingImages, _, err := imagemetadata.Fetch(sources, simplestreams.DefaultIndexPath, imageConstraint, false)
 	if err != nil {
 		return nil, err
 	}

=== modified file 'provider/openstack/local_test.go'
--- provider/openstack/local_test.go	2014-02-20 08:23:40 +0000
+++ provider/openstack/local_test.go	2014-03-04 05:51:00 +0000
@@ -605,7 +605,7 @@
 	params.Sources, err = imagemetadata.GetMetadataSources(env)
 	c.Assert(err, gc.IsNil)
 	params.Series = "raring"
-	image_ids, err := imagemetadata.ValidateImageMetadata(params)
+	image_ids, _, err := imagemetadata.ValidateImageMetadata(params)
 	c.Assert(err, gc.IsNil)
 	c.Assert(image_ids, gc.DeepEquals, []string{"id-y"})
 }

=== modified file 'provider/openstack/provider.go'
--- provider/openstack/provider.go	2014-02-28 03:05:47 +0000
+++ provider/openstack/provider.go	2014-03-04 05:51:00 +0000
@@ -585,7 +585,7 @@
 	}
 	// Add the simplestreams source off the control bucket.
 	e.imageSources = append(e.imageSources, storage.NewStorageSimpleStreamsDataSource(
-		e.Storage(), storage.BaseImagesPath))
+		"cloud storage", e.Storage(), storage.BaseImagesPath))
 	// Add the simplestreams base URL from keystone if it is defined.
 	productStreamsURL, err := e.client.MakeServiceURL("product-streams", nil)
 	if err == nil {
@@ -593,7 +593,7 @@
 		if !e.Config().SSLHostnameVerification() {
 			verify = simplestreams.NoVerifySSLHostnames
 		}
-		source := simplestreams.NewURLDataSource(productStreamsURL, verify)
+		source := simplestreams.NewURLDataSource("keystone catalog", productStreamsURL, verify)
 		e.imageSources = append(e.imageSources, source)
 	}
 	return e.imageSources, nil
@@ -618,11 +618,12 @@
 		verify = simplestreams.NoVerifySSLHostnames
 	}
 	// Add the simplestreams source off the control bucket.
-	e.toolsSources = append(e.toolsSources, storage.NewStorageSimpleStreamsDataSource(e.Storage(), storage.BaseToolsPath))
+	e.toolsSources = append(e.toolsSources, storage.NewStorageSimpleStreamsDataSource(
+		"cloud storage", e.Storage(), storage.BaseToolsPath))
 	// Add the simplestreams base URL from keystone if it is defined.
 	toolsURL, err := e.client.MakeServiceURL("juju-tools", nil)
 	if err == nil {
-		source := simplestreams.NewURLDataSource(toolsURL, verify)
+		source := simplestreams.NewURLDataSource("keystone catalog", toolsURL, verify)
 		e.toolsSources = append(e.toolsSources, source)
 	}
 	return e.toolsSources, nil