← Back to branch summary

~ubuntu-branches/ubuntu/trusty/juju-core/trusty-proposed

« back to all changes in this revision

Viewing changes to src/launchpad.net/juju-core/cmd/jujud/machine_test.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2014-02-03 09:22:46 UTC
  • mfrom: (1.1.17)
  • Revision ID: package-import@ubuntu.com-20140203092246-e03vg402vztzo4qa
Tags: 1.17.2-0ubuntu1
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/launchpad.net/juju-core/cmd/jujud/machine_test.go
16
16
        "launchpad.net/juju-core/charm"
17
17
        "launchpad.net/juju-core/cmd"
18
18
        lxctesting "launchpad.net/juju-core/container/lxc/testing"
 
19
        "launchpad.net/juju-core/environs/config"
19
20
        envtesting "launchpad.net/juju-core/environs/testing"
20
21
        "launchpad.net/juju-core/errors"
21
22
        "launchpad.net/juju-core/instance"
22
23
        "launchpad.net/juju-core/juju"
 
24
        "launchpad.net/juju-core/juju/osenv"
23
25
        "launchpad.net/juju-core/names"
24
26
        "launchpad.net/juju-core/provider/dummy"
25
27
        "launchpad.net/juju-core/state"
29
31
        charmtesting "launchpad.net/juju-core/state/apiserver/charmrevisionupdater/testing"
30
32
        statetesting "launchpad.net/juju-core/state/testing"
31
33
        "launchpad.net/juju-core/state/watcher"
 
34
        "launchpad.net/juju-core/testing"
32
35
        coretesting "launchpad.net/juju-core/testing"
33
36
        jc "launchpad.net/juju-core/testing/checkers"
34
37
        "launchpad.net/juju-core/testing/testbase"
35
38
        "launchpad.net/juju-core/tools"
 
39
        "launchpad.net/juju-core/utils"
36
40
        "launchpad.net/juju-core/utils/ssh"
37
41
        sshtesting "launchpad.net/juju-core/utils/ssh/testing"
38
42
        "launchpad.net/juju-core/version"
39
 
        "launchpad.net/juju-core/worker/addressupdater"
40
43
        "launchpad.net/juju-core/worker/authenticationworker"
41
44
        "launchpad.net/juju-core/worker/deployer"
 
45
        "launchpad.net/juju-core/worker/instancepoller"
 
46
        "launchpad.net/juju-core/worker/machineenvironmentworker"
42
47
)
43
48
 
44
49
type MachineSuite struct {
156
161
}
157
162
 
158
163
func (s *MachineSuite) TestWithDeadMachine(c *gc.C) {
159
 
        m, _, _ := s.primeAgent(c, state.JobHostUnits, state.JobManageState)
 
164
        m, _, _ := s.primeAgent(c, state.JobHostUnits)
160
165
        err := m.EnsureDead()
161
166
        c.Assert(err, gc.IsNil)
162
167
        a := s.newAgent(c, m)
165
170
}
166
171
 
167
172
func (s *MachineSuite) TestWithRemovedMachine(c *gc.C) {
168
 
        m, _, _ := s.primeAgent(c, state.JobHostUnits, state.JobManageState)
 
173
        m, _, _ := s.primeAgent(c, state.JobHostUnits)
169
174
        err := m.EnsureDead()
170
175
        c.Assert(err, gc.IsNil)
171
176
        err = m.Remove()
279
284
        usefulVersion := version.Current
280
285
        usefulVersion.Series = "quantal" // to match the charm created below
281
286
        envtesting.AssertUploadFakeToolsVersions(c, s.Conn.Environ.Storage(), usefulVersion)
282
 
        m, _, _ := s.primeAgent(c, state.JobManageEnviron, state.JobManageState)
 
287
        m, _, _ := s.primeAgent(c, state.JobManageEnviron)
283
288
        err := m.SetAddresses([]instance.Address{
284
289
                instance.NewAddress("0.1.2.3"),
285
290
        })
326
331
        }
327
332
}
328
333
 
329
 
