def setUpClassDevices(cls):
BridgeTools.delete_ns_all()
BridgeTools.create_veth_pair(cls.gtp_veth, cls.gtp_veth_ns)
BridgeTools.ifup_netdev(cls.gtp_veth, cls.gtp_pkt_dst + "/24")
BridgeTools.create_veth_pair(cls.sgi_veth, cls.sgi_veth1)
BridgeTools.create_ns_and_move_veth(cls.NS_NAME, cls.sgi_veth1, cls.inner_src_ip + "/24")
BridgeTools.ifup_netdev(cls.sgi_veth, cls.inner_dst_ip + "/24")
BridgeTools.ifup_netdev(cls.gtp_veth_ns, cls.gtp_pkt_src + "/24")
gw_ip = IPAddress(version=IPAddress.IPV4, address=socket.inet_aton(cls.sgi_veth_ip))
cls.ebpf_man = EbpfManager(cls.sgi_veth, cls.gtp_veth, gw_ip, bpf_ul_file=UL_HANDLER, bpf_dl_file=DL_HANDLER, bpf_header_path=BPF_HEADER_PATH)
cls.ebpf_man.detach_dl_ebpf()
cls.ebpf_man.attach_dl_ebpf()
cls.sniffer = AsyncSniffer(
iface='gtpu_sys_2152',
store=False,
prn=cls.pkt_cap_fun,
)
cls.sniffer.start()
def setUpClassDevices(cls):
BridgeTools.delete_ns_all()
BridgeTools.create_veth_pair(cls.gtp_veth, cls.gtp_veth_ns)
BridgeTools.ifup_netdev(cls.gtp_veth, cls.gtp_pkt_dst + "/24")
BridgeTools.create_veth_pair(cls.sgi_veth, cls.sgi_veth1)
BridgeTools.create_ns_and_move_veth(cls.NS_NAME, cls.gtp_veth_ns,
cls.gtp_pkt_src + "/24")
BridgeTools.ifup_netdev(cls.sgi_veth, cls.sgi_veth_ip + "/24")
BridgeTools.ifup_netdev(cls.sgi_veth1)
cls.ebpf_man = ebpf_manager(cls.sgi_veth, cls.gtp_veth,
cls.sgi_veth_ip, True, UL_HANDLER)
cls.ebpf_man.detach_ul_ebpf()
cls.ebpf_man.attach_ul_ebpf()
time.sleep(2)
cls.sniffer = AsyncSniffer(
iface=cls.sgi_veth1,
store=False,
prn=cls.pkt_cap_fun,
)
cls.sniffer.start()
def test_attach_tunnel_flows(self):
# Need to delete all default flows in table 0 before
# install the specific flows test case.
self.test_detach_default_tunnel_flows()
ip_no = hex(socket.htonl(int(ipaddress.ip_address(self.EnodeB_IP))))
buf = "g_{}".format(ip_no[2:])
BridgeTools.create_veth_pair(buf, buf + "ns")
BridgeTools.add_ovs_port(self.BRIDGE, buf, "40")
seid1 = 5000
ue_ip_addr = "192.168.128.30"
self.classifier_controller.add_tunnel_flows(65525, 1, 100000,
IPAddress(version=IPAddress.IPV4,address=ue_ip_addr.encode('utf-8')),
self.EnodeB_IP, seid1)
seid2 = 5001
ue_ip_addr = "192.168.128.31"
self.classifier_controller.add_tunnel_flows(65525, 2,100001,
IPAddress(version=IPAddress.IPV4,address=ue_ip_addr.encode('utf-8')),
self.EnodeB_IP, seid2)
snapshot_verifier = SnapshotVerifier(self, self.BRIDGE,
self.service_manager)
with snapshot_verifier:
pass
def test_attach_s8_tunnel_flows(self):
# Need to delete all default flows in table 0 before
# install the specific flows test case.
self.test_detach_default_tunnel_flows()
ip_no = hex(socket.htonl(int(ipaddress.ip_address(self.EnodeB_IP))))
buf = "g_{}".format(ip_no[2:])
BridgeTools.create_veth_pair(buf, buf + "ns")
BridgeTools.add_ovs_port(self.BRIDGE, buf, "40")
ue_ip_addr = "192.168.128.15"
ip_flow_dl = IPFlowDL(set_params=0)
self.classifier_controller.add_s8_tunnel_flows(
65525,
10,
5000,
IPAddress(version=IPAddress.IPV4,
address=ue_ip_addr.encode('utf-8')),
self.EnodeB_IP,
5678,
"192.168.60.112",
3000,
True,
ip_flow_dl=ip_flow_dl,
)
snapshot_verifier = SnapshotVerifier(
self,
self.BRIDGE,
self.service_manager,
)
with snapshot_verifier:
pass
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 _setup_vlan_pop_dev(self):
if self.config.ovs_vlan_workaround:
# Create device
BridgeTools.create_veth_pair(self.config.dev_vlan_in,
self.config.dev_vlan_out)
# Add to OVS,
# OFP requested port (70 and 71) no are for test validation,
# its not used anywhere else.
BridgeTools.add_ovs_port(self.config.uplink_bridge,
self.config.dev_vlan_in, "70")
BridgeTools.add_ovs_port(self.config.uplink_bridge,
self.config.dev_vlan_out, "71")
def setUpClassDevices(cls):
BridgeTools.delete_ns_all()
BridgeTools.create_veth_pair(cls.gtp_veth, cls.gtp_veth_ns)
BridgeTools.ifup_netdev(cls.gtp_veth, cls.gtp_pkt_dst + "/24")
BridgeTools.create_veth_pair(cls.sgi_veth, cls.sgi_veth1)
BridgeTools.create_ns_and_move_veth(cls.NS_NAME, cls.sgi_veth1, cls.inner_src_ip + "/24")
BridgeTools.ifup_netdev(cls.sgi_veth, cls.inner_dst_ip + "/24")
BridgeTools.ifup_netdev(cls.gtp_veth_ns, cls.gtp_pkt_src + "/24")
cls.ebpf_man = ebpf_manager(cls.sgi_veth, cls.gtp_veth, cls.sgi_veth_ip, enabled=True, bpf_ul_file=UL_HANDLER, bpf_dl_file=DL_HANDLER)
cls.ebpf_man.detach_dl_ebpf()
cls.ebpf_man.attach_dl_ebpf()
cls.sniffer = AsyncSniffer(
iface='gtpu_sys_2152',
store=False,
prn=cls.pkt_cap_fun,
)
cls.sniffer.start()
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(UplinkBridgeWithNonNATTestVlan, 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,
'sgi_management_iface_vlan': cls.VLAN_TAG,
'dev_vlan_in': cls.VLAN_DEV_IN,
'dev_vlan_out': cls.VLAN_DEV_OUT,
'sgi_management_iface_ip_addr': '1.1.11.1',
},
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_veth_pair(cls.VLAN_DEV_IN, cls.VLAN_DEV_OUT)
# Add to OVS,
BridgeTools.add_ovs_port(cls.UPLINK_BRIDGE, cls.VLAN_DEV_IN, "70")
BridgeTools.add_ovs_port(cls.UPLINK_BRIDGE, cls.VLAN_DEV_OUT, "71")
# validate vlan id set
vlan = "10"
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()
