← Back to branch summary

~allenap/maas/xxx-a-thon

« back to all changes in this revision

Viewing changes to src/maasserver/triggers/tests/test_system_listener.py

  • Committer: Gavin Panella
  • Date: 2016-03-22 21:14:34 UTC
  • mfrom: (4657.1.157 maas)
  • Revision ID: gavin.panella@canonical.com-20160322211434-xzuovio86zvzo2js
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maasserver/triggers/tests/test_system_listener.py
62
62
                "rack_controller": rack_controller,
63
63
            })
64
64
            yield process_dv.get(timeout=2)
65
 
            self.assertEqual(
66
 
                (None, "watch_%s" % rack_controller.system_id),
 
65
            self.assertEqual((
 
66
                "sys_core_%s" % region_process.id,
 
67
                "watch_%s" % rack_controller.id),
67
68
                process_dv.value)
68
69
            rack_controller = yield deferToDatabase(
69
70
                self.reload_object, rack_controller)
128
129
                "rack_controller": not_managed_rack_controller,
129
130
            })
130
131
            yield process_dv.get(timeout=2)
131
 
            self.assertEqual(
132
 
                (None, "watch_%s" % not_managed_rack_controller.system_id),
 
132
            self.assertEqual((
 
133
                "sys_core_%s" % not_managing_region_process.id,
 
134
                "watch_%s" % not_managed_rack_controller.id),
133
135
                process_dv.value)
134
136
            not_managed_rack_controller = yield deferToDatabase(
135
137
                self.reload_object, not_managed_rack_controller)
198
200
                "rack_controller": dead_managed_rack_controller,
199
201
            })
200
202
            yield process_dv.get(timeout=2)
201
 
            self.assertEqual(
202
 
                (None, "watch_%s" % dead_managed_rack_controller.system_id),
 
203
            self.assertEqual((
 
204
                "sys_core_%s" % managing_region_process.id,
 
205
                "watch_%s" % dead_managed_rack_controller.id),
203
206
                process_dv.value)
204
207
            dead_managed_rack_controller = yield deferToDatabase(
205
208
                self.reload_object, dead_managed_rack_controller)
273
276
            })
274
277
            yield overloaded_dv.get(timeout=2)
275
278
            yield process_dv.get(timeout=2)
