← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/launchpad.net/juju-core/worker/firewaller/firewaller_test.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-07-11 17:18:27 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20130711171827-vjqkg40r0dlf7ys2
Tags: 1.11.2-0ubuntu1
https://launchpad.net/bugs/1190634
https://launchpad.net/bugs/1172505
* New upstream release.
* Make juju-core the default juju (LP: #1190634):
  - d/control: Add virtual package juju -> juju-core.
  - d/juju-core.postinst.in: Bump priority of alternatives over that of
    python juju packages.
* Enable for all architectures (LP: #1172505):
  - d/control: Version BD on golang-go to >= 2:1.1.1 to ensure CGO
    support for non-x86 archs, make juju-core Arch: any.
  - d/README.source: Dropped - no longer required.
* d/watch: Updated for new upstream tarball naming.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/launchpad.net/juju-core/worker/firewaller/firewaller_test.go
 
1
// Copyright 2012, 2013 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
1
4
package firewaller_test
2
5
 
3
6
import (
4
7
        . "launchpad.net/gocheck"
5
 
        "launchpad.net/juju-core/environs"
6
8
        "launchpad.net/juju-core/environs/config"
7
9
        "launchpad.net/juju-core/environs/dummy"
 
10
        "launchpad.net/juju-core/instance"
8
11
        "launchpad.net/juju-core/juju/testing"
9
12
        "launchpad.net/juju-core/state"
10
 
        "launchpad.net/juju-core/state/api/params"
11
13
        coretesting "launchpad.net/juju-core/testing"
 
14
        "launchpad.net/juju-core/worker"
12
15
        "launchpad.net/juju-core/worker/firewaller"
13
16
        "reflect"
14
17
        stdtesting "testing"
25
28
        charm *state.Charm
26
29
}
27
30
 
 
31
var _ worker.Worker = (*firewaller.Firewaller)(nil)
 
32
 
28
33
// assertPorts retrieves the open ports of the instance and compares them
29
34
// to the expected.
30
 
func (s *FirewallerSuite) assertPorts(c *C, inst environs.Instance, machineId string, expected []params.Port) {
 
35
func (s *FirewallerSuite) assertPorts(c *C, inst instance.Instance, machineId string, expected []instance.Port) {
31
36
        s.State.StartSync()
32
37
        start := time.Now()
33
38
        for {
53
58
 
54
59
// assertEnvironPorts retrieves the open ports of environment and compares them
55
60
// to the expected.
56
 
func (s *FirewallerSuite) assertEnvironPorts(c *C, expected []params.Port) {
 
61
func (s *FirewallerSuite) assertEnvironPorts(c *C, expected []instance.Port) {
57
62
        s.State.StartSync()
58
63
        start := time.Now()
59
64
        for {
127
132
}
128
133
 
129
134
// startInstance starts a new instance for the given machine.
130
 
func (s *FirewallerSuite) startInstance(c *C, m *state.Machine) environs.Instance {
131
 
        inst := testing.StartInstance(c, s.Conn.Environ, m.Id())
132
 
        err := m.SetProvisioned(inst.Id(), "fake_nonce")
 
135
func (s *FirewallerSuite) startInstance(c *C, m *state.Machine) instance.Instance {
 
136
        inst, hc := testing.StartInstance(c, s.Conn.Environ, m.Id())
 
137
        err := m.SetProvisioned(inst.Id(), "fake_nonce", hc)
133
138
        c.Assert(err, IsNil)
134
139
        return inst
135
140
}
173
178
        err = u.OpenPort("tcp", 8080)
174
179
        c.Assert(err, IsNil)
175
180
 
176
 
        s.assertPorts(c, inst, m.Id(), []params.Port{{"tcp", 80}, {"tcp", 8080}})
 
181
        s.assertPorts(c, inst, m.Id(), []instance.Port{{"tcp", 80}, {"tcp", 8080}})
177
182
 
178
183
        err = u.ClosePort("tcp", 80)
179
184
        c.Assert(err, IsNil)
180
185
 
181
 
        s.assertPorts(c, inst, m.Id(), []params.Port{{"tcp", 8080}})
 
186
        s.assertPorts(c, inst, m.Id(), []instance.Port{{"tcp", 8080}})
182
187
}
183
188
 
184
189
func (s *FirewallerSuite) TestMultipleExposedServices(c *C) {
207
212
        err = u2.OpenPort("tcp", 3306)
208
213
        c.Assert(err, IsNil)
209
214
 
210
 
        s.assertPorts(c, inst1, m1.Id(), []params.Port{{"tcp", 80}, {"tcp", 8080}})
211
 
        s.assertPorts(c, inst2, m2.Id(), []params.Port{{"tcp", 3306}})
 
215
        s.assertPorts(c, inst1, m1.Id(), []instance.Port{{"tcp", 80}, {"tcp", 8080}})
 
216
        s.assertPorts(c, inst2, m2.Id(), []instance.Port{{"tcp", 3306}})
212
217
 
213
218
        err = u1.ClosePort("tcp", 80)
214
219
        c.Assert(err, IsNil)
215
220
        err = u2.ClosePort("tcp", 3306)
216
221
        c.Assert(err, IsNil)
217
222
 
218
 
        s.assertPorts(c, inst1, m1.Id(), []params.Port{{"tcp", 8080}})
 
223
        s.assertPorts(c, inst1, m1.Id(), []instance.Port{{"tcp", 8080}})
219
224
        s.assertPorts(c, inst2, m2.Id(), nil)
220
225
}
221
226
 
236
241
        inst2 := s.startInstance(c, m2)
237
242
        err = u2.OpenPort("tcp", 80)
238
243
        c.Assert(err, IsNil)
239
 
        s.assertPorts(c, inst2, m2.Id(), []params.Port{{"tcp", 80}})
 
244
        s.assertPorts(c, inst2, m2.Id(), []instance.Port{{"tcp", 80}})
240
245
 
241
246
        inst1 := s.startInstance(c, m1)
242
247
        err = u1.OpenPort("tcp", 8080)
243
248
        c.Assert(err, IsNil)
244
 
        s.assertPorts(c, inst1, m1.Id(), []params.Port{{"tcp", 8080}})
 
249
        s.assertPorts(c, inst1, m1.Id(), []instance.Port{{"tcp", 8080}})
245
250
}
246
251
 
247
252
func (s *FirewallerSuite) TestMultipleUnits(c *C) {
263
268
        err = u2.OpenPort("tcp", 80)
264
269
        c.Assert(err, IsNil)
265
270
 
266
 
        s.assertPorts(c, inst1, m1.Id(), []params.Port{{"tcp", 80}})
267
 
        s.assertPorts(c, inst2, m2.Id(), []params.Port{{"tcp", 80}})
 
271
        s.assertPorts(c, inst1, m1.Id(), []instance.Port{{"tcp", 80}})
 
272
        s.assertPorts(c, inst2, m2.Id(), []instance.Port{{"tcp", 80}})
268
273
 
269
274
        err = u1.ClosePort("tcp", 80)
270
275
        c.Assert(err, IsNil)
295
300
        fw := firewaller.NewFirewaller(s.State)
296
301
        defer func() { c.Assert(fw.Stop(), IsNil) }()
297
302
 
298
 
        s.assertPorts(c, inst, m.Id(), []params.Port{{"tcp", 80}, {"tcp", 8080}})
 
303
        s.assertPorts(c, inst, m.Id(), []instance.Port{{"tcp", 80}, {"tcp", 8080}})
299
304
 
300
305
        err = svc.SetExposed()
301
306
        c.Assert(err, IsNil)
325
330
        err = u.OpenPort("tcp", 80)
326
331
        c.Assert(err, IsNil)
327
332
 
328
 
        s.assertPorts(c, inst, m.Id(), []params.Port{{"tcp", 80}})
 
333
        s.assertPorts(c, inst, m.Id(), []instance.Port{{"tcp", 80}})
329
334
}
330
335
 
331
336
func (s *FirewallerSuite) TestStartWithUnexposedService(c *C) {
351
356
        // Expose service.
352
357
        err = svc.SetExposed()
353
358
        c.Assert(err, IsNil)
354
 
        s.assertPorts(c, inst, m.Id(), []params.Port{{"tcp", 80}})
 
359
        s.assertPorts(c, inst, m.Id(), []instance.Port{{"tcp", 80}})
355
360
}
356
361
 
357
362
func (s *FirewallerSuite) TestSetClearExposedService(c *C) {
375
380
        err = svc.SetExposed()
376
381
        c.Assert(err, IsNil)
377
382
 
378
 
        s.assertPorts(c, inst, m.Id(), []params.Port{{"tcp", 80}, {"tcp", 8080}})
 
383
        s.assertPorts(c, inst, m.Id(), []instance.Port{{"tcp", 80}, {"tcp", 8080}})
379
384
 
380
385
        // ClearExposed closes the ports again.
381
386
        err = svc.ClearExposed()
403
408
        err = u2.OpenPort("tcp", 80)
404
409
        c.Assert(err, IsNil)
405
410
 
406
 
        s.assertPorts(c, inst1, m1.Id(), []params.Port{{"tcp", 80}})
407
 
        s.assertPorts(c, inst2, m2.Id(), []params.Port{{"tcp", 80}})
 
411
        s.assertPorts(c, inst1, m1.Id(), []instance.Port{{"tcp", 80}})
 
412
        s.assertPorts(c, inst2, m2.Id(), []instance.Port{{"tcp", 80}})
408
413
 
409
414
        // Remove unit.
410
415
        err = u1.EnsureDead()
413
418
        c.Assert(err, IsNil)
414
419
 
415
420
        s.assertPorts(c, inst1, m1.Id(), nil)
416
 
        s.assertPorts(c, inst2, m2.Id(), []params.Port{{"tcp", 80}})
 
421
        s.assertPorts(c, inst2, m2.Id(), []instance.Port{{"tcp", 80}})
417
422
}
418
423
 
419
424
func (s *FirewallerSuite) TestRemoveService(c *C) {
430
435
        err = u.OpenPort("tcp", 80)
431
436
        c.Assert(err, IsNil)
432
437
 
433
 
        s.assertPorts(c, inst, m.Id(), []params.Port{{"tcp", 80}})
 
438
        s.assertPorts(c, inst, m.Id(), []instance.Port{{"tcp", 80}})
434
439
 
435
440
        // Remove service.
436
441
        err = u.EnsureDead()
466
471
        err = u2.OpenPort("tcp", 3306)
467
472
        c.Assert(err, IsNil)
468
473
 
469
 
        s.assertPorts(c, inst1, m1.Id(), []params.Port{{"tcp", 80}})
470
 
        s.assertPorts(c, inst2, m2.Id(), []params.Port{{"tcp", 3306}})
 
474
        s.assertPorts(c, inst1, m1.Id(), []instance.Port{{"tcp", 80}})
 
475
        s.assertPorts(c, inst2, m2.Id(), []instance.Port{{"tcp", 3306}})
471
476
 
472
477
        // Remove services.
473
478
        err = u2.EnsureDead()
502
507
        err = u.OpenPort("tcp", 80)
503
508
        c.Assert(err, IsNil)
504
509
 
505
 
        s.assertPorts(c, inst, m.Id(), []params.Port{{"tcp", 80}})
 
510
        s.assertPorts(c, inst, m.Id(), []instance.Port{{"tcp", 80}})
506
511
 
507
512
        // Remove unit and service, also tested without. Has no effect.
508
513
        err = u.EnsureDead()
535
540
        err = u.OpenPort("tcp", 80)
536
541
        c.Assert(err, IsNil)
537
542
 
538
 
        s.assertPorts(c, inst, m.Id(), []params.Port{{"tcp", 80}})
 
543
        s.assertPorts(c, inst, m.Id(), []instance.Port{{"tcp", 80}})
539
544
 
540
545
        // Remove unit.
541
546
        err = u.EnsureDead()
585
590
        err = u2.OpenPort("tcp", 80)
586
591
        c.Assert(err, IsNil)
587
592
 
588
 
        s.assertEnvironPorts(c, []params.Port{{"tcp", 80}, {"tcp", 8080}})
 
593
        s.assertEnvironPorts(c, []instance.Port{{"tcp", 80}, {"tcp", 8080}})
589
594
 
590
595
        // Closing a port opened by a different unit won't touch the environment.
591
596
        err = u1.ClosePort("tcp", 80)
592
597
        c.Assert(err, IsNil)
593
 
        s.assertEnvironPorts(c, []params.Port{{"tcp", 80}, {"tcp", 8080}})
 
598
        s.assertEnvironPorts(c, []instance.Port{{"tcp", 80}, {"tcp", 8080}})
594
599
 
595
600
        // Closing a port used just once changes the environment.
596
601
        err = u1.ClosePort("tcp", 8080)
597
602
        c.Assert(err, IsNil)
598
 
        s.assertEnvironPorts(c, []params.Port{{"tcp", 80}})
 
603
        s.assertEnvironPorts(c, []instance.Port{{"tcp", 80}})
599
604
 
600
605
        // Closing the last port also modifies the environment.
601
606
        err = u2.ClosePort("tcp", 80)
630
635
        // Expose service.
631
636
        err = svc.SetExposed()
632
637
        c.Assert(err, IsNil)
633
 
        s.assertEnvironPorts(c, []params.Port{{"tcp", 80}})
 
638
        s.assertEnvironPorts(c, []instance.Port{{"tcp", 80}})
634
639
}
635
640
 
636
641
func (s *FirewallerSuite) TestGlobalModeRestart(c *C) {
653
658
        err = u.OpenPort("tcp", 8080)
654
659
        c.Assert(err, IsNil)
655
660
 
656
 
        s.assertEnvironPorts(c, []params.Port{{"tcp", 80}, {"tcp", 8080}})
 
661
        s.assertEnvironPorts(c, []instance.Port{{"tcp", 80}, {"tcp", 8080}})
657
662
 
658
663
        // Stop firewall and close one and open a different port.
659
664
        err = fw.Stop()
668
673
        fw = firewaller.NewFirewaller(s.State)
669
674
        defer func() { c.Assert(fw.Stop(), IsNil) }()
670
675
 
671
 
        s.assertEnvironPorts(c, []params.Port{{"tcp", 80}, {"tcp", 8888}})
 
676
        s.assertEnvironPorts(c, []instance.Port{{"tcp", 80}, {"tcp", 8888}})
672
677
}
673
678
 
674
679
func (s *FirewallerSuite) TestGlobalModeRestartUnexposedService(c *C) {
691
696
        err = u.OpenPort("tcp", 8080)
692
697
        c.Assert(err, IsNil)
693
698
 
694
 
        s.assertEnvironPorts(c, []params.Port{{"tcp", 80}, {"tcp", 8080}})
 
699
        s.assertEnvironPorts(c, []instance.Port{{"tcp", 80}, {"tcp", 8080}})
695
700
 
696
701
        // Stop firewall and clear exposed flag on service.
697
702
        err = fw.Stop()
727
732
        err = u1.OpenPort("tcp", 8080)
728
733
        c.Assert(err, IsNil)
729
734
 
730
 
        s.assertEnvironPorts(c, []params.Port{{"tcp", 80}, {"tcp", 8080}})
 
735
        s.assertEnvironPorts(c, []instance.Port{{"tcp", 80}, {"tcp", 8080}})
731
736
 
732
737
        // Stop firewall and add another service using the port.
733
738
        err = fw.Stop()
747
752
        fw = firewaller.NewFirewaller(s.State)
748
753
        defer func() { c.Assert(fw.Stop(), IsNil) }()
749
754
 
750
 
        s.assertEnvironPorts(c, []params.Port{{"tcp", 80}, {"tcp", 8080}})
 
755
        s.assertEnvironPorts(c, []instance.Port{{"tcp", 80}, {"tcp", 8080}})
751
756
 
752
757
        // Closing a port opened by a different unit won't touch the environment.
753
758
        err = u1.ClosePort("tcp", 80)
754
759
        c.Assert(err, IsNil)
755
 
        s.assertEnvironPorts(c, []params.Port{{"tcp", 80}, {"tcp", 8080}})
 
760
        s.assertEnvironPorts(c, []instance.Port{{"tcp", 80}, {"tcp", 8080}})
756
761
 
757
762
        // Closing a port used just once changes the environment.
758
763
        err = u1.ClosePort("tcp", 8080)
759
764
        c.Assert(err, IsNil)
760
 
        s.assertEnvironPorts(c, []params.Port{{"tcp", 80}})
 
765
        s.assertEnvironPorts(c, []instance.Port{{"tcp", 80}})
761
766
 
762
767
        // Closing the last port also modifies the environment.
763
768
        err = u2.ClosePort("tcp", 80)