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 create_service_manager(services: List[int], static_services: List[str] = None): """ Creates a service manager from the given list of services. Args: services ([int]): Enums of the service from mconfig proto Returns: A service manager instance from the given config """ mconfig = PipelineD(services=services) magma_service = MagicMock() magma_service.mconfig = mconfig if static_services is None: static_services = [] magma_service.config = { 'static_services': static_services, '5G_feature_set': { 'enable': False } } # mock the get_default_client function used to return a fakeredis object func_mock = MagicMock(return_value=fakeredis.FakeStrictRedis()) with mock.patch('magma.pipelined.rule_mappers.get_default_client', func_mock): service_manager = ServiceManager(magma_service) # Workaround as we don't use redis in unit tests service_manager.rule_id_mapper._rule_nums_by_rule = {} service_manager.rule_id_mapper._rules_by_rule_num = {} service_manager.session_rule_version_mapper._version_by_imsi_and_rule = {} service_manager.interface_to_prefix_mapper._prefix_by_interface = {} service_manager.tunnel_id_mapper._tunnel_map = {} return service_manager
def setUpClass(cls): magma_service_mock = MagicMock() magma_service_mock.mconfig = PipelineD() magma_service_mock.mconfig.services.extend( [PipelineD.ENFORCEMENT, PipelineD.DPI, PipelineD.METERING]) magma_service_mock.config = {'static_apps': ['arpd', 'access_control']} cls.service_manager = ServiceManager(magma_service_mock)
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 create_service_manager(services: List[int], static_services: List[str] = None): """ Creates a service manager from the given list of services. Args: services ([int]): Enums of the service from mconfig proto Returns: A service manager instance from the given config """ mconfig = PipelineD(services=services) magma_service = MagicMock() magma_service.mconfig = mconfig if static_services is None: static_services = [] magma_service.config = { 'static_services': static_services, '5G_feature_set': { 'enable': False } } service_manager = ServiceManager(magma_service) # Workaround as we don't use redis in unit tests service_manager.rule_id_mapper._rule_nums_by_rule = {} service_manager.rule_id_mapper._rules_by_rule_num = {} service_manager.session_rule_version_mapper._version_by_imsi_and_rule = {} service_manager.interface_to_prefix_mapper._prefix_by_interface = {} service_manager.tunnel_id_mapper._tunnel_map = {} return service_manager
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. """ 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, 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 setUp(self): magma_service_mock = MagicMock() magma_service_mock.mconfig = PipelineD() magma_service_mock.mconfig.services.extend( [PipelineD.ENFORCEMENT, PipelineD.DPI]) magma_service_mock.config = { 'static_services': ['arpd', 'access_control', 'ipfix'] } self.service_manager = ServiceManager(magma_service_mock)
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 get_mconfig(cls): return PipelineD(allowed_gre_peers=[ { 'ip': '2.2.2.2/24' }, { 'ip': '1.2.3.4/24', 'key': 123 }, ], )
def setUp(self): magma_service_mock = MagicMock() magma_service_mock.mconfig = PipelineD() magma_service_mock.mconfig.services.extend( [PipelineD.ENFORCEMENT, PipelineD.DPI, PipelineD.METERING]) magma_service_mock.config = { 'static_services': ['arpd', 'access_control'] } # Hack since service manager is supposed to be a singleton. ServiceManager._instance = None self.service_manager = ServiceManager(magma_service_mock)
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(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, '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, }, mconfig=PipelineD(), 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 setUp(self): magma_service_mock = MagicMock() magma_service_mock.mconfig = PipelineD() magma_service_mock.mconfig.services.extend( [PipelineD.ENFORCEMENT, PipelineD.DPI]) magma_service_mock.config = { 'static_services': ['arpd', 'access_control', 'ipfix', 'proxy'], '5G_feature_set': { 'enable': False } } self.service_manager = ServiceManager(magma_service_mock)
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 create_service_manager(services=list): """ Creates a service manager from the given list of services. Args: services ([int]): Enums of the service from mconfig proto Returns: A service manager instance from the given config """ mconfig = PipelineD(relay_enabled=True, services=services) magma_service = MagicMock() magma_service.mconfig = mconfig magma_service.config = {'static_services': ['arpd', 'access_control']} return ServiceManager(magma_service)
def setUp(self): magma_service_mock = MagicMock() magma_service_mock.mconfig = PipelineD() magma_service_mock.mconfig.services.extend( [PipelineD.ENFORCEMENT, PipelineD.DPI]) magma_service_mock.config = { 'static_services': ['arpd', 'access_control', 'ipfix', 'proxy'], '5G_feature_set': {'enable': False} } # mock the get_default_client function used to return a fakeredis object func_mock = MagicMock(return_value=fakeredis.FakeStrictRedis()) with mock.patch( 'magma.pipelined.rule_mappers.get_default_client', func_mock): self.service_manager = ServiceManager(magma_service_mock)
def create_service_manager(services: List[int], include_ue_mac=False): """ Creates a service manager from the given list of services. Args: services ([int]): Enums of the service from mconfig proto Returns: A service manager instance from the given config """ mconfig = PipelineD(relay_enabled=True, services=services) magma_service = MagicMock() magma_service.mconfig = mconfig static_services = (['ue_mac', 'arpd', 'access_control', 'tunnel_learn'] if include_ue_mac else ['arpd', 'access_control']) magma_service.config = {'static_services': static_services} return ServiceManager(magma_service)
def create_service_manager(services: List[int], static_services: List[str] = None): """ Creates a service manager from the given list of services. Args: services ([int]): Enums of the service from mconfig proto Returns: A service manager instance from the given config """ mconfig = PipelineD(relay_enabled=True, services=services) magma_service = MagicMock() magma_service.mconfig = mconfig if static_services is None: static_services = [] magma_service.config = {'static_services': static_services} return ServiceManager(magma_service)
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. Mocks the redis policy_dictionary of enforcement_controller. Mocks the loop for testing EnforcementStatsController """ super(EnforcementStatsTest, self).setUpClass() warnings.simplefilter('ignore') self._static_rule_dict = {} self.service_manager = create_service_manager([PipelineD.ENFORCEMENT]) self._main_tbl_num = self.service_manager.get_table_num( EnforcementController.APP_NAME) enforcement_controller_reference = Future() testing_controller_reference = Future() enf_stat_ref = Future() """ Enforcement_stats reports data by using loop.call_soon_threadsafe, but as we don't have an eventloop in testing, just directly call the stats handling function Here is how the mocked function is used in EnforcementStatsController: self.loop.call_soon_threadsafe(self._handle_flow_stats, ev.msg.body) """ def mock_thread_safe(cmd, body): cmd(body) loop_mock = MagicMock() loop_mock.call_soon_threadsafe = mock_thread_safe test_setup = TestSetup(apps=[ PipelinedController.Enforcement, PipelinedController.Enforcement_stats, PipelinedController.Testing, PipelinedController.StartupFlows ], references={ PipelinedController.Enforcement: enforcement_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.Enforcement_stats: enf_stat_ref, PipelinedController.StartupFlows: Future(), }, config={ 'bridge_name': self.BRIDGE, 'bridge_ip_address': '192.168.128.1', 'enforcement': { 'poll_interval': 2 }, 'nat_iface': 'eth2', 'enodeb_iface': 'eth1', 'qos': { 'enable': False }, 'clean_restart': True, }, mconfig=PipelineD(), loop=loop_mock, service_manager=self.service_manager, integ_test=False, rpc_stubs={'sessiond': MagicMock()}) BridgeTools.create_bridge(self.BRIDGE, self.IFACE) self.thread = start_ryu_app_thread(test_setup) self.enforcement_stats_controller = enf_stat_ref.result() self._scratch_tbl_num = self.enforcement_stats_controller.tbl_num self.enforcement_controller = enforcement_controller_reference.result() self.testing_controller = testing_controller_reference.result() self.enforcement_stats_controller._policy_dict = self._static_rule_dict self.enforcement_stats_controller._report_usage = MagicMock() self.enforcement_controller._policy_dict = self._static_rule_dict self.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, mocks the redis policy_dictionary of dpi_controller """ super(InternalPktIpfixExportTest, cls).setUpClass() warnings.simplefilter('ignore') cls._static_rule_dict = {} cls.service_manager = create_service_manager( [PipelineD.DPI], ['ue_mac', 'ipfix'], ) cls._tbl_num = cls.service_manager.get_table_num( DPIController.APP_NAME, ) ue_mac_controller_reference = Future() dpi_controller_reference = Future() ipfix_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.UEMac, PipelinedController.DPI, PipelinedController.IPFIX, PipelinedController.Testing, PipelinedController.StartupFlows, ], references={ PipelinedController.UEMac: ue_mac_controller_reference, PipelinedController.DPI: dpi_controller_reference, PipelinedController.Arp: Future(), PipelinedController.IPFIX: ipfix_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ '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, 'clean_restart': True, 'setup_type': 'CWF', 'dpi': { 'enabled': True, 'mon_port': 'mon1', 'mon_port_number': 32769, 'idle_timeout': 42, }, 'ipfix': { 'enabled': True, 'probability': 65, 'collector_set_id': 1, 'collector_ip': '1.1.1.1', 'collector_port': 65010, 'cache_timeout': 60, 'obs_domain_id': 1, 'obs_point_id': 1, }, 'conntrackd': { 'enabled': True, }, 'ovs_gtp_port_number': 32768, }, mconfig=PipelineD(), 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.dpi_controller = dpi_controller_reference.result() cls.ipfix_controller = ipfix_controller_reference.result() cls.testing_controller = testing_controller_reference.result() cls.dpi_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, mocks the redis policy_dictionary of enforcement_controller """ super(RestartResilienceTest, cls).setUpClass() warnings.simplefilter('ignore') cls._static_rule_dict = {} cls.service_manager = create_service_manager([PipelineD.ENFORCEMENT]) cls._enforcement_tbl_num = cls.service_manager.get_table_num( EnforcementController.APP_NAME) cls._tbl_num = cls.service_manager.get_table_num( EnforcementController.APP_NAME) enforcement_controller_reference = Future() testing_controller_reference = Future() enf_stat_ref = Future() startup_flows_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.Enforcement, PipelinedController.Testing, PipelinedController.Enforcement_stats, PipelinedController.StartupFlows ], references={ PipelinedController.Enforcement: enforcement_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.Enforcement_stats: enf_stat_ref, PipelinedController.StartupFlows: startup_flows_ref, }, config={ 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP_ADDRESS, 'enforcement': { 'poll_interval': 5 }, 'nat_iface': 'eth2', 'enodeb_iface': 'eth1', 'qos': { 'enable': False }, 'clean_restart': False, }, mconfig=PipelineD(), loop=loop_mock, service_manager=cls.service_manager, integ_test=False, rpc_stubs={'sessiond': MagicMock()}) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) cls.thread = start_ryu_app_thread(test_setup) cls.enforcement_controller = enforcement_controller_reference.result() cls.enforcement_stats_controller = enf_stat_ref.result() cls.startup_flows_contoller = startup_flows_ref.result() cls.testing_controller = testing_controller_reference.result() cls.enforcement_stats_controller._policy_dict = cls._static_rule_dict cls.enforcement_stats_controller._report_usage = MagicMock() cls.enforcement_controller._policy_dict = cls._static_rule_dict 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, mocks the redis policy_dictionary of enforcement_controller """ super(EnforcementTableHeTest, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager([PipelineD.ENFORCEMENT], ['proxy']) cls._tbl_num = cls.service_manager.get_table_num( EnforcementController.APP_NAME) BridgeTools.create_bridge(cls.BRIDGE, cls.IFACE) BridgeTools.create_veth_pair(cls.VETH, cls.VETH_NS) BridgeTools.add_ovs_port(cls.BRIDGE, cls.VETH, cls.PROXY_PORT) enforcement_controller_reference = Future() testing_controller_reference = Future() he.activate_he_urls_for_ue = mocked_activate_he_urls_for_ue he.deactivate_he_urls_for_ue = mocked_deactivate_he_urls_for_ue test_setup = TestSetup(apps=[ PipelinedController.Enforcement, PipelinedController.HeaderEnrichment, PipelinedController.Testing, PipelinedController.StartupFlows ], references={ PipelinedController.Enforcement: enforcement_controller_reference, PipelinedController.HeaderEnrichment: cls.he_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, 'proxy_port_name': cls.VETH, 'enable_nat': True, 'ovs_gtp_port_number': 10, }, mconfig=PipelineD(), loop=None, service_manager=cls.service_manager, integ_test=False) cls.thread = start_ryu_app_thread(test_setup) cls.enforcement_controller = enforcement_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() ingress.get_virtual_iface_mac = mocked_get_virtual_iface_mac middle.get_virtual_iface_mac = mocked_get_virtual_iface_mac egress.get_virtual_iface_mac = mocked_get_virtual_iface_mac warnings.simplefilter('ignore') cls.service_manager = create_service_manager([], ['ue_mac', 'arpd']) 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) ingress_controller_reference = Future() middle_controller_reference = Future() egress_controller_reference = Future() ue_mac_controller_reference = Future() testing_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.Ingress, PipelinedController.Middle, PipelinedController.Egress, PipelinedController.Arp, PipelinedController.UEMac, PipelinedController.Testing, PipelinedController.StartupFlows, ], references={ PipelinedController.Ingress: ingress_controller_reference, PipelinedController.Middle: middle_controller_reference, PipelinedController.Egress: egress_controller_reference, PipelinedController.Arp: Future(), PipelinedController.UEMac: ue_mac_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', 'ovs_gtp_port_number': 32768, 'virtual_interface': 'testing_br', 'local_ue_eth_addr': False, 'quota_check_ip': '1.2.3.4', 'clean_restart': True, 'dpi': { 'enabled': False, 'mon_port': 'mon1', 'mon_port_number': 32769, 'idle_timeout': 42, }, 'uplink_port': OFPP_LOCAL, }, 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) 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.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(AccessControlTestLTE, 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={ 'setup_type': 'LTE', 'allow_unknown_arps': False, '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, }, ] }, 'clean_restart': True, }, mconfig=PipelineD( allowed_gre_peers=[{'ip': '1.2.3.4/24', 'key': 123}], ), 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, mocks the redis policy_dictionary of ue_mac_controller """ super(CWFRestartResilienceTest, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager([], ['ue_mac', 'arpd']) ue_mac_controller_reference = Future() testing_controller_reference = 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.UEMac, PipelinedController.Arp, PipelinedController.Testing, PipelinedController.StartupFlows, ], references={ PipelinedController.UEMac: ue_mac_controller_reference, PipelinedController.Arp: Future(), PipelinedController.Testing: testing_controller_reference, PipelinedController.StartupFlows: Future(), }, config={ 'setup_type': 'CWF', 'bridge_name': cls.BRIDGE, 'bridge_ip_address': cls.BRIDGE_IP_ADDRESS, 'enforcement': { 'poll_interval': 5 }, 'internal_ip_subnet': '192.168.0.0/16', 'nat_iface': 'eth2', 'local_ue_eth_addr': False, 'allow_unknown_arps': False, 'enodeb_iface': 'eth1', 'qos': { 'enable': False }, 'clean_restart': False, 'quota_check_ip': '1.2.3.4', 'enable_nat': False, 'dpi': { 'enabled': False, 'mon_port': 'mon1', 'mon_port_number': 32769, 'idle_timeout': 42, }, }, mconfig=PipelineD(ue_ip_block=cls.UE_BLOCK, ), loop=loop_mock, 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(UEMacAddressTest, cls).setUpClass() warnings.simplefilter('ignore') cls.service_manager = create_service_manager( [], ['ue_mac', 'arpd', 'check_quota'], ) check_quota_controller_reference = Future() testing_controller_reference = Future() arp_controller_reference = Future() test_setup = TestSetup( apps=[ PipelinedController.UEMac, PipelinedController.Arp, PipelinedController.CheckQuotaController, PipelinedController.Testing, PipelinedController.StartupFlows, ], references={ PipelinedController.CheckQuotaController: check_quota_controller_reference, PipelinedController.Testing: testing_controller_reference, PipelinedController.UEMac: Future(), PipelinedController.Arp: arp_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', '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, 'dpi': { 'enabled': False, 'mon_port': 'mon1', 'mon_port_number': 32769, 'idle_timeout': 42, }, }, 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) BridgeTools.create_internal_iface( cls.BRIDGE, cls.DPI_PORT, cls.DPI_IP, ) cls.thread = start_ryu_app_thread(test_setup) cls.check_quota_controller = check_quota_controller_reference.result() cls.arp_controlelr = arp_controller_reference.result() cls.testing_controller = testing_controller_reference.result()