func (s *upgradeSuite) TestPerformUpgrade(c *gc.C) {
s.PatchValue(upgrades.UpgradeOperations, upgradeOperations)
for i, test := range upgradeTests {
c.Logf("%d: %s", i, test.about)
var messages []string
ctx := &mockContext{
messages: messages,
}
fromVersion := version.Zero
if test.fromVersion != "" {
fromVersion = version.MustParse(test.fromVersion)
}
toVersion := version.MustParse("1.18.0")
if test.toVersion != "" {
toVersion = version.MustParse(test.toVersion)
}
vers := version.Current
vers.Number = toVersion
s.PatchValue(&version.Current, vers)
err := upgrades.PerformUpgrade(fromVersion, test.target, ctx)
if test.err == "" {
c.Check(err, gc.IsNil)
} else {
c.Check(err, gc.ErrorMatches, test.err)
}
c.Check(ctx.messages, jc.DeepEquals, test.expectedSteps)
}
}
func (*format_1_16Suite) TestReadConfReadsLegacyFormatAndWritesNew(c *gc.C) {
dataDir := c.MkDir()
formatPath := filepath.Join(dataDir, legacyFormatFilename)
err := utils.AtomicWriteFile(formatPath, []byte(legacyFormatFileContents), 0600)
c.Assert(err, gc.IsNil)
configPath := filepath.Join(dataDir, agentConfigFilename)
err = utils.AtomicWriteFile(configPath, []byte(agentConfig1_16Contents), 0600)
c.Assert(err, gc.IsNil)
config, err := ReadConfig(configPath)
c.Assert(err, gc.IsNil)
c.Assert(config, gc.NotNil)
// Test we wrote a currently valid config.
config, err = ReadConfig(configPath)
c.Assert(err, gc.IsNil)
c.Assert(config, gc.NotNil)
c.Assert(config.UpgradedToVersion(), jc.DeepEquals, version.MustParse("1.16.0"))
c.Assert(config.Jobs(), gc.HasLen, 0)
// Old format was deleted.
assertFileNotExist(c, formatPath)
// And new contents were written.
data, err := ioutil.ReadFile(configPath)
c.Assert(err, gc.IsNil)
c.Assert(string(data), gc.Not(gc.Equals), agentConfig1_16Contents)
}
func (s *AllowedTargetVersionSuite) TestAllowedTargetVersionSuite(c *gc.C) {
cases := []allowedTest{
{current: "1.2.3", target: "1.3.3", allowed: true},
{current: "1.2.3", target: "1.2.3", allowed: true},
{current: "1.2.3", target: "2.2.3", allowed: true},
{current: "1.2.3", target: "1.1.3", allowed: false},
{current: "1.2.3", target: "1.2.2", allowed: true},
{current: "1.2.3", target: "0.2.3", allowed: false},
}
for i, test := range cases {
c.Logf("test case %d, %#v", i, test)
current := version.MustParse(test.current)
target := version.MustParse(test.target)
c.Check(upgrader.AllowedTargetVersion(current, target), gc.Equals, test.allowed)
}
}
// binary returns the tools metadata's binary version,
// which may be used for map lookup.
func (t *ToolsMetadata) binary() version.Binary {
return version.Binary{
Number: version.MustParse(t.Version),
Series: t.Release,
Arch: t.Arch,
}
}
func (st *State) checkCanUpgrade(currentVersion, newVersion string) error {
matchCurrent := "^" + regexp.QuoteMeta(currentVersion) + "-"
matchNew := "^" + regexp.QuoteMeta(newVersion) + "-"
// Get all machines and units with a different or empty version.
sel := bson.D{{"$or", []bson.D{
{{"tools", bson.D{{"$exists", false}}}},
{{"$and", []bson.D{
{{"tools.version", bson.D{{"$not", bson.RegEx{matchCurrent, ""}}}}},
{{"tools.version", bson.D{{"$not", bson.RegEx{matchNew, ""}}}}},
}}},
}}}
var agentTags []string
for _, collection := range []*mgo.Collection{st.machines, st.units} {
var doc struct {
Id string `bson:"_id"`
}
iter := collection.Find(sel).Select(bson.D{{"_id", 1}}).Iter()
for iter.Next(&doc) {
switch collection.Name {
case "machines":
agentTags = append(agentTags, names.MachineTag(doc.Id))
case "units":
agentTags = append(agentTags, names.UnitTag(doc.Id))
}
}
if err := iter.Err(); err != nil {
return err
}
}
if len(agentTags) > 0 {
return newVersionInconsistentError(version.MustParse(currentVersion), agentTags)
}
return nil
}
func (s *productSpecSuite) TestId(c *gc.C) {
toolsConstraint := tools.NewVersionedToolsConstraint(version.MustParse("1.13.0"), simplestreams.LookupParams{
Series: []string{"precise"},
Arches: []string{"amd64"},
})
ids, err := toolsConstraint.Ids()
c.Assert(err, gc.IsNil)
c.Assert(ids, gc.DeepEquals, []string{"com.ubuntu.juju:12.04:amd64"})
}
func (*suite) TestSetUpgradedToVersion(c *gc.C) {
conf, err := agent.NewAgentConfig(attributeParams)
c.Assert(err, gc.IsNil)
c.Assert(conf.UpgradedToVersion(), gc.Equals, version.Current.Number)
expectVers := version.MustParse("3.4.5")
conf.SetUpgradedToVersion(expectVers)
c.Assert(conf.UpgradedToVersion(), gc.Equals, expectVers)
}
func (*format_1_18Suite) TestReadConfWithExisting1_18ConfigFileContents(c *gc.C) {
dataDir := c.MkDir()
configPath := filepath.Join(dataDir, agentConfigFilename)
err := utils.AtomicWriteFile(configPath, []byte(agentConfig1_18Contents), 0600)
c.Assert(err, gc.IsNil)
config, err := ReadConfig(configPath)
c.Assert(err, gc.IsNil)
c.Assert(config.UpgradedToVersion(), jc.DeepEquals, version.MustParse("1.17.5.1"))
c.Assert(config.Jobs(), jc.DeepEquals, []params.MachineJob{params.JobManageEnviron})
}
func (s *format_1_18Suite) TestMissingAttributes(c *gc.C) {
dataDir := c.MkDir()
configPath := filepath.Join(dataDir, agentConfigFilename)
err := utils.AtomicWriteFile(configPath, []byte(configData1_18WithoutUpgradedToVersion), 0600)
c.Assert(err, gc.IsNil)
readConfig, err := ReadConfig(configPath)
c.Assert(err, gc.IsNil)
c.Assert(readConfig.UpgradedToVersion(), gc.Equals, version.MustParse("1.16.0"))
c.Assert(readConfig.LogDir(), gc.Equals, "/var/log/juju")
c.Assert(readConfig.DataDir(), gc.Equals, "/var/lib/juju")
}
// ValidateToolsMetadata attempts to load tools metadata for the specified cloud attributes and returns
// any tools versions found, or an error if the metadata could not be loaded.
func ValidateToolsMetadata(params *ToolsMetadataLookupParams) ([]string, *simplestreams.ResolveInfo, error) {
if len(params.Architectures) == 0 {
return nil, nil, fmt.Errorf("required parameter arches not specified")
}
if len(params.Sources) == 0 {
return nil, nil, fmt.Errorf("required parameter sources not specified")
}
if params.Version == "" && params.Major == 0 {
params.Version = version.Current.Number.String()
}
var toolsConstraint *ToolsConstraint
if params.Version == "" {
toolsConstraint = NewGeneralToolsConstraint(params.Major, params.Minor, false, simplestreams.LookupParams{
CloudSpec: simplestreams.CloudSpec{
Region: params.Region,
Endpoint: params.Endpoint,
},
Series: []string{params.Series},
Arches: params.Architectures,
})
} else {
versNum, err := version.Parse(params.Version)
if err != nil {
return nil, nil, err
}
toolsConstraint = NewVersionedToolsConstraint(versNum, simplestreams.LookupParams{
CloudSpec: simplestreams.CloudSpec{
Region: params.Region,
Endpoint: params.Endpoint,
},
Series: []string{params.Series},
Arches: params.Architectures,
})
}
matchingTools, resolveInfo, err := Fetch(params.Sources, simplestreams.DefaultIndexPath, toolsConstraint, false)
if err != nil {
return nil, resolveInfo, err
}
if len(matchingTools) == 0 {
return nil, resolveInfo, fmt.Errorf("no matching tools found for constraint %+v", toolsConstraint)
}
versions := make([]string, len(matchingTools))
for i, tm := range matchingTools {
vers := version.Binary{
Number: version.MustParse(tm.Version),
Series: tm.Release,
Arch: tm.Arch,
}
versions[i] = vers.String()
}
return versions, resolveInfo, nil
}
func (s *machineUpgraderSuite) TestWatchAPIVersion(c *gc.C) {
w, err := s.st.WatchAPIVersion(s.rawMachine.Tag())
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewNotifyWatcherC(c, s.BackingState, w)
// Initial event
wc.AssertOneChange()
vers := version.MustParse("10.20.34")
err = statetesting.SetAgentVersion(s.BackingState, vers)
c.Assert(err, gc.IsNil)
// One change noticing the new version
wc.AssertOneChange()
// Setting the version to the same value doesn't trigger a change
err = statetesting.SetAgentVersion(s.BackingState, vers)
c.Assert(err, gc.IsNil)
wc.AssertNoChange()
vers = version.MustParse("10.20.35")
err = statetesting.SetAgentVersion(s.BackingState, vers)
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *BootstrapSuite) TestInvalidLocalSource(c *gc.C) {
s.PatchValue(&version.Current.Number, version.MustParse("1.2.0"))
env, fake := makeEmptyFakeHome(c)
defer fake.Restore()
// Bootstrap the environment with an invalid source.
// The command returns with an error.
ctx := coretesting.Context(c)
code := cmd.Main(&BootstrapCommand{}, ctx, []string{"--metadata-source", c.MkDir()})
c.Check(code, gc.Equals, 1)
// Now check that there are no tools available.
_, err := envtools.FindTools(
env, version.Current.Major, version.Current.Minor, coretools.Filter{}, envtools.DoNotAllowRetry)
c.Assert(err, gc.FitsTypeOf, errors.NotFoundf(""))
}
func (s *BootstrapSuite) TestAutoSyncLocalSource(c *gc.C) {
sourceDir := createToolsSource(c, vAll)
s.PatchValue(&version.Current.Number, version.MustParse("1.2.0"))
env, fake := makeEmptyFakeHome(c)
defer fake.Restore()
// Bootstrap the environment with the valid source.
// The bootstrapping has to show no error, because the tools
// are automatically synchronized.
ctx := coretesting.Context(c)
code := cmd.Main(&BootstrapCommand{}, ctx, []string{"--metadata-source", sourceDir})
c.Check(code, gc.Equals, 0)
// Now check the available tools which are the 1.2.0 envtools.
checkTools(c, env, v120All)
}
func (s *format_1_16Suite) TestMissingAttributes(c *gc.C) {
dataDir := c.MkDir()
formatPath := filepath.Join(dataDir, legacyFormatFilename)
err := utils.AtomicWriteFile(formatPath, []byte(legacyFormatFileContents), 0600)
c.Assert(err, gc.IsNil)
configPath := filepath.Join(dataDir, agentConfigFilename)
err = utils.AtomicWriteFile(configPath, []byte(configDataWithoutNewAttributes), 0600)
c.Assert(err, gc.IsNil)
readConfig, err := ReadConfig(configPath)
c.Assert(err, gc.IsNil)
c.Assert(readConfig.UpgradedToVersion(), gc.Equals, version.MustParse("1.16.0"))
c.Assert(readConfig.LogDir(), gc.Equals, "/var/log/juju")
c.Assert(readConfig.DataDir(), gc.Equals, "/var/lib/juju")
// Test data doesn't include a StateServerKey so StateServingInfo
// should *not* be available
_, available := readConfig.StateServingInfo()
c.Assert(available, gc.Equals, false)
}
func (*suite) TestNumberMarshalUnmarshal(c *gc.C) {
for _, m := range marshallers {
c.Logf("encoding %v", m.name)
type doc struct {
Version *version.Number
}
// Work around goyaml bug #1096149
// SetYAML is not called for non-pointer fields.
np := version.MustParse("1.2.3")
v := doc{&np}
data, err := m.marshal(&v)
c.Assert(err, gc.IsNil)
var nv doc
err = m.unmarshal(data, &nv)
c.Assert(err, gc.IsNil)
c.Assert(nv, gc.DeepEquals, v)
}
}
func registerSimpleStreamsTests() {
gc.Suite(&simplestreamsSuite{
LocalLiveSimplestreamsSuite: sstesting.LocalLiveSimplestreamsSuite{
Source: simplestreams.NewURLDataSource("test", "test:", utils.VerifySSLHostnames),
RequireSigned: false,
DataType: tools.ContentDownload,
ValidConstraint: tools.NewVersionedToolsConstraint(version.MustParse("1.13.0"), simplestreams.LookupParams{
CloudSpec: simplestreams.CloudSpec{
Region: "us-east-1",
Endpoint: "https://ec2.us-east-1.amazonaws.com",
},
Series: []string{"precise"},
Arches: []string{"amd64", "arm"},
}),
},
})
gc.Suite(&signedSuite{})
}
func opClientSetEnvironAgentVersion(c *gc.C, st *api.State, mst *state.State) (func(), error) {
attrs, err := st.Client().EnvironmentGet()
if err != nil {
return func() {}, err
}
err = st.Client().SetEnvironAgentVersion(version.Current.Number)
if err != nil {
return func() {}, err
}
return func() {
oldAgentVersion, found := attrs["agent-version"]
if found {
versionString := oldAgentVersion.(string)
st.Client().SetEnvironAgentVersion(version.MustParse(versionString))
}
}, nil
}
func (s *syncSuite) setUpTest(c *gc.C) {
s.LoggingSuite.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.
fakeHome := coretesting.MakeFakeHome(c, `
environments:
test-target:
type: dummy
state-server: false
authorized-keys: "not-really-one"
`)
s.AddCleanup(func(*gc.C) { fakeHome.Restore() })
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()
}
ttesting.MakeTools(c, baseDir, "releases", versionStrings)
ttesting.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 (s *signedSuite) TestSignedToolsMetadata(c *gc.C) {
signedSource := simplestreams.NewURLDataSource("test", "signedtest://host/signed", utils.VerifySSLHostnames)
toolsConstraint := tools.NewVersionedToolsConstraint(version.MustParse("1.13.0"), simplestreams.LookupParams{
CloudSpec: simplestreams.CloudSpec{"us-east-1", "https://ec2.us-east-1.amazonaws.com"},
Series: []string{"precise"},
Arches: []string{"amd64"},
})
toolsMetadata, resolveInfo, err := tools.Fetch(
[]simplestreams.DataSource{signedSource}, simplestreams.DefaultIndexPath, toolsConstraint, true)
c.Assert(err, gc.IsNil)
c.Assert(len(toolsMetadata), gc.Equals, 1)
c.Assert(toolsMetadata[0].Path, gc.Equals, "tools/releases/20130806/juju-1.13.1-precise-amd64.tgz")
c.Assert(resolveInfo, gc.DeepEquals, &simplestreams.ResolveInfo{
Source: "test",
Signed: true,
IndexURL: "signedtest://host/signed/streams/v1/index.sjson",
MirrorURL: "",
})
}
func setupSimpleStreamsTests(t *testing.T) {
if *live {
if *vendor == "" {
t.Fatal("missing vendor")
}
var ok bool
var testData liveTestData
if testData, ok = liveUrls[*vendor]; !ok {
keys := reflect.ValueOf(liveUrls).MapKeys()
t.Fatalf("Unknown vendor %s. Must be one of %s", *vendor, keys)
}
registerLiveSimpleStreamsTests(testData.baseURL,
tools.NewVersionedToolsConstraint(version.MustParse("1.13.0"), simplestreams.LookupParams{
CloudSpec: testData.validCloudSpec,
Series: []string{version.Current.Series},
Arches: []string{"amd64"},
}), testData.requireSigned)
}
registerSimpleStreamsTests()
}
func upgradeOperations() []upgrades.Operation {
steps := []upgrades.Operation{
&mockUpgradeOperation{
targetVersion: version.MustParse("1.12.0"),
steps: []upgrades.Step{
&mockUpgradeStep{"step 1 - 1.12.0", nil},
&mockUpgradeStep{"step 2 error", targets(upgrades.HostMachine)},
&mockUpgradeStep{"step 3", targets(upgrades.HostMachine)},
},
},
&mockUpgradeOperation{
targetVersion: version.MustParse("1.16.0"),
steps: []upgrades.Step{
&mockUpgradeStep{"step 1 - 1.16.0", targets(upgrades.HostMachine)},
&mockUpgradeStep{"step 2 - 1.16.0", targets(upgrades.HostMachine)},
&mockUpgradeStep{"step 3 - 1.16.0", targets(upgrades.StateServer)},
},
},
&mockUpgradeOperation{
targetVersion: version.MustParse("1.17.0"),
steps: []upgrades.Step{
&mockUpgradeStep{"step 1 - 1.17.0", targets(upgrades.HostMachine)},
},
},
&mockUpgradeOperation{
targetVersion: version.MustParse("1.17.1"),
steps: []upgrades.Step{
&mockUpgradeStep{"step 1 - 1.17.1", targets(upgrades.HostMachine)},
&mockUpgradeStep{"step 2 - 1.17.1", targets(upgrades.StateServer)},
},
},
&mockUpgradeOperation{
targetVersion: version.MustParse("1.18.0"),
steps: []upgrades.Step{
&mockUpgradeStep{"step 1 - 1.18.0", targets(upgrades.HostMachine)},
&mockUpgradeStep{"step 2 - 1.18.0", targets(upgrades.StateServer)},
},
},
&mockUpgradeOperation{
targetVersion: version.MustParse("1.20.0"),
steps: []upgrades.Step{
&mockUpgradeStep{"step 1 - 1.20.0", targets(upgrades.AllMachines)},
&mockUpgradeStep{"step 2 - 1.20.0", targets(upgrades.HostMachine)},
&mockUpgradeStep{"step 3 - 1.20.0", targets(upgrades.StateServer)},
},
},
}
return steps
}
func (s *BootstrapSuite) setupAutoUploadTest(c *gc.C, vers, series string) environs.Environ {
s.PatchValue(&sync.Upload, mockUploadTools)
sourceDir := createToolsSource(c, vAll)
s.PatchValue(&envtools.DefaultBaseURL, sourceDir)
// Change the tools location to be the test location and also
// the version and ensure their later restoring.
// Set the current version to be something for which there are no tools
// so we can test that an upload is forced.
origVersion := version.Current
version.Current.Number = version.MustParse(vers)
version.Current.Series = series
s.AddCleanup(func(*gc.C) { version.Current = origVersion })
// Create home with dummy provider and remove all
// of its envtools.
env, fake := makeEmptyFakeHome(c)
s.AddCleanup(func(*gc.C) { fake.Restore() })
return env
}
// PerformUpgrade runs the business logic needed to upgrade the current "from" version to this
// version of Juju on the "target" type of machine.
func PerformUpgrade(from version.Number, target Target, context Context) error {
// If from is not known, it is 1.16.
if from == version.Zero {
from = version.MustParse("1.16.0")
}
for _, upgradeOps := range upgradeOperations() {
targetVersion := upgradeOps.TargetVersion()
// Do not run steps for versions of Juju earlier or same as we are upgrading from.
if targetVersion.Compare(from) <= 0 {
continue
}
// Do not run steps for versions of Juju later than we are upgrading to.
if targetVersion.Compare(version.Current.Number) > 0 {
continue
}
if err := runUpgradeSteps(context, target, upgradeOps); err != nil {
return err
}
}
return nil
}
func (s *upgraderSuite) TestWatchAPIVersion(c *gc.C) {
args := params.Entities{
Entities: []params.Entity{{Tag: s.rawMachine.Tag()}},
}
results, err := s.upgrader.WatchAPIVersion(args)
c.Assert(err, gc.IsNil)
c.Check(results.Results, gc.HasLen, 1)
c.Check(results.Results[0].NotifyWatcherId, gc.Not(gc.Equals), "")
c.Check(results.Results[0].Error, gc.IsNil)
resource := s.resources.Get(results.Results[0].NotifyWatcherId)
c.Check(resource, gc.NotNil)
w := resource.(state.NotifyWatcher)
wc := statetesting.NewNotifyWatcherC(c, s.State, w)
wc.AssertNoChange()
err = statetesting.SetAgentVersion(s.State, version.MustParse("3.4.567.8"))
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *simplestreamsSuite) TestFetch(c *gc.C) {
for i, t := range fetchTests {
c.Logf("test %d", i)
var toolsConstraint *tools.ToolsConstraint
if t.version == "" {
toolsConstraint = tools.NewGeneralToolsConstraint(t.major, t.minor, t.released, simplestreams.LookupParams{
CloudSpec: simplestreams.CloudSpec{"us-east-1", "https://ec2.us-east-1.amazonaws.com"},
Series: []string{t.series},
Arches: t.arches,
})
} else {
toolsConstraint = tools.NewVersionedToolsConstraint(version.MustParse(t.version),
simplestreams.LookupParams{
CloudSpec: simplestreams.CloudSpec{"us-east-1", "https://ec2.us-east-1.amazonaws.com"},
Series: []string{t.series},
Arches: t.arches,
})
}
// Add invalid datasource and check later that resolveInfo is correct.
invalidSource := simplestreams.NewURLDataSource("invalid", "file://invalid", utils.VerifySSLHostnames)
tools, resolveInfo, err := tools.Fetch(
[]simplestreams.DataSource{invalidSource, s.Source},
simplestreams.DefaultIndexPath, toolsConstraint, s.RequireSigned)
if !c.Check(err, gc.IsNil) {
continue
}
for _, tm := range t.tools {
tm.FullPath, err = s.Source.URL(tm.Path)
c.Assert(err, gc.IsNil)
}
c.Check(tools, gc.DeepEquals, t.tools)
c.Check(resolveInfo, gc.DeepEquals, &simplestreams.ResolveInfo{
Source: "test",
Signed: s.RequireSigned,
IndexURL: "test:/streams/v1/index.json",
MirrorURL: "",
})
}
}
// appendMatchingTools updates matchingTools with tools metadata records from tools which belong to the
// specified series. If a tools record already exists in matchingTools, it is not overwritten.
func appendMatchingTools(source simplestreams.DataSource, matchingTools []interface{},
tools map[string]interface{}, cons simplestreams.LookupConstraint) []interface{} {
toolsMap := make(map[version.Binary]*ToolsMetadata, len(matchingTools))
for _, val := range matchingTools {
tm := val.(*ToolsMetadata)
toolsMap[tm.binary()] = tm
}
for _, val := range tools {
tm := val.(*ToolsMetadata)
if !set.NewStrings(cons.Params().Series...).Contains(tm.Release) {
continue
}
if toolsConstraint, ok := cons.(*ToolsConstraint); ok {
tmNumber := version.MustParse(tm.Version)
if toolsConstraint.Version == version.Zero {
if toolsConstraint.Released && tmNumber.IsDev() {
continue
}
if toolsConstraint.MajorVersion >= 0 && toolsConstraint.MajorVersion != tmNumber.Major {
continue
}
if toolsConstraint.MinorVersion >= 0 && toolsConstraint.MinorVersion != tmNumber.Minor {
continue
}
} else {
if toolsConstraint.Version != tmNumber {
continue
}
}
}
if _, ok := toolsMap[tm.binary()]; !ok {
tm.FullPath, _ = source.URL(tm.Path)
matchingTools = append(matchingTools, tm)
}
}
return matchingTools
}
func (s *MachineSuite) TestMachineAgentUpgradeMongo(c *gc.C) {
m, agentConfig, _ := s.primeAgent(c, version.Current, state.JobManageEnviron)
agentConfig.SetUpgradedToVersion(version.MustParse("1.18.0"))
err := agentConfig.Write()
c.Assert(err, gc.IsNil)
err = s.State.MongoSession().DB("admin").RemoveUser(m.Tag())
c.Assert(err, gc.IsNil)
s.PatchValue(&ensureMongoAdminUser, func(p mongo.EnsureAdminUserParams) (bool, error) {
err := s.State.MongoSession().DB("admin").AddUser(p.User, p.Password, false)
c.Assert(err, gc.IsNil)
return true, nil
})
stateOpened := make(chan eitherState, 1)
s.PatchValue(&reportOpenedState, func(st eitherState) {
select {
case stateOpened <- st:
default:
}
})
// Start the machine agent, and wait for state to be opened.
a := s.newAgent(c, m)
done := make(chan error)
go func() { done <- a.Run(nil) }()
defer a.Stop() // in case of failure
select {
case st := <-stateOpened:
c.Assert(st, gc.NotNil)
case <-time.After(coretesting.LongWait):
c.Fatalf("state not opened")
}
s.waitStopped(c, state.JobManageEnviron, a, done)
c.Assert(s.fakeEnsureMongo.ensureCount, gc.Equals, 1)
c.Assert(s.fakeEnsureMongo.initiateCount, gc.Equals, 1)
}
func (s *migrateLocalProviderAgentConfigSuite) primeConfig(c *gc.C, st *state.State, job state.MachineJob, tag string) {
rootDir := c.MkDir()
sharedStorageDir := filepath.Join(rootDir, "shared-storage")
c.Assert(os.MkdirAll(sharedStorageDir, 0755), gc.IsNil)
localLogDir := filepath.Join(rootDir, "log")
c.Assert(os.MkdirAll(localLogDir, 0755), gc.IsNil)
initialConfig, err := agent.NewAgentConfig(agent.AgentConfigParams{
Tag: tag,
Password: "******",
CACert: testing.CACert,
StateAddresses: []string{"localhost:1111"},
DataDir: agent.DefaultDataDir,
LogDir: agent.DefaultLogDir,
UpgradedToVersion: version.MustParse("1.16.0"),
Values: map[string]string{
"SHARED_STORAGE_ADDR": "blah",
"SHARED_STORAGE_DIR": sharedStorageDir,
},
})
c.Assert(err, gc.IsNil)
s.config = initialConfig
c.Assert(s.config.Write(), gc.IsNil)
apiState, _ := s.OpenAPIAsNewMachine(c, job)
s.ctx = &mockContext{
realAgentConfig: initialConfig,
apiState: apiState,
state: st,
}
newCfg := (map[string]interface{}{
"root-dir": rootDir,
})
err = s.State.UpdateEnvironConfig(newCfg, nil, nil)
c.Assert(err, gc.IsNil)
}
// Copyright 2014 Canonical Ltd.
// Licensed under the AGPLv3, see LICENCE file for details.
package upgrades
import "github.com/wallyworld/core/version"
// upgradeOperations returns an ordered slice of sets of operations needed
// to upgrade Juju to particular version. The slice is ordered by target
// version, so that the sets of operations are executed in order from oldest
// version to most recent.
var upgradeOperations = func() []Operation {
steps := []Operation{
upgradeToVersion{
version.MustParse("1.18.0"),
stepsFor118(),
},
}
return steps
}
c.Logf("removing files: %v", names)
for _, name := range names {
err = stor.Remove(name)
c.Check(err, gc.IsNil)
}
RemoveFakeToolsMetadata(c, stor)
}
// RemoveAllTools deletes all tools from the supplied environment.
func RemoveAllTools(c *gc.C, env environs.Environ) {
c.Logf("clearing private storage")
RemoveTools(c, env.Storage())
}
var (
V100 = version.MustParse("1.0.0")
V100p64 = version.MustParseBinary("1.0.0-precise-amd64")
V100p32 = version.MustParseBinary("1.0.0-precise-i386")
V100p = []version.Binary{V100p64, V100p32}
V100q64 = version.MustParseBinary("1.0.0-quantal-amd64")
V100q32 = version.MustParseBinary("1.0.0-quantal-i386")
V100q = []version.Binary{V100q64, V100q32}
V100all = append(V100p, V100q...)
V1001 = version.MustParse("1.0.0.1")
V1001p64 = version.MustParseBinary("1.0.0.1-precise-amd64")
V100Xall = append(V100all, V1001p64)
V110 = version.MustParse("1.1.0")
V110p64 = version.MustParseBinary("1.1.0-precise-amd64")
