X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=ovim.py;h=a1eaffab87e20288e43182dbf12a2ed3c8ebe1ce;hb=refs%2Fchanges%2F17%2F1317%2F3;hp=e5cd40d0169bf68898cf2e43342ab56012256348;hpb=57f7bda62b86d19fbcd7b90271c7150ca8a8ab18;p=osm%2Fopenvim.git diff --git a/ovim.py b/ovim.py old mode 100644 new mode 100755 index e5cd40d..a1eaffa --- a/ovim.py +++ b/ovim.py @@ -1,3 +1,4 @@ +#!/usr/bin/env python # -*- coding: utf-8 -*- ## @@ -28,15 +29,21 @@ Two thread will be launched, with normal and administrative permissions. __author__ = "Alfonso Tierno, Leonardo Mirabal" __date__ = "$06-Feb-2017 12:07:15$" +__version__ = "0.5.10-r526" +version_date = "Apr 2017" +database_version = "0.17" #expected database schema version import threading import vim_db import logging -import threading import imp import host_thread as ht import dhcp_thread as dt import openflow_thread as oft +from netaddr import IPNetwork +from jsonschema import validate as js_v, exceptions as js_e +import openflow_conn +import argparse HTTP_Bad_Request = 400 HTTP_Unauthorized = 401 @@ -84,15 +91,21 @@ class ovimException(Exception): class ovim(): running_info = {} #TODO OVIM move the info of running threads from config_dic to this static variable + of_module = {} + def __init__(self, configuration): self.config = configuration - self.logger = logging.getLogger(configuration["logger_name"]) + self.logger_name = configuration.get("logger_name", "openvim") + self.logger = logging.getLogger(self.logger_name) self.db = None - self.db = self._create_database_connection() + self.db = self._create_database_connection() + self.db_lock = None + self.db_of = None + self.of_test_mode = False def _create_database_connection(self): db = vim_db.vim_db((self.config["network_vlan_range_start"], self.config["network_vlan_range_end"]), - self.config['log_level_db']); + self.logger_name + ".db", self.config.get('log_level_db')) if db.connect(self.config['db_host'], self.config['db_user'], self.config['db_passwd'], self.config['db_name']) == -1: # self.logger.error("Cannot connect to database %s at %s@%s", self.config['db_name'], self.config['db_user'], @@ -102,29 +115,84 @@ class ovim(): self.config['db_host']) ) return db + @staticmethod + def get_version(): + return __version__ + + @staticmethod + def get_version_date(): + return version_date + + @staticmethod + def get_database_version(): + return database_version + + @staticmethod + def _check_dhcp_data_integrity(network): + """ + Check if all dhcp parameter for anet are valid, if not will be calculated from cidr value + :param network: list with user nets paramters + :return: + """ + if "cidr" in network: + cidr = network["cidr"] + ip_tools = IPNetwork(cidr) + cidr_len = ip_tools.prefixlen + if cidr_len > 29: + return False + + ips = IPNetwork(cidr) + if "dhcp_first_ip" not in network: + network["dhcp_first_ip"] = str(ips[2]) + if "dhcp_last_ip" not in network: + network["dhcp_last_ip"] = str(ips[-2]) + if "gateway_ip" not in network: + network["gateway_ip"] = str(ips[1]) + + return True + else: + return False + + @staticmethod + def _check_valid_uuid(uuid): + id_schema = {"type": "string", "pattern": "^[a-fA-F0-9]{8}(-[a-fA-F0-9]{4}){3}-[a-fA-F0-9]{12}$"} + try: + js_v(uuid, id_schema) + return True + except js_e.ValidationError: + return False def start_service(self): - #if self.running_info: + """ + Start ovim services + :return: + """ + global database_version + # if self.running_info: # return #TODO service can be checked and rebuild broken threads r = self.db.get_db_version() - if r[0]<0: + if r[0] < 0: raise ovimException("DATABASE is not a VIM one or it is a '0.0' version. Try to upgrade to version '{}' with "\ - "'./database_utils/migrate_vim_db.sh'".format(self.config["database_version"]) ) - elif r[1]!=self.config["database_version"]: + "'./database_utils/migrate_vim_db.sh'".format(database_version) ) + elif r[1] != database_version: raise ovimException("DATABASE wrong version '{}'. Try to upgrade/downgrade to version '{}' with "\ - "'./database_utils/migrate_vim_db.sh'".format(r[1], self.config["database_version"]) ) - + "'./database_utils/migrate_vim_db.sh'".format(r[1], database_version) ) + self.logger.critical("Starting ovim server version: '{} {}' database version '{}'".format( + self.get_version(), self.get_version_date(), self.get_database_version())) # create database connection for openflow threads - db_of = self._create_database_connection() - self.config["db"] = db_of - db_lock = threading.Lock() - self.config["db_lock"] = db_lock + self.db_of = self._create_database_connection() + self.config["db"] = self.db_of + self.db_lock = threading.Lock() + self.config["db_lock"] = self.db_lock + + self.of_test_mode = False if self.config['mode'] == 'normal' or self.config['mode'] == "OF only" else True + # precreate interfaces; [bridge:, VLAN used at Host, uuid of network camping in this bridge, + # speed in Gbit/s - # precreate interfaces; [bridge:, VLAN used at Host, uuid of network camping in this bridge, speed in Gbit/s self.config['dhcp_nets'] = [] self.config['bridge_nets'] = [] for bridge, vlan_speed in self.config["bridge_ifaces"].items(): - # skip 'development_bridge' + # skip 'development_bridge' if self.config['mode'] == 'development' and self.config['development_bridge'] == bridge: continue self.config['bridge_nets'].append([bridge, vlan_speed[0], vlan_speed[1], None]) @@ -132,7 +200,7 @@ class ovim(): # check if this bridge is already used (present at database) for a network) used_bridge_nets = [] for brnet in self.config['bridge_nets']: - r, nets = db_of.get_table(SELECT=('uuid',), FROM='nets', WHERE={'provider': "bridge:" + brnet[0]}) + r, nets = self.db.get_table(SELECT=('uuid',), FROM='nets', WHERE={'provider': "bridge:" + brnet[0]}) if r > 0: brnet[3] = nets[0]['uuid'] used_bridge_nets.append(brnet[0]) @@ -144,73 +212,22 @@ class ovim(): # get nets used by dhcp if self.config.get("dhcp_server"): for net in self.config["dhcp_server"].get("nets", ()): - r, nets = db_of.get_table(SELECT=('uuid',), FROM='nets', WHERE={'name': net}) + r, nets = self.db.get_table(SELECT=('uuid',), FROM='nets', WHERE={'name': net}) if r > 0: self.config['dhcp_nets'].append(nets[0]['uuid']) - # get host list from data base before starting threads - r, hosts = db_of.get_table(SELECT=('name', 'ip_name', 'user', 'uuid'), FROM='hosts', WHERE={'status': 'ok'}) - if r < 0: - raise ovimException("Cannot get hosts from database {}".format(hosts)) - # create connector to the openflow controller - of_test_mode = False if self.config['mode'] == 'normal' or self.config['mode'] == "OF only" else True + # OFC default + self._start_ofc_default_task() - if of_test_mode: - OF_conn = oft.of_test_connector({"of_debug": self.config['log_level_of']}) - else: - # load other parameters starting by of_ from config dict in a temporal dict - temp_dict = {"of_ip": self.config['of_controller_ip'], - "of_port": self.config['of_controller_port'], - "of_dpid": self.config['of_controller_dpid'], - "of_debug": self.config['log_level_of'] - } - for k, v in self.config.iteritems(): - if type(k) is str and k[0:3] == "of_" and k[0:13] != "of_controller": - temp_dict[k] = v - if self.config['of_controller'] == 'opendaylight': - module = "ODL" - elif "of_controller_module" in self.config: - module = self.config["of_controller_module"] - else: - module = self.config['of_controller'] - module_info = None - try: - module_info = imp.find_module(module) - - OF_conn = imp.load_module("OF_conn", *module_info) - try: - OF_conn = OF_conn.OF_conn(temp_dict) - except Exception as e: - self.logger.error("Cannot open the Openflow controller '%s': %s", type(e).__name__, str(e)) - if module_info and module_info[0]: - file.close(module_info[0]) - exit(-1) - except (IOError, ImportError) as e: - if module_info and module_info[0]: - file.close(module_info[0]) - self.logger.error( - "Cannot open openflow controller module '%s'; %s: %s; revise 'of_controller' field of configuration file.", - module, type(e).__name__, str(e)) - raise ovimException("Cannot open openflow controller module '{}'; {}: {}; revise 'of_controller' field of configuration file.".fromat( - module, type(e).__name__, str(e))) - - - # create openflow thread - thread = oft.openflow_thread(OF_conn, of_test=of_test_mode, db=db_of, db_lock=db_lock, - pmp_with_same_vlan=self.config['of_controller_nets_with_same_vlan'], - debug=self.config['log_level_of']) - r, c = thread.OF_connector.obtain_port_correspondence() - if r < 0: - raise ovimException("Cannot get openflow information %s", c) - thread.start() - self.config['of_thread'] = thread + # OFC per tenant in DB + self._start_of_db_tasks() # create dhcp_server thread host_test_mode = True if self.config['mode'] == 'test' or self.config['mode'] == "OF only" else False dhcp_params = self.config.get("dhcp_server") if dhcp_params: thread = dt.dhcp_thread(dhcp_params=dhcp_params, test=host_test_mode, dhcp_nets=self.config["dhcp_nets"], - db=db_of, db_lock=db_lock, debug=self.config['log_level_of']) + db=self.db_of, db_lock=self.db_lock, debug=self.config['log_level_of']) thread.start() self.config['dhcp_thread'] = thread @@ -218,20 +235,191 @@ class ovim(): host_test_mode = True if self.config['mode'] == 'test' or self.config['mode'] == "OF only" else False host_develop_mode = True if self.config['mode'] == 'development' else False host_develop_bridge_iface = self.config.get('development_bridge', None) + + # get host list from data base before starting threads + r, hosts = self.db.get_table(SELECT=('name', 'ip_name', 'user', 'uuid'), FROM='hosts', WHERE={'status': 'ok'}) + if r < 0: + raise ovimException("Cannot get hosts from database {}".format(hosts)) + self.config['host_threads'] = {} for host in hosts: host['image_path'] = '/opt/VNF/images/openvim' - thread = ht.host_thread(name=host['name'], user=host['user'], host=host['ip_name'], db=db_of, db_lock=db_lock, - test=host_test_mode, image_path=self.config['image_path'], version=self.config['version'], - host_id=host['uuid'], develop_mode=host_develop_mode, + thread = ht.host_thread(name=host['name'], user=host['user'], host=host['ip_name'], db=self.db_of, + db_lock=self.db_lock, test=host_test_mode, image_path=self.config['image_path'], + version=self.config['version'], host_id=host['uuid'], develop_mode=host_develop_mode, develop_bridge_iface=host_develop_bridge_iface) thread.start() self.config['host_threads'][host['uuid']] = thread + # create ovs dhcp thread + result, content = self.db.get_table(FROM='nets') + if result < 0: + self.logger.error("http_get_ports Error %d %s", result, content) + raise ovimException(str(content), -result) + + for net in content: + net_type = net['type'] + if (net_type == 'bridge_data' or net_type == 'bridge_man') \ + and net["provider"][:4] == 'OVS:' and net["enable_dhcp"] == "true": + self.launch_dhcp_server(net['vlan'], + net['dhcp_first_ip'], + net['dhcp_last_ip'], + net['cidr'], + net['gateway_ip']) + + def _start_of_db_tasks(self): + """ + Start ofc task for existing ofcs in database + :param db_of: + :param db_lock: + :return: + """ + ofcs = self.get_of_controllers() + + for ofc in ofcs: + of_conn = self._load_of_module(ofc) + # create ofc thread per of controller + self._create_ofc_task(ofc['uuid'], ofc['dpid'], of_conn) + + def _create_ofc_task(self, ofc_uuid, dpid, of_conn): + """ + Create an ofc thread for handle each sdn controllers + :param ofc_uuid: sdn controller uuid + :param dpid: sdn controller dpid + :param of_conn: OF_conn module + :return: + """ + if 'ofcs_thread' not in self.config and 'ofcs_thread_dpid' not in self.config: + ofcs_threads = {} + ofcs_thread_dpid = [] + else: + ofcs_threads = self.config['ofcs_thread'] + ofcs_thread_dpid = self.config['ofcs_thread_dpid'] + + if ofc_uuid not in ofcs_threads: + ofc_thread = self._create_ofc_thread(of_conn, ofc_uuid) + if ofc_uuid == "Default": + self.config['of_thread'] = ofc_thread + + ofcs_threads[ofc_uuid] = ofc_thread + self.config['ofcs_thread'] = ofcs_threads + + ofcs_thread_dpid.append({dpid: ofc_thread}) + self.config['ofcs_thread_dpid'] = ofcs_thread_dpid + + def _start_ofc_default_task(self): + """ + Create default ofc thread + """ + if 'of_controller' not in self.config \ + and 'of_controller_ip' not in self.config \ + and 'of_controller_port' not in self.config \ + and 'of_controller_dpid' not in self.config: + return + + # OF THREAD + db_config = {} + db_config['ip'] = self.config.get('of_controller_ip') + db_config['port'] = self.config.get('of_controller_port') + db_config['dpid'] = self.config.get('of_controller_dpid') + db_config['type'] = self.config.get('of_controller') + db_config['user'] = self.config.get('of_user') + db_config['password'] = self.config.get('of_password') + + # create connector to the openflow controller + # load other parameters starting by of_ from config dict in a temporal dict + + of_conn = self._load_of_module(db_config) + # create openflow thread + self._create_ofc_task("Default", db_config['dpid'], of_conn) + + def _load_of_module(self, db_config): + """ + import python module for each SDN controller supported + :param db_config: SDN dn information + :return: Module + """ + if not db_config: + raise ovimException("No module found it", HTTP_Internal_Server_Error) + + module_info = None + + try: + if self.of_test_mode: + return openflow_conn.OfTestConnector({"name": db_config['type'], + "dpid": db_config['dpid'], + "of_debug": self.config['log_level_of']}) + temp_dict = {} + + if db_config: + temp_dict['of_ip'] = db_config['ip'] + temp_dict['of_port'] = db_config['port'] + temp_dict['of_dpid'] = db_config['dpid'] + temp_dict['of_controller'] = db_config['type'] + temp_dict['of_user'] = db_config.get('user') + temp_dict['of_password'] = db_config.get('password') + + temp_dict['of_debug'] = self.config['log_level_of'] + + if temp_dict['of_controller'] == 'opendaylight': + module = "ODL" + else: + module = temp_dict['of_controller'] + + if module not in ovim.of_module: + module_info = imp.find_module(module) + of_conn_module = imp.load_module("OF_conn", *module_info) + ovim.of_module[module] = of_conn_module + else: + of_conn_module = ovim.of_module[module] + + try: + return of_conn_module.OF_conn(temp_dict) + except Exception as e: + self.logger.error("Cannot open the Openflow controller '%s': %s", type(e).__name__, str(e)) + if module_info and module_info[0]: + file.close(module_info[0]) + raise ovimException("Cannot open the Openflow controller '{}': '{}'".format(type(e).__name__, str(e)), + HTTP_Internal_Server_Error) + except (IOError, ImportError) as e: + if module_info and module_info[0]: + file.close(module_info[0]) + self.logger.error("Cannot open openflow controller module '%s'; %s: %s; revise 'of_controller' " + "field of configuration file.", module, type(e).__name__, str(e)) + raise ovimException("Cannot open openflow controller module '{}'; {}: {}; revise 'of_controller' " + "field of configuration file.".format(module, type(e).__name__, str(e)), + HTTP_Internal_Server_Error) + + def _create_ofc_thread(self, of_conn, ofc_uuid="Default"): + """ + Create and launch a of thread + :return: thread obj + """ + # create openflow thread + + #if 'of_controller_nets_with_same_vlan' in self.config: + # ofc_net_same_vlan = self.config['of_controller_nets_with_same_vlan'] + #else: + # ofc_net_same_vlan = False + ofc_net_same_vlan = False + + thread = oft.openflow_thread(ofc_uuid, of_conn, of_test=self.of_test_mode, db=self.db_of, db_lock=self.db_lock, + pmp_with_same_vlan=ofc_net_same_vlan, debug=self.config['log_level_of']) + #r, c = thread.OF_connector.obtain_port_correspondence() + #if r < 0: + # raise ovimException("Cannot get openflow information %s", c) + thread.start() + return thread + def stop_service(self): threads = self.config.get('host_threads', {}) if 'of_thread' in self.config: threads['of'] = (self.config['of_thread']) + if 'ofcs_thread' in self.config: + ofcs_thread = self.config['ofcs_thread'] + for ofc in ofcs_thread: + threads[ofc] = ofcs_thread[ofc] + if 'dhcp_thread' in self.config: threads['dhcp'] = (self.config['dhcp_thread']) @@ -239,10 +427,404 @@ class ovim(): thread.insert_task("exit") for thread in threads.values(): thread.join() - # http_thread.join() - # if http_thread_admin is not None: - # http_thread_admin.join() + def get_networks(self, columns=None, db_filter={}, limit=None): + """ + Retreive networks available + :param columns: List with select query parameters + :param db_filter: List with where query parameters + :param limit: Query limit result + :return: + """ + result, content = self.db.get_table(SELECT=columns, FROM='nets', WHERE=db_filter, LIMIT=limit) + + if result < 0: + raise ovimException(str(content), -result) + + convert_boolean(content, ('shared', 'admin_state_up', 'enable_dhcp')) + + return content + + def show_network(self, network_id, db_filter={}): + """ + Get network from DB by id + :param network_id: net Id + :param db_filter: List with where query parameters + :return: + """ + # obtain data + if not network_id: + raise ovimException("Not network id was not found") + db_filter['uuid'] = network_id + + result, content = self.db.get_table(FROM='nets', WHERE=db_filter, LIMIT=100) + + if result < 0: + raise ovimException(str(content), -result) + elif result == 0: + raise ovimException("show_network network '%s' not found" % network_id, -result) + else: + convert_boolean(content, ('shared', 'admin_state_up', 'enable_dhcp')) + # get ports from DB + result, ports = self.db.get_table(FROM='ports', SELECT=('uuid as port_id',), + WHERE={'net_id': network_id}, LIMIT=100) + if len(ports) > 0: + content[0]['ports'] = ports + + convert_boolean(content, ('shared', 'admin_state_up', 'enable_dhcp')) + return content[0] + + def new_network(self, network): + """ + Create a net in DB + :return: + """ + tenant_id = network.get('tenant_id') + + if tenant_id: + result, _ = self.db.get_table(FROM='tenants', SELECT=('uuid',), WHERE={'uuid': tenant_id, "enabled": True}) + if result <= 0: + raise ovimException("set_network error, no tenant founded", -result) + + bridge_net = None + # check valid params + net_provider = network.get('provider') + net_type = network.get('type') + net_vlan = network.get("vlan") + net_bind_net = network.get("bind_net") + net_bind_type = network.get("bind_type") + name = network["name"] + + # check if network name ends with : and network exist in order to make and automated bindning + vlan_index = name.rfind(":") + if not net_bind_net and not net_bind_type and vlan_index > 1: + try: + vlan_tag = int(name[vlan_index + 1:]) + if not vlan_tag and vlan_tag < 4096: + net_bind_net = name[:vlan_index] + net_bind_type = "vlan:" + name[vlan_index + 1:] + except: + pass + + if net_bind_net: + # look for a valid net + if self._check_valid_uuid(net_bind_net): + net_bind_key = "uuid" + else: + net_bind_key = "name" + result, content = self.db.get_table(FROM='nets', WHERE={net_bind_key: net_bind_net}) + if result < 0: + raise ovimException(' getting nets from db ' + content, HTTP_Internal_Server_Error) + elif result == 0: + raise ovimException(" bind_net %s '%s'not found" % (net_bind_key, net_bind_net), HTTP_Bad_Request) + elif result > 1: + raise ovimException(" more than one bind_net %s '%s' found, use uuid" % (net_bind_key, net_bind_net), HTTP_Bad_Request) + network["bind_net"] = content[0]["uuid"] + + if net_bind_type: + if net_bind_type[0:5] != "vlan:": + raise ovimException("bad format for 'bind_type', must be 'vlan:'", HTTP_Bad_Request) + if int(net_bind_type[5:]) > 4095 or int(net_bind_type[5:]) <= 0: + raise ovimException("bad format for 'bind_type', must be 'vlan:' with a tag between 1 and 4095", + HTTP_Bad_Request) + network["bind_type"] = net_bind_type + + if net_provider: + if net_provider[:9] == "openflow:": + if net_type: + if net_type != "ptp" and net_type != "data": + raise ovimException(" only 'ptp' or 'data' net types can be bound to 'openflow'", + HTTP_Bad_Request) + else: + net_type = 'data' + else: + if net_type: + if net_type != "bridge_man" and net_type != "bridge_data": + raise ovimException("Only 'bridge_man' or 'bridge_data' net types can be bound " + "to 'bridge', 'macvtap' or 'default", HTTP_Bad_Request) + else: + net_type = 'bridge_man' + + if not net_type: + net_type = 'bridge_man' + + if net_provider: + if net_provider[:7] == 'bridge:': + # check it is one of the pre-provisioned bridges + bridge_net_name = net_provider[7:] + for brnet in self.config['bridge_nets']: + if brnet[0] == bridge_net_name: # free + if not brnet[3]: + raise ovimException("invalid 'provider:physical', " + "bridge '%s' is already used" % bridge_net_name, HTTP_Conflict) + bridge_net = brnet + net_vlan = brnet[1] + break + # if bridge_net==None: + # bottle.abort(HTTP_Bad_Request, "invalid 'provider:physical', bridge '%s' is not one of the + # provisioned 'bridge_ifaces' in the configuration file" % bridge_net_name) + # return + + elif self.config['network_type'] == 'bridge' and (net_type == 'bridge_data' or net_type == 'bridge_man'): + # look for a free precreated nets + for brnet in self.config['bridge_nets']: + if not brnet[3]: # free + if not bridge_net: + if net_type == 'bridge_man': # look for the smaller speed + if brnet[2] < bridge_net[2]: + bridge_net = brnet + else: # look for the larger speed + if brnet[2] > bridge_net[2]: + bridge_net = brnet + else: + bridge_net = brnet + net_vlan = brnet[1] + if not bridge_net: + raise ovimException("Max limits of bridge networks reached. Future versions of VIM " + "will overcome this limit", HTTP_Bad_Request) + else: + self.logger.debug("using net " + bridge_net) + net_provider = "bridge:" + bridge_net[0] + net_vlan = bridge_net[1] + elif net_type == 'bridge_data' or net_type == 'bridge_man' and self.config['network_type'] == 'ovs': + net_provider = 'OVS' + if not net_vlan and (net_type == "data" or net_type == "ptp" or net_provider == "OVS"): + net_vlan = self.db.get_free_net_vlan() + if net_vlan < 0: + raise ovimException("Error getting an available vlan", HTTP_Internal_Server_Error) + if net_provider == 'OVS': + net_provider = 'OVS' + ":" + str(net_vlan) + + network['provider'] = net_provider + network['type'] = net_type + network['vlan'] = net_vlan + dhcp_integrity = True + if 'enable_dhcp' in network and network['enable_dhcp']: + dhcp_integrity = self._check_dhcp_data_integrity(network) + + result, content = self.db.new_row('nets', network, True, True) + + if result >= 0 and dhcp_integrity: + if bridge_net: + bridge_net[3] = content + if self.config.get("dhcp_server") and self.config['network_type'] == 'bridge': + if network["name"] in self.config["dhcp_server"].get("nets", ()): + self.config["dhcp_nets"].append(content) + self.logger.debug("dhcp_server: add new net", content) + elif not bridge_net and bridge_net[0] in self.config["dhcp_server"].get("bridge_ifaces", ()): + self.config["dhcp_nets"].append(content) + self.logger.debug("dhcp_server: add new net", content, content) + return content + else: + raise ovimException("Error posting network", HTTP_Internal_Server_Error) +# TODO kei change update->edit + + def edit_network(self, network_id, network): + """ + Update entwork data byt id + :return: + """ + # Look for the previous data + where_ = {'uuid': network_id} + result, network_old = self.db.get_table(FROM='nets', WHERE=where_) + if result < 0: + raise ovimException("Error updating network %s" % network_old, HTTP_Internal_Server_Error) + elif result == 0: + raise ovimException('network %s not found' % network_id, HTTP_Not_Found) + # get ports + nbports, content = self.db.get_table(FROM='ports', SELECT=('uuid as port_id',), + WHERE={'net_id': network_id}, LIMIT=100) + if result < 0: + raise ovimException("http_put_network_id error %d %s" % (result, network_old), HTTP_Internal_Server_Error) + if nbports > 0: + if 'type' in network and network['type'] != network_old[0]['type']: + raise ovimException("Can not change type of network while having ports attached", + HTTP_Method_Not_Allowed) + if 'vlan' in network and network['vlan'] != network_old[0]['vlan']: + raise ovimException("Can not change vlan of network while having ports attached", + HTTP_Method_Not_Allowed) + + # check valid params + net_provider = network.get('provider', network_old[0]['provider']) + net_type = network.get('type', network_old[0]['type']) + net_bind_net = network.get("bind_net") + net_bind_type = network.get("bind_type") + if net_bind_net: + # look for a valid net + if self._check_valid_uuid(net_bind_net): + net_bind_key = "uuid" + else: + net_bind_key = "name" + result, content = self.db.get_table(FROM='nets', WHERE={net_bind_key: net_bind_net}) + if result < 0: + raise ovimException('Getting nets from db ' + content, HTTP_Internal_Server_Error) + elif result == 0: + raise ovimException("bind_net %s '%s'not found" % (net_bind_key, net_bind_net), HTTP_Bad_Request) + elif result > 1: + raise ovimException("More than one bind_net %s '%s' found, use uuid" % (net_bind_key, net_bind_net), + HTTP_Bad_Request) + network["bind_net"] = content[0]["uuid"] + if net_bind_type: + if net_bind_type[0:5] != "vlan:": + raise ovimException("Bad format for 'bind_type', must be 'vlan:'", HTTP_Bad_Request) + if int(net_bind_type[5:]) > 4095 or int(net_bind_type[5:]) <= 0: + raise ovimException("bad format for 'bind_type', must be 'vlan:' with a tag between 1 and 4095", + HTTP_Bad_Request) + if net_provider: + if net_provider[:9] == "openflow:": + if net_type != "ptp" and net_type != "data": + raise ovimException("Only 'ptp' or 'data' net types can be bound to 'openflow'", HTTP_Bad_Request) + else: + if net_type != "bridge_man" and net_type != "bridge_data": + raise ovimException("Only 'bridge_man' or 'bridge_data' net types can be bound to " + "'bridge', 'macvtap' or 'default", HTTP_Bad_Request) + + # insert in data base + result, content = self.db.update_rows('nets', network, WHERE={'uuid': network_id}, log=True) + if result >= 0: + # if result > 0 and nbports>0 and 'admin_state_up' in network + # and network['admin_state_up'] != network_old[0]['admin_state_up']: + if result > 0: + + try: + if nbports: + self.net_update_ofc_thread(network_id) + except ovimException as e: + raise ovimException("Error while launching openflow rules in network '{}' {}" + .format(network_id, str(e)), HTTP_Internal_Server_Error) + except Exception as e: + raise ovimException("Error while launching openflow rules in network '{}' {}" + .format(network_id, str(e)), HTTP_Internal_Server_Error) + + if self.config.get("dhcp_server"): + if network_id in self.config["dhcp_nets"]: + self.config["dhcp_nets"].remove(network_id) + if network.get("name", network_old[0]["name"]) in self.config["dhcp_server"].get("nets", ()): + self.config["dhcp_nets"].append(network_id) + else: + net_bind = network.get("bind_type", network_old[0]["bind_type"]) + if net_bind and net_bind and net_bind[:7] == "bridge:" and net_bind[7:] in self.config["dhcp_server"].get( + "bridge_ifaces", ()): + self.config["dhcp_nets"].append(network_id) + return network_id + else: + raise ovimException(content, -result) + + def delete_network(self, network_id): + """ + Delete network by network id + :param network_id: network id + :return: + """ + + # delete from the data base + result, content = self.db.delete_row('nets', network_id) + + if result == 0: + raise ovimException("Network %s not found " % network_id, HTTP_Not_Found) + elif result > 0: + for brnet in self.config['bridge_nets']: + if brnet[3] == network_id: + brnet[3] = None + break + if self.config.get("dhcp_server") and network_id in self.config["dhcp_nets"]: + self.config["dhcp_nets"].remove(network_id) + return content + else: + raise ovimException("Error deleting network %s" % network_id, HTTP_Internal_Server_Error) + + def get_openflow_rules(self, network_id=None): + """ + Get openflow id from DB + :param network_id: Network id, if none all networks will be retrieved + :return: Return a list with Openflow rules per net + """ + # ignore input data + if not network_id: + where_ = {} + else: + where_ = {"net_id": network_id} + result, content = self.db.get_table( + SELECT=("name", "net_id", "ofc_id", "priority", "vlan_id", "ingress_port", "src_mac", "dst_mac", "actions"), + WHERE=where_, FROM='of_flows') + + if result < 0: + raise ovimException(str(content), -result) + return content + + def edit_openflow_rules(self, network_id=None): + + """ + To make actions over the net. The action is to reinstall the openflow rules + network_id can be 'all' + :param network_id: Network id, if none all networks will be retrieved + :return : Number of nets updated + """ + + # ignore input data + if not network_id: + where_ = {} + else: + where_ = {"uuid": network_id} + result, content = self.db.get_table(SELECT=("uuid", "type"), WHERE=where_, FROM='nets') + + if result < 0: + raise ovimException(str(content), -result) + + for net in content: + if net["type"] != "ptp" and net["type"] != "data": + result -= 1 + continue + + try: + self.net_update_ofc_thread(net['uuid']) + except ovimException as e: + raise ovimException("Error updating network'{}' {}".format(net['uuid'], str(e)), + HTTP_Internal_Server_Error) + except Exception as e: + raise ovimException("Error updating network '{}' {}".format(net['uuid'], str(e)), + HTTP_Internal_Server_Error) + + return result + + def delete_openflow_rules(self, ofc_id=None): + """ + To make actions over the net. The action is to delete ALL openflow rules + :return: return operation result + """ + + if not ofc_id: + if 'Default' in self.config['ofcs_thread']: + r, c = self.config['ofcs_thread']['Default'].insert_task("clear-all") + else: + raise ovimException("Default Openflow controller not not running", HTTP_Not_Found) + + elif ofc_id in self.config['ofcs_thread']: + r, c = self.config['ofcs_thread'][ofc_id].insert_task("clear-all") + + # ignore input data + if r < 0: + raise ovimException(str(c), -r) + else: + raise ovimException("Openflow controller not found with ofc_id={}".format(ofc_id), HTTP_Not_Found) + return r + + def get_openflow_ports(self, ofc_id=None): + """ + Obtain switch ports names of openflow controller + :return: Return flow ports in DB + """ + if not ofc_id: + if 'Default' in self.config['ofcs_thread']: + conn = self.config['ofcs_thread']['Default'].OF_connector + else: + raise ovimException("Default Openflow controller not not running", HTTP_Not_Found) + + if ofc_id in self.config['ofcs_thread']: + conn = self.config['ofcs_thread'][ofc_id].OF_connector + else: + raise ovimException("Openflow controller not found with ofc_id={}".format(ofc_id), HTTP_Not_Found) + return conn.pp2ofi def get_ports(self, columns=None, filter={}, limit=None): # result, content = my.db.get_ports(where_) @@ -254,7 +836,6 @@ class ovim(): convert_boolean(content, ('admin_state_up',)) return content - def new_port(self, port_data): port_data['type'] = 'external' if port_data.get('net_id'): @@ -266,14 +847,132 @@ class ovim(): result, uuid = self.db.new_row('ports', port_data, True, True) if result > 0: if 'net_id' in port_data: - r, c = self.config['of_thread'].insert_task("update-net", port_data['net_id']) - if r < 0: - self.logger.error("Cannot insert a task for updating network '$s' %s", port_data['net_id'], c) - #TODO put network in error status + try: + self.net_update_ofc_thread(port_data['net_id']) + except ovimException as e: + raise ovimException("Cannot insert a task for updating network '{}' {}" + .format(port_data['net_id'], str(e)), HTTP_Internal_Server_Error) + except Exception as e: + raise ovimException("Cannot insert a task for updating network '{}' {}" + .format(port_data['net_id'], str(e)), HTTP_Internal_Server_Error) + + return uuid + else: + raise ovimException(str(uuid), -result) + + def new_external_port(self, port_data): + """ + Create new external port and check port mapping correspondence + :param port_data: port_data = { + 'region': 'datacenter region', + 'compute_node': 'compute node id', + 'pci': 'pci port address', + 'vlan': 'net vlan', + 'net_id': 'net id', + 'tenant_id': 'tenant id', + 'mac': 'switch mac', + 'name': 'port name' + 'ip_address': 'ip address - optional'} + :return: + """ + + port_data['type'] = 'external' + + if port_data.get('net_id'): + # check that new net has the correct type + result, new_net = self.db.check_target_net(port_data['net_id'], None, 'external') + if result < 0: + raise ovimException(str(new_net), -result) + # insert in data base + db_filter = {} + + if port_data.get('region'): + db_filter['region'] = port_data['region'] + if port_data.get('pci'): + db_filter['pci'] = port_data['pci'] + if port_data.get('compute_node'): + db_filter['compute_node'] = port_data['compute_node'] + + columns = ['ofc_id', 'switch_dpid', 'switch_port', 'switch_mac', 'pci'] + port_mapping_data = self.get_of_port_mappings(columns, db_filter) + + if not len(port_mapping_data): + raise ovimException("No port mapping founded for '{}'".format(str(db_filter)), + HTTP_Not_Found) + elif len(port_mapping_data) > 1: + raise ovimException("Wrong port data was given, please check pci, region & compute id data", + HTTP_Conflict) + + port_data['ofc_id'] = port_mapping_data[0]['ofc_id'] + port_data['switch_dpid'] = port_mapping_data[0]['switch_dpid'] + port_data['switch_port'] = port_mapping_data[0]['switch_port'] + port_data['switch_mac'] = port_mapping_data[0]['switch_mac'] + + # remove from compute_node, region and pci of_port_data to adapt to 'ports' structure + if 'region' in port_data: + del port_data['region'] + if 'pci' in port_data: + del port_data['pci'] + if 'compute_node' in port_data: + del port_data['compute_node'] + + result, uuid = self.db.new_row('ports', port_data, True, True) + if result > 0: + try: + self.net_update_ofc_thread(port_data['net_id'], port_data['ofc_id']) + except ovimException as e: + raise ovimException("Cannot insert a task for updating network '{}' {}". + format(port_data['net_id'], str(e)), HTTP_Internal_Server_Error) + except Exception as e: + raise ovimException("Cannot insert a task for updating network '{}' {}" + .format(port_data['net_id'], e), HTTP_Internal_Server_Error) return uuid else: raise ovimException(str(uuid), -result) + def net_update_ofc_thread(self, net_id, ofc_id=None, switch_dpid=None): + """ + Insert a update net task by net id or ofc_id for each ofc thread + :param net_id: network id + :param ofc_id: openflow controller id + :param switch_dpid: switch dpid + :return: + """ + if not net_id: + raise ovimException("No net_id received", HTTP_Internal_Server_Error) + + r = -1 + c = 'No valid ofc_id or switch_dpid received' + + if not ofc_id: + ports = self.get_ports(filter={"net_id": net_id}) + for port in ports: + port_ofc_id = port.get('ofc_id', None) + if port_ofc_id: + ofc_id = port['ofc_id'] + switch_dpid = port['switch_dpid'] + break + #TODO if not ofc_id: look at database table ofcs + + + # If no ofc_id found it, default ofc_id is used. + if not ofc_id and not switch_dpid: + ofc_id = "Default" + + if ofc_id and ofc_id in self.config['ofcs_thread']: + r, c = self.config['ofcs_thread'][ofc_id].insert_task("update-net", net_id) + elif switch_dpid: + + ofcs_dpid_list = self.config['ofcs_thread_dpid'] + for ofc_t in ofcs_dpid_list: + if switch_dpid in ofc_t: + r, c = ofc_t[switch_dpid].insert_task("update-net", net_id) + + if r < 0: + message = "Cannot insert a task for updating network '{}', {}".format(net_id, c) + self.logger.error(message) + raise ovimException(message, HTTP_Internal_Server_Error) + def delete_port(self, port_id): # Look for the previous port data result, ports = self.db.get_table(WHERE={'uuid': port_id, "type": "external"}, FROM='ports') @@ -289,11 +988,17 @@ class ovim(): network = ports[0].get('net_id', None) if network: # change of net. - r, c = self.config['of_thread'].insert_task("update-net", network) - if r < 0: - self.logger.error("Cannot insert a task for updating network '$s' %s", network, c) - return content + try: + self.net_update_ofc_thread(network, ofc_id=ports[0]["ofc_id"], switch_dpid=ports[0]["switch_dpid"]) + except ovimException as e: + raise ovimException("Cannot insert a task for delete network '{}' {}".format(network, str(e)), + HTTP_Internal_Server_Error) + except Exception as e: + raise ovimException("Cannot insert a task for delete network '{}' {}".format(network, str(e)), + HTTP_Internal_Server_Error) + + return content def edit_port(self, port_id, port_data, admin=True): # Look for the previous port data @@ -339,14 +1044,20 @@ class ovim(): # insert in data base if result >= 0: result, content = self.db.update_rows('ports', port_data, WHERE={'uuid': port_id}, log=False) + port.update(port_data) # Insert task to complete actions if result > 0: for net_id in nets: - r, v = self.config['of_thread'].insert_task("update-net", net_id) - if r < 0: - self.logger.error("Error updating network '{}' {}".format(r,v)) - # TODO Do something if fails + try: + self.net_update_ofc_thread(net_id, port["ofc_id"], switch_dpid=port["switch_dpid"]) + except ovimException as e: + raise ovimException("Error updating network'{}' {}".format(net_id, str(e)), + HTTP_Internal_Server_Error) + except Exception as e: + raise ovimException("Error updating network '{}' {}".format(net_id, str(e)), + HTTP_Internal_Server_Error) + if host_id: r, v = self.config['host_threads'][host_id].insert_task("edit-iface", port_id, old_net, new_net) if r < 0: @@ -356,3 +1067,316 @@ class ovim(): return port_id else: raise ovimException("Error {}".format(content), http_code=-result) + + def new_of_controller(self, ofc_data): + """ + Create a new openflow controller into DB + :param ofc_data: Dict openflow controller data + :return: openflow controller dpid + """ + + result, ofc_uuid = self.db.new_row('ofcs', ofc_data, True, True) + if result < 0: + raise ovimException("New ofc Error %s" % ofc_uuid, HTTP_Internal_Server_Error) + + ofc_data['uuid'] = ofc_uuid + of_conn = self._load_of_module(ofc_data) + self._create_ofc_task(ofc_uuid, ofc_data['dpid'], of_conn) + + return ofc_uuid + + def edit_of_controller(self, of_id, ofc_data): + """ + Edit an openflow controller entry from DB + :return: + """ + if not ofc_data: + raise ovimException("No data received during uptade OF contorller", http_code=HTTP_Internal_Server_Error) + + old_of_controller = self.show_of_controller(of_id) + + if old_of_controller: + result, content = self.db.update_rows('ofcs', ofc_data, WHERE={'uuid': of_id}, log=False) + if result >= 0: + return ofc_data + else: + raise ovimException("Error uptating OF contorller with uuid {}".format(of_id), + http_code=-result) + else: + raise ovimException("Error uptating OF contorller with uuid {}".format(of_id), + http_code=HTTP_Internal_Server_Error) + + def delete_of_controller(self, of_id): + """ + Delete an openflow controller from DB. + :param of_id: openflow controller dpid + :return: + """ + + ofc = self.show_of_controller(of_id) + + result, content = self.db.delete_row("ofcs", of_id) + if result < 0: + raise ovimException("Cannot delete ofc from database: {}".format(content), http_code=-result) + elif result == 0: + raise ovimException("ofc {} not found ".format(content), http_code=HTTP_Not_Found) + + ofc_thread = self.config['ofcs_thread'][of_id] + del self.config['ofcs_thread'][of_id] + for ofc_th in self.config['ofcs_thread_dpid']: + if ofc['dpid'] in ofc_th: + self.config['ofcs_thread_dpid'].remove(ofc_th) + + ofc_thread.insert_task("exit") + #ofc_thread.join() + + return content + + def show_of_controller(self, uuid): + """ + Show an openflow controller by dpid from DB. + :param db_filter: List with where query parameters + :return: + """ + + result, content = self.db.get_table(FROM='ofcs', WHERE={"uuid": uuid}, LIMIT=100) + + if result == 0: + raise ovimException("Openflow controller with uuid '{}' not found".format(uuid), + http_code=HTTP_Not_Found) + elif result < 0: + raise ovimException("Openflow controller with uuid '{}' error".format(uuid), + http_code=HTTP_Internal_Server_Error) + return content[0] + + def get_of_controllers(self, columns=None, db_filter={}, limit=None): + """ + Show an openflow controllers from DB. + :param columns: List with SELECT query parameters + :param db_filter: List with where query parameters + :param limit: result Limit + :return: + """ + result, content = self.db.get_table(SELECT=columns, FROM='ofcs', WHERE=db_filter, LIMIT=limit) + + if result < 0: + raise ovimException(str(content), -result) + + return content + + def get_tenants(self, columns=None, db_filter={}, limit=None): + """ + Retrieve tenant list from DB + :param columns: List with SELECT query parameters + :param db_filter: List with where query parameters + :param limit: result limit + :return: + """ + result, content = self.db.get_table(FROM='tenants', SELECT=columns, WHERE=db_filter, LIMIT=limit) + if result < 0: + raise ovimException('get_tenatns Error {}'.format(str(content)), -result) + else: + convert_boolean(content, ('enabled',)) + return content + + def show_tenant_id(self, tenant_id): + """ + Get tenant from DB by id + :param tenant_id: tenant id + :return: + """ + result, content = self.db.get_table(FROM='tenants', SELECT=('uuid', 'name', 'description', 'enabled'), + WHERE={"uuid": tenant_id}) + if result < 0: + raise ovimException(str(content), -result) + elif result == 0: + raise ovimException("tenant with uuid='{}' not found".format(tenant_id), HTTP_Not_Found) + else: + convert_boolean(content, ('enabled',)) + return content[0] + + def new_tentant(self, tenant): + """ + Create a tenant and store in DB + :param tenant: Dictionary with tenant data + :return: the uuid of created tenant. Raise exception upon error + """ + + # insert in data base + result, tenant_uuid = self.db.new_tenant(tenant) + + if result >= 0: + return tenant_uuid + else: + raise ovimException(str(tenant_uuid), -result) + + def delete_tentant(self, tenant_id): + """ + Delete a tenant from the database. + :param tenant_id: Tenant id + :return: delete tenant id + """ + + # check permissions + r, tenants_flavors = self.db.get_table(FROM='tenants_flavors', SELECT=('flavor_id', 'tenant_id'), + WHERE={'tenant_id': tenant_id}) + if r <= 0: + tenants_flavors = () + r, tenants_images = self.db.get_table(FROM='tenants_images', SELECT=('image_id', 'tenant_id'), + WHERE={'tenant_id': tenant_id}) + if r <= 0: + tenants_images = () + + result, content = self.db.delete_row('tenants', tenant_id) + if result == 0: + raise ovimException("tenant '%s' not found" % tenant_id, HTTP_Not_Found) + elif result > 0: + for flavor in tenants_flavors: + self.db.delete_row_by_key("flavors", "uuid", flavor['flavor_id']) + for image in tenants_images: + self.db.delete_row_by_key("images", "uuid", image['image_id']) + return content + else: + raise ovimException("Error deleting tenant '%s' " % tenant_id, HTTP_Internal_Server_Error) + + def edit_tenant(self, tenant_id, tenant_data): + """ + Update a tenant data identified by tenant id + :param tenant_id: tenant id + :param tenant_data: Dictionary with tenant data + :return: + """ + + # Look for the previous data + result, tenant_data_old = self.db.get_table(FROM='tenants', WHERE={'uuid': tenant_id}) + if result < 0: + raise ovimException("Error updating tenant with uuid='{}': {}".format(tenant_id, tenant_data_old), + HTTP_Internal_Server_Error) + elif result == 0: + raise ovimException("tenant with uuid='{}' not found".format(tenant_id), HTTP_Not_Found) + + # insert in data base + result, content = self.db.update_rows('tenants', tenant_data, WHERE={'uuid': tenant_id}, log=True) + if result >= 0: + return content + else: + raise ovimException(str(content), -result) + + def set_of_port_mapping(self, of_maps, ofc_id=None, switch_dpid=None, region=None): + """ + Create new port mapping entry + :param of_maps: List with port mapping information + # maps =[{"ofc_id": ,"region": datacenter region,"compute_node": compute uuid,"pci": pci adress, + "switch_dpid": swith dpid,"switch_port": port name,"switch_mac": mac}] + :param ofc_id: ofc id + :param switch_dpid: switch dpid + :param region: datacenter region id + :return: + """ + + for map in of_maps: + if ofc_id: + map['ofc_id'] = ofc_id + if switch_dpid: + map['switch_dpid'] = switch_dpid + if region: + map['region'] = region + + for of_map in of_maps: + result, uuid = self.db.new_row('of_port_mappings', of_map, True) + if result > 0: + of_map["uuid"] = uuid + else: + raise ovimException(str(uuid), -result) + return of_maps + + def clear_of_port_mapping(self, db_filter={}): + """ + Clear port mapping filtering using db_filter dict + :param db_filter: Parameter to filter during remove process + :return: + """ + result, content = self.db.delete_row_by_dict(FROM='of_port_mappings', WHERE=db_filter) + # delete_row_by_key + if result >= 0: + return content + else: + raise ovimException("Error deleting of_port_mappings with filter='{}'".format(str(db_filter)), + HTTP_Internal_Server_Error) + + def get_of_port_mappings(self, column=None, db_filter=None, db_limit=None): + """ + Retrive port mapping from DB + :param column: + :param db_filter: + :return: + """ + result, content = self.db.get_table(SELECT=column, WHERE=db_filter, FROM='of_port_mappings', LIMIT=db_limit) + + if result < 0: + self.logger.error("get_of_port_mappings Error %d %s", result, content) + raise ovimException(str(content), -result) + else: + return content + + def get_dhcp_controller(self): + """ + Create an host_thread object for manage openvim controller and not create a thread for itself + :return: dhcp_host openvim controller object + """ + + if 'openvim_controller' in self.config['host_threads']: + return self.config['host_threads']['openvim_controller'] + + bridge_ifaces = [] + controller_ip = self.config['ovs_controller_ip'] + ovs_controller_user = self.config['ovs_controller_user'] + + host_test_mode = True if self.config['mode'] == 'test' or self.config['mode'] == "OF only" else False + host_develop_mode = True if self.config['mode'] == 'development' else False + + dhcp_host = ht.host_thread(name='openvim_controller', user=ovs_controller_user, host=controller_ip, + db=self.db_of, + db_lock=self.db_lock, test=host_test_mode, + image_path=self.config['image_path'], version=self.config['version'], + host_id='openvim_controller', develop_mode=host_develop_mode, + develop_bridge_iface=bridge_ifaces) + + self.config['host_threads']['openvim_controller'] = dhcp_host + if not host_test_mode: + dhcp_host.ssh_connect() + return dhcp_host + + def launch_dhcp_server(self, vlan, first_ip, last_ip, cidr, gateway): + """ + Launch a dhcpserver base on dnsmasq attached to the net base on vlan id across the the openvim computes + :param vlan: vlan identifier + :param first_ip: First dhcp range ip + :param last_ip: Last dhcp range ip + :param cidr: net cidr + :param gateway: net gateway + :return: + """ + ip_tools = IPNetwork(cidr) + dhcp_netmask = str(ip_tools.netmask) + ip_range = [first_ip, last_ip] + + dhcp_path = self.config['ovs_controller_file_path'] + + controller_host = self.get_dhcp_controller() + controller_host.create_linux_bridge(vlan) + controller_host.create_dhcp_interfaces(vlan, first_ip, dhcp_netmask) + controller_host.launch_dhcp_server(vlan, ip_range, dhcp_netmask, dhcp_path, gateway) + +if __name__ == "__main__": + + parser = argparse.ArgumentParser() + parser.add_argument("-v","--version", help="show ovim library version", action="store_true") + parser.add_argument("--database-version", help="show required database version", action="store_true") + args = parser.parse_args() + if args.version: + print ('openvimd version {} {}'.format(ovim.get_version(), ovim.get_version_date())) + print ('(c) Copyright Telefonica') + elif args.database_version: + print ('required database version: {}'.format(ovim.get_database_version())) +