func (s *MachineSuite) TestManageEnvironRunsAddressUpdater(c *gc.C) {
330
 
        defer testbase.PatchValue(&addressupdater.ShortPoll, 500*time.Millisecond).Restore()
 
334
func (s *MachineSuite) TestManageEnvironRunsInstancePoller(c *gc.C) {
 
335
        defer testbase.PatchValue(&instancepoller.ShortPoll, 500*time.Millisecond).Restore()
331
336
        usefulVersion := version.Current
332
337
        usefulVersion.Series = "quantal" // to match the charm created below
333
338
        envtesting.AssertUploadFakeToolsVersions(c, s.Conn.Environ.Storage(), usefulVersion)
334
 
        m, _, _ := s.primeAgent(c, state.JobManageEnviron, state.JobManageState)
 
339
        m, _, _ := s.primeAgent(c, state.JobManageEnviron)
335
340
        err := m.SetAddresses([]instance.Address{
336
341
                instance.NewAddress("0.1.2.3"),
337
342
        })
353
358
        c.Assert(err, gc.IsNil)
354
359
        addrs := []instance.Address{instance.NewAddress("1.2.3.4")}
355
360
        dummy.SetInstanceAddresses(insts[0], addrs)
 
361
        dummy.SetInstanceStatus(insts[0], "running")
356
362
 
357
363
        for a := coretesting.LongAttempt.Start(); a.Next(); {
358
364
                if !a.HasNext() {
361
367
                }
362
368
                err := m.Refresh()
363
369
                c.Assert(err, gc.IsNil)
364
 
                if reflect.DeepEqual(m.Addresses(), addrs) {
 
370
                instStatus, err := m.InstanceStatus()
 
371
                c.Assert(err, gc.IsNil)
 
372
                if reflect.DeepEqual(m.Addresses(), addrs) && instStatus == "running" {
365
373
                        break
366
374
                }
367
375
        }
397
405
}
398
406
 
399
407
func (s *MachineSuite) TestUpgrade(c *gc.C) {
400
 
        m, _, currentTools := s.primeAgent(c, state.JobManageState, state.JobManageEnviron, state.JobHostUnits)
 
408
        m, _, currentTools := s.primeAgent(c, state.JobManageEnviron, state.JobHostUnits)
401
409
        a := s.newAgent(c, m)
402
410
        s.testUpgrade(c, a, m.Tag(), currentTools)
403
411
}
409
417
 
410
418
func (s *MachineSuite) waitStopped(c *gc.C, job state.MachineJob, a *MachineAgent, done chan error) {
411
419
        err := a.Stop()
412
 
        if job == state.JobManageState {
 
420
        if job == state.JobManageEnviron {
413
421
                // When shutting down, the API server can be shut down before
414
422
                // the other workers that connect to it, so they get an error so
415
423
                // they then die, causing Stop to return an error.  It's not
500
508
// This test has been failing regularly on the Bot. Until someone fixes it so
501
509
// it doesn't crash, it isn't worth having as we can't tell when someone
502
510
// actually breaks something.
503
 
func (s *MachineSuite) TestManageStateServesAPI(c *gc.C) {
 
511
func (s *MachineSuite) TestManageEnvironServesAPI(c *gc.C) {
504
512
        c.Skip("does not pass reliably on the bot (http://pad.lv/1219661")
505
 
        s.assertJobWithState(c, state.JobManageState, func(conf agent.Config, agentState *state.State) {
 
513
        s.assertJobWithState(c, state.JobManageEnviron, func(conf agent.Config, agentState *state.State) {
506
514
                st, _, err := conf.OpenAPI(fastDialOpts)
507
515
                c.Assert(err, gc.IsNil)
508
516
                defer st.Close()
512
520
        })
513
521
}
514
522
 
515
 
func (s *MachineSuite) TestManageStateRunsCleaner(c *gc.C) {
516
 
        s.assertJobWithState(c, state.JobManageState, func(conf agent.Config, agentState *state.State) {
 
523
func (s *MachineSuite) TestManageEnvironRunsCleaner(c *gc.C) {
 
524
        s.assertJobWithState(c, state.JobManageEnviron, func(conf agent.Config, agentState *state.State) {
517
525
                // Create a service and unit, and destroy the service.
518
526
                service := s.AddTestingService(c, "wordpress", s.AddTestingCharm(c, "wordpress"))
519
527
                unit, err := service.AddUnit()
549
557
        })
550
558
}
551
559
 
552
 
func (s *MachineSuite) TestManageStateRunsMinUnitsWorker(c *gc.C) {
553
 
        s.assertJobWithState(c, state.JobManageState, func(conf agent.Config, agentState *state.State) {
 
560
func (s *MachineSuite) TestJobManageEnvironRunsMinUnitsWorker(c *gc.C) {
 
561
        s.assertJobWithState(c, state.JobManageEnviron, func(conf agent.Config, agentState *state.State) {
554
562
                // Ensure that the MinUnits worker is alive by doing a simple check
555
563
                // that it responds to state changes: add a service, set its minimum
556
564
                // number of units to one, wait for the worker to add the missing unit.
640
648
        })
641
649
}
642
650
 
643
 
func (s *MachineSuite) TestOpenStateWorksForJobManageState(c *gc.C) {
644
 
        s.assertJobWithAPI(c, state.JobManageState, func(conf agent.Config, st *api.State) {
645
 
                s.assertCanOpenState(c, conf.Tag(), conf.DataDir())
646
 
        })
647
 
}
648
 
 
649
 
// TODO(dimitern) Once firewaller uses the API and no longer connects
650
 
// to state, change this test to use assertCannotOpenState, like the
651
 
// one for JobHostUnits.
652
651
func (s *MachineSuite) TestOpenStateWorksForJobManageEnviron(c *gc.C) {
653
 
        s.assertJobWithAPI(c, state.JobManageState, func(conf agent.Config, st *api.State) {
 
652
        s.assertJobWithAPI(c, state.JobManageEnviron, func(conf agent.Config, st *api.State) {
654
653
                s.assertCanOpenState(c, conf.Tag(), conf.DataDir())
655
654
        })
656
655
}
658
657
func (s *MachineSuite) TestMachineAgentSymlinkJujuRun(c *gc.C) {
659
658
        _, err := os.Stat(jujuRun)
660
659
        c.Assert(err, jc.Satisfies, os.IsNotExist)
661
 
        s.assertJobWithAPI(c, state.JobManageState, func(conf agent.Config, st *api.State) {
 
660
        s.assertJobWithAPI(c, state.JobManageEnviron, func(conf agent.Config, st *api.State) {
662
661
                // juju-run should have been created
663
662
                _, err := os.Stat(jujuRun)
664
663
                c.Assert(err, gc.IsNil)
670
669
        c.Assert(err, gc.IsNil)
671
670
        _, err = os.Stat(jujuRun)
672
671
        c.Assert(err, jc.Satisfies, os.IsNotExist)
673
 
        s.assertJobWithAPI(c, state.JobManageState, func(conf agent.Config, st *api.State) {
 
672
        s.assertJobWithAPI(c, state.JobManageEnviron, func(conf agent.Config, st *api.State) {
674
673
                // juju-run should have been recreated
675
674
                _, err := os.Stat(jujuRun)
676
675
                c.Assert(err, gc.IsNil)
680
679
        })
681
680
}
682
681
 
 
682
func (s *MachineSuite) TestMachineEnvirnWorker(c *gc.C) {
 
683
        proxyDir := c.MkDir()
 
684
        s.PatchValue(&machineenvironmentworker.ProxyDirectory, proxyDir)
 
685
        s.PatchValue(&utils.AptConfFile, filepath.Join(proxyDir, "juju-apt-proxy"))
 
686
 
 
687
        s.primeAgent(c, state.JobHostUnits)
 
688
        // Make sure there are some proxy settings to write.
 
689
        oldConfig, err := s.State.EnvironConfig()
 
690
        c.Assert(err, gc.IsNil)
 
691
 
 
692
        proxySettings := osenv.ProxySettings{
 
693
                Http:  "http proxy",
 
694
                Https: "https proxy",
 
695
                Ftp:   "ftp proxy",
 
696
        }
 
697
 
 
698
        envConfig, err := oldConfig.Apply(config.ProxyConfigMap(proxySettings))
 
699
        c.Assert(err, gc.IsNil)
 
700
 
 
701
        err = s.State.SetEnvironConfig(envConfig, oldConfig)
 
702
        c.Assert(err, gc.IsNil)
 
703
 
 
704
        s.assertJobWithAPI(c, state.JobHostUnits, func(conf agent.Config, st *api.State) {
 
705
                for {
 
706
                        select {
 
707
                        case <-time.After(testing.LongWait):
 
708
                                c.Fatalf("timeout while waiting for proxy settings to change")
 
709
                        case <-time.After(10 * time.Millisecond):
 
710
                                _, err := os.Stat(utils.AptConfFile)
 
711
                                if os.IsNotExist(err) {
 
712
                                        continue
 
713
                                }
 
714
                                c.Assert(err, gc.IsNil)
 
715
                                return
 
716
                        }
 
717
                }
 
718
        })
 
719
}
 
720
 
683
721
func (s *MachineSuite) TestMachineAgentUninstall(c *gc.C) {
684
 
        m, ac, _ := s.primeAgent(c, state.JobHostUnits, state.JobManageState)
 
722
        m, ac, _ := s.primeAgent(c, state.JobHostUnits)
685
723
        err := m.EnsureDead()
686
724
        c.Assert(err, gc.IsNil)
687
725
        a := s.newAgent(c, m)
714
752
                Series:     "quantal",
715
753
                InstanceId: "ardbeg-0",
716
754
                Nonce:      state.BootstrapNonce,
717
 
                Jobs:       []state.MachineJob{state.JobManageState},
 
755
                Jobs:       []state.MachineJob{state.JobManageEnviron},
718
756
        })
719
757
        c.Assert(err, gc.IsNil)
720
758
        err = s.machine.SetPassword(initialMachinePassword)
728
766
        writeStateAgentConfig(c, stateInfo, s.DataDir(), tag, initialMachinePassword)
729
767
}
730
768
 
731
 
func (s *MachineWithCharmsSuite) TestManageStateRunsCharmRevisionUpdater(c *gc.C) {
 
769
func (s *MachineWithCharmsSuite) TestManageEnvironRunsCharmRevisionUpdater(c *gc.C) {
732
770
        s.SetupScenario(c)
733
771
 
734
772
        // Start the machine agent.