func (s *UpgraderSuite) TestUpgraderRetryAndChanged(c *gc.C) { oldTools := s.primeTools(c, version.MustParseBinary("5.4.3-foo-bar")) newTools := s.uploadTools(c, version.MustParseBinary("5.4.5-foo-bar")) 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(), tools.StorageName(newTools.Version), fmt.Errorf("a non-fatal dose")) u := upgrader.New(s.state.Upgrader(), s.machine.Tag(), s.DataDir()) 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 := s.uploadTools(c, version.MustParseBinary("5.4.6-foo-bar")) err = statetesting.SetAgentVersion(s.State, newerTools.Version.Number) c.Assert(err, gc.IsNil) s.BackingState.Sync() done := make(chan error) go func() { done <- u.Wait() }() select { case err := <-done: c.Assert(err, gc.DeepEquals, &upgrader.UpgradeReadyError{ AgentName: s.machine.Tag(), OldTools: oldTools, NewTools: newerTools, DataDir: s.DataDir(), }) case <-time.After(coretesting.LongWait): c.Fatalf("upgrader did not quit after upgrading") } }
func (s *upgraderSuite) TestWatchAPIVersion(c *C) { w, err := s.st.WatchAPIVersion(s.rawMachine.Tag()) c.Assert(err, 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, 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, IsNil) wc.AssertNoChange() vers = version.MustParse("10.20.35") err = statetesting.SetAgentVersion(s.BackingState, vers) c.Assert(err, IsNil) wc.AssertOneChange() statetesting.AssertStop(c, w) wc.AssertClosed() }
func (s *UpgraderSuite) TestUpgraderSetsTools(c *gc.C) { vers := version.MustParseBinary("5.4.3-foo-bar") err := statetesting.SetAgentVersion(s.State, vers.Number) c.Assert(err, gc.IsNil) agentTools := s.primeTools(c, vers) _, err = s.machine.AgentTools() c.Assert(err, jc.Satisfies, errors.IsNotFoundError) u := upgrader.New(s.state.Upgrader(), s.machine.Tag(), s.DataDir()) statetesting.AssertStop(c, u) s.machine.Refresh() gotTools, err := s.machine.AgentTools() c.Assert(err, gc.IsNil) c.Assert(gotTools, gc.DeepEquals, agentTools) }
func (s *UpgraderSuite) TestUpgraderSetToolsEvenWithNoToolsToRead(c *gc.C) { vers := version.MustParseBinary("5.4.3-foo-bar") s.primeTools(c, vers) err := os.RemoveAll(filepath.Join(s.DataDir(), "tools")) c.Assert(err, gc.IsNil) _, err = s.machine.AgentTools() c.Assert(err, jc.Satisfies, errors.IsNotFoundError) err = statetesting.SetAgentVersion(s.State, vers.Number) c.Assert(err, gc.IsNil) u := upgrader.New(s.state.Upgrader(), s.machine.Tag(), s.DataDir()) statetesting.AssertStop(c, u) s.machine.Refresh() gotTools, err := s.machine.AgentTools() c.Assert(err, gc.IsNil) c.Assert(gotTools, gc.DeepEquals, &tools.Tools{Version: version.Current}) }
// checkUpgrade sets the environment agent version and checks that // all the provided watchers upgrade to the requested version. func (t *LiveTests) checkUpgrade(c *C, conn *juju.Conn, newVersion version.Binary, waiters ...*toolsWaiter) { c.Logf("putting testing version of juju tools") upgradeTools, err := tools.Upload(t.Env.Storage(), &newVersion.Number, newVersion.Series) c.Assert(err, IsNil) // tools.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.Series = newVersion.Series // Check that the put version really is the version we expect. c.Assert(upgradeTools.Binary, Equals, newVersion) err = statetesting.SetAgentVersion(conn.State, newVersion.Number) c.Assert(err, 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 *C) { args := params.Entities{ Entities: []params.Entity{{Tag: s.rawMachine.Tag()}}, } results, err := s.upgrader.WatchAPIVersion(args) c.Assert(err, IsNil) c.Check(results.Results, HasLen, 1) c.Check(results.Results[0].NotifyWatcherId, Not(Equals), "") c.Check(results.Results[0].Error, IsNil) resource := s.resources.Get(results.Results[0].NotifyWatcherId) c.Check(resource, 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, IsNil) wc.AssertOneChange() statetesting.AssertStop(c, w) wc.AssertClosed() }
func (s *UpgraderSuite) TestUpgraderUpgradesImmediately(c *gc.C) { oldTools := s.primeTools(c, version.MustParseBinary("5.4.3-foo-bar")) newTools := s.uploadTools(c, version.MustParseBinary("5.4.5-foo-bar")) 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 := upgrader.New(s.state.Upgrader(), s.machine.Tag(), s.DataDir()) err = u.Stop() c.Assert(err, gc.DeepEquals, &upgrader.UpgradeReadyError{ AgentName: s.machine.Tag(), OldTools: oldTools, NewTools: newTools, DataDir: s.DataDir(), }) foundTools, err := tools.ReadTools(s.DataDir(), newTools.Version) c.Assert(err, gc.IsNil) c.Assert(foundTools, gc.DeepEquals, newTools) }