[EDGEPOD-231] Add helm chart for BESS based OMEC user plane
Change-Id: I4321beca6731b261fcb62a7c880318d865e64542
diff --git a/omec/omec-user-plane/files/route_control.py b/omec/omec-user-plane/files/route_control.py
new file mode 100755
index 0000000..11621d6
--- /dev/null
+++ b/omec/omec-user-plane/files/route_control.py
@@ -0,0 +1,524 @@
+#!/usr/bin/env python
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2020-present Open Networking Foundation
+# Copyright(c) 2019 Intel Corporation
+
+import argparse
+import signal
+import sys
+import time
+
+# for retrieving neighbor info
+from pyroute2 import IPDB, IPRoute
+
+from scapy.all import *
+
+try:
+ from pybess.bess import *
+except ImportError:
+ print('Cannot import the API module (pybess)')
+ raise
+
+MAX_RETRIES = 5
+SLEEP_S = 2
+
+
+class NeighborEntry:
+ def __init__(self):
+ self.neighbor_ip = None
+ self.iface = None
+ self.iprange = None
+ self.prefix_len = None
+ self.route_count = 0
+ self.gate_idx = 0
+ self.macstr = None
+
+ def __str__(self):
+ return ('{neigh: %s, iface: %s, ip-range: %s/%s}' %
+ (self.neighbor_ip, self.iface, self.iprange, self.prefix_len))
+
+
+def mac2hex(mac):
+ return int(mac.replace(':', ''), 16)
+
+
+def send_ping(neighbor_ip):
+ send(IP(dst=neighbor_ip) / ICMP())
+
+
+def send_arp(neighbor_ip, src_mac, iface):
+ pkt = Ether(dst="ff:ff:ff:ff:ff:ff") / ARP(pdst=neighbor_ip, hwsrc=src_mac)
+ pkt.show()
+ hexdump(pkt)
+ sendp(pkt, iface=iface)
+
+
+def fetch_mac(dip):
+ ip = ''
+ _mac = ''
+ neighbors = ipr.get_neighbours(dst=dip)
+ for i in range(len(neighbors)):
+ for att in neighbors[i]['attrs']:
+ if 'NDA_DST' in att and dip == att[1]:
+ # ('NDA_DST', dip)
+ ip = att[1]
+ if 'NDA_LLADDR' in att:
+ # ('NDA_LLADDR', _mac)
+ _mac = att[1]
+ return _mac
+
+
+def link_modules(server, module, next_module, ogate=0, igate=0):
+ print('Linking {} module'.format(next_module))
+
+ # Pause bess first
+ bess.pause_all()
+ # Connect module to next_module
+ for _ in range(MAX_RETRIES):
+ try:
+ server.connect_modules(module, next_module, ogate, igate)
+ except BESS.Error as e:
+ bess.resume_all()
+ if e.code == errno.EBUSY:
+ break
+ else:
+ return #raise
+ except Exception as e:
+ print(
+ 'Error connecting module {}:{}->{}:{}: {}. Retrying in {} secs...'
+ .format(module, ogate, igate, next_module, e, SLEEP_S))
+ time.sleep(SLEEP_S)
+ else:
+ bess.resume_all()
+ break
+ else:
+ bess.resume_all()
+ print('BESS module connection ({}:{}->{}:{}) failure.'.format(
+ module, ogate, igate, next_module))
+ return
+ #raise Exception('BESS module connection ({}:{}->{}:{}) failure.'.
+ # format(module, ogate, igate, next_module))
+
+
+def link_route_module(server, gateway_mac, item):
+ iprange = item.iprange
+ prefix_len = item.prefix_len
+ route_module = item.iface + 'Routes'
+ last_module = item.iface + 'FastPO'
+ gateway_mac_str = '{:X}'.format(gateway_mac)
+ print('Adding route entry {}/{} for {}'.format(iprange, prefix_len,
+ route_module))
+
+ print('Trying to retrieve neighbor entry {} from neighbor cache'.format(
+ item.neighbor_ip))
+ neighbor_exists = neighborcache.get(item.neighbor_ip)
+
+ # How many gates does this module have?
+ # If entry does not exist, then initialize it
+ if not modgatecnt.get(route_module):
+ modgatecnt[route_module] = 0
+
+ # Compute likely index
+ if neighbor_exists:
+ # No need to create a new Update module
+ gate_idx = neighbor_exists.gate_idx
+ else:
+ # Need to create a new Update module,
+ # so get gate_idx from gate count
+ gate_idx = modgatecnt[route_module]
+
+ # Pause bess first
+ bess.pause_all()
+ # Pass routing entry to bessd's route module
+ for _ in range(MAX_RETRIES):
+ try:
+ server.run_module_command(route_module, 'add',
+ 'IPLookupCommandAddArg', {
+ 'prefix': iprange,
+ 'prefix_len': int(prefix_len),
+ 'gate': gate_idx
+ })
+ except:
+ print('Error adding route entry {}/{} in {}. Retrying in {}sec...'.
+ format(iprange, prefix_len, route_module, SLEEP_S))
+ time.sleep(SLEEP_S)
+ else:
+ bess.resume_all()
+ break
+ else:
+ bess.resume_all()
+ print('BESS route entry ({}/{}) insertion failure in module {}'.format(
+ iprange, prefix_len, route_module))
+ return
+ #raise Exception('BESS route entry ({}/{}) insertion failure in module {}'.
+ # format(iprange, prefix_len, route_module))
+
+ if not neighbor_exists:
+ print('Neighbor does not exist')
+ # Create Update module
+ update_module = route_module + 'DstMAC' + gateway_mac_str
+
+ # Pause bess first
+ bess.pause_all()
+ for _ in range(MAX_RETRIES):
+ try:
+ server.create_module('Update', update_module, {
+ 'fields': [{
+ 'offset': 0,
+ 'size': 6,
+ 'value': gateway_mac
+ }]
+ })
+ except BESS.Error as e:
+ bess.resume_all()
+ if e.code == errno.EEXIST:
+ break
+ else:
+ return #raise
+ except Exception as e:
+ print(
+ 'Error creating update module {}: {}. Retrying in {} secs...'
+ .format(update_module, e, SLEEP_S))
+ time.sleep(SLEEP_S)
+ else:
+ bess.resume_all()
+ break
+ else:
+ bess.resume_all()
+ print('BESS module {} creation failure.'.format(update_module))
+ return #raise Exception('BESS module {} creation failure.'.
+ # format(update_module))
+
+ print('Update module created')
+
+ # Connect Update module to route module
+ link_modules(server, route_module, update_module, gate_idx, 0)
+
+ # Connect Update module to dpdk_out module
+ link_modules(server, update_module, last_module, 0, 0)
+
+ # Add a new neighbor in neighbor cache
+ neighborcache[item.neighbor_ip] = item
+
+ # Add a record of the affliated gate id
+ item.gate_idx = gate_idx
+
+ # Set the mac str
+ item.macstr = gateway_mac_str
+
+ # Increment global gate count number
+ modgatecnt[route_module] += 1
+
+ neighbor_exists = item
+
+ else:
+ print('Neighbor already exists')
+
+ # Finally increment route count
+ neighborcache[item.neighbor_ip].route_count += 1
+
+
+def del_route_entry(server, item):
+ iprange = item.iprange
+ prefix_len = item.prefix_len
+ route_module = item.iface + 'Routes'
+ last_module = item.iface + 'FastPO'
+
+ neighbor_exists = neighborcache.get(item.neighbor_ip)
+ if neighbor_exists:
+ # Pause bess first
+ bess.pause_all()
+ # Delete routing entry from bessd's route module
+ for i in range(MAX_RETRIES):
+ try:
+ server.run_module_command(route_module, 'delete',
+ 'IPLookupCommandDeleteArg', {
+ 'prefix': iprange,
+ 'prefix_len': int(prefix_len)
+ })
+ except:
+ print(
+ 'Error while deleting route entry for {}. Retrying in {} sec...'
+ .format(route_module, SLEEP_S))
+ time.sleep(SLEEP_S)
+ else:
+ bess.resume_all()
+ break
+ else:
+ bess.resume_all()
+ print('Route entry deletion failure.')
+ return
+ #raise Exception('Route entry deletion failure.')
+
+ print('Route entry {}/{} deleted from {}'.format(
+ iprange, prefix_len, route_module))
+
+ # Decrementing route count for the registered neighbor
+ neighbor_exists.route_count -= 1
+
+ # If route count is 0, then delete the whole module
+ if neighbor_exists.route_count == 0:
+ update_module = route_module + 'DstMAC' + neighbor_exists.macstr
+ # Pause bess first
+ bess.pause_all()
+ for i in range(MAX_RETRIES):
+ try:
+ server.destroy_module(update_module)
+ except:
+ print('Error destroying module {}. Retrying in {}sec...'.
+ format(update_module, SLEEP_S))
+ time.sleep(SLEEP_S)
+ else:
+ bess.resume_all()
+ break
+ else:
+ bess.resume_all()
+ print('Module {} deletion failure.'.format(update_module))
+ return
+ #raise Exception('Module {} deletion failure.'.
+ # format(update_module))
+
+ print('Module {} destroyed'.format(update_module))
+
+ # Delete entry from the neighbor cache
+ del neighborcache[item.neighbor_ip]
+ print('Deleting item from neighborcache')
+ del neighbor_exists
+ else:
+ print('Route count for {} decremented to {}'.format(
+ item.neighbor_ip, neighbor_exists.route_count))
+ neighborcache[item.neighbor_ip] = neighbor_exists
+ else:
+ print('Neighbor {} does not exist'.format(item.neighbor_ip))
+
+
+def probe_addr(item, src_mac):
+ # Store entry if entry does not exist in ARP cache
+ arpcache[item.neighbor_ip] = item
+ print('Adding entry {} in arp probe table'.format(item))
+
+ # Probe ARP request by sending ping
+ send_ping(item.neighbor_ip)
+
+ # Probe ARP request
+ ##send_arp(neighbor_ip, src_mac, item.iface)
+
+
+def parse_new_route(msg):
+ item = NeighborEntry()
+ # Fetch prefix_len
+ item.prefix_len = msg['dst_len']
+ # Default route
+ if item.prefix_len is 0:
+ item.iprange = '0.0.0.0'
+
+ for att in msg['attrs']:
+ if 'RTA_DST' in att:
+ # Fetch IP range
+ # ('RTA_DST', iprange)
+ item.iprange = att[1]
+ if 'RTA_GATEWAY' in att:
+ # Fetch gateway MAC address
+ # ('RTA_GATEWAY', neighbor_ip)
+ item.neighbor_ip = att[1]
+ _mac = fetch_mac(att[1])
+ if not _mac:
+ gateway_mac = 0
+ else:
+ gateway_mac = mac2hex(_mac)
+ if 'RTA_OIF' in att:
+ # Fetch interface name
+ # ('RTA_OIF', iface)
+ item.iface = ipdb.interfaces[int(att[1])].ifname
+
+ if not item.iface in args.i or not item.iprange or not item.neighbor_ip:
+ # Neighbor info is invalid
+ del item
+ return
+
+ # Fetch prefix_len
+ item.prefix_len = msg['dst_len']
+
+ # if mac is 0, send ARP request
+ if gateway_mac == 0:
+ print('Adding entry {} in arp probe table'.format(item.iface))
+ probe_addr(item, ipdb.interfaces[item.iface].address)
+
+ else: # if gateway_mac is set
+ print('Linking module {}Routes with {}FastPO (Dest MAC: {})'.format(
+ item.iface, item.iface, _mac))
+
+ link_route_module(bess, gateway_mac, item)
+
+
+def parse_new_neighbor(msg):
+ for att in msg['attrs']:
+ if 'NDA_DST' in att:
+ # ('NDA_DST', neighbor_ip)
+ neighbor_ip = att[1]
+ if 'NDA_LLADDR' in att:
+ # ('NDA_LLADDR', neighbor_mac)
+ gateway_mac = att[1]
+
+ item = arpcache.get(neighbor_ip)
+ if item:
+ print('Linking module {}Routes with {}FastPO (Dest MAC: {})'.format(
+ item.iface, item.iface, gateway_mac))
+
+ # Add route entry, and add item in the registered neighbor cache
+ link_route_module(bess, mac2hex(gateway_mac), item)
+
+ # Remove entry from unresolved arp cache
+ del arpcache[neighbor_ip]
+
+
+def parse_del_route(msg):
+ item = NeighborEntry()
+ for att in msg['attrs']:
+ if 'RTA_DST' in att:
+ # Fetch IP range
+ # ('RTA_DST', iprange)
+ item.iprange = att[1]
+ if 'RTA_GATEWAY' in att:
+ # Fetch gateway MAC address
+ # ('RTA_GATEWAY', neighbor_ip)
+ item.neighbor_ip = att[1]
+ if 'RTA_OIF' in att:
+ # Fetch interface name
+ # ('RTA_OIF', iface)
+ item.iface = ipdb.interfaces[int(att[1])].ifname
+
+ if not item.iface in args.i or not item.iprange or not item.neighbor_ip:
+ # Neighbor info is invalid
+ del item
+ return
+
+ # Fetch prefix_len
+ item.prefix_len = msg['dst_len']
+
+ del_route_entry(bess, item)
+
+ # Delete item
+ del item
+
+
+def netlink_event_listener(ipdb, netlink_message, action):
+
+ # If you get a netlink message, parse it
+ msg = netlink_message
+
+ if action == 'RTM_NEWROUTE':
+ parse_new_route(msg)
+
+ if action == 'RTM_NEWNEIGH':
+ parse_new_neighbor(msg)
+
+ if action == 'RTM_DELROUTE':
+ parse_del_route(msg)
+
+
+def bootstrap_routes():
+ routes = ipr.get_routes()
+ for i in routes:
+ if i['event'] == 'RTM_NEWROUTE':
+ parse_new_route(i)
+
+
+def connect_bessd():
+ print('Connecting to BESS daemon...'),
+ # Connect to BESS (assuming host=localhost, port=10514 (default))
+ for i in range(MAX_RETRIES):
+ try:
+ if not bess.is_connected():
+ bess.connect(grpc_url=args.ip + ':' + args.port)
+ except BESS.RPCError:
+ print(
+ 'Error connecting to BESS daemon. Retrying in {}sec...'.format(
+ SLEEP_S))
+ time.sleep(SLEEP_S)
+ else:
+ break
+ else:
+ raise Exception('BESS connection failure.')
+
+ print('Done.')
+
+
+def reconfigure(number, frame):
+ print('Received: {} Reloading routes'.format(number))
+ # clear arpcache
+ for ip in list(arpcache):
+ item = arpcache.get(ip)
+ del item
+ arpcache.clear()
+ for ip in list(neighborcache):
+ item = neighborcache.get(ip)
+ del item
+ neighborcache.clear()
+ for modname in list(modgatecnt):
+ item = modgatecnt.get(modname)
+ del item
+ modgatecnt.clear()
+ bootstrap_routes()
+ signal.pause()
+
+
+def cleanup(number, frame):
+ ipdb.unregister_callback(event_callback)
+ print('Received: {} Exiting'.format(number))
+ sys.exit()
+
+
+def main():
+ global arpcache, neighborcache, modgatecnt, ipdb, event_callback, bess, ipr
+ # for holding unresolved ARP queries
+ arpcache = {}
+ # for holding list of registered neighbors
+ neighborcache = {}
+ # for holding gate count per route module
+ modgatecnt = {}
+ # for interacting with kernel
+ ipdb = IPDB()
+ ipr = IPRoute()
+ # for bess client
+ bess = BESS()
+
+ # connect to bessd
+ connect_bessd()
+
+ # program current routes
+ #bootstrap_routes()
+
+ # listen for netlink events
+ print('Registering netlink event listener callback...'),
+ event_callback = ipdb.register_callback(netlink_event_listener)
+ print('Done.')
+
+ signal.signal(signal.SIGHUP, reconfigure)
+ signal.signal(signal.SIGINT, cleanup)
+ signal.signal(signal.SIGTERM, cleanup)
+ signal.pause()
+
+
+if __name__ == '__main__':
+ parser = argparse.ArgumentParser(
+ description='Basic IPv4 Routing Controller')
+ parser.add_argument('-i',
+ type=str,
+ nargs='+',
+ help='interface(s) to control')
+ parser.add_argument('--ip',
+ type=str,
+ default='localhost',
+ help='BESSD address')
+ parser.add_argument('--port', type=str, default='10514', help='BESSD port')
+
+ # for holding command-line arguments
+ global args
+ args = parser.parse_args()
+
+ if args.i:
+ main()
+ # if interface list is empty, print help menu and quit
+ else:
+ print(parser.print_help())