func (s *URLsSuite) TestToolsMetadataURLsRegisteredFuncs(c *gc.C) {
tools.RegisterToolsDataSourceFunc("id0", func(environs.Environ) (simplestreams.DataSource, error) {
return simplestreams.NewURLDataSource("id0", "betwixt/releases", utils.NoVerifySSLHostnames), nil
})
tools.RegisterToolsDataSourceFunc("id1", func(environs.Environ) (simplestreams.DataSource, error) {
return simplestreams.NewURLDataSource("id1", "yoink", utils.NoVerifySSLHostnames), nil
})
// overwrite the one previously registered against id1
tools.RegisterToolsDataSourceFunc("id1", func(environs.Environ) (simplestreams.DataSource, error) {
// NotSupported errors do not cause GetMetadataSources to fail,
// they just cause the datasource function to be ignored.
return nil, errors.NewNotSupported(nil, "oyvey")
})
defer tools.UnregisterToolsDataSourceFunc("id0")
defer tools.UnregisterToolsDataSourceFunc("id1")
env := s.env(c, "config-tools-metadata-url")
sources, err := tools.GetMetadataSources(env)
c.Assert(err, jc.ErrorIsNil)
sstesting.AssertExpectedSources(c, sources, []string{
"config-tools-metadata-url/",
"betwixt/releases/",
"https://streams.canonical.com/juju/tools/",
})
}
func (s *ImageMetadataSuite) TestImageMetadataURLsRegisteredFuncs(c *gc.C) {
environs.RegisterImageDataSourceFunc("id0", func(environs.Environ) (simplestreams.DataSource, error) {
return simplestreams.NewURLDataSource("id0", "betwixt/releases", utils.NoVerifySSLHostnames, simplestreams.DEFAULT_CLOUD_DATA, false), nil
})
environs.RegisterImageDataSourceFunc("id1", func(environs.Environ) (simplestreams.DataSource, error) {
return simplestreams.NewURLDataSource("id1", "yoink", utils.NoVerifySSLHostnames, simplestreams.SPECIFIC_CLOUD_DATA, false), nil
})
// overwrite the one previously registered against id1
environs.RegisterImageDataSourceFunc("id1", func(environs.Environ) (simplestreams.DataSource, error) {
return nil, errors.NewNotSupported(nil, "oyvey")
})
environs.RegisterUserImageDataSourceFunc("id2", func(environs.Environ) (simplestreams.DataSource, error) {
return simplestreams.NewURLDataSource("id2", "foobar", utils.NoVerifySSLHostnames, simplestreams.CUSTOM_CLOUD_DATA, false), nil
})
defer environs.UnregisterImageDataSourceFunc("id0")
defer environs.UnregisterImageDataSourceFunc("id1")
defer environs.UnregisterImageDataSourceFunc("id2")
env := s.env(c, "config-image-metadata-url", "")
sources, err := environs.ImageMetadataSources(env)
c.Assert(err, jc.ErrorIsNil)
sstesting.AssertExpectedSources(c, sources, []sstesting.SourceDetails{
{"config-image-metadata-url/", ""},
{"foobar/", ""},
{"betwixt/releases/", ""},
{"https://streams.canonical.com/juju/images/releases/", imagemetadata.SimplestreamsImagesPublicKey},
{"http://cloud-images.ubuntu.com/releases/", imagemetadata.SimplestreamsImagesPublicKey},
})
}
// GetMetadataSources returns the sources to use when looking for
// simplestreams image id metadata for the given stream. If env implements
// SupportsCustomSources, the sources returned from that method will also
// be considered.
func GetMetadataSources(env environs.ConfigGetter) ([]simplestreams.DataSource, error) {
var sources []simplestreams.DataSource
config := env.Config()
if userURL, ok := config.ImageMetadataURL(); ok {
verify := utils.VerifySSLHostnames
if !config.SSLHostnameVerification() {
verify = utils.NoVerifySSLHostnames
}
sources = append(sources, simplestreams.NewURLDataSource("image-metadata-url", userURL, verify))
}
if custom, ok := env.(SupportsCustomSources); ok {
customSources, err := custom.GetImageSources()
if err != nil {
return nil, err
}
sources = append(sources, customSources...)
}
defaultURL, err := ImageMetadataURL(DefaultBaseURL, config.ImageStream())
if err != nil {
return nil, err
}
if defaultURL != "" {
sources = append(sources,
simplestreams.NewURLDataSource("default cloud images", defaultURL, utils.VerifySSLHostnames))
}
return sources, nil
}
// GetMetadataSourcesWithRetries returns the sources to use when looking for
// simplestreams tools metadata. If env implements SupportsCustomSurces,
// the sources returned from that method will also be considered.
// The sources are configured to use retries according to the value of allowRetry.
func GetMetadataSourcesWithRetries(env environs.ConfigGetter, allowRetry bool) ([]simplestreams.DataSource, error) {
var sources []simplestreams.DataSource
config := env.Config()
if userURL, ok := config.ToolsURL(); ok {
verify := utils.VerifySSLHostnames
if !config.SSLHostnameVerification() {
verify = utils.NoVerifySSLHostnames
}
sources = append(sources, simplestreams.NewURLDataSource("tools-metadata-url", userURL, verify))
}
if custom, ok := env.(SupportsCustomSources); ok {
customSources, err := custom.GetToolsSources()
if err != nil {
return nil, err
}
sources = append(sources, customSources...)
}
defaultURL, err := ToolsURL(DefaultBaseURL)
if err != nil {
return nil, err
}
if defaultURL != "" {
sources = append(sources,
simplestreams.NewURLDataSource("default simplestreams", defaultURL, utils.VerifySSLHostnames))
}
for _, source := range sources {
source.SetAllowRetry(allowRetry)
}
return sources, nil
}
func (s *ImageMetadataSuite) TestImageMetadataURLsRegisteredFuncs(c *gc.C) {
environs.RegisterImageDataSourceFunc("id0", func(environs.Environ) (simplestreams.DataSource, error) {
return simplestreams.NewURLDataSource("id0", "betwixt/releases", utils.NoVerifySSLHostnames), nil
})
environs.RegisterImageDataSourceFunc("id1", func(environs.Environ) (simplestreams.DataSource, error) {
return simplestreams.NewURLDataSource("id1", "yoink", utils.NoVerifySSLHostnames), nil
})
// overwrite the one previously registered against id1
environs.RegisterImageDataSourceFunc("id1", func(environs.Environ) (simplestreams.DataSource, error) {
return nil, errors.NewNotSupported(nil, "oyvey")
})
environs.RegisterUserImageDataSourceFunc("id2", func(environs.Environ) (simplestreams.DataSource, error) {
return simplestreams.NewURLDataSource("id2", "foobar", utils.NoVerifySSLHostnames), nil
})
defer environs.UnregisterImageDataSourceFunc("id0")
defer environs.UnregisterImageDataSourceFunc("id1")
defer environs.UnregisterImageDataSourceFunc("id2")
env := s.env(c, "config-image-metadata-url", "")
sources, err := environs.ImageMetadataSources(env)
c.Assert(err, jc.ErrorIsNil)
sstesting.AssertExpectedSources(c, sources, []string{
"config-image-metadata-url/",
"foobar/",
"betwixt/releases/",
"http://cloud-images.ubuntu.com/releases/",
})
}
// ImageMetadataSources returns the sources to use when looking for
// simplestreams image id metadata for the given stream.
func ImageMetadataSources(env Environ) ([]simplestreams.DataSource, error) {
config := env.Config()
// Add configured and environment-specific datasources.
var sources []simplestreams.DataSource
if userURL, ok := config.ImageMetadataURL(); ok {
verify := utils.VerifySSLHostnames
if !config.SSLHostnameVerification() {
verify = utils.NoVerifySSLHostnames
}
sources = append(sources, simplestreams.NewURLDataSource("image-metadata-url", userURL, verify))
}
envDataSources, err := environmentDataSources(env)
if err != nil {
return nil, err
}
sources = append(sources, envDataSources...)
// Add the default, public datasource.
defaultURL, err := imagemetadata.ImageMetadataURL(imagemetadata.DefaultBaseURL, config.ImageStream())
if err != nil {
return nil, err
}
if defaultURL != "" {
sources = append(sources,
simplestreams.NewURLDataSource("default cloud images", defaultURL, utils.VerifySSLHostnames))
}
for _, ds := range sources {
logger.Debugf("using image datasource %q", ds.Description())
}
return sources, nil
}
func (s *ValidateSuite) TestMajorVersionMatch(c *gc.C) {
s.makeLocalMetadata(c, "released", "1.11.2", "raring")
params := &ToolsMetadataLookupParams{
Major: 1,
Minor: -1,
MetadataLookupParams: simplestreams.MetadataLookupParams{
Region: "region-2",
Series: "raring",
Architectures: []string{"amd64"},
Endpoint: "some-auth-url",
Stream: "released",
Sources: []simplestreams.DataSource{
simplestreams.NewURLDataSource("test", s.toolsURL(), utils.VerifySSLHostnames)},
},
}
versions, resolveInfo, err := ValidateToolsMetadata(params)
c.Assert(err, jc.ErrorIsNil)
c.Assert(versions, gc.DeepEquals, []string{"1.11.2-raring-amd64"})
c.Check(resolveInfo, gc.DeepEquals, &simplestreams.ResolveInfo{
Source: "test",
Signed: false,
IndexURL: utils.MakeFileURL(path.Join(s.metadataDir, "tools/streams/v1/index2.json")),
MirrorURL: "",
})
}
func (s *simplestreamsSuite) TestFetchMetadata(c *gc.C) {
for i, test := range fetchMetadataTests {
c.Logf("\ntest %d: %s", i, test.about)
// Patch the current Juju version.
jujuVersion := version.MustParse(test.jujuVersion)
s.PatchValue(&jujuversion.Current, jujuVersion)
// Add invalid datasource and check later that resolveInfo is correct.
invalidSource := simplestreams.NewURLDataSource(
"invalid", "file://invalid", utils.VerifySSLHostnames, simplestreams.DEFAULT_CLOUD_DATA, s.RequireSigned)
// Fetch the Juju GUI archives.
allMeta, err := gui.FetchMetadata(test.stream, invalidSource, s.Source)
for i, meta := range allMeta {
c.Logf("metadata %d:\n%#v", i, meta)
}
if test.expectedError != "" {
c.Assert(err, gc.ErrorMatches, test.expectedError)
c.Assert(allMeta, gc.IsNil)
continue
}
// Populate the expected metadata with missing fields.
for _, meta := range test.expectedMetadata {
meta.JujuMajorVersion = jujuVersion.Major
meta.FullPath = "test:/" + meta.Path
meta.Source = s.Source
meta.StringVersion = meta.Version.String()
}
c.Assert(err, jc.ErrorIsNil)
c.Assert(allMeta, jc.DeepEquals, test.expectedMetadata)
}
}
// GetMetadataSources returns the sources to use when looking for
// simplestreams tools metadata for the given stream.
func GetMetadataSources(env environs.Environ) ([]simplestreams.DataSource, error) {
config := env.Config()
// Add configured and environment-specific datasources.
var sources []simplestreams.DataSource
if userURL, ok := config.AgentMetadataURL(); ok {
verify := utils.VerifySSLHostnames
if !config.SSLHostnameVerification() {
verify = utils.NoVerifySSLHostnames
}
sources = append(sources, simplestreams.NewURLDataSource(conf.AgentMetadataURLKey, userURL, verify, simplestreams.SPECIFIC_CLOUD_DATA, false))
}
envDataSources, err := environmentDataSources(env)
if err != nil {
return nil, err
}
sources = append(sources, envDataSources...)
// Add the default, public datasource.
defaultURL, err := ToolsURL(DefaultBaseURL)
if err != nil {
return nil, err
}
if defaultURL != "" {
sources = append(sources,
simplestreams.NewURLSignedDataSource("default simplestreams", defaultURL, simplestreams.SimplestreamsJujuPublicKey, utils.VerifySSLHostnames, simplestreams.DEFAULT_CLOUD_DATA, true))
}
return sources, nil
}
// ImageMetadataSources returns the sources to use when looking for
// simplestreams image id metadata for the given stream.
func ImageMetadataSources(env Environ) ([]simplestreams.DataSource, error) {
config := env.Config()
// Add configured and environment-specific datasources.
var sources []simplestreams.DataSource
if userURL, ok := config.ImageMetadataURL(); ok {
verify := utils.VerifySSLHostnames
if !config.SSLHostnameVerification() {
verify = utils.NoVerifySSLHostnames
}
sources = append(sources, simplestreams.NewURLDataSource("image-metadata-url", userURL, verify, simplestreams.SPECIFIC_CLOUD_DATA, false))
}
envDataSources, err := environmentDataSources(env)
if err != nil {
return nil, err
}
sources = append(sources, envDataSources...)
// Add the official image metadata datasources.
officialDataSources, err := imagemetadata.OfficialDataSources(config.ImageStream())
if err != nil {
return nil, err
}
for _, source := range officialDataSources {
sources = append(sources, source)
}
for _, ds := range sources {
logger.Debugf("using image datasource %q", ds.Description())
}
return sources, nil
}
func (s *simplestreamsSuite) TestGetMetadataNoMatching(c *gc.C) {
source := &countingSource{
DataSource: simplestreams.NewURLDataSource(
"test", "test:/daily", utils.VerifySSLHostnames,
),
}
sources := []simplestreams.DataSource{source, source, source}
constraint := sstesting.NewTestConstraint(simplestreams.LookupParams{
CloudSpec: simplestreams.CloudSpec{
Region: "us-east-1",
Endpoint: "https://ec2.us-east-1.amazonaws.com",
},
Series: []string{"precise"},
Arches: []string{"not-a-real-arch"}, // never matches
})
params := simplestreams.GetMetadataParams{
StreamsVersion: s.StreamsVersion,
LookupConstraint: constraint,
ValueParams: simplestreams.ValueParams{DataType: "image-ids"},
}
items, resolveInfo, err := simplestreams.GetMetadata(sources, params)
c.Assert(err, jc.ErrorIsNil)
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 4 calls to each data-source:
// one for .sjson, one for .json, repeated for legacy vs new index files.
c.Assert(source.count, gc.Equals, 4*len(sources))
}
// setPrivateMetadataSources sets the default tools metadata source
// for tools syncing, and adds an image metadata source after verifying
// the contents.
func setPrivateMetadataSources(env environs.Environ, metadataDir string) ([]*imagemetadata.ImageMetadata, error) {
logger.Infof("Setting default tools and image metadata sources: %s", metadataDir)
tools.DefaultBaseURL = metadataDir
imageMetadataDir := filepath.Join(metadataDir, storage.BaseImagesPath)
if _, err := os.Stat(imageMetadataDir); err != nil {
if !os.IsNotExist(err) {
return nil, errors.Annotate(err, "cannot access image metadata")
}
return nil, nil
}
baseURL := fmt.Sprintf("file://%s", filepath.ToSlash(imageMetadataDir))
datasource := simplestreams.NewURLDataSource("bootstrap metadata", baseURL, utils.NoVerifySSLHostnames)
// Read the image metadata, as we'll want to upload it to the environment.
imageConstraint := imagemetadata.NewImageConstraint(simplestreams.LookupParams{})
existingMetadata, _, err := imagemetadata.Fetch(
[]simplestreams.DataSource{datasource}, imageConstraint, false)
if err != nil && !errors.IsNotFound(err) {
return nil, errors.Annotate(err, "cannot read image metadata")
}
// Add an image metadata datasource for constraint validation, etc.
// TODO (anastasiamac 2015-09-26) Delete when search path is modified to look
// into state first.
environs.RegisterUserImageDataSourceFunc("bootstrap metadata", func(environs.Environ) (simplestreams.DataSource, error) {
return datasource, nil
})
logger.Infof("custom image metadata added to search path")
return existingMetadata, nil
}
func getImageSource(env environs.Environ) (simplestreams.DataSource, error) {
e, ok := env.(*environ)
if !ok {
return nil, errors.NotSupportedf("non-cloudsigma environment")
}
return simplestreams.NewURLDataSource("cloud images", fmt.Sprintf(CloudsigmaCloudImagesURLTemplate, e.ecfg.region()), utils.VerifySSLHostnames), nil
}
func (s *simplestreamsSuite) TestFetch(c *gc.C) {
for i, t := range fetchTests {
c.Logf("test %d", i)
cloudSpec := simplestreams.CloudSpec{t.region, "https://ec2.us-east-1.amazonaws.com"}
if t.region == "" {
cloudSpec = simplestreams.EmptyCloudSpec
}
imageConstraint := imagemetadata.NewImageConstraint(simplestreams.LookupParams{
CloudSpec: cloudSpec,
Series: []string{"precise"},
Arches: t.arches,
})
// Add invalid datasource and check later that resolveInfo is correct.
invalidSource := simplestreams.NewURLDataSource("invalid", "file://invalid", utils.VerifySSLHostnames, simplestreams.DEFAULT_CLOUD_DATA, s.RequireSigned)
images, resolveInfo, err := imagemetadata.Fetch(
[]simplestreams.DataSource{invalidSource, s.Source}, imageConstraint)
if !c.Check(err, jc.ErrorIsNil) {
continue
}
for _, testImage := range t.images {
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: "",
})
}
}
func registerLiveSimpleStreamsTests(baseURL string, validImageConstraint simplestreams.LookupConstraint, requireSigned bool) {
gc.Suite(&sstesting.LocalLiveSimplestreamsSuite{
Source: simplestreams.NewURLDataSource("test", baseURL, utils.VerifySSLHostnames, simplestreams.DEFAULT_CLOUD_DATA, requireSigned),
RequireSigned: requireSigned,
DataType: imagemetadata.ImageIds,
ValidConstraint: validImageConstraint,
})
}
func registerLiveSimpleStreamsTests(baseURL string, validToolsConstraint simplestreams.LookupConstraint, requireSigned bool) {
gc.Suite(&sstesting.LocalLiveSimplestreamsSuite{
Source: simplestreams.NewURLDataSource("test", baseURL, utils.VerifySSLHostnames),
RequireSigned: requireSigned,
DataType: tools.ContentDownload,
ValidConstraint: validToolsConstraint,
})
}
func (s *signedSuite) TestSignedImageMetadataInvalidSignature(c *gc.C) {
signedSource := simplestreams.NewURLDataSource("test", "test://host/signed", utils.VerifySSLHostnames, simplestreams.DEFAULT_CLOUD_DATA, true)
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([]simplestreams.DataSource{signedSource}, imageConstraint)
c.Assert(err, gc.ErrorMatches, "cannot read index data.*")
}
func (s *datasourceSuite) TestFetch(c *gc.C) {
ds := simplestreams.NewURLDataSource("test", "test:", utils.VerifySSLHostnames, simplestreams.DEFAULT_CLOUD_DATA, false)
rc, url, err := ds.Fetch("streams/v1/tools_metadata.json")
c.Assert(err, jc.ErrorIsNil)
defer rc.Close()
c.Assert(url, gc.Equals, "test:/streams/v1/tools_metadata.json")
data, err := ioutil.ReadAll(rc)
cloudMetadata, err := simplestreams.ParseCloudMetadata(data, "products:1.0", url, imagemetadata.ImageMetadata{})
c.Assert(err, jc.ErrorIsNil)
c.Assert(len(cloudMetadata.Products), jc.GreaterThan, 0)
}
func (s *datasourceHTTPSSuite) TestNormalClientFails(c *gc.C) {
ds := simplestreams.NewURLDataSource("test", s.Server.URL, utils.VerifySSLHostnames, simplestreams.DEFAULT_CLOUD_DATA, false)
url, err := ds.URL("bar")
c.Assert(err, jc.ErrorIsNil)
c.Check(url, gc.Equals, s.Server.URL+"/bar")
reader, _, err := ds.Fetch("bar")
// The underlying failure is a x509: certificate signed by unknown authority
// However, the urlDataSource abstraction hides that as a simple NotFound
c.Assert(err, gc.ErrorMatches, "invalid URL \".*/bar\" not found")
c.Check(reader, gc.IsNil)
}
// selectSourceDatasource returns a storage reader based on the source setting.
func selectSourceDatasource(syncContext *SyncContext) (simplestreams.DataSource, error) {
source := syncContext.Source
if source == "" {
source = envtools.DefaultBaseURL
}
sourceURL, err := envtools.ToolsURL(source)
if err != nil {
return nil, err
}
logger.Infof("using sync tools source: %v", sourceURL)
return simplestreams.NewURLDataSource("sync tools source", sourceURL, utils.VerifySSLHostnames), nil
}
func getImageSource(env environs.Environ) (simplestreams.DataSource, error) {
e, ok := env.(*environ)
if !ok {
return nil, errors.NotSupportedf("non-cloudsigma model")
}
return simplestreams.NewURLDataSource(
"cloud images",
fmt.Sprintf(CloudsigmaCloudImagesURLTemplate, e.cloud.Region),
utils.VerifySSLHostnames,
simplestreams.SPECIFIC_CLOUD_DATA,
false,
), nil
}
func (s *regionMetadataSuite) createTestDataSource(c *gc.C, dsID string, files []struct{ path, content string }) int {
metadataDir := c.MkDir()
writeTempFiles(c, metadataDir, files)
ds := simplestreams.NewURLDataSource(dsID, "file://"+metadataDir, false, 20, false)
environs.RegisterImageDataSourceFunc(dsID, func(environs.Environ) (simplestreams.DataSource, error) {
return ds, nil
})
s.AddCleanup(func(*gc.C) {
environs.UnregisterImageDataSourceFunc(dsID)
})
return ds.Priority()
}
func (s *datasourceHTTPSSuite) TestNonVerifyingClientSucceeds(c *gc.C) {
ds := simplestreams.NewURLDataSource("test", s.Server.URL, utils.NoVerifySSLHostnames, simplestreams.DEFAULT_CLOUD_DATA, false)
url, err := ds.URL("bar")
c.Assert(err, jc.ErrorIsNil)
c.Check(url, gc.Equals, s.Server.URL+"/bar")
reader, _, err := ds.Fetch("bar")
// The underlying failure is a x509: certificate signed by unknown authority
// However, the urlDataSource abstraction hides that as a simple NotFound
c.Assert(err, jc.ErrorIsNil)
defer reader.Close()
byteContent, err := ioutil.ReadAll(reader)
c.Assert(err, jc.ErrorIsNil)
c.Check(string(byteContent), gc.Equals, "Greetings!\n")
}
func (s *ValidateSuite) assertNoMatch(c *gc.C, stream string) {
s.makeLocalMetadata(c, "1234", "region-2", "raring", "some-auth-url", stream)
params := &simplestreams.MetadataLookupParams{
Region: "region-2",
Series: "precise",
Architectures: []string{"amd64"},
Endpoint: "some-auth-url",
Stream: stream,
Sources: []simplestreams.DataSource{
simplestreams.NewURLDataSource("test", "file://"+s.metadataDir, utils.VerifySSLHostnames, simplestreams.DEFAULT_CLOUD_DATA, false)},
}
_, _, err := imagemetadata.ValidateImageMetadata(params)
c.Assert(err, gc.Not(gc.IsNil))
}
func (c *toolsMetadataCommand) Run(context *cmd.Context) error {
loggo.RegisterWriter("toolsmetadata", cmd.NewCommandLogWriter("juju.environs.tools", context.Stdout, context.Stderr), loggo.INFO)
defer loggo.RemoveWriter("toolsmetadata")
if c.metadataDir == "" {
c.metadataDir = osenv.JujuHome()
} else {
c.metadataDir = context.AbsPath(c.metadataDir)
}
sourceStorage, err := filestorage.NewFileStorageReader(c.metadataDir)
if err != nil {
return err
}
// We now store the tools in a directory named after their stream, but the
// legacy behaviour is to store all tools in a single "releases" directory.
toolsDir := c.stream
if c.stream == "" {
fmt.Fprintf(context.Stdout, "No stream specified, defaulting to released tools in the releases directory.\n")
c.stream = envtools.ReleasedStream
toolsDir = envtools.LegacyReleaseDirectory
}
fmt.Fprintf(context.Stdout, "Finding tools in %s for stream %s.\n", c.metadataDir, c.stream)
const minorVersion = -1
toolsList, err := envtools.ReadList(sourceStorage, toolsDir, version.Current.Major, minorVersion)
if err == envtools.ErrNoTools {
var source string
source, err = envtools.ToolsURL(envtools.DefaultBaseURL)
if err != nil {
return err
}
sourceDataSource := simplestreams.NewURLDataSource("local source", source, utils.VerifySSLHostnames)
toolsList, err = envtools.FindToolsForCloud(
[]simplestreams.DataSource{sourceDataSource}, simplestreams.CloudSpec{}, c.stream,
version.Current.Major, minorVersion, coretools.Filter{})
}
if err != nil {
return err
}
targetStorage, err := filestorage.NewFileStorageWriter(c.metadataDir)
if err != nil {
return err
}
writeMirrors := envtools.DoNotWriteMirrors
if c.public {
writeMirrors = envtools.WriteMirrors
}
return mergeAndWriteMetadata(targetStorage, toolsDir, c.stream, c.clean, toolsList, writeMirrors)
}
func (s *ValidateSuite) TestNoMatch(c *gc.C) {
s.makeLocalMetadata(c, "1.11.2", "raring")
params := &ToolsMetadataLookupParams{
Version: "1.11.2",
MetadataLookupParams: simplestreams.MetadataLookupParams{
Region: "region-2",
Series: "precise",
Architectures: []string{"amd64"},
Endpoint: "some-auth-url",
Sources: []simplestreams.DataSource{
simplestreams.NewURLDataSource("test", s.toolsURL(), utils.VerifySSLHostnames)},
},
}
_, _, err := ValidateToolsMetadata(params)
c.Assert(err, gc.Not(gc.IsNil))
}
func (s *specSuite) TestFindInstanceSpecNotSetCpuPowerWhenInstanceTypeSet(c *gc.C) {
source := []simplestreams.DataSource{
simplestreams.NewURLDataSource("test", "test:", utils.VerifySSLHostnames),
}
instanceConstraint := &instances.InstanceConstraint{
Region: "test",
Series: testing.FakeDefaultSeries,
Constraints: constraints.MustParse("instance-type=t2.medium"),
}
c.Check(instanceConstraint.Constraints.CpuPower, gc.IsNil)
findInstanceSpec(source, "released", instanceConstraint)
c.Check(instanceConstraint.Constraints.CpuPower, gc.IsNil)
}
func (s *specSuite) TestFindInstanceSpecErrors(c *gc.C) {
for i, t := range findInstanceSpecErrorTests {
c.Logf("test %d", i)
_, err := findInstanceSpec(
[]simplestreams.DataSource{
simplestreams.NewURLDataSource("test", "test:", utils.VerifySSLHostnames)},
"released",
&instances.InstanceConstraint{
Region: "test",
Series: t.series,
Arches: t.arches,
Constraints: constraints.MustParse(t.cons),
})
c.Check(err, gc.ErrorMatches, t.err)
}
}
func (s *imageSuite) TestFindInstanceSpec(c *gc.C) {
for _, t := range findInstanceSpecTests {
c.Logf("test: %v", t.desc)
t.init()
cons := imagemetadata.NewImageConstraint(simplestreams.LookupParams{
CloudSpec: simplestreams.CloudSpec{t.region, "ep"},
Series: []string{"precise"},
Arches: t.arches,
Stream: t.stream,
})
imageMeta, err := imagemetadata.GetLatestImageIdMetadata(
[]byte(jsonImagesContent),
simplestreams.NewURLDataSource("test", "some-url", utils.VerifySSLHostnames), cons)
c.Assert(err, jc.ErrorIsNil)
var images []Image
for _, imageMetadata := range imageMeta {
im := *imageMetadata
images = append(images, Image{
Id: im.Id,
VirtType: im.VirtType,
Arch: im.Arch,
})
}
imageCons := constraints.MustParse(t.constraints)
spec, err := FindInstanceSpec(images, &InstanceConstraint{
Series: "precise",
Region: t.region,
Arches: t.arches,
Constraints: imageCons,
}, t.instanceTypes)
if t.err != "" {
c.Check(err, gc.ErrorMatches, t.err)
continue
} else {
if !c.Check(err, jc.ErrorIsNil) {
continue
}
c.Check(spec.Image.Id, gc.Equals, t.imageId)
if len(t.instanceTypes) == 1 {
c.Check(spec.InstanceType, gc.DeepEquals, t.instanceTypes[0])
}
if imageCons.HasInstanceType() {
c.Assert(spec.InstanceType.Name, gc.Equals, *imageCons.InstanceType)
}
}
}
}
func registerSimpleStreamsTests() {
gc.Suite(&simplestreamsSuite{
LocalLiveSimplestreamsSuite: sstesting.LocalLiveSimplestreamsSuite{
Source: simplestreams.NewURLDataSource("test", "test:", utils.VerifySSLHostnames),
RequireSigned: false,
DataType: "image-ids",
ValidConstraint: sstesting.NewTestConstraint(simplestreams.LookupParams{
CloudSpec: simplestreams.CloudSpec{
Region: "us-east-1",
Endpoint: "https://ec2.us-east-1.amazonaws.com",
},
Series: []string{"precise"},
Arches: []string{"amd64", "arm"},
}),
},
})
}