| |
| # Copyright 2017-present Open Networking Foundation |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| |
| # |
| # Copyright 2016-present Ciena Corporation |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| # |
| import json |
| import requests |
| import os,sys,time |
| from OltConfig import OltConfig |
| from CordTestUtils import get_mac, get_controller, log_test |
| from EapolAAA import get_radius_macs, get_radius_networks |
| |
| class OnosCtrl: |
| |
| auth = ('karaf', 'karaf') |
| controller = get_controller() |
| cfg_url = 'http://%s:8181/onos/v1/network/configuration/' %(controller) |
| maven_repo = 'http://central.maven.org/maven2/org/onosproject' |
| applications_url = 'http://%s:8181/onos/v1/applications' %(controller) |
| host_cfg_url = 'http://%s:8181/onos/v1/network/configuration/hosts/' %(controller) |
| |
| def __init__(self, app, controller = None): |
| self.app = app |
| if controller is not None: |
| self.controller = controller |
| self.app_url = 'http://%s:8181/onos/v1/applications/%s' %(self.controller, self.app) |
| self.cfg_url = 'http://%s:8181/onos/v1/network/configuration/' %(self.controller) |
| self.auth = ('karaf', 'karaf') |
| |
| @classmethod |
| def config(cls, config, controller=None): |
| if config is not None: |
| json_data = json.dumps(config) |
| if controller is None: |
| resp = requests.post(cls.cfg_url, auth = cls.auth, data = json_data) |
| else: |
| cfg_url = 'http://%s:8181/onos/v1/network/configuration/' %(controller) |
| resp = requests.post(cfg_url, auth = cls.auth, data = json_data) |
| return resp.ok, resp.status_code |
| return False, 400 |
| |
| @classmethod |
| def get_config(cls, controller=None): |
| if controller is None: |
| controller = cls.controller |
| cfg_url = 'http://%s:8181/onos/v1/network/configuration/' %(controller) |
| resp = requests.get(cfg_url, auth = cls.auth) |
| if resp.ok: |
| return resp.json() |
| return None |
| |
| @classmethod |
| def delete(cls, config, controller=None): |
| if config: |
| json_data = json.dumps(config) |
| if controller is None: |
| print('default Onos config url is %s'%cls.cfg_url) |
| resp = requests.delete(cls.cfg_url, auth = cls.auth, data = json_data) |
| else: |
| cfg_url = 'http://%s:8181/onos/v1/network/configuration/' %(controller) |
| resp = requests.delete(cfg_url, auth = cls.auth, data = json_data) |
| return resp.ok, resp.status_code |
| return False, 400 |
| |
| def activate(self): |
| resp = requests.post(self.app_url + '/active', auth = self.auth) |
| return resp.ok, resp.status_code |
| |
| def deactivate(self): |
| resp = requests.delete(self.app_url + '/active', auth = self.auth) |
| return resp.ok, resp.status_code |
| |
| @classmethod |
| def get_devices(cls, controller = None, mfr = None): |
| if controller is None: |
| controller = cls.controller |
| url = 'http://%s:8181/onos/v1/devices' %(controller) |
| result = requests.get(url, auth = cls.auth) |
| if result.ok: |
| devices = result.json()['devices'] |
| devices = filter(lambda d: d['available'], devices) |
| if mfr: |
| devices = filter(lambda d: d['mfr'].startswith(mfr), devices) |
| return devices |
| return None |
| |
| @classmethod |
| def get_links(cls, controller = None): |
| if controller is None: |
| controller = cls.controller |
| url = 'http://%s:8181/onos/v1/links' %(controller) |
| result = requests.get(url, auth = cls.auth) |
| if result.ok: |
| links = result.json()['links'] |
| return links |
| return None |
| |
| @classmethod |
| def get_device_id(cls, controller = None, mfr = None, olt_conf_file = ''): |
| '''If running under olt, we get the first switch connected to onos''' |
| olt = OltConfig(olt_conf_file = olt_conf_file) |
| did = 'of:' + get_mac() |
| if olt.on_olt(): |
| devices = cls.get_devices(controller = controller, mfr = mfr) |
| if devices: |
| dids = map(lambda d: d['id'], devices) |
| if len(dids) == 1: |
| did = dids[0] |
| else: |
| ###If we have more than 1, then check for env before using first one |
| did = os.getenv('OLT_DEVICE_ID', dids[0]) |
| |
| return did |
| |
| @classmethod |
| def get_device_ids(cls, controller = None, olt_conf_file = ''): |
| '''If running under olt, we get the first switch connected to onos''' |
| olt = OltConfig(olt_conf_file = olt_conf_file) |
| did = 'of:' + get_mac() |
| device_ids = [] |
| if olt.on_olt(): |
| devices = cls.get_devices(controller = controller) |
| if devices: |
| device_ids = map(lambda d: d['id'], devices) |
| else: |
| device_ids.append(did) |
| |
| return device_ids |
| |
| @classmethod |
| def get_flows(cls, device_id,controller=None): |
| if controller is None: |
| url = 'http://%s:8181/onos/v1/flows/' %(cls.controller) + device_id |
| else: |
| url = 'http://%s:8181/onos/v1/flows/' %(controller) + device_id |
| result = requests.get(url, auth = cls.auth) |
| if result.ok: |
| return result.json()['flows'] |
| return None |
| |
| @classmethod |
| def get_ports_device(cls, device_id, controller = None): |
| if controller is None: |
| url = 'http://{}:8181/onos/v1/devices/{}/ports'.format(cls.controller, device_id) |
| else: |
| url = 'http://{}:8181/onos/v1/devices/{}/ports'.format(controller, device_id) |
| |
| result = requests.get(url, auth = cls.auth) |
| if result.ok: |
| return result.json()['ports'] |
| return None |
| |
| @classmethod |
| def cord_olt_device_map(cls, olt_config, controller = None): |
| olt_device_list = [] |
| olt_port_map, _ = olt_config.olt_port_map() |
| switches = olt_port_map['switches'] |
| if len(switches) > 1: |
| device_ids = cls.get_device_ids(controller = controller) |
| else: |
| did = cls.get_device_id(controller = controller) |
| if did is None: |
| return olt_device_list |
| uplink_dict = {} |
| uplink_dict['did'] = did |
| uplink_dict['switch'] = switches[0] |
| uplink_dict['uplink'] = str(olt_config.olt_conf['uplink']) |
| uplink_dict['vlan'] = str(olt_config.olt_conf['vlan']) |
| olt_device_list.append(uplink_dict) |
| return olt_device_list |
| |
| for did in device_ids: |
| ports = cls.get_ports_device(did, controller = controller) |
| if ports: |
| matched = False |
| for port in ports: |
| for switch in switches: |
| if port['annotations']['portName'] == switch: |
| uplink_dict = {} |
| uplink = olt_port_map[switch]['uplink'] |
| uplink_dict['did'] = did |
| uplink_dict['switch'] = switch |
| uplink_dict['uplink'] = str(uplink) |
| uplink_dict['vlan'] = str(olt_config.olt_conf['vlan']) |
| olt_device_list.append(uplink_dict) |
| matched = True |
| break |
| if matched == True: |
| break |
| |
| return olt_device_list |
| |
| @classmethod |
| def cord_olt_config(cls, olt_config, controller=None): |
| '''Configures OLT data for existing devices/switches''' |
| did_dict = {} |
| config = { 'devices' : did_dict } |
| olt_device_list = cls.cord_olt_device_map(olt_config, controller = controller) |
| if not olt_device_list: |
| return |
| for olt_map in olt_device_list: |
| access_device_dict = {} |
| device_data = {'uplink': olt_map['uplink'], 'vlan': olt_map['vlan']} |
| access_device_dict['accessDevice'] = device_data |
| did_dict[olt_map['did']] = access_device_dict |
| |
| ##configure the device list with access information |
| return cls.config(config, controller=controller) |
| |
| @classmethod |
| def install_app(cls, app_file, onos_ip = None): |
| params = {'activate':'true'} |
| headers = {'content-type':'application/octet-stream'} |
| url = cls.applications_url if onos_ip is None else 'http://{0}:8181/onos/v1/applications'.format(onos_ip) |
| with open(app_file, 'rb') as payload: |
| result = requests.post(url, auth = cls.auth, |
| params = params, headers = headers, |
| data = payload) |
| print('result.ok, result.status_code are %s and %s'%(result.ok, result.status_code)) |
| return result.ok, result.status_code |
| |
| @classmethod |
| def install_app_from_url(cls, app_name, app_version, app_url = None, onos_ip = None): |
| params = {'activate':'true'} |
| headers = {'content-type':'application/json'} |
| if app_url is None: |
| app_oar_file = '{}-{}.oar'.format(app_name, app_version) |
| app_url = '{0}/{1}/{2}/{3}'.format(cls.maven_repo, app_name, app_version, app_oar_file) |
| params['url'] = app_url |
| url = cls.applications_url if onos_ip is None else 'http://{0}:8181/onos/v1/applications'.format(onos_ip) |
| result = requests.post(url, auth = cls.auth, |
| json = params, headers = headers) |
| return result.ok, result.status_code |
| |
| @classmethod |
| def uninstall_app(cls, app_name, onos_ip = None): |
| params = {'activate':'true'} |
| headers = {'content-type':'application/octet-stream'} |
| url = cls.applications_url if onos_ip is None else 'http://{0}:8181/onos/v1/applications'.format(onos_ip) |
| app_url = '{}/{}'.format(url, app_name) |
| resp = requests.delete(app_url, auth = cls.auth) |
| return resp.ok, resp.status_code |
| |
| @classmethod |
| def host_config(cls, config, onos_ip=None): |
| if config: |
| json_data = json.dumps(config) |
| url = cls.host_cfg_url if onos_ip is None else 'http://{}:8181/onos/v1/network/configuration/hosts/'.format(onos_ip) |
| resp = requests.post(url, auth = cls.auth, data = json_data) |
| return resp.ok, resp.status_code |
| return False, 400 |
| |
| @classmethod |
| def config_device_driver(cls, controller = None, dids = None, driver = 'pmc-olt'): |
| driver_apps = ('org.onosproject.drivers', 'org.onosproject.openflow-base',) |
| if dids is None: |
| dids = cls.get_device_ids(controller = controller) |
| device_map = {} |
| for did in dids: |
| device_map[did] = { 'basic' : { 'driver' : driver } } |
| network_cfg = { 'devices' : device_map } |
| cls.config(network_cfg) |
| for driver in driver_apps: |
| cls(driver).deactivate() |
| time.sleep(2) |
| for driver in driver_apps: |
| cls(driver).activate() |
| time.sleep(5) |
| |
| @classmethod |
| def device_id_to_mac(cls, device_id): |
| device_mac_raw = device_id[-12:] |
| hwaddrs = [] |
| for i in xrange(0, 12, 2): |
| hwaddrs.append(device_mac_raw[i:i+2]) |
| |
| device_mac = ':'.join(hwaddrs) |
| return device_mac |
| |
| @classmethod |
| def aaa_load_config(cls, controller = None, olt_conf_file = '', conn_type = 'socket'): |
| ovs_devices = cls.get_devices(controller = controller, mfr = 'Nicira') |
| if not ovs_devices: |
| log_test.info('No OVS devices found to configure AAA connect points') |
| return |
| olt = OltConfig(olt_conf_file = olt_conf_file) |
| port_map, _ = olt.olt_port_map() |
| app = 'org.opencord.aaa' |
| cfg = { 'apps' : { app : { 'AAA' : {} } } } |
| if conn_type == 'socket': |
| customizer = 'default' |
| else: |
| customizer = 'sample' |
| aaa_cfg = dict(radiusConnectionType = conn_type, |
| radiusSecret = 'radius_password', |
| radiusServerPort = '1812', |
| packetCustomizer = customizer, |
| vlanId = -1) |
| radius_networks = get_radius_networks(len(port_map['switch_radius_port_list'])) |
| index = 0 |
| for switch, ports in port_map['switch_radius_port_list']: |
| radius_macs = get_radius_macs(len(ports)) |
| prefix, _, _ = radius_networks[index] |
| index += 1 |
| aaa_cfg['nasIp'] = controller or cls.controller |
| aaa_cfg['nasMac'] = radius_macs[0] |
| aaa_cfg['radiusMac'] = radius_macs[0] |
| connect_points = [] |
| radius_port = port_map[ ports[0] ] |
| radius_ip = '{}.{}'.format(prefix, radius_port) |
| if conn_type == 'socket': |
| radius_ip = os.getenv('ONOS_AAA_IP') |
| aaa_cfg['radiusIp'] = radius_ip |
| for dev in ovs_devices: |
| device_id = dev['id'] |
| ports = OnosCtrl.get_ports_device(device_id, controller = controller) |
| radius_ports = filter(lambda p: p['isEnabled'] and 'annotations' in p and \ |
| p['annotations']['portName'].startswith('r'), |
| ports) |
| radius_port = radius_ports[0]['port'] |
| connect_point = '{}/{}'.format(device_id, radius_port) |
| connect_points.append(connect_point) |
| aaa_cfg['radiusServerConnectPoints'] = connect_points |
| break |
| |
| cfg['apps'][app]['AAA'] = aaa_cfg |
| cls.config(cfg, controller = controller) |
| |
| @classmethod |
| def get_ovs_switch_map(cls, controller = None, olt_conf_file = ''): |
| port_map = None |
| #build ovs switch map |
| if olt_conf_file: |
| olt = OltConfig(olt_conf_file = olt_conf_file) |
| port_map, _ = olt.olt_port_map() |
| |
| devices = cls.get_devices(controller = controller, mfr = 'Nicira') |
| switch_map = {} |
| for dev in devices: |
| device_id = dev['id'] |
| serial = dev['serial'] |
| ports = cls.get_ports_device(dev['id'], controller = controller) |
| ports = filter(lambda p: p['isEnabled'] and 'annotations' in p, ports) |
| #just create dummy ctag/uni port numbers |
| onu_ports = [1] * len(ports) |
| onu_names = map(lambda p: p['annotations']['portName'], ports) |
| onu_macs = map(lambda p: p['annotations']['portMac'], ports) |
| switch_map[device_id] = dict(uplink_vlan = 1, |
| serial = serial, |
| ports = onu_ports, |
| names = onu_names, |
| macs = onu_macs) |
| return switch_map |
| |
| @classmethod |
| def sadis_load_config(cls, controller = None, olt_switch_map = {}, olt_conf_file = ''): |
| sadis_app = 'org.opencord.sadis' |
| aaa_app = 'org.opencord.aaa' |
| sadis_cfg = { |
| 'apps' : { |
| sadis_app : { |
| 'sadis' : { |
| 'integration' : { |
| 'cache' : { |
| 'enabled' : False, |
| 'maxsize' : 50, |
| 'ttl' : 'PT0m', |
| }, |
| }, |
| 'entries' : [], |
| }, |
| }, |
| } |
| } |
| sadis_entries = sadis_cfg['apps'][sadis_app]['sadis']['entries'] |
| nasId = '1/1/2' |
| nasPortId = '1/1/2' |
| switch_map = olt_switch_map.copy() |
| ovs_switch_map = cls.get_ovs_switch_map(controller = controller, |
| olt_conf_file = olt_conf_file) |
| #log_test.info('OVS switch map: %s' %ovs_switch_map) |
| switch_map.update(ovs_switch_map) |
| for device, entries in switch_map.iteritems(): |
| uni_ports = entries['ports'] |
| uni_port_names = entries['names'] |
| uni_port_macs = entries['macs'] |
| s_tag = entries['uplink_vlan'] |
| serial = entries['serial'] |
| #add entries for uni ports and device |
| for p in xrange(len(uni_ports)): |
| sadis_entry = dict(nasId = nasId, nasPortId = nasPortId, slot = 1) |
| sadis_entry['id'] = uni_port_names[p] |
| sadis_entry['hardwareIdentifier'] = uni_port_macs[p] |
| sadis_entry['cTag'] = uni_ports[p] |
| sadis_entry['sTag'] = s_tag |
| sadis_entry['port'] = uni_ports[p] |
| sadis_entry['ipAddress'] = controller or cls.controller |
| sadis_entries.append(sadis_entry) |
| #add entry for the device itself |
| sadis_entry = dict(nasId = nasId, nasPortId = nasPortId, slot = 1) |
| sadis_entry['id'] = serial |
| sadis_entry['hardwareIdentifier'] = cls.device_id_to_mac(device) |
| sadis_entry['cTag'] = uni_ports[p] |
| sadis_entry['sTag'] = s_tag |
| sadis_entry['port'] = uni_ports[p] |
| sadis_entry['ipAddress'] = controller or cls.controller |
| sadis_entries.append(sadis_entry) |
| |
| #log_test.info('Sadis cfg: %s' %json.dumps(sadis_cfg, indent=4)) |
| cls.config(sadis_cfg, controller = controller) |
| |
| @classmethod |
| def config_olt_access(cls, uplink_vlan, controller = None, defaultVlan = '0', olt_conf_file = ''): |
| olt = OltConfig(olt_conf_file = olt_conf_file) |
| port_map, _ = olt.olt_port_map() |
| uplink = str(port_map['uplink']) |
| device_config = { 'devices' : {} } |
| ovs_devices = cls.get_devices(controller = controller, mfr = 'Nicira') |
| for dev in ovs_devices: |
| device_id = dev['id'] |
| device_config['devices'][device_id] = {} |
| device_config['devices'][device_id]['basic'] = dict(driver = 'default') |
| device_config['devices'][device_id]['accessDevice'] = dict(uplink = uplink, |
| vlan = uplink_vlan, |
| defaultVlan = defaultVlan) |
| |
| cls.config(device_config, controller = controller) |
| |
| @classmethod |
| def config_olt_component(cls, controller = None, enableDhcpIgmpOnProvisioning = True, defaultVlan = 0): |
| if controller is None: |
| controller = cls.controller |
| olt_property_url = 'configuration/org.opencord.olt.impl.Olt' |
| property_url = 'http://{}:8181/onos/v1/{}'.format(controller, olt_property_url) |
| cfg = dict(enableDhcpIgmpOnProvisioning = enableDhcpIgmpOnProvisioning, defaultVlan = defaultVlan) |
| resp = requests.post(property_url, auth = cls.auth, data = json.dumps(cfg)) |
| return resp.ok, resp.status_code |
| |
| @classmethod |
| def config_extraneous_flows(cls, controller = None, enable = True): |
| if controller is None: |
| controller = cls.controller |
| flow_property_url = 'configuration/org.onosproject.net.flow.impl.FlowRuleManager' |
| property_url = 'http://{}:8181/onos/v1/{}'.format(controller, flow_property_url) |
| cfg = dict(allowExtraneousRules = enable) |
| resp = requests.post(property_url, auth = cls.auth, data = json.dumps(cfg)) |
| return resp.ok, resp.status_code |