Merge "Service monitor changes for port-tuple"

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

@@ -284,7 +284,8 @@ def __init__(self, uuid, obj_dict=None):
         self.instance_id = None
         self.physical_interface = None
         self.port_tuple = None
-        self.update(obj_dict)
+        obj_dict = self.update(obj_dict)
+        self.add_to_parent(obj_dict)
     # end __init__
 
     def update(self, obj=None):
@@ -310,6 +311,7 @@ def update(self, obj=None):
             vm = VirtualMachineSM.get(self.virtual_machine)
             if vm:
                 self.service_instance = vm.service_instance
+        return obj
     # end update
 
     @classmethod
@@ -327,6 +329,7 @@ def delete(cls, uuid):
         obj.update_single_ref('interface_route_table', {})
         obj.update_single_ref('security_group', {})
         obj.update_single_ref('port_tuple', {})
+        obj.remove_from_parent()
         del cls._dict[uuid]
     # end delete
 # end VirtualMachineInterfaceSM
@@ -358,6 +361,7 @@ def __init__(self, uuid, obj_dict=None):
         self.port_tuples = set()
         obj_dict = self.update(obj_dict)
         self.set_children('port_tuple', obj_dict)
+        self.add_to_parent(obj_dict)
         if self.ha_mode == 'active-standby':
             self.max_instances = 2
             self.local_preference = [svc_info.get_active_preference(),
@@ -418,6 +422,7 @@ def delete(cls, uuid):
         obj.update_single_ref('loadbalancer_pool', {})
         obj.update_multiple_refs('virtual_machine_interface',{})
         obj.update_multiple_refs('virtual_machine', {})
+        obj.remove_from_parent()
         del cls._dict[uuid]
     # end delete
 # end class ServiceInstanceSM
@@ -533,6 +538,8 @@ class InstanceIpSM(DBBaseSM):
     def __init__(self, uuid, obj_dict=None):
         self.uuid = uuid
         self.address = None
+        self.family = None
+        self.service_instance_ip = None
         self.virtual_machine_interfaces = set()
         self.update(obj_dict)
     # end __init__
@@ -542,6 +549,8 @@ def update(self, obj=None):
             obj = self.read_obj(self.uuid)
         self.name = obj['fq_name'][-1]
         self.fq_name = obj['fq_name']
+        self.service_instance_ip = obj.get('service_instance_ip', False)
+        self.family = obj.get('instance_ip_family', 'v4')
         self.address = obj.get('instance_ip_address', None)
         self.update_multiple_refs('virtual_machine_interface', obj)
     # end update
@@ -921,7 +930,7 @@ class PortTupleSM(DBBaseSM):
     def __init__(self, uuid, obj_dict=None):
         self.uuid = uuid
         self.virtual_machine_interfaces = set()
-        self.update(obj_dict)
+        obj = self.update(obj_dict)
         self.add_to_parent(obj_dict)
     # end __init__
 
@@ -942,4 +951,4 @@ def delete(cls, uuid):
         obj.remove_from_parent()
         del cls._dict[uuid]
     # end delete
-# end LogicalRouterSM
+# end PortTupleSM

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

@@ -19,123 +19,130 @@
 
 from vnc_api.vnc_api import *
 from config_db import *
+from agent import Agent
+
+class PortTupleAgent(Agent):
+
+    def __init__(self, svc_mon, vnc_lib, cassandra, config_section, logger):
+        super(PortTupleAgent, self).__init__(svc_mon, vnc_lib,
+            cassandra, config_section)
+        self._logger = logger
+
+    def handle_service_type(self):
+        return 'port-tuple'
+
+    def _allocate_iip_for_family(self, vn_obj, iip_name, iip_family, vmi_obj):
+        iip_name = iip_name + '-' + iip_family
+        iip_obj = InstanceIp(name=iip_name, instance_ip_family=iip_family)
+        iip_obj.add_virtual_network(vn_obj)
+        iip_obj.set_service_instance_ip(True)
+        iip_obj.set_secondary_ip(True)
+        iip_obj.add_virtual_machine_interface(vmi_obj)
+        for iip in InstanceIpSM.values():
+            if iip.name == iip_name:
+                iip_obj.uuid = iip.uuid
+                return iip_obj
+
+        if not iip_obj.uuid:
+            try:
+                self._vnc_lib.instance_ip_create(iip_obj)
+            except RefsExistError:
+                iip_obj = self._vnc_lib.instance_ip_read(fq_name=[iip_name])
+            except HttpError:
+                return None
+
+        InstanceIpSM.locate(iip_obj.uuid)
+        return iip_obj
+
+    def _allocate_shared_iip(self, port, vmi, vmi_obj):
+        vn_obj = self._vnc_lib.virtual_network_read(id=vmi.virtual_network)
+        iip_name = si.uuid + '-' + port['type']
+        self._allocate_iip_for_family(vn_obj, iip_name, 'v4', vmi_obj)
+        self._allocate_iip_for_family(vn_obj, iip_name, 'v6', vmi_obj)
+        return
+
+    def set_port_service_health_check(self, port, vmi):
+        if port['service-health-check']:
+            vmi_obj.set_service_health_check(port['service-health-check'])
+            return True
+        return False
+
+    def set_port_allowed_address_pairs(self, port, vmi):
+        if port['allowed-address-pairs']:
+            vmi_obj.set_virtual_machine_interface_allowed_address_pairs(port['allowed-address-pairs'])
+            return True
+        return False
+
+    def set_port_static_routes(self, st, si, port, vmi_obj):
+        #TODO
+        return False
+
+    def set_port_service_chain_ip(self, port, vmi, vmi_obj):
+        if nic['shared-ip']:
+            self._allocate_shared_iip(port, vmi, vmi_obj)
+            return
 
+        for iip_id in vmi.instance_ips:
+            iip = InstanceIpSM.get(iip_id)
+            if iip and not iip.service_instance_ip:
+                iip_obj = self._vnc_lib.instance_ip_read(id=iip_id)
+                iip_obj.set_service_instance_ip(True)
+                self._vnc_lib.instance_ip_update(iip_obj)
 
-class ServicePortTuple(object):
-
-    def __init__(self, vnc_lib, db, logger, vrouter_scheduler,
-                 nova_client, agent_manager, args=None):
-        self.logger = logger
-        self._vnc_lib = vnc_lib
-        self._args = args
-        self._nc = nova_client
-        self._agent_manager = agent_manager
-        self.vrouter_scheduler = vrouter_scheduler
-
-    def set_port_service_health_check(self, st, si, nic, vmi_obj):
-        vmi_obj.set_service_health_check(nic['service-health_check'])
-        self._vnc_lib.virtual_machine_interface_update(vmi_obj)
-
-    def set_port_allowed_address_pairs(self, st, si, nic, vmi_obj):
-        vmi_obj.set_allowed_address_pairs(nic['allowed-address-pairs'])
-        self._vnc_lib.virtual_machine_interface_update(vmi_obj)
-
-    def set_port_static_routes(self, st, si, nic, vmi_obj):
-        if nic['static-route-enable']:
-            rt_obj = self._set_static_routes(nic, si)
-            vmi_obj.set_interface_route_table(rt_obj)
-            self._vnc_lib.virtual_machine_interface_update(vmi_obj)
-
-    def set_port_service_chain_ip(self, st, si, nic, vmi_obj):
-        if nic['shared-ip']:
-            vn_obj = self._vnc_lib.virtual_network_read(id=nic['net-id'])
-            iip_name = si.uuid + '-' + nic['type']
-            iip_obj, iipv6_obj = self._allocate_iip(vn_obj, iip_name)
-            iip_obj.set_service_instance_ip(True)
-            self._vnc_lib.instance_ip_update(iip_obj)
-            iipv6_obj.set_service_instance_ip(True)
-            self._vnc_lib.instance_ip_update(iipv6_obj)
-        else:
-            for iip_id in vmi.instance_ips:
-                iip = InstanceIpSM.get(iip_id)
-                if not iip:
-                    continue
-                if not iip.params['instance_ip_secondary']:
-                    iip_obj = self._vnc_lib.instance_ip_read(id=iip_id)
-                    iip_obj.set_service_instance_ip(True)
-                    self._vnc_lib.instance_ip_update(iip_obj)
-
-    def validate_network_config(self, st, si):
+    def get_port_config(self, st, si):
         st_if_list = st.params.get('interface_type', [])
         si_if_list = si.params.get('interface_list', [])
 
         port_config = {}
-        config_complete = True
         for index in range(0, len(st_if_list)):
             try:
                 si_if = si_if_list[index]
                 st_if = st_if_list[index]
             except IndexError:
                 continue
 
-            nic = {}
-            itf_type = st_if.get('service_interface_type')
-            vn_fq_str = si_if.get('virtual_network', None)
-            if not vn_fq_str:
-                config_complete = False
-            else:
-                try:
-                    vn_id = self._vnc_lib.fq_name_to_id(
-                        'virtual-network', vn_fq_str.split(':'))
-                except NoIdError:
-                    self.logger.log_notice("virtual-network %s not found" % vn_fq_str)
-                    config_complete = False
-
-            nic['type'] = itf_type
-            nic['net-id'] = vn_id
-            nic['shared-ip'] = st_if.get('shared_ip')
-            nic['static-route-enable'] = st_if.get('static_route_enable')
-            nic['static-routes'] = si_if.get('static_routes')
-            nic['allowed-address-pairs'] = si_if.get('allowed_address_pairs')
-            nic['service-heath-check'] = si_if.get('service_health_check')
-            port_config[itf_type] = nic
-
-        if config_complete:
-            self.logger.log_notice("si %s info is complete" % si.fq_name)
-            return port_config
-        else:
-            self.logger.log_notice("si %s info is not complete" % si.fq_name)
-            return None
-
-    def update_properties_from_si_to_pt_vmis(self, st, si):
-        pt = PortTupleSM.get(si.port_tuple)
+            port = {}
+            port['type'] = st_if.get('service_interface_type')
+            port['shared-ip'] = st_if.get('shared_ip')
+            port['static-route-enable'] = st_if.get('static_route_enable')
+            port['static-routes'] = si_if.get('static_routes')
+            port['allowed-address-pairs'] = si_if.get('allowed_address_pairs')
+            port['service-health-check'] = si_if.get('service_health_check')
+            port_config[st_if.get('service_interface_type')] = port
+
+        return port_config
+
+    def update_port_tuple(self, pt_id):
+        pt = PortTupleSM.get(pt_id)
         if not pt:
             return
-
-        port_config = self.validate_network_config(st, si)
+        si = ServiceInstanceSM.get(pt.parent_key)
+        if not si:
+            return
+        st = ServiceTemplateSM.get(si.service_template)
+        port_config = self.get_port_config(st, si)
         if not port_config:
             return
 
         for vmi_id in pt.virtual_machine_interfaces:
             vmi = VirtualMachineInterfaceSM.get(vmi_id)
             if not vmi:
                 continue
-
-            nic = port_config[vmi.params.get('service_interface_type')]
-            if not nic:
+            port = port_config[vmi.params.get('service_interface_type')]
+            if not port:
                 #log TODO
                 continue
 
-            vmi_obj = VirtualMachineInterface(
-                parent_obj=proj_obj, name=vmi.name)
+            vmi_obj = VirtualMachineInterface(fq_name=vmi.fq_name, name=vmi.name)
             vmi_obj.uuid = vmi.uuid
-            vmi_obj.fq_name = vmi.fq_name
-
-            self.set_port_service_chain_ip(st, si, nic, vmi_obj)
-            self.set_port_allowed_address_pairs(st, si, nic, vmi_obj)
-            self.set_port_service_health_check(st, si, vmi, nic, vmi_obj)
-
-            try:
-                self._vnc_lib.virtual_machine_update(vmi_obj)
-            except NoIdError:
-                pass
+            self.set_port_service_chain_ip(port, vmi, vmi_obj)
+            update_vmi = self.set_port_allowed_address_pairs(port, vmi, vmi_obj)
+            update_vmi |= self.set_port_service_health_check(port, vmi, vmi_obj)
+            update_vmi |= self.set_port_static_routes(port, vmi, vmi_obj)
+            if update_vmi:
+                self._vnc_lib.virtual_machine_interface_update(vmi_obj)
+
+    def update_port_tuples(self):
+        for si in ServiceInstanceSM.values():
+            for pt_id in si.port_tuples:
+                self.update_port_tuple(pt_id)

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

@@ -48,6 +48,7 @@
 from db import ServiceMonitorDB
 from logger import ServiceMonitorLogger
 from loadbalancer_agent import LoadbalancerAgent
+from port_tuple import PortTupleAgent
 from snat_agent import SNATAgent
 
 from novaclient import exceptions as nc_exc
@@ -89,8 +90,9 @@ class SvcMonitor(object):
             'loadbalancer_pool': []
         },
         "service_instance": {
-            'self': ['virtual_machine','virtual_machine_interface'],
+            'self': ['virtual_machine', 'port_tuple', 'virtual_machine_interface'],
             'virtual_machine': [],
+            'port_tuple': [],
             'virtual_machine_interface' : []
         },
         "instance_ip": {
@@ -124,10 +126,16 @@ class SvcMonitor(object):
             'service_instance': [],
             'virtual_machine_interface': [],
         },
