X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=ovim.py;h=a1eaffab87e20288e43182dbf12a2ed3c8ebe1ce;hb=ba1862b460afc13008f96b13252f2abcb075f138;hp=922e1221c74be0518d8119568bd061771f495db9;hpb=65ba8f83bd586b24dc712cfe36e53aaa96ae535e;p=osm%2Fopenvim.git diff --git a/ovim.py b/ovim.py old mode 100644 new mode 100755 index 922e122..a1eaffa --- a/ovim.py +++ b/ovim.py @@ -1,3 +1,4 @@ +#!/usr/bin/env python # -*- coding: utf-8 -*- ## @@ -28,17 +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 @@ -86,16 +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'], @@ -105,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]) @@ -135,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]) @@ -147,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 @@ -221,12 +235,18 @@ 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 @@ -239,18 +259,167 @@ class ovim(): 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": + 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']) @@ -259,15 +428,15 @@ class ovim(): for thread in threads.values(): thread.join() - def get_networks(self, select_=None, where_=None, limit_=100): + def get_networks(self, columns=None, db_filter={}, limit=None): """ Retreive networks available - :param select_: List with select query parameters - :param where_: List with where query parameters - :param limit_: Query limit result + :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=select_, FROM='nets', WHERE=where_, LIMIT=limit_) + result, content = self.db.get_table(SELECT=columns, FROM='nets', WHERE=db_filter, LIMIT=limit) if result < 0: raise ovimException(str(content), -result) @@ -276,36 +445,38 @@ class ovim(): return content - def get_network_by_id(self, where_, limit_=100): + def show_network(self, network_id, db_filter={}): """ - - :param where_: - :param limit_: + Get network from DB by id + :param network_id: net Id + :param db_filter: List with where query parameters :return: """ # obtain data - if 'uuid' not in where_: - raise ovimException("Not network id was not found" ) - result, content = self.db.get_table(FROM='nets', WHERE=where_, LIMIT=limit_) + if not network_id: + raise ovimException("Not network id was not found") + db_filter['uuid'] = network_id - network_id = where_['uuid'] + 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("http_get_networks_id network '%s' not found" % network_id, -result) + raise ovimException("show_network network '%s' not found" % network_id, -result) else: convert_boolean(content, ('shared', 'admin_state_up', 'enable_dhcp')) - # get ports + # get ports from DB result, ports = self.db.get_table(FROM='ports', SELECT=('uuid as port_id',), - WHERE={'net_id': network_id}, LIMIT=100) + WHERE={'net_id': network_id}, LIMIT=100) if len(ports) > 0: content[0]['ports'] = ports - return content - def set_network(self, network): - """ + 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') @@ -319,10 +490,6 @@ class ovim(): # check valid params net_provider = network.get('provider') net_type = network.get('type') - net_enable_dhcp = network.get('enable_dhcp') - if net_enable_dhcp: - net_cidr = network.get('cidr') - net_vlan = network.get("vlan") net_bind_net = network.get("bind_net") net_bind_type = network.get("bind_type") @@ -393,9 +560,11 @@ class ovim(): 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 + # 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']: @@ -414,7 +583,7 @@ class ovim(): raise ovimException("Max limits of bridge networks reached. Future versions of VIM " "will overcome this limit", HTTP_Bad_Request) else: - print "using net", bridge_net + 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': @@ -441,51 +610,128 @@ class ovim(): 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) - print "dhcp_server: add new net", 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) - print "dhcp_server: add new net", content + self.logger.debug("dhcp_server: add new net", content, content) return content else: - print "http_post_networks error %d %s" % (result, content) raise ovimException("Error posting network", HTTP_Internal_Server_Error) +# TODO kei change update->edit - @staticmethod - def _check_dhcp_data_integrity(network): + def edit_network(self, network_id, 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 + Update entwork data byt id :return: """ - control_iface = [] + # 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) - if "cidr" in network: - cidr = network["cidr"] - ip_tools = IPNetwork(cidr) - cidr_len = ip_tools.prefixlen - if cidr_len > 29: - return False + # 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) - 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]) + # 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: - return True + 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: - return False + raise ovimException(content, -result) - @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 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): """ @@ -498,16 +744,15 @@ class ovim(): where_ = {} else: where_ = {"net_id": network_id} - result, content = self.db.get_table( - SELECT=("name", "net_id", "priority", "vlan_id", "ingress_port", "src_mac", "dst_mac", "actions"), + 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 update_openflow_rules(self, network_id=None): + def edit_openflow_rules(self, network_id=None): """ To make actions over the net. The action is to reinstall the openflow rules @@ -530,29 +775,56 @@ class ovim(): if net["type"] != "ptp" and net["type"] != "data": result -= 1 continue - r, c = self.config['of_thread'].insert_task("update-net", net['uuid']) - if r < 0: - raise ovimException(str(c), -r) + + 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 clear_openflow_rules(self): + 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 """ - # ignore input data - r, c = self.config['of_thread'].insert_task("clear-all") - if r < 0: - raise ovimException(str(c), -r) + + 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): + def get_openflow_ports(self, ofc_id=None): """ Obtain switch ports names of openflow controller :return: Return flow ports in DB """ - data = {'ports': self.config['of_thread'].OF_connector.pp2ofi} - return data + 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_) @@ -575,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') @@ -598,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 @@ -648,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: @@ -666,6 +1068,257 @@ class ovim(): 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 @@ -683,8 +1336,8 @@ class ovim(): 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.config['db'], - db_lock=self.config['db_lock'], test=host_test_mode, + 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) @@ -701,6 +1354,7 @@ class ovim(): :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) @@ -714,4 +1368,15 @@ class ovim(): 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()))