def __init__(self, args=None):
self._args = args
# create database and logger
self.db = ServiceMonitorDB(args)
# initialize discovery client
self._disc = None
if self._args.disc_server_ip and self._args.disc_server_port:
self._disc = client.DiscoveryClient(self._args.disc_server_ip,
self._args.disc_server_port,
client_type='Service Monitor')
# initialize logger
self.logger = ServiceMonitorLogger(self.db, self._disc, args)
self.db.add_logger(self.logger)
# rotating log file for catchall errors
self._err_file = '/var/log/contrail/svc-monitor.err'
self._tmp_file = '/var/log/contrail/svc-monitor.tmp'
try:
with open(self._err_file, 'a'):
pass
with open(self._tmp_file, 'a'):
pass
except IOError:
self._err_file = './svc-monitor.err'
self._tmp_file = './svc-monitor.tmp'
self._svc_err_logger = logging.getLogger('SvcErrLogger')
self._svc_err_logger.setLevel(logging.ERROR)
handler = logging.handlers.RotatingFileHandler(
self._err_file, maxBytes=64*1024, backupCount=2)
self._svc_err_logger.addHandler(handler)
def __init__(self, args=None):
self._args = args
# create database and logger
self.db = ServiceMonitorDB(args)
# initialize discovery client
self._disc = None
if self._args.disc_server_ip and self._args.disc_server_port:
self._disc = client.DiscoveryClient(
self._args.disc_server_ip, self._args.disc_server_port,
ModuleNames[Module.SVC_MONITOR])
# initialize logger
self.logger = ServiceMonitorLogger(self.db, self._disc, args)
self.db.add_logger(self.logger)
self.db.init_database()
# rotating log file for catchall errors
self._err_file = self._args.trace_file
self._svc_err_logger = logging.getLogger('SvcErrLogger')
self._svc_err_logger.setLevel(logging.ERROR)
try:
with open(self._err_file, 'a'):
handler = logging.handlers.RotatingFileHandler(self._err_file,
maxBytes=64 *
1024,
backupCount=2)
self._svc_err_logger.addHandler(handler)
except IOError:
self.logger.log("Failed to open trace file %s" % self._err_file)
def __init__(self, sm_logger=None, args=None):
self._args = args
self._args.analytics_api_ssl_params = analytics_api_ssl_params(args)
# initialize logger
if sm_logger is not None:
self.logger = sm_logger
else:
# Initialize logger
self.logger = ServiceMonitorLogger(args)
# init object_db
self._object_db = ServiceMonitorDB(self._args, self.logger)
DBBaseSM.init(self, self.logger, self._object_db)
# init rabbit connection
rabbitmq_cfg = get_rabbitmq_cfg(args)
if 'host_ip' in self._args:
host_ip = self._args.host_ip
else:
host_ip = socket.gethostbyname(socket.getfqdn())
self.rabbit = VncAmqpHandle(self.logger._sandesh, self.logger,
DBBaseSM, REACTION_MAP, 'svc_monitor',
rabbitmq_cfg, host_ip,
self._args.trace_file)
self.rabbit.establish()
def __init__(self, args=None):
self._args = args
# initialize logger
self.logger = ServiceMonitorLogger(args)
# rotating log file for catchall errors
self._err_file = self._args.trace_file
self._svc_err_logger = logging.getLogger('SvcErrLogger')
self._svc_err_logger.setLevel(logging.ERROR)
try:
with open(self._err_file, 'a'):
handler = logging.handlers.RotatingFileHandler(self._err_file,
maxBytes=64 *
1024,
backupCount=2)
self._svc_err_logger.addHandler(handler)
except IOError:
self.logger.warning("Failed to open trace file %s" %
self._err_file)
# init object_db
self._object_db = ServiceMonitorDB(self._args, self.logger)
DBBaseSM.init(self, self.logger, self._object_db)
# init rabbit connection
self.rabbit = VncAmqpHandle(self.logger,
DBBaseSM,
REACTION_MAP,
'svc_monitor',
args=self._args)
self.rabbit.establish()
def __init__(self, args=None):
self._args = args
# initialize discovery client
self._disc = None
if self._args.disc_server_ip and self._args.disc_server_port:
self._disc = client.DiscoveryClient(
self._args.disc_server_ip, self._args.disc_server_port,
ModuleNames[Module.SVC_MONITOR])
# initialize logger
self.logger = ServiceMonitorLogger(self._disc, args)
# rotating log file for catchall errors
self._err_file = self._args.trace_file
self._svc_err_logger = logging.getLogger('SvcErrLogger')
self._svc_err_logger.setLevel(logging.ERROR)
try:
with open(self._err_file, 'a'):
handler = logging.handlers.RotatingFileHandler(self._err_file,
maxBytes=64 *
1024,
backupCount=2)
self._svc_err_logger.addHandler(handler)
except IOError:
self.logger.warning("Failed to open trace file %s" %
self._err_file)
# init cassandra
self._cassandra = ServiceMonitorDB(self._args, self.logger)
DBBaseSM.init(self, self.logger, self._cassandra)
# init rabbit connection
self.rabbit = RabbitConnection(self.logger, args)
self.rabbit._connect_rabbit()
def __init__(self, args=None):
self._args = args
# create database and logger
self.db = ServiceMonitorDB(args)
# initialize discovery client
self._disc = None
if self._args.disc_server_ip and self._args.disc_server_port:
self._disc = client.DiscoveryClient(self._args.disc_server_ip,
self._args.disc_server_port,
ModuleNames[Module.SVC_MONITOR])
# initialize logger
self.logger = ServiceMonitorLogger(self.db, self._disc, args)
self.db.add_logger(self.logger)
self.db.init_database()
# rotating log file for catchall errors
self._err_file = self._args.trace_file
self._svc_err_logger = logging.getLogger('SvcErrLogger')
self._svc_err_logger.setLevel(logging.ERROR)
try:
with open(self._err_file, 'a'):
handler = logging.handlers.RotatingFileHandler(
self._err_file, maxBytes=64*1024, backupCount=2)
self._svc_err_logger.addHandler(handler)
except IOError:
self.logger.log("Failed to open trace file %s" % self._err_file)
def __init__(self, args=None):
self._args = args
# create database and logger
self.db = ServiceMonitorDB(args)
# initialize discovery client
self._disc = None
if self._args.disc_server_ip and self._args.disc_server_port:
self._disc = client.DiscoveryClient(self._args.disc_server_ip,
self._args.disc_server_port,
client_type='Service Monitor')
# initialize logger
self.logger = ServiceMonitorLogger(self.db, self._disc, args)
self.db.add_logger(self.logger)
self.db.init_database()
# rotating log file for catchall errors
self._err_file = '/var/log/contrail/svc-monitor.err'
self._tmp_file = '/var/log/contrail/svc-monitor.tmp'
try:
with open(self._err_file, 'a'):
pass
with open(self._tmp_file, 'a'):
pass
except IOError:
self._err_file = './svc-monitor.err'
self._tmp_file = './svc-monitor.tmp'
self._svc_err_logger = logging.getLogger('SvcErrLogger')
self._svc_err_logger.setLevel(logging.ERROR)
handler = logging.handlers.RotatingFileHandler(
self._err_file, maxBytes=64*1024, backupCount=2)
self._svc_err_logger.addHandler(handler)
def __init__(self, sm_logger=None, args=None):
self._args = args
# initialize discovery client
self._disc = None
if self._args.disc_server_ip and self._args.disc_server_port:
dss_kwargs = {}
if self._args.disc_server_ssl:
if self._args.disc_server_cert:
dss_kwargs.update({'cert': self._args.disc_server_cert})
if self._args.disc_server_key:
dss_kwargs.update({'key': self._args.disc_server_key})
if self._args.disc_server_cacert:
dss_kwargs.update(
{'cacert': self._args.disc_server_cacert})
self._disc = client.DiscoveryClient(
self._args.disc_server_ip, self._args.disc_server_port,
ModuleNames[Module.SVC_MONITOR], **dss_kwargs)
# initialize logger
if sm_logger is not None:
self.logger = sm_logger
else:
# Initialize logger
self.logger = ServiceMonitorLogger(self._disc, args)
# rotating log file for catchall errors
self._err_file = self._args.trace_file
self._svc_err_logger = logging.getLogger('SvcErrLogger')
self._svc_err_logger.setLevel(logging.ERROR)
try:
with open(self._err_file, 'a'):
handler = logging.handlers.RotatingFileHandler(self._err_file,
maxBytes=64 *
1024,
backupCount=2)
self._svc_err_logger.addHandler(handler)
except IOError:
self.logger.warning("Failed to open trace file %s" %
self._err_file)
# init cassandra
self._cassandra = ServiceMonitorDB(self._args, self.logger)
DBBaseSM.init(self, self.logger, self._cassandra)
# init rabbit connection
self.rabbit = VncAmqpHandle(self.logger,
DBBaseSM,
REACTION_MAP,
'svc_monitor',
args=self._args)
self.rabbit.establish()
def __init__(self, sm_logger=None, args=None):
self._args = args
# initialize logger
if sm_logger is not None:
self.logger = sm_logger
else:
# Initialize logger
self.logger = ServiceMonitorLogger(args)
# init object_db
self._object_db = ServiceMonitorDB(self._args, self.logger)
DBBaseSM.init(self, self.logger, self._object_db)
# init rabbit connection
rabbitmq_cfg = get_rabbitmq_cfg(args)
self.rabbit = VncAmqpHandle(self.logger._sandesh, self.logger,
DBBaseSM, REACTION_MAP, 'svc_monitor',
rabbitmq_cfg, self._args.trace_file)
self.rabbit.establish()
def _connect_rabbit(self):
rabbit_server = self._args.rabbit_server
rabbit_port = self._args.rabbit_port
rabbit_user = self._args.rabbit_user
rabbit_password = self._args.rabbit_password
rabbit_vhost = self._args.rabbit_vhost
rabbit_ha_mode = self._args.rabbit_ha_mode
self._db_resync_done = gevent.event.Event()
q_name = 'svc_mon.%s' % (socket.gethostname())
self._vnc_kombu = VncKombuClient(rabbit_server, rabbit_port,
rabbit_user, rabbit_password,
rabbit_vhost, rabbit_ha_mode,
q_name, self._vnc_subscribe_callback,
self.logger.log)
self._cassandra = ServiceMonitorDB(self._args, self.logger)
DBBaseSM.init(self, self.logger, self._cassandra)
def _connect_rabbit(self):
rabbit_server = self._args.rabbit_server
rabbit_port = self._args.rabbit_port
rabbit_user = self._args.rabbit_user
rabbit_password = self._args.rabbit_password
rabbit_vhost = self._args.rabbit_vhost
rabbit_ha_mode = self._args.rabbit_ha_mode
self._db_resync_done = gevent.event.Event()
q_name = 'svc_mon.%s' % (socket.gethostname())
self._vnc_kombu = VncKombuClient(rabbit_server, rabbit_port,
rabbit_user, rabbit_password,
rabbit_vhost, rabbit_ha_mode, q_name,
self._vnc_subscribe_callback,
self.logger.log)
self._cassandra = ServiceMonitorDB(self._args, self.logger)
DBBaseSM.init(self, self.logger, self._cassandra)
class SvcMonitor(object):
"""
data + methods used/referred to by ssrc and arc greenlets
"""
_REACTION_MAP = {
"loadbalancer_pool": {
'self': [],
'virtual_ip': [],
'loadbalancer_member': [],
'loadbalancer_healthmonitor': [],
},
"loadbalancer_member": {
'self': ['loadbalancer_pool'],
'loadbalancer_pool': []
},
"virtual_ip": {
'self': ['loadbalancer_pool'],
'loadbalancer_pool': []
},
"loadbalancer_healthmonitor": {
'self': ['loadbalancer_pool'],
'loadbalancer_pool': []
},
"service_instance": {
'self': [],
},
"service_template": {
'self': [],
}
}
def __init__(self, args=None):
self._args = args
# create database and logger
self.db = ServiceMonitorDB(args)
# initialize discovery client
self._disc = None
if self._args.disc_server_ip and self._args.disc_server_port:
self._disc = client.DiscoveryClient(self._args.disc_server_ip,
self._args.disc_server_port,
ModuleNames[Module.SVC_MONITOR])
# initialize logger
self.logger = ServiceMonitorLogger(self.db, self._disc, args)
self.db.add_logger(self.logger)
self.db.init_database()
# rotating log file for catchall errors
self._err_file = self._args.trace_file
self._svc_err_logger = logging.getLogger('SvcErrLogger')
self._svc_err_logger.setLevel(logging.ERROR)
try:
with open(self._err_file, 'a'):
handler = logging.handlers.RotatingFileHandler(
self._err_file, maxBytes=64*1024, backupCount=2)
self._svc_err_logger.addHandler(handler)
except IOError:
self.logger.log("Failed to open trace file %s" % self._err_file)
# Connect to Rabbit and Initialize cassandra connection
# TODO activate this code
# self._connect_rabbit()
def _connect_rabbit(self):
rabbit_server = self._args.rabbit_server
rabbit_port = self._args.rabbit_port
rabbit_user = self._args.rabbit_user
rabbit_password = self._args.rabbit_password
rabbit_vhost = self._args.rabbit_vhost
self._db_resync_done = gevent.event.Event()
q_name = 'svc_mon.%s' % (socket.gethostname())
self._vnc_kombu = VncKombuClient(rabbit_server, rabbit_port,
rabbit_user, rabbit_password,
rabbit_vhost, q_name,
self._vnc_subscribe_callback,
self.config_log)
cass_server_list = self._args.cassandra_server_list
reset_config = self._args.reset_config
self._cassandra = VncCassandraClient(cass_server_list, reset_config,
self._args.cluster_id, None,
self.config_log)
DBBase.init(self, self.logger, self._cassandra)
# end _connect_rabbit
def config_log(self, msg, level):
self.logger.log(msg)
def _vnc_subscribe_callback(self, oper_info):
import pdb;pdb.set_trace()
self._db_resync_done.wait()
try:
msg = "Notification Message: %s" % (pformat(oper_info))
self.config_log(msg, level=SandeshLevel.SYS_DEBUG)
obj_type = oper_info['type'].replace('-', '_')
obj_class = DBBase._OBJ_TYPE_MAP.get(obj_type)
if obj_class is None:
return
if oper_info['oper'] == 'CREATE' or oper_info['oper'] == 'UPDATE':
dependency_tracker = DependencyTracker(DBBase._OBJ_TYPE_MAP, self._REACTION_MAP)
obj_id = oper_info['uuid']
obj = obj_class.get(obj_id)
if obj is not None:
dependency_tracker.evaluate(obj_type, obj)
else:
obj = obj_class.locate(obj_id)
obj.update()
dependency_tracker.evaluate(obj_type, obj)
elif oper_info['oper'] == 'DELETE':
obj_id = oper_info['uuid']
obj = obj_class.get(obj_id)
if obj is None:
return
dependency_tracker = DependencyTracker(DBBase._OBJ_TYPE_MAP, self._REACTION_MAP)
dependency_tracker.evaluate(obj_type, obj)
obj_class.delete(obj_id)
else:
# unknown operation
self.config_log('Unknown operation %s' % oper_info['oper'],
level=SandeshLevel.SYS_ERR)
return
if obj is None:
self.config_log('Error while accessing %s uuid %s' % (
obj_type, obj_id))
return
except Exception:
string_buf = cStringIO.StringIO()
cgitb.Hook(file=string_buf, format="text").handle(sys.exc_info())
self.config_log(string_buf.getvalue(), level=SandeshLevel.SYS_ERR)
for lb_pool_id in dependency_tracker.resources.get('loadbalancer_pool', []):
lb_pool = LoadbalancerPoolSM.get(lb_pool_id)
if lb_pool is not None:
lb_pool.add()
# end _vnc_subscribe_callback
def post_init(self, vnc_lib, args=None):
# api server
self._vnc_lib = vnc_lib
# create default analyzer template
self._create_default_template('analyzer-template', 'analyzer',
flavor='m1.medium',
image_name='analyzer')
# create default NAT template
self._create_default_template('nat-template', 'firewall',
svc_mode='in-network-nat',
image_name='analyzer',
flavor='m1.medium')
# create default netns SNAT template
self._create_default_template('netns-snat-template', 'source-nat',
svc_mode='in-network-nat',
hypervisor_type='network-namespace',
scaling=True)
# create default loadbalancer template
self._create_default_template('haproxy-loadbalancer-template', 'loadbalancer',
svc_mode='in-network-nat',
hypervisor_type='network-namespace',
scaling=True)
self._create_default_template('docker-template', 'firewall',
svc_mode='transparent',
image_name="ubuntu",
hypervisor_type='vrouter-instance',
vrouter_instance_type='docker',
instance_data={
"command": "/bin/bash"
})
self._nova_client = importutils.import_object(
'svc_monitor.nova_client.ServiceMonitorNovaClient',
self._args, self.logger)
# load vrouter scheduler
self.vrouter_scheduler = importutils.import_object(
self._args.si_netns_scheduler_driver,
self._vnc_lib, self._nova_client,
self._args)
# load virtual machine instance manager
self.vm_manager = importutils.import_object(
'svc_monitor.virtual_machine_manager.VirtualMachineManager',
self._vnc_lib, self.db, self.logger,
self.vrouter_scheduler, self._nova_client, self._args)
# load network namespace instance manager
self.netns_manager = importutils.import_object(
'svc_monitor.instance_manager.NetworkNamespaceManager',
self._vnc_lib, self.db, self.logger,
self.vrouter_scheduler, self._nova_client, self._args)
# load a vrouter instance manager
self.vrouter_manager = importutils.import_object(
'svc_monitor.vrouter_instance_manager.VRouterInstanceManager',
self._vnc_lib, self.db, self.logger,
self.vrouter_scheduler, self._nova_client, self._args)
# load a loadbalancer agent
# TODO : activate the code
# self.loadbalancer_agent = LoadbalancerAgent(self._vnc_lib, self._args)
# Read the cassandra and populate the entry in ServiceMonitor DB
# TODO : activate the code
# self.sync_sm()
# resync db
self.db_resync()
def db_resync(self):
si_list = self.db.service_instance_list()
for si_fq_str, si in si_list or []:
for idx in range(0, int(si.get('max-instances', '0'))):
prefix = self.db.get_vm_db_prefix(idx)
vm_key = prefix + 'uuid'
if vm_key not in si.keys():
continue
try:
vm_obj = self._vnc_lib.virtual_machine_read(id=si[vm_key])
except NoIdError:
continue
vmi_back_refs = vm_obj.get_virtual_machine_interface_back_refs()
for vmi_back_ref in vmi_back_refs or []:
try:
vmi_obj = self._vnc_lib.virtual_machine_interface_read(
id=vmi_back_ref['uuid'])
except NoIdError:
continue
vmi_props = vmi_obj.get_virtual_machine_interface_properties()
if not vmi_props:
continue
if_type = vmi_props.get_service_interface_type()
if not if_type:
continue
key = prefix + 'if-' + if_type
self.db.service_instance_insert(si_fq_str,
{key:vmi_obj.uuid})
def sync_sm(self):
vn_set = set()
vmi_set = set()
iip_set = set()
ok, lb_pool_list = self._cassandra._cassandra_loadbalancer_pool_list()
if not ok:
pass
else:
for fq_name, uuid in lb_pool_list:
lb_pool = LoadbalancerPoolSM.locate(uuid)
if lb_pool.virtual_machine_interface:
vmi_set.add(lb_pool.virtual_machine_interface)
ok, lb_pool_member_list = self._cassandra._cassandra_loadbalancer_member_list()
if not ok:
pass
else:
for fq_name, uuid in lb_pool_member_list:
lb_pool_member = LoadbalancerMemberSM.locate(uuid)
ok, lb_vip_list = self._cassandra._cassandra_virtual_ip_list()
if not ok:
pass
else:
for fq_name, uuid in lb_vip_list:
virtual_ip = VirtualIpSM.locate(uuid)
if virtual_ip.virtual_machine_interface:
vmi_set.add(virtual_ip.virtual_machine_interface)
ok, lb_hm_list = self._cassandra._cassandra_loadbalancer_healthmonitor_list()
if not ok:
pass
else:
for fq_name, uuid in lb_hm_list:
lb_hm = HealthMonitorSM.locate(uuid)
ok, si_list = self._cassandra._cassandra_service_instance_list()
if not ok:
pass
else:
for fq_name, uuid in si_list:
si = ServiceInstanceSM.locate(uuid)
ok, st_list = self._cassandra._cassandra_service_template_list()
if not ok:
pass
else:
for fq_name, uuid in si_list:
si = ServiceInstanceSM.locate(uuid)
for vmi_id in vmi_set:
vmi = VirtualMachineInterfaceSM.locate(vmi_id)
if (vmi.instance_ip):
iip_set.add(vmi.instance_ip)
for iip_id in iip_set:
iip = InstanceIpSM.locate(iip_id)
for lb_pool in LoadbalancerPoolSM.values():
lb_pool.add()
self._db_resync_done.set()
# end sync_sm
# create service template
def _create_default_template(self, st_name, svc_type, svc_mode=None,
hypervisor_type='virtual-machine',
image_name=None, flavor=None, scaling=False,
vrouter_instance_type=None,
instance_data=None):
domain_name = 'default-domain'
domain_fq_name = [domain_name]
st_fq_name = [domain_name, st_name]
self.logger.log("Creating %s %s hypervisor %s" %
(domain_name, st_name, hypervisor_type))
try:
st_obj = self._vnc_lib.service_template_read(fq_name=st_fq_name)
st_uuid = st_obj.uuid
self.logger.log("%s exists uuid %s" % (st_name, str(st_uuid)))
return
except NoIdError:
domain = self._vnc_lib.domain_read(fq_name=domain_fq_name)
st_obj = ServiceTemplate(name=st_name, domain_obj=domain)
st_uuid = self._vnc_lib.service_template_create(st_obj)
svc_properties = ServiceTemplateType()
svc_properties.set_service_type(svc_type)
svc_properties.set_service_mode(svc_mode)
svc_properties.set_service_virtualization_type(hypervisor_type)
svc_properties.set_image_name(image_name)
svc_properties.set_flavor(flavor)
svc_properties.set_ordered_interfaces(True)
svc_properties.set_service_scaling(scaling)
# set interface list
if svc_type == 'analyzer':
if_list = [['left', False]]
elif hypervisor_type == 'network-namespace':
if_list = [['right', True], ['left', True]]
else:
if_list = [
['management', False], ['left', False], ['right', False]]
for itf in if_list:
if_type = ServiceTemplateInterfaceType(shared_ip=itf[1])
if_type.set_service_interface_type(itf[0])
svc_properties.add_interface_type(if_type)
if vrouter_instance_type is not None:
svc_properties.set_vrouter_instance_type(vrouter_instance_type)
if instance_data is not None:
svc_properties.set_instance_data(
json.dumps(instance_data, separators=(',', ':')))
try:
st_obj.set_service_template_properties(svc_properties)
self._vnc_lib.service_template_update(st_obj)
except Exception as e:
print e
self.logger.log("%s created with uuid %s" % (st_name, str(st_uuid)))
#_create_default_analyzer_template
def cleanup(self):
pass
# end cleanup
def _get_proj_name_from_si_fq_str(self, si_fq_str):
return si_fq_str.split(':')[1]
# enf _get_si_fq_str_to_proj_name
def _get_virtualization_type(self, st_props):
return st_props.get_service_virtualization_type() or 'virtual-machine'
# end _get_virtualization_type
def _check_store_si_info(self, st_obj, si_obj):
config_complete = True
st_props = st_obj.get_service_template_properties()
st_if_list = st_props.get_interface_type()
si_props = si_obj.get_service_instance_properties()
si_if_list = si_props.get_interface_list()
# for lb relax the check because vip and pool could be in same net
if (st_props.get_service_type() != svc_info.get_lb_service_type()) \
and si_if_list and (len(si_if_list) != len(st_if_list)):
self.logger.log("Error: IF mismatch template %s instance %s" %
(len(st_if_list), len(si_if_list)))
return
# read existing si_entry
si_entry = self.db.service_instance_get(si_obj.get_fq_name_str())
if not si_entry:
si_entry = {}
si_entry['instance_type'] = self._get_virtualization_type(st_props)
si_entry['uuid'] = si_obj.uuid
# walk the interface list
for idx in range(0, len(st_if_list)):
st_if = st_if_list[idx]
itf_type = st_if.service_interface_type
si_if = None
if si_if_list and st_props.get_ordered_interfaces():
try:
si_if = si_if_list[idx]
except IndexError:
continue
si_vn_str = si_if.get_virtual_network()
else:
funcname = "get_" + itf_type + "_virtual_network"
func = getattr(si_props, funcname)
si_vn_str = func()
if not si_vn_str:
continue
si_entry[itf_type + '-vn'] = si_vn_str
try:
vn_obj = self._vnc_lib.virtual_network_read(
fq_name_str=si_vn_str)
if vn_obj.uuid != si_entry.get(si_vn_str, None):
si_entry[si_vn_str] = vn_obj.uuid
except NoIdError:
self.logger.log("Warn: VN %s add is pending" % si_vn_str)
si_entry[si_vn_str] = 'pending'
config_complete = False
if config_complete:
self.logger.log("SI %s info is complete" %
si_obj.get_fq_name_str())
si_entry['state'] = 'config_complete'
else:
self.logger.log("Warn: SI %s info is not complete" %
si_obj.get_fq_name_str())
si_entry['state'] = 'pending_config'
#insert entry
self.db.service_instance_insert(si_obj.get_fq_name_str(), si_entry)
return config_complete
#end _check_store_si_info
def _restart_svc(self, si_fq_str):
si_obj = self._vnc_lib.service_instance_read(fq_name_str=si_fq_str)
st_list = si_obj.get_service_template_refs()
if st_list is not None:
fq_name = st_list[0]['to']
st_obj = self._vnc_lib.service_template_read(fq_name=fq_name)
self._create_svc_instance(st_obj, si_obj)
# end _restart_svc
def _create_svc_instance(self, st_obj, si_obj):
#check if all config received before launch
if not self._check_store_si_info(st_obj, si_obj):
return
st_props = st_obj.get_service_template_properties()
if st_props is None:
self.logger.log("Cannot find service template associated to "
"service instance %s" % si_obj.get_fq_name_str())
virt_type = self._get_virtualization_type(st_props)
if virt_type == 'virtual-machine':
self.vm_manager.create_service(st_obj, si_obj)
elif virt_type == 'network-namespace':
self.netns_manager.create_service(st_obj, si_obj)
elif virt_type == 'vrouter-instance':
self.vrouter_manager.create_service(st_obj, si_obj)
else:
self.logger.log("Unkown virtualization type: %s" % virt_type)
def _delete_svc_instance(self, vm_uuid, proj_name,
si_fq_str=None, virt_type=None):
self.logger.log("Deleting VM %s %s" % (proj_name, vm_uuid))
try:
if virt_type == svc_info.get_vm_instance_type():
self.vm_manager.delete_iip(vm_uuid)
self.vm_manager.delete_service(si_fq_str, vm_uuid, proj_name)
elif virt_type == svc_info.get_netns_instance_type():
self.netns_manager.delete_service(si_fq_str, vm_uuid)
elif virt_type == 'vrouter-instance':
self.vrouter_manager.delete_service(si_fq_str, vm_uuid)
except KeyError:
return True
# generate UVE
self.logger.uve_svc_instance(si_fq_str, status='DELETE',
vms=[{'uuid': vm_uuid}])
return False
def _delete_shared_vn(self, vn_uuid, proj_name):
try:
vn_obj = self._vnc_lib.virtual_network_read(id=vn_uuid)
except NoIdError:
self.logger.log("Deleted VN %s %s" % (proj_name, vn_uuid))
return True
iip_back_refs = vn_obj.get_instance_ip_back_refs()
for iip_back_ref in iip_back_refs or []:
try:
self._vnc_lib.instance_ip_delete(id=iip_back_ref['uuid'])
except (NoIdError, RefsExistError):
continue
try:
self.logger.log("Deleting VN %s %s" % (proj_name, vn_uuid))
self._vnc_lib.virtual_network_delete(id=vn_uuid)
except RefsExistError:
pass
except NoIdError:
self.logger.log("Deleted VN %s %s" % (proj_name, vn_uuid))
return True
return False
def _cleanup_si(self, si_fq_str):
si_info = self.db.service_instance_get(si_fq_str)
if not si_info:
return
cleaned_up = True
state = {}
state['state'] = 'deleting'
self.db.service_instance_insert(si_fq_str, state)
proj_name = self._get_proj_name_from_si_fq_str(si_fq_str)
for idx in range(0, int(si_info.get('max-instances', '0'))):
prefix = self.db.get_vm_db_prefix(idx)
vm_key = prefix + 'uuid'
if vm_key in si_info.keys():
if not self._delete_svc_instance(
si_info[vm_key], proj_name, si_fq_str=si_fq_str,
virt_type=si_info['instance_type']):
cleaned_up = False
if cleaned_up:
vn_name = 'snat-si-left_%s' % si_fq_str.split(':')[-1]
if vn_name in si_info.keys():
if not self._delete_shared_vn(si_info[vn_name], proj_name):
cleaned_up = False
if cleaned_up:
for vn_name in svc_info.get_shared_vn_list():
if vn_name in si_info.keys():
self._delete_shared_vn(si_info[vn_name], proj_name)
self.db.service_instance_remove(si_fq_str)
def _check_si_status(self, si_fq_name_str, si_info):
try:
si_obj = self._vnc_lib.service_instance_read(id=si_info['uuid'])
except NoIdError:
# cleanup service instance
return 'DELETE'
# check status only if service is active
if si_info['state'] != 'active':
return ''
if si_info['instance_type'] == 'virtual-machine':
proj_name = self._get_proj_name_from_si_fq_str(si_fq_name_str)
status = self.vm_manager.check_service(si_obj, proj_name)
elif si_info['instance_type'] == 'network-namespace':
status = self.netns_manager.check_service(si_obj)
elif si_info['instance_type'] == 'vrouter-instance':
status = self.vrouter_manager.check_service(si_obj)
return status
def _delmsg_virtual_machine_service_instance(self, idents):
vm_fq_str = idents['virtual-machine']
si_fq_str = idents['service-instance']
self.db.remove_vm_info(si_fq_str, vm_fq_str)
def _delmsg_virtual_machine_interface_virtual_network(self, idents):
vmi_fq_str = idents['virtual-machine-interface']
vn_fq_str = idents['virtual-network']
vn_fq_name = vn_fq_str.split(':')
for vn_name in svc_info.get_shared_vn_list():
if vn_name != vn_fq_name[2]:
continue
try:
vn_id = self._vnc_lib.fq_name_to_id(
'virtual-network', vn_fq_name)
except NoIdError:
continue
self._delete_shared_vn(vn_id, vn_fq_name[1])
def _delmsg_service_instance_service_template(self, idents):
self._cleanup_si(idents['service-instance'])
def _delmsg_virtual_machine_interface_route_table(self, idents):
rt_fq_str = idents['interface-route-table']
try:
rt_obj = self._vnc_lib.interface_route_table_read(
fq_name_str=rt_fq_str)
except NoIdError:
return
try:
vmi_list = rt_obj.get_virtual_machine_interface_back_refs()
if vmi_list is None:
self._vnc_lib.interface_route_table_delete(id=rt_obj.uuid)
except NoIdError:
return
def _addmsg_service_instance_service_template(self, idents):
st_fq_str = idents['service-template']
si_fq_str = idents['service-instance']
try:
st_obj = self._vnc_lib.service_template_read(
fq_name_str=st_fq_str)
si_obj = self._vnc_lib.service_instance_read(
fq_name_str=si_fq_str)
except NoIdError:
self.logger.log("No template or service instance with ids: %s, %s"
% (st_fq_str, si_fq_str))
return
#launch VMs
self._create_svc_instance(st_obj, si_obj)
# end _addmsg_service_instance_service_template
def _addmsg_service_instance_properties(self, idents):
si_fq_str = idents['service-instance']
try:
si_obj = self._vnc_lib.service_instance_read(
fq_name_str=si_fq_str)
except NoIdError:
return
#update static routes
self.vm_manager.update_static_routes(si_obj)
def _addmsg_project_virtual_network(self, idents):
vn_fq_str = idents['virtual-network']
si_list = self.db.service_instance_list()
if not si_list:
return
for si_fq_str, si_info in si_list:
if vn_fq_str not in si_info.keys():
continue
try:
si_obj = self._vnc_lib.service_instance_read(
fq_name_str=si_fq_str)
if si_obj.get_virtual_machine_back_refs():
continue
st_refs = si_obj.get_service_template_refs()
fq_name = st_refs[0]['to']
st_obj = self._vnc_lib.service_template_read(fq_name=fq_name)
#launch VMs
self._create_svc_instance(st_obj, si_obj)
except Exception:
continue
def _addmsg_floating_ip_virtual_machine_interface(self, idents):
fip_fq_str = idents['floating-ip']
vmi_fq_str = idents['virtual-machine-interface']
try:
fip_obj = self._vnc_lib.floating_ip_read(
fq_name_str=fip_fq_str)
vmi_obj = self._vnc_lib.virtual_machine_interface_read(
fq_name_str=vmi_fq_str)
except NoIdError:
return
# handle only if VIP back ref exists
vip_back_refs = vmi_obj.get_virtual_ip_back_refs()
if vip_back_refs is None:
return
# associate fip to all VMIs
iip_back_refs = vmi_obj.get_instance_ip_back_refs()
try:
iip_obj = self._vnc_lib.instance_ip_read(
id=iip_back_refs[0]['uuid'])
except NoIdError:
return
fip_updated = False
vmi_refs_iip = iip_obj.get_virtual_machine_interface_refs()
vmi_refs_fip = fip_obj.get_virtual_machine_interface_refs()
for vmi_ref_iip in vmi_refs_iip:
if vmi_ref_iip in vmi_refs_fip:
continue
try:
vmi_obj = self._vnc_lib.virtual_machine_interface_read(
id=vmi_ref_iip['uuid'])
except NoIdError:
continue
fip_obj.add_virtual_machine_interface(vmi_obj)
fip_updated = True
if fip_updated:
self._vnc_lib.floating_ip_update(fip_obj)
def process_poll_result(self, poll_result_str):
result_list = parse_poll_result(poll_result_str)
# process ifmap message
for (result_type, idents, metas) in result_list:
if 'ERROR' in idents.values():
continue
for meta in metas:
meta_name = re.sub('{.*}', '', meta.tag)
if result_type == 'deleteResult':
funcname = "_delmsg_" + meta_name.replace('-', '_')
elif result_type in ['searchResult', 'updateResult']:
funcname = "_addmsg_" + meta_name.replace('-', '_')
# end if result_type
try:
func = getattr(self, funcname)
except AttributeError:
pass
else:
self.logger.log("%s with %s/%s"
% (funcname, meta_name, idents))
func(idents)
class SvcMonitor(object):
"""
data + methods used/referred to by ssrc and arc greenlets
"""
def __init__(self, args=None):
self._args = args
# create database and logger
self.db = ServiceMonitorDB(args)
# initialize discovery client
self._disc = None
if self._args.disc_server_ip and self._args.disc_server_port:
self._disc = client.DiscoveryClient(self._args.disc_server_ip,
self._args.disc_server_port,
client_type='Service Monitor')
# initialize logger
self.logger = ServiceMonitorLogger(self.db, self._disc, args)
self.db.add_logger(self.logger)
self.db.init_database()
# rotating log file for catchall errors
self._err_file = '/var/log/contrail/svc-monitor.err'
self._tmp_file = '/var/log/contrail/svc-monitor.tmp'
try:
with open(self._err_file, 'a'):
pass
with open(self._tmp_file, 'a'):
pass
except IOError:
self._err_file = './svc-monitor.err'
self._tmp_file = './svc-monitor.tmp'
self._svc_err_logger = logging.getLogger('SvcErrLogger')
self._svc_err_logger.setLevel(logging.ERROR)
handler = logging.handlers.RotatingFileHandler(
self._err_file, maxBytes=64*1024, backupCount=2)
self._svc_err_logger.addHandler(handler)
def post_init(self, vnc_lib, args=None):
# api server
self._vnc_lib = vnc_lib
# create default analyzer template
self._create_default_template('analyzer-template', 'analyzer',
flavor='m1.medium',
image_name='analyzer')
# create default NAT template
self._create_default_template('nat-template', 'firewall',
svc_mode='in-network-nat',
image_name='analyzer',
flavor='m1.medium')
# create default netns SNAT template
self._create_default_template('netns-snat-template', 'source-nat',
svc_mode='in-network-nat',
hypervisor_type='network-namespace',
scaling=True)
# create default loadbalancer template
self._create_default_template('haproxy-loadbalancer-template', 'loadbalancer',
svc_mode='in-network-nat',
hypervisor_type='network-namespace',
scaling=True)
# load vrouter scheduler
self.vrouter_scheduler = importutils.import_object(
self._args.si_netns_scheduler_driver,
self._vnc_lib,
self._args)
# load virtual machine instance manager
self.vm_manager = importutils.import_object(
'svc_monitor.instance_manager.VirtualMachineManager',
self._vnc_lib, self.db, self.logger,
self.vrouter_scheduler, self._args)
# load network namespace instance manager
self.netns_manager = importutils.import_object(
'svc_monitor.instance_manager.NetworkNamespaceManager',
self._vnc_lib, self.db, self.logger,
self.vrouter_scheduler, self._args)
# create service template
def _create_default_template(self, st_name, svc_type, svc_mode=None,
hypervisor_type='virtual-machine',
image_name=None, flavor=None, scaling=False):
domain_name = 'default-domain'
domain_fq_name = [domain_name]
st_fq_name = [domain_name, st_name]
self.logger.log("Creating %s %s hypervisor %s" %
(domain_name, st_name, hypervisor_type))
try:
st_obj = self._vnc_lib.service_template_read(fq_name=st_fq_name)
st_uuid = st_obj.uuid
self.logger.log("%s exists uuid %s" % (st_name, str(st_uuid)))
return
except NoIdError:
domain = self._vnc_lib.domain_read(fq_name=domain_fq_name)
st_obj = ServiceTemplate(name=st_name, domain_obj=domain)
st_uuid = self._vnc_lib.service_template_create(st_obj)
svc_properties = ServiceTemplateType()
svc_properties.set_service_type(svc_type)
svc_properties.set_service_mode(svc_mode)
svc_properties.set_service_virtualization_type(hypervisor_type)
svc_properties.set_image_name(image_name)
svc_properties.set_flavor(flavor)
svc_properties.set_ordered_interfaces(True)
svc_properties.set_service_scaling(scaling)
# set interface list
if svc_type == 'analyzer':
if_list = [['left', False]]
elif hypervisor_type == 'network-namespace':
if_list = [['right', True], ['left', True]]
else:
if_list = [
['management', False], ['left', False], ['right', False]]
for itf in if_list:
if_type = ServiceTemplateInterfaceType(shared_ip=itf[1])
if_type.set_service_interface_type(itf[0])
svc_properties.add_interface_type(if_type)
try:
st_obj.set_service_template_properties(svc_properties)
self._vnc_lib.service_template_update(st_obj)
except Exception as e:
print e
self.logger.log("%s created with uuid %s" % (st_name, str(st_uuid)))
#_create_default_analyzer_template
def cleanup(self):
pass
# end cleanup
def _get_proj_name_from_si_fq_str(self, si_fq_str):
return si_fq_str.split(':')[1]
# enf _get_si_fq_str_to_proj_name
def _get_virtualization_type(self, st_props):
return st_props.get_service_virtualization_type() or 'virtual-machine'
# end _get_virtualization_type
def _check_store_si_info(self, st_obj, si_obj):
config_complete = True
st_props = st_obj.get_service_template_properties()
st_if_list = st_props.get_interface_type()
si_props = si_obj.get_service_instance_properties()
si_if_list = si_props.get_interface_list()
# for lb relax the check because vip and pool could be in same net
if (st_props.get_service_type() != svc_info.get_lb_service_type()) \
and si_if_list and (len(si_if_list) != len(st_if_list)):
self.logger.log("Error: IF mismatch template %s instance %s" %
(len(st_if_list), len(si_if_list)))
return
# read existing si_entry
si_entry = self.db.service_instance_get(si_obj.get_fq_name_str())
if not si_entry:
si_entry = {}
si_entry['instance_type'] = self._get_virtualization_type(st_props)
si_entry['uuid'] = si_obj.uuid
# walk the interface list
for idx in range(0, len(st_if_list)):
st_if = st_if_list[idx]
itf_type = st_if.service_interface_type
si_if = None
if si_if_list and st_props.get_ordered_interfaces():
try:
si_if = si_if_list[idx]
except IndexError:
continue
si_vn_str = si_if.get_virtual_network()
else:
funcname = "get_" + itf_type + "_virtual_network"
func = getattr(si_props, funcname)
si_vn_str = func()
if not si_vn_str:
continue
si_entry[itf_type + '-vn'] = si_vn_str
try:
vn_obj = self._vnc_lib.virtual_network_read(
fq_name_str=si_vn_str)
if vn_obj.uuid != si_entry.get(si_vn_str, None):
si_entry[si_vn_str] = vn_obj.uuid
except NoIdError:
self.logger.log("Warn: VN %s add is pending" % si_vn_str)
si_entry[si_vn_str] = 'pending'
config_complete = False
if config_complete:
self.logger.log("SI %s info is complete" %
si_obj.get_fq_name_str())
si_entry['state'] = 'active'
else:
self.logger.log("Warn: SI %s info is not complete" %
si_obj.get_fq_name_str())
si_entry['state'] = 'pending'
#insert entry
self.db.service_instance_insert(si_obj.get_fq_name_str(), si_entry)
return config_complete
#end _check_store_si_info
def _restart_svc(self, si_fq_str):
si_obj = self._vnc_lib.service_instance_read(fq_name_str=si_fq_str)
st_list = si_obj.get_service_template_refs()
if st_list is not None:
fq_name = st_list[0]['to']
st_obj = self._vnc_lib.service_template_read(fq_name=fq_name)
self._create_svc_instance(st_obj, si_obj)
# end _restart_svc
def _create_svc_instance(self, st_obj, si_obj):
#check if all config received before launch
if not self._check_store_si_info(st_obj, si_obj):
return
st_props = st_obj.get_service_template_properties()
if st_props is None:
self.logger.log("Cannot find service template associated to "
"service instance %s" % si_obj.get_fq_name_str())
virt_type = self._get_virtualization_type(st_props)
if virt_type == 'virtual-machine':
self.vm_manager.create_service(st_obj, si_obj)
elif virt_type == 'network-namespace':
self.netns_manager.create_service(st_obj, si_obj)
def _delete_svc_instance(self, vm_uuid, proj_name,
si_fq_str=None, virt_type=None):
self.logger.log("Deleting VM %s %s" % (proj_name, vm_uuid))
try:
if virt_type == svc_info.get_vm_instance_type():
self.vm_manager.delete_service(vm_uuid, proj_name)
elif virt_type == svc_info.get_netns_instance_type():
self.netns_manager.delete_service(vm_uuid)
except KeyError:
return True
# generate UVE
self.logger.uve_svc_instance(si_fq_str, status='DELETE',
vms=[{'uuid': vm_uuid}])
return False
def _delete_shared_vn(self, vn_uuid, proj_name):
try:
self.logger.log("Deleting VN %s %s" % (proj_name, vn_uuid))
self._vnc_lib.virtual_network_delete(id=vn_uuid)
except RefsExistError:
self._svc_err_logger.error("Delete failed refs exist VN %s %s" %
(proj_name, vn_uuid))
except NoIdError:
return True
return False
def _cleanup_si(self, si_fq_str):
si_info = self.db.service_instance_get(si_fq_str)
if not si_info:
return
cleaned_up = True
state = {}
state['state'] = 'deleting'
self.db.service_instance_insert(si_fq_str, state)
proj_name = self._get_proj_name_from_si_fq_str(si_fq_str)
for idx in range(0, int(si_info.get('max-instances', '0'))):
prefix = self.db.get_vm_db_prefix(idx)
vm_key = prefix + 'uuid'
if vm_key in si_info.keys():
if not self._delete_svc_instance(
si_info[vm_key], proj_name, si_fq_str=si_fq_str,
virt_type=si_info['instance_type']):
cleaned_up = False
if cleaned_up:
vn_name = 'snat-si-left_%s' % si_fq_str.split(':')[-1]
if vn_name in si_info.keys():
if not self._delete_shared_vn(si_info[vn_name], proj_name):
cleaned_up = False
# delete shared vn and delete si info
if cleaned_up:
for vn_name in svc_info.get_shared_vn_list():
if vn_name in si_info.keys():
self._delete_shared_vn(si_info[vn_name], proj_name)
self.db.service_instance_remove(si_fq_str)
def _check_si_status(self, si_fq_name_str, si_info):
try:
si_obj = self._vnc_lib.service_instance_read(id=si_info['uuid'])
except NoIdError:
# cleanup service instance
return 'DELETE'
if si_info['instance_type'] == 'virtual-machine':
proj_name = self._get_proj_name_from_si_fq_str(si_fq_name_str)
status = self.vm_manager.check_service(si_obj, proj_name)
elif si_info['instance_type'] == 'network-namespace':
status = self.netns_manager.check_service(si_obj)
return status
def _delmsg_service_instance_service_template(self, idents):
self._cleanup_si(idents['service-instance'])
def _delmsg_virtual_machine_interface_route_table(self, idents):
rt_fq_str = idents['interface-route-table']
try:
rt_obj = self._vnc_lib.interface_route_table_read(
fq_name_str=rt_fq_str)
except NoIdError:
return
vmi_list = rt_obj.get_virtual_machine_interface_back_refs()
if vmi_list is None:
self._vnc_lib.interface_route_table_delete(id=rt_obj.uuid)
def _addmsg_service_instance_service_template(self, idents):
st_fq_str = idents['service-template']
si_fq_str = idents['service-instance']
try:
st_obj = self._vnc_lib.service_template_read(
fq_name_str=st_fq_str)
si_obj = self._vnc_lib.service_instance_read(
fq_name_str=si_fq_str)
except NoIdError:
return
#launch VMs
self._create_svc_instance(st_obj, si_obj)
# end _addmsg_service_instance_service_template
def _addmsg_service_instance_properties(self, idents):
si_fq_str = idents['service-instance']
try:
si_obj = self._vnc_lib.service_instance_read(
fq_name_str=si_fq_str)
except NoIdError:
return
#update static routes
self.vm_manager.update_static_routes(si_obj)
def _addmsg_project_virtual_network(self, idents):
vn_fq_str = idents['virtual-network']
si_list = self.db.service_instance_list()
if not si_list:
return
for si_fq_str, si_info in si_list:
if vn_fq_str not in si_info.keys():
continue
try:
si_obj = self._vnc_lib.service_instance_read(
fq_name_str=si_fq_str)
if si_obj.get_virtual_machine_back_refs():
continue
st_refs = si_obj.get_service_template_refs()
fq_name = st_refs[0]['to']
st_obj = self._vnc_lib.service_template_read(fq_name=fq_name)
#launch VMs
self._create_svc_instance(st_obj, si_obj)
except Exception:
continue
def _addmsg_floating_ip_virtual_machine_interface(self, idents):
fip_fq_str = idents['floating-ip']
vmi_fq_str = idents['virtual-machine-interface']
try:
fip_obj = self._vnc_lib.floating_ip_read(
fq_name_str=fip_fq_str)
vmi_obj = self._vnc_lib.virtual_machine_interface_read(
fq_name_str=vmi_fq_str)
except NoIdError:
return
# handle only if VIP back ref exists
vip_back_refs = vmi_obj.get_virtual_ip_back_refs()
if vip_back_refs is None:
return
# associate fip to all VMIs
iip_back_refs = vmi_obj.get_instance_ip_back_refs()
try:
iip_obj = self._vnc_lib.instance_ip_read(
id=iip_back_refs[0]['uuid'])
except NoIdError:
return
fip_updated = False
vmi_refs_iip = iip_obj.get_virtual_machine_interface_refs()
vmi_refs_fip = fip_obj.get_virtual_machine_interface_refs()
for vmi_ref_iip in vmi_refs_iip:
if vmi_ref_iip in vmi_refs_fip:
continue
try:
vmi_obj = self._vnc_lib.virtual_machine_interface_read(
id=vmi_ref_iip['uuid'])
except NoIdError:
continue
fip_obj.add_virtual_machine_interface(vmi_obj)
fip_updated = True
if fip_updated:
self._vnc_lib.floating_ip_update(fip_obj)
def process_poll_result(self, poll_result_str):
result_list = parse_poll_result(poll_result_str)
# process ifmap message
for (result_type, idents, metas) in result_list:
if 'ERROR' in idents.values():
continue
for meta in metas:
meta_name = re.sub('{.*}', '', meta.tag)
if result_type == 'deleteResult':
funcname = "_delmsg_" + meta_name.replace('-', '_')
elif result_type in ['searchResult', 'updateResult']:
funcname = "_addmsg_" + meta_name.replace('-', '_')
# end if result_type
try:
func = getattr(self, funcname)
except AttributeError:
pass
else:
self.logger.log("%s with %s/%s"
% (funcname, meta_name, idents))
func(idents)
class SvcMonitor(object):
"""
data + methods used/referred to by ssrc and arc greenlets
"""
_REACTION_MAP = {
"loadbalancer_pool": {
'self': [],
'virtual_ip': [],
'loadbalancer_member': [],
'loadbalancer_healthmonitor': [],
},
"loadbalancer_member": {
'self': ['loadbalancer_pool'],
'loadbalancer_pool': []
},
"virtual_ip": {
'self': ['loadbalancer_pool'],
'loadbalancer_pool': []
},
"loadbalancer_healthmonitor": {
'self': ['loadbalancer_pool'],
'loadbalancer_pool': []
},
"service_instance": {
'self': ['virtual_machine'],
'virtual_machine': []
},
"instance_ip": {
'self': [],
},
"service_template": {
'self': [],
},
"physical_router": {
'self': [],
},
"physical_interface": {
'self': [],
},
"logical_interface": {
'self': [],
},
"virtual_network": {
'self': [],
},
"virtual_machine": {
'self': ['virtual_machine_interface'],
'service_instance': [],
'virtual_machine_interface': [],
},
"virtual_machine_interface": {
'self': ['interface_route_table', 'virtual_machine'],
'interface_route_table': [],
'virtual_machine': [],
},
"interface_route_table": {
'self': [],
'virtual_machine_interface': [],
},
"project": {
'self': [],
},
}
def __init__(self, args=None):
self._args = args
# create database and logger
self.db = ServiceMonitorDB(args)
# initialize discovery client
self._disc = None
if self._args.disc_server_ip and self._args.disc_server_port:
self._disc = client.DiscoveryClient(self._args.disc_server_ip,
self._args.disc_server_port,
ModuleNames[Module.SVC_MONITOR])
# initialize logger
self.logger = ServiceMonitorLogger(self.db, self._disc, args)
self.db.add_logger(self.logger)
self.db.init_database()
# rotating log file for catchall errors
self._err_file = self._args.trace_file
self._svc_err_logger = logging.getLogger('SvcErrLogger')
self._svc_err_logger.setLevel(logging.ERROR)
try:
with open(self._err_file, 'a'):
handler = logging.handlers.RotatingFileHandler(
self._err_file, maxBytes=64*1024, backupCount=2)
self._svc_err_logger.addHandler(handler)
except IOError:
self.logger.log_warning("Failed to open trace file %s" %
self._err_file)
# Connect to Rabbit and Initialize cassandra connection
self._connect_rabbit()
def _connect_rabbit(self):
rabbit_server = self._args.rabbit_server
rabbit_port = self._args.rabbit_port
rabbit_user = self._args.rabbit_user
rabbit_password = self._args.rabbit_password
rabbit_vhost = self._args.rabbit_vhost
rabbit_ha_mode = self._args.rabbit_ha_mode
self._db_resync_done = gevent.event.Event()
q_name = 'svc_mon.%s' % (socket.gethostname())
self._vnc_kombu = VncKombuClient(rabbit_server, rabbit_port,
rabbit_user, rabbit_password,
rabbit_vhost, rabbit_ha_mode,
q_name, self._vnc_subscribe_callback,
self.config_log)
cass_server_list = self._args.cassandra_server_list
reset_config = self._args.reset_config
self._cassandra = VncCassandraClient(cass_server_list, reset_config,
self._args.cluster_id, None,
self.config_log)
DBBase.init(self, self.logger, self._cassandra)
# end _connect_rabbit
def config_log(self, msg, level):
self.logger.log(msg)
def _vnc_subscribe_callback(self, oper_info):
self._db_resync_done.wait()
try:
msg = "Notification Message: %s" % (pformat(oper_info))
self.config_log(msg, level=SandeshLevel.SYS_DEBUG)
obj_type = oper_info['type'].replace('-', '_')
obj_class = DBBase._OBJ_TYPE_MAP.get(obj_type)
if obj_class is None:
return
if oper_info['oper'] == 'CREATE' or oper_info['oper'] == 'UPDATE':
dependency_tracker = DependencyTracker(DBBase._OBJ_TYPE_MAP,
self._REACTION_MAP)
obj_id = oper_info['uuid']
obj = obj_class.get(obj_id)
if obj is not None:
dependency_tracker.evaluate(obj_type, obj)
else:
obj = obj_class.locate(obj_id)
obj.update()
dependency_tracker.evaluate(obj_type, obj)
elif oper_info['oper'] == 'DELETE':
obj_id = oper_info['uuid']
obj = obj_class.get(obj_id)
if obj is None:
return
dependency_tracker = DependencyTracker(DBBase._OBJ_TYPE_MAP,
self._REACTION_MAP)
dependency_tracker.evaluate(obj_type, obj)
obj_class.delete(obj_id)
else:
# unknown operation
self.config_log('Unknown operation %s' % oper_info['oper'],
level=SandeshLevel.SYS_ERR)
return
if obj is None:
self.config_log('Error while accessing %s uuid %s' % (
obj_type, obj_id))
return
except Exception:
string_buf = cStringIO.StringIO()
cgitb.Hook(file=string_buf, format="text").handle(sys.exc_info())
self.config_log(string_buf.getvalue(), level=SandeshLevel.SYS_ERR)
for sas_id in dependency_tracker.resources.get('service_appliance_set', []):
sas_obj = ServiceApplianceSetSM.get(sas_id)
if sas_obj is not None:
sas_obj.add()
for lb_pool_id in dependency_tracker.resources.get('loadbalancer_pool', []):
lb_pool = LoadbalancerPoolSM.get(lb_pool_id)
if lb_pool is not None:
lb_pool.add()
# end _vnc_subscribe_callback
for si_id in dependency_tracker.resources.get('service_instance', []):
si = ServiceInstanceSM.get(si_id)
if si:
self._create_service_instance(si)
else:
for vm_id in dependency_tracker.resources.get(
'virtual_machine', []):
vm = VirtualMachineSM.get(vm_id)
self._delete_service_instance(vm)
for vn_id in dependency_tracker.resources.get('virtual_network', []):
vn = VirtualNetworkSM.get(vn_id)
if vn:
for si_id in ServiceInstanceSM:
si = ServiceInstanceSM.get(si_id)
if (':').join(vn.fq_name) in si.params.values():
self._create_service_instance(si)
for vmi_id in dependency_tracker.resources.get('virtual_machine_interface', []):
vmi = VirtualMachineInterfaceSM.get(vmi_id)
if vmi:
for vm_id in dependency_tracker.resources.get(
'virtual_machine', []):
vm = VirtualMachineSM.get(vm_id)
if vm:
self.check_link_si_to_vm(vm, vmi)
else:
for irt_id in dependency_tracker.resources.get(
'interface_route_table', []):
self._delete_interface_route_table(irt_id)
def post_init(self, vnc_lib, args=None):
# api server
self._vnc_lib = vnc_lib
self._nova_client = importutils.import_object(
'svc_monitor.nova_client.ServiceMonitorNovaClient',
self._args, self.logger)
# load vrouter scheduler
self.vrouter_scheduler = importutils.import_object(
self._args.si_netns_scheduler_driver,
self._vnc_lib, self._nova_client,
self._args)
# load virtual machine instance manager
self.vm_manager = importutils.import_object(
'svc_monitor.virtual_machine_manager.VirtualMachineManager',
self._vnc_lib, self.db, self.logger,
self.vrouter_scheduler, self._nova_client, self._args)
# load network namespace instance manager
self.netns_manager = importutils.import_object(
'svc_monitor.instance_manager.NetworkNamespaceManager',
self._vnc_lib, self.db, self.logger,
self.vrouter_scheduler, self._nova_client, self._args)
# load a vrouter instance manager
self.vrouter_manager = importutils.import_object(
'svc_monitor.vrouter_instance_manager.VRouterInstanceManager',
self._vnc_lib, self.db, self.logger,
self.vrouter_scheduler, self._nova_client, self._args)
# load a loadbalancer agent
self.loadbalancer_agent = LoadbalancerAgent(self, self._vnc_lib, self._args)
# Read the cassandra and populate the entry in ServiceMonitor DB
self.sync_sm()
# create default analyzer template
self._create_default_template('analyzer-template', 'analyzer',
flavor='m1.medium',
image_name='analyzer')
# create default NAT template
self._create_default_template('nat-template', 'firewall',
svc_mode='in-network-nat',
image_name='analyzer',
flavor='m1.medium')
# create default netns SNAT template
self._create_default_template('netns-snat-template', 'source-nat',
svc_mode='in-network-nat',
hypervisor_type='network-namespace',
scaling=True)
# create default loadbalancer template
self._create_default_template('haproxy-loadbalancer-template', 'loadbalancer',
svc_mode='in-network-nat',
hypervisor_type='network-namespace',
scaling=True)
self._create_default_template('docker-template', 'firewall',
svc_mode='transparent',
image_name="ubuntu",
hypervisor_type='vrouter-instance',
vrouter_instance_type='docker',
instance_data={
"command": "/bin/bash"
})
# check services
self.launch_services()
def launch_services(self):
for si in ServiceInstanceSM.values():
self._create_service_instance(si)
def sync_sm(self):
vn_set = set()
vmi_set = set()
iip_set = set()
ok, lb_pool_list = self._cassandra._cassandra_loadbalancer_pool_list()
if not ok:
pass
else:
for fq_name, uuid in lb_pool_list:
lb_pool = LoadbalancerPoolSM.locate(uuid)
if lb_pool.virtual_machine_interface:
vmi_set.add(lb_pool.virtual_machine_interface)
ok, lb_pool_member_list = self._cassandra._cassandra_loadbalancer_member_list()
if not ok:
pass
else:
for fq_name, uuid in lb_pool_member_list:
lb_pool_member = LoadbalancerMemberSM.locate(uuid)
ok, lb_vip_list = self._cassandra._cassandra_virtual_ip_list()
if not ok:
pass
else:
for fq_name, uuid in lb_vip_list:
virtual_ip = VirtualIpSM.locate(uuid)
if virtual_ip.virtual_machine_interface:
vmi_set.add(virtual_ip.virtual_machine_interface)
ok, lb_hm_list = self._cassandra._cassandra_loadbalancer_healthmonitor_list()
if not ok:
pass
else:
for fq_name, uuid in lb_hm_list:
lb_hm = HealthMonitorSM.locate(uuid)
ok, si_list = self._cassandra._cassandra_service_instance_list()
if not ok:
pass
else:
for fq_name, uuid in si_list:
si = ServiceInstanceSM.locate(uuid)
ok, st_list = self._cassandra._cassandra_service_template_list()
if not ok:
pass
else:
for fq_name, uuid in st_list:
st = ServiceTemplateSM.locate(uuid)
ok, vn_list = self._cassandra._cassandra_virtual_network_list()
if not ok:
pass
else:
for fq_name, uuid in vn_list:
vn = VirtualNetworkSM.locate(uuid)
vmi_set |= vn.virtual_machine_interfaces
ok, ifd_list = self._cassandra._cassandra_physical_interface_list()
if not ok:
pass
else:
for fq_name, uuid in ifd_list:
ifd = PhysicalInterfaceSM.locate(uuid)
ok, ifl_list = self._cassandra._cassandra_logical_interface_list()
if not ok:
pass
else:
for fq_name, uuid in ifl_list:
ifl = LogicalInterfaceSM.locate(uuid)
if ifl.virtual_machine_interface:
vmi_set.add(ifl.virtual_machine_interface)
ok, pr_list = self._cassandra._cassandra_physical_router_list()
if not ok:
pass
else:
for fq_name, uuid in pr_list:
pr = PhysicalRouterSM.locate(uuid)
ok, vr_list = self._cassandra._cassandra_virtual_router_list()
if not ok:
pass
else:
for fq_name, uuid in vr_list:
vr = VirtualRouterSM.locate(uuid)
ok, vmi_list = self._cassandra._cassandra_virtual_machine_interface_list()
if not ok:
pass
else:
for fq_name, uuid in vmi_list:
vmi = VirtualMachineInterfaceSM.locate(uuid)
if vmi.instance_ip:
iip_set.add(vmi.instance_ip)
ok, irt_list = self._cassandra._cassandra_interface_route_table_list()
if not ok:
pass
else:
for fq_name, uuid in irt_list:
irt = InterfaceRouteTableSM.locate(uuid)
ok, project_list = self._cassandra._cassandra_project_list()
if not ok:
pass
else:
for fq_name, uuid in project_list:
prj = ProjectSM.locate(uuid)
ok, sas_list = self._cassandra._cassandra_service_appliance_set_list()
if not ok:
pass
else:
for fq_name, uuid in sas_list:
sas = ServiceApplianceSetSM.locate(uuid)
ok, sa_list = self._cassandra._cassandra_service_appliance_list()
if not ok:
pass
else:
for fq_name, uuid in sa_list:
sa = ServiceApplianceSM.locate(uuid)
ok, domain_list = self._cassandra._cassandra_domain_list()
if not ok:
pass
else:
for fq_name, uuid in domain_list:
DomainSM.locate(uuid)
ok, iip_list = self._cassandra._cassandra_instance_ip_list()
if not ok:
pass
else:
for fq_name, uuid in iip_list:
InstanceIpSM.locate(uuid)
ok, vm_list = self._cassandra._cassandra_virtual_machine_list()
if not ok:
pass
else:
for fq_name, uuid in vm_list:
vm = VirtualMachineSM.locate(uuid)
if vm.service_instance:
continue
for vmi_id in vm.virtual_machine_interfaces:
vmi = VirtualMachineInterfaceSM.get(vmi_id)
if not vmi:
continue
self.check_link_si_to_vm(vm, vmi)
# Load the loadbalancer driver
self.loadbalancer_agent.load_drivers()
for lb_pool in LoadbalancerPoolSM.values():
lb_pool.add()
self._db_resync_done.set()
# end sync_sm
# create service template
def _create_default_template(self, st_name, svc_type, svc_mode=None,
hypervisor_type='virtual-machine',
image_name=None, flavor=None, scaling=False,
vrouter_instance_type=None,
instance_data=None):
domain_name = 'default-domain'
domain_fq_name = [domain_name]
st_fq_name = [domain_name, st_name]
self.logger.log_info("Creating %s %s hypervisor %s" %
(domain_name, st_name, hypervisor_type))
domain_obj = None
for domain in DomainSM.values():
if domain.fq_name == domain_fq_name:
domain_obj = Domain()
domain_obj.uuid = domain.uuid
domain_obj.fq_name = domain_fq_name
break
if not domain_obj:
self.logger.log_error("%s domain not found" % (domain_name))
return
for st in ServiceTemplateSM.values():
if st.fq_name == st_fq_name:
self.logger.log_info("%s exists uuid %s" %
(st.name, str(st.uuid)))
return
st_obj = ServiceTemplate(name=st_name, domain_obj=domain)
st_uuid = self._vnc_lib.service_template_create(st_obj)
svc_properties = ServiceTemplateType()
svc_properties.set_service_type(svc_type)
svc_properties.set_service_mode(svc_mode)
svc_properties.set_service_virtualization_type(hypervisor_type)
svc_properties.set_image_name(image_name)
svc_properties.set_flavor(flavor)
svc_properties.set_ordered_interfaces(True)
svc_properties.set_service_scaling(scaling)
# set interface list
if svc_type == 'analyzer':
if_list = [['left', False]]
elif hypervisor_type == 'network-namespace':
if_list = [['right', True], ['left', True]]
else:
if_list = [
['management', False], ['left', False], ['right', False]]
for itf in if_list:
if_type = ServiceTemplateInterfaceType(shared_ip=itf[1])
if_type.set_service_interface_type(itf[0])
svc_properties.add_interface_type(if_type)
if vrouter_instance_type is not None:
svc_properties.set_vrouter_instance_type(vrouter_instance_type)
if instance_data is not None:
svc_properties.set_instance_data(
json.dumps(instance_data, separators=(',', ':')))
try:
st_obj.set_service_template_properties(svc_properties)
self._vnc_lib.service_template_update(st_obj)
except Exception as e:
print e
self.logger.log_info("%s created with uuid %s" %
(st_name, str(st_uuid)))
#_create_default_analyzer_template
def check_link_si_to_vm(self, vm, vmi):
if vm.service_instance:
return
if not vmi.if_type:
return
si_fq_name = vmi.name.split('__')[0:3]
index = int(vmi.name.split('__')[3]) - 1
for si in ServiceInstanceSM.values():
if si.fq_name != si_fq_name:
continue
st = ServiceTemplateSM.get(si.service_template)
self.vm_manager.link_si_to_vm(si, st, index, vm.uuid)
return
def _create_service_instance(self, si):
if si.state == 'active':
return
st = ServiceTemplateSM.get(si.service_template)
if st.virtualization_type == 'virtual-machine':
self.vm_manager.create_service(st, si)
elif st.virtualization_type == 'network-namespace':
self.netns_manager.create_service(st, si)
elif st.virtualization_type == 'vrouter-instance':
self.vrouter_manager.create_service(st, si)
else:
self.logger.log_error("Unknown virt type: %s" %
st.virtualization_type)
def _delete_service_instance(self, vm):
self.logger.log_info("Deleting VM %s %s" %
((':').join(vm.proj_fq_name), vm.uuid))
if vm.virtualization_type == svc_info.get_vm_instance_type():
self.vm_manager.delete_service(vm)
elif vm.virtualization_type == svc_info.get_netns_instance_type():
self.netns_manager.delete_service(vm)
elif vm.virtualization_type == 'vrouter-instance':
self.vrouter_manager.delete_service(vm)
# generate UVE
si_fq_name = vm.display_name.split('__')[:-2]
si_fq_str = (':').join(si_fq_name)
self.logger.uve_svc_instance(si_fq_str, status='DELETE',
vms=[{'uuid': vm.uuid}])
return True
def _relaunch_service_instance(self, si):
if si.state == 'active':
si.state = 'relaunch'
self._create_service_instance(si)
def _check_service_running(self, si):
if si.state != 'active':
return
st = ServiceTemplateSM.get(si.service_template)
if st.virtualization_type == 'virtual-machine':
status = self.vm_manager.check_service(si)
elif st.virtualization_type == 'network-namespace':
status = self.netns_manager.check_service(si)
elif st.virtualization_type == 'vrouter-instance':
status = self.vrouter_manager.check_service(si)
return status
def _delete_interface_route_table(self, irt_uuid):
try:
self._vnc_lib.interface_route_table_delete(id=irt_uuid)
except (NoIdError, RefsExistError):
return
def _delete_shared_vn(self, vn_uuid):
try:
self.logger.log_info("Deleting vn %s" % (vn_uuid))
self._vnc_lib.virtual_network_delete(id=vn_uuid)
except (NoIdError, RefsExistError):
pass
class SvcMonitor(object):
"""
data + methods used/referred to by ssrc and arc greenlets
"""
def __init__(self, args=None):
self._args = args
# create database and logger
self.db = ServiceMonitorDB(args)
# initialize discovery client
self._disc = None
if self._args.disc_server_ip and self._args.disc_server_port:
self._disc = client.DiscoveryClient(
self._args.disc_server_ip, self._args.disc_server_port,
ModuleNames[Module.SVC_MONITOR])
# initialize logger
self.logger = ServiceMonitorLogger(self.db, self._disc, args)
self.db.add_logger(self.logger)
self.db.init_database()
# rotating log file for catchall errors
self._err_file = self._args.trace_file
self._svc_err_logger = logging.getLogger('SvcErrLogger')
self._svc_err_logger.setLevel(logging.ERROR)
try:
with open(self._err_file, 'a'):
handler = logging.handlers.RotatingFileHandler(self._err_file,
maxBytes=64 *
1024,
backupCount=2)
self._svc_err_logger.addHandler(handler)
except IOError:
self.logger.log("Failed to open trace file %s" % self._err_file)
def post_init(self, vnc_lib, args=None):
# api server
self._vnc_lib = vnc_lib
# create default analyzer template
self._create_default_template('analyzer-template',
'analyzer',
flavor='m1.medium',
image_name='analyzer')
# create default NAT template
self._create_default_template('nat-template',
'firewall',
svc_mode='in-network-nat',
image_name='analyzer',
flavor='m1.medium')
# create default netns SNAT template
self._create_default_template('netns-snat-template',
'source-nat',
svc_mode='in-network-nat',
hypervisor_type='network-namespace',
scaling=True)
# create default loadbalancer template
self._create_default_template('haproxy-loadbalancer-template',
'loadbalancer',
svc_mode='in-network-nat',
hypervisor_type='network-namespace',
scaling=True)
self._create_default_template('docker-template',
'firewall',
svc_mode='transparent',
image_name="ubuntu",
hypervisor_type='vrouter-instance',
vrouter_instance_type='docker',
instance_data={"command": "/bin/bash"})
self._nova_client = importutils.import_object(
'svc_monitor.nova_client.ServiceMonitorNovaClient', self._args)
# load vrouter scheduler
self.vrouter_scheduler = importutils.import_object(
self._args.si_netns_scheduler_driver, self._vnc_lib,
self._nova_client, self._args)
# load virtual machine instance manager
self.vm_manager = importutils.import_object(
'svc_monitor.virtual_machine_manager.VirtualMachineManager',
self._vnc_lib, self.db, self.logger, self.vrouter_scheduler,
self._nova_client, self._args)
# load network namespace instance manager
self.netns_manager = importutils.import_object(
'svc_monitor.instance_manager.NetworkNamespaceManager',
self._vnc_lib, self.db, self.logger, self.vrouter_scheduler,
self._nova_client, self._args)
# load a vrouter instance manager
self.vrouter_manager = importutils.import_object(
'svc_monitor.vrouter_instance_manager.VRouterInstanceManager',
self._vnc_lib, self.db, self.logger, self.vrouter_scheduler,
self._nova_client, self._args)
# create service template
def _create_default_template(self,
st_name,
svc_type,
svc_mode=None,
hypervisor_type='virtual-machine',
image_name=None,
flavor=None,
scaling=False,
vrouter_instance_type=None,
instance_data=None):
domain_name = 'default-domain'
domain_fq_name = [domain_name]
st_fq_name = [domain_name, st_name]
self.logger.log("Creating %s %s hypervisor %s" %
(domain_name, st_name, hypervisor_type))
try:
st_obj = self._vnc_lib.service_template_read(fq_name=st_fq_name)
st_uuid = st_obj.uuid
self.logger.log("%s exists uuid %s" % (st_name, str(st_uuid)))
return
except NoIdError:
domain = self._vnc_lib.domain_read(fq_name=domain_fq_name)
st_obj = ServiceTemplate(name=st_name, domain_obj=domain)
st_uuid = self._vnc_lib.service_template_create(st_obj)
svc_properties = ServiceTemplateType()
svc_properties.set_service_type(svc_type)
svc_properties.set_service_mode(svc_mode)
svc_properties.set_service_virtualization_type(hypervisor_type)
svc_properties.set_image_name(image_name)
svc_properties.set_flavor(flavor)
svc_properties.set_ordered_interfaces(True)
svc_properties.set_service_scaling(scaling)
# set interface list
if svc_type == 'analyzer':
if_list = [['left', False]]
elif hypervisor_type == 'network-namespace':
if_list = [['right', True], ['left', True]]
else:
if_list = [['management', False], ['left', False],
['right', False]]
for itf in if_list:
if_type = ServiceTemplateInterfaceType(shared_ip=itf[1])
if_type.set_service_interface_type(itf[0])
svc_properties.add_interface_type(if_type)
if vrouter_instance_type is not None:
svc_properties.set_vrouter_instance_type(vrouter_instance_type)
if instance_data is not None:
svc_properties.set_instance_data(
json.dumps(instance_data, separators=(',', ':')))
try:
st_obj.set_service_template_properties(svc_properties)
self._vnc_lib.service_template_update(st_obj)
except Exception as e:
print e
self.logger.log("%s created with uuid %s" % (st_name, str(st_uuid)))
#_create_default_analyzer_template
def cleanup(self):
pass
# end cleanup
def _get_proj_name_from_si_fq_str(self, si_fq_str):
return si_fq_str.split(':')[1]
# enf _get_si_fq_str_to_proj_name
def _get_virtualization_type(self, st_props):
return st_props.get_service_virtualization_type() or 'virtual-machine'
# end _get_virtualization_type
def _check_store_si_info(self, st_obj, si_obj):
config_complete = True
st_props = st_obj.get_service_template_properties()
st_if_list = st_props.get_interface_type()
si_props = si_obj.get_service_instance_properties()
si_if_list = si_props.get_interface_list()
# for lb relax the check because vip and pool could be in same net
if (st_props.get_service_type() != svc_info.get_lb_service_type()) \
and si_if_list and (len(si_if_list) != len(st_if_list)):
self.logger.log("Error: IF mismatch template %s instance %s" %
(len(st_if_list), len(si_if_list)))
return
# read existing si_entry
si_entry = self.db.service_instance_get(si_obj.get_fq_name_str())
if not si_entry:
si_entry = {}
si_entry['instance_type'] = self._get_virtualization_type(st_props)
si_entry['uuid'] = si_obj.uuid
# walk the interface list
for idx in range(0, len(st_if_list)):
st_if = st_if_list[idx]
itf_type = st_if.service_interface_type
si_if = None
if si_if_list and st_props.get_ordered_interfaces():
try:
si_if = si_if_list[idx]
except IndexError:
continue
si_vn_str = si_if.get_virtual_network()
else:
funcname = "get_" + itf_type + "_virtual_network"
func = getattr(si_props, funcname)
si_vn_str = func()
if not si_vn_str:
continue
si_entry[itf_type + '-vn'] = si_vn_str
try:
vn_obj = self._vnc_lib.virtual_network_read(
fq_name_str=si_vn_str)
if vn_obj.uuid != si_entry.get(si_vn_str, None):
si_entry[si_vn_str] = vn_obj.uuid
except NoIdError:
self.logger.log("Warn: VN %s add is pending" % si_vn_str)
si_entry[si_vn_str] = 'pending'
config_complete = False
if config_complete:
self.logger.log("SI %s info is complete" %
si_obj.get_fq_name_str())
si_entry['state'] = 'config_complete'
else:
self.logger.log("Warn: SI %s info is not complete" %
si_obj.get_fq_name_str())
si_entry['state'] = 'pending_config'
#insert entry
self.db.service_instance_insert(si_obj.get_fq_name_str(), si_entry)
return config_complete
#end _check_store_si_info
def _restart_svc(self, si_fq_str):
si_obj = self._vnc_lib.service_instance_read(fq_name_str=si_fq_str)
st_list = si_obj.get_service_template_refs()
if st_list is not None:
fq_name = st_list[0]['to']
st_obj = self._vnc_lib.service_template_read(fq_name=fq_name)
self._create_svc_instance(st_obj, si_obj)
# end _restart_svc
def _create_svc_instance(self, st_obj, si_obj):
#check if all config received before launch
if not self._check_store_si_info(st_obj, si_obj):
return
st_props = st_obj.get_service_template_properties()
if st_props is None:
self.logger.log("Cannot find service template associated to "
"service instance %s" % si_obj.get_fq_name_str())
virt_type = self._get_virtualization_type(st_props)
if virt_type == 'virtual-machine':
self.vm_manager.create_service(st_obj, si_obj)
elif virt_type == 'network-namespace':
self.netns_manager.create_service(st_obj, si_obj)
elif virt_type == 'vrouter-instance':
self.vrouter_manager.create_service(st_obj, si_obj)
else:
self.logger.log("Unkown virtualization type: %s" % virt_type)
def _delete_svc_instance(self,
vm_uuid,
proj_name,
si_fq_str=None,
virt_type=None):
self.logger.log("Deleting VM %s %s" % (proj_name, vm_uuid))
try:
if virt_type == svc_info.get_vm_instance_type():
self.vm_manager.delete_service(si_fq_str, vm_uuid, proj_name)
elif virt_type == svc_info.get_netns_instance_type():
self.netns_manager.delete_service(si_fq_str, vm_uuid)
elif virt_type == 'vrouter-instance':
self.vrouter_manager.delete_service(si_fq_str, vm_uuid)
except KeyError:
return True
# generate UVE
self.logger.uve_svc_instance(si_fq_str,
status='DELETE',
vms=[{
'uuid': vm_uuid
}])
return False
def _delete_shared_vn(self, vn_uuid, proj_name):
try:
self.logger.log("Deleting VN %s %s" % (proj_name, vn_uuid))
self._vnc_lib.virtual_network_delete(id=vn_uuid)
except RefsExistError:
pass
except NoIdError:
self.logger.log("Deleted VN %s %s" % (proj_name, vn_uuid))
return True
return False
def _cleanup_si(self, si_fq_str):
si_info = self.db.service_instance_get(si_fq_str)
if not si_info:
return
cleaned_up = True
state = {}
state['state'] = 'deleting'
self.db.service_instance_insert(si_fq_str, state)
proj_name = self._get_proj_name_from_si_fq_str(si_fq_str)
for idx in range(0, int(si_info.get('max-instances', '0'))):
prefix = self.db.get_vm_db_prefix(idx)
vm_key = prefix + 'uuid'
if vm_key in si_info.keys():
if not self._delete_svc_instance(
si_info[vm_key],
proj_name,
si_fq_str=si_fq_str,
virt_type=si_info['instance_type']):
cleaned_up = False
if cleaned_up:
vn_name = 'snat-si-left_%s' % si_fq_str.split(':')[-1]
if vn_name in si_info.keys():
if not self._delete_shared_vn(si_info[vn_name], proj_name):
cleaned_up = False
if cleaned_up:
for vn_name in svc_info.get_shared_vn_list():
if vn_name in si_info.keys():
self._delete_shared_vn(si_info[vn_name], proj_name)
self.db.service_instance_remove(si_fq_str)
def _check_si_status(self, si_fq_name_str, si_info):
try:
si_obj = self._vnc_lib.service_instance_read(id=si_info['uuid'])
except NoIdError:
# cleanup service instance
return 'DELETE'
# check status only if service is active
if si_info['state'] != 'active':
return ''
if si_info['instance_type'] == 'virtual-machine':
proj_name = self._get_proj_name_from_si_fq_str(si_fq_name_str)
status = self.vm_manager.check_service(si_obj, proj_name)
elif si_info['instance_type'] == 'network-namespace':
status = self.netns_manager.check_service(si_obj)
elif si_info['instance_type'] == 'vrouter-instance':
status = self.vrouter_manager.check_service(si_obj)
return status
def _delmsg_virtual_machine_service_instance(self, idents):
vm_fq_str = idents['virtual-machine']
si_fq_str = idents['service-instance']
self.db.remove_vm_info(si_fq_str, vm_fq_str)
def _delmsg_virtual_machine_interface_virtual_network(self, idents):
vmi_fq_str = idents['virtual-machine-interface']
vn_fq_str = idents['virtual-network']
vn_fq_name = vn_fq_str.split(':')
for vn_name in svc_info.get_shared_vn_list():
if vn_name != vn_fq_name[2]:
continue
try:
vn_id = self._vnc_lib.fq_name_to_id('virtual-network',
vn_fq_name)
except NoIdError:
continue
self._delete_shared_vn(vn_id, vn_fq_name[1])
def _delmsg_service_instance_service_template(self, idents):
self._cleanup_si(idents['service-instance'])
def _delmsg_virtual_machine_interface_route_table(self, idents):
rt_fq_str = idents['interface-route-table']
try:
rt_obj = self._vnc_lib.interface_route_table_read(
fq_name_str=rt_fq_str)
except NoIdError:
return
try:
vmi_list = rt_obj.get_virtual_machine_interface_back_refs()
if vmi_list is None:
self._vnc_lib.interface_route_table_delete(id=rt_obj.uuid)
except NoIdError:
return
def _addmsg_service_instance_service_template(self, idents):
st_fq_str = idents['service-template']
si_fq_str = idents['service-instance']
try:
st_obj = self._vnc_lib.service_template_read(fq_name_str=st_fq_str)
si_obj = self._vnc_lib.service_instance_read(fq_name_str=si_fq_str)
except NoIdError:
self.logger.log(
"No template or service instance with ids: %s, %s" %
(st_fq_str, si_fq_str))
return
#launch VMs
self._create_svc_instance(st_obj, si_obj)
# end _addmsg_service_instance_service_template
def _addmsg_service_instance_properties(self, idents):
si_fq_str = idents['service-instance']
try:
si_obj = self._vnc_lib.service_instance_read(fq_name_str=si_fq_str)
except NoIdError:
return
#update static routes
self.vm_manager.update_static_routes(si_obj)
def _addmsg_project_virtual_network(self, idents):
vn_fq_str = idents['virtual-network']
si_list = self.db.service_instance_list()
if not si_list:
return
for si_fq_str, si_info in si_list:
if vn_fq_str not in si_info.keys():
continue
try:
si_obj = self._vnc_lib.service_instance_read(
fq_name_str=si_fq_str)
if si_obj.get_virtual_machine_back_refs():
continue
st_refs = si_obj.get_service_template_refs()
fq_name = st_refs[0]['to']
st_obj = self._vnc_lib.service_template_read(fq_name=fq_name)
#launch VMs
self._create_svc_instance(st_obj, si_obj)
except Exception:
continue
def _addmsg_floating_ip_virtual_machine_interface(self, idents):
fip_fq_str = idents['floating-ip']
vmi_fq_str = idents['virtual-machine-interface']
try:
fip_obj = self._vnc_lib.floating_ip_read(fq_name_str=fip_fq_str)
vmi_obj = self._vnc_lib.virtual_machine_interface_read(
fq_name_str=vmi_fq_str)
except NoIdError:
return
# handle only if VIP back ref exists
vip_back_refs = vmi_obj.get_virtual_ip_back_refs()
if vip_back_refs is None:
return
# associate fip to all VMIs
iip_back_refs = vmi_obj.get_instance_ip_back_refs()
try:
iip_obj = self._vnc_lib.instance_ip_read(
id=iip_back_refs[0]['uuid'])
except NoIdError:
return
fip_updated = False
vmi_refs_iip = iip_obj.get_virtual_machine_interface_refs()
vmi_refs_fip = fip_obj.get_virtual_machine_interface_refs()
for vmi_ref_iip in vmi_refs_iip:
if vmi_ref_iip in vmi_refs_fip:
continue
try:
vmi_obj = self._vnc_lib.virtual_machine_interface_read(
id=vmi_ref_iip['uuid'])
except NoIdError:
continue
fip_obj.add_virtual_machine_interface(vmi_obj)
fip_updated = True
if fip_updated:
self._vnc_lib.floating_ip_update(fip_obj)
def process_poll_result(self, poll_result_str):
result_list = parse_poll_result(poll_result_str)
# process ifmap message
for (result_type, idents, metas) in result_list:
if 'ERROR' in idents.values():
continue
for meta in metas:
meta_name = re.sub('{.*}', '', meta.tag)
if result_type == 'deleteResult':
funcname = "_delmsg_" + meta_name.replace('-', '_')
elif result_type in ['searchResult', 'updateResult']:
funcname = "_addmsg_" + meta_name.replace('-', '_')
# end if result_type
try:
func = getattr(self, funcname)
except AttributeError:
pass
else:
self.logger.log("%s with %s/%s" %
(funcname, meta_name, idents))
func(idents)
class SvcMonitor(object):
"""
data + methods used/referred to by ssrc and arc greenlets
"""
_REACTION_MAP = {
"loadbalancer_pool": {
'self': [],
'virtual_ip': [],
'loadbalancer_member': [],
'loadbalancer_healthmonitor': [],
},
"loadbalancer_member": {
'self': ['loadbalancer_pool'],
'loadbalancer_pool': []
},
"virtual_ip": {
'self': ['loadbalancer_pool'],
'loadbalancer_pool': []
},
"loadbalancer_healthmonitor": {
'self': ['loadbalancer_pool'],
'loadbalancer_pool': []
},
"service_instance": {
'self': ['virtual_machine'],
'virtual_machine': []
},
"instance_ip": {
'self': [],
},
"service_template": {
'self': [],
},
"physical_router": {
'self': [],
},
"physical_interface": {
'self': [],
},
"logical_interface": {
'self': [],
},
"virtual_network": {
'self': [],
},
"virtual_machine": {
'self': ['virtual_machine_interface'],
'service_instance': [],
'virtual_machine_interface': [],
},
"virtual_machine_interface": {
'self': ['interface_route_table', 'virtual_machine'],
'interface_route_table': [],
'virtual_machine': [],
},
"interface_route_table": {
'self': [],
'virtual_machine_interface': [],
},
"project": {
'self': [],
},
}
def __init__(self, args=None):
self._args = args
# create database and logger
self.db = ServiceMonitorDB(args)
# initialize discovery client
self._disc = None
if self._args.disc_server_ip and self._args.disc_server_port:
self._disc = client.DiscoveryClient(self._args.disc_server_ip,
self._args.disc_server_port,
ModuleNames[Module.SVC_MONITOR])
# initialize logger
self.logger = ServiceMonitorLogger(self.db, self._disc, args)
self.db.add_logger(self.logger)
self.db.init_database()
# rotating log file for catchall errors
self._err_file = self._args.trace_file
self._svc_err_logger = logging.getLogger('SvcErrLogger')
self._svc_err_logger.setLevel(logging.ERROR)
try:
with open(self._err_file, 'a'):
handler = logging.handlers.RotatingFileHandler(
self._err_file, maxBytes=64*1024, backupCount=2)
self._svc_err_logger.addHandler(handler)
except IOError:
self.logger.log_warning("Failed to open trace file %s" %
self._err_file)
# Connect to Rabbit and Initialize cassandra connection
self._connect_rabbit()
def _connect_rabbit(self):
rabbit_server = self._args.rabbit_server
rabbit_port = self._args.rabbit_port
rabbit_user = self._args.rabbit_user
rabbit_password = self._args.rabbit_password
rabbit_vhost = self._args.rabbit_vhost
rabbit_ha_mode = self._args.rabbit_ha_mode
self._db_resync_done = gevent.event.Event()
q_name = 'svc_mon.%s' % (socket.gethostname())
self._vnc_kombu = VncKombuClient(rabbit_server, rabbit_port,
rabbit_user, rabbit_password,
rabbit_vhost, rabbit_ha_mode,
q_name, self._vnc_subscribe_callback,
self.config_log)
cass_server_list = self._args.cassandra_server_list
reset_config = self._args.reset_config
self._cassandra = VncCassandraClient(cass_server_list, reset_config,
self._args.cluster_id, None,
self.config_log)
DBBase.init(self, self.logger, self._cassandra)
# end _connect_rabbit
def config_log(self, msg, level):
self.logger.log(msg)
def _vnc_subscribe_callback(self, oper_info):
self._db_resync_done.wait()
try:
msg = "Notification Message: %s" % (pformat(oper_info))
self.config_log(msg, level=SandeshLevel.SYS_DEBUG)
obj_type = oper_info['type'].replace('-', '_')
obj_class = DBBase._OBJ_TYPE_MAP.get(obj_type)
if obj_class is None:
return
if oper_info['oper'] == 'CREATE' or oper_info['oper'] == 'UPDATE':
dependency_tracker = DependencyTracker(DBBase._OBJ_TYPE_MAP,
self._REACTION_MAP)
obj_id = oper_info['uuid']
obj = obj_class.get(obj_id)
if obj is not None:
dependency_tracker.evaluate(obj_type, obj)
else:
obj = obj_class.locate(obj_id)
obj.update()
dependency_tracker.evaluate(obj_type, obj)
elif oper_info['oper'] == 'DELETE':
obj_id = oper_info['uuid']
obj = obj_class.get(obj_id)
if obj is None:
return
dependency_tracker = DependencyTracker(DBBase._OBJ_TYPE_MAP,
self._REACTION_MAP)
dependency_tracker.evaluate(obj_type, obj)
obj_class.delete(obj_id)
else:
# unknown operation
self.config_log('Unknown operation %s' % oper_info['oper'],
level=SandeshLevel.SYS_ERR)
return
if obj is None:
self.config_log('Error while accessing %s uuid %s' % (
obj_type, obj_id))
return
except Exception:
string_buf = cStringIO.StringIO()
cgitb.Hook(file=string_buf, format="text").handle(sys.exc_info())
self.config_log(string_buf.getvalue(), level=SandeshLevel.SYS_ERR)
for sas_id in dependency_tracker.resources.get('service_appliance_set', []):
sas_obj = ServiceApplianceSetSM.get(sas_id)
if sas_obj is not None:
sas_obj.add()
for lb_pool_id in dependency_tracker.resources.get('loadbalancer_pool', []):
lb_pool = LoadbalancerPoolSM.get(lb_pool_id)
if lb_pool is not None:
lb_pool.add()
# end _vnc_subscribe_callback
for si_id in dependency_tracker.resources.get('service_instance', []):
si = ServiceInstanceSM.get(si_id)
if si:
self._create_service_instance(si)
else:
for vm_id in dependency_tracker.resources.get(
'virtual_machine', []):
vm = VirtualMachineSM.get(vm_id)
self._delete_service_instance(vm)
for vn_id in dependency_tracker.resources.get('virtual_network', []):
vn = VirtualNetworkSM.get(vn_id)
if vn:
for si_id in ServiceInstanceSM:
si = ServiceInstanceSM.get(si_id)
if (':').join(vn.fq_name) in si.params.values():
self._create_service_instance(si)
for vmi_id in dependency_tracker.resources.get('virtual_machine_interface', []):
vmi = VirtualMachineInterfaceSM.get(vmi_id)
if vmi:
for vm_id in dependency_tracker.resources.get(
'virtual_machine', []):
vm = VirtualMachineSM.get(vm_id)
if vm:
self.check_link_si_to_vm(vm, vmi)
else:
for irt_id in dependency_tracker.resources.get(
'interface_route_table', []):
self._delete_interface_route_table(irt_id)
def post_init(self, vnc_lib, args=None):
# api server
self._vnc_lib = vnc_lib
self._nova_client = importutils.import_object(
'svc_monitor.nova_client.ServiceMonitorNovaClient',
self._args, self.logger)
# load vrouter scheduler
self.vrouter_scheduler = importutils.import_object(
self._args.si_netns_scheduler_driver,
self._vnc_lib, self._nova_client,
self._args)
# load virtual machine instance manager
self.vm_manager = importutils.import_object(
'svc_monitor.virtual_machine_manager.VirtualMachineManager',
self._vnc_lib, self.db, self.logger,
self.vrouter_scheduler, self._nova_client, self._args)
# load network namespace instance manager
self.netns_manager = importutils.import_object(
'svc_monitor.instance_manager.NetworkNamespaceManager',
self._vnc_lib, self.db, self.logger,
self.vrouter_scheduler, self._nova_client, self._args)
# load a vrouter instance manager
self.vrouter_manager = importutils.import_object(
'svc_monitor.vrouter_instance_manager.VRouterInstanceManager',
self._vnc_lib, self.db, self.logger,
self.vrouter_scheduler, self._nova_client, self._args)
# load a loadbalancer agent
self.loadbalancer_agent = LoadbalancerAgent(self, self._vnc_lib, self._args)
# Read the cassandra and populate the entry in ServiceMonitor DB
self.sync_sm()
# create default analyzer template
self._create_default_template('analyzer-template', 'analyzer',
flavor='m1.medium',
image_name='analyzer')
# create default NAT template
self._create_default_template('nat-template', 'firewall',
svc_mode='in-network-nat',
image_name='analyzer',
flavor='m1.medium')
# create default netns SNAT template
self._create_default_template('netns-snat-template', 'source-nat',
svc_mode='in-network-nat',
hypervisor_type='network-namespace',
scaling=True)
# create default loadbalancer template
self._create_default_template('haproxy-loadbalancer-template', 'loadbalancer',
svc_mode='in-network-nat',
hypervisor_type='network-namespace',
scaling=True)
self._create_default_template('docker-template', 'firewall',
svc_mode='transparent',
image_name="ubuntu",
hypervisor_type='vrouter-instance',
vrouter_instance_type='docker',
instance_data={
"command": "/bin/bash"
})
# upgrade handling
self.upgrade()
# check services
self.launch_services()
def upgrade(self):
for si in ServiceInstanceSM.values():
st = ServiceTemplateSM.get(si.service_template)
if not st:
continue
for vm_id in si.virtual_machines:
vm = VirtualMachineSM.get(vm_id)
if vm.virtualization_type:
continue
nova_vm = self._nova_client.oper('servers', 'get',
si.proj_name, id=vm_id)
if not nova_vm:
continue
si_obj = ServiceInstance()
si_obj.name = si.name
si_obj.fq_name = si.fq_name
instance_name = self.vm_manager._get_instance_name(
si_obj, vm.index)
if vm.name == instance_name:
continue
nova_vm.update(name=instance_name)
vm_obj = VirtualMachine()
vm_obj.uuid = vm_id
vm_obj.fq_name = [vm_id]
vm_obj.set_display_name(instance_name + '__' +
st.virtualization_type)
try:
self._vnc_lib.virtual_machine_update(vm_obj)
except Exception:
pass
def launch_services(self):
for si in ServiceInstanceSM.values():
self._create_service_instance(si)
def sync_sm(self):
vn_set = set()
vmi_set = set()
iip_set = set()
ok, lb_pool_list = self._cassandra._cassandra_loadbalancer_pool_list()
if not ok:
pass
else:
for fq_name, uuid in lb_pool_list:
lb_pool = LoadbalancerPoolSM.locate(uuid)
if lb_pool.virtual_machine_interface:
vmi_set.add(lb_pool.virtual_machine_interface)
ok, lb_pool_member_list = self._cassandra._cassandra_loadbalancer_member_list()
if not ok:
pass
else:
for fq_name, uuid in lb_pool_member_list:
lb_pool_member = LoadbalancerMemberSM.locate(uuid)
ok, lb_vip_list = self._cassandra._cassandra_virtual_ip_list()
if not ok:
pass
else:
for fq_name, uuid in lb_vip_list:
virtual_ip = VirtualIpSM.locate(uuid)
if virtual_ip.virtual_machine_interface:
vmi_set.add(virtual_ip.virtual_machine_interface)
ok, lb_hm_list = self._cassandra._cassandra_loadbalancer_healthmonitor_list()
if not ok:
pass
else:
for fq_name, uuid in lb_hm_list:
lb_hm = HealthMonitorSM.locate(uuid)
ok, si_list = self._cassandra._cassandra_service_instance_list()
if not ok:
pass
else:
for fq_name, uuid in si_list:
si = ServiceInstanceSM.locate(uuid)
ok, st_list = self._cassandra._cassandra_service_template_list()
if not ok:
pass
else:
for fq_name, uuid in st_list:
st = ServiceTemplateSM.locate(uuid)
ok, vn_list = self._cassandra._cassandra_virtual_network_list()
if not ok:
pass
else:
for fq_name, uuid in vn_list:
vn = VirtualNetworkSM.locate(uuid)
vmi_set |= vn.virtual_machine_interfaces
ok, ifd_list = self._cassandra._cassandra_physical_interface_list()
if not ok:
pass
else:
for fq_name, uuid in ifd_list:
ifd = PhysicalInterfaceSM.locate(uuid)
ok, ifl_list = self._cassandra._cassandra_logical_interface_list()
if not ok:
pass
else:
for fq_name, uuid in ifl_list:
ifl = LogicalInterfaceSM.locate(uuid)
if ifl.virtual_machine_interface:
vmi_set.add(ifl.virtual_machine_interface)
ok, pr_list = self._cassandra._cassandra_physical_router_list()
if not ok:
pass
else:
for fq_name, uuid in pr_list:
pr = PhysicalRouterSM.locate(uuid)
ok, vr_list = self._cassandra._cassandra_virtual_router_list()
if not ok:
pass
else:
for fq_name, uuid in vr_list:
vr = VirtualRouterSM.locate(uuid)
ok, vmi_list = self._cassandra._cassandra_virtual_machine_interface_list()
if not ok:
pass
else:
for fq_name, uuid in vmi_list:
vmi = VirtualMachineInterfaceSM.locate(uuid)
if vmi.instance_ip:
iip_set.add(vmi.instance_ip)
ok, irt_list = self._cassandra._cassandra_interface_route_table_list()
if not ok:
pass
else:
for fq_name, uuid in irt_list:
irt = InterfaceRouteTableSM.locate(uuid)
ok, project_list = self._cassandra._cassandra_project_list()
if not ok:
pass
else:
for fq_name, uuid in project_list:
prj = ProjectSM.locate(uuid)
ok, sas_list = self._cassandra._cassandra_service_appliance_set_list()
if not ok:
pass
else:
for fq_name, uuid in sas_list:
sas = ServiceApplianceSetSM.locate(uuid)
ok, sa_list = self._cassandra._cassandra_service_appliance_list()
if not ok:
pass
else:
for fq_name, uuid in sa_list:
sa = ServiceApplianceSM.locate(uuid)
ok, domain_list = self._cassandra._cassandra_domain_list()
if not ok:
pass
else:
for fq_name, uuid in domain_list:
DomainSM.locate(uuid)
ok, iip_list = self._cassandra._cassandra_instance_ip_list()
if not ok:
pass
else:
for fq_name, uuid in iip_list:
InstanceIpSM.locate(uuid)
ok, sg_list = self._cassandra._cassandra_security_group_list()
if not ok:
pass
else:
for fq_name, uuid in sg_list:
SecurityGroupSM.locate(uuid)
ok, vm_list = self._cassandra._cassandra_virtual_machine_list()
if not ok:
pass
else:
for fq_name, uuid in vm_list:
vm = VirtualMachineSM.locate(uuid)
if vm.service_instance:
continue
for vmi_id in vm.virtual_machine_interfaces:
vmi = VirtualMachineInterfaceSM.get(vmi_id)
if not vmi:
continue
self.check_link_si_to_vm(vm, vmi)
# Load the loadbalancer driver
self.loadbalancer_agent.load_drivers()
for lb_pool in LoadbalancerPoolSM.values():
lb_pool.add()
self._db_resync_done.set()
# end sync_sm
# create service template
def _create_default_template(self, st_name, svc_type, svc_mode=None,
hypervisor_type='virtual-machine',
image_name=None, flavor=None, scaling=False,
vrouter_instance_type=None,
instance_data=None):
domain_name = 'default-domain'
domain_fq_name = [domain_name]
st_fq_name = [domain_name, st_name]
self.logger.log_info("Creating %s %s hypervisor %s" %
(domain_name, st_name, hypervisor_type))
domain_obj = None
for domain in DomainSM.values():
if domain.fq_name == domain_fq_name:
domain_obj = Domain()
domain_obj.uuid = domain.uuid
domain_obj.fq_name = domain_fq_name
break
if not domain_obj:
self.logger.log_error("%s domain not found" % (domain_name))
return
for st in ServiceTemplateSM.values():
if st.fq_name == st_fq_name:
self.logger.log_info("%s exists uuid %s" %
(st.name, str(st.uuid)))
return
st_obj = ServiceTemplate(name=st_name, domain_obj=domain)
st_uuid = self._vnc_lib.service_template_create(st_obj)
svc_properties = ServiceTemplateType()
svc_properties.set_service_type(svc_type)
svc_properties.set_service_mode(svc_mode)
svc_properties.set_service_virtualization_type(hypervisor_type)
svc_properties.set_image_name(image_name)
svc_properties.set_flavor(flavor)
svc_properties.set_ordered_interfaces(True)
svc_properties.set_service_scaling(scaling)
# set interface list
if svc_type == 'analyzer':
if_list = [['left', False]]
elif hypervisor_type == 'network-namespace':
if_list = [['right', True], ['left', True]]
else:
if_list = [
['management', False], ['left', False], ['right', False]]
for itf in if_list:
if_type = ServiceTemplateInterfaceType(shared_ip=itf[1])
if_type.set_service_interface_type(itf[0])
svc_properties.add_interface_type(if_type)
if vrouter_instance_type is not None:
svc_properties.set_vrouter_instance_type(vrouter_instance_type)
if instance_data is not None:
svc_properties.set_instance_data(
json.dumps(instance_data, separators=(',', ':')))
try:
st_obj.set_service_template_properties(svc_properties)
self._vnc_lib.service_template_update(st_obj)
except Exception as e:
print e
self.logger.log_info("%s created with uuid %s" %
(st_name, str(st_uuid)))
#_create_default_analyzer_template
def check_link_si_to_vm(self, vm, vmi):
if vm.service_instance:
return
if not vmi.if_type:
return
si_fq_name = vmi.name.split('__')[0:3]
index = int(vmi.name.split('__')[3]) - 1
for si in ServiceInstanceSM.values():
if si.fq_name != si_fq_name:
continue
st = ServiceTemplateSM.get(si.service_template)
self.vm_manager.link_si_to_vm(si, st, index, vm.uuid)
return
def _create_service_instance(self, si):
if si.state == 'active':
return
st = ServiceTemplateSM.get(si.service_template)
if st.virtualization_type == 'virtual-machine':
self.vm_manager.create_service(st, si)
elif st.virtualization_type == 'network-namespace':
self.netns_manager.create_service(st, si)
elif st.virtualization_type == 'vrouter-instance':
self.vrouter_manager.create_service(st, si)
else:
self.logger.log_error("Unknown virt type: %s" %
st.virtualization_type)
def _delete_service_instance(self, vm):
self.logger.log_info("Deleting VM %s %s" %
((':').join(vm.proj_fq_name), vm.uuid))
if vm.virtualization_type == svc_info.get_vm_instance_type():
self.vm_manager.delete_service(vm)
elif vm.virtualization_type == svc_info.get_netns_instance_type():
self.netns_manager.delete_service(vm)
elif vm.virtualization_type == 'vrouter-instance':
self.vrouter_manager.delete_service(vm)
# generate UVE
si_fq_name = vm.display_name.split('__')[:-2]
si_fq_str = (':').join(si_fq_name)
self.logger.uve_svc_instance(si_fq_str, status='DELETE',
vms=[{'uuid': vm.uuid}])
return True
def _relaunch_service_instance(self, si):
if si.state == 'active':
si.state = 'relaunch'
self._create_service_instance(si)
def _check_service_running(self, si):
if si.state != 'active':
return
st = ServiceTemplateSM.get(si.service_template)
if st.virtualization_type == 'virtual-machine':
status = self.vm_manager.check_service(si)
elif st.virtualization_type == 'network-namespace':
status = self.netns_manager.check_service(si)
elif st.virtualization_type == 'vrouter-instance':
status = self.vrouter_manager.check_service(si)
return status
def _delete_interface_route_table(self, irt_uuid):
try:
self._vnc_lib.interface_route_table_delete(id=irt_uuid)
except (NoIdError, RefsExistError):
return
def _delete_shared_vn(self, vn_uuid):
try:
self.logger.log_info("Deleting vn %s" % (vn_uuid))
self._vnc_lib.virtual_network_delete(id=vn_uuid)
except (NoIdError, RefsExistError):
pass
class SvcMonitor(object):
"""
data + methods used/referred to by ssrc and arc greenlets
"""
def __init__(self, args=None):
self._args = args
# create database and logger
self.db = ServiceMonitorDB(args)
# initialize discovery client
self._disc = None
if self._args.disc_server_ip and self._args.disc_server_port:
self._disc = client.DiscoveryClient(
self._args.disc_server_ip, self._args.disc_server_port, client_type="Service Monitor"
)
# initialize logger
self.logger = ServiceMonitorLogger(self.db, self._disc, args)
self.db.add_logger(self.logger)
# rotating log file for catchall errors
self._err_file = "/var/log/contrail/svc-monitor.err"
self._tmp_file = "/var/log/contrail/svc-monitor.tmp"
try:
with open(self._err_file, "a"):
pass
with open(self._tmp_file, "a"):
pass
except IOError:
self._err_file = "./svc-monitor.err"
self._tmp_file = "./svc-monitor.tmp"
self._svc_err_logger = logging.getLogger("SvcErrLogger")
self._svc_err_logger.setLevel(logging.ERROR)
handler = logging.handlers.RotatingFileHandler(self._err_file, maxBytes=64 * 1024, backupCount=2)
self._svc_err_logger.addHandler(handler)
def post_init(self, vnc_lib, args=None):
# api server
self._vnc_lib = vnc_lib
# create default analyzer template
self._create_default_template("analyzer-template", "analyzer", flavor="m1.medium", image_name="analyzer")
# create default NAT template
self._create_default_template(
"nat-template", "firewall", svc_mode="in-network-nat", image_name="analyzer", flavor="m1.medium"
)
# create default netns SNAT template
self._create_default_template(
"netns-snat-template",
"source-nat",
svc_mode="in-network-nat",
hypervisor_type="network-namespace",
scaling=True,
)
# create default loadbalancer template
self._create_default_template(
"haproxy-loadbalancer-template",
"loadbalancer",
svc_mode="in-network-nat",
hypervisor_type="network-namespace",
scaling=True,
)
# load vrouter scheduler
self.vrouter_scheduler = importutils.import_object(
self._args.si_netns_scheduler_driver, self._vnc_lib, self._args
)
# load virtual machine instance manager
self.vm_manager = importutils.import_object(
"svc_monitor.instance_manager.VirtualMachineManager",
self._vnc_lib,
self.db,
self.logger,
self.vrouter_scheduler,
self._args,
)
# load network namespace instance manager
self.netns_manager = importutils.import_object(
"svc_monitor.instance_manager.NetworkNamespaceManager",
self._vnc_lib,
self.db,
self.logger,
self.vrouter_scheduler,
self._args,
)
# create service template
def _create_default_template(
self,
st_name,
svc_type,
svc_mode=None,
hypervisor_type="virtual-machine",
image_name=None,
flavor=None,
scaling=False,
):
domain_name = "default-domain"
domain_fq_name = [domain_name]
st_fq_name = [domain_name, st_name]
self.logger.log("Creating %s %s hypervisor %s" % (domain_name, st_name, hypervisor_type))
try:
st_obj = self._vnc_lib.service_template_read(fq_name=st_fq_name)
st_uuid = st_obj.uuid
self.logger.log("%s exists uuid %s" % (st_name, str(st_uuid)))
return
except NoIdError:
domain = self._vnc_lib.domain_read(fq_name=domain_fq_name)
st_obj = ServiceTemplate(name=st_name, domain_obj=domain)
st_uuid = self._vnc_lib.service_template_create(st_obj)
svc_properties = ServiceTemplateType()
svc_properties.set_service_type(svc_type)
svc_properties.set_service_mode(svc_mode)
svc_properties.set_service_virtualization_type(hypervisor_type)
svc_properties.set_image_name(image_name)
svc_properties.set_flavor(flavor)
svc_properties.set_ordered_interfaces(True)
svc_properties.set_service_scaling(scaling)
# set interface list
if svc_type == "analyzer":
if_list = [["left", False]]
elif hypervisor_type == "network-namespace":
if_list = [["right", True], ["left", True]]
else:
if_list = [["management", False], ["left", False], ["right", False]]
for itf in if_list:
if_type = ServiceTemplateInterfaceType(shared_ip=itf[1])
if_type.set_service_interface_type(itf[0])
svc_properties.add_interface_type(if_type)
try:
st_obj.set_service_template_properties(svc_properties)
self._vnc_lib.service_template_update(st_obj)
except Exception as e:
print e
self.logger.log("%s created with uuid %s" % (st_name, str(st_uuid)))
# _create_default_analyzer_template
def cleanup(self):
# TODO cleanup sandesh context
pass
# end cleanup
def _get_proj_name_from_si_fq_str(self, si_fq_str):
return si_fq_str.split(":")[1]
# enf _get_si_fq_str_to_proj_name
def _get_virtualization_type(self, st_props):
return st_props.get_service_virtualization_type() or "virtual-machine"
# end _get_virtualization_type
def _check_store_si_info(self, st_obj, si_obj):
config_complete = True
st_props = st_obj.get_service_template_properties()
st_if_list = st_props.get_interface_type()
si_props = si_obj.get_service_instance_properties()
si_if_list = si_props.get_interface_list()
# for lb relax the check because vip and pool could be in same net
if (
(st_props.get_service_type() != svc_info.get_lb_service_type())
and si_if_list
and (len(si_if_list) != len(st_if_list))
):
self.logger.log("Error: IF mismatch template %s instance %s" % (len(st_if_list), len(si_if_list)))
return
# read existing si_entry
si_entry = self.db.service_instance_get(si_obj.get_fq_name_str())
if not si_entry:
si_entry = {}
si_entry["instance_type"] = self._get_virtualization_type(st_props)
si_entry["uuid"] = si_obj.uuid
# walk the interface list
for idx in range(0, len(st_if_list)):
st_if = st_if_list[idx]
itf_type = st_if.service_interface_type
si_if = None
if si_if_list and st_props.get_ordered_interfaces():
try:
si_if = si_if_list[idx]
except IndexError:
continue
si_vn_str = si_if.get_virtual_network()
else:
funcname = "get_" + itf_type + "_virtual_network"
func = getattr(si_props, funcname)
si_vn_str = func()
if not si_vn_str:
continue
si_entry[itf_type + "-vn"] = si_vn_str
try:
vn_obj = self._vnc_lib.virtual_network_read(fq_name_str=si_vn_str)
if vn_obj.uuid != si_entry.get(si_vn_str, None):
si_entry[si_vn_str] = vn_obj.uuid
except NoIdError:
self.logger.log("Warn: VN %s add is pending" % si_vn_str)
si_entry[si_vn_str] = "pending"
config_complete = False
if config_complete:
self.logger.log("SI %s info is complete" % si_obj.get_fq_name_str())
else:
self.logger.log("Warn: SI %s info is not complete" % si_obj.get_fq_name_str())
# insert entry
self.db.service_instance_insert(si_obj.get_fq_name_str(), si_entry)
return config_complete
# end _check_store_si_info
def _restart_svc(self, si_fq_str):
si_obj = self._vnc_lib.service_instance_read(fq_name_str=si_fq_str)
st_list = si_obj.get_service_template_refs()
if st_list is not None:
fq_name = st_list[0]["to"]
st_obj = self._vnc_lib.service_template_read(fq_name=fq_name)
self._create_svc_instance(st_obj, si_obj)
# end _restart_svc
def _delete_shared_vn(self, vn_uuid, proj_name):
try:
self.logger.log("Deleting VN %s %s" % (proj_name, vn_uuid))
self._vnc_lib.virtual_network_delete(id=vn_uuid)
except RefsExistError:
self._svc_err_logger.error("Delete failed refs exist VN %s %s" % (proj_name, vn_uuid))
except NoIdError:
# remove from cleanup list
self.db.cleanup_table_remove(vn_uuid)
# end _delete_shared_vn
def _create_svc_instance(self, st_obj, si_obj):
# check if all config received before launch
if not self._check_store_si_info(st_obj, si_obj):
return
st_props = st_obj.get_service_template_properties()
if st_props is None:
self.logger.log(
"Cannot find service template associated to " "service instance %s" % si_obj.get_fq_name_str()
)
virt_type = self._get_virtualization_type(st_props)
if virt_type == "virtual-machine":
self.vm_manager.create_service(st_obj, si_obj)
elif virt_type == "network-namespace":
self.netns_manager.create_service(st_obj, si_obj)
def _delete_svc_instance(self, vm_uuid, proj_name, si_fq_str=None, virt_type=None):
self.logger.log("Deleting VM %s %s" % (proj_name, vm_uuid))
try:
if virt_type == svc_info.get_vm_instance_type():
self.vm_manager.delete_service(vm_uuid, proj_name)
elif virt_type == svc_info.get_netns_instance_type():
self.netns_manager.delete_service(vm_uuid)
except KeyError:
self.db.cleanup_table_remove(vm_uuid)
return
# remove from launch table and queue into cleanup list
self.db.virtual_machine_remove(vm_uuid)
self.db.cleanup_table_insert(vm_uuid, {"proj_name": proj_name, "type": virt_type})
self.logger.uve_svc_instance(si_fq_str, status="DELETE", vm_uuid=vm_uuid)
def _check_si_status(self, si_fq_name_str, si_info):
try:
si_obj = self._vnc_lib.service_instance_read(id=si_info["uuid"])
except NoIdError:
self.db.service_instance_remove(si_fq_name_str)
return "ACTIVE"
if si_info["instance_type"] == "virtual-machine":
proj_name = self._get_proj_name_from_si_fq_str(si_fq_name_str)
status = self.vm_manager.check_service(si_obj, proj_name)
elif si_info["instance_type"] == "network-namespace":
status = self.netns_manager.check_service(si_obj)
return status
def _check_vm_si_link(self, vm_uuid, si_info):
try:
vm_obj = self._vnc_lib.virtual_machine_read(id=vm_uuid)
except NoIdError:
return
si_fq_str = si_info["si_fq_str"]
si_refs = vm_obj.get_service_instance_refs()
if (si_refs is None) or (si_refs[0]["to"][0] == "ERROR"):
proj_name = self._get_proj_name_from_si_fq_str(si_fq_str)
self._delete_svc_instance(vm_uuid, proj_name, si_fq_str, si_info["instance_type"])
def _delmsg_project_service_instance(self, idents):
proj_fq_str = idents["project"]
si_fq_str = idents["service-instance"]
si_info = self.db.service_instance_get(si_fq_str)
if not si_info:
return
virt_type = si_info["instance_type"]
if virt_type == "virtual-machine":
self.vm_manager.clean_resources(proj_fq_str, si_fq_str)
elif virt_type == "network-namespace":
self.netns_manager.clean_resources(proj_fq_str, si_fq_str)
# delete si info
self.db.service_instance_remove(si_fq_str)
# end _delmsg_project_service_instance
def _delmsg_service_instance_service_template(self, idents):
si_fq_str = idents["service-instance"]
si_info = self.db.service_instance_get(si_fq_str)
if not si_info:
return
vm_list = self.db.virtual_machine_list()
for vm_uuid, si in vm_list:
if si_fq_str != si["si_fq_str"]:
continue
proj_name = self._get_proj_name_from_si_fq_str(si_fq_str)
self._delete_svc_instance(vm_uuid, proj_name, si_fq_str=si_fq_str, virt_type=si["instance_type"])
# insert shared instance IP uuids into cleanup list if present
for itf_str in svc_info.get_if_str_list():
iip_uuid_str = itf_str + "-iip-uuid"
if not iip_uuid_str in si_info:
continue
self.db.cleanup_table_insert(si_info[iip_uuid_str], {"proj_name": proj_name, "type": "iip"})
# delete si info
self.db.service_instance_remove(si_fq_str)
# end _delmsg_service_instance_service_template
def _delmsg_virtual_machine_service_instance(self, idents):
vm_uuid = idents["virtual-machine"]
si_fq_str = idents["service-instance"]
proj_name = self._get_proj_name_from_si_fq_str(si_fq_str)
vm_info = self.db.virtual_machine_get(vm_uuid)
if vm_info:
self._delete_svc_instance(
vm_uuid, proj_name, si_fq_str=vm_info["si_fq_str"], virt_type=vm_info["instance_type"]
)
return
# end _delmsg_service_instance_virtual_machine
def _delmsg_virtual_machine_interface_route_table(self, idents):
rt_fq_str = idents["interface-route-table"]
rt_obj = self._vnc_lib.interface_route_table_read(fq_name_str=rt_fq_str)
vmi_list = rt_obj.get_virtual_machine_interface_back_refs()
if vmi_list is None:
self._vnc_lib.interface_route_table_delete(id=rt_obj.uuid)
# end _delmsg_virtual_machine_interface_route_table
def _addmsg_virtual_machine_interface_virtual_machine(self, idents):
vm_fq_str = idents["virtual-machine"]
try:
vm_obj = self._vnc_lib.virtual_machine_read(fq_name_str=vm_fq_str)
except NoIdError:
return
# check if this is a service vm
si_list = vm_obj.get_service_instance_refs()
if si_list:
return
vm_info = self.db.virtual_machine_get(vm_obj.uuid)
if not vm_info:
return
si_fq_str = vm_info["si_fq_str"]
try:
si_obj = self._vnc_lib.service_instance_read(fq_name_str=si_fq_str)
except NoIdError:
proj_name = self._get_proj_name_from_si_fq_str(si_fq_str)
self._delete_svc_instance(vm_obj.uuid, proj_name, si_fq_str=si_fq_str, virt_type=vm_info["instance_type"])
return
# create service instance to service vm link
vm_obj.add_service_instance(si_obj)
self._vnc_lib.virtual_machine_update(vm_obj)
self.logger.log("Info: VM %s updated SI %s" % (vm_obj.get_fq_name_str(), si_fq_str))
# end _addmsg_virtual_machine_interface_virtual_machine
def _addmsg_service_instance_service_template(self, idents):
st_fq_str = idents["service-template"]
si_fq_str = idents["service-instance"]
try:
st_obj = self._vnc_lib.service_template_read(fq_name_str=st_fq_str)
si_obj = self._vnc_lib.service_instance_read(fq_name_str=si_fq_str)
except NoIdError:
return
# launch VMs
self._create_svc_instance(st_obj, si_obj)
# end _addmsg_service_instance_service_template
def _addmsg_service_instance_properties(self, idents):
si_fq_str = idents["service-instance"]
try:
si_obj = self._vnc_lib.service_instance_read(fq_name_str=si_fq_str)
except NoIdError:
return
# update static routes
self._update_static_routes(si_obj)
# end _addmsg_service_instance_service_template
def _addmsg_project_virtual_network(self, idents):
vn_fq_str = idents["virtual-network"]
si_list = self.db.service_instance_list()
if not si_list:
return
for si_fq_str, si_info in si_list:
if vn_fq_str not in si_info.keys():
continue
try:
si_obj = self._vnc_lib.service_instance_read(fq_name_str=si_fq_str)
if si_obj.get_virtual_machine_back_refs():
continue
st_refs = si_obj.get_service_template_refs()
fq_name = st_refs[0]["to"]
st_obj = self._vnc_lib.service_template_read(fq_name=fq_name)
# launch VMs
self._create_svc_instance(st_obj, si_obj)
except Exception:
continue
# end _addmsg_project_virtual_network
def _addmsg_floating_ip_virtual_machine_interface(self, idents):
fip_fq_str = idents["floating-ip"]
vmi_fq_str = idents["virtual-machine-interface"]
try:
fip_obj = self._vnc_lib.floating_ip_read(fq_name_str=fip_fq_str)
vmi_obj = self._vnc_lib.virtual_machine_interface_read(fq_name_str=vmi_fq_str)
except NoIdError:
return
# handle only if VIP back ref exists
vip_back_refs = vmi_obj.get_virtual_ip_back_refs()
if vip_back_refs is None:
return
# associate fip to all VMIs
iip_back_refs = vmi_obj.get_instance_ip_back_refs()
try:
iip_obj = self._vnc_lib.instance_ip_read(id=iip_back_refs[0]["uuid"])
except NoIdError:
return
fip_updated = False
vmi_refs_iip = iip_obj.get_virtual_machine_interface_refs()
vmi_refs_fip = fip_obj.get_virtual_machine_interface_refs()
for vmi_ref_iip in vmi_refs_iip:
if vmi_ref_iip in vmi_refs_fip:
continue
try:
vmi_obj = self._vnc_lib.virtual_machine_interface_read(id=vmi_ref_iip["uuid"])
except NoIdError:
continue
fip_obj.add_virtual_machine_interface(vmi_obj)
fip_updated = True
if fip_updated:
self._vnc_lib.floating_ip_update(fip_obj)
def process_poll_result(self, poll_result_str):
result_list = parse_poll_result(poll_result_str)
# process ifmap message
for (result_type, idents, metas) in result_list:
if "ERROR" in idents.values():
continue
for meta in metas:
meta_name = re.sub("{.*}", "", meta.tag)
if result_type == "deleteResult":
funcname = "_delmsg_" + meta_name.replace("-", "_")
elif result_type in ["searchResult", "updateResult"]:
funcname = "_addmsg_" + meta_name.replace("-", "_")
# end if result_type
try:
func = getattr(self, funcname)
except AttributeError:
pass
else:
self.logger.log("%s with %s/%s" % (funcname, meta_name, idents))
func(idents)
# end for meta
# end for result_type
# end process_poll_result
def _update_static_routes(self, si_obj):
# get service instance interface list
si_props = si_obj.get_service_instance_properties()
si_if_list = si_props.get_interface_list()
if not si_if_list:
return
for idx in range(0, len(si_if_list)):
si_if = si_if_list[idx]
static_routes = si_if.get_static_routes()
if not static_routes:
static_routes = {"route": []}
# update static routes
try:
domain_name, proj_name = si_obj.get_parent_fq_name()
rt_name = si_obj.uuid + " " + str(idx)
rt_fq_name = [domain_name, proj_name, rt_name]
rt_obj = self._vnc_lib.interface_route_table_read(fq_name=rt_fq_name)
rt_obj.set_interface_route_table_routes(static_routes)
self._vnc_lib.interface_route_table_update(rt_obj)
except NoIdError:
pass
class SvcMonitor(object):
"""
data + methods used/referred to by ssrc and arc greenlets
"""
def __init__(self, args=None):
self._args = args
# create database and logger
self.db = ServiceMonitorDB(args)
# initialize discovery client
self._disc = None
if self._args.disc_server_ip and self._args.disc_server_port:
self._disc = client.DiscoveryClient(self._args.disc_server_ip,
self._args.disc_server_port,
client_type='Service Monitor')
# initialize logger
self.logger = ServiceMonitorLogger(self.db, self._disc, args)
self.db.add_logger(self.logger)
# rotating log file for catchall errors
self._err_file = '/var/log/contrail/svc-monitor.err'
self._tmp_file = '/var/log/contrail/svc-monitor.tmp'
try:
with open(self._err_file, 'a'):
pass
with open(self._tmp_file, 'a'):
pass
except IOError:
self._err_file = './svc-monitor.err'
self._tmp_file = './svc-monitor.tmp'
self._svc_err_logger = logging.getLogger('SvcErrLogger')
self._svc_err_logger.setLevel(logging.ERROR)
handler = logging.handlers.RotatingFileHandler(
self._err_file, maxBytes=64*1024, backupCount=2)
self._svc_err_logger.addHandler(handler)
def post_init(self, vnc_lib, args=None):
# api server
self._vnc_lib = vnc_lib
# create default analyzer template
self._create_default_template('analyzer-template', 'analyzer',
flavor='m1.medium',
image_name='analyzer')
# create default NAT template
self._create_default_template('nat-template', 'firewall',
svc_mode='in-network-nat',
image_name='analyzer',
flavor='m1.medium')
# create default netns SNAT template
self._create_default_template('netns-snat-template', 'source-nat',
svc_mode='in-network-nat',
hypervisor_type='network-namespace',
scaling=True)
# create default loadbalancer template
self._create_default_template('haproxy-loadbalancer-template', 'loadbalancer',
image_name='in-network',
hypervisor_type='network-namespace',
scaling=True)
# load vrouter scheduler
self.vrouter_scheduler = importutils.import_object(
self._args.si_netns_scheduler_driver,
self._vnc_lib,
self._args)
# load virtual machine instance manager
self.vm_manager = importutils.import_object(
'svc_monitor.instance_manager.VirtualMachineManager',
self._vnc_lib, self.db, self.logger,
self.vrouter_scheduler, self._args)
# load network namespace instance manager
self.netns_manager = importutils.import_object(
'svc_monitor.instance_manager.NetworkNamespaceManager',
self._vnc_lib, self.db, self.logger,
self.vrouter_scheduler, self._args)
# create service template
def _create_default_template(self, st_name, svc_type, svc_mode=None,
hypervisor_type='virtual-machine',
image_name=None, flavor=None, scaling=False):
domain_name = 'default-domain'
domain_fq_name = [domain_name]
st_fq_name = [domain_name, st_name]
self.logger.log("Creating %s %s hypervisor %s" %
(domain_name, st_name, hypervisor_type))
try:
st_obj = self._vnc_lib.service_template_read(fq_name=st_fq_name)
st_uuid = st_obj.uuid
self.logger.log("%s exists uuid %s" % (st_name, str(st_uuid)))
return
except NoIdError:
domain = self._vnc_lib.domain_read(fq_name=domain_fq_name)
st_obj = ServiceTemplate(name=st_name, domain_obj=domain)
st_uuid = self._vnc_lib.service_template_create(st_obj)
svc_properties = ServiceTemplateType()
svc_properties.set_service_type(svc_type)
svc_properties.set_service_mode(svc_mode)
svc_properties.set_service_virtualization_type(hypervisor_type)
svc_properties.set_image_name(image_name)
svc_properties.set_flavor(flavor)
svc_properties.set_ordered_interfaces(True)
svc_properties.set_service_scaling(scaling)
# set interface list
if svc_type == 'analyzer':
if_list = [['left', False]]
elif hypervisor_type == 'network-namespace':
if_list = [['left', False], ['right', False]]
else:
if_list = [
['management', False], ['left', False], ['right', False]]
for itf in if_list:
if_type = ServiceTemplateInterfaceType(shared_ip=itf[1])
if_type.set_service_interface_type(itf[0])
svc_properties.add_interface_type(if_type)
try:
st_obj.set_service_template_properties(svc_properties)
self._vnc_lib.service_template_update(st_obj)
except Exception as e:
print e
self.logger.log("%s created with uuid %s" % (st_name, str(st_uuid)))
#_create_default_analyzer_template
def cleanup(self):
# TODO cleanup sandesh context
pass
# end cleanup
def _get_proj_name_from_si_fq_str(self, si_fq_str):
return si_fq_str.split(':')[1]
# enf _get_si_fq_str_to_proj_name
def _get_virtualization_type(self, st_props):
return st_props.get_service_virtualization_type() or 'virtual-machine'
# end _get_virtualization_type
def _check_svc_vm_exists(self, si_obj):
vm_back_refs = si_obj.get_virtual_machine_back_refs()
if not vm_back_refs:
return False
si_props = si_obj.get_service_instance_properties()
if si_props.get_scale_out():
max_instances = si_props.get_scale_out().get_max_instances()
else:
max_instances = 1
if max_instances == len(vm_back_refs):
return True
return False
#end _check_svc_vm_exists
def _check_store_si_info(self, st_obj, si_obj):
config_complete = True
st_props = st_obj.get_service_template_properties()
st_if_list = st_props.get_interface_type()
si_props = si_obj.get_service_instance_properties()
si_if_list = si_props.get_interface_list()
if si_if_list and (len(si_if_list) != len(st_if_list)):
self.logger.log("Error: IF mismatch template %s instance %s" %
(len(st_if_list), len(si_if_list)))
return
# read existing si_entry
si_entry = self.db.service_instance_get(si_obj.get_fq_name_str())
if not si_entry:
si_entry = {}
si_entry['instance_type'] = self._get_virtualization_type(st_props)
# walk the interface list
for idx in range(0, len(st_if_list)):
st_if = st_if_list[idx]
itf_type = st_if.service_interface_type
si_if = None
if si_if_list and st_props.get_ordered_interfaces():
si_if = si_if_list[idx]
si_vn_str = si_if.get_virtual_network()
else:
funcname = "get_" + itf_type + "_virtual_network"
func = getattr(si_props, funcname)
si_vn_str = func()
if not si_vn_str:
continue
si_entry[itf_type + '-vn'] = si_vn_str
try:
vn_obj = self._vnc_lib.virtual_network_read(
fq_name_str=si_vn_str)
if vn_obj.uuid != si_entry.get(si_vn_str, None):
si_entry[si_vn_str] = vn_obj.uuid
except NoIdError:
self.logger.log("Warn: VN %s add is pending" % si_vn_str)
si_entry[si_vn_str] = 'pending'
config_complete = False
if config_complete:
self.logger.log("SI %s info is complete" %
si_obj.get_fq_name_str())
else:
self.logger.log("Warn: SI %s info is not complete" %
si_obj.get_fq_name_str())
#insert entry
self.db.service_instance_insert(si_obj.get_fq_name_str(), si_entry)
return config_complete
#end _check_store_si_info
def _restart_svc(self, vm_uuid, si_fq_str):
proj_name = self._get_proj_name_from_si_fq_str(si_fq_str)
self._delete_svc_instance(vm_uuid, proj_name, si_fq_str=si_fq_str)
# Wait the clean phase was completely done before recreate the SI
gevent.sleep(_CHECK_CLEANUP_INTERVAL + 1)
si_obj = self._vnc_lib.service_instance_read(fq_name_str=si_fq_str)
st_list = si_obj.get_service_template_refs()
if st_list is not None:
fq_name = st_list[0]['to']
st_obj = self._vnc_lib.service_template_read(fq_name=fq_name)
self._create_svc_instance(st_obj, si_obj)
# end _restart_svc
def _delete_shared_vn(self, vn_uuid, proj_name):
try:
self.logger.log("Deleting VN %s %s" % (proj_name, vn_uuid))
self._vnc_lib.virtual_network_delete(id=vn_uuid)
except RefsExistError:
self._svc_err_logger.error("Delete failed refs exist VN %s %s" %
(proj_name, vn_uuid))
except NoIdError:
# remove from cleanup list
self.db.cleanup_table_remove(vn_uuid)
# end _delete_shared_vn
def _create_svc_instance(self, st_obj, si_obj):
#check if all config received before launch
if not self._check_store_si_info(st_obj, si_obj):
return
#check if VMs already exist
if self._check_svc_vm_exists(si_obj):
return
st_props = st_obj.get_service_template_properties()
if st_props is None:
self.logger.log("Cannot find service template associated to "
"service instance %s" % si_obj.get_fq_name_str())
virt_type = self._get_virtualization_type(st_props)
if virt_type == 'virtual-machine':
self.vm_manager.create_service(st_obj, si_obj)
elif virt_type == 'network-namespace':
self.netns_manager.create_service(st_obj, si_obj)
def _delete_svc_instance(self, vm_uuid, proj_name, si_fq_str=None):
vm_entry = self.db.virtual_machine_get(vm_uuid)
if not vm_entry:
self.db.cleanup_table_remove(vm_uuid)
return
self.logger.log("Deleting VM %s %s" % (proj_name, vm_uuid))
virt_type = vm_entry['instance_type']
if virt_type == 'virtual-machine':
self.vm_manager.delete_service(vm_uuid, proj_name)
elif virt_type == 'network-namespace':
self.netns_manager.delete_service(vm_uuid)
# remove from launch table and queue into cleanup list
self.db.virtual_machine_remove(vm_uuid)
self.db.cleanup_table_insert(
vm_uuid, {'proj_name': proj_name, 'type': 'vm'})
self.logger.uve_svc_instance(si_fq_str, status='DELETE', vm_uuid=vm_uuid)
def _delmsg_project_service_instance(self, idents):
proj_fq_str = idents['project']
si_fq_str = idents['service-instance']
si_info = self.db.service_instance_get(si_fq_str)
if not si_info:
return
virt_type = si_info['instance_type']
if virt_type == 'virtual-machine':
self.vm_manager.clean_resources(proj_fq_str, si_fq_str)
elif virt_type == 'network-namespace':
self.netns_manager.clean_resources(proj_fq_str, si_fq_str)
#delete si info
self.db.service_instance_remove(si_fq_str)
# end _delmsg_project_service_instance
def _delmsg_service_instance_service_template(self, idents):
si_fq_str = idents['service-instance']
si_info = self.db.service_instance_get(si_fq_str)
if not si_info:
return
vm_list = self.db.virtual_machine_list()
for vm_uuid, si in vm_list:
if si_fq_str != si['si_fq_str']:
continue
proj_name = self._get_proj_name_from_si_fq_str(si_fq_str)
self._delete_svc_instance(vm_uuid, proj_name, si_fq_str=si_fq_str)
#insert shared instance IP uuids into cleanup list if present
for itf_str in svc_info.get_if_str_list():
iip_uuid_str = itf_str + '-iip-uuid'
if not iip_uuid_str in si_info:
continue
self.db.cleanup_table_insert(
si_info[iip_uuid_str], {'proj_name': proj_name,
'type': 'iip'})
#end _delmsg_service_instance_service_template
def _delmsg_virtual_machine_service_instance(self, idents):
vm_uuid = idents['virtual-machine']
si_fq_str = idents['service-instance']
proj_name = self._get_proj_name_from_si_fq_str(si_fq_str)
vm_list = self.db.virtual_machine_list()
for vm_uuid, si in vm_list:
if si_fq_str != si['si_fq_str']:
continue
self._delete_svc_instance(vm_uuid, proj_name, si_fq_str=si_fq_str)
# end _delmsg_service_instance_virtual_machine
def _delmsg_virtual_machine_interface_route_table(self, idents):
rt_fq_str = idents['interface-route-table']
rt_obj = self._vnc_lib.interface_route_table_read(
fq_name_str=rt_fq_str)
vmi_list = rt_obj.get_virtual_machine_interface_back_refs()
if vmi_list is None:
self._vnc_lib.interface_route_table_delete(id=rt_obj.uuid)
# end _delmsg_virtual_machine_interface_route_table
def _addmsg_virtual_machine_interface_virtual_machine(self, idents):
vm_fq_str = idents['virtual-machine']
try:
vm_obj = self._vnc_lib.virtual_machine_read(
fq_name_str=vm_fq_str)
except NoIdError:
return
# check if this is a service vm
si_list = vm_obj.get_service_instance_refs()
if not si_list:
return
vm_info = self.db.virtual_machine_get(vm_obj.uuid)
if not vm_info:
return
si_fq_str = vm_info['si_fq_str']
try:
si_obj = self._vnc_lib.service_instance_read(
fq_name_str=si_fq_str)
except NoIdError:
proj_name = self._get_proj_name_from_si_fq_str(si_fq_str)
self._delete_svc_instance(vm_obj.uuid, proj_name,
si_fq_str=si_fq_str)
return
# create service instance to service vm link
vm_obj.add_service_instance(si_obj)
self._vnc_lib.virtual_machine_update(vm_obj)
self.logger.log("Info: VM %s updated SI %s" %
(vm_obj.get_fq_name_str(), si_fq_str))
# end _addmsg_virtual_machine_interface_virtual_machine
def _addmsg_service_instance_service_template(self, idents):
st_fq_str = idents['service-template']
si_fq_str = idents['service-instance']
try:
st_obj = self._vnc_lib.service_template_read(
fq_name_str=st_fq_str)
si_obj = self._vnc_lib.service_instance_read(
fq_name_str=si_fq_str)
except NoIdError:
return
#launch VMs
self._create_svc_instance(st_obj, si_obj)
# end _addmsg_service_instance_service_template
def _addmsg_service_instance_properties(self, idents):
si_fq_str = idents['service-instance']
try:
si_obj = self._vnc_lib.service_instance_read(
fq_name_str=si_fq_str)
except NoIdError:
return
#update static routes
self._update_static_routes(si_obj)
# end _addmsg_service_instance_service_template
def _addmsg_project_virtual_network(self, idents):
vn_fq_str = idents['virtual-network']
si_list = self.db.service_instance_list()
if not si_list:
return
for si_fq_str, si_info in si_list:
if vn_fq_str not in si_info.keys():
continue
try:
si_obj = self._vnc_lib.service_instance_read(
fq_name_str=si_fq_str)
if si_obj.get_virtual_machine_back_refs():
continue
st_refs = si_obj.get_service_template_refs()
fq_name = st_refs[0]['to']
st_obj = self._vnc_lib.service_template_read(fq_name=fq_name)
#launch VMs
self._create_svc_instance(st_obj, si_obj)
except Exception:
continue
#end _addmsg_project_virtual_network
def process_poll_result(self, poll_result_str):
result_list = parse_poll_result(poll_result_str)
# process ifmap message
for (result_type, idents, metas) in result_list:
if 'ERROR' in idents.values():
continue
for meta in metas:
meta_name = re.sub('{.*}', '', meta.tag)
if result_type == 'deleteResult':
funcname = "_delmsg_" + meta_name.replace('-', '_')
elif result_type in ['searchResult', 'updateResult']:
funcname = "_addmsg_" + meta_name.replace('-', '_')
# end if result_type
try:
func = getattr(self, funcname)
except AttributeError:
pass
else:
self.logger.log("%s with %s/%s"
% (funcname, meta_name, idents))
func(idents)
# end for meta
# end for result_type
# end process_poll_result
def _update_static_routes(self, si_obj):
# get service instance interface list
si_props = si_obj.get_service_instance_properties()
si_if_list = si_props.get_interface_list()
if not si_if_list:
return
for idx in range(0, len(si_if_list)):
si_if = si_if_list[idx]
static_routes = si_if.get_static_routes()
if not static_routes:
static_routes = {'route':[]}
# update static routes
try:
domain_name, proj_name = si_obj.get_parent_fq_name()
rt_name = si_obj.uuid + ' ' + str(idx)
rt_fq_name = [domain_name, proj_name, rt_name]
rt_obj = self._vnc_lib.interface_route_table_read(
fq_name=rt_fq_name)
rt_obj.set_interface_route_table_routes(static_routes)
self._vnc_lib.interface_route_table_update(rt_obj)
except NoIdError:
pass