+        "port_tuple": {
+            'self': ['virtual_machine_interface'],
+            'service_instance': [],
+            'virtual_machine_interface': [],
+        },
         "virtual_machine_interface": {
-            'self': ['interface_route_table', 'virtual_machine'],
+            'self': ['interface_route_table', 'virtual_machine', 'port_tuple'],
             'interface_route_table': [],
             'virtual_machine': [],
+            'port_tuple': [],
             'service_instance': ['physical_interface'],
             'physical_interface': ['service_instance']
         },
@@ -362,6 +370,11 @@ def post_init(self, vnc_lib, args=None):
                                     self._cassandra, self._args)
         self._agent_manager.register_agent(self.snat_agent)
 
+        # load port tuple agent
+        self.port_tuple_agent = PortTupleAgent(self, self._vnc_lib,
+            self._cassandra, self._args, self.logger)
+        self._agent_manager.register_agent(self.port_tuple_agent)
+
         # Read the cassandra and populate the entry in ServiceMonitor DB
         self.sync_sm()
 
@@ -452,6 +465,9 @@ def sync_sm(self):
                     continue
                 self.port_delete_or_si_link(vm, vmi)
 
+        # invoke port tuple handling
+        self.port_tuple_agent.update_port_tuples()
+
         # Load the loadbalancer driver
         self.loadbalancer_agent.load_drivers()
 

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

