func (s *uploadSuite) TestMockBuildTools(c *gc.C) {
checkTools := func(tools *sync.BuiltAgent, vers version.Binary) {
c.Check(tools.StorageName, gc.Equals, "name")
c.Check(tools.Version, jc.DeepEquals, vers)
f, err := os.Open(filepath.Join(tools.Dir, "name"))
c.Assert(err, jc.ErrorIsNil)
defer f.Close()
gzr, err := gzip.NewReader(f)
c.Assert(err, jc.ErrorIsNil)
_, tr, err := tar.FindFile(gzr, names.Jujud)
c.Assert(err, jc.ErrorIsNil)
content, err := ioutil.ReadAll(tr)
c.Assert(err, jc.ErrorIsNil)
c.Check(string(content), gc.Equals, fmt.Sprintf("jujud contents %s", vers))
}
current := version.MustParseBinary("1.9.1-trusty-amd64")
s.PatchValue(&jujuversion.Current, current.Number)
s.PatchValue(&arch.HostArch, func() string { return current.Arch })
s.PatchValue(&series.HostSeries, func() string { return current.Series })
buildToolsFunc := toolstesting.GetMockBuildTools(c)
builtTools, err := buildToolsFunc(true, nil, "released")
c.Assert(err, jc.ErrorIsNil)
checkTools(builtTools, current)
vers := version.MustParseBinary("1.5.3-trusty-amd64")
builtTools, err = buildToolsFunc(true, &vers.Number, "released")
c.Assert(err, jc.ErrorIsNil)
checkTools(builtTools, vers)
}
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",
},
}
expected := toolsList
// Add tools with an unknown series. Do not add an entry in the
// expected list as these tools should be ignored.
vers, err := version.ParseBinary("3.2.1-xuanhuaceratops-amd64")
c.Assert(err, jc.Satisfies, series.IsUnknownOSForSeriesError)
toolsList = append(toolsList, &coretools.Tools{
Version: vers,
Size: 456,
SHA256: "wqe",
})
dir := c.MkDir()
writer, err := filestorage.NewFileStorageWriter(dir)
c.Assert(err, jc.ErrorIsNil)
err = tools.MergeAndWriteMetadata(writer, "proposed", "proposed", toolsList, tools.DoNotWriteMirrors)
c.Assert(err, jc.ErrorIsNil)
metadata := toolstesting.ParseMetadataFromDir(c, dir, "proposed", false)
assertMetadataMatches(c, dir, "proposed", expected, metadata)
}
func (*metadataHelperSuite) TestMetadataFromTools(c *gc.C) {
metadata := tools.MetadataFromTools(nil, "proposed")
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/proposed/juju-2.0.1-raring-amd64.tgz",
Size: 456,
SHA256: "xyz",
}}
metadata = tools.MetadataFromTools(toolsList, "proposed")
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, "proposed")[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) 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)
}
func (s *uploadSuite) TestMockBuildTools(c *gc.C) {
current := version.MustParseBinary("1.9.1-trusty-amd64")
s.PatchValue(&jujuversion.Current, current.Number)
s.PatchValue(&arch.HostArch, func() string { return current.Arch })
s.PatchValue(&series.HostSeries, func() string { return current.Series })
buildToolsFunc := toolstesting.GetMockBuildTools(c)
builtTools, err := buildToolsFunc(nil, "released")
c.Assert(err, jc.ErrorIsNil)
builtTools.Dir = ""
expectedBuiltTools := &sync.BuiltTools{
StorageName: "name",
Version: current,
Size: 127,
Sha256Hash: "6a19d08ca4913382ca86508aa38eb8ee5b9ae2d74333fe8d862c0f9e29b82c39",
}
c.Assert(builtTools, gc.DeepEquals, expectedBuiltTools)
vers := version.MustParseBinary("1.5.3-trusty-amd64")
builtTools, err = buildToolsFunc(&vers.Number, "released")
c.Assert(err, jc.ErrorIsNil)
builtTools.Dir = ""
expectedBuiltTools = &sync.BuiltTools{
StorageName: "name",
Version: vers,
Size: 127,
Sha256Hash: "cad8ccedab8f26807ff379ddc2f2f78d9a7cac1276e001154cee5e39b9ddcc38",
}
c.Assert(builtTools, gc.DeepEquals, expectedBuiltTools)
}
func (s *bootstrapSuite) setupBootstrapSpecificVersion(c *gc.C, clientMajor, clientMinor int, toolsVersion *version.Number) (error, int, version.Number) {
currentVersion := jujuversion.Current
currentVersion.Major = clientMajor
currentVersion.Minor = clientMinor
currentVersion.Tag = ""
s.PatchValue(&jujuversion.Current, currentVersion)
s.PatchValue(&series.HostSeries, func() string { return "trusty" })
s.PatchValue(&arch.HostArch, func() string { return arch.AMD64 })
env := newEnviron("foo", useDefaultKeys, nil)
s.setDummyStorage(c, env)
envtools.RegisterToolsDataSourceFunc("local storage", func(environs.Environ) (simplestreams.DataSource, error) {
return storage.NewStorageSimpleStreamsDataSource("test datasource", env.storage, "tools", simplestreams.CUSTOM_CLOUD_DATA, false), nil
})
defer envtools.UnregisterToolsDataSourceFunc("local storage")
toolsBinaries := []version.Binary{
version.MustParseBinary("10.11.12-trusty-amd64"),
version.MustParseBinary("10.11.13-trusty-amd64"),
version.MustParseBinary("10.11-beta1-trusty-amd64"),
}
stream := "released"
if toolsVersion != nil && toolsVersion.Tag != "" {
stream = "devel"
currentVersion.Tag = toolsVersion.Tag
}
_, err := envtesting.UploadFakeToolsVersions(env.storage, stream, stream, toolsBinaries...)
c.Assert(err, jc.ErrorIsNil)
err = bootstrap.Bootstrap(envtesting.BootstrapContext(c), env, bootstrap.BootstrapParams{
AgentVersion: toolsVersion,
})
vers, _ := env.cfg.AgentVersion()
return err, env.bootstrapCount, vers
}
func (s *lxcBrokerSuite) TestStartInstanceHostArch(c *gc.C) {
instanceConfig := s.instanceConfig(c, "1/lxc/0")
// Patch the host's arch, so the LXC broker will filter tools.
s.PatchValue(&arch.HostArch, func() string { return arch.PPC64EL })
possibleTools := coretools.List{&coretools.Tools{
Version: version.MustParseBinary("2.3.4-quantal-amd64"),
URL: "http://tools.testing.invalid/2.3.4-quantal-amd64.tgz",
}, {
Version: version.MustParseBinary("2.3.4-quantal-ppc64el"),
URL: "http://tools.testing.invalid/2.3.4-quantal-ppc64el.tgz",
}}
callback := func(settableStatus status.Status, info string, data map[string]interface{}) error {
return nil
}
_, err := s.broker.StartInstance(environs.StartInstanceParams{
Constraints: constraints.Value{},
Tools: possibleTools,
InstanceConfig: instanceConfig,
StatusCallback: callback,
})
c.Assert(err, jc.ErrorIsNil)
c.Assert(instanceConfig.Tools.Version.Arch, gc.Equals, arch.PPC64EL)
}
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, jc.ErrorIsNil)
err = env.SetConfig(cfg)
c.Assert(err, jc.ErrorIsNil)
s.PatchValue(&jujuversion.Current, t.currentVersion)
bootstrapTools, err := bootstrap.SetBootstrapTools(env, availableTools)
c.Assert(err, jc.ErrorIsNil)
for _, tools := range bootstrapTools {
c.Assert(tools.Version.Number, gc.Equals, t.expectedTools)
}
agentVersion, _ := env.Config().AgentVersion()
c.Assert(agentVersion, gc.Equals, t.expectedAgentVersion)
}
}
func (*instancecfgSuite) TestSetToolsSameVersions(c *gc.C) {
var icfg instancecfg.InstanceConfig
list := coretools.List{
&coretools.Tools{Version: version.MustParseBinary("2.3.4-trusty-amd64")},
&coretools.Tools{Version: version.MustParseBinary("2.3.4-trusty-amd64")},
}
err := icfg.SetTools(list)
c.Assert(err, jc.ErrorIsNil)
c.Assert(icfg.ToolsList(), jc.DeepEquals, list)
}
func makePossibleTools() coretools.List {
return coretools.List{&coretools.Tools{
Version: version.MustParseBinary("2.3.4-quantal-amd64"),
URL: "http://tools.testing.invalid/2.3.4-quantal-amd64.tgz",
}, {
// non-host-arch tools should be filtered out by StartInstance
Version: version.MustParseBinary("2.3.4-quantal-arm64"),
URL: "http://tools.testing.invalid/2.3.4-quantal-arm64.tgz",
}}
}
func (*instancecfgSuite) TestSetToolsDifferentVersions(c *gc.C) {
var icfg instancecfg.InstanceConfig
list := coretools.List{
&coretools.Tools{Version: version.MustParseBinary("2.3.4-trusty-amd64")},
&coretools.Tools{Version: version.MustParseBinary("2.3.5-trusty-amd64")},
}
err := icfg.SetTools(list)
c.Assert(err, gc.ErrorMatches, `tools info mismatch.*2\.3\.4.*2\.3\.5.*`)
c.Assert(icfg.ToolsList(), gc.HasLen, 0)
}
func (s *UpgraderSuite) TestUpgraderRetryAndChanged(c *gc.C) {
stor := s.DefaultToolsStorage
oldTools := envtesting.PrimeTools(c, stor, s.DataDir(), s.Environ.Config().AgentStream(), version.MustParseBinary("5.4.3-precise-amd64"))
s.patchVersion(oldTools.Version)
newTools := envtesting.AssertUploadFakeToolsVersions(
c, stor, s.Environ.Config().AgentStream(), s.Environ.Config().AgentStream(), version.MustParseBinary("5.4.5-precise-amd64"))[0]
err := statetesting.SetAgentVersion(s.State, newTools.Version.Number)
c.Assert(err, jc.ErrorIsNil)
retryc := make(chan time.Time)
*upgrader.RetryAfter = func() <-chan time.Time {
c.Logf("replacement retry after")
return retryc
}
err = stor.Remove(envtools.StorageName(newTools.Version, "released"))
c.Assert(err, jc.ErrorIsNil)
u := s.makeUpgrader(c)
defer u.Stop()
s.expectInitialUpgradeCheckNotDone(c)
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, stor, s.Environ.Config().AgentStream(), s.Environ.Config().AgentStream(), version.MustParseBinary("5.4.6-precise-amd64"))[0]
err = statetesting.SetAgentVersion(s.State, newerTools.Version.Number)
c.Assert(err, jc.ErrorIsNil)
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().String(),
OldTools: oldTools.Version,
NewTools: newerTools.Version,
DataDir: s.DataDir(),
})
case <-time.After(coretesting.LongWait):
c.Fatalf("upgrader did not quit after upgrading")
}
}
func (s *clientSuite) TestClientFindTools(c *gc.C) {
result, err := s.APIState.Client().FindTools(99, -1, "", "")
c.Assert(err, jc.ErrorIsNil)
c.Assert(result.Error, jc.Satisfies, params.IsCodeNotFound)
toolstesting.UploadToStorage(c, s.DefaultToolsStorage, "released", version.MustParseBinary("2.99.0-precise-amd64"))
result, err = s.APIState.Client().FindTools(2, 99, "precise", "amd64")
c.Assert(err, jc.ErrorIsNil)
c.Assert(result.Error, gc.IsNil)
c.Assert(result.List, gc.HasLen, 1)
c.Assert(result.List[0].Version, gc.Equals, version.MustParseBinary("2.99.0-precise-amd64"))
url := fmt.Sprintf("https://%s/model/%s/tools/%s",
s.APIState.Addr(), coretesting.ModelTag.Id(), result.List[0].Version)
c.Assert(result.List[0].URL, gc.Equals, url)
}
func (s *toolsSuite) TestFindTools(c *gc.C) {
envtoolsList := coretools.List{
&coretools.Tools{
Version: version.MustParseBinary("123.456.0-win81-alpha"),
Size: 2048,
SHA256: "badf00d",
},
&coretools.Tools{
Version: version.MustParseBinary("123.456.1-win81-alpha"),
},
}
storageMetadata := []binarystorage.Metadata{{
Version: "123.456.0-win81-alpha",
Size: 1024,
SHA256: "feedface",
}}
s.PatchValue(common.EnvtoolsFindTools, func(e environs.Environ, major, minor int, stream string, filter coretools.Filter) (coretools.List, error) {
c.Assert(major, gc.Equals, 123)
c.Assert(minor, gc.Equals, 456)
c.Assert(stream, gc.Equals, "released")
c.Assert(filter.Series, gc.Equals, "win81")
c.Assert(filter.Arch, gc.Equals, "alpha")
return envtoolsList, nil
})
toolsFinder := common.NewToolsFinder(
stateenvirons.EnvironConfigGetter{s.State}, &mockToolsStorage{metadata: storageMetadata}, sprintfURLGetter("tools:%s"),
)
result, err := toolsFinder.FindTools(params.FindToolsParams{
MajorVersion: 123,
MinorVersion: 456,
Series: "win81",
Arch: "alpha",
})
c.Assert(err, jc.ErrorIsNil)
c.Assert(result.Error, gc.IsNil)
c.Check(result.List, jc.DeepEquals, coretools.List{
&coretools.Tools{
Version: version.MustParseBinary(storageMetadata[0].Version),
Size: storageMetadata[0].Size,
SHA256: storageMetadata[0].SHA256,
URL: "tools:" + storageMetadata[0].Version,
},
&coretools.Tools{
Version: version.MustParseBinary("123.456.1-win81-alpha"),
URL: "tools:123.456.1-win81-alpha",
},
})
}
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 *toolsSuite) TestFindToolsExactInStorage(c *gc.C) {
mockToolsStorage := &mockToolsStorage{
metadata: []binarystorage.Metadata{
{Version: "1.22-beta1-trusty-amd64"},
{Version: "1.22.0-trusty-amd64"},
},
}
s.PatchValue(&arch.HostArch, func() string { return arch.AMD64 })
s.PatchValue(&series.HostSeries, func() string { return "trusty" })
s.PatchValue(&jujuversion.Current, version.MustParseBinary("1.22-beta1-trusty-amd64").Number)
s.testFindToolsExact(c, mockToolsStorage, true, true)
s.PatchValue(&jujuversion.Current, version.MustParseBinary("1.22.0-trusty-amd64").Number)
s.testFindToolsExact(c, mockToolsStorage, true, false)
}
func (s *UpgradeJujuSuite) setUpEnvAndTools(c *gc.C, currentVersion string, agentVersion string, tools []string) {
current := version.MustParseBinary(currentVersion)
s.PatchValue(&jujuversion.Current, current.Number)
s.PatchValue(&arch.HostArch, func() string { return current.Arch })
s.PatchValue(&series.HostSeries, func() string { return current.Series })
toolsDir := c.MkDir()
updateAttrs := map[string]interface{}{
"agent-version": agentVersion,
"agent-metadata-url": "file://" + toolsDir + "/tools",
}
err := s.State.UpdateModelConfig(updateAttrs, nil, nil)
c.Assert(err, jc.ErrorIsNil)
versions := make([]version.Binary, len(tools))
for i, v := range tools {
versions[i], err = version.ParseBinary(v)
if err != nil {
c.Assert(err, jc.Satisfies, series.IsUnknownOSForSeriesError)
}
}
if len(versions) > 0 {
stor, err := filestorage.NewFileStorageWriter(toolsDir)
c.Assert(err, jc.ErrorIsNil)
envtesting.MustUploadFakeToolsVersions(stor, s.Environ.Config().AgentStream(), versions...)
}
}
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 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-quantal-amd64")
err = obj.SetAgentVersion(v2)
c.Assert(err, jc.ErrorIsNil)
t3, err := obj.AgentTools()
c.Assert(err, jc.ErrorIsNil)
c.Assert(t3.Version, gc.DeepEquals, v2)
err = obj.Refresh()
c.Assert(err, jc.ErrorIsNil)
t3, err = obj.AgentTools()
c.Assert(err, jc.ErrorIsNil)
c.Assert(t3.Version, gc.DeepEquals, v2)
testWhenDying(c, obj, noErr, deadErr, func() error {
return obj.SetAgentVersion(v2)
})
}
func createContainer(c *gc.C, manager container.Manager, machineId string) instance.Instance {
machineNonce := "fake-nonce"
stateInfo := jujutesting.FakeStateInfo(machineId)
apiInfo := jujutesting.FakeAPIInfo(machineId)
instanceConfig, err := instancecfg.NewInstanceConfig(machineId, machineNonce, imagemetadata.ReleasedStream, "quantal", "", true, stateInfo, apiInfo)
c.Assert(err, jc.ErrorIsNil)
network := container.BridgeNetworkConfig("virbr0", 0, nil)
err = instanceConfig.SetTools(tools.List{
&tools.Tools{
Version: version.MustParseBinary("2.3.4-foo-bar"),
URL: "http://tools.testing.invalid/2.3.4-foo-bar.tgz",
},
})
c.Assert(err, jc.ErrorIsNil)
environConfig := dummyConfig(c)
err = instancecfg.FinishInstanceConfig(instanceConfig, environConfig)
c.Assert(err, jc.ErrorIsNil)
callback := func(settableStatus status.Status, info string, data map[string]interface{}) error { return nil }
inst, hardware, err := manager.CreateContainer(instanceConfig, "precise", network, nil, callback)
c.Assert(err, jc.ErrorIsNil)
c.Assert(hardware, gc.NotNil)
expected := fmt.Sprintf("arch=%s cpu-cores=1 mem=512M root-disk=8192M", arch.HostArch())
c.Assert(hardware.String(), gc.Equals, expected)
return inst
}
func (s *UpgraderSuite) TestUpgraderAllowsDowngradeToOrigVersionIfUpgradeInProgress(c *gc.C) {
// note: otherwise illegal version jump
downgradeVersion := version.MustParseBinary("5.3.0-precise-amd64")
s.confVersion = downgradeVersion.Number
stor := s.DefaultToolsStorage
origTools := envtesting.PrimeTools(c, stor, s.DataDir(), s.Environ.Config().AgentStream(), version.MustParseBinary("5.4.3-precise-amd64"))
s.patchVersion(origTools.Version)
downgradeTools := envtesting.AssertUploadFakeToolsVersions(
c, stor, s.Environ.Config().AgentStream(), s.Environ.Config().AgentStream(), downgradeVersion)[0]
err := statetesting.SetAgentVersion(s.State, downgradeVersion.Number)
c.Assert(err, jc.ErrorIsNil)
u := s.makeUpgrader(c)
err = u.Stop()
s.expectInitialUpgradeCheckNotDone(c)
envtesting.CheckUpgraderReadyError(c, err, &upgrader.UpgradeReadyError{
AgentName: s.machine.Tag().String(),
OldTools: origTools.Version,
NewTools: downgradeVersion,
DataDir: s.DataDir(),
})
foundTools, err := agenttools.ReadTools(s.DataDir(), downgradeTools.Version)
c.Assert(err, jc.ErrorIsNil)
downgradeTools.URL = fmt.Sprintf("https://%s/model/%s/tools/5.3.0-precise-amd64",
s.APIState.Addr(), coretesting.ModelTag.Id())
envtesting.CheckTools(c, foundTools, downgradeTools)
}
// Check that we get a consistent error when asking for an instance without
// a valid machine config.
func (t *LiveTests) TestStartInstanceWithEmptyNonceFails(c *gc.C) {
machineId := "4"
stateInfo := jujutesting.FakeStateInfo(machineId)
apiInfo := jujutesting.FakeAPIInfo(machineId)
instanceConfig, err := instancecfg.NewInstanceConfig(machineId, "", "released", "quantal", "", true, nil, stateInfo, apiInfo)
c.Assert(err, jc.ErrorIsNil)
t.PrepareOnce(c)
possibleTools := coretools.List(envtesting.AssertUploadFakeToolsVersions(
c, t.toolsStorage, "released", "released", version.MustParseBinary("5.4.5-trusty-amd64"),
))
params := environs.StartInstanceParams{
Tools: possibleTools,
InstanceConfig: instanceConfig,
}
err = jujutesting.SetImageMetadata(
t.Env,
possibleTools.AllSeries(),
possibleTools.Arches(),
¶ms.ImageMetadata,
)
c.Check(err, jc.ErrorIsNil)
result, err := t.Env.StartInstance(params)
if result != nil && result.Instance != nil {
err := t.Env.StopInstances(result.Instance.Id())
c.Check(err, jc.ErrorIsNil)
}
c.Assert(result, gc.IsNil)
c.Assert(err, gc.ErrorMatches, ".*missing machine nonce")
}
func (s *ClientSuite) TestExport(c *gc.C) {
var stub jujutesting.Stub
apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
stub.AddCall(objType+"."+request, id, arg)
out := result.(*params.SerializedModel)
*out = params.SerializedModel{
Bytes: []byte("foo"),
Charms: []string{"cs:foo-1"},
Tools: []params.SerializedModelTools{{
Version: "2.0.0-trusty-amd64",
URI: "/tools/0",
}},
}
return nil
})
client := migrationmaster.NewClient(apiCaller, nil)
out, err := client.Export()
c.Assert(err, jc.ErrorIsNil)
stub.CheckCalls(c, []jujutesting.StubCall{
{"MigrationMaster.Export", []interface{}{"", nil}},
})
c.Assert(out, gc.DeepEquals, migration.SerializedModel{
Bytes: []byte("foo"),
Charms: []string{"cs:foo-1"},
Tools: map[version.Binary]string{
version.MustParseBinary("2.0.0-trusty-amd64"): "/tools/0",
},
})
}
func (s *apiEnvironmentSuite) TestUploadToolsOtherEnvironment(c *gc.C) {
// setup other environment
otherState := s.Factory.MakeModel(c, nil)
defer otherState.Close()
info := s.APIInfo(c)
info.ModelTag = otherState.ModelTag()
otherAPIState, err := api.Open(info, api.DefaultDialOpts())
c.Assert(err, jc.ErrorIsNil)
defer otherAPIState.Close()
otherClient := otherAPIState.Client()
defer otherClient.ClientFacade.Close()
newVersion := version.MustParseBinary("5.4.3-quantal-amd64")
vers := newVersion.String()
// build fake tools
tgz, checksum := coretesting.TarGz(
coretesting.NewTarFile(jujunames.Jujud, 0777, "jujud contents "+vers))
toolsList, err := otherClient.UploadTools(bytes.NewReader(tgz), newVersion)
c.Assert(err, jc.ErrorIsNil)
c.Assert(toolsList, gc.HasLen, 1)
c.Assert(toolsList[0].SHA256, gc.Equals, checksum)
toolStrg, err := otherState.ToolsStorage()
defer toolStrg.Close()
c.Assert(err, jc.ErrorIsNil)
meta, closer, err := toolStrg.Open(vers)
defer closer.Close()
c.Assert(err, jc.ErrorIsNil)
c.Assert(meta.SHA256, gc.Equals, checksum)
c.Assert(meta.Version, gc.Equals, vers)
}
func (s *toolsSuite) TestFindAvailableToolsAutoUpload(c *gc.C) {
s.PatchValue(&arch.HostArch, func() string { return arch.AMD64 })
trustyTools := &tools.Tools{
Version: version.MustParseBinary("1.2.3-trusty-amd64"),
URL: "http://testing.invalid/tools.tar.gz",
}
s.PatchValue(bootstrap.FindTools, func(_ environs.Environ, major, minor int, stream string, f tools.Filter) (tools.List, error) {
return tools.List{trustyTools}, nil
})
env := newEnviron("foo", useDefaultKeys, map[string]interface{}{
"agent-stream": "proposed"})
availableTools, err := bootstrap.FindAvailableTools(env, nil, nil, nil, false)
c.Assert(err, jc.ErrorIsNil)
c.Assert(len(availableTools), jc.GreaterThan, 1)
c.Assert(env.supportedArchitecturesCount, gc.Equals, 1)
var trustyToolsFound int
expectedVersion := jujuversion.Current
expectedVersion.Build++
for _, tools := range availableTools {
if tools == trustyTools {
trustyToolsFound++
} else {
c.Assert(tools.Version.Number, gc.Equals, expectedVersion)
c.Assert(tools.Version.Series, gc.Not(gc.Equals), "trusty")
c.Assert(tools.URL, gc.Equals, "")
}
}
c.Assert(trustyToolsFound, gc.Equals, 1)
}
func (s *lxcBrokerSuite) startInstancePopulatesNetworkInfo(c *gc.C) (*environs.StartInstanceResult, error) {
s.PatchValue(provisioner.InterfaceAddrs, func(i *net.Interface) ([]net.Addr, error) {
return []net.Addr{&fakeAddr{"0.1.2.1/24"}}, nil
})
fakeResolvConf := filepath.Join(c.MkDir(), "resolv.conf")
err := ioutil.WriteFile(fakeResolvConf, []byte("nameserver ns1.dummy\nnameserver ns2.dummy\nsearch dummy\n"), 0644)
c.Assert(err, jc.ErrorIsNil)
s.PatchValue(provisioner.ResolvConf, fakeResolvConf)
instanceConfig := s.instanceConfig(c, "42")
possibleTools := coretools.List{&coretools.Tools{
Version: version.MustParseBinary("2.3.4-quantal-amd64"),
URL: "http://tools.testing.invalid/2.3.4-quantal-amd64.tgz",
}}
callback := func(settableStatus status.Status, info string, data map[string]interface{}) error {
return nil
}
return s.broker.StartInstance(environs.StartInstanceParams{
Constraints: constraints.Value{},
Tools: possibleTools,
InstanceConfig: instanceConfig,
StatusCallback: callback,
})
}
func (s *MigrationBaseSuite) makeUnitWithStorage(c *gc.C) (*state.Application, *state.Unit, names.StorageTag) {
pool := "loop-pool"
kind := "block"
// Create a default pool for block devices.
pm := poolmanager.New(state.NewStateSettings(s.State), dummy.StorageProviders())
_, err := pm.Create(pool, provider.LoopProviderType, map[string]interface{}{})
c.Assert(err, jc.ErrorIsNil)
// There are test charms called "storage-block" and
// "storage-filesystem" which are what you'd expect.
ch := s.AddTestingCharm(c, "storage-"+kind)
storage := map[string]state.StorageConstraints{
"data": makeStorageCons(pool, 1024, 1),
}
service := s.AddTestingServiceWithStorage(c, "storage-"+kind, ch, storage)
unit, err := service.AddUnit()
machine := s.Factory.MakeMachine(c, nil)
err = unit.AssignToMachine(machine)
c.Assert(err, jc.ErrorIsNil)
c.Assert(err, jc.ErrorIsNil)
storageTag := names.NewStorageTag("data/0")
agentVersion := version.MustParseBinary("2.0.1-quantal-and64")
err = unit.SetAgentVersion(agentVersion)
c.Assert(err, jc.ErrorIsNil)
return service, unit, storageTag
}
func (s *clientSuite) TestUploadToolsOtherModel(c *gc.C) {
otherSt, otherAPISt := s.otherModel(c)
defer otherSt.Close()
defer otherAPISt.Close()
client := otherAPISt.Client()
newVersion := version.MustParseBinary("5.4.3-quantal-amd64")
var called bool
// build fake tools
expectedTools, _ := coretesting.TarGz(
coretesting.NewTarFile(jujunames.Jujud, 0777, "jujud contents "+newVersion.String()))
// UploadTools does not use the facades, so instead of patching the
// facade call, we set up a fake endpoint to test.
defer fakeAPIEndpoint(c, client, envEndpoint(c, otherAPISt, "tools"), "POST",
func(w http.ResponseWriter, r *http.Request) {
called = true
c.Assert(r.URL.Query(), gc.DeepEquals, url.Values{
"binaryVersion": []string{"5.4.3-quantal-amd64"},
"series": []string{""},
})
defer r.Body.Close()
obtainedTools, err := ioutil.ReadAll(r.Body)
c.Assert(err, jc.ErrorIsNil)
c.Assert(obtainedTools, gc.DeepEquals, expectedTools)
},
).Close()
// We don't test the error or tools results as we only wish to assert that
// the API client POSTs the tools archive to the correct endpoint.
client.UploadTools(bytes.NewReader(expectedTools), newVersion)
c.Assert(called, jc.IsTrue)
}
func (s *CloudInitSuite) TestWindowsUserdataEncoding(c *gc.C) {
series := "win8"
metricsSpoolDir := must(paths.MetricsSpoolDir("win8"))
toolsList := tools.List{
&tools.Tools{
URL: "http://foo.com/tools/released/juju1.2.3-win8-amd64.tgz",
Version: version.MustParseBinary("1.2.3-win8-amd64"),
Size: 10,
SHA256: "1234",
},
}
dataDir, err := paths.DataDir(series)
c.Assert(err, jc.ErrorIsNil)
logDir, err := paths.LogDir(series)
c.Assert(err, jc.ErrorIsNil)
cfg := instancecfg.InstanceConfig{
ControllerTag: testing.ControllerTag,
MachineId: "10",
AgentEnvironment: map[string]string{agent.ProviderType: "dummy"},
Series: series,
Jobs: []multiwatcher.MachineJob{multiwatcher.JobHostUnits},
MachineNonce: "FAKE_NONCE",
APIInfo: &api.Info{
Addrs: []string{"state-addr.testing.invalid:54321"},
Password: "******",
CACert: "CA CERT\n" + testing.CACert,
Tag: names.NewMachineTag("10"),
ModelTag: testing.ModelTag,
},
MachineAgentServiceName: "jujud-machine-10",
DataDir: dataDir,
LogDir: path.Join(logDir, "juju"),
MetricsSpoolDir: metricsSpoolDir,
CloudInitOutputLog: path.Join(logDir, "cloud-init-output.log"),
}
err = cfg.SetTools(toolsList)
c.Assert(err, jc.ErrorIsNil)
ci, err := cloudinit.New("win8")
c.Assert(err, jc.ErrorIsNil)
udata, err := cloudconfig.NewUserdataConfig(&cfg, ci)
c.Assert(err, jc.ErrorIsNil)
err = udata.Configure()
c.Assert(err, jc.ErrorIsNil)
data, err := ci.RenderYAML()
c.Assert(err, jc.ErrorIsNil)
cicompose, err := cloudinit.New("win8")
c.Assert(err, jc.ErrorIsNil)
base64Data := base64.StdEncoding.EncodeToString(utils.Gzip(data))
got := []byte(fmt.Sprintf(cloudconfig.UserDataScript, base64Data))
expected, err := providerinit.ComposeUserData(&cfg, cicompose, openstack.OpenstackRenderer{})
c.Assert(err, jc.ErrorIsNil)
c.Assert(string(got), gc.Equals, string(expected))
}
func newTools(vers, url string) *tools.Tools {
return &tools.Tools{
Version: version.MustParseBinary(vers),
URL: url,
Size: 10,
SHA256: "1234",
}
}