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 (s *UpgradeJujuSuite) TestUpgradeJuju(c *gc.C) {
for i, test := range upgradeJujuTests {
c.Logf("\ntest %d: %s", i, test.about)
s.Reset(c)
tools.DefaultBaseURL = ""
// Set up apparent CLI version and initialize the command.
s.PatchValue(&version.Current, version.MustParseBinary(test.currentVersion))
com := &UpgradeJujuCommand{}
if err := coretesting.InitCommand(envcmd.Wrap(com), test.args); err != nil {
if test.expectInitErr != "" {
c.Check(err, gc.ErrorMatches, test.expectInitErr)
} else {
c.Check(err, jc.ErrorIsNil)
}
continue
}
// Set up state and environ, and run the command.
toolsDir := c.MkDir()
updateAttrs := map[string]interface{}{
"agent-version": test.agentVersion,
"agent-metadata-url": "file://" + toolsDir + "/tools",
}
err := s.State.UpdateEnvironConfig(updateAttrs, nil, nil)
c.Assert(err, jc.ErrorIsNil)
versions := make([]version.Binary, len(test.tools))
for i, v := range test.tools {
versions[i] = version.MustParseBinary(v)
}
if len(versions) > 0 {
stor, err := filestorage.NewFileStorageWriter(toolsDir)
c.Assert(err, jc.ErrorIsNil)
envtesting.MustUploadFakeToolsVersions(stor, s.Environ.Config().AgentStream(), versions...)
}
err = com.Run(coretesting.Context(c))
if test.expectErr != "" {
c.Check(err, gc.ErrorMatches, test.expectErr)
continue
} else if !c.Check(err, jc.ErrorIsNil) {
continue
}
// Check expected changes to environ/state.
cfg, err := s.State.EnvironConfig()
c.Check(err, jc.ErrorIsNil)
agentVersion, ok := cfg.AgentVersion()
c.Check(ok, jc.IsTrue)
c.Check(agentVersion, gc.Equals, version.MustParse(test.expectVersion))
for _, uploaded := range test.expectUploaded {
// Substitute latest LTS for placeholder in expected series for uploaded tools
uploaded = strings.Replace(uploaded, "%LTS%", config.LatestLtsSeries(), 1)
vers := version.MustParseBinary(uploaded)
s.checkToolsUploaded(c, vers, agentVersion)
}
}
}
func (s *JujuConnSuite) setUpConn(c *gc.C) {
if s.RootDir != "" {
panic("JujuConnSuite.setUpConn without teardown")
}
s.RootDir = c.MkDir()
s.oldHome = utils.Home()
home := filepath.Join(s.RootDir, "/home/ubuntu")
err := os.MkdirAll(home, 0777)
c.Assert(err, gc.IsNil)
utils.SetHome(home)
s.oldJujuHome = osenv.SetJujuHome(filepath.Join(home, ".juju"))
err = os.Mkdir(osenv.JujuHome(), 0777)
c.Assert(err, gc.IsNil)
err = os.MkdirAll(s.DataDir(), 0777)
c.Assert(err, gc.IsNil)
s.PatchEnvironment(osenv.JujuEnvEnvKey, "")
// TODO(rog) remove these files and add them only when
// the tests specifically need them (in cmd/juju for example)
s.writeSampleConfig(c, osenv.JujuHomePath("environments.yaml"))
err = ioutil.WriteFile(osenv.JujuHomePath("dummyenv-cert.pem"), []byte(testing.CACert), 0666)
c.Assert(err, gc.IsNil)
err = ioutil.WriteFile(osenv.JujuHomePath("dummyenv-private-key.pem"), []byte(testing.CAKey), 0600)
c.Assert(err, gc.IsNil)
store, err := configstore.Default()
c.Assert(err, gc.IsNil)
s.ConfigStore = store
ctx := testing.Context(c)
environ, err := environs.PrepareFromName("dummyenv", ctx, s.ConfigStore)
c.Assert(err, gc.IsNil)
// sanity check we've got the correct environment.
c.Assert(environ.Config().Name(), gc.Equals, "dummyenv")
s.PatchValue(&dummy.DataDir, s.DataDir())
s.LogDir = c.MkDir()
s.PatchValue(&dummy.LogDir, s.LogDir)
versions := PreferredDefaultVersions(environ.Config(), version.Binary{Number: version.Current.Number, Series: "precise", Arch: "amd64"})
versions = append(versions, version.Current)
// Upload tools for both preferred and fake default series
envtesting.MustUploadFakeToolsVersions(environ.Storage(), versions...)
err = bootstrap.Bootstrap(ctx, environ, bootstrap.BootstrapParams{})
c.Assert(err, gc.IsNil)
s.BackingState = environ.(GetStater).GetStateInAPIServer()
s.State, err = newState(environ, s.BackingState.MongoConnectionInfo())
c.Assert(err, gc.IsNil)
s.APIState, err = juju.NewAPIState(environ, api.DialOpts{})
c.Assert(err, gc.IsNil)
s.Environ = environ
}
func (suite *environSuite) TestAcquireNodePassedAgentName(c *gc.C) {
stor := NewStorage(suite.makeEnviron())
fakeTools := envtesting.MustUploadFakeToolsVersions(stor, version.Current)[0]
env := suite.makeEnviron()
suite.testMAASObject.TestServer.NewNode(`{"system_id": "node0", "hostname": "host0"}`)
_, _, err := env.acquireNode("", constraints.Value{}, nil, nil, tools.List{fakeTools})
c.Check(err, gc.IsNil)
requestValues := suite.testMAASObject.TestServer.NodeOperationRequestValues()
nodeRequestValues, found := requestValues["node0"]
c.Assert(found, gc.Equals, true)
c.Assert(nodeRequestValues[0].Get("agent_name"), gc.Equals, exampleAgentName)
}
func (suite *environSuite) TestAcquireNodeTakesConstraintsIntoAccount(c *gc.C) {
stor := NewStorage(suite.makeEnviron())
fakeTools := envtesting.MustUploadFakeToolsVersions(stor, version.Current)[0]
env := suite.makeEnviron()
suite.testMAASObject.TestServer.NewNode(`{"system_id": "node0", "hostname": "host0"}`)
constraints := constraints.Value{Arch: stringp("arm"), Mem: uint64p(1024)}
_, _, err := env.acquireNode("", constraints, nil, nil, tools.List{fakeTools})
c.Check(err, gc.IsNil)
requestValues := suite.testMAASObject.TestServer.NodeOperationRequestValues()
nodeRequestValues, found := requestValues["node0"]
c.Assert(found, gc.Equals, true)
c.Assert(nodeRequestValues[0].Get("arch"), gc.Equals, "arm")
c.Assert(nodeRequestValues[0].Get("mem"), gc.Equals, "1024")
}
func (suite *environSuite) TestAcquireNodeByName(c *gc.C) {
stor := NewStorage(suite.makeEnviron())
fakeTools := envtesting.MustUploadFakeToolsVersions(stor, version.Current)[0]
env := suite.makeEnviron()
suite.testMAASObject.TestServer.NewNode(`{"system_id": "node0", "hostname": "host0"}`)
_, _, err := env.acquireNode("host0", constraints.Value{}, nil, nil, tools.List{fakeTools})
c.Check(err, gc.IsNil)
operations := suite.testMAASObject.TestServer.NodeOperations()
actions, found := operations["node0"]
c.Assert(found, gc.Equals, true)
c.Check(actions, gc.DeepEquals, []string{"acquire"})
// no "name" parameter should have been passed through
values := suite.testMAASObject.TestServer.NodeOperationRequestValues()["node0"][0]
nodeName := values.Get("name")
c.Assert(nodeName, gc.Equals, "host0")
}
func (s *UpgradeJujuSuite) TestUpgradeJuju(c *gc.C) {
oldVersion := version.Current
defer func() {
version.Current = oldVersion
}()
for i, test := range upgradeJujuTests {
c.Logf("\ntest %d: %s", i, test.about)
s.Reset(c)
// Set up apparent CLI version and initialize the command.
version.Current = version.MustParseBinary(test.currentVersion)
com := &UpgradeJujuCommand{}
if err := coretesting.InitCommand(envcmd.Wrap(com), test.args); err != nil {
if test.expectInitErr != "" {
c.Check(err, gc.ErrorMatches, test.expectInitErr)
} else {
c.Check(err, gc.IsNil)
}
continue
}
// Set up state and environ, and run the command.
toolsDir := c.MkDir()
updateAttrs := map[string]interface{}{
"agent-version": test.agentVersion,
"tools-metadata-url": "file://" + toolsDir,
}
err := s.State.UpdateEnvironConfig(updateAttrs, nil, nil)
c.Assert(err, gc.IsNil)
versions := make([]version.Binary, len(test.tools))
for i, v := range test.tools {
versions[i] = version.MustParseBinary(v)
}
if len(versions) > 0 {
envtesting.MustUploadFakeToolsVersions(s.Conn.Environ.Storage(), versions...)
stor, err := filestorage.NewFileStorageWriter(toolsDir)
c.Assert(err, gc.IsNil)
envtesting.MustUploadFakeToolsVersions(stor, versions...)
}
err = com.Run(coretesting.Context(c))
if test.expectErr != "" {
c.Check(err, gc.ErrorMatches, test.expectErr)
continue
} else if !c.Check(err, gc.IsNil) {
continue
}
// Check expected changes to environ/state.
cfg, err := s.State.EnvironConfig()
c.Check(err, gc.IsNil)
agentVersion, ok := cfg.AgentVersion()
c.Check(ok, gc.Equals, true)
c.Check(agentVersion, gc.Equals, version.MustParse(test.expectVersion))
for _, uploaded := range test.expectUploaded {
// Substitute latest LTS for placeholder in expected series for uploaded tools
uploaded = strings.Replace(uploaded, "%LTS%", config.LatestLtsSeries(), 1)
vers := version.MustParseBinary(uploaded)
r, err := storage.Get(s.Conn.Environ.Storage(), envtools.StorageName(vers))
if !c.Check(err, gc.IsNil) {
continue
}
data, err := ioutil.ReadAll(r)
r.Close()
c.Check(err, gc.IsNil)
expectContent := version.Current
expectContent.Number = agentVersion
checkToolsContent(c, data, "jujud contents "+expectContent.String())
}
}
}
func (s *UpgradeJujuSuite) TestUpgradeDryRun(c *gc.C) {
tests := []DryRunTest{
DryRunTest{
about: "dry run outputs and doesn't change anything when uploading tools",
cmdArgs: []string{"--upload-tools", "--dry-run"},
tools: []string{"2.2.0-quantal-amd64", "2.2.2-quantal-i386", "2.2.3-quantal-amd64"},
currentVersion: "2.0.0-quantal-amd64",
agentVersion: "2.0.0",
expectedCmdOutput: `available tools:
2.2.0-quantal-amd64
2.2.2-quantal-i386
2.2.3-quantal-amd64
best version:
2.2.3
upgrade to this version by running
juju upgrade-juju --version="2.2.3"
`,
},
DryRunTest{
about: "dry run outputs and doesn't change anything",
cmdArgs: []string{"--dry-run"},
tools: []string{"2.2.0-quantal-amd64", "2.2.2-quantal-i386", "2.2.3-quantal-amd64"},
currentVersion: "2.0.0-quantal-amd64",
agentVersion: "2.0.0",
expectedCmdOutput: `available tools:
2.2.0-quantal-amd64
2.2.2-quantal-i386
2.2.3-quantal-amd64
best version:
2.2.3
upgrade to this version by running
juju upgrade-juju --version="2.2.3"
`,
},
}
for i, test := range tests {
c.Logf("\ntest %d: %s", i, test.about)
s.PatchValue(&version.Current, version.MustParseBinary(test.currentVersion))
com := &UpgradeJujuCommand{}
err := coretesting.InitCommand(envcmd.Wrap(com), test.cmdArgs)
c.Assert(err, gc.IsNil)
toolsDir := c.MkDir()
updateAttrs := map[string]interface{}{
"agent-version": test.agentVersion,
"tools-metadata-url": "file://" + toolsDir,
}
err = s.State.UpdateEnvironConfig(updateAttrs, nil, nil)
c.Assert(err, gc.IsNil)
versions := make([]version.Binary, len(test.tools))
for i, v := range test.tools {
versions[i] = version.MustParseBinary(v)
}
if len(versions) > 0 {
envtesting.MustUploadFakeToolsVersions(s.Conn.Environ.Storage(), versions...)
stor, err := filestorage.NewFileStorageWriter(toolsDir)
c.Assert(err, gc.IsNil)
envtesting.MustUploadFakeToolsVersions(stor, versions...)
}
ctx := coretesting.Context(c)
err = com.Run(ctx)
c.Assert(err, gc.IsNil)
// Check agent version doesn't change
cfg, err := s.State.EnvironConfig()
c.Assert(err, gc.IsNil)
agentVer, ok := cfg.AgentVersion()
c.Assert(ok, gc.Equals, true)
c.Assert(agentVer, gc.Equals, version.MustParse(test.agentVersion))
output := coretesting.Stderr(ctx)
c.Assert(output, gc.Equals, test.expectedCmdOutput)
}
}
func (s *UpgradeJujuSuite) TestUpgradeDryRun(c *gc.C) {
tests := []DryRunTest{
{
about: "dry run outputs and doesn't change anything when uploading tools",
cmdArgs: []string{"--upload-tools", "--dry-run"},
tools: []string{"2.1.0-quantal-amd64", "2.1.2-quantal-i386", "2.1.3-quantal-amd64", "2.1-dev1-quantal-amd64", "2.2.3-quantal-amd64"},
currentVersion: "2.0.0-quantal-amd64",
agentVersion: "2.0.0",
expectedCmdOutput: `available tools:
2.1-dev1-quantal-amd64
2.1.0-quantal-amd64
2.1.2-quantal-i386
2.1.3-quantal-amd64
2.2.3-quantal-amd64
best version:
2.1.3
upgrade to this version by running
juju upgrade-juju --version="2.1.3"
`,
},
{
about: "dry run outputs and doesn't change anything",
cmdArgs: []string{"--dry-run"},
tools: []string{"2.1.0-quantal-amd64", "2.1.2-quantal-i386", "2.1.3-quantal-amd64", "2.1-dev1-quantal-amd64", "2.2.3-quantal-amd64"},
currentVersion: "2.0.0-quantal-amd64",
agentVersion: "2.0.0",
expectedCmdOutput: `available tools:
2.1-dev1-quantal-amd64
2.1.0-quantal-amd64
2.1.2-quantal-i386
2.1.3-quantal-amd64
2.2.3-quantal-amd64
best version:
2.1.3
upgrade to this version by running
juju upgrade-juju --version="2.1.3"
`,
},
{
about: "dry run ignores unknown series",
cmdArgs: []string{"--dry-run"},
tools: []string{"2.1.0-quantal-amd64", "2.1.2-quantal-i386", "2.1.3-quantal-amd64", "1.2.3-myawesomeseries-amd64"},
currentVersion: "2.0.0-quantal-amd64",
agentVersion: "2.0.0",
expectedCmdOutput: `available tools:
2.1.0-quantal-amd64
2.1.2-quantal-i386
2.1.3-quantal-amd64
best version:
2.1.3
upgrade to this version by running
juju upgrade-juju --version="2.1.3"
`,
},
}
for i, test := range tests {
c.Logf("\ntest %d: %s", i, test.about)
s.Reset(c)
tools.DefaultBaseURL = ""
current := version.MustParseBinary(test.currentVersion)
s.PatchValue(&version.Current, current.Number)
s.PatchValue(&arch.HostArch, func() string { return current.Arch })
s.PatchValue(&series.HostSeries, func() string { return current.Series })
var com upgradeJujuCommand
err := coretesting.InitCommand(envcmd.Wrap(&com), test.cmdArgs)
c.Assert(err, jc.ErrorIsNil)
toolsDir := c.MkDir()
updateAttrs := map[string]interface{}{
"agent-version": test.agentVersion,
"agent-metadata-url": "file://" + toolsDir + "/tools",
}
err = s.State.UpdateEnvironConfig(updateAttrs, nil, nil)
c.Assert(err, jc.ErrorIsNil)
versions := make([]version.Binary, len(test.tools))
for i, v := range test.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...)
}
ctx := coretesting.Context(c)
err = envcmd.Wrap(&com).Run(ctx)
c.Assert(err, jc.ErrorIsNil)
// Check agent version doesn't change
cfg, err := s.State.EnvironConfig()
c.Assert(err, jc.ErrorIsNil)
agentVer, ok := cfg.AgentVersion()
c.Assert(ok, jc.IsTrue)
c.Assert(agentVer, gc.Equals, version.MustParse(test.agentVersion))
output := coretesting.Stderr(ctx)
c.Assert(output, gc.Equals, test.expectedCmdOutput)
}
}