@@ -216,6 +216,8 @@ def vmi_db_read(obj_type, vmi_id):
     vmi_obj = {}
     vmi_obj['uuid'] = 'fake-vmi-uuid'
     vmi_obj['fq_name'] = ['fake-vmi-uuid']
+    vmi_obj['parent_type'] = 'project'
+    vmi_obj['parent_uuid'] = 'fake-project'
     return True, [vmi_obj]
 
 def iip_db_read(obj_type, iip_id):

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

@@ -134,7 +134,7 @@ def setUp(self):
         config_db.VirtualMachineInterfaceSM.locate(
             ROUTER_1['virtual_machine_interface_refs'][0]['uuid'],
             {'fq_name': ROUTER_1['virtual_machine_interface_refs'][0]['to'],
-             'virtual_network_refs': [{'uuid': 'private1-uuid'}]})
+             'virtual_network_refs': [{'uuid': 'private1-uuid'}], 'parent_type': 'project'})
 
     def tearDown(self):
         config_db.LogicalRouterSM.reset()
@@ -404,7 +404,7 @@ def test_add_interface(self):
         config_db.VirtualMachineInterfaceSM.locate(
             router_dict['virtual_machine_interface_refs'][1]['uuid'],
             {'fq_name': router_dict['virtual_machine_interface_refs'][1]['to'],
-             'virtual_network_refs': [{'uuid': 'private2-uuid'}]})
+             'virtual_network_refs': [{'uuid': 'private2-uuid'}], 'parent_type': 'project'})
 
         # reset all calls
         self.vnc_lib.virtual_network_update.reset_mock()