func (s *metadataHelperSuite) TestReadWriteMetadataUnchanged(c *gc.C) {
metadata := map[string][]*tools.ToolsMetadata{
"released": {{
Release: "precise",
Version: "1.2.3",
Arch: "amd64",
Path: "path1",
}, {
Release: "raring",
Version: "1.2.3",
Arch: "amd64",
Path: "path2",
}},
}
stor, err := filestorage.NewFileStorageWriter(c.MkDir())
c.Assert(err, jc.ErrorIsNil)
err = tools.WriteMetadata(stor, metadata, []string{"released"}, tools.DoNotWriteMirrors)
c.Assert(err, jc.ErrorIsNil)
s.PatchValue(tools.WriteMetadataFiles, func(stor storage.Storage, metadataInfo []tools.MetadataFile) error {
// The product data is the same, we only write the indices.
c.Assert(metadataInfo, gc.HasLen, 2)
c.Assert(metadataInfo[0].Path, gc.Equals, "streams/v1/index2.json")
c.Assert(metadataInfo[1].Path, gc.Equals, "streams/v1/index.json")
return nil
})
err = tools.WriteMetadata(stor, metadata, []string{"released"}, tools.DoNotWriteMirrors)
c.Assert(err, jc.ErrorIsNil)
}
func (*metadataHelperSuite) TestReadMetadataPrefersNewIndex(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("Skipped for now because of introduced regression")
}
metadataDir := c.MkDir()
// Generate metadata and rename index to index.json
metadata := map[string][]*tools.ToolsMetadata{
"proposed": {{
Release: "precise",
Version: "1.2.3",
Arch: "amd64",
Path: "path1",
}},
"released": {{
Release: "trusty",
Version: "1.2.3",
Arch: "amd64",
Path: "path1",
}},
}
stor, err := filestorage.NewFileStorageWriter(metadataDir)
c.Assert(err, jc.ErrorIsNil)
err = tools.WriteMetadata(stor, metadata, []string{"proposed", "released"}, tools.DoNotWriteMirrors)
c.Assert(err, jc.ErrorIsNil)
err = os.Rename(
filepath.Join(metadataDir, "tools", "streams", "v1", "index2.json"),
filepath.Join(metadataDir, "tools", "streams", "v1", "index.json"),
)
c.Assert(err, jc.ErrorIsNil)
// Generate different metadata with index2.json
metadata = map[string][]*tools.ToolsMetadata{
"released": {{
Release: "precise",
Version: "1.2.3",
Arch: "amd64",
Path: "path1",
}},
}
err = tools.WriteMetadata(stor, metadata, []string{"released"}, tools.DoNotWriteMirrors)
c.Assert(err, jc.ErrorIsNil)
// Read back all metadata, expecting to find metadata in index2.json.
out, err := tools.ReadAllMetadata(stor)
for _, outMetadata := range out {
for _, md := range outMetadata {
// FullPath is set by ReadAllMetadata.
c.Assert(md.FullPath, gc.Not(gc.Equals), "")
md.FullPath = ""
}
}
c.Assert(out, jc.DeepEquals, metadata)
}
func (*metadataHelperSuite) TestReadWriteMetadataSingleStream(c *gc.C) {
metadata := map[string][]*tools.ToolsMetadata{
"released": {{
Release: "precise",
Version: "1.2.3",
Arch: "amd64",
Path: "path1",
}, {
Release: "raring",
Version: "1.2.3",
Arch: "amd64",
Path: "path2",
}},
}
stor, err := filestorage.NewFileStorageWriter(c.MkDir())
c.Assert(err, jc.ErrorIsNil)
out, err := tools.ReadAllMetadata(stor)
c.Assert(err, jc.ErrorIsNil) // non-existence is not an error
c.Assert(out, gc.HasLen, 0)
err = tools.WriteMetadata(stor, metadata, []string{"released"}, tools.DoNotWriteMirrors)
c.Assert(err, jc.ErrorIsNil)
// Read back what was just written.
out, err = tools.ReadAllMetadata(stor)
c.Assert(err, jc.ErrorIsNil)
for _, outMetadata := range out {
for _, md := range outMetadata {
// FullPath is set by ReadAllMetadata.
c.Assert(md.FullPath, gc.Not(gc.Equals), "")
md.FullPath = ""
}
}
c.Assert(out, jc.DeepEquals, metadata)
}
func (*metadataHelperSuite) writeMetadataMultipleStream(c *gc.C) (storage.StorageReader, map[string][]*tools.ToolsMetadata) {
metadata := map[string][]*tools.ToolsMetadata{
"released": {{
Release: "precise",
Version: "1.2.3",
Arch: "amd64",
Path: "path1",
}},
"proposed": {{
Release: "raring",
Version: "1.2.3",
Arch: "amd64",
Path: "path2",
}},
}
stor, err := filestorage.NewFileStorageWriter(c.MkDir())
c.Assert(err, jc.ErrorIsNil)
out, err := tools.ReadAllMetadata(stor)
c.Assert(out, gc.HasLen, 0)
c.Assert(err, jc.ErrorIsNil) // non-existence is not an error
err = tools.WriteMetadata(stor, metadata, []string{"released", "proposed"}, tools.DoNotWriteMirrors)
c.Assert(err, jc.ErrorIsNil)
return stor, metadata
}
func (*metadataHelperSuite) TestReadWriteMetadata(c *gc.C) {
metadata := []*tools.ToolsMetadata{{
Release: "precise",
Version: "1.2.3",
Arch: "amd64",
Path: "path1",
}, {
Release: "raring",
Version: "1.2.3",
Arch: "amd64",
Path: "path2",
}}
stor, err := filestorage.NewFileStorageWriter(c.MkDir())
c.Assert(err, gc.IsNil)
out, err := tools.ReadMetadata(stor)
c.Assert(out, gc.HasLen, 0)
c.Assert(err, gc.IsNil) // non-existence is not an error
err = tools.WriteMetadata(stor, metadata, tools.DoNotWriteMirrors)
c.Assert(err, gc.IsNil)
out, err = tools.ReadMetadata(stor)
for _, md := range out {
// FullPath is set by ReadMetadata.
c.Assert(md.FullPath, gc.Not(gc.Equals), "")
md.FullPath = ""
}
c.Assert(out, gc.DeepEquals, metadata)
}
// This is essentially the same as tools.MergeAndWriteMetadata, but also
// resolves metadata for existing tools by fetching them and computing
// size/sha256 locally.
func mergeAndWriteMetadata(stor storage.Storage, toolsList coretools.List, writeMirrors envtools.ShouldWriteMirrors) error {
existing, err := envtools.ReadMetadata(stor)
if err != nil {
return err
}
metadata := envtools.MetadataFromTools(toolsList)
if metadata, err = envtools.MergeMetadata(metadata, existing); err != nil {
return err
}
if err = envtools.ResolveMetadata(stor, metadata); err != nil {
return err
}
return envtools.WriteMetadata(stor, metadata, writeMirrors)
}
func (s *ValidateToolsMetadataSuite) makeLocalMetadata(c *gc.C, version, region, series, endpoint string) error {
tm := []*tools.ToolsMetadata{{
Version: version,
Arch: "amd64",
Release: series,
}}
targetStorage, err := filestorage.NewFileStorageWriter(s.metadataDir)
c.Assert(err, gc.IsNil)
err = tools.WriteMetadata(targetStorage, tm, false)
if err != nil {
return err
}
return nil
}
func (s *ValidateToolsMetadataSuite) makeLocalMetadata(c *gc.C, stream, version, region, series, endpoint string) error {
tm := []*tools.ToolsMetadata{{
Version: version,
Arch: arch.HostArch(),
Release: series,
}}
targetStorage, err := filestorage.NewFileStorageWriter(s.metadataDir)
c.Assert(err, jc.ErrorIsNil)
streamMetadata := map[string][]*tools.ToolsMetadata{
stream: tm,
}
err = tools.WriteMetadata(targetStorage, streamMetadata, []string{stream}, false)
if err != nil {
return err
}
return nil
}
// This is essentially the same as tools.MergeAndWriteMetadata, but also
// resolves metadata for existing tools by fetching them and computing
// size/sha256 locally.
func mergeAndWriteMetadata(
stor storage.Storage, toolsDir, stream string, clean bool, toolsList coretools.List, writeMirrors envtools.ShouldWriteMirrors,
) error {
existing, err := envtools.ReadAllMetadata(stor)
if err != nil {
return err
}
if clean {
delete(existing, stream)
}
metadata := envtools.MetadataFromTools(toolsList, toolsDir)
var mergedMetadata []*envtools.ToolsMetadata
if mergedMetadata, err = envtools.MergeMetadata(metadata, existing[stream]); err != nil {
return err
}
if err = envtools.ResolveMetadata(stor, toolsDir, mergedMetadata); err != nil {
return err
}
existing[stream] = mergedMetadata
return envtools.WriteMetadata(stor, existing, []string{stream}, writeMirrors)
}