+#!/usr/bin/env python
# -*- coding: utf-8 -*-
##
__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
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'],
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):
"""
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:<host_bridge_name>, VLAN used at Host, uuid of network camping in this bridge,
+ # speed in Gbit/s
- # precreate interfaces; [bridge:<host_bridge_name>, 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])
# 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])
# 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
-
- 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)
+ # OFC default
+ self._start_ofc_default_task()
- 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
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
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'])
# 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:
- r, c = self.config['of_thread'].insert_task("update-net", network_id)
- if r < 0:
- raise ovimException("Error while launching openflow rules %s" % c, HTTP_Internal_Server_Error)
+
+ 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["name"]) in self.config["dhcp_server"].get("nets", ()):
+ 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", network_old["bind"])
- if net_bind and net_bind[:7] == "bridge:" and net_bind[7:] in self.config["dhcp_server"].get(
+ 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
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:
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 delete_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_)
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')
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)
+
+ 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):
# 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:
:return: openflow controller dpid
"""
- result, content = self.db.new_row('ofcs', ofc_data, True, True)
+ result, ofc_uuid = self.db.new_row('ofcs', ofc_data, True, True)
if result < 0:
- raise ovimException("New ofc Error %s" % content, HTTP_Internal_Server_Error)
- return content
+ 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):
"""
:return:
"""
- result, content = self.db.delete_row_by_key("ofcs", "uuid", of_id)
+ 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):
elif result < 0:
raise ovimException("Openflow controller with uuid '{}' error".format(uuid),
http_code=HTTP_Internal_Server_Error)
- return content
+ return content[0]
def get_of_controllers(self, columns=None, db_filter={}, limit=None):
"""
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": <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
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)
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()))
projects / osm / openvim.git / blobdiff