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 *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 *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 *UpgraderSuite) TestUpgraderSetsTools(c *gc.C) { vers := version.MustParseBinary("5.4.3-precise-amd64") err := statetesting.SetAgentVersion(s.State, vers.Number) c.Assert(err, gc.IsNil) stor := s.Conn.Environ.Storage() agentTools := envtesting.PrimeTools(c, stor, s.DataDir(), vers) s.PatchValue(&version.Current, agentTools.Version) err = envtools.MergeAndWriteMetadata(stor, coretools.List{agentTools}, envtools.DoNotWriteMirrors) _, err = s.machine.AgentTools() c.Assert(err, jc.Satisfies, errors.IsNotFound) u := s.makeUpgrader() statetesting.AssertStop(c, u) s.machine.Refresh() gotTools, err := s.machine.AgentTools() c.Assert(err, gc.IsNil) envtesting.CheckTools(c, gotTools, agentTools) }
func (s *UpgraderSuite) TestUpgraderSetVersion(c *gc.C) { vers := version.MustParseBinary("5.4.3-precise-amd64") agentTools := envtesting.PrimeTools(c, s.Conn.Environ.Storage(), s.DataDir(), vers) s.PatchValue(&version.Current, agentTools.Version) err := os.RemoveAll(filepath.Join(s.DataDir(), "tools")) c.Assert(err, gc.IsNil) _, err = s.machine.AgentTools() c.Assert(err, jc.Satisfies, errors.IsNotFound) err = statetesting.SetAgentVersion(s.State, vers.Number) c.Assert(err, gc.IsNil) u := s.makeUpgrader() statetesting.AssertStop(c, u) s.machine.Refresh() gotTools, err := s.machine.AgentTools() c.Assert(err, gc.IsNil) c.Assert(gotTools, gc.DeepEquals, &coretools.Tools{Version: version.Current}) }
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") }
// checkUpgrade sets the environment agent version and checks that // all the provided watchers upgrade to the requested version. func (t *LiveTests) checkUpgrade(c *gc.C, conn *juju.Conn, newVersion version.Binary, waiters ...*toolsWaiter) { c.Logf("putting testing version of juju tools") upgradeTools, err := sync.Upload(t.Env.Storage(), &newVersion.Number, newVersion.Series) c.Assert(err, gc.IsNil) // sync.Upload always returns tools for the series on which the tests are running. // We are only interested in checking the version.Number below so need to fake the // upgraded tools series to match that of newVersion. upgradeTools.Version.Series = newVersion.Series // Check that the put version really is the version we expect. c.Assert(upgradeTools.Version, gc.Equals, newVersion) err = statetesting.SetAgentVersion(conn.State, newVersion.Number) c.Assert(err, gc.IsNil) for i, w := range waiters { c.Logf("waiting for upgrade of %d: %v", i, w.tooler.String()) waitAgentTools(c, w, newVersion) c.Logf("upgrade %d successful", i) } }
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 *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) }