1
// Copyright 2014 Canonical Ltd.
2
// Licensed under the AGPLv3, see LICENCE file for details.
10
"github.com/juju/errors"
11
jc "github.com/juju/testing/checkers"
12
"github.com/juju/version"
13
gc "gopkg.in/check.v1"
15
"github.com/juju/juju/constraints"
16
"github.com/juju/juju/instance"
17
"github.com/juju/juju/state"
18
statetesting "github.com/juju/juju/state/testing"
19
"github.com/juju/juju/worker"
22
type UpgradeSuite struct {
27
var _ = gc.Suite(&UpgradeSuite{})
29
func vers(s string) version.Number {
30
return version.MustParse(s)
33
func (s *UpgradeSuite) provision(c *gc.C, machineIds ...string) {
34
for _, machineId := range machineIds {
35
machine, err := s.State.Machine(machineId)
36
c.Assert(err, jc.ErrorIsNil)
37
err = machine.SetProvisioned(
38
instance.Id(fmt.Sprintf("instance-%s", machineId)),
39
fmt.Sprintf("nonce-%s", machineId),
42
c.Assert(err, jc.ErrorIsNil)
46
func (s *UpgradeSuite) addControllers(c *gc.C) (machineId1, machineId2 string) {
47
changes, err := s.State.EnableHA(3, constraints.Value{}, "quantal", nil)
48
c.Assert(err, jc.ErrorIsNil)
49
return changes.Added[0], changes.Added[1]
52
func (s *UpgradeSuite) assertUpgrading(c *gc.C, expect bool) {
53
upgrading, err := s.State.IsUpgrading()
54
c.Assert(err, jc.ErrorIsNil)
55
c.Assert(upgrading, gc.Equals, expect)
58
func (s *UpgradeSuite) SetUpTest(c *gc.C) {
59
s.ConnSuite.SetUpTest(c)
60
controller, err := s.State.AddMachine("quantal", state.JobManageModel)
61
c.Assert(err, jc.ErrorIsNil)
62
pinger, err := controller.SetAgentPresence()
63
c.Assert(err, jc.ErrorIsNil)
64
s.AddCleanup(func(c *gc.C) {
65
c.Assert(worker.Stop(pinger), jc.ErrorIsNil)
67
s.serverIdA = controller.Id()
68
s.provision(c, s.serverIdA)
71
func (s *UpgradeSuite) TestEnsureUpgradeInfo(c *gc.C) {
72
vPrevious := vers("1.2.3")
73
vTarget := vers("2.3.4")
74
vMismatch := vers("1.9.1")
77
info, err := s.State.EnsureUpgradeInfo(s.serverIdA, vPrevious, vTarget)
78
c.Assert(err, jc.ErrorIsNil)
79
c.Assert(info.PreviousVersion(), gc.DeepEquals, vPrevious)
80
c.Assert(info.TargetVersion(), gc.DeepEquals, vTarget)
81
c.Assert(info.Status(), gc.Equals, state.UpgradePending)
82
c.Assert(info.Started().IsZero(), jc.IsFalse)
83
c.Assert(info.ControllersReady(), gc.DeepEquals, []string{s.serverIdA})
84
c.Assert(info.ControllersDone(), gc.HasLen, 0)
87
info, err = s.State.EnsureUpgradeInfo(s.serverIdA, vPrevious, vTarget)
88
c.Assert(err, jc.ErrorIsNil)
89
c.Assert(info.PreviousVersion(), gc.DeepEquals, vPrevious)
90
c.Assert(info.TargetVersion(), gc.DeepEquals, vTarget)
92
// mismatching previous
93
info, err = s.State.EnsureUpgradeInfo(s.serverIdA, vMismatch, vTarget)
94
c.Assert(err, gc.ErrorMatches, "current upgrade info mismatch: expected previous version 1.9.1, got 1.2.3")
95
c.Assert(info, gc.IsNil)
98
info, err = s.State.EnsureUpgradeInfo(s.serverIdA, vPrevious, vMismatch)
99
c.Assert(err, gc.ErrorMatches, "current upgrade info mismatch: expected target version 1.9.1, got 2.3.4")
100
c.Assert(info, gc.IsNil)
103
func (s *UpgradeSuite) TestControllersReadyCopies(c *gc.C) {
104
info, err := s.State.EnsureUpgradeInfo(s.serverIdA, vers("1.2.3"), vers("2.4.5"))
105
c.Assert(err, jc.ErrorIsNil)
106
controllersReady := info.ControllersReady()
107
c.Assert(controllersReady, gc.DeepEquals, []string{"0"})
108
controllersReady[0] = "lol"
109
controllersReady = info.ControllersReady()
110
c.Assert(controllersReady, gc.DeepEquals, []string{"0"})
113
func (s *UpgradeSuite) TestControllersDoneCopies(c *gc.C) {
114
info, err := s.State.EnsureUpgradeInfo(s.serverIdA, vers("1.2.3"), vers("2.4.5"))
115
c.Assert(err, jc.ErrorIsNil)
116
s.setToFinishing(c, info)
117
err = info.SetControllerDone("0")
118
c.Assert(err, jc.ErrorIsNil)
120
info = s.getOneUpgradeInfo(c)
121
controllersDone := info.ControllersDone()
122
c.Assert(controllersDone, gc.DeepEquals, []string{"0"})
123
controllersDone[0] = "lol"
124
controllersDone = info.ControllersReady()
125
c.Assert(controllersDone, gc.DeepEquals, []string{"0"})
128
func (s *UpgradeSuite) TestEnsureUpgradeInfoDowngrade(c *gc.C) {
129
v123 := vers("1.2.3")
130
v111 := vers("1.1.1")
132
info, err := s.State.EnsureUpgradeInfo(s.serverIdA, v123, v111)
133
c.Assert(err, gc.ErrorMatches, "cannot sanely upgrade from 1.2.3 to 1.1.1")
134
c.Assert(info, gc.IsNil)
136
info, err = s.State.EnsureUpgradeInfo(s.serverIdA, v123, v123)
137
c.Assert(err, gc.ErrorMatches, "cannot sanely upgrade from 1.2.3 to 1.2.3")
138
c.Assert(info, gc.IsNil)
141
func (s *UpgradeSuite) TestEnsureUpgradeInfoNonController(c *gc.C) {
142
info, err := s.State.EnsureUpgradeInfo("2345678", vers("1.2.3"), vers("2.3.4"))
143
c.Assert(err, gc.ErrorMatches, `machine "2345678" is not a controller`)
144
c.Assert(info, gc.IsNil)
147
func (s *UpgradeSuite) TestEnsureUpgradeInfoNotProvisioned(c *gc.C) {
148
serverIdB, _ := s.addControllers(c)
149
_, err := s.State.EnsureUpgradeInfo(serverIdB, vers("1.1.1"), vers("1.2.3"))
150
expectErr := fmt.Sprintf("machine %s is not provisioned and should not be participating in upgrades", serverIdB)
151
c.Assert(err, gc.ErrorMatches, expectErr)
154
func (s *UpgradeSuite) TestEnsureUpgradeInfoMultipleServers(c *gc.C) {
155
serverIdB, serverIdC := s.addControllers(c)
156
s.provision(c, serverIdB, serverIdC)
158
v111 := vers("1.1.1")
159
v123 := vers("1.2.3")
160
_, err := s.State.EnsureUpgradeInfo(s.serverIdA, v111, v123)
161
c.Assert(err, jc.ErrorIsNil)
163
// add first new controller with bad version
164
info, err := s.State.EnsureUpgradeInfo(serverIdB, v111, vers("1.2.4"))
165
c.Assert(err, gc.ErrorMatches, "current upgrade info mismatch: expected target version 1.2.4, got 1.2.3")
166
c.Assert(info, gc.IsNil)
168
// add first new controller properly
169
info, err = s.State.EnsureUpgradeInfo(serverIdB, v111, v123)
170
c.Assert(err, jc.ErrorIsNil)
171
expectReady := []string{s.serverIdA, serverIdB}
172
c.Assert(info.ControllersReady(), jc.SameContents, expectReady)
174
// add second new controller
175
info, err = s.State.EnsureUpgradeInfo(serverIdC, v111, v123)
176
c.Assert(err, jc.ErrorIsNil)
177
expectReady = append(expectReady, serverIdC)
178
c.Assert(info.ControllersReady(), jc.SameContents, expectReady)
180
// add second new controller again
181
info, err = s.State.EnsureUpgradeInfo(serverIdC, v111, v123)
182
c.Assert(err, jc.ErrorIsNil)
183
c.Assert(info.ControllersReady(), jc.SameContents, expectReady)
186
func (s *UpgradeSuite) TestEnsureUpgradeInfoRace(c *gc.C) {
187
v100 := vers("1.0.0")
188
v200 := vers("2.0.0")
190
_, err := s.State.EnsureUpgradeInfo(s.serverIdA, v100, v200)
191
c.Assert(err, jc.ErrorIsNil)
193
defer state.SetAfterHooks(c, s.State, func() {
194
err := s.State.ClearUpgradeInfo()
195
c.Assert(err, jc.ErrorIsNil)
198
info, err := s.State.EnsureUpgradeInfo(s.serverIdA, v100, v200)
199
c.Assert(err, gc.ErrorMatches, "current upgrade info not found")
200
c.Assert(err, jc.Satisfies, errors.IsNotFound)
201
c.Assert(info, gc.IsNil)
204
func (s *UpgradeSuite) TestEnsureUpgradeInfoMultipleServersRace1(c *gc.C) {
205
serverIdB, serverIdC := s.addControllers(c)
206
s.provision(c, serverIdB, serverIdC)
208
v111 := vers("1.1.1")
209
v123 := vers("1.2.3")
210
defer state.SetBeforeHooks(c, s.State, func() {
211
_, err := s.State.EnsureUpgradeInfo(serverIdC, v111, v123)
212
c.Assert(err, jc.ErrorIsNil)
215
info, err := s.State.EnsureUpgradeInfo(serverIdB, v111, v123)
216
c.Assert(err, jc.ErrorIsNil)
217
expectReady := []string{serverIdB, serverIdC}
218
c.Assert(info.ControllersReady(), jc.SameContents, expectReady)
221
func (s *UpgradeSuite) TestEnsureUpgradeInfoMultipleServersRace2(c *gc.C) {
222
serverIdB, serverIdC := s.addControllers(c)
223
s.provision(c, serverIdB, serverIdC)
225
v111 := vers("1.1.1")
226
v123 := vers("1.2.3")
227
_, err := s.State.EnsureUpgradeInfo(s.serverIdA, v111, v123)
228
c.Assert(err, jc.ErrorIsNil)
230
defer state.SetAfterHooks(c, s.State, func() {
231
_, err := s.State.EnsureUpgradeInfo(serverIdC, v111, v123)
232
c.Assert(err, jc.ErrorIsNil)
235
info, err := s.State.EnsureUpgradeInfo(serverIdB, v111, v123)
236
c.Assert(err, jc.ErrorIsNil)
237
expectReady := []string{s.serverIdA, serverIdB, serverIdC}
238
c.Assert(info.ControllersReady(), jc.SameContents, expectReady)
241
func (s *UpgradeSuite) TestEnsureUpgradeInfoMultipleServersRace3(c *gc.C) {
242
serverIdB, serverIdC := s.addControllers(c)
243
s.provision(c, serverIdB, serverIdC)
245
v111 := vers("1.1.1")
246
v123 := vers("1.2.3")
247
v124 := vers("1.2.4")
248
_, err := s.State.EnsureUpgradeInfo(s.serverIdA, v111, v123)
249
c.Assert(err, jc.ErrorIsNil)
251
defer state.SetBeforeHooks(c, s.State, nil, func() {
252
err := s.State.ClearUpgradeInfo()
253
c.Assert(err, jc.ErrorIsNil)
254
_, err = s.State.EnsureUpgradeInfo(serverIdC, v111, v124)
255
c.Assert(err, jc.ErrorIsNil)
258
_, err = s.State.EnsureUpgradeInfo(serverIdB, v111, v123)
259
c.Assert(err, gc.ErrorMatches, "upgrade info changed during update")
262
func (s *UpgradeSuite) TestEnsureUpgradeInfoMultipleServersRace4(c *gc.C) {
263
serverIdB, serverIdC := s.addControllers(c)
264
s.provision(c, serverIdB, serverIdC)
266
v111 := vers("1.1.1")
267
v123 := vers("1.2.3")
268
v124 := vers("1.2.4")
269
_, err := s.State.EnsureUpgradeInfo(s.serverIdA, v111, v123)
270
c.Assert(err, jc.ErrorIsNil)
272
defer state.SetAfterHooks(c, s.State, nil, func() {
273
err := s.State.ClearUpgradeInfo()
274
c.Assert(err, jc.ErrorIsNil)
275
_, err = s.State.EnsureUpgradeInfo(serverIdC, v111, v124)
276
c.Assert(err, jc.ErrorIsNil)
279
_, err = s.State.EnsureUpgradeInfo(serverIdB, v111, v123)
280
c.Assert(err, gc.ErrorMatches, "current upgrade info mismatch: expected target version 1.2.3, got 1.2.4")
283
func (s *UpgradeSuite) TestRefresh(c *gc.C) {
284
v111 := vers("1.1.1")
285
v123 := vers("1.2.3")
286
serverIdB, _ := s.addControllers(c)
287
s.provision(c, serverIdB)
289
info, err := s.State.EnsureUpgradeInfo(s.serverIdA, v111, v123)
290
c.Assert(err, jc.ErrorIsNil)
291
info2, err := s.State.EnsureUpgradeInfo(serverIdB, v111, v123)
292
c.Assert(err, jc.ErrorIsNil)
293
info2.SetStatus(state.UpgradeRunning)
295
c.Assert(info.ControllersReady(), jc.SameContents, []string{s.serverIdA})
296
c.Assert(info.Status(), gc.Equals, state.UpgradePending)
299
c.Assert(err, jc.ErrorIsNil)
301
c.Assert(info.ControllersReady(), jc.SameContents, []string{s.serverIdA, serverIdB})
302
c.Assert(info.Status(), gc.Equals, state.UpgradeRunning)
305
func (s *UpgradeSuite) TestWatch(c *gc.C) {
306
v111 := vers("1.1.1")
307
v123 := vers("1.2.3")
308
serverIdB, serverIdC := s.addControllers(c)
309
s.provision(c, serverIdB, serverIdC)
311
w := s.State.WatchUpgradeInfo()
312
defer statetesting.AssertStop(c, w)
315
wc := statetesting.NewNotifyWatcherC(c, s.State, w)
318
// single change is reported
319
_, err := s.State.EnsureUpgradeInfo(s.serverIdA, v111, v123)
320
c.Assert(err, jc.ErrorIsNil)
323
// non-change is not reported
324
_, err = s.State.EnsureUpgradeInfo(s.serverIdA, v111, v123)
325
c.Assert(err, jc.ErrorIsNil)
328
// changes are coalesced
329
_, err = s.State.EnsureUpgradeInfo(serverIdB, v111, v123)
330
c.Assert(err, jc.ErrorIsNil)
331
_, err = s.State.EnsureUpgradeInfo(serverIdC, v111, v123)
332
c.Assert(err, jc.ErrorIsNil)
336
statetesting.AssertStop(c, w)
340
func (s *UpgradeSuite) TestWatchMethod(c *gc.C) {
341
v111 := vers("1.1.1")
342
v123 := vers("1.2.3")
343
serverIdB, serverIdC := s.addControllers(c)
344
s.provision(c, serverIdB, serverIdC)
346
info, err := s.State.EnsureUpgradeInfo(s.serverIdA, v111, v123)
347
c.Assert(err, jc.ErrorIsNil)
350
defer statetesting.AssertStop(c, w)
353
wc := statetesting.NewNotifyWatcherC(c, s.State, w)
356
// single change is reported
357
info, err = s.State.EnsureUpgradeInfo(serverIdB, v111, v123)
358
c.Assert(err, jc.ErrorIsNil)
361
// non-change is not reported
362
info, err = s.State.EnsureUpgradeInfo(serverIdB, v111, v123)
363
c.Assert(err, jc.ErrorIsNil)
366
// changes are coalesced
367
_, err = s.State.EnsureUpgradeInfo(serverIdC, v111, v123)
368
c.Assert(err, jc.ErrorIsNil)
369
err = info.SetStatus(state.UpgradeRunning)
370
c.Assert(err, jc.ErrorIsNil)
374
statetesting.AssertStop(c, w)
378
func (s *UpgradeSuite) TestAllProvisionedControllersReady(c *gc.C) {
379
serverIdB, serverIdC := s.addControllers(c)
380
s.provision(c, serverIdB)
382
v111 := vers("1.1.1")
383
v123 := vers("1.2.3")
384
info, err := s.State.EnsureUpgradeInfo(s.serverIdA, v111, v123)
385
c.Assert(err, jc.ErrorIsNil)
387
assertReady := func(expect bool) {
388
ok, err := info.AllProvisionedControllersReady()
389
c.Assert(err, jc.ErrorIsNil)
390
c.Assert(ok, gc.Equals, expect)
394
info, err = s.State.EnsureUpgradeInfo(serverIdB, v111, v123)
395
c.Assert(err, jc.ErrorIsNil)
398
s.provision(c, serverIdC)
401
info, err = s.State.EnsureUpgradeInfo(serverIdC, v111, v123)
402
c.Assert(err, jc.ErrorIsNil)
406
func (s *UpgradeSuite) TestSetStatus(c *gc.C) {
407
v123 := vers("1.2.3")
408
v234 := vers("2.3.4")
409
info, err := s.State.EnsureUpgradeInfo(s.serverIdA, v123, v234)
410
c.Assert(err, jc.ErrorIsNil)
412
assertStatus := func(expect state.UpgradeStatus) {
413
info, err := s.State.EnsureUpgradeInfo(s.serverIdA, v123, v234)
414
c.Assert(err, jc.ErrorIsNil)
415
c.Assert(info.Status(), gc.Equals, expect)
417
err = info.SetStatus(state.UpgradePending)
418
c.Assert(err, gc.ErrorMatches, `cannot explicitly set upgrade status to "pending"`)
419
assertStatus(state.UpgradePending)
421
err = info.SetStatus(state.UpgradeFinishing)
422
c.Assert(err, gc.ErrorMatches, `cannot set upgrade status to "finishing": `+
423
"Another status change may have occurred concurrently")
424
assertStatus(state.UpgradePending)
426
err = info.SetStatus(state.UpgradeComplete)
427
c.Assert(err, gc.ErrorMatches, `cannot explicitly set upgrade status to "complete"`)
428
assertStatus(state.UpgradePending)
430
err = info.SetStatus(state.UpgradeAborted)
431
c.Assert(err, gc.ErrorMatches, `cannot explicitly set upgrade status to "aborted"`)
432
assertStatus(state.UpgradePending)
434
err = info.SetStatus(state.UpgradeStatus("lol"))
435
c.Assert(err, gc.ErrorMatches, "unknown upgrade status: lol")
436
assertStatus(state.UpgradePending)
438
err = info.SetStatus(state.UpgradeRunning)
439
c.Assert(err, jc.ErrorIsNil)
440
assertStatus(state.UpgradeRunning)
441
err = info.SetStatus(state.UpgradeRunning)
442
c.Assert(err, jc.ErrorIsNil)
443
assertStatus(state.UpgradeRunning)
445
err = info.SetStatus(state.UpgradeFinishing)
446
c.Assert(err, jc.ErrorIsNil)
447
assertStatus(state.UpgradeFinishing)
448
err = info.SetStatus(state.UpgradeFinishing)
449
c.Assert(err, jc.ErrorIsNil)
450
assertStatus(state.UpgradeFinishing)
451
err = info.SetStatus(state.UpgradeRunning)
452
c.Assert(err, gc.ErrorMatches, `cannot set upgrade status to "running": `+
453
"Another status change may have occurred concurrently")
454
assertStatus(state.UpgradeFinishing)
457
func (s *UpgradeSuite) TestSetControllerDone(c *gc.C) {
458
info, err := s.State.EnsureUpgradeInfo(s.serverIdA, vers("1.2.3"), vers("2.3.4"))
459
c.Assert(err, jc.ErrorIsNil)
461
err = info.SetControllerDone(s.serverIdA)
462
c.Assert(err, gc.ErrorMatches, "cannot complete upgrade: upgrade has not yet run")
464
err = info.SetStatus(state.UpgradeRunning)
465
c.Assert(err, jc.ErrorIsNil)
466
err = info.SetControllerDone(s.serverIdA)
467
c.Assert(err, gc.ErrorMatches, "cannot complete upgrade: upgrade has not yet run")
469
err = info.SetStatus(state.UpgradeFinishing)
470
c.Assert(err, jc.ErrorIsNil)
471
err = info.SetControllerDone(s.serverIdA)
472
c.Assert(err, jc.ErrorIsNil)
473
s.assertUpgrading(c, false)
475
s.checkUpgradeInfoArchived(c, info, state.UpgradeComplete, 1)
478
func (s *UpgradeSuite) TestSetControllerDoneMultipleServers(c *gc.C) {
479
v111 := vers("1.1.1")
480
v123 := vers("1.2.3")
481
serverIdB, serverIdC := s.addControllers(c)
482
s.provision(c, serverIdB, serverIdC)
483
for _, id := range []string{serverIdB, serverIdC} {
484
_, err := s.State.EnsureUpgradeInfo(id, v111, v123)
485
c.Assert(err, jc.ErrorIsNil)
488
info, err := s.State.EnsureUpgradeInfo(s.serverIdA, v111, v123)
489
c.Assert(err, jc.ErrorIsNil)
490
s.setToFinishing(c, info)
492
err = info.SetControllerDone(s.serverIdA)
493
c.Assert(err, jc.ErrorIsNil)
494
s.assertUpgrading(c, true)
496
err = info.SetControllerDone(s.serverIdA)
497
c.Assert(err, jc.ErrorIsNil)
498
s.assertUpgrading(c, true)
500
err = info.SetControllerDone(serverIdB)
501
c.Assert(err, jc.ErrorIsNil)
502
s.assertUpgrading(c, true)
504
err = info.SetControllerDone(serverIdC)
505
c.Assert(err, jc.ErrorIsNil)
506
s.assertUpgrading(c, false)
508
s.checkUpgradeInfoArchived(c, info, state.UpgradeComplete, 3)
511
func (s *UpgradeSuite) TestSetControllerDoneMultipleServersRace(c *gc.C) {
512
v100 := vers("1.0.0")
513
v200 := vers("2.0.0")
514
serverIdB, serverIdC := s.addControllers(c)
515
s.provision(c, serverIdB, serverIdC)
517
info, err := s.State.EnsureUpgradeInfo(s.serverIdA, v100, v200)
518
c.Assert(err, jc.ErrorIsNil)
519
_, err = s.State.EnsureUpgradeInfo(serverIdB, v100, v200)
520
c.Assert(err, jc.ErrorIsNil)
521
_, err = s.State.EnsureUpgradeInfo(serverIdC, v100, v200)
522
c.Assert(err, jc.ErrorIsNil)
523
s.setToFinishing(c, info)
525
// Interrupt the transaction for controller A twice with calls
526
// from the other machines.
527
defer state.SetBeforeHooks(c, s.State, func() {
528
err = info.SetControllerDone(serverIdB)
529
c.Assert(err, jc.ErrorIsNil)
531
err = info.SetControllerDone(serverIdC)
532
c.Assert(err, jc.ErrorIsNil)
534
err = info.SetControllerDone(s.serverIdA)
535
c.Assert(err, jc.ErrorIsNil)
536
s.assertUpgrading(c, false)
538
info = s.getOneUpgradeInfo(c)
539
c.Assert(info.Status(), gc.Equals, state.UpgradeComplete)
540
c.Assert(info.ControllersDone(), jc.SameContents, []string{"0", "1", "2"})
543
func (s *UpgradeSuite) TestAbort(c *gc.C) {
544
info, err := s.State.EnsureUpgradeInfo(s.serverIdA, vers("1.2.3"), vers("2.3.4"))
545
c.Assert(err, jc.ErrorIsNil)
548
c.Assert(err, jc.ErrorIsNil)
550
s.checkUpgradeInfoArchived(c, info, state.UpgradeAborted, 0)
553
func (s *UpgradeSuite) TestAbortRace(c *gc.C) {
554
info, err := s.State.EnsureUpgradeInfo(s.serverIdA, vers("1.2.3"), vers("2.3.4"))
555
c.Assert(err, jc.ErrorIsNil)
557
defer state.SetBeforeHooks(c, s.State, func() {
559
c.Assert(err, jc.ErrorIsNil)
562
c.Assert(err, jc.ErrorIsNil)
564
s.checkUpgradeInfoArchived(c, info, state.UpgradeAborted, 0)
567
func (s *UpgradeSuite) checkUpgradeInfoArchived(
569
initialInfo *state.UpgradeInfo,
570
expectedStatus state.UpgradeStatus,
571
expectedControllers int,
573
info := s.getOneUpgradeInfo(c)
574
c.Assert(info.Status(), gc.Equals, expectedStatus)
575
c.Assert(info.PreviousVersion(), gc.Equals, initialInfo.PreviousVersion())
576
c.Assert(info.TargetVersion(), gc.Equals, initialInfo.TargetVersion())
577
// Truncate because mongo only stores times down to millisecond resolution.
578
c.Assert(info.Started().Equal(initialInfo.Started().Truncate(time.Millisecond)), jc.IsTrue)
579
c.Assert(len(info.ControllersDone()), gc.Equals, expectedControllers)
580
if expectedControllers > 0 {
581
c.Assert(info.ControllersDone(), jc.SameContents, info.ControllersReady())
585
func (s *UpgradeSuite) getOneUpgradeInfo(c *gc.C) *state.UpgradeInfo {
586
upgradeInfos, err := state.GetAllUpgradeInfos(s.State)
587
c.Assert(err, jc.ErrorIsNil)
588
c.Assert(len(upgradeInfos), gc.Equals, 1)
589
return upgradeInfos[0]
592
func (s *UpgradeSuite) TestAbortCurrentUpgrade(c *gc.C) {
593
// First try with nothing to abort.
594
err := s.State.AbortCurrentUpgrade()
595
c.Assert(err, jc.ErrorIsNil)
597
upgradeInfos, err := state.GetAllUpgradeInfos(s.State)
598
c.Assert(len(upgradeInfos), gc.Equals, 0)
600
// Now create a UpgradeInfo to abort.
601
_, err = s.State.EnsureUpgradeInfo(s.serverIdA, vers("1.1.1"), vers("1.2.3"))
602
c.Assert(err, jc.ErrorIsNil)
604
err = s.State.AbortCurrentUpgrade()
605
c.Assert(err, jc.ErrorIsNil)
607
info := s.getOneUpgradeInfo(c)
608
c.Check(info.Status(), gc.Equals, state.UpgradeAborted)
610
// It should now be possible to start another upgrade.
611
_, err = s.State.EnsureUpgradeInfo(s.serverIdA, vers("1.2.3"), vers("1.3.0"))
612
c.Check(err, jc.ErrorIsNil)
615
func (s *UpgradeSuite) TestClearUpgradeInfo(c *gc.C) {
616
v111 := vers("1.1.1")
617
v123 := vers("1.2.3")
618
v153 := vers("1.5.3")
620
s.assertUpgrading(c, false)
621
_, err := s.State.EnsureUpgradeInfo(s.serverIdA, v111, v123)
622
c.Assert(err, jc.ErrorIsNil)
623
s.assertUpgrading(c, true)
625
err = s.State.ClearUpgradeInfo()
626
c.Assert(err, jc.ErrorIsNil)
627
s.assertUpgrading(c, false)
629
_, err = s.State.EnsureUpgradeInfo(s.serverIdA, v111, v153)
630
c.Assert(err, jc.ErrorIsNil)
631
s.assertUpgrading(c, true)
634
func (s *UpgradeSuite) TestServiceUnitSeqToSequence(c *gc.C) {
635
v123 := vers("1.2.3")
636
v124 := vers("1.2.4")
638
s.assertUpgrading(c, false)
639
_, err := s.State.EnsureUpgradeInfo(s.serverIdA, v123, v124)
640
c.Assert(err, jc.ErrorIsNil)
641
s.assertUpgrading(c, true)
644
func (s *UpgradeSuite) setToFinishing(c *gc.C, info *state.UpgradeInfo) {
645
err := info.SetStatus(state.UpgradeRunning)
646
c.Assert(err, jc.ErrorIsNil)
647
err = info.SetStatus(state.UpgradeFinishing)
648
c.Assert(err, jc.ErrorIsNil)