func (s *BootstrapSuite) testToolsMetadata(c *gc.C, exploded bool) {
provider, err := environs.Provider(s.envcfg.Type())
c.Assert(err, gc.IsNil)
env, err := provider.Open(s.envcfg)
c.Assert(err, gc.IsNil)
oldMetadata, err := envtools.ReadMetadata(env.Storage())
c.Assert(err, gc.IsNil)
_, cmd, err := s.initBootstrapCommand(c, nil, "--env-config", s.b64yamlEnvcfg, "--instance-id", string(s.instanceId))
c.Assert(err, gc.IsNil)
err = cmd.Run(nil)
c.Assert(err, gc.IsNil)
newMetadata, err := envtools.ReadMetadata(env.Storage())
c.Assert(err, gc.IsNil)
if !exploded {
c.Assert(newMetadata, gc.HasLen, len(oldMetadata))
} else {
// new metadata should have more tools.
c.Assert(len(newMetadata), jc.GreaterThan, len(oldMetadata))
var expectedSeries set.Strings
for _, series := range version.SupportedSeries() {
os, err := version.GetOSFromSeries(series)
c.Assert(err, gc.IsNil)
if os == version.Ubuntu {
expectedSeries.Add(series)
}
}
c.Assert(newMetadata, gc.HasLen, expectedSeries.Size())
for _, m := range newMetadata {
c.Assert(expectedSeries.Contains(m.Release), jc.IsTrue)
}
}
}
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)
}
func (s *BootstrapSuite) testToolsMetadata(c *gc.C, exploded bool) {
envtesting.RemoveFakeToolsMetadata(c, s.toolsStorage)
_, cmd, err := s.initBootstrapCommand(c, nil,
"--model-config", s.b64yamlControllerModelConfig,
"--hosted-model-config", s.b64yamlHostedModelConfig,
"--instance-id", string(s.instanceId),
)
c.Assert(err, jc.ErrorIsNil)
err = cmd.Run(nil)
c.Assert(err, jc.ErrorIsNil)
// We don't write metadata at bootstrap anymore.
simplestreamsMetadata, err := envtools.ReadMetadata(s.toolsStorage, "released")
c.Assert(err, jc.ErrorIsNil)
c.Assert(simplestreamsMetadata, gc.HasLen, 0)
// The tools should have been added to tools storage, and
// exploded into each of the supported series of
// the same operating system if the tools were uploaded.
st, err := state.Open(testing.ModelTag, &mongo.MongoInfo{
Info: mongo.Info{
Addrs: []string{gitjujutesting.MgoServer.Addr()},
CACert: testing.CACert,
},
Password: testPassword,
}, mongotest.DialOpts(), environs.NewStatePolicy())
c.Assert(err, jc.ErrorIsNil)
defer st.Close()
expectedSeries := make(set.Strings)
if exploded {
for _, ser := range series.SupportedSeries() {
os, err := series.GetOSFromSeries(ser)
c.Assert(err, jc.ErrorIsNil)
hostos, err := series.GetOSFromSeries(series.HostSeries())
c.Assert(err, jc.ErrorIsNil)
if os == hostos {
expectedSeries.Add(ser)
}
}
} else {
expectedSeries.Add(series.HostSeries())
}
storage, err := st.ToolsStorage()
c.Assert(err, jc.ErrorIsNil)
defer storage.Close()
metadata, err := storage.AllMetadata()
c.Assert(err, jc.ErrorIsNil)
c.Assert(metadata, gc.HasLen, expectedSeries.Size())
for _, m := range metadata {
v := version.MustParseBinary(m.Version)
c.Assert(expectedSeries.Contains(v.Series), jc.IsTrue)
}
}
func (s *BootstrapSuite) testToolsMetadata(c *gc.C, exploded bool) {
provider, err := environs.Provider(s.envcfg.Type())
c.Assert(err, gc.IsNil)
env, err := provider.Open(s.envcfg)
c.Assert(err, gc.IsNil)
envtesting.RemoveFakeToolsMetadata(c, env.Storage())
_, cmd, err := s.initBootstrapCommand(c, nil, "--env-config", s.b64yamlEnvcfg, "--instance-id", string(s.instanceId))
c.Assert(err, gc.IsNil)
err = cmd.Run(nil)
c.Assert(err, gc.IsNil)
// We don't write metadata at bootstrap anymore.
simplestreamsMetadata, err := envtools.ReadMetadata(env.Storage())
c.Assert(err, gc.IsNil)
c.Assert(simplestreamsMetadata, gc.HasLen, 0)
// The tools should have been added to state, and
// exploded into each of the supported series of
// the same operating system if the tools were uploaded.
st, err := state.Open(&mongo.MongoInfo{
Info: mongo.Info{
Addrs: []string{gitjujutesting.MgoServer.Addr()},
CACert: testing.CACert,
},
Password: testPasswordHash(),
}, mongo.DefaultDialOpts(), environs.NewStatePolicy())
c.Assert(err, gc.IsNil)
defer st.Close()
var expectedSeries set.Strings
if exploded {
for _, series := range version.SupportedSeries() {
os, err := version.GetOSFromSeries(series)
c.Assert(err, gc.IsNil)
if os == version.Current.OS {
expectedSeries.Add(series)
}
}
} else {
expectedSeries.Add(version.Current.Series)
}
storage, err := st.ToolsStorage()
c.Assert(err, gc.IsNil)
defer storage.Close()
metadata, err := storage.AllMetadata()
c.Assert(err, gc.IsNil)
c.Assert(metadata, gc.HasLen, expectedSeries.Size())
for _, m := range metadata {
c.Assert(expectedSeries.Contains(m.Version.Series), jc.IsTrue)
}
}
// 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 *uploadSuite) assertUploadedTools(c *gc.C, t *coretools.Tools, expectSeries []string, stream string) {
s.assertEqualsCurrentVersion(c, t.Version)
expectRaw := downloadToolsRaw(c, t)
list, err := envtools.ReadList(s.targetStorage, stream, jujuversion.Current.Major, jujuversion.Current.Minor)
c.Assert(err, jc.ErrorIsNil)
c.Assert(list.AllSeries(), jc.SameContents, expectSeries)
sort.Strings(expectSeries)
c.Assert(list.AllSeries(), gc.DeepEquals, expectSeries)
for _, t := range list {
c.Logf("checking %s", t.URL)
c.Assert(t.Version.Number, gc.Equals, jujuversion.Current)
actualRaw := downloadToolsRaw(c, t)
c.Assert(string(actualRaw), gc.Equals, string(expectRaw))
}
metadata, err := envtools.ReadMetadata(s.targetStorage, stream)
c.Assert(err, jc.ErrorIsNil)
c.Assert(metadata, gc.HasLen, 0)
}
func (s *uploadSuite) assertUploadedTools(c *gc.C, t *coretools.Tools, uploadedSeries string) {
c.Assert(t.Version, gc.Equals, version.Current)
expectRaw := downloadToolsRaw(c, t)
list, err := envtools.ReadList(s.env.Storage(), version.Current.Major, version.Current.Minor)
c.Assert(err, gc.IsNil)
c.Assert(list, gc.HasLen, 3)
expectSeries := []string{"quantal", uploadedSeries, version.Current.Series}
sort.Strings(expectSeries)
c.Assert(list.AllSeries(), gc.DeepEquals, expectSeries)
for _, t := range list {
c.Logf("checking %s", t.URL)
c.Assert(t.Version.Number, gc.Equals, version.Current.Number)
actualRaw := downloadToolsRaw(c, t)
c.Assert(string(actualRaw), gc.Equals, string(expectRaw))
}
metadata, err := envtools.ReadMetadata(s.env.Storage())
c.Assert(err, gc.IsNil)
c.Assert(metadata, gc.HasLen, 0)
}