Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 1 | from distutils.util import strtobool |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 2 | import copy |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 3 | |
| 4 | FALSE = '0' |
| 5 | TRUE = '1' |
| 6 | DIR_UPLINK = '1' |
| 7 | DIR_DOWNLINK = '2' |
| 8 | IFACE_ACCESS = '1' |
| 9 | IFACE_CORE = '2' |
| 10 | TUNNEL_SPORT = '2152' |
| 11 | TUNNEL_TYPE_GPDU = '3' |
| 12 | |
| 13 | UE_PORT = 400 |
| 14 | PDN_PORT = 800 |
| 15 | GPDU_PORT = 2152 |
| 16 | |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 17 | N_FLOWS_PER_UE = 5 |
Daniele Moro | c6811a8 | 2021-10-12 11:29:41 +0200 | [diff] [blame] | 18 | |
Daniele Moro | a197519 | 2022-01-21 18:01:19 +0100 | [diff] [blame] | 19 | DEFAULT_APP_ID = 0 |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 20 | |
| 21 | class UP4: |
| 22 | """ |
| 23 | Utility that manages interaction with UP4 via a P4RuntimeCliDriver available |
| 24 | in the cluster. Additionally, can verify connectivity by crafting GTP packets |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 25 | via Scapy with an HostDriver component, specified via <enodebs>, <pdn_host>, |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 26 | and <router_mac> parameters. |
| 27 | |
| 28 | Example params file: |
| 29 | <UP4> |
| 30 | <pdn_host>Compute1</pdn_host> # Needed to verify connectivity with scapy |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 31 | <enodebs> # List of emulated eNodeBs |
| 32 | <enode_1> |
| 33 | <host>Compute1</host> # Host that emulates this eNodeB |
| 34 | <interface>eno3</interface> # Name of the linux interface to use on the host, if not specified take the default |
| 35 | <enb_address>10.32.11.122</enb_address> # IP address of the eNodeB |
| 36 | <ues>ue3</ues> # Emulated ues connected to this eNB |
| 37 | </enode_1> |
| 38 | <enodeb_2> |
| 39 | <host>Compute3</host> |
| 40 | <enb_address>10.32.11.194</enb_address> |
| 41 | <ues>ue1,ue2</ues> |
| 42 | </enodeb_2> |
| 43 | </enodebs> |
| 44 | <enodeb_host>Compute3</enodeb_host> |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 45 | <router_mac>00:00:0A:4C:1C:46</router_mac> # Needed to verify connectivity with scapy |
| 46 | <s1u_address>10.32.11.126</s1u_address> |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 47 | <ues> |
| 48 | <ue2> |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 49 | <ue_address>10.240.0.2</ue_address> |
| 50 | <teid>200</teid> |
| 51 | <up_id>20</up_id> |
| 52 | <down_id>21</down_id> |
Carmelo Cascone | 848d1f5 | 2022-01-27 18:15:58 -0800 | [diff] [blame^] | 53 | <!-- TC 0 means BEST EFFORT --> |
| 54 | <tc>2</tc> |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 55 | <five_g>False</five_g> |
| 56 | </ue2> |
| 57 | </ues> |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 58 | <switch_to_kill>Leaf2</switch_to_kill> # Component name of the switch to kill in CASE 5 |
| 59 | <enodebs_fail>enodeb_1</enodebs_fail> # List of eNodeBs that should fail traffic forwarding in CASE 5 |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 60 | </UP4> |
| 61 | """ |
| 62 | |
| 63 | def __init__(self): |
| 64 | self.s1u_address = None |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 65 | self.enodebs = None |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 66 | self.pdn_host = None |
| 67 | self.pdn_interface = None |
| 68 | self.router_mac = None |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 69 | self.emulated_ues = {} |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 70 | self.up4_client = None |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 71 | self.no_host = False |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 72 | |
Daniele Moro | 954e228 | 2021-09-22 17:32:03 +0200 | [diff] [blame] | 73 | def setup(self, p4rt_client, no_host=False): |
| 74 | """ |
| 75 | Set up P4RT and scapy on eNB and PDN hosts |
| 76 | :param p4rt_client: a P4RuntimeCliDriver component |
| 77 | :param no_host: True if you don't want to start scapy on the hosts |
| 78 | :return: |
| 79 | """ |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 80 | self.s1u_address = main.params["UP4"]["s1u_address"] |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 81 | self.emulated_ues = main.params["UP4"]['ues'] |
| 82 | self.up4_client = p4rt_client |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 83 | self.no_host = no_host |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 84 | |
| 85 | # Optional Parameters |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 86 | |
| 87 | self.enodebs = copy.deepcopy((main.params["UP4"]["enodebs"])) |
| 88 | for enb in self.enodebs.values(): |
| 89 | enb["ues"] = enb["ues"].split(",") |
| 90 | enb["host"] = getattr(main, enb["host"]) |
| 91 | # If interface not provided by the params, use the default in the host |
| 92 | if "interface" not in enb.keys(): |
| 93 | enb["interface"] = enb["host"].interfaces[0]["name"] |
| 94 | if "pdn_host" in main.params["UP4"]: |
| 95 | self.pdn_host = getattr(main, main.params["UP4"]["pdn_host"]) |
| 96 | self.pdn_interface = self.pdn_host.interfaces[0] |
| 97 | self.router_mac = main.params["UP4"].get("router_mac", None) |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 98 | |
| 99 | # Start components |
| 100 | self.up4_client.startP4RtClient() |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 101 | if not self.no_host: |
| 102 | if self.enodebs is not None: |
| 103 | for enb in self.enodebs.values(): |
| 104 | enb["host"].startScapy(ifaceName=enb["interface"], |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 105 | enableGtp=True) |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 106 | if self.pdn_host is not None: |
| 107 | self.pdn_host.startScapy(ifaceName=self.pdn_interface["name"]) |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 108 | |
| 109 | def teardown(self): |
| 110 | self.up4_client.stopP4RtClient() |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 111 | if not self.no_host: |
| 112 | if self.enodebs is not None: |
| 113 | for enb in self.enodebs.values(): |
| 114 | enb["host"].stopScapy() |
| 115 | if self.pdn_host is not None: |
| 116 | self.pdn_host.stopScapy() |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 117 | |
| 118 | def attachUes(self): |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 119 | for (name, ue) in self.emulated_ues.items(): |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 120 | ue = UP4.__sanitizeUeData(ue) |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 121 | self.attachUe(name, **ue) |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 122 | |
| 123 | def detachUes(self): |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 124 | for (name, ue) in self.emulated_ues.items(): |
Daniele Moro | 249d6e7 | 2021-09-20 10:32:54 +0200 | [diff] [blame] | 125 | ue = UP4.__sanitizeUeData(ue) |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 126 | self.detachUe(name, **ue) |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 127 | |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 128 | def testUpstreamTraffic(self, enb_names=None, shouldFail=False): |
| 129 | if self.enodebs is None or self.pdn_host is None: |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 130 | main.log.error( |
| 131 | "Need eNodeB and PDN host params to generate scapy traffic") |
| 132 | return |
| 133 | # Scapy filter needs to start before sending traffic |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 134 | if enb_names is None or enb_names == []: |
| 135 | enodebs = self.enodebs.values() |
| 136 | else: |
| 137 | enodebs = [self.enodebs[enb] for enb in enb_names] |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 138 | pkt_filter_upstream = "" |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 139 | ues = [] |
| 140 | for enb in enodebs: |
| 141 | for ue_name in enb["ues"]: |
| 142 | ue = self.emulated_ues[ue_name] |
| 143 | if "ue_address" in ue: |
| 144 | ues.append(ue) |
| 145 | if len(pkt_filter_upstream) != 0: |
| 146 | pkt_filter_upstream += " or " |
| 147 | pkt_filter_upstream += "src host " + ue["ue_address"] |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 148 | pkt_filter_upstream = "ip and udp dst port %s and (%s) and dst host %s" % \ |
| 149 | (PDN_PORT, pkt_filter_upstream, |
| 150 | self.pdn_interface["ips"][0]) |
| 151 | main.log.info("Start listening on %s intf %s" % |
| 152 | (self.pdn_host.name, self.pdn_interface["name"])) |
| 153 | main.log.debug("BPF Filter Upstream: \n %s" % pkt_filter_upstream) |
| 154 | self.pdn_host.startFilter(ifaceName=self.pdn_interface["name"], |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 155 | sniffCount=len(ues), |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 156 | pktFilter=pkt_filter_upstream) |
| 157 | |
| 158 | main.log.info( |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 159 | "Sending %d packets from eNodeB host" % len(ues)) |
| 160 | for enb in enodebs: |
| 161 | for ue_name in enb["ues"]: |
| 162 | main.log.info(ue_name) |
| 163 | ue = self.emulated_ues[ue_name] |
| 164 | main.log.info(str(ue)) |
| 165 | UP4.buildGtpPacket(enb["host"], |
| 166 | src_ip_outer=enb["enb_address"], |
| 167 | dst_ip_outer=self.s1u_address, |
| 168 | src_ip_inner=ue["ue_address"], |
| 169 | dst_ip_inner=self.pdn_interface["ips"][0], |
| 170 | src_udp_inner=UE_PORT, |
| 171 | dst_udp_inner=PDN_PORT, |
| 172 | teid=int(ue["teid"])) |
| 173 | enb["host"].sendPacket(iface=enb["interface"]) |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 174 | |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 175 | packets = UP4.checkFilterAndGetPackets(self.pdn_host) |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 176 | fail = False |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 177 | if len(ues) != packets.count('Ether'): |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 178 | fail = True |
Daniele Moro | c6811a8 | 2021-10-12 11:29:41 +0200 | [diff] [blame] | 179 | msg = "Failed to capture packets in PDN.\n" + str(packets) |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 180 | else: |
| 181 | msg = "Correctly captured packet in PDN. " |
| 182 | # We expect exactly 1 packet per UE |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 183 | pktsFiltered = [packets.count("src=" + ue["ue_address"]) for ue in ues] |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 184 | if pktsFiltered.count(1) != len(pktsFiltered): |
| 185 | fail = True |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 186 | msg += "\nError on the number of packets per UE in downstream.\n" + str( |
| 187 | packets) |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 188 | else: |
Daniele Moro | c6811a8 | 2021-10-12 11:29:41 +0200 | [diff] [blame] | 189 | msg += "\nOne packet per UE in upstream. " |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 190 | |
| 191 | utilities.assert_equal( |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 192 | expect=shouldFail, actual=fail, onpass=msg, onfail=msg) |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 193 | |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 194 | def testDownstreamTraffic(self, enb_names=None, shouldFail=False): |
| 195 | if self.enodebs is None or self.pdn_host is None: |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 196 | main.log.error( |
| 197 | "Need eNodeB and PDN host params to generate scapy traffic") |
| 198 | return |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 199 | if enb_names is None or enb_names == []: |
| 200 | enodebs = self.enodebs.values() |
| 201 | else: |
| 202 | enodebs = [self.enodebs[enb] for enb in enb_names] |
| 203 | pkt_filter_downstream = "ip and udp src port %d and udp dst port %d and src host %s" % ( |
| 204 | GPDU_PORT, GPDU_PORT, self.s1u_address) |
| 205 | ues = [] |
| 206 | for enb in enodebs: |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 207 | filter_down = pkt_filter_downstream + " and dst host %s" % enb[ |
| 208 | "enb_address"] |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 209 | main.log.info("Start listening on %s intf %s" % ( |
| 210 | enb["host"], enb["interface"])) |
| 211 | main.log.debug("BPF Filter Downstream: \n %s" % filter_down) |
| 212 | enb["host"].startFilter(ifaceName=enb["interface"], |
| 213 | sniffCount=len(enb["ues"]), |
| 214 | pktFilter=filter_down) |
| 215 | ues.extend([self.emulated_ues[ue_name] for ue_name in enb["ues"]]) |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 216 | |
| 217 | main.log.info( |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 218 | "Sending %d packets from PDN host" % len(ues)) |
| 219 | for ue in ues: |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 220 | # From PDN we have to set dest MAC, otherwise scapy will do ARP |
| 221 | # request for the UE IP address. |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 222 | UP4.buildUdpPacket(self.pdn_host, |
| 223 | dst_eth=self.router_mac, |
| 224 | src_ip=self.pdn_interface["ips"][0], |
| 225 | dst_ip=ue["ue_address"], |
| 226 | src_udp=PDN_PORT, |
| 227 | dst_udp=UE_PORT) |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 228 | self.pdn_host.sendPacket(iface=self.pdn_interface["name"]) |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 229 | packets = "" |
| 230 | for enb in enodebs: |
| 231 | pkt = UP4.checkFilterAndGetPackets(enb["host"]) |
| 232 | packets += pkt |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 233 | # The BPF filter might capture non-GTP packets because we can't filter |
| 234 | # GTP header in BPF. For this reason, check that the captured packets |
| 235 | # are from the expected tunnels. |
| 236 | # TODO: check inner UDP and IP fields as well |
| 237 | # FIXME: with newer scapy TEID becomes teid (required for Scapy 2.4.5) |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 238 | pktsFiltered = [packets.count("TEID=" + hex(int(ue["teid"])) + "L ") |
| 239 | for ue in ues] |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 240 | main.log.info("PACKETS: " + str(packets)) |
| 241 | main.log.info("PKTs Filtered: " + str(pktsFiltered)) |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 242 | fail = False |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 243 | if len(ues) != sum(pktsFiltered): |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 244 | fail = True |
Daniele Moro | c6811a8 | 2021-10-12 11:29:41 +0200 | [diff] [blame] | 245 | msg = "Failed to capture packets in eNodeB.\n" + str(packets) |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 246 | else: |
| 247 | msg = "Correctly captured packets in eNodeB. " |
| 248 | # We expect exactly 1 packet per UE |
| 249 | if pktsFiltered.count(1) != len(pktsFiltered): |
| 250 | fail = True |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 251 | msg += "\nError on the number of packets per GTP TEID in downstream.\n" + str( |
| 252 | packets) |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 253 | else: |
Daniele Moro | c6811a8 | 2021-10-12 11:29:41 +0200 | [diff] [blame] | 254 | msg += "\nOne packet per GTP TEID in downstream. " |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 255 | |
| 256 | utilities.assert_equal( |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 257 | expect=shouldFail, actual=fail, onpass=msg, onfail=msg) |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 258 | |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 259 | def readUeSessionsNumber(self): |
Daniele Moro | 954e228 | 2021-09-22 17:32:03 +0200 | [diff] [blame] | 260 | """ |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 261 | Read the UE session tables and return the number of entries |
Daniele Moro | 954e228 | 2021-09-22 17:32:03 +0200 | [diff] [blame] | 262 | |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 263 | :return: Number of entries in the UE session tables |
Daniele Moro | 954e228 | 2021-09-22 17:32:03 +0200 | [diff] [blame] | 264 | """ |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 265 | tableName = 'PreQosPipe.sessions_uplink' |
| 266 | nUeSess = self.up4_client.readNumberTableEntries(tableName) |
| 267 | tableName = 'PreQosPipe.sessions_downlink' |
| 268 | nUeSess += self.up4_client.readNumberTableEntries(tableName) |
| 269 | return nUeSess |
Daniele Moro | 954e228 | 2021-09-22 17:32:03 +0200 | [diff] [blame] | 270 | |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 271 | def readTerminationsNumber(self): |
Daniele Moro | 954e228 | 2021-09-22 17:32:03 +0200 | [diff] [blame] | 272 | """ |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 273 | Read the terminations and return the number of entities |
Daniele Moro | 954e228 | 2021-09-22 17:32:03 +0200 | [diff] [blame] | 274 | |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 275 | :return: Number of terminations entities |
Daniele Moro | 954e228 | 2021-09-22 17:32:03 +0200 | [diff] [blame] | 276 | """ |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 277 | tableName = 'PreQosPipe.terminations_uplink' |
| 278 | nTerm = self.up4_client.readNumberTableEntries(tableName) |
| 279 | tableName = 'PreQosPipe.terminations_downlink' |
| 280 | nTerm += self.up4_client.readNumberTableEntries(tableName) |
| 281 | return nTerm |
Daniele Moro | 954e228 | 2021-09-22 17:32:03 +0200 | [diff] [blame] | 282 | |
| 283 | def verifyUesFlowNumberP4rt(self): |
| 284 | """ |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 285 | Verify via P4RT CLI that the number of UE sessions and terminations |
| 286 | is the expected one |
Daniele Moro | 954e228 | 2021-09-22 17:32:03 +0200 | [diff] [blame] | 287 | |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 288 | :return: True if the number of UE sessions and terminations is expected, |
| 289 | False otherwise |
Daniele Moro | 954e228 | 2021-09-22 17:32:03 +0200 | [diff] [blame] | 290 | """ |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 291 | nUeSessions = self.readUeSessionsNumber() |
| 292 | nTerminations = self.readTerminationsNumber() |
| 293 | return nUeSessions == nTerminations == len(self.emulated_ues) * 2 |
Daniele Moro | 954e228 | 2021-09-22 17:32:03 +0200 | [diff] [blame] | 294 | |
| 295 | def verifyNoUesFlowNumberP4rt(self, preInstalledUes=0): |
| 296 | """ |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 297 | Verify via P4RT CLI that there is no UE sessions and terminations installed. |
Daniele Moro | 954e228 | 2021-09-22 17:32:03 +0200 | [diff] [blame] | 298 | |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 299 | :param preInstalledUes: Number of UEs whose UE sessions and terminations |
| 300 | are still programmed |
Daniele Moro | 954e228 | 2021-09-22 17:32:03 +0200 | [diff] [blame] | 301 | :return: |
| 302 | """ |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 303 | return self.readUeSessionsNumber() == self.readTerminationsNumber() == preInstalledUes * 2 |
Daniele Moro | 954e228 | 2021-09-22 17:32:03 +0200 | [diff] [blame] | 304 | |
Daniele Moro | 6dfbfef | 2021-09-28 22:44:19 +0200 | [diff] [blame] | 305 | def verifyNoUesFlow(self, onosCli, retries=10): |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 306 | """ |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 307 | Verify that no UE session, terminations are installed in ONOS. |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 308 | |
| 309 | :param onosCli: An instance of a OnosCliDriver |
| 310 | :param retries: number of retries |
| 311 | :return: |
| 312 | """ |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 313 | retValue = utilities.retry(f=UP4.__verifyNoUeSessionAndTerminationOnos, |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 314 | retValue=False, |
| 315 | args=[onosCli], |
Daniele Moro | 6dfbfef | 2021-09-28 22:44:19 +0200 | [diff] [blame] | 316 | sleep=5, |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 317 | attempts=retries) |
| 318 | utilities.assert_equal(expect=True, |
| 319 | actual=retValue, |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 320 | onpass="No UE session and terminations in ONOS", |
| 321 | onfail="Stale UE session or terminations") |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 322 | |
| 323 | @staticmethod |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 324 | def __verifyNoUeSessionAndTerminationOnos(onosCli): |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 325 | """ |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 326 | Verify that no UE session, terminations are installed in ONOS |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 327 | |
| 328 | :param onosCli: An instance of a OnosCliDriver |
| 329 | """ |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 330 | sessions = onosCli.sendline(cmdStr="up4:read-entities -s", |
| 331 | showResponse=True, |
| 332 | noExit=True, expectJson=False) |
| 333 | terminations = onosCli.sendline(cmdStr="up4:read-entities -t", |
| 334 | showResponse=True, |
| 335 | noExit=True, expectJson=False) |
| 336 | return sessions == "" and terminations == "" |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 337 | |
Daniele Moro | c6811a8 | 2021-10-12 11:29:41 +0200 | [diff] [blame] | 338 | def verifyUp4Flow(self, onosCli, retries=10): |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 339 | """ |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 340 | Verify UE session, terminations and GTP tunnel peers installed via UP4 |
| 341 | using the ONOS CLI. |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 342 | |
| 343 | :param onosCli: An instance of a OnosCliDriver |
Daniele Moro | c6811a8 | 2021-10-12 11:29:41 +0200 | [diff] [blame] | 344 | :param retries: Number of retries |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 345 | """ |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 346 | failString = "" |
Daniele Moro | c6811a8 | 2021-10-12 11:29:41 +0200 | [diff] [blame] | 347 | retValue = utilities.retry(f=self.__internalVerifyUp4Flow, |
| 348 | retValue=False, |
| 349 | args=[onosCli, failString], |
| 350 | sleep=5, |
| 351 | attempts=retries) |
| 352 | utilities.assert_equal( |
| 353 | expect=True, |
| 354 | actual=retValue, |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 355 | onpass="Correct UE session, terminations and GTP tunnel peers in ONOS", |
| 356 | onfail="Wrong UE session, terminations and GTP tunnel peers in ONOS. " + |
| 357 | "Missing:\n" + failString |
Daniele Moro | c6811a8 | 2021-10-12 11:29:41 +0200 | [diff] [blame] | 358 | ) |
| 359 | |
| 360 | def __internalVerifyUp4Flow(self, onosCli, failMsg=""): |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 361 | sessions = onosCli.sendline(cmdStr="up4:read-entities -s", |
| 362 | showResponse=True, |
| 363 | noExit=True, expectJson=False) |
| 364 | terminations = onosCli.sendline(cmdStr="up4:read-entities -t", |
| 365 | showResponse=True, |
| 366 | noExit=True, expectJson=False) |
| 367 | tunn_peer = onosCli.sendline(cmdStr="up4:read-entities -g", |
| 368 | showResponse=True, |
| 369 | noExit=True, expectJson=False) |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 370 | fail = False |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 371 | for (ue_name, ue) in self.emulated_ues.items(): |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 372 | if sessions.count(self.upUeSessionOnosString(**ue)) != 1: |
| 373 | failMsg += self.upUeSessionOnosString(**ue) + "\n" |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 374 | fail = True |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 375 | if sessions.count(self.downUeSessionOnosString(**ue)) != 1: |
| 376 | failMsg += self.downUeSessionOnosString(**ue) + "\n" |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 377 | fail = True |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 378 | if terminations.count(self.upTerminationOnosString(**ue)) != 1: |
| 379 | failMsg += self.upTerminationOnosString(**ue) + "\n" |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 380 | fail = True |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 381 | if terminations.count(self.downTerminationOnosString(**ue)) != 1: |
| 382 | failMsg += self.downTerminationOnosString(**ue) + "\n" |
| 383 | fail = True |
| 384 | if tunn_peer.count(self.gtpTunnelPeerOnosString(ue_name, **ue)) != 1: |
| 385 | failMsg += self.gtpTunnelPeerOnosString(ue_name, **ue) + "\n" |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 386 | fail = True |
Daniele Moro | c6811a8 | 2021-10-12 11:29:41 +0200 | [diff] [blame] | 387 | return not fail |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 388 | |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 389 | def upUeSessionOnosString(self, teid=None, teid_up=None, **kwargs): |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 390 | if teid is not None: |
| 391 | teid_up = teid |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 392 | return "UESessionUL{{Match(tun_dst_addr={}, TEID={}) -> (FWD)}}".format( |
| 393 | self.s1u_address, teid_up) |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 394 | |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 395 | def downUeSessionOnosString(self, ue_address, down_id=None, |
| 396 | tunn_peer_id=None, |
| 397 | **kwargs): |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 398 | if down_id is not None: |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 399 | tunn_peer_id = down_id |
| 400 | return "UESessionDL{{Match(ue_addr={}) -> (FWD, tun_peer={})}}".format( |
| 401 | ue_address, tunn_peer_id) |
| 402 | |
| 403 | def upTerminationOnosString(self, ue_address, up_id=None, ctr_id_up=None, |
Carmelo Cascone | 848d1f5 | 2022-01-27 18:15:58 -0800 | [diff] [blame^] | 404 | tc=None, **kwargs): |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 405 | if up_id is not None: |
| 406 | ctr_id_up = up_id |
| 407 | return "TerminationUL{{Match(ue_addr={})->(CTR_ID={}, TC={})}}".format( |
Carmelo Cascone | 848d1f5 | 2022-01-27 18:15:58 -0800 | [diff] [blame^] | 408 | ue_address, ctr_id_up, tc) |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 409 | |
| 410 | def downTerminationOnosString(self, ue_address, teid=None, down_id=None, |
Carmelo Cascone | 848d1f5 | 2022-01-27 18:15:58 -0800 | [diff] [blame^] | 411 | ctr_id_down=None, teid_down=None, tc=None, |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 412 | **kwargs): |
| 413 | if down_id is not None: |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 414 | ctr_id_down = down_id |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 415 | if teid is not None: |
| 416 | teid_down = teid |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 417 | return "TerminationDL{{Match(ue_addr={})->(TEID={}, CTR_ID={}, QFI={}, TC={})}}".format( |
Carmelo Cascone | 848d1f5 | 2022-01-27 18:15:58 -0800 | [diff] [blame^] | 418 | ue_address, teid_down, ctr_id_down, tc, tc) |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 419 | |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 420 | def gtpTunnelPeerOnosString(self, ue_name, down_id=None, tunn_peer_id=None, |
| 421 | **kwargs): |
| 422 | if down_id is not None: |
| 423 | tunn_peer_id = down_id |
| 424 | enb_address = self.__getEnbAddress(ue_name) |
| 425 | return "GTP-Tunnel-Peer({} -> src:{}, dst:{} srcPort:{})".format( |
| 426 | tunn_peer_id, self.s1u_address, enb_address, GPDU_PORT) |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 427 | |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 428 | @staticmethod |
| 429 | def __sanitizeUeData(ue): |
Daniele Moro | 249d6e7 | 2021-09-20 10:32:54 +0200 | [diff] [blame] | 430 | if "five_g" in ue and type(ue["five_g"]) != bool: |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 431 | ue["five_g"] = bool(strtobool(ue["five_g"])) |
Carmelo Cascone | 848d1f5 | 2022-01-27 18:15:58 -0800 | [diff] [blame^] | 432 | if "tc" in ue and ue["tc"] == "": |
| 433 | ue["tc"] = 0 |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 434 | return ue |
| 435 | |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 436 | def attachUe(self, ue_name, ue_address, |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 437 | teid=None, up_id=None, down_id=None, |
| 438 | teid_up=None, teid_down=None, |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 439 | ctr_id_up=None, ctr_id_down=None, |
| 440 | tunn_peer_id=None, |
Carmelo Cascone | 848d1f5 | 2022-01-27 18:15:58 -0800 | [diff] [blame^] | 441 | tc=None, five_g=False): |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 442 | self.__programUp4Rules(ue_name, |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 443 | ue_address, |
| 444 | teid, up_id, down_id, |
| 445 | teid_up, teid_down, |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 446 | ctr_id_up, ctr_id_down, |
| 447 | tunn_peer_id, |
Carmelo Cascone | 848d1f5 | 2022-01-27 18:15:58 -0800 | [diff] [blame^] | 448 | tc, five_g, action="program") |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 449 | |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 450 | def detachUe(self, ue_name, ue_address, |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 451 | teid=None, up_id=None, down_id=None, |
| 452 | teid_up=None, teid_down=None, |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 453 | ctr_id_up=None, ctr_id_down=None, |
| 454 | tunn_peer_id=None, |
Carmelo Cascone | 848d1f5 | 2022-01-27 18:15:58 -0800 | [diff] [blame^] | 455 | tc=None, five_g=False): |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 456 | self.__programUp4Rules(ue_name, |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 457 | ue_address, |
| 458 | teid, up_id, down_id, |
| 459 | teid_up, teid_down, |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 460 | ctr_id_up, ctr_id_down, |
| 461 | tunn_peer_id, |
Carmelo Cascone | 848d1f5 | 2022-01-27 18:15:58 -0800 | [diff] [blame^] | 462 | tc, five_g, action="clear") |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 463 | |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 464 | def __programUp4Rules(self, ue_name, ue_address, |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 465 | teid=None, up_id=None, down_id=None, |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 466 | teid_up=None, teid_down=None, ctr_id_up=None, |
| 467 | ctr_id_down=None, tunn_peer_id=None, |
Carmelo Cascone | 848d1f5 | 2022-01-27 18:15:58 -0800 | [diff] [blame^] | 468 | tc=0, five_g=False, app_id=DEFAULT_APP_ID, |
Daniele Moro | a197519 | 2022-01-21 18:01:19 +0100 | [diff] [blame] | 469 | action="program"): |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 470 | if up_id is not None: |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 471 | ctr_id_up = up_id |
| 472 | if down_id is not None: |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 473 | tunn_peer_id = down_id |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 474 | ctr_id_down = down_id |
| 475 | if teid is not None: |
| 476 | teid_up = teid |
| 477 | teid_down = teid |
| 478 | |
| 479 | entries = [] |
| 480 | |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 481 | # Retrieve eNobeB address from eNodeB list |
| 482 | enb_address = self.__getEnbAddress(ue_name) |
| 483 | |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 484 | # ========================# |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 485 | # UE Session Entries |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 486 | # ========================# |
| 487 | |
| 488 | # Uplink |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 489 | tableName = 'PreQosPipe.sessions_uplink' |
| 490 | actionName = 'PreQosPipe.set_session_uplink' |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 491 | matchFields = {} |
| 492 | actionParams = {} |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 493 | # Match fields |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 494 | matchFields['n3_address'] = str(self.s1u_address) |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 495 | matchFields['teid'] = str(teid_up) |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 496 | if five_g: |
| 497 | # TODO: currently QFI match is unsupported in TNA |
| 498 | main.log.warn("Matching on QFI is currently unsupported in TNA") |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 499 | if not self.__add_entry(tableName, actionName, matchFields, |
| 500 | actionParams, entries, action): |
| 501 | return False |
| 502 | |
| 503 | # Downlink |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 504 | tableName = 'PreQosPipe.sessions_downlink' |
| 505 | actionName = 'PreQosPipe.set_session_downlink' |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 506 | matchFields = {} |
| 507 | actionParams = {} |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 508 | # Match fields |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 509 | matchFields['ue_address'] = str(ue_address) |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 510 | # Action params |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 511 | actionParams['tunnel_peer_id'] = str(tunn_peer_id) |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 512 | if not self.__add_entry(tableName, actionName, matchFields, |
| 513 | actionParams, entries, action): |
| 514 | return False |
| 515 | |
| 516 | # ========================# |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 517 | # Terminations Entries |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 518 | # ========================# |
| 519 | |
| 520 | # Uplink |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 521 | tableName = 'PreQosPipe.terminations_uplink' |
| 522 | actionName = 'PreQosPipe.uplink_term_fwd' |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 523 | matchFields = {} |
| 524 | actionParams = {} |
| 525 | |
| 526 | # Match fields |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 527 | matchFields['ue_address'] = str(ue_address) |
Daniele Moro | a197519 | 2022-01-21 18:01:19 +0100 | [diff] [blame] | 528 | matchFields['app_id'] = str(app_id) |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 529 | # Action params |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 530 | actionParams['ctr_idx'] = str(ctr_id_up) |
Carmelo Cascone | 848d1f5 | 2022-01-27 18:15:58 -0800 | [diff] [blame^] | 531 | actionParams['tc'] = str(tc) |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 532 | if not self.__add_entry(tableName, actionName, matchFields, |
| 533 | actionParams, entries, action): |
| 534 | return False |
| 535 | |
| 536 | # Downlink |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 537 | tableName = 'PreQosPipe.terminations_downlink' |
| 538 | actionName = 'PreQosPipe.downlink_term_fwd' |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 539 | matchFields = {} |
| 540 | actionParams = {} |
| 541 | |
| 542 | # Match fields |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 543 | matchFields['ue_address'] = str(ue_address) |
Daniele Moro | a197519 | 2022-01-21 18:01:19 +0100 | [diff] [blame] | 544 | matchFields['app_id'] = str(app_id) |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 545 | # Action params |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 546 | actionParams['teid'] = str(teid_down) |
| 547 | actionParams['ctr_idx'] = str(ctr_id_down) |
| 548 | # 1-1 mapping between QFI and TC |
Carmelo Cascone | 848d1f5 | 2022-01-27 18:15:58 -0800 | [diff] [blame^] | 549 | actionParams['tc'] = str(tc) |
| 550 | actionParams['qfi'] = str(tc) |
Daniele Moro | 49a843c | 2022-01-05 14:36:32 +0100 | [diff] [blame] | 551 | if not self.__add_entry(tableName, actionName, matchFields, |
| 552 | actionParams, entries, action): |
| 553 | return False |
| 554 | |
| 555 | # ========================# |
| 556 | # Tunnel Peer Entry |
| 557 | # ========================# |
| 558 | tableName = 'PreQosPipe.tunnel_peers' |
| 559 | actionName = 'PreQosPipe.load_tunnel_param' |
| 560 | matchFields = {} |
| 561 | actionParams = {} |
| 562 | # Match fields |
| 563 | matchFields['tunnel_peer_id'] = str(tunn_peer_id) |
| 564 | # Action params |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 565 | actionParams['src_addr'] = str(self.s1u_address) |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 566 | actionParams['dst_addr'] = str(enb_address) |
Daniele Moro | 8088956 | 2021-09-08 10:09:26 +0200 | [diff] [blame] | 567 | actionParams['sport'] = TUNNEL_SPORT |
| 568 | if not self.__add_entry(tableName, actionName, matchFields, |
| 569 | actionParams, entries, action): |
| 570 | return False |
| 571 | if action == "program": |
| 572 | main.log.info("All entries added successfully.") |
| 573 | elif action == "clear": |
| 574 | self.__clear_entries(entries) |
| 575 | |
| 576 | def __add_entry(self, tableName, actionName, matchFields, actionParams, |
| 577 | entries, action): |
| 578 | if action == "program": |
| 579 | self.up4_client.buildP4RtTableEntry( |
| 580 | tableName=tableName, actionName=actionName, |
| 581 | actionParams=actionParams, matchFields=matchFields) |
| 582 | if self.up4_client.pushTableEntry(debug=True) == main.TRUE: |
| 583 | main.log.info("*** Entry added.") |
| 584 | else: |
| 585 | main.log.error("Error during table insertion") |
| 586 | self.__clear_entries(entries) |
| 587 | return False |
| 588 | entries.append({"tableName": tableName, "actionName": actionName, |
| 589 | "matchFields": matchFields, |
| 590 | "actionParams": actionParams}) |
| 591 | return True |
| 592 | |
| 593 | def __clear_entries(self, entries): |
| 594 | for i, entry in enumerate(entries): |
| 595 | self.up4_client.buildP4RtTableEntry(**entry) |
| 596 | if self.up4_client.deleteTableEntry(debug=True) == main.TRUE: |
| 597 | main.log.info( |
| 598 | "*** Entry %d of %d deleted." % (i + 1, len(entries))) |
| 599 | else: |
| 600 | main.log.error("Error during table delete") |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 601 | |
Daniele Moro | 522023c | 2021-10-15 17:30:33 +0200 | [diff] [blame] | 602 | def __getEnbAddress(self, ue_name): |
| 603 | for enb in self.enodebs.values(): |
| 604 | if ue_name in enb["ues"]: |
| 605 | return enb["enb_address"] |
| 606 | main.log.error("Missing eNodeB address!") |
| 607 | return "" |
| 608 | |
Daniele Moro | bf53dec | 2021-09-13 18:11:56 +0200 | [diff] [blame] | 609 | @staticmethod |
| 610 | def buildGtpPacket(host, src_ip_outer, dst_ip_outer, src_ip_inner, |
| 611 | dst_ip_inner, src_udp_inner, dst_udp_inner, teid): |
| 612 | host.buildEther() |
| 613 | host.buildIP(src=src_ip_outer, dst=dst_ip_outer) |
| 614 | host.buildUDP(ipVersion=4, dport=GPDU_PORT) |
| 615 | # FIXME: With newer scapy TEID becomes teid (required for Scapy 2.4.5) |
| 616 | host.buildGTP(gtp_type=0xFF, TEID=teid) |
| 617 | host.buildIP(overGtp=True, src=src_ip_inner, dst=dst_ip_inner) |
| 618 | host.buildUDP(ipVersion=4, overGtp=True, sport=src_udp_inner, |
| 619 | dport=dst_udp_inner) |
| 620 | |
| 621 | @staticmethod |
| 622 | def buildUdpPacket(host, src_ip, dst_ip, src_udp, dst_udp, src_eth=None, |
| 623 | dst_eth=None): |
| 624 | host.buildEther(src=src_eth, dst=dst_eth) |
| 625 | host.buildIP(src=src_ip, dst=dst_ip) |
| 626 | host.buildUDP(ipVersion=4, sport=src_udp, dport=dst_udp) |
| 627 | |
| 628 | @staticmethod |
| 629 | def checkFilterAndGetPackets(host): |
| 630 | finished = host.checkFilter() |
| 631 | if finished: |
| 632 | packets = host.readPackets(detailed=True) |
| 633 | for p in packets.splitlines(): |
| 634 | main.log.debug(p) |
| 635 | # We care only of the last line from readPackets |
| 636 | return packets.splitlines()[-1] |
| 637 | else: |
| 638 | kill = host.killFilter() |
| 639 | main.log.debug(kill) |
| 640 | return "" |