def setUp(self, *_): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ cls = ArpTableTestRouterIP add_to_ip_blocks_list('1.1.1.0/24') add_to_ip_blocks_list('2.2.2.2') warnings.simplefilter('ignore') cls.service_manager = create_service_manager([], ['arpd']) cls._tbl_num = cls.service_manager.get_table_num(ArpController.APP_NAME) arp.mobilityd_list_ip_blocks = mocked_mobilityd_list_ip_blocks arp_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.Arp, PipelinedController.Testing, PipelinedController.StartupFlows ], references={ PipelinedController.Arp: arp_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ 'setup_type': 'LTE', 'allow_unknown_arps': False, 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP, 'ovs_gtp_port_number': 32768, 'virtual_mac': cls.VIRTUAL_MAC, 'local_ue_eth_addr': True, 'quota_check_ip': '1.2.3.4', 'clean_restart': True, 'enable_nat': False, 'mtr_ip': cls.MTR_IP, 'mtr_mac': cls.MTR_MAC, }, mconfig=PipelineD( ue_ip_block=cls.UE_BLOCK, ), loop=None, service_manager=cls.service_manager, integ_test=False, ) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) cls.thread = start_ryu_app_thread(test_setup) cls.arp_controller = arp_controller_reference.result() cls.testing_controller = testing_controller_reference.result()
def setUpClass(cls): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ super(AccessControlTest, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager([]) cls._tbl_num = cls.service_manager.get_table_num( AccessControlController.APP_NAME) access_control_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.AccessControl, PipelinedController.Testing, ], references={ PipelinedController.AccessControl: access_control_controller_reference, PipelinedController.Testing: testing_controller_reference }, config={ 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP, 'nat_iface': 'eth2', 'enodeb_iface': 'eth1', 'enable_queue_pgm': False, 'access_control': { 'ip_blacklist': [ { 'ip': cls.INBOUND_TEST_IP, 'direction': 'inbound', }, { 'ip': cls.OUTBOUND_TEST_IP, 'direction': 'outbound', }, { 'ip': cls.BOTH_DIR_TEST_IP, }, ] } }, mconfig=None, loop=None, service_manager=cls.service_manager, integ_test=False, ) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) cls.thread = start_ryu_app_thread(test_setup) cls.access_control_controller = \ access_control_controller_reference.result() cls.testing_controller = testing_controller_reference.result()
def setUpClass(cls, *_): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ super(IPV6RouterSolicitationTableTest, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager( [], ['ipv6_solicitation'], ) cls._tbl_num = cls.service_manager.get_table_num( IPV6SolicitationController.APP_NAME) ipv6_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.IPV6RouterSolicitation, PipelinedController.Testing, PipelinedController.StartupFlows, ], references={ PipelinedController.IPV6RouterSolicitation: ipv6_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ 'setup_type': 'LTE', 'allow_unknown_arps': False, 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP, 'ovs_gtp_port_number': 32768, 'virtual_interface': cls.BRIDGE, 'local_ue_eth_addr': True, 'quota_check_ip': '1.2.3.4', 'ipv6_router_addr': 'd88d:aba4:472f:fc95:7e7d:8457:5301:ebce', 'clean_restart': True, 'virtual_mac': 'd6:34:bc:81:5d:40', 'enable_nat': True, }, mconfig=PipelineD(ue_ip_block=cls.UE_BLOCK, ), loop=None, service_manager=cls.service_manager, integ_test=False, ) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) cls.thread = start_ryu_app_thread(test_setup) cls.solicitation_controller = ipv6_controller_reference.result() cls.testing_controller = testing_controller_reference.result() cls._prefix_dict = {} cls.solicitation_controller._prefix_mapper._prefix_by_interface = \ cls._prefix_dict
def setUpClass(cls): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ super(TunnelLearnTest, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager( [], ['ue_mac', 'tunnel_learn'], ) cls._tbl_num = cls.service_manager.get_table_num( TunnelLearnController.APP_NAME, ) tunnel_learn_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.TunnelLearnController, PipelinedController.Testing, PipelinedController.StartupFlows, ], references={ PipelinedController.TunnelLearnController: tunnel_learn_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ 'setup_type': 'CWF', 'allow_unknown_arps': False, 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP, 'internal_ip_subnet': '192.168.0.0/16', 'nat_iface': 'eth2', 'enodeb_iface': 'eth1', 'qos': { 'enable': False }, 'clean_restart': True, 'access_control': { 'ip_blocklist': [], }, }, mconfig=PipelineD(allowed_gre_peers=[], ), loop=None, service_manager=cls.service_manager, integ_test=False, ) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) cls.thread = start_ryu_app_thread(test_setup) cls.tunnel_learn_controller = \ tunnel_learn_controller_reference.result() cls.testing_controller = testing_controller_reference.result()
def setUpClass(cls, *_): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures, mocks the redis policy_dictionary of gy_controller """ super(GYTableTest, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager([PipelineD.ENFORCEMENT], ['arpd']) cls._tbl_num = cls.service_manager.get_table_num(GYController.APP_NAME) gy_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.GY, PipelinedController.Arp, PipelinedController.Testing, PipelinedController.StartupFlows ], references={ PipelinedController.GY: gy_controller_reference, PipelinedController.Arp: Future(), PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ 'setup_type': 'CWF', 'allow_unknown_arps': False, 'bridge_name': cls.BRIDGE, 'bridge_ip_address': '192.168.128.1', 'internal_ip_subnet': '192.168.0.0/16', 'nat_iface': 'eth2', 'enodeb_iface': 'eth1', 'enable_queue_pgm': False, 'local_ue_eth_addr': False, 'qos': { 'enable': False }, 'dpi': { 'enable': False }, 'clean_restart': True, }, mconfig=PipelineD(ue_ip_block='192.168.128.0/24'), loop=None, service_manager=cls.service_manager, integ_test=False) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) cls.thread = start_ryu_app_thread(test_setup) cls.gy_controller = gy_controller_reference.result() cls.testing_controller = testing_controller_reference.result() cls.gy_controller._redirect_manager._save_redirect_entry = MagicMock()
def setUpClass(cls): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ super(LIMirrorTest, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager([], ['li_mirror']) inout_controller_reference = Future() li_mirror_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[PipelinedController.InOut, PipelinedController.LIMirror, PipelinedController.Testing, PipelinedController.StartupFlows], references={ PipelinedController.InOut: inout_controller_reference, PipelinedController.LIMirror: li_mirror_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ 'setup_type': 'CWF', 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP, 'internal_ip_subnet': '192.168.0.0/16', 'ovs_gtp_port_number': 32768, 'clean_restart': True, 'li_mirror_all': True, 'li_local_iface': cls.LI_LOCAL_IFACE, 'li_dst_iface': cls.LI_DST_IFACE, 'uplink_port': OFPP_LOCAL }, mconfig=None, loop=None, service_manager=cls.service_manager, integ_test=False, ) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) BridgeTools.create_internal_iface(cls.BRIDGE, cls.LI_LOCAL_IFACE, cls.LI_LOCAL_IP) BridgeTools.create_internal_iface(cls.BRIDGE, cls.LI_DST_IFACE, cls.LI_DST_IP) cls.thread = start_ryu_app_thread(test_setup) cls.inout_controller = inout_controller_reference.result() cls.li_controller = li_mirror_reference.result() cls.testing_controller = testing_controller_reference.result()
def setUpClass(cls): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ super(InOutTest, cls).setUpClass() inout.get_virtual_iface_mac = mocked_get_virtual_iface_mac warnings.simplefilter('ignore') cls.service_manager = create_service_manager([]) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) BridgeTools.create_internal_iface( cls.BRIDGE, cls.MTR_PORT, None, ) mtr_port_no = BridgeTools.get_ofport(cls.MTR_PORT) inout_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.InOut, PipelinedController.Testing, PipelinedController.StartupFlows, ], references={ PipelinedController.InOut: inout_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP, 'ovs_gtp_port_number': 32768, 'clean_restart': True, 'enable_nat': True, 'uplink_gw_mac': '11:22:33:44:55:66', 'uplink_port': OFPP_LOCAL, 'virtual_interface': cls.BRIDGE, 'mtr_ip': '5.6.7.8', 'mtr_interface': cls.MTR_PORT, 'ovs_mtr_port_number': mtr_port_no, }, mconfig=None, loop=None, service_manager=cls.service_manager, integ_test=False, ) cls.thread = start_ryu_app_thread(test_setup) cls.inout_controller = inout_controller_reference.result() cls.testing_controller = testing_controller_reference.result()
def setUpClass(cls, *_): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ he.activate_he_urls_for_ue = mocked_activate_he_urls_for_ue he.deactivate_he_urls_for_ue = mocked_deactivate_he_urls_for_ue super(HeTableTest, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager([], ['proxy']) cls._tbl_num = cls.service_manager.get_table_num(HeaderEnrichmentController.APP_NAME) BridgeTools.create_veth_pair(cls.VETH, cls.VETH_NS) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) BridgeTools.add_ovs_port(cls.BRIDGE, cls.VETH, cls.PROXY_PORT) he_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.HeaderEnrichment, PipelinedController.Testing, PipelinedController.StartupFlows, ], references={ PipelinedController.HeaderEnrichment: he_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ 'setup_type': 'LTE', 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP, 'uplink_port': 20, 'proxy_port_name': cls.VETH, 'clean_restart': True, 'enable_nat': True, 'ovs_gtp_port_number': 10, }, mconfig=PipelineD( ue_ip_block=cls.UE_BLOCK, ), loop=None, service_manager=cls.service_manager, integ_test=False, ) cls.thread = start_ryu_app_thread(test_setup) cls.he_controller = he_controller_reference.result() cls.testing_controller = testing_controller_reference.result()
def setUpClass(cls): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ super(InOutTestNonNATBasicFlows, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager([]) ingress_controller_reference = Future() middle_controller_reference = Future() egress_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.Ingress, PipelinedController.Middle, PipelinedController.Egress, PipelinedController.Testing, PipelinedController.StartupFlows, ], references={ PipelinedController.Ingress: ingress_controller_reference, PipelinedController.Middle: middle_controller_reference, PipelinedController.Egress: egress_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP, 'ovs_gtp_port_number': 32768, 'clean_restart': True, 'enable_nat': False, 'uplink_gw_mac': '11:22:33:44:55:66', 'uplink_port': OFPP_LOCAL, }, mconfig=None, loop=None, service_manager=cls.service_manager, integ_test=False, ) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) cls.thread = start_ryu_app_thread(test_setup) cls.ingress_controller = ingress_controller_reference.result() cls.middle_controller = middle_controller_reference.result() cls.egress_controller = egress_controller_reference.result() cls.testing_controller = testing_controller_reference.result()
def setUpClass(cls): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ super(UplinkBridgeWithNonNATTest, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager([]) uplink_bridge_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.UplinkBridge, PipelinedController.Testing, PipelinedController.StartupFlows ], references={ PipelinedController.UplinkBridge: uplink_bridge_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP, 'ovs_gtp_port_number': 32768, 'clean_restart': True, 'enable_nat': False, 'uplink_bridge': cls.UPLINK_BRIDGE, 'uplink_eth_port_name': cls.UPLINK_ETH_PORT, 'virtual_mac': '02:bb:5e:36:06:4b', 'uplink_patch': cls.UPLINK_PATCH, 'uplink_dhcp_port': cls.UPLINK_DHCP, }, mconfig=None, loop=None, service_manager=cls.service_manager, integ_test=False, ) BridgeTools.create_bridge(cls.BRIDGE, cls.BRIDGE) # dummy uplink interface BridgeTools.create_bridge(cls.UPLINK_BRIDGE, cls.UPLINK_BRIDGE) BridgeTools.create_internal_iface(cls.UPLINK_BRIDGE, cls.UPLINK_DHCP, None) BridgeTools.create_internal_iface(cls.UPLINK_BRIDGE, cls.UPLINK_PATCH, None) BridgeTools.create_internal_iface(cls.UPLINK_BRIDGE, cls.UPLINK_ETH_PORT, None) cls.thread = start_ryu_app_thread(test_setup) cls.uplink_br_controller = uplink_bridge_controller_reference.result() cls.testing_controller = testing_controller_reference.result()
def setUpClass(cls): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures, mocks the redis policy_dictionary of enforcement_controller """ super(EnforcementTableTest, cls).setUpClass() warnings.simplefilter('ignore') cls._static_rule_dict = {} cls.service_manager = create_service_manager([PipelineD.ENFORCEMENT]) cls._tbl_num = cls.service_manager.get_table_num( EnforcementController.APP_NAME, ) enforcement_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.Enforcement, PipelinedController.Testing, PipelinedController.StartupFlows, ], references={ PipelinedController.Enforcement: enforcement_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ 'bridge_name': cls.BRIDGE, 'bridge_ip_address': '192.168.128.1', 'nat_iface': 'eth2', 'enodeb_iface': 'eth1', 'qos': {'enable': False}, 'clean_restart': True, 'uplink_port': 20, 'enable_nat': True, 'ovs_gtp_port_number': 10, 'setup_type': 'LTE', }, mconfig=PipelineD(), loop=None, service_manager=cls.service_manager, integ_test=False, ) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) cls.thread = start_ryu_app_thread(test_setup) cls.enforcement_controller = enforcement_controller_reference.result() cls.testing_controller = testing_controller_reference.result() cls.enforcement_controller._policy_dict = cls._static_rule_dict
def setUpClass(cls): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ super(UEMacAddressTest, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager([], ['ue_mac']) cls._tbl_num = cls.service_manager.get_table_num( UEMacAddressController.APP_NAME, ) ue_mac_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.UEMac, PipelinedController.Testing, PipelinedController.StartupFlows, ], references={ PipelinedController.UEMac: ue_mac_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.Arp: Future(), PipelinedController.StartupFlows: Future(), }, config={ 'setup_type': 'CWF', 'allow_unknown_arps': False, 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP, 'internal_ip_subnet': '192.168.0.0/16', 'ovs_gtp_port_number': 32768, 'clean_restart': True, 'dpi': { 'enabled': False, 'mon_port': 'mon1', 'mon_port_number': 32769, 'idle_timeout': 42, }, }, mconfig=None, loop=None, service_manager=cls.service_manager, integ_test=False, ) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) BridgeTools.create_internal_iface( cls.BRIDGE, cls.DPI_PORT, cls.DPI_IP, ) cls.thread = start_ryu_app_thread(test_setup) cls.ue_mac_controller = ue_mac_controller_reference.result() cls.testing_controller = testing_controller_reference.result()
def setUpClass(cls): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ super(DPITest, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager([PipelineD.DPI], []) dpi_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.DPI, PipelinedController.Testing, PipelinedController.StartupFlows, ], references={ PipelinedController.DPI: dpi_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP, 'ovs_gtp_port_number': 32768, 'clean_restart': True, 'setup_type': 'LTE', 'dpi': { 'enabled': True, 'mon_port': cls.DPI_PORT, 'mon_port_number': 32769, 'idle_timeout': 42, }, }, mconfig=None, loop=None, service_manager=cls.service_manager, integ_test=False, ) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) BridgeTools.create_internal_iface( cls.BRIDGE, cls.DPI_PORT, cls.DPI_IP, ) cls.thread = start_ryu_app_thread(test_setup) cls.dpi_controller = dpi_controller_reference.result() cls.testing_controller = testing_controller_reference.result()
def setUp(self): self._dhcp_gw_info_mock = store.GatewayInfoMap() self._dhcp_gw_info_mock[DHCP_Router_key] = '192.168.128.211' logging.info("set router key [{}]".format(self._dhcp_gw_info_mock[DHCP_Router_key])) """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ cls = self.__class__ super(InOutNonNatTest, cls).setUpClass() warnings.simplefilter('ignore') cls.setup_uplink_br() cls.service_manager = create_service_manager([]) inout_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[PipelinedController.InOut, PipelinedController.Testing, PipelinedController.StartupFlows], references={ PipelinedController.InOut: inout_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ 'setup_type': 'LTE', 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP, 'ovs_gtp_port_number': 32768, 'clean_restart': True, 'enable_nat': False, 'non_mat_gw_probe_frequency': .2, 'non_nat_arp_egress_port': 't_dhcp0', 'ovs_uplink_port_name': 'patch-up' }, mconfig=None, loop=None, service_manager=cls.service_manager, integ_test=False ) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) cls.thread = start_ryu_app_thread(test_setup) cls.inout_controller = inout_controller_reference.result() cls.testing_controller = testing_controller_reference.result()
def setUpClass(cls, *_): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ super(UEMacAddressTest, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager([], include_ue_mac=True) cls._tbl_num = cls.service_manager.get_table_num( UEMacAddressController.APP_NAME) cls._ingress_tbl_num = cls.service_manager.get_table_num(INGRESS) cls._egress_tbl_num = cls.service_manager.get_table_num(EGRESS) inout_controller_reference = Future() ue_mac_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[PipelinedController.InOut, PipelinedController.Arp, PipelinedController.UEMac, PipelinedController.Testing], references={ PipelinedController.InOut: inout_controller_reference, PipelinedController.Arp: Future(), PipelinedController.UEMac: ue_mac_controller_reference, PipelinedController.Testing: testing_controller_reference }, config={ 'setup_type': 'CWF', 'allow_unknown_arps': False, 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP, 'ovs_gtp_port_number': 32768, 'virtual_interface': 'testing_br', 'local_ue_eth_addr': False, }, mconfig=PipelineD( ue_ip_block="192.168.128.0/24", ), loop=None, service_manager=cls.service_manager, integ_test=False, ) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) cls.thread = start_ryu_app_thread(test_setup) cls.ue_mac_controller = ue_mac_controller_reference.result() cls.testing_controller = testing_controller_reference.result()
def testSudoUser(self, _, mock_check_call): intf = 'qt' BRIDGE = 'qtbr0' BridgeTools.create_bridge(BRIDGE, BRIDGE) BridgeTools.create_internal_iface(BRIDGE, intf, None) TrafficClass.init_qdisc(intf) mock_check_call.assert_any_call( ["sudo", "tc", "qdisc", "add", "dev", intf, "root", "handle", "1:", "htb"], )
def setUpClass(cls): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ inout.getmacbyip6 = mocked_getmacbyip6 inout.get_mobilityd_gw_info = mocked_get_mobilityd_gw_info inout.set_mobilityd_gw_info = mocked_set_mobilityd_gw_info super(InOutTestNonNATBasicFlowsIPv6, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager([]) inout_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.InOut, PipelinedController.Testing, PipelinedController.StartupFlows, ], references={ PipelinedController.InOut: inout_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ 'setup_type': 'LTE', 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP, 'ovs_gtp_port_number': 32768, 'clean_restart': True, 'enable_nat': False, 'uplink_gw_mac': '11:22:33:44:55:11', 'uplink_port': OFPP_LOCAL, 'non_nat_gw_probe_frequency': 0.5, }, mconfig=None, loop=None, service_manager=cls.service_manager, integ_test=False, ) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) cls.thread = start_ryu_app_thread(test_setup) cls.inout_controller = inout_controller_reference.result() cls.testing_controller = testing_controller_reference.result()
def setUpClass(cls, *_): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ super(UEMacAddressTest, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager([], include_ue_mac=True) check_quota_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[PipelinedController.CheckQuotaController, PipelinedController.Arp, PipelinedController.Testing, PipelinedController.StartupFlows], references={ PipelinedController.CheckQuotaController: check_quota_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.Arp: Future(), PipelinedController.StartupFlows: Future(), }, config={ 'setup_type': 'CWF', 'allow_unknown_arps': False, 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP, 'ovs_gtp_port_number': 32768, 'has_quota_port': 50001, 'no_quota_port': 50002, 'quota_check_ip': '1.2.3.4', 'local_ue_eth_addr': False, 'clean_restart': True, }, mconfig=PipelineD( ue_ip_block='192.168.128.0/24', ), loop=None, service_manager=cls.service_manager, integ_test=False, ) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) cls.thread = start_ryu_app_thread(test_setup) cls.check_quota_controller = check_quota_controller_reference.result() cls.check_quota_controller._setup_fake_ip_arp = MagicMock() cls.testing_controller = testing_controller_reference.result()
def setUpClass(cls): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ super(QfigtpTest, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager([], ['classifier']) classifier_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.Classifier, PipelinedController.Testing, PipelinedController.StartupFlows, ], references={ PipelinedController.Classifier: classifier_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP, 'ovs_gtp_port_number': 32768, 'ovs_mtr_port_number': 15577, 'mtr_ip': cls.MTR_IP, 'ovs_internal_sampling_port_number': 15578, 'ovs_internal_sampling_fwd_tbl_number': 201, 'ovs_internal_conntrack_port_number': 15579, 'ovs_internal_conntrack_fwd_tbl_number': 202, 'clean_restart': True, 'ovs_multi_tunnel': False, 'paging_timeout': 30, 'classifier_controller_id': 5, 'enable_nat': True, 'ovs_uplink_port_name': "patch-up", }, mconfig=None, loop=None, service_manager=cls.service_manager, integ_test=False, rpc_stubs={'sessiond_setinterface': MagicMock()}, ) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) cls.thread = start_ryu_app_thread(test_setup) cls.classifier_controller = classifier_reference.result() cls.testing_controller = testing_controller_reference.result()
def setUpClass(cls): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures, mocks the redis policy_dictionary of enforcement_controller """ super(RedirectTest, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager([PipelineD.ENFORCEMENT]) cls._tbl_num = cls.service_manager.get_table_num( EnforcementController.APP_NAME) enforcement_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.Enforcement, PipelinedController.Testing, PipelinedController.StartupFlows ], references={ PipelinedController.Enforcement: enforcement_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP_ADDRESS, 'nat_iface': 'eth2', 'enodeb_iface': 'eth1', 'qos': { 'enable': False }, 'clean_restart': True, }, mconfig=PipelineD(relay_enabled=True), loop=None, service_manager=cls.service_manager, integ_test=False, ) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) cls.thread = start_ryu_app_thread(test_setup) cls.enforcement_controller = enforcement_controller_reference.result() cls.testing_controller = testing_controller_reference.result() cls.enforcement_controller._redirect_manager._save_redirect_entry =\ MagicMock()
def setUpClass(cls): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ super(UplinkBridgeTestNatIPAddr, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager([]) uplink_bridge_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.UplinkBridge, PipelinedController.Testing, PipelinedController.StartupFlows, ], references={ PipelinedController.UplinkBridge: uplink_bridge_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP, 'ovs_gtp_port_number': 32768, 'clean_restart': True, 'enable_nat': True, 'uplink_bridge': cls.UPLINK_BRIDGE, 'sgi_management_iface_ip_addr': cls.SGi_IP, 'uplink_eth_port_name': cls.BRIDGE_ETH_PORT, }, mconfig=None, loop=None, service_manager=cls.service_manager, integ_test=False, ) BridgeTools.create_bridge(cls.BRIDGE, cls.BRIDGE) BridgeTools.create_bridge(cls.UPLINK_BRIDGE, cls.UPLINK_BRIDGE) BridgeTools.create_internal_iface( cls.BRIDGE, cls.BRIDGE_ETH_PORT, '2.2.2.2', ) cls.thread = start_ryu_app_thread(test_setup) cls.uplink_br_controller = uplink_bridge_controller_reference.result() cls.testing_controller = testing_controller_reference.result()
def setUpClass(cls, *_): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ super(ArpTableTest, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager([PipelineD.ENFORCEMENT]) cls._tbl_num = cls.service_manager.get_table_num(ArpController.APP_NAME) arp_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.Arp, PipelinedController.Testing, PipelinedController.StartupFlows ], references={ PipelinedController.Arp: arp_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ 'setup_type': 'LTE', 'allow_unknown_arps': False, 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP, 'ovs_gtp_port_number': 32768, 'virtual_interface': cls.BRIDGE, 'local_ue_eth_addr': True, 'clean_restart': True, }, mconfig=PipelineD( ue_ip_block=cls.UE_BLOCK, ), loop=None, service_manager=cls.service_manager, integ_test=False, ) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) cls.thread = start_ryu_app_thread(test_setup) cls.arp_controller = arp_controller_reference.result() cls.testing_controller = testing_controller_reference.result()
def setUpClass(cls, *_): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ super(GTPTrafficTest, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager([], ['classifier']) cls._tbl_num = cls.service_manager.get_table_num(Classifier.APP_NAME) testing_controller_reference = Future() classifier_reference = Future() test_setup = TestSetup( apps=[PipelinedController.Classifier, PipelinedController.Testing, PipelinedController.StartupFlows], references={ PipelinedController.Classifier: classifier_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP, 'internal_ip_subnet': '192.168.0.0/16', 'ovs_gtp_port_number': 32768, 'ovs_mtr_port_number': 15577, 'mtr_ip': cls.MTR_IP, 'ovs_internal_sampling_port_number': 15578, 'ovs_internal_sampling_fwd_tbl_number': 201, 'clean_restart': True, 'ovs_multi_tunnel': False, }, mconfig=PipelineD( ue_ip_block="192.168.128.0/24", ), loop=None, service_manager=cls.service_manager, integ_test=False, ) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) cls.thread = start_ryu_app_thread(test_setup) cls.classifier_controller = classifier_reference.result() cls.testing_controller = testing_controller_reference.result()
def setUp(self): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ super(NGServiceControllerTest, self).setUpClass() warnings.simplefilter('ignore') self.service_manager = create_service_manager([]) ng_services_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.NGServiceController, PipelinedController.Testing, PipelinedController.StartupFlows, ], references={ PipelinedController.NGServiceController: ng_services_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ 'enodeb_iface': 'eth1', 'clean_restart': True, '5G_feature_set': { 'enable': True }, '5G_feature_set': { 'node_identifier': '192.168.220.1' }, 'bridge_name': self.BRIDGE, }, mconfig=None, loop=None, service_manager=self.service_manager, integ_test=False, rpc_stubs={'sessiond_setinterface': MagicMock()}, ) BridgeTools.create_bridge(self.BRIDGE, self.IFACE) self.thread = start_ryu_app_thread(test_setup) self.ng_services_controller = \ ng_services_controller_reference.result() self.testing_controller = testing_controller_reference.result()
def setUpClass(cls): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ super(IPFIXTest, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager([], include_ipfix=True) ipfix_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.IPFIX, PipelinedController.Testing, PipelinedController.StartupFlows ], references={ PipelinedController.IPFIX: ipfix_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP, 'ovs_gtp_port_number': 32768, 'ipfix': { 'enabled': 'true', 'probability': 30000, 'collector_ip': '10.22.20.116', 'collector_port': 4740, 'collector_set_id': 1, 'obs_domain_id': 1, 'obs_point_id': 1, }, 'clean_restart': True, }, mconfig=None, loop=None, service_manager=cls.service_manager, integ_test=False, ) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) cls.thread = start_ryu_app_thread(test_setup) cls.ipfix_controller = ipfix_controller_reference.result() cls.testing_controller = testing_controller_reference.result()
def setUpClass(cls): super(MeterStatsTest, cls).setUpClass() warnings.simplefilter('ignore') service_manager = create_service_manager([PipelineD.METERING]) cls._tbl_num = service_manager.get_table_num(MeterController.APP_NAME) meter_ref = Future() testing_controller_reference = Future() meter_stat_ref = Future() def mock_thread_safe(cmd, body): cmd(body) loop_mock = MagicMock() loop_mock.call_soon_threadsafe = mock_thread_safe test_setup = TestSetup(apps=[ PipelinedController.Meter, PipelinedController.Testing, PipelinedController.MeterStats ], references={ PipelinedController.Meter: meter_ref, PipelinedController.Testing: testing_controller_reference, PipelinedController.MeterStats: meter_stat_ref }, config={ 'bridge_name': cls.BRIDGE, 'bridge_ip_address': '192.168.128.1', 'meter': { 'poll_interval': 3, 'enabled': True }, }, mconfig={}, loop=loop_mock, service_manager=service_manager, integ_test=False, rpc_stubs={'metering_cloud': MagicMock()}) BridgeTools.create_bridge(cls.BRIDGE, cls.BRIDGE) cls.thread = start_ryu_app_thread(test_setup) cls.meter_controller = meter_ref.result() cls.stats_controller = meter_stat_ref.result() cls.testing_controller = testing_controller_reference.result() cls.stats_controller._sync_stats = MagicMock()
def setUpClass(cls): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ super(UplinkBridgeTestFlowRestore, cls).setUpClass() cls.service_manager = create_service_manager([]) BridgeTools.create_bridge(cls.BRIDGE, cls.BRIDGE) cmd1 = ['ovs-ofctl', 'del-flows', cls.BRIDGE] subprocess.check_call(cmd1) cmd1 = ['ovs-ofctl', 'add-flows', cls.BRIDGE, cls.FLOWS_FILE] subprocess.check_call(cmd1)
def setUpClass(cls): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ super(VlanLearnTest, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager( [], ['ue_mac', 'vlan_learn'], ) vlan_learn_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.VlanLearn, PipelinedController.Testing, PipelinedController.StartupFlows, ], references={ PipelinedController.VlanLearn: vlan_learn_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP, 'internal_ip_subnet': '192.168.0.0/16', 'ovs_gtp_port_number': 32768, 'clean_restart': True, }, mconfig=None, loop=None, service_manager=cls.service_manager, integ_test=False, ) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) cls.thread = start_ryu_app_thread(test_setup) cls.vlan_learn_controller = vlan_learn_controller_reference.result() cls.testing_controller = testing_controller_reference.result()
def setUpClass(cls): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ super(AbstractAccessControlTest, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager( [], ['access_control'], ) cls._tbl_num = cls.service_manager.get_table_num( AccessControlController.APP_NAME, ) access_control_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.AccessControl, PipelinedController.Testing, PipelinedController.StartupFlows, ], references={ PipelinedController.AccessControl: access_control_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config=cls.get_config(), mconfig=cls.get_mconfig(), loop=None, service_manager=cls.service_manager, integ_test=False, ) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) cls.thread = start_ryu_app_thread(test_setup) cls.access_control_controller = \ access_control_controller_reference.result() cls.testing_controller = testing_controller_reference.result()
def setUpClass(cls): """ Starts the thread which launches ryu apps Create a testing bridge, add a port, setup the port interfaces. Then launch the ryu apps for testing pipelined. Gets the references to apps launched by using futures. """ super(UEMacAddressTest, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager([], include_ue_mac=True) cls._tbl_num = cls.service_manager.get_table_num( UEMacAddressController.APP_NAME) ue_mac_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[PipelinedController.UEMac, PipelinedController.Testing], references={ PipelinedController.UEMac: ue_mac_controller_reference, PipelinedController.Testing: testing_controller_reference }, config={ 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP, 'ovs_gtp_port_number': 32768, }, mconfig=None, loop=None, service_manager=cls.service_manager, integ_test=False, ) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) cls.thread = start_ryu_app_thread(test_setup) cls.ue_mac_controller = ue_mac_controller_reference.result() cls.testing_controller = testing_controller_reference.result()