def testFlowVlanSnapshotMatch2(self):
fake_inout_setup(self.inout_controller)
cls = self.__class__
vlan1 = "21"
self.setUpNetworkAndController(vlan1)
vlan2 = "22"
cls._setup_vlan(vlan2)
ip_addr = ipaddress.ip_address("10.200.21.211")
mocked_set_mobilityd_gw_info(
IPAddress(address=ip_addr.packed, version=IPBlock.IPV4), "", vlan1)
ip_addr = ipaddress.ip_address("10.200.22.211")
mocked_set_mobilityd_gw_info(
IPAddress(address=ip_addr.packed, version=IPBlock.IPV4), "", vlan2)
hub.sleep(2)
while gw_info_map[vlan2].mac is None or gw_info_map[vlan2].mac == '':
threading.Event().wait(.5)
logging.info("done waiting for vlan: %s", vlan1)
snapshot_verifier = SnapshotVerifier(
self,
self.BRIDGE,
self.service_manager,
max_sleep_time=40,
datapath=cls.inout_controller._datapath,
try_snapshot=True)
with snapshot_verifier:
pass
self.assertEqual(gw_info_map[vlan1].mac, 'b2:a0:cc:85:80:21')
self.assertEqual(gw_info_map[vlan2].mac, 'b2:a0:cc:85:80:22')
def testFlowVlanSnapshotMatch(self):
fake_inout_setup(self.inout_controller)
cls = self.__class__
vlan = "11"
self.setUpNetworkAndController(vlan)
# wait for atleast one iteration of the ARP probe.
ip_addr = ipaddress.ip_address("10.200.11.211")
mocked_set_mobilityd_gw_info(
IPAddress(
address=ip_addr.packed,
version=IPBlock.IPV4,
),
"",
vlan,
)
hub.sleep(2)
while gw_info_map[vlan].mac is None or gw_info_map[vlan].mac == '':
threading.Event().wait(.5)
logging.info("done waiting for vlan: %s", vlan)
snapshot_verifier = SnapshotVerifier(
self,
self.BRIDGE,
self.service_manager,
max_sleep_time=40,
datapath=cls.inout_controller._datapath,
try_snapshot=True,
)
with snapshot_verifier:
pass
self.assertEqual(gw_info_map[vlan].mac, 'b2:a0:cc:85:80:11')
def testFlowSnapshotMatch(self):
fake_inout_setup(self.inout_controller)
cls = self.__class__
self.setUpNetworkAndController(non_nat_arp_egress_port=cls.UPLINK_BR,
gw_mac_addr="33:44:55:ff:ff:ff")
# wait for atleast one iteration of the ARP probe.
ip_addr = ipaddress.ip_address("192.168.128.211")
vlan = ""
mocked_set_mobilityd_gw_info(
IPAddress(address=ip_addr.packed, version=IPBlock.IPV4), "", vlan)
hub.sleep(2)
while gw_info_map[vlan].mac is None or gw_info_map[vlan].mac == '':
threading.Event().wait(.5)
snapshot_verifier = SnapshotVerifier(
self,
self.BRIDGE,
self.service_manager,
max_sleep_time=40,
datapath=cls.inout_controller._datapath,
try_snapshot=True)
with snapshot_verifier:
pass
self.assertEqual(gw_info_map[vlan].mac, 'b2:a0:cc:85:80:7a')
def testFlowSnapshotMatch(self):
ipv6_addr1 = "2002::22"
mac_addr1 = "11:22:33:44:55:88"
mocked_setmacbyip6(ipv6_addr1, mac_addr1)
ip_addr = ipaddress.ip_address(ipv6_addr1)
vlan = "NO_VLAN"
mocked_set_mobilityd_gw_info(
IPAddress(
address=ip_addr.packed,
version=IPBlock.IPV6,
),
"", vlan,
)
fake_inout_setup(self.inout_controller)
snapshot_verifier = SnapshotVerifier(
self,
self.BRIDGE,
self.service_manager,
max_sleep_time=20,
datapath=InOutTestNonNATBasicFlowsIPv6.inout_controller._datapath,
)
with snapshot_verifier:
pass
assert_GW_mac(self, vlan, mac_addr1)
def testFlowVlanSnapshotMatch(self):
cls = self.__class__
vlan = "11"
self.setUpNetworkAndController(vlan)
# wait for atleast one iteration of the ARP probe.
fake_inout_setup(cls.inout_controller)
ip_addr = ipaddress.ip_address("10.200.11.211")
mocked_set_mobilityd_gw_info(
IPAddress(
address=ip_addr.packed,
version=IPBlock.IPV4,
),
'b2:a0:cc:85:80:11', vlan,
)
hub.sleep(2)
check_GW_rec(vlan)
logging.info("done waiting for vlan: %s", vlan)
snapshot_verifier = SnapshotVerifier(
self, self.BRIDGE,
self.service_manager,
max_sleep_time=40,
datapath=cls.inout_controller._datapath,
)
with snapshot_verifier:
pass
assert_GW_mac(self, vlan, 'b2:a0:cc:85:80:11')
def testFlowSnapshotMatch(self):
cls = self.__class__
self.setUpNetworkAndController(
non_nat_arp_egress_port=cls.UPLINK_BR,
gw_mac_addr="33:44:55:ff:ff:ff",
)
fake_inout_setup(cls.inout_controller)
# wait for atleast one iteration of the ARP probe.
ip_addr = ipaddress.ip_address("192.168.128.211")
vlan = ""
mocked_set_mobilityd_gw_info(
IPAddress(
address=ip_addr.packed,
version=IPBlock.IPV4,
),
"b2:a0:cc:85:80:7a", vlan,
)
check_GW_rec(vlan)
snapshot_verifier = SnapshotVerifier(
self, self.BRIDGE,
self.service_manager,
max_sleep_time=40,
datapath=cls.inout_controller._datapath,
)
with snapshot_verifier:
pass
assert_GW_mac(self, vlan, 'b2:a0:cc:85:80:7a')
def testFlowVlanSnapshotMatch_static2(self):
fake_inout_setup(self.inout_controller)
cls = self.__class__
# setup network on unused vlan.
self.setUpNetworkAndController("34")
# statically configured config
vlan1 = "31"
ip_addr = ipaddress.ip_address("10.200.21.100")
mocked_set_mobilityd_gw_info(
IPAddress(
address=ip_addr.packed,
version=IPBlock.IPV4,
),
"11:33:44:55:66:77",
vlan1,
)
vlan2 = "32"
ip_addr = ipaddress.ip_address("10.200.22.200")
mocked_set_mobilityd_gw_info(
IPAddress(
address=ip_addr.packed,
version=IPBlock.IPV4,
),
"22:33:44:55:66:77",
vlan2,
)
ip_addr = ipaddress.ip_address("10.200.22.10")
mocked_set_mobilityd_gw_info(
IPAddress(
address=ip_addr.packed,
version=IPBlock.IPV4,
),
"00:33:44:55:66:77",
"",
)
hub.sleep(2)
while gw_info_map[vlan2].mac is None or gw_info_map[vlan2].mac == '':
threading.Event().wait(.5)
logging.info("done waiting for vlan: %s", vlan1)
snapshot_verifier = SnapshotVerifier(
self,
self.BRIDGE,
self.service_manager,
max_sleep_time=20,
datapath=cls.inout_controller._datapath,
)
with snapshot_verifier:
pass
self.assertEqual(gw_info_map[vlan1].mac, '11:33:44:55:66:77')
self.assertEqual(gw_info_map[vlan2].mac, '22:33:44:55:66:77')
self.assertEqual(gw_info_map[""].mac, '00:33:44:55:66:77')
def testFlowSnapshotMatch(self):
fake_inout_setup(self.inout_controller)
snapshot_verifier = SnapshotVerifier(self,
self.BRIDGE,
self.service_manager,
max_sleep_time=20,
datapath=InOutTestNonNATBasicFlows.inout_controller._datapath)
with snapshot_verifier:
pass
def testFlowVlanSnapshotMatch_static2(self):
cls = self.__class__
# setup network on unused vlan.
self.setUpNetworkAndController("34")
# statically configured config
fake_inout_setup(cls.inout_controller)
vlan1 = "31"
ip_addr = ipaddress.ip_address("10.200.21.100")
mocked_set_mobilityd_gw_info(
IPAddress(
address=ip_addr.packed,
version=IPBlock.IPV4,
),
"11:33:44:55:66:77", vlan1,
)
vlan2 = "32"
ip_addr = ipaddress.ip_address("10.200.22.200")
mocked_set_mobilityd_gw_info(
IPAddress(
address=ip_addr.packed,
version=IPBlock.IPV4,
),
"22:33:44:55:66:77", vlan2,
)
ip_addr = ipaddress.ip_address("10.200.22.10")
mocked_set_mobilityd_gw_info(
IPAddress(
address=ip_addr.packed,
version=IPBlock.IPV4,
),
"00:33:44:55:66:77", "",
)
check_GW_rec(vlan1)
check_GW_rec(vlan2)
check_GW_rec("")
assert_GW_mac(self, vlan1, '11:33:44:55:66:77')
assert_GW_mac(self, vlan2, '22:33:44:55:66:77')
assert_GW_mac(self, "", '00:33:44:55:66:77')
hub.sleep(2)
snapshot_verifier = SnapshotVerifier(
self, self.BRIDGE,
self.service_manager,
max_sleep_time=20,
datapath=cls.inout_controller._datapath,
try_snapshot=True,
)
with snapshot_verifier:
pass
def testFlowVlanSnapshotMatch_static1(self):
cls = self.__class__
# setup network on unused vlan.
vlan1 = "21"
self.setUpNetworkAndController(vlan1)
# statically configured config
vlan2 = "22"
fake_inout_setup(cls.inout_controller)
ip_addr = ipaddress.ip_address("10.200.21.211")
mocked_set_mobilityd_gw_info(
IPAddress(
address=ip_addr.packed,
version=IPBlock.IPV4,
),
"11:33:44:55:66:77", vlan1,
)
ip_addr = ipaddress.ip_address("10.200.22.211")
mocked_set_mobilityd_gw_info(
IPAddress(
address=ip_addr.packed,
version=IPBlock.IPV4,
),
"22:33:44:55:66:77", vlan2,
)
hub.sleep(2)
check_GW_rec(vlan2)
logging.info("done waiting for vlan: %s", vlan1)
snapshot_verifier = SnapshotVerifier(
self, self.BRIDGE,
self.service_manager,
max_sleep_time=20,
datapath=cls.inout_controller._datapath,
)
with snapshot_verifier:
pass
assert_GW_mac(self, vlan1, 'b2:a0:cc:85:80:21')
assert_GW_mac(self, vlan2, '22:33:44:55:66:77')
def testFlowVlanSnapshotMatch2(self):
cls = self.__class__
vlan1 = "21"
self.setUpNetworkAndController(vlan1)
vlan2 = "22"
cls._setup_vlan(vlan2)
fake_inout_setup(cls.inout_controller)
ip_addr = ipaddress.ip_address("10.200.21.211")
mocked_set_mobilityd_gw_info(
IPAddress(
address=ip_addr.packed,
version=IPBlock.IPV4,
),
"b2:a0:cc:85:80:21", vlan1,
)
ip_addr = ipaddress.ip_address("10.200.22.211")
mocked_set_mobilityd_gw_info(
IPAddress(
address=ip_addr.packed,
version=IPBlock.IPV4,
),
"b2:a0:cc:85:80:22", vlan2,
)
check_GW_rec(vlan1)
check_GW_rec(vlan2)
logging.info("done waiting for vlan: %s", vlan1)
snapshot_verifier = SnapshotVerifier(
self, self.BRIDGE,
self.service_manager,
max_sleep_time=40,
datapath=cls.inout_controller._datapath,
)
with snapshot_verifier:
pass
def testFlowSnapshotMatch(self):
fake_inout_setup(self.inout_controller)
assert_bridge_snapshot_match(self, self.BRIDGE, self.service_manager)
def test_passthrough_rules(self):
"""
Add UE MAC flows for two subscribers
"""
imsi_1 = 'IMSI010000000088888'
other_mac = '5e:cc:cc:b1:aa:aa'
cli_ip = '1.1.1.1'
server_ip = '151.42.41.122'
fake_inout_setup(self.inout_controller)
# Add subscriber with UE MAC address """
self.ue_mac_controller.add_ue_mac_flow(imsi_1, self.UE_MAC_1)
# Create a set of packets
pkt_sender = ScapyPacketInjector(self.BRIDGE)
# Only send downlink as the pkt_sender sends pkts from in_port=LOCAL
downlink_packet1 = EtherPacketBuilder() \
.set_ether_layer(self.UE_MAC_1, other_mac) \
.build()
dhcp_packet = DHCPPacketBuilder() \
.set_ether_layer(self.UE_MAC_1, other_mac) \
.set_ip_layer(server_ip, cli_ip) \
.set_udp_layer(67, 68) \
.set_bootp_layer(2, cli_ip, server_ip, other_mac) \
.set_dhcp_layer([("message-type", "ack"), "end"]) \
.build()
dns_packet = UDPPacketBuilder() \
.set_ether_layer(self.UE_MAC_1, other_mac) \
.set_ip_layer('151.42.41.122', '1.1.1.1') \
.set_udp_layer(53, 32795) \
.build()
arp_packet = ARPPacketBuilder() \
.set_ether_layer(self.UE_MAC_1, other_mac) \
.set_arp_layer('1.1.1.1') \
.set_arp_hwdst(self.UE_MAC_1) \
.set_arp_src(other_mac, '1.1.1.12') \
.build()
# Check if these flows were added (queries should return flows)
flow_queries = [
FlowQuery(self._tbl_num,
self.testing_controller,
match=MagmaMatch(eth_dst=self.UE_MAC_1))
]
# =========================== Verification ===========================
# Verify 3 flows installed for ue_mac table (3 pkts matched)
# 4 flows installed for inout (3 pkts matched)
# 2 flows installed (2 pkts matches)
flow_verifier = FlowVerifier([
FlowTest(FlowQuery(self._tbl_num, self.testing_controller), 4, 3),
FlowTest(FlowQuery(self._ingress_tbl_num, self.testing_controller),
4, 3),
FlowTest(FlowQuery(self._egress_tbl_num, self.testing_controller),
3, 2),
FlowTest(flow_queries[0], 4, 1),
], lambda: wait_after_send(self.testing_controller))
snapshot_verifier = SnapshotVerifier(self, self.BRIDGE,
self.service_manager)
with flow_verifier, snapshot_verifier:
pkt_sender.send(dhcp_packet)
pkt_sender.send(downlink_packet1)
pkt_sender.send(dns_packet)
hub.sleep(3)
pkt_sender.send(arp_packet)
flow_verifier.verify()
