// Note that whether the metadata actually needs
// to be stored will be determined within this call.
errs, err := api.Save(metadata)
if err != nil {
return errors.Annotatef(err, "saving published images metadata")
}
return processErrors(append(errs.Results, parseErrs...))
}
// convertToParams converts model-specific images metadata to structured metadata format.
var convertToParams = func(info *simplestreams.ResolveInfo, priority int, published []*envmetadata.ImageMetadata) (params.MetadataSaveParams, []params.ErrorResult) {
metadata := []params.CloudImageMetadataList{{}}
errs := []params.ErrorResult{}
for _, p := range published {
s, err := series.VersionSeries(p.Version)
if err != nil {
errs = append(errs, params.ErrorResult{Error: common.ServerError(err)})
continue
}
m := params.CloudImageMetadata{
Source: info.Source,
ImageId: p.Id,
Stream: p.Stream,
Region: p.RegionName,
Arch: p.Arch,
VirtType: p.VirtType,
RootStorageType: p.Storage,
Series: s,
Priority: priority,
func (s *supportedSeriesSuite) TestVersionSeriesInvalid(c *gc.C) {
setSeriesTestData()
_, err := series.VersionSeries("73655")
c.Assert(err, gc.ErrorMatches, `.*unknown series for version: "73655".*`)
}
func (s *supportedSeriesSuite) TestVersionSeriesValid(c *gc.C) {
setSeriesTestData()
seriesResult, err := series.VersionSeries("14.04")
c.Assert(err, jc.ErrorIsNil)
c.Assert("trusty", gc.DeepEquals, seriesResult)
}
// imageMetadataFromDataSources finds image metadata that match specified criteria in existing data sources.
func (p *ProvisionerAPI) imageMetadataFromDataSources(env environs.Environ, constraint *imagemetadata.ImageConstraint) ([]params.CloudImageMetadata, error) {
sources, err := environs.ImageMetadataSources(env)
if err != nil {
return nil, errors.Trace(err)
}
cfg := env.Config()
toModel := func(m *imagemetadata.ImageMetadata, mSeries string, source string, priority int) cloudimagemetadata.Metadata {
result := cloudimagemetadata.Metadata{
MetadataAttributes: cloudimagemetadata.MetadataAttributes{
Region: m.RegionName,
Arch: m.Arch,
VirtType: m.VirtType,
RootStorageType: m.Storage,
Source: source,
Series: mSeries,
Stream: m.Stream,
Version: m.Version,
},
Priority: priority,
ImageId: m.Id,
}
// TODO (anastasiamac 2016-08-24) This is a band-aid solution.
// Once correct value is read from simplestreams, this needs to go.
// Bug# 1616295
if result.Stream == "" {
result.Stream = constraint.Stream
}
if result.Stream == "" {
result.Stream = cfg.ImageStream()
}
return result
}
var metadataState []cloudimagemetadata.Metadata
for _, source := range sources {
logger.Debugf("looking in data source %v", source.Description())
found, info, err := imagemetadata.Fetch([]simplestreams.DataSource{source}, constraint)
if err != nil {
// Do not stop looking in other data sources if there is an issue here.
logger.Warningf("encountered %v while getting published images metadata from %v", err, source.Description())
continue
}
for _, m := range found {
mSeries, err := series.VersionSeries(m.Version)
if err != nil {
logger.Warningf("could not determine series for image id %s: %v", m.Id, err)
continue
}
metadataState = append(metadataState, toModel(m, mSeries, info.Source, source.Priority()))
}
}
if len(metadataState) > 0 {
if err := p.st.CloudImageMetadataStorage.SaveMetadata(metadataState); err != nil {
// No need to react here, just take note
logger.Warningf("failed to save published image metadata: %v", err)
}
}
// Since we've fallen through to data sources search and have saved all needed images into controller,
// let's try to get them from controller to avoid duplication of conversion logic here.
all, err := p.imageMetadataFromState(constraint)
if err != nil {
return nil, errors.Annotate(err, "could not read metadata from controller after saving it there from data sources")
}
if len(all) == 0 {
return nil, errors.NotFoundf("image metadata for series %v, arch %v", constraint.Series, constraint.Arches)
}
return all, nil
}
