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)
}
