and host controllers
'''
-__author__="Alfonso Tierno"
-__date__ ="$10-jul-2014 12:07:15$"
-__version__="0.5.1-r507"
-version_date="Jan 2017"
-database_version="0.9" #expected database schema version
+__author__ = "Alfonso Tierno"
+__date__ = "$10-jul-2014 12:07:15$"
+
import httpserver
import auxiliary_functions as af
import sys
import getopt
import time
-import vim_db
import yaml
import os
from jsonschema import validate as js_v, exceptions as js_e
-import host_thread as ht
-import dhcp_thread as dt
-import openflow_thread as oft
-import threading
from vim_schema import config_schema
import logging
import logging.handlers as log_handlers
-import imp
import socket
+import ovim
global config_dic
global logger
'log_level': "DEBUG",
'log_level_db': "ERROR",
'log_level_of': 'ERROR',
+ 'bridge_ifaces': {},
+ 'network_type': 'ovs',
+ 'ovs_controller_user': 'osm_dhcp',
+ 'ovs_controller_file_path': '/var/lib/',
}
try:
#First load configuration from configuration file
return (False, "Error loading configuration file '"+configuration_file+"': "+str(e))
return (True, config)
-def create_database_connection(config_dic):
- db = vim_db.vim_db( (config_dic["network_vlan_range_start"],config_dic["network_vlan_range_end"]), config_dic['log_level_db'] );
- if db.connect(config_dic['db_host'], config_dic['db_user'], config_dic['db_passwd'], config_dic['db_name']) == -1:
- logger.error("Cannot connect to database %s at %s@%s", config_dic['db_name'], config_dic['db_user'], config_dic['db_host'])
- exit(-1)
- return db
-
def usage():
print "Usage: ", sys.argv[0], "[options]"
print " -v|--version: prints current version"
log_format_simple = "%(asctime)s %(levelname)s %(name)s %(filename)s:%(lineno)s %(message)s"
log_formatter_simple = logging.Formatter(log_format_simple, datefmt='%Y-%m-%dT%H:%M:%S')
logging.basicConfig(format=log_format_simple, level= logging.DEBUG)
- logger = logging.getLogger('openmano')
+ logger = logging.getLogger('openvim')
logger.setLevel(logging.DEBUG)
try:
opts, args = getopt.getopt(sys.argv[1:], "hvc:p:P:", ["config=", "help", "version", "port=", "adminport=", "log-file=", "dbname="])
for o, a in opts:
if o in ("-v", "--version"):
- print "openvimd version", __version__, version_date
+ print "openvimd version", ovim.ovim.get_version(), ovim.ovim.get_version_date()
print "(c) Copyright Telefonica"
sys.exit(0)
elif o in ("-h", "--help"):
assert False, "Unhandled option"
+ engine = None
+ http_thread = None
+ http_thread_admin = None
+
try:
#Load configuration file
r, config_dic = load_configuration(config_file)
#allow backward compatibility of test_mode option
if 'test_mode' in config_dic and config_dic['test_mode']==True:
config_dic['mode'] = 'test'
- if config_dic['mode'] == 'development' and ( 'development_bridge' not in config_dic or config_dic['development_bridge'] not in config_dic.get("bridge_ifaces",None) ):
+ if config_dic['mode'] == 'development' and config_dic['network_type'] == 'bridge' and \
+ ( 'development_bridge' not in config_dic or config_dic['development_bridge'] not in config_dic.get("bridge_ifaces",None) ):
logger.error("'%s' is not a valid 'development_bridge', not one of the 'bridge_ifaces'", config_file)
exit(-1)
-
+
if config_dic['mode'] != 'normal':
print '!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
print "!! Warning, openvimd in TEST mode '%s'" % config_dic['mode']
print '!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
- config_dic['version'] = __version__
+ config_dic['version'] = ovim.ovim.get_version()
+ config_dic["logger_name"] = "openvim"
- #Connect to database
- db_http = create_database_connection(config_dic)
- r = db_http.get_db_version()
- if r[0]<0:
- logger.error("DATABASE is not a VIM one or it is a '0.0' version. Try to upgrade to version '%s' with './database_utils/migrate_vim_db.sh'", database_version)
- exit(-1)
- elif r[1]!=database_version:
- logger.error("DATABASE wrong version '%s'. Try to upgrade/downgrade to version '%s' with './database_utils/migrate_vim_db.sh'", r[1], database_version)
- exit(-1)
- db_of = create_database_connection(config_dic)
- db_lock= threading.Lock()
- config_dic['db'] = db_of
- config_dic['db_lock'] = db_lock
-
- #precreate interfaces; [bridge:<host_bridge_name>, VLAN used at Host, uuid of network camping in this bridge, speed in Gbit/s
- config_dic['dhcp_nets']=[]
- config_dic['bridge_nets']=[]
- for bridge,vlan_speed in config_dic["bridge_ifaces"].items():
- #skip 'development_bridge'
- if config_dic['mode'] == 'development' and config_dic['development_bridge'] == bridge:
- continue
- config_dic['bridge_nets'].append( [bridge, vlan_speed[0], vlan_speed[1], None] )
- del config_dic["bridge_ifaces"]
-
- #check if this bridge is already used (present at database) for a network)
- used_bridge_nets=[]
- for brnet in config_dic['bridge_nets']:
- r,nets = db_of.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])
- if config_dic.get("dhcp_server"):
- if brnet[0] in config_dic["dhcp_server"]["bridge_ifaces"]:
- config_dic['dhcp_nets'].append(nets[0]['uuid'])
- if len(used_bridge_nets) > 0 :
- logger.info("found used bridge nets: " + ",".join(used_bridge_nets))
- #get nets used by dhcp
- if config_dic.get("dhcp_server"):
- for net in config_dic["dhcp_server"].get("nets", () ):
- r,nets = db_of.get_table(SELECT=('uuid',), FROM='nets',WHERE={'name': net})
- if r>0:
- config_dic['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:
- logger.error("Cannot get hosts from database %s", hosts)
- exit(-1)
- # create connector to the openflow controller
- of_test_mode = False if config_dic['mode']=='normal' or config_dic['mode']=="OF only" else True
-
- if of_test_mode:
- OF_conn = oft.of_test_connector({"of_debug": config_dic['log_level_of']} )
- else:
- #load other parameters starting by of_ from config dict in a temporal dict
- temp_dict={ "of_ip": config_dic['of_controller_ip'],
- "of_port": config_dic['of_controller_port'],
- "of_dpid": config_dic['of_controller_dpid'],
- "of_debug": config_dic['log_level_of']
- }
- for k,v in config_dic.iteritems():
- if type(k) is str and k[0:3]=="of_" and k[0:13] != "of_controller":
- temp_dict[k]=v
- if config_dic['of_controller']=='opendaylight':
- module = "ODL"
- elif "of_controller_module" in config_dic:
- module = config_dic["of_controller_module"]
- else:
- module = config_dic['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:
- 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])
- logger.error("Cannot open openflow controller module '%s'; %s: %s; revise 'of_controller' field of configuration file.", module, type(e).__name__, str(e))
- exit(-1)
-
-
- #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=config_dic['of_controller_nets_with_same_vlan'],
- debug=config_dic['log_level_of'])
- r,c = thread.OF_connector.obtain_port_correspondence()
- if r<0:
- logger.error("Cannot get openflow information %s", c)
- exit()
- thread.start()
- config_dic['of_thread'] = thread
-
- #create dhcp_server thread
- host_test_mode = True if config_dic['mode']=='test' or config_dic['mode']=="OF only" else False
- dhcp_params = config_dic.get("dhcp_server")
- if dhcp_params:
- thread = dt.dhcp_thread(dhcp_params=dhcp_params, test=host_test_mode, dhcp_nets=config_dic["dhcp_nets"], db=db_of, db_lock=db_lock, debug=config_dic['log_level_of'])
- thread.start()
- config_dic['dhcp_thread'] = thread
+ engine = ovim.ovim(config_dic)
+ engine.start_service()
- #Create one thread for each host
- host_test_mode = True if config_dic['mode']=='test' or config_dic['mode']=="OF only" else False
- host_develop_mode = True if config_dic['mode']=='development' else False
- host_develop_bridge_iface = config_dic.get('development_bridge', None)
- config_dic['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=config_dic['image_path'], version=config_dic['version'],
- host_id=host['uuid'], develop_mode=host_develop_mode, develop_bridge_iface=host_develop_bridge_iface )
- thread.start()
- config_dic['host_threads'][ host['uuid'] ] = thread
-
-
-
#Create thread to listen to web requests
- http_thread = httpserver.httpserver(db_http, 'http', config_dic['http_host'], config_dic['http_port'], False, config_dic)
+ http_thread = httpserver.httpserver(engine, 'http', config_dic['http_host'], config_dic['http_port'], False, config_dic)
http_thread.start()
- if 'http_admin_port' in config_dic:
- db_http = create_database_connection(config_dic)
- http_thread_admin = httpserver.httpserver(db_http, 'http-admin', config_dic['http_host'], config_dic['http_admin_port'], True)
+ if 'http_admin_port' in config_dic:
+ engine2 = ovim.ovim(config_dic)
+ http_thread_admin = httpserver.httpserver(engine2, 'http-admin', config_dic['http_host'], config_dic['http_admin_port'], True)
http_thread_admin.start()
else:
http_thread_admin = None
except LoadConfigurationException as e:
logger.critical(str(e))
exit(-1)
+ except ovim.ovimException as e:
+ logger.critical(str(e))
+ exit(-1)
logger.info('Exiting openvimd')
- threads = config_dic.get('host_threads', {})
- if 'of_thread' in config_dic:
- threads['of'] = (config_dic['of_thread'])
- if 'dhcp_thread' in config_dic:
- threads['dhcp'] = (config_dic['dhcp_thread'])
-
- for thread in threads.values():
- thread.insert_task("exit")
- for thread in threads.values():
- thread.join()
- #http_thread.join()
- #if http_thread_admin is not None:
- #http_thread_admin.join()
+ if engine:
+ engine.stop_service()
+ if http_thread:
+ http_thread.join(1)
+ if http_thread_admin:
+ http_thread_admin.join(1)
+
logger.debug( "bye!")
exit()