X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=ovim.py;h=a1eaffab87e20288e43182dbf12a2ed3c8ebe1ce;hb=refs%2Fchanges%2F17%2F1317%2F3;hp=d15fdbda721e1511fcb34ab3e61bfa8f2a3cc6df;hpb=e9f6f1a5ff8da7db0704ade6f977048528b99b09;p=osm%2Fopenvim.git

diff --git a/ovim.py b/ovim.py
old mode 100644
new mode 100755
index d15fdbd..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,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'],
@@ -104,6 +115,18 @@ 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):
         """
@@ -140,27 +163,36 @@ class ovim():
             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])
@@ -168,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])
@@ -180,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
 
@@ -254,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
@@ -280,10 +267,159 @@ class ovim():
                                             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'])
 
@@ -292,15 +428,15 @@ class ovim():
         for thread in threads.values():
             thread.join()
 
-    def get_networks(self, columns=None, filter={}, limit=None):
+    def get_networks(self, columns=None, db_filter={}, limit=None):
         """
         Retreive networks available
         :param columns: List with select query parameters
-        :param filter: List with where 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=filter, 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)
@@ -309,20 +445,19 @@ class ovim():
 
         return content
 
-    def show_network(self, network_id, filter={}):
+    def show_network(self, network_id, db_filter={}):
         """
         Get network from DB by id
         :param network_id: net Id
-        :param filter:
-        :param limit:
+        :param db_filter: List with where query parameters
         :return:
         """
         # obtain data
         if not network_id:
             raise ovimException("Not network id was not found")
-        filter['uuid'] = network_id
+        db_filter['uuid'] = network_id
 
-        result, content = self.db.get_table(FROM='nets', WHERE=filter, LIMIT=100)
+        result, content = self.db.get_table(FROM='nets', WHERE=db_filter, LIMIT=100)
 
         if result < 0:
             raise ovimException(str(content), -result)
@@ -550,17 +685,25 @@ class ovim():
             # 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
@@ -568,6 +711,11 @@ class ovim():
             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)
@@ -596,9 +744,8 @@ 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:
@@ -628,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 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_)
@@ -673,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')
@@ -696,9 +988,16 @@ 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)
+
+            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):
@@ -745,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:
@@ -763,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": <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
@@ -780,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)
@@ -812,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()))