func (s *syncSuite) setUpTest(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("issue 1403084: Currently does not work because of jujud problems")
}
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.ToolsFixture.SetUpTest(c)
// It's important that this be v1.8.x to match the test data.
s.PatchValue(&jujuversion.Current, version.MustParse("1.8.3"))
// Create a source storage.
baseDir := c.MkDir()
stor, err := filestorage.NewFileStorageWriter(baseDir)
c.Assert(err, jc.ErrorIsNil)
s.storage = stor
// Create a local tools directory.
s.localStorage = c.MkDir()
// Populate both local and default tools locations with the public tools.
versionStrings := make([]string, len(vAll))
for i, vers := range vAll {
versionStrings[i] = vers.String()
}
toolstesting.MakeTools(c, baseDir, "released", versionStrings)
toolstesting.MakeTools(c, s.localStorage, "released", versionStrings)
// Switch the default tools location.
baseURL, err := s.storage.URL(storage.BaseToolsPath)
c.Assert(err, jc.ErrorIsNil)
s.PatchValue(&envtools.DefaultBaseURL, baseURL)
}
func (s *ToolsMetadataSuite) TestGenerateWithMirrors(c *gc.C) {
metadataDir := c.MkDir()
toolstesting.MakeTools(c, metadataDir, "released", versionStrings)
ctx := coretesting.Context(c)
code := cmd.Main(newToolsMetadataCommand(), ctx, []string{"--public", "-d", metadataDir, "--stream", "released"})
c.Assert(code, gc.Equals, 0)
output := ctx.Stdout.(*bytes.Buffer).String()
mirrosTmpl := expectedOutputCommon + `
.*Writing tools/streams/v1/index2\.json
.*Writing tools/streams/v1/index\.json
.*Writing tools/streams/v1/com\.ubuntu\.juju-{{.Stream}}-tools\.json
.*Writing tools/streams/v1/mirrors\.json
`
expectedOutput := makeExpectedOutput(mirrosTmpl, "released", "released")
c.Check(output, gc.Matches, expectedOutput)
metadata := toolstesting.ParseMetadataFromDir(c, metadataDir, "released", true)
c.Check(metadata, gc.HasLen, len(versionStrings))
obtainedVersionStrings := make([]string, len(versionStrings))
for i, metadata := range metadata {
s := fmt.Sprintf("%s-%s-%s", metadata.Version, metadata.Release, metadata.Arch)
obtainedVersionStrings[i] = s
}
c.Assert(obtainedVersionStrings, gc.DeepEquals, versionStrings)
}
func (*metadataHelperSuite) TestResolveMetadata(c *gc.C) {
var versionStrings = []string{"1.2.3-precise-amd64"}
dir := c.MkDir()
toolstesting.MakeTools(c, dir, "released", versionStrings)
toolsList := coretools.List{{
Version: version.MustParseBinary(versionStrings[0]),
Size: 123,
SHA256: "abc",
}}
stor, err := filestorage.NewFileStorageReader(dir)
c.Assert(err, jc.ErrorIsNil)
err = tools.ResolveMetadata(stor, "released", nil)
c.Assert(err, jc.ErrorIsNil)
// We already have size/sha256, so ensure that storage isn't consulted.
countingStorage := &countingStorage{StorageReader: stor}
metadata := tools.MetadataFromTools(toolsList, "released")
err = tools.ResolveMetadata(countingStorage, "released", metadata)
c.Assert(err, jc.ErrorIsNil)
c.Assert(countingStorage.counter, gc.Equals, 0)
// Now clear size/sha256, and check that it is called, and
// the size/sha256 sum are updated.
metadata[0].Size = 0
metadata[0].SHA256 = ""
err = tools.ResolveMetadata(countingStorage, "released", metadata)
c.Assert(err, jc.ErrorIsNil)
c.Assert(countingStorage.counter, gc.Equals, 1)
c.Assert(metadata[0].Size, gc.Not(gc.Equals), 0)
c.Assert(metadata[0].SHA256, gc.Not(gc.Equals), "")
}
func (s *simplestreamsSuite) assertWriteMetadata(c *gc.C, withMirrors bool) {
var versionStrings = []string{
"1.2.3-precise-amd64",
"2.0.1-raring-amd64",
}
dir := c.MkDir()
toolstesting.MakeTools(c, dir, "proposed", versionStrings)
toolsList := coretools.List{
{
// If sha256/size is already known, do not recalculate
Version: version.MustParseBinary("1.2.3-precise-amd64"),
Size: 123,
SHA256: "abcd",
}, {
Version: version.MustParseBinary("2.0.1-raring-amd64"),
// The URL is not used for generating metadata.
URL: "bogus://",
},
}
writer, err := filestorage.NewFileStorageWriter(dir)
c.Assert(err, jc.ErrorIsNil)
writeMirrors := tools.DoNotWriteMirrors
if withMirrors {
writeMirrors = tools.WriteMirrors
}
err = tools.MergeAndWriteMetadata(writer, "proposed", "proposed", toolsList, writeMirrors)
c.Assert(err, jc.ErrorIsNil)
metadata := toolstesting.ParseMetadataFromDir(c, dir, "proposed", withMirrors)
assertMetadataMatches(c, dir, "proposed", toolsList, metadata)
// No release stream generated so there will not be a legacy index file created.
_, err = writer.Get("tools/streams/v1/index.json")
c.Assert(err, gc.NotNil)
}
// createToolsSource writes the mock tools and metadata into a temporary
// directory and returns it.
func createToolsSource(c *gc.C, versions []version.Binary) string {
versionStrings := make([]string, len(versions))
for i, vers := range versions {
versionStrings[i] = vers.String()
}
source := c.MkDir()
toolstesting.MakeTools(c, source, "released", versionStrings)
return source
}
func (s *syncSuite) setUpTest(c *gc.C) {
s.FakeJujuHomeSuite.SetUpTest(c)
s.ToolsFixture.SetUpTest(c)
s.origVersion = version.Current
// It's important that this be v1.8.x to match the test data.
version.Current.Number = version.MustParse("1.8.3")
// Create a target environments.yaml.
envConfig := `
environments:
test-target:
type: dummy
state-server: false
authorized-keys: "not-really-one"
`
coretesting.WriteEnvironments(c, envConfig)
var err error
s.targetEnv, err = environs.PrepareFromName("test-target", coretesting.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
envtesting.RemoveAllTools(c, s.targetEnv)
// Create a source storage.
baseDir := c.MkDir()
stor, err := filestorage.NewFileStorageWriter(baseDir)
c.Assert(err, gc.IsNil)
s.storage = stor
// Create a local tools directory.
s.localStorage = c.MkDir()
// Populate both local and default tools locations with the public tools.
versionStrings := make([]string, len(vAll))
for i, vers := range vAll {
versionStrings[i] = vers.String()
}
toolstesting.MakeTools(c, baseDir, "releases", versionStrings)
toolstesting.MakeTools(c, s.localStorage, "releases", versionStrings)
// Switch the default tools location.
baseURL, err := s.storage.URL(storage.BaseToolsPath)
c.Assert(err, gc.IsNil)
s.PatchValue(&envtools.DefaultBaseURL, baseURL)
}
func (a *fakeUpgradeJujuAPI) FindTools(majorVersion, minorVersion int, series, arch string) (
result params.FindToolsResult, err error,
) {
a.findToolsCalled = true
a.tools = append(a.tools, a.nextVersion.String())
tools := toolstesting.MakeTools(a.c, a.c.MkDir(), "released", a.tools)
return params.FindToolsResult{
List: tools,
Error: nil,
}, nil
}
func (s *ToolsMetadataSuite) TestGenerateDeleteExisting(c *gc.C) {
metadataDir := c.MkDir()
toolstesting.MakeTools(c, metadataDir, "proposed", versionStrings)
toolstesting.MakeTools(c, metadataDir, "released", currentVersionStrings)
ctx := coretesting.Context(c)
code := cmd.Main(envcmd.Wrap(&ToolsMetadataCommand{}), ctx, []string{"-d", metadataDir, "--stream", "proposed"})
c.Assert(code, gc.Equals, 0)
code = cmd.Main(envcmd.Wrap(&ToolsMetadataCommand{}), ctx, []string{"-d", metadataDir, "--stream", "released"})
c.Assert(code, gc.Equals, 0)
// Remove existing proposed tarballs, and create some different ones.
err := os.RemoveAll(filepath.Join(metadataDir, "tools", "proposed"))
c.Assert(err, jc.ErrorIsNil)
toolstesting.MakeTools(c, metadataDir, "proposed", currentVersionStrings)
// Generate proposed metadata again, using --clean.
code = cmd.Main(envcmd.Wrap(&ToolsMetadataCommand{}), ctx, []string{"-d", metadataDir, "--stream", "proposed", "--clean"})
c.Assert(code, gc.Equals, 0)
// Proposed metadata should just list the tarballs that were there, not the merged set.
metadata := toolstesting.ParseMetadataFromDir(c, metadataDir, "proposed", false)
c.Assert(metadata, gc.HasLen, len(currentVersionStrings))
obtainedVersionStrings := make([]string, len(currentVersionStrings))
for i, metadata := range metadata {
s := fmt.Sprintf("%s-%s-%s", metadata.Version, metadata.Release, metadata.Arch)
obtainedVersionStrings[i] = s
}
c.Assert(obtainedVersionStrings, gc.DeepEquals, currentVersionStrings)
// Released metadata should be untouched.
metadata = toolstesting.ParseMetadataFromDir(c, metadataDir, "released", false)
c.Assert(metadata, gc.HasLen, len(currentVersionStrings))
obtainedVersionStrings = make([]string, len(currentVersionStrings))
for i, metadata := range metadata {
s := fmt.Sprintf("%s-%s-%s", metadata.Version, metadata.Release, metadata.Arch)
obtainedVersionStrings[i] = s
}
c.Assert(obtainedVersionStrings, gc.DeepEquals, currentVersionStrings)
}
func (s *ToolsMetadataSuite) TestPatchLevels(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("Skipping on windows, test only set up for Linux tools")
}
currentVersion := jujuversion.Current
currentVersion.Build = 0
versionStrings := []string{
currentVersion.String() + "-precise-amd64",
currentVersion.String() + ".1-precise-amd64",
}
metadataDir := osenv.JujuXDGDataHomeDir() // default metadata dir
toolstesting.MakeTools(c, metadataDir, "released", versionStrings)
ctx := coretesting.Context(c)
code := cmd.Main(newToolsMetadataCommand(), ctx, []string{"--stream", "released"})
c.Assert(code, gc.Equals, 0)
output := ctx.Stdout.(*bytes.Buffer).String()
expectedOutput := fmt.Sprintf(`
Finding tools in .*
.*Fetching tools from dir "released" to generate hash: %s
.*Fetching tools from dir "released" to generate hash: %s
.*Writing tools/streams/v1/index2\.json
.*Writing tools/streams/v1/index\.json
.*Writing tools/streams/v1/com\.ubuntu\.juju-released-tools\.json
`[1:], regexp.QuoteMeta(versionStrings[0]), regexp.QuoteMeta(versionStrings[1]))
c.Assert(output, gc.Matches, expectedOutput)
metadata := toolstesting.ParseMetadataFromDir(c, metadataDir, "released", false)
c.Assert(metadata, gc.HasLen, 2)
filename := fmt.Sprintf("juju-%s-precise-amd64.tgz", currentVersion)
size, sha256 := toolstesting.SHA256sum(c, filepath.Join(metadataDir, "tools", "released", filename))
c.Assert(metadata[0], gc.DeepEquals, &tools.ToolsMetadata{
Release: "precise",
Version: currentVersion.String(),
Arch: "amd64",
Size: size,
Path: "released/" + filename,
FileType: "tar.gz",
SHA256: sha256,
})
filename = fmt.Sprintf("juju-%s.1-precise-amd64.tgz", currentVersion)
size, sha256 = toolstesting.SHA256sum(c, filepath.Join(metadataDir, "tools", "released", filename))
c.Assert(metadata[1], gc.DeepEquals, &tools.ToolsMetadata{
Release: "precise",
Version: currentVersion.String() + ".1",
Arch: "amd64",
Size: size,
Path: "released/" + filename,
FileType: "tar.gz",
SHA256: sha256,
})
}
func (s *ToolsMetadataSuite) TestGenerateMultipleStreams(c *gc.C) {
metadataDir := c.MkDir()
toolstesting.MakeTools(c, metadataDir, "proposed", versionStrings)
toolstesting.MakeTools(c, metadataDir, "released", currentVersionStrings)
ctx := coretesting.Context(c)
code := cmd.Main(envcmd.Wrap(&ToolsMetadataCommand{}), ctx, []string{"-d", metadataDir, "--stream", "proposed"})
c.Assert(code, gc.Equals, 0)
code = cmd.Main(envcmd.Wrap(&ToolsMetadataCommand{}), ctx, []string{"-d", metadataDir, "--stream", "released"})
c.Assert(code, gc.Equals, 0)
metadata := toolstesting.ParseMetadataFromDir(c, metadataDir, "proposed", false)
c.Assert(metadata, gc.HasLen, len(versionStrings))
obtainedVersionStrings := make([]string, len(versionStrings))
for i, metadata := range metadata {
s := fmt.Sprintf("%s-%s-%s", metadata.Version, metadata.Release, metadata.Arch)
obtainedVersionStrings[i] = s
}
c.Assert(obtainedVersionStrings, gc.DeepEquals, versionStrings)
metadata = toolstesting.ParseMetadataFromDir(c, metadataDir, "released", false)
c.Assert(metadata, gc.HasLen, len(currentVersionStrings))
obtainedVersionStrings = make([]string, len(currentVersionStrings))
for i, metadata := range metadata {
s := fmt.Sprintf("%s-%s-%s", metadata.Version, metadata.Release, metadata.Arch)
obtainedVersionStrings[i] = s
}
c.Assert(obtainedVersionStrings, gc.DeepEquals, currentVersionStrings)
toolstesting.MakeTools(c, metadataDir, "released", versionStrings)
metadata = toolstesting.ParseMetadataFromDir(c, metadataDir, "released", false)
c.Assert(metadata, gc.HasLen, len(versionStrings))
obtainedVersionStrings = make([]string, len(versionStrings))
for i, metadata := range metadata {
s := fmt.Sprintf("%s-%s-%s", metadata.Version, metadata.Release, metadata.Arch)
obtainedVersionStrings[i] = s
}
c.Assert(obtainedVersionStrings, gc.DeepEquals, versionStrings)
}
func (*metadataHelperSuite) TestResolveMetadataLegacyPPC64(c *gc.C) {
var versionStrings = []string{"1.2.3-precise-amd64", "1.2.3-precise-ppc64el"}
dir := c.MkDir()
toolstesting.MakeTools(c, dir, "released", versionStrings)
toolsList := coretools.List{
{
Version: version.MustParseBinary(versionStrings[0]),
}, {
Version: version.MustParseBinary(versionStrings[1]),
}, {
Version: version.MustParseBinary("1.2.3-precise-ppc64"),
},
}
toolsMetadata := tools.MetadataFromTools(toolsList, dir)
stor, err := filestorage.NewFileStorageReader(dir)
c.Assert(err, jc.ErrorIsNil)
err = tools.ResolveMetadata(stor, "released", toolsMetadata)
c.Assert(err, jc.ErrorIsNil)
c.Assert(toolsMetadata, gc.DeepEquals, []*tools.ToolsMetadata{
{
Release: "precise",
Version: "1.2.3",
Arch: "amd64",
Size: 19,
FileType: "tar.gz",
SHA256: "dcdd65b962b804a3d63b108d670290ee95a867a97fe9b9f99b2b77b5c7173e59",
Path: fmt.Sprintf("%s/juju-1.2.3-precise-amd64.tgz", dir),
},
{
Release: "precise",
Version: "1.2.3",
Arch: "ppc64el",
Size: 21,
FileType: "tar.gz",
SHA256: "a3460ed45eb07a69adfcd541413a495f988c5842d715c6a40353075c3ad47af2",
Path: fmt.Sprintf("%s/juju-1.2.3-precise-ppc64el.tgz", dir),
},
{
Release: "precise",
Version: "1.2.3",
Arch: "ppc64",
Size: 21,
FileType: "tar.gz",
SHA256: "a3460ed45eb07a69adfcd541413a495f988c5842d715c6a40353075c3ad47af2",
Path: fmt.Sprintf("%s/juju-1.2.3-precise-ppc64el.tgz", dir),
},
})
}
func (s *ToolsMetadataSuite) TestPatchLevels(c *gc.C) {
currentVersion := version.Current.Number
currentVersion.Build = 0
versionStrings := []string{
currentVersion.String() + "-precise-amd64",
currentVersion.String() + ".1-precise-amd64",
}
metadataDir := osenv.JujuHome() // default metadata dir
toolstesting.MakeTools(c, metadataDir, "releases", versionStrings)
ctx := coretesting.Context(c)
code := cmd.Main(envcmd.Wrap(&ToolsMetadataCommand{}), ctx, nil)
c.Assert(code, gc.Equals, 0)
output := ctx.Stdout.(*bytes.Buffer).String()
expectedOutput := fmt.Sprintf(`
Finding tools in .*
.*Fetching tools to generate hash: %s
.*Fetching tools to generate hash: %s
.*Writing tools/streams/v1/index\.json
.*Writing tools/streams/v1/com\.ubuntu\.juju:released:tools\.json
`[1:], regexp.QuoteMeta(versionStrings[0]), regexp.QuoteMeta(versionStrings[1]))
c.Assert(output, gc.Matches, expectedOutput)
metadata := toolstesting.ParseMetadataFromDir(c, metadataDir, false)
c.Assert(metadata, gc.HasLen, 2)
filename := fmt.Sprintf("juju-%s-precise-amd64.tgz", currentVersion)
size, sha256 := toolstesting.SHA256sum(c, filepath.Join(metadataDir, "tools", "releases", filename))
c.Assert(metadata[0], gc.DeepEquals, &tools.ToolsMetadata{
Release: "precise",
Version: currentVersion.String(),
Arch: "amd64",
Size: size,
Path: "releases/" + filename,
FileType: "tar.gz",
SHA256: sha256,
})
filename = fmt.Sprintf("juju-%s.1-precise-amd64.tgz", currentVersion)
size, sha256 = toolstesting.SHA256sum(c, filepath.Join(metadataDir, "tools", "releases", filename))
c.Assert(metadata[1], gc.DeepEquals, &tools.ToolsMetadata{
Release: "precise",
Version: currentVersion.String() + ".1",
Arch: "amd64",
Size: size,
Path: "releases/" + filename,
FileType: "tar.gz",
SHA256: sha256,
})
}
func (s *ToolsMetadataSuite) TestGenerateWithMirrors(c *gc.C) {
metadataDir := c.MkDir()
toolstesting.MakeTools(c, metadataDir, "released", versionStrings)
ctx := coretesting.Context(c)
code := cmd.Main(envcmd.Wrap(&ToolsMetadataCommand{}), ctx, []string{"--public", "-d", metadataDir, "--stream", "released"})
c.Assert(code, gc.Equals, 0)
output := ctx.Stdout.(*bytes.Buffer).String()
c.Assert(output, gc.Matches, expectedOutputMirrorsReleased)
metadata := toolstesting.ParseMetadataFromDir(c, metadataDir, "released", true)
c.Assert(metadata, gc.HasLen, len(versionStrings))
obtainedVersionStrings := make([]string, len(versionStrings))
for i, metadata := range metadata {
s := fmt.Sprintf("%s-%s-%s", metadata.Version, metadata.Release, metadata.Arch)
obtainedVersionStrings[i] = s
}
c.Assert(obtainedVersionStrings, gc.DeepEquals, versionStrings)
}
func (s *ToolsMetadataSuite) TestGenerateLegacyRelease(c *gc.C) {
metadataDir := osenv.JujuHome() // default metadata dir
toolstesting.MakeTools(c, metadataDir, "releases", versionStrings)
ctx := coretesting.Context(c)
code := cmd.Main(envcmd.Wrap(&ToolsMetadataCommand{}), ctx, nil)
c.Assert(code, gc.Equals, 0)
output := ctx.Stdout.(*bytes.Buffer).String()
c.Assert(output, gc.Matches, expectedOutputDirectoryLegacyReleased)
metadata := toolstesting.ParseMetadataFromDir(c, metadataDir, "released", false)
c.Assert(metadata, gc.HasLen, len(versionStrings))
obtainedVersionStrings := make([]string, len(versionStrings))
for i, metadata := range metadata {
s := fmt.Sprintf("%s-%s-%s", metadata.Version, metadata.Release, metadata.Arch)
obtainedVersionStrings[i] = s
}
c.Assert(obtainedVersionStrings, gc.DeepEquals, versionStrings)
}
func (s *ToolsMetadataSuite) TestGenerateStream(c *gc.C) {
metadataDir := c.MkDir()
toolstesting.MakeTools(c, metadataDir, "proposed", versionStrings)
ctx := coretesting.Context(c)
code := cmd.Main(newToolsMetadataCommand(), ctx, []string{"-d", metadataDir, "--stream", "proposed"})
c.Assert(code, gc.Equals, 0)
output := ctx.Stdout.(*bytes.Buffer).String()
c.Assert(output, gc.Matches, makeExpectedOutput(expectedOutputDirectoryTemplate, "proposed", "proposed"))
metadata := toolstesting.ParseMetadataFromDir(c, metadataDir, "proposed", false)
c.Assert(metadata, gc.HasLen, len(versionStrings))
obtainedVersionStrings := make([]string, len(versionStrings))
for i, metadata := range metadata {
s := fmt.Sprintf("%s-%s-%s", metadata.Version, metadata.Release, metadata.Arch)
obtainedVersionStrings[i] = s
}
c.Assert(obtainedVersionStrings, gc.DeepEquals, versionStrings)
}
