Merge "Service monitor changes for VM services" into R2.0

src/config/svc-monitor/svc_monitor/db.py

@@ -38,6 +38,25 @@ def add_logger(self, logger):
     def get_vm_db_prefix(self, inst_count):
         return('vm' + str(inst_count) + '-')
 
+    def remove_vm_info(self, si_fq_str, vm_uuid):
+        si_info = self.service_instance_get(si_fq_str)
+        if not si_info:
+            return
+
+        prefix = None
+        for key, item in si_info.items():
+            if item == vm_uuid:
+                prefix = key.split('-')[0]
+                break
+        if not prefix:
+            return
+
+        vm_column_list = []
+        for key in si_info.keys():
+            if key.startswith(prefix):
+                vm_column_list.append(key)
+        self.service_instance_remove(si_fq_str, vm_column_list)
+
     # service instance CRUD
     def service_instance_get(self, si_fq_str):
         return self._db_get(self._svc_si_cf, si_fq_str)

src/config/svc-monitor/svc_monitor/instance_manager.py

@@ -19,6 +19,7 @@
 
 import abc
 import six
+import uuid
 
 from cfgm_common import analytics_client
 from cfgm_common import svc_info
@@ -40,7 +41,7 @@ def create_service(self, st_obj, si_obj):
         pass
 
     @abc.abstractmethod
-    def delete_service(self, vm_uuid, proj_name=None):
+    def delete_service(self, si_fq_str, vm_uuid, proj_name=None):
         pass
 
     @abc.abstractmethod
@@ -60,11 +61,15 @@ def _get_default_security_group(self, vn_obj):
         return sg_obj
 
     def _get_instance_name(self, si_obj, inst_count):
-        name = si_obj.uuid + '__' + str(inst_count + 1)
+        name = si_obj.name + '__' + str(inst_count + 1)
         proj_fq_name = si_obj.get_parent_fq_name()
         instance_name = "__".join(proj_fq_name + [name])
         return instance_name
 
+    def index_from_instance_name(self, instance_name):
+        instance_index = int(instance_name.split('__')[-1]) - 1
+        return instance_index
+
     def _get_if_route_table_name(self, if_type, si_obj):
         domain_name, proj_name = si_obj.get_parent_fq_name()
         rt_name = si_obj.uuid + ' ' + if_type
@@ -88,19 +93,12 @@ def _set_vm_db_info(self, inst_count, instance_name, vm_uuid,
         return vm_entry
 
     def _allocate_iip(self, proj_obj, vn_obj, iip_name):
+        iip_obj = InstanceIp(name=iip_name)
+        iip_obj.add_virtual_network(vn_obj)
         try:
+            self._vnc_lib.instance_ip_create(iip_obj)
+        except Exception as e:
             iip_obj = self._vnc_lib.instance_ip_read(fq_name=[iip_name])
-        except NoIdError:
-            iip_obj = None
-
-        # allocate ip
-        if not iip_obj:
-            iip_obj = InstanceIp(name=iip_name)
-            iip_obj.add_virtual_network(vn_obj)
-            try:
-                self._vnc_lib.instance_ip_create(iip_obj)
-            except Exception as e:
-                return None
 
         return iip_obj
 
@@ -140,23 +138,34 @@ def _create_svc_vm_port(self, nic, instance_name, st_obj, si_obj,
                    si_obj.get_parent_fq_name_str()))
             return
 
+        # check if port already in db
+        vmi_uuid = None
+        si_db_entry = self.db.service_instance_get(si_obj.get_fq_name_str())
+        if si_db_entry:
+            index = self.index_from_instance_name(instance_name)
+            key = self.db.get_vm_db_prefix(index) + 'if-' + nic['type']
+            if key in si_db_entry:
+                vmi_uuid = si_db_entry[key]
+
         # create or find port
-        port_name = instance_name + '-' + nic['type']
         proj_fq_name = si_obj.get_parent_fq_name()
         proj_obj = self._vnc_lib.project_read(fq_name=proj_fq_name)
-        port_fq_name = proj_fq_name + [port_name]
         vmi_create = False
         vmi_updated = False
         if_properties = None
-        try:
-            vmi_obj = self._vnc_lib.virtual_machine_interface_read(fq_name=port_fq_name)
-            if_properties = vmi_obj.get_virtual_machine_interface_properties()
-        except NoIdError:
-            vmi_obj = VirtualMachineInterface(parent_obj=proj_obj, name=port_name)
+
+        if not vmi_uuid:
+            port_uuid = str(uuid.uuid4())
+            port_name = instance_name + '-' + nic['type'] + '-' + port_uuid
+            vmi_obj = VirtualMachineInterface(parent_obj=proj_obj,
+                name=port_name, uuid=port_uuid)
             if user_visible is not None:
                 id_perms = IdPermsType(enable=True, user_visible=user_visible)
                 vmi_obj.set_id_perms(id_perms)
             vmi_create = True
