func (s *BootstrapSuite) TestAutoUploadAfterFailedSync(c *gc.C) {
s.PatchValue(&version.Current.Series, config.LatestLtsSeries())
otherSeries := "quantal"
env := s.setupAutoUploadTest(c, "1.7.3", otherSeries)
// Run command and check for that upload has been run for tools matching the current juju version.
opc, errc := runCommand(nullContext(c), new(BootstrapCommand))
c.Assert(<-errc, gc.IsNil)
c.Assert((<-opc).(dummy.OpPutFile).Env, gc.Equals, "peckham")
list, err := envtools.FindTools(env, version.Current.Major, version.Current.Minor, coretools.Filter{}, false)
c.Assert(err, gc.IsNil)
c.Logf("found: " + list.String())
urls := list.URLs()
// We expect:
// supported LTS series precise, trusty,
// the specified series (quantal),
// and the environment's default series (raring).
expectedVers := []version.Binary{
version.MustParseBinary(fmt.Sprintf("1.7.3.1-%s-%s", "quantal", version.Current.Arch)),
version.MustParseBinary(fmt.Sprintf("1.7.3.1-%s-%s", "raring", version.Current.Arch)),
version.MustParseBinary(fmt.Sprintf("1.7.3.1-%s-%s", "precise", version.Current.Arch)),
version.MustParseBinary(fmt.Sprintf("1.7.3.1-%s-%s", "trusty", version.Current.Arch)),
}
c.Assert(urls, gc.HasLen, len(expectedVers))
for _, vers := range expectedVers {
c.Logf("seeking: " + vers.String())
_, found := urls[vers]
c.Check(found, gc.Equals, true)
}
}
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()
ttesting.MakeTools(c, dir, "releases", 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, gc.IsNil)
writeMirrors := tools.DoNotWriteMirrors
if withMirrors {
writeMirrors = tools.WriteMirrors
}
err = tools.MergeAndWriteMetadata(writer, toolsList, writeMirrors)
c.Assert(err, gc.IsNil)
metadata := ttesting.ParseMetadataFromDir(c, dir, withMirrors)
assertMetadataMatches(c, dir, toolsList, metadata)
}
func (*metadataHelperSuite) TestMetadataFromTools(c *gc.C) {
metadata := tools.MetadataFromTools(nil)
c.Assert(metadata, gc.HasLen, 0)
toolsList := coretools.List{{
Version: version.MustParseBinary("1.2.3-precise-amd64"),
Size: 123,
SHA256: "abc",
}, {
Version: version.MustParseBinary("2.0.1-raring-amd64"),
URL: "file:///tmp/releases/juju-2.0.1-raring-amd64.tgz",
Size: 456,
SHA256: "xyz",
}}
metadata = tools.MetadataFromTools(toolsList)
c.Assert(metadata, gc.HasLen, len(toolsList))
for i, t := range toolsList {
md := metadata[i]
c.Assert(md.Release, gc.Equals, t.Version.Series)
c.Assert(md.Version, gc.Equals, t.Version.Number.String())
c.Assert(md.Arch, gc.Equals, t.Version.Arch)
// FullPath is only filled out when reading tools using simplestreams.
// It's not needed elsewhere and requires a URL() call.
c.Assert(md.FullPath, gc.Equals, "")
c.Assert(md.Path, gc.Equals, tools.StorageName(t.Version)[len("tools/"):])
c.Assert(md.FileType, gc.Equals, "tar.gz")
c.Assert(md.Size, gc.Equals, t.Size)
c.Assert(md.SHA256, gc.Equals, t.SHA256)
}
}
func (s *simplestreamsSuite) TestWriteMetadataMergeWithExisting(c *gc.C) {
dir := c.MkDir()
existingToolsList := coretools.List{
{
Version: version.MustParseBinary("1.2.3-precise-amd64"),
Size: 123,
SHA256: "abc",
}, {
Version: version.MustParseBinary("2.0.1-raring-amd64"),
Size: 456,
SHA256: "xyz",
},
}
writer, err := filestorage.NewFileStorageWriter(dir)
c.Assert(err, gc.IsNil)
err = tools.MergeAndWriteMetadata(writer, existingToolsList, tools.DoNotWriteMirrors)
c.Assert(err, gc.IsNil)
newToolsList := coretools.List{
existingToolsList[0],
{
Version: version.MustParseBinary("2.1.0-raring-amd64"),
Size: 789,
SHA256: "def",
},
}
err = tools.MergeAndWriteMetadata(writer, newToolsList, tools.DoNotWriteMirrors)
c.Assert(err, gc.IsNil)
requiredToolsList := append(existingToolsList, newToolsList[1])
metadata := ttesting.ParseMetadataFromDir(c, dir, false)
assertMetadataMatches(c, dir, requiredToolsList, metadata)
}
func (s *UpgraderSuite) TestUpgraderUpgradesImmediately(c *gc.C) {
stor := s.Conn.Environ.Storage()
oldTools := envtesting.PrimeTools(c, stor, s.DataDir(), version.MustParseBinary("5.4.3-precise-amd64"))
s.PatchValue(&version.Current, oldTools.Version)
newTools := envtesting.AssertUploadFakeToolsVersions(
c, stor, version.MustParseBinary("5.4.5-precise-amd64"))[0]
err := statetesting.SetAgentVersion(s.State, newTools.Version.Number)
c.Assert(err, gc.IsNil)
// Make the download take a while so that we verify that
// the download happens before the upgrader checks if
// it's been stopped.
dummy.SetStorageDelay(coretesting.ShortWait)
u := s.makeUpgrader()
err = u.Stop()
envtesting.CheckUpgraderReadyError(c, err, &upgrader.UpgradeReadyError{
AgentName: s.machine.Tag(),
OldTools: oldTools.Version,
NewTools: newTools.Version,
DataDir: s.DataDir(),
})
foundTools, err := agenttools.ReadTools(s.DataDir(), newTools.Version)
c.Assert(err, gc.IsNil)
envtesting.CheckTools(c, foundTools, newTools)
}
func (s *bootstrapSuite) TestSetBootstrapTools(c *gc.C) {
availableVersions := []version.Binary{
version.MustParseBinary("1.18.0-trusty-arm64"),
version.MustParseBinary("1.18.1-trusty-arm64"),
version.MustParseBinary("1.18.1.1-trusty-arm64"),
version.MustParseBinary("1.18.1.2-trusty-arm64"),
version.MustParseBinary("1.18.1.3-trusty-arm64"),
}
availableTools := make(tools.List, len(availableVersions))
for i, v := range availableVersions {
availableTools[i] = &tools.Tools{Version: v}
}
type test struct {
currentVersion version.Number
expectedTools version.Number
expectedAgentVersion version.Number
}
tests := []test{{
currentVersion: version.MustParse("1.18.0"),
expectedTools: version.MustParse("1.18.0"),
expectedAgentVersion: version.MustParse("1.18.1.3"),
}, {
currentVersion: version.MustParse("1.18.1.4"),
expectedTools: version.MustParse("1.18.1.3"),
expectedAgentVersion: version.MustParse("1.18.1.3"),
}, {
// build number is ignored unless major/minor don't
// match the latest.
currentVersion: version.MustParse("1.18.1.2"),
expectedTools: version.MustParse("1.18.1.3"),
expectedAgentVersion: version.MustParse("1.18.1.3"),
}, {
// If the current patch level exceeds whatever's in
// the tools source (e.g. when bootstrapping from trunk)
// then the latest available tools will be chosen.
currentVersion: version.MustParse("1.18.2"),
expectedTools: version.MustParse("1.18.1.3"),
expectedAgentVersion: version.MustParse("1.18.1.3"),
}}
env := newEnviron("foo", useDefaultKeys, nil)
for i, t := range tests {
c.Logf("test %d: %+v", i, t)
cfg, err := env.Config().Remove([]string{"agent-version"})
c.Assert(err, gc.IsNil)
err = env.SetConfig(cfg)
c.Assert(err, gc.IsNil)
s.PatchValue(&version.Current.Number, t.currentVersion)
bootstrapTools, err := bootstrap.SetBootstrapTools(env, availableTools)
c.Assert(err, gc.IsNil)
c.Assert(bootstrapTools, gc.HasLen, 1)
c.Assert(bootstrapTools[0].Version.Number, gc.Equals, t.expectedTools)
agentVersion, _ := env.Config().AgentVersion()
c.Assert(agentVersion, gc.Equals, t.expectedAgentVersion)
}
}
func (s *UpgraderSuite) TestUpgraderRetryAndChanged(c *gc.C) {
stor := s.Conn.Environ.Storage()
oldTools := envtesting.PrimeTools(c, stor, s.DataDir(), version.MustParseBinary("5.4.3-precise-amd64"))
s.PatchValue(&version.Current, oldTools.Version)
newTools := envtesting.AssertUploadFakeToolsVersions(
c, stor, version.MustParseBinary("5.4.5-precise-amd64"))[0]
err := statetesting.SetAgentVersion(s.State, newTools.Version.Number)
c.Assert(err, gc.IsNil)
retryc := make(chan time.Time)
*upgrader.RetryAfter = func() <-chan time.Time {
c.Logf("replacement retry after")
return retryc
}
dummy.Poison(s.Conn.Environ.Storage(), envtools.StorageName(newTools.Version), fmt.Errorf("a non-fatal dose"))
u := s.makeUpgrader()
defer u.Stop()
for i := 0; i < 3; i++ {
select {
case retryc <- time.Now():
case <-time.After(coretesting.LongWait):
c.Fatalf("upgrader did not retry (attempt %d)", i)
}
}
// Make it upgrade to some newer tools that can be
// downloaded ok; it should stop retrying, download
// the newer tools and exit.
newerTools := envtesting.AssertUploadFakeToolsVersions(
c, s.Conn.Environ.Storage(), version.MustParseBinary("5.4.6-precise-amd64"))[0]
err = statetesting.SetAgentVersion(s.State, newerTools.Version.Number)
c.Assert(err, gc.IsNil)
s.BackingState.StartSync()
done := make(chan error)
go func() {
done <- u.Wait()
}()
select {
case err := <-done:
envtesting.CheckUpgraderReadyError(c, err, &upgrader.UpgradeReadyError{
AgentName: s.machine.Tag(),
OldTools: oldTools.Version,
NewTools: newerTools.Version,
DataDir: s.DataDir(),
})
case <-time.After(coretesting.LongWait):
c.Fatalf("upgrader did not quit after upgrading")
}
}
func (s *toolsSuite) TestUploadFakeSeries(c *gc.C) {
// Make some fake tools.
localStorage := c.MkDir()
vers := version.MustParseBinary("1.9.0-quantal-amd64")
versionStrings := []string{vers.String()}
expectedTools := ttesting.MakeToolsWithCheckSum(c, localStorage, "releases", versionStrings)
// Now try uploading them.
toolsFile := tools.StorageName(vers)
params := "?binaryVersion=" + vers.String() + "&series=precise,trusty"
resp, err := s.uploadRequest(c, s.toolsURI(c, params), true, path.Join(localStorage, toolsFile))
c.Assert(err, gc.IsNil)
// Check the response.
stor := s.Conn.Environ.Storage()
toolsURL, err := stor.URL(tools.StorageName(vers))
c.Assert(err, gc.IsNil)
expectedTools[0].URL = toolsURL
s.assertUploadResponse(c, resp, expectedTools[0])
// Check the contents.
for _, series := range []string{"precise", "quantal", "trusty"} {
toolsVersion := vers
toolsVersion.Series = series
r, err := stor.Get(tools.StorageName(toolsVersion))
c.Assert(err, gc.IsNil)
uploadedData, err := ioutil.ReadAll(r)
c.Assert(err, gc.IsNil)
expectedData, err := ioutil.ReadFile(filepath.Join(localStorage, tools.StorageName(vers)))
c.Assert(err, gc.IsNil)
c.Assert(uploadedData, gc.DeepEquals, expectedData)
}
}
func testAgentTools(c *gc.C, obj tooler, agent string) {
// object starts with zero'd tools.
t, err := obj.AgentTools()
c.Assert(t, gc.IsNil)
c.Assert(err, jc.Satisfies, errors.IsNotFound)
err = obj.SetAgentVersion(version.Binary{})
c.Assert(err, gc.ErrorMatches, fmt.Sprintf("cannot set agent version for %s: empty series or arch", agent))
v2 := version.MustParseBinary("7.8.9-foo-bar")
err = obj.SetAgentVersion(v2)
c.Assert(err, gc.IsNil)
t3, err := obj.AgentTools()
c.Assert(err, gc.IsNil)
c.Assert(t3.Version, gc.DeepEquals, v2)
err = obj.Refresh()
c.Assert(err, gc.IsNil)
t3, err = obj.AgentTools()
c.Assert(err, gc.IsNil)
c.Assert(t3.Version, gc.DeepEquals, v2)
testWhenDying(c, obj, noErr, deadErr, func() error {
return obj.SetAgentVersion(v2)
})
}
func (s *BootstrapSuite) runAllowRetriesTest(c *gc.C, test bootstrapRetryTest) {
toolsVersions := envtesting.VAll
if test.version != "" {
useVersion := strings.Replace(test.version, "%LTS%", config.LatestLtsSeries(), 1)
testVersion := version.MustParseBinary(useVersion)
s.PatchValue(&version.Current, testVersion)
if test.addVersionToSource {
toolsVersions = append([]version.Binary{}, toolsVersions...)
toolsVersions = append(toolsVersions, testVersion)
}
}
_, fake := makeEmptyFakeHome(c)
defer fake.Restore()
sourceDir := createToolsSource(c, toolsVersions)
s.PatchValue(&envtools.DefaultBaseURL, sourceDir)
var findToolsRetryValues []bool
mockFindTools := func(cloudInst environs.ConfigGetter, majorVersion, minorVersion int,
filter coretools.Filter, allowRetry bool) (list coretools.List, err error) {
findToolsRetryValues = append(findToolsRetryValues, allowRetry)
return nil, errors.NotFoundf("tools")
}
restore := envtools.TestingPatchBootstrapFindTools(mockFindTools)
defer restore()
_, errc := runCommand(nullContext(c), new(BootstrapCommand), test.args...)
err := <-errc
c.Check(findToolsRetryValues, gc.DeepEquals, test.expectedAllowRetry)
stripped := strings.Replace(err.Error(), "\n", "", -1)
c.Check(stripped, gc.Matches, test.err)
}
func (*metadataHelperSuite) TestResolveMetadata(c *gc.C) {
var versionStrings = []string{"1.2.3-precise-amd64"}
dir := c.MkDir()
ttesting.MakeTools(c, dir, "releases", versionStrings)
toolsList := coretools.List{{
Version: version.MustParseBinary(versionStrings[0]),
Size: 123,
SHA256: "abc",
}}
stor, err := filestorage.NewFileStorageReader(dir)
c.Assert(err, gc.IsNil)
err = tools.ResolveMetadata(stor, nil)
c.Assert(err, gc.IsNil)
// We already have size/sha256, so ensure that storage isn't consulted.
countingStorage := &countingStorage{StorageReader: stor}
metadata := tools.MetadataFromTools(toolsList)
err = tools.ResolveMetadata(countingStorage, metadata)
c.Assert(err, gc.IsNil)
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, metadata)
c.Assert(err, gc.IsNil)
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 makeTools(c *gc.C, metadataDir, subdir string, versionStrings []string, withCheckSum bool) coretools.List {
toolsDir := filepath.Join(metadataDir, storage.BaseToolsPath)
if subdir != "" {
toolsDir = filepath.Join(toolsDir, subdir)
}
c.Assert(os.MkdirAll(toolsDir, 0755), gc.IsNil)
var toolsList coretools.List
for _, versionString := range versionStrings {
binary := version.MustParseBinary(versionString)
path := filepath.Join(toolsDir, fmt.Sprintf("juju-%s.tgz", binary))
data := binary.String()
err := ioutil.WriteFile(path, []byte(data), 0644)
c.Assert(err, gc.IsNil)
tool := &coretools.Tools{
Version: binary,
URL: path,
}
if withCheckSum {
tool.Size, tool.SHA256 = SHA256sum(c, path)
}
toolsList = append(toolsList, tool)
}
// Write the tools metadata.
stor, err := filestorage.NewFileStorageWriter(metadataDir)
c.Assert(err, gc.IsNil)
err = tools.MergeAndWriteMetadata(stor, toolsList, false)
c.Assert(err, gc.IsNil)
return toolsList
}
func newSimpleTools(vers string) *tools.Tools {
return &tools.Tools{
URL: "http://foo.com/tools/releases/juju" + vers + ".tgz",
Version: version.MustParseBinary(vers),
Size: 10,
SHA256: "1234",
}
}
func newTools(vers, url string) *tools.Tools {
return &tools.Tools{
Version: version.MustParseBinary(vers),
URL: url,
Size: 10,
SHA256: "1234",
}
}
func (t *ToolsSuite) TestChangeAgentTools(c *gc.C) {
files := []*testing.TarFile{
testing.NewTarFile("jujuc", 0755, "juju executable"),
testing.NewTarFile("jujud", 0755, "jujuc executable"),
}
data, checksum := testing.TarGz(files...)
testTools := &coretest.Tools{
URL: "http://foo/bar1",
Version: version.MustParseBinary("1.2.3-foo-bar"),
Size: int64(len(data)),
SHA256: checksum,
}
err := agenttools.UnpackTools(t.dataDir, testTools, bytes.NewReader(data))
c.Assert(err, gc.IsNil)
gotTools, err := agenttools.ChangeAgentTools(t.dataDir, "testagent", testTools.Version)
c.Assert(err, gc.IsNil)
c.Assert(*gotTools, gc.Equals, *testTools)
assertDirNames(c, t.toolsDir(), []string{"1.2.3-foo-bar", "testagent"})
assertDirNames(c, agenttools.ToolsDir(t.dataDir, "testagent"), []string{"jujuc", "jujud", toolsFile})
// Upgrade again to check that the link replacement logic works ok.
files2 := []*testing.TarFile{
testing.NewTarFile("foo", 0755, "foo content"),
testing.NewTarFile("bar", 0755, "bar content"),
}
data2, checksum2 := testing.TarGz(files2...)
tools2 := &coretest.Tools{
URL: "http://foo/bar2",
Version: version.MustParseBinary("1.2.4-foo-bar"),
Size: int64(len(data2)),
SHA256: checksum2,
}
err = agenttools.UnpackTools(t.dataDir, tools2, bytes.NewReader(data2))
c.Assert(err, gc.IsNil)
gotTools, err = agenttools.ChangeAgentTools(t.dataDir, "testagent", tools2.Version)
c.Assert(err, gc.IsNil)
c.Assert(*gotTools, gc.Equals, *tools2)
assertDirNames(c, t.toolsDir(), []string{"1.2.3-foo-bar", "1.2.4-foo-bar", "testagent"})
assertDirNames(c, agenttools.ToolsDir(t.dataDir, "testagent"), []string{"foo", "bar", toolsFile})
}
func (s *StorageSuite) TestReadList(c *gc.C) {
store := s.env.Storage()
v001 := version.MustParseBinary("0.0.1-precise-amd64")
v100 := version.MustParseBinary("1.0.0-precise-amd64")
v101 := version.MustParseBinary("1.0.1-precise-amd64")
v111 := version.MustParseBinary("1.1.1-precise-amd64")
agentTools := envtesting.AssertUploadFakeToolsVersions(c, store, v001, v100, v101, v111)
t001 := agentTools[0]
t100 := agentTools[1]
t101 := agentTools[2]
t111 := agentTools[3]
for i, t := range []struct {
majorVersion,
minorVersion int
list coretools.List
}{{
0, 0, coretools.List{t001},
}, {
1, 0, coretools.List{t100, t101},
}, {
1, 1, coretools.List{t111},
}, {
1, -1, coretools.List{t100, t101, t111},
}, {
1, 2, nil,
}, {
2, 0, nil,
}} {
c.Logf("test %d", i)
list, err := envtools.ReadList(store, t.majorVersion, t.minorVersion)
if t.list != nil {
c.Assert(err, gc.IsNil)
// ReadList doesn't set the Size of SHA256, so blank out those attributes.
for _, tool := range t.list {
tool.Size = 0
tool.SHA256 = ""
}
c.Assert(list, gc.DeepEquals, t.list)
} else {
c.Assert(err, gc.Equals, coretools.ErrNoMatches)
}
}
}
func (s *unitUpgraderSuite) TestWatchAPIVersion(c *gc.C) {
w, err := s.st.WatchAPIVersion(s.rawUnit.Tag())
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewNotifyWatcherC(c, s.BackingState, w)
// Initial event
wc.AssertOneChange()
vers := version.MustParseBinary("10.20.34-quantal-amd64")
err = s.rawMachine.SetAgentVersion(vers)
c.Assert(err, gc.IsNil)
// One change noticing the new version
wc.AssertOneChange()
vers = version.MustParseBinary("10.20.35-quantal-amd64")
err = s.rawMachine.SetAgentVersion(vers)
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *UpgraderSuite) TestUpgraderRefusesToDowngradeMinorVersions(c *gc.C) {
stor := s.Conn.Environ.Storage()
origTools := envtesting.PrimeTools(c, stor, s.DataDir(), version.MustParseBinary("5.4.3-precise-amd64"))
s.PatchValue(&version.Current, origTools.Version)
downgradeTools := envtesting.AssertUploadFakeToolsVersions(
c, stor, version.MustParseBinary("5.3.3-precise-amd64"))[0]
err := statetesting.SetAgentVersion(s.State, downgradeTools.Version.Number)
c.Assert(err, gc.IsNil)
u := s.makeUpgrader()
err = u.Stop()
// If the upgrade would have triggered, we would have gotten an
// UpgradeReadyError, since it was skipped, we get no error
c.Check(err, gc.IsNil)
_, err = agenttools.ReadTools(s.DataDir(), downgradeTools.Version)
// TODO: ReadTools *should* be returning some form of errors.NotFound,
// however, it just passes back a fmt.Errorf so we live with it
// c.Assert(err, jc.Satisfies, errors.IsNotFound)
c.Check(err, gc.ErrorMatches, "cannot read tools metadata in tools directory.*no such file or directory")
}
func (s *simplestreamsSuite) TestWriteMetadataNoFetch(c *gc.C) {
toolsList := coretools.List{
{
Version: version.MustParseBinary("1.2.3-precise-amd64"),
Size: 123,
SHA256: "abcd",
}, {
Version: version.MustParseBinary("2.0.1-raring-amd64"),
Size: 456,
SHA256: "xyz",
},
}
dir := c.MkDir()
writer, err := filestorage.NewFileStorageWriter(dir)
c.Assert(err, gc.IsNil)
err = tools.MergeAndWriteMetadata(writer, toolsList, tools.DoNotWriteMirrors)
c.Assert(err, gc.IsNil)
metadata := ttesting.ParseMetadataFromDir(c, dir, false)
assertMetadataMatches(c, dir, toolsList, metadata)
}
func (s *UpgraderSuite) TestChangeAgentTools(c *gc.C) {
oldTools := &coretools.Tools{
Version: version.MustParseBinary("1.2.3-quantal-amd64"),
}
stor := s.Conn.Environ.Storage()
newTools := envtesting.PrimeTools(c, stor, s.DataDir(), version.MustParseBinary("5.4.3-precise-amd64"))
s.PatchValue(&version.Current, newTools.Version)
err := envtools.MergeAndWriteMetadata(stor, coretools.List{newTools}, envtools.DoNotWriteMirrors)
c.Assert(err, gc.IsNil)
ugErr := &upgrader.UpgradeReadyError{
AgentName: "anAgent",
OldTools: oldTools.Version,
NewTools: newTools.Version,
DataDir: s.DataDir(),
}
err = ugErr.ChangeAgentTools()
c.Assert(err, gc.IsNil)
link, err := os.Readlink(agenttools.ToolsDir(s.DataDir(), "anAgent"))
c.Assert(err, gc.IsNil)
c.Assert(link, gc.Equals, newTools.Version.String())
}
func (s *UpgraderSuite) TestEnsureToolsChecksBeforeDownloading(c *gc.C) {
stor := s.Conn.Environ.Storage()
newTools := envtesting.PrimeTools(c, stor, s.DataDir(), version.MustParseBinary("5.4.3-precise-amd64"))
s.PatchValue(&version.Current, newTools.Version)
// We've already downloaded the tools, so change the URL to be
// something invalid and ensure we don't actually get an error, because
// it doesn't actually do an HTTP request
u := s.makeUpgrader()
newTools.URL = "http://0.1.2.3/invalid/path/tools.tgz"
err := upgrader.EnsureTools(u, newTools, utils.VerifySSLHostnames)
c.Assert(err, gc.IsNil)
}
func (s *bootstrapSuite) TestEnsureToolsAvailabilityNonDevVersion(c *gc.C) {
// Can't automatically upload tools for released versions.
s.PatchValue(&version.Current, version.MustParseBinary("1.18.0-trusty-arm64"))
env := newEnviron("foo", useDefaultKeys, nil)
s.setDummyStorage(c, env)
envtesting.RemoveFakeTools(c, env.Storage())
_, err := bootstrap.EnsureToolsAvailability(coretesting.Context(c), env, config.PreferredSeries(env.Config()), nil)
c.Assert(err, gc.NotNil)
stripped := strings.Replace(err.Error(), "\n", "", -1)
c.Assert(stripped,
gc.Matches,
"cannot upload bootstrap tools: Juju cannot bootstrap because no tools are available for your environment.*")
}
func (t *ToolsSuite) TestUnpackToolsBadChecksum(c *gc.C) {
data, _ := testing.TarGz(testing.NewTarFile("tools", 0755, "some data"))
testTools := &coretest.Tools{
URL: "http://foo/bar",
Version: version.MustParseBinary("1.2.3-foo-bar"),
Size: int64(len(data)),
SHA256: "1234",
}
err := agenttools.UnpackTools(t.dataDir, testTools, bytes.NewReader(data))
c.Assert(err, gc.ErrorMatches, "tarball sha256 mismatch, expected 1234, got .*")
_, err = os.Stat(t.toolsDir())
c.Assert(err, gc.FitsTypeOf, &os.PathError{})
}
func (s *UpgraderSuite) TestUpgraderAllowsDowngradingPatchVersions(c *gc.C) {
stor := s.Conn.Environ.Storage()
origTools := envtesting.PrimeTools(c, stor, s.DataDir(), version.MustParseBinary("5.4.3-precise-amd64"))
s.PatchValue(&version.Current, origTools.Version)
downgradeTools := envtesting.AssertUploadFakeToolsVersions(
c, stor, version.MustParseBinary("5.4.2-precise-amd64"))[0]
err := statetesting.SetAgentVersion(s.State, downgradeTools.Version.Number)
c.Assert(err, gc.IsNil)
dummy.SetStorageDelay(coretesting.ShortWait)
u := s.makeUpgrader()
err = u.Stop()
envtesting.CheckUpgraderReadyError(c, err, &upgrader.UpgradeReadyError{
AgentName: s.machine.Tag(),
OldTools: origTools.Version,
NewTools: downgradeTools.Version,
DataDir: s.DataDir(),
})
foundTools, err := agenttools.ReadTools(s.DataDir(), downgradeTools.Version)
c.Assert(err, gc.IsNil)
envtesting.CheckTools(c, foundTools, downgradeTools)
}
func (*cloudinitSuite) createMachineConfig(c *gc.C, environConfig *config.Config) *cloudinit.MachineConfig {
machineId := "42"
machineNonce := "fake-nonce"
stateInfo := jujutesting.FakeStateInfo(machineId)
apiInfo := jujutesting.FakeAPIInfo(machineId)
machineConfig := environs.NewMachineConfig(machineId, machineNonce, nil, nil, stateInfo, apiInfo)
machineConfig.Tools = &tools.Tools{
Version: version.MustParseBinary("2.3.4-foo-bar"),
URL: "http://tools.testing.invalid/2.3.4-foo-bar.tgz",
}
err := environs.FinishMachineConfig(machineConfig, environConfig, constraints.Value{})
c.Assert(err, gc.IsNil)
return machineConfig
}
func (t *ToolsSuite) TestUnpackToolsBadData(c *gc.C) {
for i, test := range unpackToolsBadDataTests {
c.Logf("test %d", i)
testTools := &coretest.Tools{
URL: "http://foo/bar",
Version: version.MustParseBinary("1.2.3-foo-bar"),
Size: int64(len(test.data)),
SHA256: test.checksum,
}
err := agenttools.UnpackTools(t.dataDir, testTools, bytes.NewReader(test.data))
c.Assert(err, gc.ErrorMatches, test.err)
assertDirNames(c, t.toolsDir(), []string{})
}
}
// Copied from environs/agent/tools_test.go
func (s *DiskManagerSuite) TestUnpackToolsContents(c *gc.C) {
files := []*coretesting.TarFile{
coretesting.NewTarFile("bar", 0755, "bar contents"),
coretesting.NewTarFile("foo", 0755, "foo contents"),
}
gzfile, checksum := coretesting.TarGz(files...)
t1 := &coretools.Tools{
URL: "http://foo/bar",
Version: version.MustParseBinary("1.2.3-foo-bar"),
Size: int64(len(gzfile)),
SHA256: checksum,
}
err := s.manager.UnpackTools(t1, bytes.NewReader(gzfile))
c.Assert(err, gc.IsNil)
assertDirNames(c, s.toolsDir(), []string{"1.2.3-foo-bar"})
s.assertToolsContents(c, t1, files)
// Try to unpack the same version of tools again - it should succeed,
// leaving the original version around.
files2 := []*coretesting.TarFile{
coretesting.NewTarFile("bar", 0755, "bar2 contents"),
coretesting.NewTarFile("x", 0755, "x contents"),
}
gzfile2, checksum2 := coretesting.TarGz(files2...)
t2 := &coretools.Tools{
URL: "http://arble",
Version: version.MustParseBinary("1.2.3-foo-bar"),
Size: int64(len(gzfile2)),
SHA256: checksum2,
}
err = s.manager.UnpackTools(t2, bytes.NewReader(gzfile2))
c.Assert(err, gc.IsNil)
assertDirNames(c, s.toolsDir(), []string{"1.2.3-foo-bar"})
s.assertToolsContents(c, t1, files)
}
func (t *ToolsSuite) TestUnpackToolsContents(c *gc.C) {
files := []*testing.TarFile{
testing.NewTarFile("bar", 0755, "bar contents"),
testing.NewTarFile("foo", 0755, "foo contents"),
}
data, checksum := testing.TarGz(files...)
testTools := &coretest.Tools{
URL: "http://foo/bar",
Version: version.MustParseBinary("1.2.3-foo-bar"),
Size: int64(len(data)),
SHA256: checksum,
}
err := agenttools.UnpackTools(t.dataDir, testTools, bytes.NewReader(data))
c.Assert(err, gc.IsNil)
assertDirNames(c, t.toolsDir(), []string{"1.2.3-foo-bar"})
t.assertToolsContents(c, testTools, files)
// Try to unpack the same version of tools again - it should succeed,
// leaving the original version around.
files2 := []*testing.TarFile{
testing.NewTarFile("bar", 0755, "bar2 contents"),
testing.NewTarFile("x", 0755, "x contents"),
}
data2, checksum2 := testing.TarGz(files2...)
tools2 := &coretest.Tools{
URL: "http://arble",
Version: version.MustParseBinary("1.2.3-foo-bar"),
Size: int64(len(data2)),
SHA256: checksum2,
}
err = agenttools.UnpackTools(t.dataDir, tools2, bytes.NewReader(data2))
c.Assert(err, gc.IsNil)
assertDirNames(c, t.toolsDir(), []string{"1.2.3-foo-bar"})
t.assertToolsContents(c, testTools, files)
}
func CreateContainer(c *gc.C, manager container.Manager, machineId string) instance.Instance {
stateInfo := jujutesting.FakeStateInfo(machineId)
apiInfo := jujutesting.FakeAPIInfo(machineId)
machineConfig := environs.NewMachineConfig(machineId, "fake-nonce", nil, nil, stateInfo, apiInfo)
machineConfig.Tools = &tools.Tools{
Version: version.MustParseBinary("2.3.4-foo-bar"),
URL: "http://tools.testing.invalid/2.3.4-foo-bar.tgz",
}
series := "series"
network := container.BridgeNetworkConfig("nic42")
inst, hardware, err := manager.CreateContainer(machineConfig, series, network)
c.Assert(err, gc.IsNil)
c.Assert(hardware, gc.NotNil)
c.Assert(hardware.String(), gc.Not(gc.Equals), "")
return inst
}
func (t *ToolsSuite) TestReadToolsErrors(c *gc.C) {
vers := version.MustParseBinary("1.2.3-precise-amd64")
testTools, err := agenttools.ReadTools(t.dataDir, vers)
c.Assert(testTools, gc.IsNil)
c.Assert(err, gc.ErrorMatches, "cannot read tools metadata in tools directory: .*")
dir := agenttools.SharedToolsDir(t.dataDir, vers)
err = os.MkdirAll(dir, 0755)
c.Assert(err, gc.IsNil)
err = ioutil.WriteFile(filepath.Join(dir, toolsFile), []byte(" \t\n"), 0644)
c.Assert(err, gc.IsNil)
testTools, err = agenttools.ReadTools(t.dataDir, vers)
c.Assert(testTools, gc.IsNil)
c.Assert(err, gc.ErrorMatches, "invalid tools metadata in tools directory .*")
}
