// WriteMetadata writes the given tools metadata for the specified streams to the given storage.
// streamMetadata contains all known metadata so that the correct index files can be written.
// Only product files for the specified streams are written.
func WriteMetadata(stor storage.Storage, streamMetadata map[string][]*ToolsMetadata, streams []string, writeMirrors ShouldWriteMirrors) error {
// TODO(perrito666) 2016-05-02 lp:1558657
updated := time.Now()
index, legacyIndex, products, err := MarshalToolsMetadataJSON(streamMetadata, updated)
if err != nil {
return err
}
metadataInfo := []MetadataFile{
{simplestreams.UnsignedIndex(currentStreamsVersion, IndexFileVersion), index},
}
if legacyIndex != nil {
metadataInfo = append(metadataInfo, MetadataFile{
simplestreams.UnsignedIndex(currentStreamsVersion, 1), legacyIndex,
})
}
for _, stream := range streams {
if metadata, ok := products[stream]; ok {
// If metadata hasn't changed, do not overwrite.
unchanged, err := metadataUnchanged(stor, stream, metadata)
if err != nil {
return err
}
if unchanged {
logger.Infof("Metadata for stream %q unchanged", stream)
continue
}
// Metadata is different, so include it.
metadataInfo = append(metadataInfo, MetadataFile{ProductMetadataPath(stream), metadata})
}
}
if writeMirrors {
streamsMirrorsMetadata := make(map[string][]simplestreams.MirrorReference)
for stream := range streamMetadata {
streamsMirrorsMetadata[ToolsContentId(stream)] = []simplestreams.MirrorReference{{
Updated: updated.Format("20060102"), // YYYYMMDD
DataType: ContentDownload,
Format: simplestreams.MirrorFormat,
Path: simplestreams.MirrorFile,
}}
}
mirrorsMetadata := map[string]map[string][]simplestreams.MirrorReference{
"mirrors": streamsMirrorsMetadata,
}
mirrorsInfo, err := json.MarshalIndent(&mirrorsMetadata, "", " ")
if err != nil {
return err
}
metadataInfo = append(
metadataInfo, MetadataFile{simplestreams.UnsignedMirror(currentStreamsVersion), mirrorsInfo})
}
return writeMetadataFiles(stor, metadataInfo)
}
// ParseMetadataFromStorage loads ToolsMetadata from the specified storage reader.
func ParseMetadataFromStorage(c *gc.C, stor storage.StorageReader, stream string, expectMirrors bool) []*tools.ToolsMetadata {
source := storage.NewStorageSimpleStreamsDataSource("test storage reader", stor, "tools")
params := simplestreams.ValueParams{
DataType: tools.ContentDownload,
ValueTemplate: tools.ToolsMetadata{},
}
const requireSigned = false
indexPath := simplestreams.UnsignedIndex("v1", 2)
mirrorsPath := simplestreams.MirrorsPath("v1")
indexRef, err := simplestreams.GetIndexWithFormat(
source, indexPath, "index:1.0", mirrorsPath, requireSigned, simplestreams.CloudSpec{}, params)
c.Assert(err, jc.ErrorIsNil)
toolsIndexMetadata := indexRef.Indexes[tools.ToolsContentId(stream)]
c.Assert(toolsIndexMetadata, gc.NotNil)
// Read the products file contents.
r, err := stor.Get(path.Join("tools", toolsIndexMetadata.ProductsFilePath))
defer r.Close()
c.Assert(err, jc.ErrorIsNil)
data, err := ioutil.ReadAll(r)
c.Assert(err, jc.ErrorIsNil)
url, err := source.URL(toolsIndexMetadata.ProductsFilePath)
c.Assert(err, jc.ErrorIsNil)
cloudMetadata, err := simplestreams.ParseCloudMetadata(data, "products:1.0", url, tools.ToolsMetadata{})
c.Assert(err, jc.ErrorIsNil)
toolsMetadataMap := make(map[string]*tools.ToolsMetadata)
expectedProductIds := make(set.Strings)
toolsVersions := make(set.Strings)
for _, mc := range cloudMetadata.Products {
for _, items := range mc.Items {
for key, item := range items.Items {
toolsMetadata := item.(*tools.ToolsMetadata)
toolsMetadataMap[key] = toolsMetadata
toolsVersions.Add(key)
seriesVersion, err := series.SeriesVersion(toolsMetadata.Release)
if err != nil {
c.Assert(err, jc.Satisfies, series.IsUnknownSeriesVersionError)
}
productId := fmt.Sprintf("com.ubuntu.juju:%s:%s", seriesVersion, toolsMetadata.Arch)
expectedProductIds.Add(productId)
}
}
}
// Make sure index's product IDs are all represented in the products metadata.
sort.Strings(toolsIndexMetadata.ProductIds)
c.Assert(toolsIndexMetadata.ProductIds, gc.DeepEquals, expectedProductIds.SortedValues())
toolsMetadata := make([]*tools.ToolsMetadata, len(toolsMetadataMap))
for i, key := range toolsVersions.SortedValues() {
toolsMetadata[i] = toolsMetadataMap[key]
}
if expectMirrors {
r, err = stor.Get(path.Join("tools", simplestreams.UnsignedMirror("v1")))
c.Assert(err, jc.ErrorIsNil)
defer r.Close()
data, err = ioutil.ReadAll(r)
c.Assert(err, jc.ErrorIsNil)
c.Assert(string(data), jc.Contains, `"mirrors":`)
c.Assert(string(data), jc.Contains, tools.ToolsContentId(stream))
c.Assert(err, jc.ErrorIsNil)
}
return toolsMetadata
}