276
 
            self.assertEqual(
277
 
                (None, "unwatch_%s" % rack_controller.system_id),
 
279
            self.assertEqual((
 
280
                "sys_core_%s" % overloaded_region_process.id,
 
281
                "unwatch_%s" % rack_controller.id),
278
282
                overloaded_dv.value)
279
 
            self.assertEqual(
280
 
                (None, "watch_%s" % rack_controller.system_id),
 
283
            self.assertEqual((
 
284
                "sys_core_%s" % region_process.id,
 
285
                "watch_%s" % rack_controller.id),
281
286
                process_dv.value)
282
287
            rack_controller = yield deferToDatabase(
283
288
                self.reload_object, rack_controller)
431
436
                self.delete_region_rack_rpc_connection, connection.id)
432
437
            yield process_dv.get(timeout=2)
433
438
            yield other_process_dv.get(timeout=2)
434
 
            self.assertEqual(
435
 
                (None, "unwatch_%s" % rack_controller.system_id),
 
439
            self.assertEqual((
 
440
                "sys_core_%s" % region_process.id,
 
441
                "unwatch_%s" % rack_controller.id),
436
442
                process_dv.value)
437
 
            self.assertEqual(
438
 
                (None, "watch_%s" % rack_controller.system_id),
 
443
            self.assertEqual((
 
444
                "sys_core_%s" % other_region_process.id,
 
445
                "watch_%s" % rack_controller.id),
439
446
                other_process_dv.value)
440
447
            rack_controller = yield deferToDatabase(
441
448
                self.reload_object, rack_controller)
485
492
            yield deferToDatabase(
486
493
                self.delete_region_rack_rpc_connection, connection.id)
487
494
            yield process_dv.get(timeout=2)
488
 
            self.assertEqual(
489
 
                (None, "unwatch_%s" % rack_controller.system_id),
 
495
            self.assertEqual((
 
496
                "sys_core_%s" % region_process.id,
 
497
                "unwatch_%s" % rack_controller.id),
490
498
                process_dv.value)
491
499
            rack_controller = yield deferToDatabase(
492
500
                self.reload_object, rack_controller)
552
560
 
553
561
    @wait_for_reactor
554
562
    @inlineCallbacks
 
563
    def test_sends_message_for_both_when_secondary_set(self):
 
564
        yield deferToDatabase(register_system_triggers)
 
565
        primary_rack = yield deferToDatabase(self.create_rack_controller)
 
566
        secondary_rack = yield deferToDatabase(self.create_rack_controller)
 
567
        vlan = yield deferToDatabase(self.create_vlan, {
 
568
            "dhcp_on": True,
 
569
            "primary_rack": primary_rack,
 
570
        })
 
571
 
 
572
        primary_dv = DeferredValue()
 
573
        secondary_dv = DeferredValue()
 
574
        listener = self.make_listener_without_delay()
 
575
        listener.register(
 
576
            "sys_dhcp_%s" % primary_rack.id,
 
577
            lambda *args: primary_dv.set(args))
 
578
        listener.register(
 
579
            "sys_dhcp_%s" % secondary_rack.id,
 
580
            lambda *args: secondary_dv.set(args))
 
581
        yield listener.startService()
 
582
        try:
 
583
            yield deferToDatabase(self.update_vlan, vlan.id, {
 
584
                "secondary_rack": secondary_rack,
 
585
            })
 
586
            yield primary_dv.get(timeout=2)
 
587
            yield secondary_dv.get(timeout=2)
 
588
        finally:
 
589
            yield listener.stopService()
 
590
 
 
591
    @wait_for_reactor
 
592
    @inlineCallbacks
 
593
    def test_sends_message_for_both_when_secondary_cleared(self):
 
594
        yield deferToDatabase(register_system_triggers)
 
595
        primary_rack = yield deferToDatabase(self.create_rack_controller)
 
596
        old_secondary_rack = yield deferToDatabase(self.create_rack_controller)
 
597
        vlan = yield deferToDatabase(self.create_vlan, {
 
598
            "dhcp_on": True,
 
599
            "primary_rack": primary_rack,
 
600
            "secondary_rack": old_secondary_rack,
 
601
        })
 
602
 
 
603
        primary_dv = DeferredValue()
 
604
        old_secondary_dv = DeferredValue()
 
605
        listener = self.make_listener_without_delay()
 
606
        listener.register(
 
607
            "sys_dhcp_%s" % primary_rack.id,
 
608
            lambda *args: primary_dv.set(args))
 
609
        listener.register(
 
610
            "sys_dhcp_%s" % old_secondary_rack.id,
 
611
            lambda *args: old_secondary_dv.set(args))
 
612
        yield listener.startService()
 
613
        try:
 
614
            yield deferToDatabase(self.update_vlan, vlan.id, {
 
615
                "secondary_rack": None,
 
616
            })
 
617
            yield primary_dv.get(timeout=2)
 
618
            yield old_secondary_dv.get(timeout=2)
 
619
        finally:
 
620
            yield listener.stopService()
 
621
 
 
622
    @wait_for_reactor
 
623
    @inlineCallbacks
555
624
    def test_sends_message_for_old_primary_when_turned_off(self):
556
625
        yield deferToDatabase(register_system_triggers)
557
626
        primary_rack = yield deferToDatabase(self.create_rack_controller)
642
711
    @inlineCallbacks
643
712
    def test_sends_message_for_old_and_new_secondary_when_changed(self):
644
713
        yield deferToDatabase(register_system_triggers)
 
714
        primary_rack = yield deferToDatabase(self.create_rack_controller)
645
715
        old_secondary_rack = yield deferToDatabase(self.create_rack_controller)
646
716
        new_secondary_rack = yield deferToDatabase(self.create_rack_controller)
647
717
        vlan = yield deferToDatabase(self.create_vlan, {
648
718
            "dhcp_on": True,
 
719
            "primary_rack": primary_rack,
649
720
            "secondary_rack": old_secondary_rack,
650
721
        })
651
722
 
 
723
        primary_dv = DeferredValue()
652
724
        old_secondary_dv = DeferredValue()
653
725
        new_secondary_rack_dv = DeferredValue()
654
726
        listener = self.make_listener_without_delay()
655
727
        listener.register(
 
728
            "sys_dhcp_%s" % primary_rack.id,
 
729
            lambda *args: primary_dv.set(args))
 
730
        listener.register(
656
731
            "sys_dhcp_%s" % old_secondary_rack.id,
657
732
            lambda *args: old_secondary_dv.set(args))
658
733
        listener.register(
663
738
            yield deferToDatabase(self.update_vlan, vlan.id, {
664
739
                "secondary_rack": new_secondary_rack,
665
740
            })
 
741
            yield primary_dv.get(timeout=2)
666
742
            yield old_secondary_dv.get(timeout=2)
667
743
            yield new_secondary_rack_dv.get(timeout=2)
668
744
        finally:
795
871
        yield listener.startService()
796
872
        try:
797
873
            network = factory.make_ip4_or_6_network()
 
874
            gateway_ip = yield deferToDatabase(
 
875
                factory.pick_ip_in_network, network)
798
876
            yield deferToDatabase(self.update_subnet, subnet.id, {
799
877
                "cidr": str(network.cidr),
800
 
                "gateway_ip": factory.pick_ip_in_network(network),
 
878
                "gateway_ip": gateway_ip,
801
879
            })
802
880
            yield primary_dv.get(timeout=2)
803
881
            yield secondary_dv.get(timeout=2)
830
908
            lambda *args: secondary_dv.set(args))
831
909
        yield listener.startService()
832
910
        try:
833
 
            yield deferToDatabase(self.update_subnet, subnet.id, {
834
 
                "gateway_ip": factory.pick_ip_in_network(
835
 
                    subnet.get_ipnetwork(), but_not=[subnet.gateway_ip]),
 
911
            gateway_ip = yield deferToDatabase(
 
912
                factory.pick_ip_in_network, subnet.get_ipnetwork(),
 
913
                but_not=[subnet.gateway_ip])
 
914
            yield deferToDatabase(self.update_subnet, subnet.id, {
 
915
                "gateway_ip": gateway_ip,
 
916
            })
 
917
            yield primary_dv.get(timeout=2)
 
918
            yield secondary_dv.get(timeout=2)
 
919
        finally:
 
920
            yield listener.stopService()
 
921
 
 
922
    @wait_for_reactor
 
923
    @inlineCallbacks
 
924
    def test_sends_message_for_vlan_when_gateway_ip_is_set(self):
 
925
        yield deferToDatabase(register_system_triggers)
 
926
        primary_rack = yield deferToDatabase(self.create_rack_controller)
 
927
        secondary_rack = yield deferToDatabase(self.create_rack_controller)
 
928
        vlan = yield deferToDatabase(self.create_vlan, {
 
929
            "dhcp_on": True,
 
930
            "primary_rack": primary_rack,
 
931
            "secondary_rack": secondary_rack,
 
932
        })
 
933
        subnet = yield deferToDatabase(self.create_subnet, {
 
934
            "vlan": vlan,
 
935
        })
 
936
        # Make sure its empty. This test that it handles being set.
 
937
        yield deferToDatabase(self.update_subnet, subnet.id, {
 
938
            "gateway_ip": None,
 
939
        })
 
940
 
 
941
        primary_dv = DeferredValue()
 
942
        secondary_dv = DeferredValue()
 
943
        listener = self.make_listener_without_delay()
 
944
        listener.register(
 
945
            "sys_dhcp_%s" % primary_rack.id,
 
946
            lambda *args: primary_dv.set(args))
 
947
        listener.register(
 
948
            "sys_dhcp_%s" % secondary_rack.id,
 
949
            lambda *args: secondary_dv.set(args))
 
950
        yield listener.startService()
 
951
        try:
 
952
            gateway_ip = yield deferToDatabase(
 
953
                factory.pick_ip_in_network, subnet.get_ipnetwork())
 
954
            yield deferToDatabase(self.update_subnet, subnet.id, {
 
955
                "gateway_ip": gateway_ip,
 
956
            })
 
957
            yield primary_dv.get(timeout=2)
 
958
            yield secondary_dv.get(timeout=2)
 
959
        finally:
 
960
            yield listener.stopService()
 
961
 
 
962
    @wait_for_reactor
 
963
    @inlineCallbacks
 
964
    def test_sends_message_for_vlan_when_gateway_ip_is_cleared(self):
 
965
        yield deferToDatabase(register_system_triggers)
 
966
        primary_rack = yield deferToDatabase(self.create_rack_controller)
 
967
        secondary_rack = yield deferToDatabase(self.create_rack_controller)
 
968
        vlan = yield deferToDatabase(self.create_vlan, {
 
969
            "dhcp_on": True,
 
970
            "primary_rack": primary_rack,
 
971
            "secondary_rack": secondary_rack,
 
972
        })
 
973
        subnet = yield deferToDatabase(self.create_subnet, {
 
974
            "vlan": vlan,
 
975
        })
 
976
 
 
977
        primary_dv = DeferredValue()
 
978
        secondary_dv = DeferredValue()
 
979
        listener = self.make_listener_without_delay()
 
980
        listener.register(
 
981
            "sys_dhcp_%s" % primary_rack.id,
 
982
            lambda *args: primary_dv.set(args))
 
983
        listener.register(
 
984
            "sys_dhcp_%s" % secondary_rack.id,
 
985
            lambda *args: secondary_dv.set(args))
 
986
        yield listener.startService()
 
987
        try:
 
988
            yield deferToDatabase(self.update_subnet, subnet.id, {
 
989
                "gateway_ip": None,
836
990
            })
837
991
            yield primary_dv.get(timeout=2)
838
992
            yield secondary_dv.get(timeout=2)
865
1019
            lambda *args: secondary_dv.set(args))
866
1020
        yield listener.startService()
867
1021
        try:
868
 
            yield deferToDatabase(self.update_subnet, subnet.id, {
869
 
                "dns_servers": [factory.pick_ip_in_network(
870
 
                    subnet.get_ipnetwork(), but_not=subnet.dns_servers)],
 
1022
            dns_server = yield deferToDatabase(
 
1023
                factory.pick_ip_in_network, subnet.get_ipnetwork(),
 
1024
                but_not=subnet.dns_servers)
 
1025
            yield deferToDatabase(self.update_subnet, subnet.id, {
 
1026
                "dns_servers": [dns_server],
 
1027
            })
 
1028
            yield primary_dv.get(timeout=2)
 
1029
            yield secondary_dv.get(timeout=2)
 
1030
        finally:
 
1031
            yield listener.stopService()
 
1032
 
 
1033
    @wait_for_reactor
 
1034
    @inlineCallbacks
 
1035
    def test_sends_message_for_vlan_when_dns_servers_is_set(self):
 
1036
        yield deferToDatabase(register_system_triggers)
 
1037
        primary_rack = yield deferToDatabase(self.create_rack_controller)
 
1038
        secondary_rack = yield deferToDatabase(self.create_rack_controller)
 
1039
        vlan = yield deferToDatabase(self.create_vlan, {
 
1040
            "dhcp_on": True,
 
1041
            "primary_rack": primary_rack,
 
1042
            "secondary_rack": secondary_rack,
 
1043
        })
 
1044
        subnet = yield deferToDatabase(self.create_subnet, {
 
1045
            "vlan": vlan,
 
1046
        })
 
1047
        # Make sure its empty. This test that it handles being set.
 
1048
        yield deferToDatabase(self.update_subnet, subnet.id, {
 
1049
            "dns_servers": [],
 
1050
        })
 
1051
 
 
1052
        primary_dv = DeferredValue()
 
1053
        secondary_dv = DeferredValue()
 
1054
        listener = self.make_listener_without_delay()
 
1055
        listener.register(
 
1056
            "sys_dhcp_%s" % primary_rack.id,
 
1057
            lambda *args: primary_dv.set(args))
 
1058
        listener.register(
 
1059
            "sys_dhcp_%s" % secondary_rack.id,
 
1060
            lambda *args: secondary_dv.set(args))
 
1061
        yield listener.startService()
 
1062
        try:
 
1063
            dns_server = yield deferToDatabase(
 
1064
                factory.pick_ip_in_network, subnet.get_ipnetwork(),
 
1065
                but_not=subnet.dns_servers)
 
1066
            yield deferToDatabase(self.update_subnet, subnet.id, {
 
1067
                "dns_servers": [dns_server],
 
1068
            })
 
1069
            yield primary_dv.get(timeout=2)
 
1070
            yield secondary_dv.get(timeout=2)
 
1071
        finally:
 
1072
            yield listener.stopService()
 
1073
 
 
1074
    @wait_for_reactor
 
1075
    @inlineCallbacks
 
1076
    def test_sends_message_for_vlan_when_dns_servers_is_cleared(self):
 
1077
        yield deferToDatabase(register_system_triggers)
 
1078
        primary_rack = yield deferToDatabase(self.create_rack_controller)
 
1079
        secondary_rack = yield deferToDatabase(self.create_rack_controller)
 
1080
        vlan = yield deferToDatabase(self.create_vlan, {
 
1081
            "dhcp_on": True,
 
1082
            "primary_rack": primary_rack,
 
1083
            "secondary_rack": secondary_rack,
 
1084
        })
 
1085
        subnet = yield deferToDatabase(self.create_subnet, {
 
1086
            "vlan": vlan,
 
1087
        })
 
1088
        dns_server = yield deferToDatabase(
 
1089
            factory.pick_ip_in_network, subnet.get_ipnetwork(),
 
1090
            but_not=subnet.dns_servers)
 
1091
        yield deferToDatabase(self.update_subnet, subnet.id, {
 
1092
            "dns_servers": [dns_server],
 
1093
        })
 
1094
 
 
1095
        primary_dv = DeferredValue()
 
1096
        secondary_dv = DeferredValue()
 
1097
        listener = self.make_listener_without_delay()
 
1098
        listener.register(
 
1099
            "sys_dhcp_%s" % primary_rack.id,
 
1100
            lambda *args: primary_dv.set(args))
 
1101
        listener.register(
 
1102
            "sys_dhcp_%s" % secondary_rack.id,
 
1103
            lambda *args: secondary_dv.set(args))
 
1104
        yield listener.startService()
 
1105
        try:
 
1106
            yield deferToDatabase(self.update_subnet, subnet.id, {
 
1107
                "dns_servers": [],
871
1108
            })
872
1109
            yield primary_dv.get(timeout=2)
873
1110
            yield secondary_dv.get(timeout=2)
1224
1461
            lambda *args: secondary_dv_2.set(args))
1225
1462
        yield listener.startService()
1226
1463
        try:
 
1464
            ip = yield deferToDatabase(factory.pick_ip_in_Subnet, subnet_2)
1227
1465
            yield deferToDatabase(self.update_staticipaddress, staticip.id, {
1228
1466
                "subnet": subnet_2,
1229
 
                "ip": factory.pick_ip_in_Subnet(subnet_2),
 
1467
                "ip": ip,
1230
1468
            })
1231
1469
            yield primary_dv_1.get(timeout=2)
1232
1470
            yield secondary_dv_1.get(timeout=2)
1271
1509
            lambda *args: secondary_dv.set(args))
1272
1510
        yield listener.startService()
1273
1511
        try:
 
1512
            ip = yield deferToDatabase(factory.pick_ip_in_Subnet, subnet_2)
1274
1513
            yield deferToDatabase(self.update_staticipaddress, staticip.id, {
1275
1514
                "subnet": subnet_2,
1276
 
                "ip": factory.pick_ip_in_Subnet(subnet_2),
 
1515
                "ip": ip,
1277
1516
            })
1278
1517
            yield primary_dv.get(timeout=2)
1279
1518
            yield secondary_dv.get(timeout=2)
1318
1557
            lambda *args: secondary_dv.set(args))
1319
1558
        yield listener.startService()
1320
1559
        try:
 
1560
            ip = yield deferToDatabase(factory.pick_ip_in_Subnet, subnet)
1321
1561
            yield deferToDatabase(self.update_staticipaddress, staticip.id, {
1322
 
                "ip": factory.pick_ip_in_Subnet(subnet),
 
1562
                "ip": ip,
1323
1563
            })
1324
1564
            yield primary_dv.get(timeout=2)
1325
1565
            yield secondary_dv.get(timeout=2)
1408
1648
            lambda *args: secondary_dv.set(args))
1409
1649
        yield listener.startService()
1410
1650
        try:
 
1651
            ip = yield deferToDatabase(
 
1652
                factory.pick_ip_in_Subnet, subnet, but_not=[staticip.ip])
1411
1653
            yield deferToDatabase(self.update_staticipaddress, staticip.id, {
1412
 
                "ip": factory.pick_ip_in_Subnet(subnet, but_not=[staticip.ip]),
 
1654
                "ip": ip,
1413
1655
            })
1414
1656
            yield primary_dv.get(timeout=2)
1415
1657
            yield secondary_dv.get(timeout=2)
1453
1695
            lambda *args: secondary_dv.set(args))
1454
1696
        yield listener.startService()
1455
1697
        try:
 
1698
            ip = yield deferToDatabase(
 
1699
                factory.pick_ip_in_Subnet, subnet, but_not=[staticip.ip])
1456
1700
            yield deferToDatabase(self.update_staticipaddress, staticip.id, {
1457
 
                "ip": factory.pick_ip_in_Subnet(subnet, but_not=[staticip.ip]),
 
1701
                "ip": ip,
1458
1702
            })
1459
1703
            yield primary_dv.get(timeout=2)
1460
1704
            yield secondary_dv.get(timeout=2)