+        else:
+            vmi_obj = self._vnc_lib.virtual_machine_interface_read(id=vmi_uuid)
+            if_properties = vmi_obj.get_virtual_machine_interface_properties()
 
         # set vn, itf_type, sg and static routes
         if vmi_obj.get_virtual_network_refs() is None:
@@ -194,17 +203,19 @@ def _create_svc_vm_port(self, nic, instance_name, st_obj, si_obj,
             # read back the id perms
             vmi_obj = self._vnc_lib.virtual_machine_interface_read(
                 id=vmi_obj.uuid)
+            self.db.service_instance_insert(si_obj.get_fq_name_str(),
+                                            {key:vmi_obj.uuid})
         elif vmi_updated:
             self._vnc_lib.virtual_machine_interface_update(vmi_obj)
 
         # instance ip
         if 'iip-id' in nic:
             iip_obj = self._vnc_lib.instance_ip_read(id=nic['iip-id'])
         elif nic['shared-ip']:
-            iip_name = si_obj.name + '-' + nic['type']
+            iip_name = "__".join(si_obj.fq_name) + '-' + nic['type']
             iip_obj = self._allocate_iip(proj_obj, vn_obj, iip_name)
         else:
-            iip_name = instance_name + '-' + nic['type']
+            iip_name = instance_name + '-' + nic['type'] + '-' + vmi_obj.uuid
             iip_obj = self._allocate_iip(proj_obj, vn_obj, iip_name)
 
         if not iip_obj:
@@ -364,7 +375,7 @@ class VRouterHostedManager(InstanceManager):
     def create_service(self, st_obj, si_obj):
         pass
 
-    def delete_service(self, vm_uuid, proj_name=None):
+    def delete_service(self, si_fq_str, vm_uuid, proj_name=None):
         try:
             vm_obj = self._vnc_lib.virtual_machine_read(id=vm_uuid)
         except NoIdError:

src/config/svc-monitor/svc_monitor/logger.py

@@ -58,7 +58,6 @@ def __init__(self, db, discovery, args=None):
 
 
     def log(self, log_msg):
-        self._sandesh._logger.debug("%s", log_msg)
         vn_log = sandesh.SvcMonitorLog(
             log_msg=log_msg, sandesh=self._sandesh)
         vn_log.send(sandesh=self._sandesh)
@@ -89,6 +88,8 @@ def sandesh_si_handle_request(self, req):
                 sandesh_vm_list = []
                 for idx in range(0, int(si.get('max-instances', '0'))):
                     prefix = self._db.get_vm_db_prefix(idx)
+                    if not (prefix + 'name') in si.keys():
+                        continue
                     vm_name = si.get(prefix + 'name', '')
                     vm_uuid = si.get(prefix + 'uuid', '')
                     vm_str = ("%s: %s" % (vm_name, vm_uuid))

src/config/svc-monitor/svc_monitor/svc_monitor.py

@@ -268,11 +268,11 @@ def _check_store_si_info(self, st_obj, si_obj):
         if config_complete:
             self.logger.log("SI %s info is complete" %
                              si_obj.get_fq_name_str())
-            si_entry['state'] = 'active'
+            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'
+            si_entry['state'] = 'pending_config'
 
         #insert entry
         self.db.service_instance_insert(si_obj.get_fq_name_str(), si_entry)
@@ -314,11 +314,11 @@ def _delete_svc_instance(self, vm_uuid, proj_name,
 
         try:
             if virt_type == svc_info.get_vm_instance_type():
-                self.vm_manager.delete_service(vm_uuid, proj_name)
+                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(vm_uuid)
+                self.netns_manager.delete_service(si_fq_str, vm_uuid)
             elif virt_type == 'vrouter-instance':
-                self.vrouter_manager.delete_service(vm_uuid)
+                self.vrouter_manager.delete_service(si_fq_str, vm_uuid)
         except KeyError:
             return True
 
@@ -332,9 +332,9 @@ def _delete_shared_vn(self, vn_uuid, proj_name):
             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))
+            pass
         except NoIdError:
+            self.logger.log("Deleted VN %s %s" % (proj_name, vn_uuid))
             return True
         return False
 
@@ -363,7 +363,6 @@ def _cleanup_si(self, si_fq_str):
                 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():
@@ -377,6 +376,10 @@ def _check_si_status(self, si_fq_name_str, si_info):
             # 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)
@@ -387,6 +390,25 @@ def _check_si_status(self, si_fq_name_str, si_info):
 
         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'])
 
@@ -399,9 +421,12 @@ def _delmsg_virtual_machine_interface_route_table(self, idents):
         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)
+        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']