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 (s *upgradeSuite) TestStateStepsNotAttemptedWhenNoStateTarget(c *gc.C) {
stateCount := 0
stateUpgradeOperations := func() []upgrades.Operation {
stateCount++
return nil
}
s.PatchValue(upgrades.StateUpgradeOperations, stateUpgradeOperations)
apiCount := 0
upgradeOperations := func() []upgrades.Operation {
apiCount++
return nil
}
s.PatchValue(upgrades.UpgradeOperations, upgradeOperations)
fromVers := version.MustParse("1.18.0")
ctx := new(mockContext)
check := func(target upgrades.Target, expectedStateCallCount int) {
stateCount = 0
apiCount = 0
err := upgrades.PerformUpgrade(fromVers, targets(target), ctx)
c.Assert(err, jc.ErrorIsNil)
c.Assert(stateCount, gc.Equals, expectedStateCallCount)
c.Assert(apiCount, gc.Equals, 1)
}
check(upgrades.Controller, 1)
check(upgrades.DatabaseMaster, 1)
check(upgrades.AllMachines, 0)
check(upgrades.HostMachine, 0)
}
// runUpgrades runs the upgrade operations for each job type and updates the updatedToVersion on success.
func (a *MachineAgent) runUpgrades(
st *state.State,
apiState *api.State,
jobs []params.MachineJob,
agentConfig agent.Config,
) error {
from := version.Current
from.Number = agentConfig.UpgradedToVersion()
if from == version.Current {
logger.Infof("upgrade to %v already completed.", version.Current)
return nil
}
var err error
writeErr := a.ChangeConfig(func(agentConfig agent.ConfigSetter) {
context := upgrades.NewContext(agentConfig, apiState, st)
for _, job := range jobs {
target := upgradeTarget(job)
if target == "" {
continue
}
logger.Infof("starting upgrade from %v to %v for %v %q", from, version.Current, target, a.Tag())
if err = upgrades.PerformUpgrade(from.Number, target, context); err != nil {
err = fmt.Errorf("cannot perform upgrade from %v to %v for %v %q: %v", from, version.Current, target, a.Tag(), err)
return
}
}
agentConfig.SetUpgradedToVersion(version.Current.Number)
})
if writeErr != nil {
return fmt.Errorf("cannot write updated agent configuration: %v", writeErr)
}
return nil
}
func (s *upgradeSuite) checkContextRestriction(c *gc.C, expectedPanic string) {
fromVersion := version.MustParse("1.20.0")
type fakeAgentConfigSetter struct{ agent.ConfigSetter }
ctx := upgrades.NewContext(fakeAgentConfigSetter{}, nil, new(state.State))
c.Assert(
func() { upgrades.PerformUpgrade(fromVersion, targets(upgrades.Controller), ctx) },
gc.PanicMatches, expectedPanic,
)
}