provider centric service chains

With the introduction of NCP, one single chain will have only
one provider but multiple consumers. This reduces
the number of instances (and consumed resources).

Partially implements blueprint node-centric-chain-plugin

Change-Id: I2bef4d7c6d8e578b8cd4b6555820630f1eecf05f

gbpservice/neutron/extensions/servicechain.py

@@ -181,13 +181,13 @@ RESOURCE_ATTRIBUTE_MAP = {
                               'default': None, 'is_visible': True,
                               'required': True},
         'provider_ptg_id': {'allow_post': True, 'allow_put': False,
-                         'validate': {'type:uuid_or_none': None},
-                         'is_visible': True, 'default': None,
-                         'required': True},
+                            'validate': {'type:uuid_or_none': None},
+                            'is_visible': True, 'default': None,
+                            'required': True},
         'consumer_ptg_id': {'allow_post': True, 'allow_put': False,
-                         'validate': {'type:uuid_or_none': None},
-                         'is_visible': True, 'default': None,
-                         'required': True},
+                            'validate': {'type:string_or_none': None},
+                            'is_visible': True, 'default': None,
+                            'required': True},
         'management_ptg_id': {'allow_post': True, 'allow_put': False,
                               'validate': {'type:uuid_or_none': None},
                               'is_visible': True, 'default': None,

gbpservice/neutron/services/grouppolicy/common/exceptions.py

@@ -286,3 +286,7 @@ class OnlyOneProxyGatewayAllowed(GroupPolicyBadRequest):
 class OnlyOneGroupDefaultGatewayAllowed(GroupPolicyBadRequest):
     message = _("Another group default gateway PT already exists for group "
                 "%(group_id)s")
+
+
+class PTGAlreadyProvidingRedirectPRS(GroupPolicyBadRequest):
+    message = _("PTG %(ptg_id)s is already providing a redirect PRS.")

gbpservice/neutron/services/grouppolicy/drivers/resource_mapping.py

@@ -44,6 +44,7 @@ from gbpservice.neutron.services.grouppolicy.common import exceptions as exc
 
 LOG = logging.getLogger(__name__)
 DEFAULT_SG_PREFIX = 'gbp_%s'
+SCI_CONSUMER_NOT_AVAILABLE = 'N/A'
 
 group_policy_opts = [
     cfg.StrOpt('chain_owner_user',
@@ -505,6 +506,7 @@ class ResourceMappingDriver(api.PolicyDriver, local_api.LocalAPI):
         self._validate_ptg_subnets(context)
         self._validate_nat_pool_for_nsp(context)
         self._validate_proxy_ptg(context)
+        self._validate_ptg_prss(context, context.current)
 
     @log.log
     def create_policy_target_group_postcommit(self, context):
@@ -699,6 +701,8 @@ class ResourceMappingDriver(api.PolicyDriver, local_api.LocalAPI):
         self._validate_ptg_subnets(context, new_subnets)
         self._reject_cross_tenant_ptg_l2p(context)
         self._validate_ptg_subnets(context, context.current['subnets'])
+        self._validate_ptg_prss(context, context.current)
+
         if (context.current['network_service_policy_id'] !=
             context.original['network_service_policy_id']):
             self._validate_nat_pool_for_nsp(context)
@@ -707,19 +711,11 @@ class ResourceMappingDriver(api.PolicyDriver, local_api.LocalAPI):
             'provided_policy_rule_sets']
         curr_provided_policy_rule_sets = context.current[
             'provided_policy_rule_sets']
-        orig_consumed_policy_rule_sets = context.original[
-            'consumed_policy_rule_sets']
-        curr_consumed_policy_rule_sets = context.current[
-            'consumed_policy_rule_sets']
 
         removed_provided_prs = (set(orig_provided_policy_rule_sets) -
                                 set(curr_provided_policy_rule_sets))
-        removed_consumed_prs = (set(orig_consumed_policy_rule_sets) -
-                                set(curr_consumed_policy_rule_sets))
         added_provided_prs = (set(curr_provided_policy_rule_sets) -
                               set(orig_provided_policy_rule_sets))
-        added_consumed_prs = (set(curr_consumed_policy_rule_sets) -
-                              set(orig_consumed_policy_rule_sets))
         context.ptg_chain_map = []
         # If the Redirect is removed, delete the chain. If the spec is
         # changed, then update the existing instance with new spec
@@ -728,17 +724,7 @@ class ResourceMappingDriver(api.PolicyDriver, local_api.LocalAPI):
             self._is_redirect_in_policy_rule_sets(
                 context, added_provided_prs)):
             context.ptg_chain_map += self._get_ptg_servicechain_mapping(
-                                            context._plugin_context.session,
-                                            context.current['id'],
-                                            None)
-        if (self._is_redirect_in_policy_rule_sets(
-                context, removed_consumed_prs) and not
-            self._is_redirect_in_policy_rule_sets(
-                context, added_consumed_prs)):
-            context.ptg_chain_map += self._get_ptg_servicechain_mapping(
-                                            context._plugin_context.session,
-                                            None,
-                                            context.current['id'])
+                context._plugin_context.session, context.current['id'])
 
     def _is_redirect_in_policy_rule_sets(self, context, policy_rule_sets):
         policy_rule_ids = []
@@ -805,8 +791,7 @@ class ResourceMappingDriver(api.PolicyDriver, local_api.LocalAPI):
         # If the spec is changed, then update the chain with new spec
         # If redirect is newly added, create the chain
         if self._is_redirect_in_policy_rule_sets(
-            context,
-            new_provided_policy_rule_sets + new_consumed_policy_rule_sets):
+                context, new_provided_policy_rule_sets):
             policy_rule_sets = (curr_consumed_policy_rule_sets +
                                 curr_provided_policy_rule_sets)
             self._handle_redirect_action(context, policy_rule_sets)
@@ -848,14 +833,9 @@ class ResourceMappingDriver(api.PolicyDriver, local_api.LocalAPI):
         context.nsp_cleanup_fips = self._get_ptg_policy_fip_mapping(
             context._plugin_context.session, context.current['id'])
         provider_ptg_chain_map = self._get_ptg_servicechain_mapping(
-                                            context._plugin_context.session,
-                                            context.current['id'],
-                                            None)
-        consumer_ptg_chain_map = self._get_ptg_servicechain_mapping(
-                                            context._plugin_context.session,
-                                            None,
-                                            context.current['id'],)
-        context.ptg_chain_map = provider_ptg_chain_map + consumer_ptg_chain_map
+            context._plugin_context.session, context.current['id'])
+
+        context.ptg_chain_map = provider_ptg_chain_map
 
     @log.log
     def delete_policy_target_group_postcommit(self, context):
@@ -1101,6 +1081,13 @@ class ResourceMappingDriver(api.PolicyDriver, local_api.LocalAPI):
     @log.log
     def update_policy_rule_precommit(self, context):
         self._reject_multiple_redirects_in_rule(context)
+        old_redirect = self._get_redirect_action(context, context.original)
+        new_redirect = self._get_redirect_action(context, context.current)
+        if not old_redirect and new_redirect:
+            for prs in context._plugin.get_policy_rule_sets(
+                    context._plugin_context,
+                    {'id': context.current['policy_rule_sets']}):
+                self._validate_new_prs_redirect(context, prs)
 
     @log.log
     def update_policy_rule_postcommit(self, context):
@@ -1177,6 +1164,15 @@ class ResourceMappingDriver(api.PolicyDriver, local_api.LocalAPI):
         self._reject_shared(context.current, 'policy_rule_set')
         self._reject_multiple_redirects_in_prs(context)
 
+        old_red_count = self._multiple_pr_redirect_action_number(
+            context._plugin_context.session,
+            context.original['policy_rules'])
+        new_red_count = self._multiple_pr_redirect_action_number(
+            context._plugin_context.session,
+            context.current['policy_rules'])
+        if new_red_count > old_red_count:
+            self._validate_new_prs_redirect(context, context.current)
+
     @log.log
     def update_policy_rule_set_postcommit(self, context):
         # Update policy_rule_set rules
@@ -1343,24 +1339,12 @@ class ResourceMappingDriver(api.PolicyDriver, local_api.LocalAPI):
                 self._set_sg_rules_for_cidrs(
                     context, cidr_list, ep['provided_policy_rule_sets'],
                     ep['consumed_policy_rule_sets'])
-            if ep['consumed_policy_rule_sets']:
-                self._handle_redirect_action(context,
-                                             ep['consumed_policy_rule_sets'])
 
     def update_external_policy_precommit(self, context):
         if context.original['external_segments']:
             if (set(context.current['external_segments']) !=
                     set(context.original['external_segments'])):
                 raise exc.ESUpdateNotSupportedForEP()
-        provider_ptg_chain_map = self._get_ptg_servicechain_mapping(
-                                            context._plugin_context.session,
-                                            context.current['id'],
-                                            None)
-        consumer_ptg_chain_map = self._get_ptg_servicechain_mapping(
-                                            context._plugin_context.session,
-                                            None,
-                                            context.current['id'],)
-        context.ptg_chain_map = provider_ptg_chain_map + consumer_ptg_chain_map
 
     def update_external_policy_postcommit(self, context):
         # REVISIT(ivar): Concurrency issue, the cidr_list could be different
@@ -1382,9 +1366,6 @@ class ResourceMappingDriver(api.PolicyDriver, local_api.LocalAPI):
                 context, cidr_list, prov_cons['provided_policy_rule_sets'],
                 prov_cons['consumed_policy_rule_sets'])
 
-        if prov_cons['consumed_policy_rule_sets']:
-            self._cleanup_redirect_action(context)
-
         # Added PRS
         for attr in prov_cons:
             orig_policy_rule_sets = context.original[attr]
@@ -1399,20 +1380,8 @@ class ResourceMappingDriver(api.PolicyDriver, local_api.LocalAPI):
                 context, cidr_list, prov_cons['provided_policy_rule_sets'],
                 prov_cons['consumed_policy_rule_sets'])
 
-        if prov_cons['consumed_policy_rule_sets']:
-            self._handle_redirect_action(
-                context, prov_cons['consumed_policy_rule_sets'])
-
     def delete_external_policy_precommit(self, context):
-        provider_ptg_chain_map = self._get_ptg_servicechain_mapping(
-                                            context._plugin_context.session,
-                                            context.current['id'],
-                                            None)
-        consumer_ptg_chain_map = self._get_ptg_servicechain_mapping(
-                                            context._plugin_context.session,
-                                            None,
-                                            context.current['id'],)
-        context.ptg_chain_map = provider_ptg_chain_map + consumer_ptg_chain_map
+        pass
 
     def delete_external_policy_postcommit(self, context):
         if (context.current['provided_policy_rule_sets'] or
@@ -1424,7 +1393,6 @@ class ResourceMappingDriver(api.PolicyDriver, local_api.LocalAPI):
                 context, cidr_list,
                 context.current['provided_policy_rule_sets'],
                 context.current['consumed_policy_rule_sets'])
-        self._cleanup_redirect_action(context)
 
     def create_nat_pool_precommit(self, context):
         self._add_nat_pool_to_segment(context)
@@ -1953,7 +1921,7 @@ class ResourceMappingDriver(api.PolicyDriver, local_api.LocalAPI):
             'provided_policy_rule_sets']
         subnets = context.current['subnets']
         ptg_id = context.current['id']
-        if provided_policy_rule_sets or consumed_policy_rule_sets:
+        if provided_policy_rule_sets:
             policy_rule_sets = (
                 consumed_policy_rule_sets + provided_policy_rule_sets)
             self._handle_redirect_action(context, policy_rule_sets)
@@ -2108,15 +2076,12 @@ class ResourceMappingDriver(api.PolicyDriver, local_api.LocalAPI):
                                     context._plugin_context,
                                     filters={'id': policy_rule_set_ids})
         for policy_rule_set in policy_rule_sets:
-            ptgs_consuming_prs = (
-                policy_rule_set['consuming_policy_target_groups'] +
-                policy_rule_set['consuming_external_policies'])
             ptgs_providing_prs = policy_rule_set[
-                                            'providing_policy_target_groups']
+                'providing_policy_target_groups']
 
             # Create the ServiceChain Instance when we have both Provider and
             # consumer PTGs. If Labels are available, they have to be applied
-            if not ptgs_consuming_prs or not ptgs_providing_prs:
+            if not ptgs_providing_prs:
                 continue
 
             parent_classifier_id = None
@@ -2157,12 +2122,11 @@ class ResourceMappingDriver(api.PolicyDriver, local_api.LocalAPI):
                     continue
                 spec_id = (policy_actions and policy_actions[0]['action_value']
                            or None)
-                for ptg_consuming_prs in ptgs_consuming_prs:
-                    for ptg_providing_prs in ptgs_providing_prs:
-                        # REVISIT(Magesh): There may be concurrency issues here
-                        self._create_or_update_chain(
-                            context, ptg_providing_prs, ptg_consuming_prs,
-                            spec_id,
+                for ptg_providing_prs in ptgs_providing_prs:
+                    # REVISIT(Magesh): There may be concurrency issues here
+                    self._create_or_update_chain(
+                            context, ptg_providing_prs,
+                            SCI_CONSUMER_NOT_AVAILABLE, spec_id,
                             parent_spec_id, classifier_id,
                             hierarchial_classifier_mismatch, policy_rule_set)
 
@@ -2170,7 +2134,7 @@ class ResourceMappingDriver(api.PolicyDriver, local_api.LocalAPI):
                                 parent_spec_id, classifier_id,
                                 hierarchial_classifier_mismatch, prs_id):
         ptg_chain_map = self._get_ptg_servicechain_mapping(
-            context._plugin_context.session, provider, consumer)
+            context._plugin_context.session, provider)
         if ptg_chain_map:
             if hierarchial_classifier_mismatch or not spec_id:
                 ctx = self._get_chain_admin_context(
@@ -2190,9 +2154,9 @@ class ResourceMappingDriver(api.PolicyDriver, local_api.LocalAPI):
                         classifier_id=classifier_id,
                         sc_specs=sc_specs)
         elif spec_id and not hierarchial_classifier_mismatch:
-            self._create_servicechain_instance(context, spec_id,
-                                               parent_spec_id, provider,
-                                               consumer, classifier_id, prs_id)
+            self._create_servicechain_instance(
+                context, spec_id, parent_spec_id, provider,
+                SCI_CONSUMER_NOT_AVAILABLE, classifier_id, prs_id)
 
     def _cleanup_redirect_action(self, context):
         for ptg_chain in context.ptg_chain_map:
@@ -2263,13 +2227,6 @@ class ResourceMappingDriver(api.PolicyDriver, local_api.LocalAPI):
             context._plugin_context,
             provider_tenant_id=provider_ptg['tenant_id'])
         session = context._plugin_context.session
-        if consumer_ptg_id:
-            try:
-                consumer_ptg = context._plugin.get_policy_target_group(
-                    p_ctx, consumer_ptg_id)
-            except gp_ext.PolicyTargetGroupNotFound:
-                consumer_ptg = context._plugin.get_external_policy(
-                    p_ctx, consumer_ptg_id)
         network_service_policy_id = provider_ptg.get(
             "network_service_policy_id")
         if network_service_policy_id:
@@ -2297,15 +2254,14 @@ class ResourceMappingDriver(api.PolicyDriver, local_api.LocalAPI):
                     for fip_map in fip_maps:
                         servicepolicy_fip_ids.append(fip_map.floatingip_id)
                     config_param_values[key] = servicepolicy_fip_ids
-        name = 'gbp_%s_%s_%s' % (policy_rule_set['name'], provider_ptg['name'],
-                                 consumer_ptg['name'] if consumer_ptg else '')
+        name = 'gbp_%s_%s' % (policy_rule_set['name'], provider_ptg['name'])
 
         attrs = {'tenant_id': p_ctx.tenant,
                  'name': name,
                  'description': "",
                  'servicechain_specs': sc_spec,
                  'provider_ptg_id': provider_ptg_id,
-                 'consumer_ptg_id': consumer_ptg_id,
+                 'consumer_ptg_id': SCI_CONSUMER_NOT_AVAILABLE,
                  'management_ptg_id': None,
                  'classifier_id': classifier_id,
                  'config_param_values': jsonutils.dumps(config_param_values)}
@@ -2313,8 +2269,8 @@ class ResourceMappingDriver(api.PolicyDriver, local_api.LocalAPI):
             ResourceMappingDriver, self)._create_servicechain_instance(
                 p_ctx, attrs)
         self._set_ptg_servicechain_instance_mapping(
-            session, provider_ptg_id, consumer_ptg_id, sc_instance['id'],
-            p_ctx.tenant)
+            session, provider_ptg_id, SCI_CONSUMER_NOT_AVAILABLE,
+            sc_instance['id'], p_ctx.tenant)
         return sc_instance
 
     # Do Not Pass floating_ip_address to this method until after Kilo Release
@@ -3103,3 +3059,54 @@ class ResourceMappingDriver(api.PolicyDriver, local_api.LocalAPI):
 
     def _unset_proxy_gateway_routes(self, context, pt):
         self._update_proxy_gateway_routes(context, pt, unset=True)
+
+    def _validate_ptg_prss(self, context, ptg):
+        # If the PTG is providing a redirect PRS, it can't provide any more
+        # redirect rules
+        if self._prss_redirect_rules(context._plugin_context.session,
+                                     ptg['provided_policy_rule_sets']) > 1:
+                raise exc.PTGAlreadyProvidingRedirectPRS(ptg_id=ptg['id'])
+
+    def _validate_new_prs_redirect(self, context, prs):
+        if self._prss_redirect_rules(context._plugin_context.session,
+                                     [prs['id']]) > 1:
+            raise exc.MultipleRedirectActionsNotSupportedForPRS()
+        for ptg in context._plugin.get_policy_target_groups(
+                context._plugin_context,
+                {'id': prs['providing_policy_target_groups']}):
+            self._validate_ptg_prss(context, ptg)
+
+    def _prss_redirect_rules(self, session, prs_ids):
+        if len(prs_ids) == 0:
+            # No result will be found in this case
+            return 0
+        query = (session.query(gpdb.PolicyAction).
+                 join(gpdb.PolicyRuleActionAssociation).
+                 join(gpdb.PolicyRule).
+                 join(gpdb.PRSToPRAssociation).
+                 filter(
+                 gpdb.PRSToPRAssociation.policy_rule_set_id.in_(prs_ids)).
+                 filter(gpdb.PolicyAction.action_type ==
+                        gconst.GP_ACTION_REDIRECT))
+        return query.count()
+
+    def _multiple_pr_redirect_action_number(self, session, pr_ids):
+        # Given a set of rules, gives the total number of redirect actions
+        # found
+        if len(pr_ids) == 0:
+            # No result will be found in this case
+            return 0
+        return (session.query(gpdb.PolicyAction).
+                join(gpdb.PolicyRuleActionAssociation).
+                filter(
+                gpdb.PolicyRuleActionAssociation.policy_rule_id.in_(
+                    pr_ids)).
+                filter(gpdb.PolicyAction.action_type ==
+                       gconst.GP_ACTION_REDIRECT)).count()
+
+    def _get_redirect_action(self, context, policy_rule):
+        for action in context._plugin.get_policy_actions(
+                context._plugin_context,
+                filters={'id': policy_rule['policy_actions']}):
+            if action['action_type'] == gconst.GP_ACTION_REDIRECT:
+                return action

gbpservice/neutron/services/grouppolicy/plugin.py

@@ -352,9 +352,9 @@ class GroupPolicyPlugin(group_policy_mapping_db.GroupPolicyMappingDbPlugin):
                 policy_context)
         except Exception:
             with excutils.save_and_reraise_exception():
-                LOG.error(_("create_policy_target_postcommit "
-                            "failed, deleting policy_target %s"),
-                          result['id'])
+                LOG.exception(_("create_policy_target_postcommit "
+                                "failed, deleting policy_target %s"),
+                              result['id'])
                 self.delete_policy_target(context, result['id'])
 
         # REVISIT(ivar): For now just raise the exception if something goes
@@ -460,9 +460,9 @@ class GroupPolicyPlugin(group_policy_mapping_db.GroupPolicyMappingDbPlugin):
                 policy_context)
         except Exception:
             with excutils.save_and_reraise_exception():
-                LOG.error(_("create_policy_target_group_postcommit "
-                            "failed, deleting policy_target_group %s"),
-                          result['id'])
+                LOG.exception(_("create_policy_target_group_postcommit "
+                                "failed, deleting policy_target_group %s"),
+                              result['id'])
                 self.delete_policy_target_group(context, result['id'])
 
         return result
@@ -590,8 +590,8 @@ class GroupPolicyPlugin(group_policy_mapping_db.GroupPolicyMappingDbPlugin):
                 policy_context)
         except Exception:
             with excutils.save_and_reraise_exception():
-                LOG.error(_("create_l2_policy_postcommit "
-                            "failed, deleting l2_policy %s"), result['id'])
+                LOG.exception(_("create_l2_policy_postcommit "
+                                "failed, deleting l2_policy %s"), result['id'])
                 self.delete_l2_policy(context, result['id'])
 
         return result
@@ -684,9 +684,9 @@ class GroupPolicyPlugin(group_policy_mapping_db.GroupPolicyMappingDbPlugin):
                 policy_context)
         except Exception:
             with excutils.save_and_reraise_exception():
-                LOG.error(_("create_network_service_policy_postcommit "
-                            "failed, deleting network_service_policy %s"),
-                          result['id'])
+                LOG.exception(_("create_network_service_policy_postcommit "
+                                "failed, deleting network_service_policy %s"),
+                              result['id'])
                 self.delete_network_service_policy(context, result['id'])
 
         return result
@@ -788,8 +788,8 @@ class GroupPolicyPlugin(group_policy_mapping_db.GroupPolicyMappingDbPlugin):
                 policy_context)
         except Exception:
             with excutils.save_and_reraise_exception():
-                LOG.error(_("create_l3_policy_postcommit "
-                            "failed, deleting l3_policy %s"), result['id'])
+                LOG.exception(_("create_l3_policy_postcommit "
+                                "failed, deleting l3_policy %s"), result['id'])
                 self.delete_l3_policy(context, result['id'])
 
         return result
@@ -888,7 +888,7 @@ class GroupPolicyPlugin(group_policy_mapping_db.GroupPolicyMappingDbPlugin):
                 policy_context)
         except Exception:
             with excutils.save_and_reraise_exception():
-                LOG.error(_(
+                LOG.exception(_(
                     "policy_driver_manager.create_policy_classifier_postcommit"
                     " failed, deleting policy_classifier %s"), result['id'])
                 self.delete_policy_classifier(context, result['id'])
@@ -986,7 +986,7 @@ class GroupPolicyPlugin(group_policy_mapping_db.GroupPolicyMappingDbPlugin):
                 policy_context)
         except Exception:
             with excutils.save_and_reraise_exception():
-                LOG.error(_(
+                LOG.exception(_(
                     "policy_driver_manager.create_policy_action_postcommit "
                     "failed, deleting policy_action %s"), result['id'])
                 self.delete_policy_action(context, result['id'])
@@ -1081,7 +1081,7 @@ class GroupPolicyPlugin(group_policy_mapping_db.GroupPolicyMappingDbPlugin):
                 policy_context)
         except Exception:
             with excutils.save_and_reraise_exception():
-                LOG.error(_(
+                LOG.exception(_(
                     "policy_driver_manager.create_policy_rule_postcommit"
                     " failed, deleting policy_rule %s"), result['id'])
                 self.delete_policy_rule(context, result['id'])
@@ -1176,7 +1176,7 @@ class GroupPolicyPlugin(group_policy_mapping_db.GroupPolicyMappingDbPlugin):
                 policy_context)
         except Exception:
             with excutils.save_and_reraise_exception():
-                LOG.error(_(
+                LOG.exception(_(
                     "policy_driver_manager.create_policy_rule_set_postcommit "
                     "failed, deleting policy_rule_set %s"), result['id'])
                 self.delete_policy_rule_set(context, result['id'])
@@ -1274,9 +1274,9 @@ class GroupPolicyPlugin(group_policy_mapping_db.GroupPolicyMappingDbPlugin):
              create_external_segment_postcommit(policy_context))
         except Exception:
             with excutils.save_and_reraise_exception():
-                LOG.error(_("create_external_segment_postcommit "
-                            "failed, deleting external_segment "
-                            "%s"), result['id'])
+                LOG.exception(_("create_external_segment_postcommit "
+                                "failed, deleting external_segment "
+                                "%s"), result['id'])
                 self.delete_external_segment(context, result['id'])
 
         return result
@@ -1380,9 +1380,9 @@ class GroupPolicyPlugin(group_policy_mapping_db.GroupPolicyMappingDbPlugin):
              create_external_policy_postcommit(policy_context))
         except Exception:
             with excutils.save_and_reraise_exception():
-                LOG.error(_("create_external_policy_postcommit "
-                            "failed, deleting external_policy "
-                            "%s"), result['id'])
+                LOG.exception(_("create_external_policy_postcommit "
+                                "failed, deleting external_policy "
+                                "%s"), result['id'])
                 self.delete_external_policy(context, result['id'])
 
         return result
@@ -1424,17 +1424,9 @@ class GroupPolicyPlugin(group_policy_mapping_db.GroupPolicyMappingDbPlugin):
                 self, context, es)
             (self.policy_driver_manager.
              delete_external_policy_precommit(policy_context))
-
-        # Disassociate all the PRSs first, this will trigger service chains
-        # deletion.
-        self.update_external_policy(
-            context, external_policy_id,
-            {'external_policy': {'provided_policy_rule_sets': {},
-                                 'consumed_policy_rule_sets': {}}})
-
-        with session.begin(subtransactions=True):
             super(GroupPolicyPlugin, self).delete_external_policy(
                 context, external_policy_id)
+
         try:
             self.policy_driver_manager.delete_external_policy_postcommit(
                 policy_context)
@@ -1486,8 +1478,8 @@ class GroupPolicyPlugin(group_policy_mapping_db.GroupPolicyMappingDbPlugin):
              create_nat_pool_postcommit(policy_context))
         except Exception:
             with excutils.save_and_reraise_exception():
-                LOG.error(_("create_nat_pool_postcommit failed, deleting "
-                            "nat_pool %s"), result['id'])
+                LOG.exception(_("create_nat_pool_postcommit failed, deleting "
+                                "nat_pool %s"), result['id'])
                 self.delete_nat_pool(context, result['id'])
 
         return result

gbpservice/neutron/services/servicechain/plugins/ncp/config.py

@@ -21,7 +21,7 @@ service_chain_opts = [
                        "gbpservice.neutron.servicechain.ncp_drivers "
                        "namespace.")),
     cfg.StrOpt('node_plumber',
-               default='agnostic_plumber',
+               default='dummy_plumber',
                help=_("The plumber used by the Node Composition Plugin "
                       "for service plumbing. Entrypoint loaded from the "
                       "gbpservice.neutron.servicechain.ncp_plumbers "

gbpservice/neutron/services/servicechain/plugins/ncp/context.py

@@ -14,6 +14,7 @@ from neutron import manager
 from neutron.plugins.common import constants as pconst
 
 from gbpservice.common import utils
+from gbpservice.neutron.services.grouppolicy.drivers import resource_mapping
 from gbpservice.neutron.services.servicechain.plugins.ncp import model
 
 
@@ -63,6 +64,8 @@ def get_node_driver_context(sc_plugin, context, sc_instance,
 
 
 def _get_ptg_or_ep(context, group_id):
+    if group_id == resource_mapping.SCI_CONSUMER_NOT_AVAILABLE:
+        return None, False
     group = None
     is_group_external = False
     if group_id:

gbpservice/neutron/services/servicechain/plugins/ncp/node_drivers/heat_node_driver.py

@@ -277,17 +277,21 @@ class HeatNodeDriver(driver_base.NodeDriverBase):
         else:
             provider_subnet = context.core_plugin.get_subnet(
                                 context.plugin_context, provider_ptg_subnet_id)
-            if context.is_consumer_external:
-                # REVISIT(Magesh): Allowing the first destination which is 0/0
-                # Validate and skip adding FW rule in case routes is not set
-                es = context.gbp_plugin.get_external_segment(
-                    context.plugin_context, consumer['external_segments'][0])
-                consumer_cidrs = [x['destination']
-                                  for x in es['external_routes']]
-            else:
-                consumer_subnet = context.core_plugin.get_subnet(
-                    context._plugin_context, consumer['subnets'][0])
-                consumer_cidrs = [consumer_subnet['cidr']]
+            consumer_cidrs = []
+            if consumer:
+                if context.is_consumer_external:
+                    # REVISIT(Magesh): Allowing the first destination which is
+                    # 0/0 Validate and skip adding FW rule in case routes is
+                    # not set
+                    es = context.gbp_plugin.get_external_segment(
+                        context.plugin_context,
+                        consumer['external_segments'][0])
+                    consumer_cidrs = [x['destination']
+                                      for x in es['external_routes']]
+                else:
+                    consumer_subnet = context.core_plugin.get_subnet(
+                        context._plugin_context, consumer['subnets'][0])
+                    consumer_cidrs = [consumer_subnet['cidr']]
             provider_cidr = provider_subnet['cidr']
             self._update_template_with_firewall_rules(
                     context, provider_ptg, provider_cidr, consumer_cidrs,

gbpservice/neutron/services/servicechain/plugins/ncp/node_plumbers/chain_agnostic_plumber.py

@@ -1,38 +0,0 @@
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from neutron.common import log
-
-from gbpservice.neutron.services.servicechain.plugins.ncp import plumber_base
-
-
-class ChainAgnosticPlumber(plumber_base.NodePlumberBase):
-    """ Chain Agnostic Plumber.
-
-    This plumber simply provides node drivers with the Service Targets
-    they requested for, without making any modification depending on the
-    rest of the chain.
-    """
-
-    @log.log
-    def initialize(self):
-        pass
-
-    @log.log
-    def plug_services(self, context, deployment):
-        for part in deployment:
-            self._create_service_targets(context, part)
-
-    @log.log
-    def unplug_services(self, context, deployment):
-        for part in deployment:
-            self._delete_service_targets(context, part)

gbpservice/neutron/services/servicechain/plugins/ncp/plumber_base.py

@@ -127,7 +127,7 @@ class NodePlumberBase(object):
         gbp_plugin = part_context.gbp_plugin
         for target in targets:
             if not group:
-                exceptions.NotAvailablePTGForTargetRequest(
+                raise exceptions.NotAvailablePTGForTargetRequest(
                     ptg_type=relationship, instance=instance['id'],
                     node=node['id'])
             data = {'policy_target_group_id': group['id'],
@@ -146,4 +146,4 @@ class NodePlumberBase(object):
 
     def _sort_deployment(self, deployment):
         deployment.sort(key=lambda x: x['context'].current_position,
-                        reverse=True)
+                        reverse=True)

gbpservice/neutron/tests/unit/services/grouppolicy/test_resource_mapping.py

@@ -110,7 +110,7 @@ class ResourceMappingTestCase(test_plugin.GroupPolicyPluginTestCase):
                                       consumer_ptg_id, scs_id_list,
                                       classifier_id=None):
         self.assertEqual(sc_instance['provider_ptg_id'], provider_ptg_id)
-        self.assertEqual(sc_instance['consumer_ptg_id'], consumer_ptg_id)
+        self.assertEqual(sc_instance['consumer_ptg_id'], 'N/A')
         self.assertEqual(scs_id_list, sc_instance['servicechain_specs'])
         if classifier_id:
             self.assertEqual(sc_instance['classifier_id'], classifier_id)
@@ -2036,7 +2036,7 @@ class TestServiceChain(ResourceMappingTestCase):
                                       consumer_ptg_id, scs_id_list,
                                       classifier_id=None):
         self.assertEqual(sc_instance['provider_ptg_id'], provider_ptg_id)
-        self.assertEqual(sc_instance['consumer_ptg_id'], consumer_ptg_id)
+        self.assertEqual(sc_instance['consumer_ptg_id'], 'N/A')
         self.assertEqual(scs_id_list, sc_instance['servicechain_specs'])
         provider = self.show_policy_target_group(
             provider_ptg_id)['policy_target_group']
@@ -2263,9 +2263,8 @@ class TestServiceChain(ResourceMappingTestCase):
         self._assert_proper_chain_instance(
             sc_instance, provider_ptg_id, consumer_ptg_id, [scs_id],
             classifier_id=classifier_id)
-
         # Verify that PTG delete cleans up the chain instances
-        self._verify_ptg_delete_cleanup_chain(consumer_ptg_id)
+        self._verify_ptg_delete_cleanup_chain(provider_ptg_id)
 
     def test_ptg_updates_affecting_chain(self):
         scs1_id = self._create_servicechain_spec()
@@ -2419,7 +2418,7 @@ class TestServiceChain(ResourceMappingTestCase):
             sc_instances[0], provider_ptg_id, consumer_ptg_id,
             [scs4_id, scs3_id], classifier_id=classifier_id)
 
-        self._verify_ptg_delete_cleanup_chain(consumer_ptg_id)
+        self._verify_ptg_delete_cleanup_chain(provider_ptg_id)
 
     def test_rule_update_updates_chain(self):
         scs_id = self._create_servicechain_spec()
@@ -2492,7 +2491,7 @@ class TestServiceChain(ResourceMappingTestCase):
             sc_instances[0], provider_ptg_id, consumer_ptg_id,
             [scs2_id], classifier_id=classifier['id'])
 
-        self._verify_ptg_delete_cleanup_chain(consumer_ptg_id)
+        self._verify_ptg_delete_cleanup_chain(provider_ptg_id)
 
     def test_redirect_to_ep_update(self):
         scs_id = self._create_servicechain_spec()
@@ -2529,9 +2528,9 @@ class TestServiceChain(ResourceMappingTestCase):
                     sc_instance, provider['policy_target_group']['id'],
                     ep['external_policy']['id'], [scs_id])
 
-                self.update_external_policy(
-                    ep['external_policy']['id'],
-                    consumed_policy_rule_sets={})
+                self.delete_policy_target_group(
+                    provider['policy_target_group']['id'],
+                    expected_res_status=webob.exc.HTTPNoContent.code)
                 sc_instance_list_req = self.new_list_request(
                     SERVICECHAIN_INSTANCES)
                 res = sc_instance_list_req.get_response(self.ext_api)
@@ -2573,10 +2572,9 @@ class TestServiceChain(ResourceMappingTestCase):
                     ep['external_policy']['id'], [scs_id])
 
                 # Verify that PTG delete cleans up the chain instances
-                req = self.new_delete_request(
-                    'external_policies', ep['external_policy']['id'])
-                res = req.get_response(self.ext_api)
-                self.assertEqual(res.status_int, webob.exc.HTTPNoContent.code)
+                self.delete_policy_target_group(
+                    provider['policy_target_group']['id'],
+                    expected_res_status=webob.exc.HTTPNoContent.code)
                 sc_instance_list_req = self.new_list_request(
                     SERVICECHAIN_INSTANCES)
                 res = sc_instance_list_req.get_response(self.ext_api)
@@ -2632,7 +2630,7 @@ class TestServiceChain(ResourceMappingTestCase):
                                            consumer_ptg_id,
                                            [parent_scs_id, scs_id])
 
-        self._verify_ptg_delete_cleanup_chain(consumer_ptg_id)
+        self._verify_ptg_delete_cleanup_chain(provider_ptg_id)
 
     def test_enforce_parent_redirect_after_ptg_create(self):
         scs_id = self._create_servicechain_spec()
@@ -2671,6 +2669,7 @@ class TestServiceChain(ResourceMappingTestCase):
         parent_prs_id = parent_prs['policy_rule_set']['id']
 
         self._verify_prs_rules(child_prs_id)
+
         sc_instances = self._list(SERVICECHAIN_INSTANCES)
         # We should have a new service chain instance created now from both
         # parent and child specs
@@ -2691,7 +2690,7 @@ class TestServiceChain(ResourceMappingTestCase):
         self._assert_proper_chain_instance(sc_instance, provider_ptg_id,
                                            consumer_ptg_id, [scs_id])
 
-        self._verify_ptg_delete_cleanup_chain(consumer_ptg_id)
+        self._verify_ptg_delete_cleanup_chain(provider_ptg_id)
 
     def test_hierarchical_redirect(self):
         scs_id = self._create_servicechain_spec()
@@ -2723,21 +2722,16 @@ class TestServiceChain(ResourceMappingTestCase):
         self._verify_prs_rules(child_prs_id)
         sc_instances = self._list(SERVICECHAIN_INSTANCES)
         # We should have one service chain instance created now
-        self.assertEqual(4, len(sc_instances['servicechain_instances']))
+        self.assertEqual(2, len(sc_instances['servicechain_instances']))
         sc_instances = sc_instances['servicechain_instances']
         sc_instances_provider_ptg_ids = set()
-        sc_instances_consumer_ptg_ids = set()
         for sc_instance in sc_instances:
             sc_instances_provider_ptg_ids.add(sc_instance['provider_ptg_id'])
-            sc_instances_consumer_ptg_ids.add(sc_instance['consumer_ptg_id'])
             self.assertEqual(sc_instance['servicechain_specs'],
                              [parent_scs_id, scs_id])
         expected_provider_ptg_ids = set([provider_ptg1_id, provider_ptg2_id])
-        expected_consumer_ptg_ids = set([consumer_ptg1_id, consumer_ptg2_id])
         self.assertEqual(expected_provider_ptg_ids,
                          sc_instances_provider_ptg_ids)
-        self.assertEqual(expected_consumer_ptg_ids,
-                         sc_instances_consumer_ptg_ids)
 
         with mock.patch.object(
                 servicechain_db.ServiceChainDbPlugin,
@@ -2757,7 +2751,7 @@ class TestServiceChain(ResourceMappingTestCase):
             self._verify_prs_rules(child_prs_id)
             sc_instances_updated = self._list(SERVICECHAIN_INSTANCES)[
                                                 'servicechain_instances']
-            self.assertEqual(4, len(sc_instances_updated))
+            self.assertEqual(2, len(sc_instances_updated))
             self.assertEqual(sc_instances, sc_instances_updated)
 
             expected_update_calls = []
@@ -2773,25 +2767,12 @@ class TestServiceChain(ResourceMappingTestCase):
 
         # Deleting one group should end up deleting the two service chain
         # Instances associated to it
-        req = self.new_delete_request(
-            'policy_target_groups', consumer_ptg1_id)
-        res = req.get_response(self.ext_api)
-        self.assertEqual(res.status_int, webob.exc.HTTPNoContent.code)
-        sc_instances = self._list(SERVICECHAIN_INSTANCES)
-        self.assertEqual(2, len(sc_instances['servicechain_instances']))
-        sc_instances = sc_instances['servicechain_instances']
-        for sc_instance in sc_instances:
-            self.assertNotEqual(sc_instance['consumer_ptg_id'],
-                                consumer_ptg1_id)
-
         req = self.new_delete_request(
             'policy_target_groups', provider_ptg1_id)
         res = req.get_response(self.ext_api)
         self.assertEqual(res.status_int, webob.exc.HTTPNoContent.code)
         sc_instances = self._list(SERVICECHAIN_INSTANCES)
         self.assertEqual(1, len(sc_instances['servicechain_instances']))
-        sc_instance = sc_instances['servicechain_instances'][0]
-        self.assertNotEqual(sc_instance['provider_ptg_id'], provider_ptg1_id)
 
         self._verify_ptg_delete_cleanup_chain(provider_ptg2_id)
 
@@ -2816,6 +2797,7 @@ class TestServiceChain(ResourceMappingTestCase):
         self.create_policy_rule_set(
             name="c1", policy_rules=[parent_policy_rule_id],
             child_policy_rule_sets=[child_prs_id])
+
         provider_ptg_id, consumer_ptg_id = self._create_provider_consumer_ptgs(
                                                             child_prs_id)
 
@@ -2892,7 +2874,7 @@ class TestServiceChain(ResourceMappingTestCase):
         self._assert_proper_chain_instance(
             sc_instances[0], provider_ptg_id, consumer_ptg_id,
             [parent_scs_id, scs2_id], classifier_id=classifier_id)
-        self._verify_ptg_delete_cleanup_chain(consumer_ptg_id)
+        self._verify_ptg_delete_cleanup_chain(provider_ptg_id)
 
     def test_redirect_multiple_ptgs_single_prs(self):
         scs_id = self._create_servicechain_spec()
@@ -2912,19 +2894,14 @@ class TestServiceChain(ResourceMappingTestCase):
         self._verify_prs_rules(policy_rule_set_id)
         sc_instances = self._list(SERVICECHAIN_INSTANCES)
         # We should have 4 service chain instances created now
-        self.assertEqual(len(sc_instances['servicechain_instances']), 4)
+        self.assertEqual(2, len(sc_instances['servicechain_instances']))
         sc_instances = sc_instances['servicechain_instances']
         sc_instances_provider_ptg_ids = set()
-        sc_instances_consumer_ptg_ids = set()
         for sc_instance in sc_instances:
             sc_instances_provider_ptg_ids.add(sc_instance['provider_ptg_id'])
-            sc_instances_consumer_ptg_ids.add(sc_instance['consumer_ptg_id'])
         expected_provider_ptg_ids = set([provider_ptg1_id, provider_ptg2_id])
-        expected_consumer_ptg_ids = set([consumer_ptg1_id, consumer_ptg2_id])
         self.assertEqual(expected_provider_ptg_ids,
                          sc_instances_provider_ptg_ids)
-        self.assertEqual(expected_consumer_ptg_ids,
-                         sc_instances_consumer_ptg_ids)
 
         with mock.patch.object(
                 servicechain_db.ServiceChainDbPlugin,
@@ -2939,7 +2916,7 @@ class TestServiceChain(ResourceMappingTestCase):
             self._verify_prs_rules(policy_rule_set_id)
             sc_instances_updated = self._list(SERVICECHAIN_INSTANCES)[
                                                 'servicechain_instances']
-            self.assertEqual(4, len(sc_instances_updated))
+            self.assertEqual(2, len(sc_instances_updated))
             self.assertEqual(sc_instances, sc_instances_updated)
 
             expected_update_calls = []
@@ -2960,13 +2937,8 @@ class TestServiceChain(ResourceMappingTestCase):
         self.assertEqual(res.status_int, webob.exc.HTTPNoContent.code)
         sc_instances = self._list(SERVICECHAIN_INSTANCES)
         self.assertEqual(2, len(sc_instances['servicechain_instances']))
-        sc_instances = sc_instances['servicechain_instances']
-        for sc_instance in sc_instances:
-            self.assertNotEqual(sc_instance['consumer_ptg_id'],
-                                consumer_ptg1_id)
 
-        req = self.new_delete_request(
-            'policy_target_groups', provider_ptg1_id)
+        req = self.new_delete_request('policy_target_groups', provider_ptg1_id)
         res = req.get_response(self.ext_api)
         self.assertEqual(res.status_int, webob.exc.HTTPNoContent.code)
         sc_instances = self._list(SERVICECHAIN_INSTANCES)
@@ -2999,9 +2971,9 @@ class TestServiceChainAdminOwner(TestServiceChain):
                                       consumer_ptg_id, scs_id_list,
                                       classifier_id=None):
         self.assertEqual(sc_instance['provider_ptg_id'], provider_ptg_id)
-        self.assertEqual(sc_instance['consumer_ptg_id'], consumer_ptg_id)
-        self.assertEqual(scs_id_list, sc_instance['servicechain_specs'])
+        self.assertEqual(sc_instance['consumer_ptg_id'], 'N/A')
         self.assertEqual(sc_instance['tenant_id'], CHAIN_TENANT_ID)
+        self.assertEqual(scs_id_list, sc_instance['servicechain_specs'])
         if classifier_id:
             self.assertEqual(sc_instance['classifier_id'], classifier_id)
 
@@ -3681,11 +3653,9 @@ class TestNetworkServicePolicy(ResourceMappingTestCase):
                             expected_res_status=webob.exc.HTTPCreated.code)
                         self.create_policy_target_group(
                             network_service_policy_id=nsp['id'],
-                            expected_res_status=webob.exc.HTTPCreated.code)[
-                                                        'policy_target_group']
+                            expected_res_status=webob.exc.HTTPCreated.code)
                         self.create_policy_target_group(
-                            expected_res_status=webob.exc.HTTPCreated.code)[
-                                                        'policy_target_group']
+                            expected_res_status=webob.exc.HTTPCreated.code)
                         req = self.new_list_request('l3_policies',
                                                     fmt=self.fmt)
                         l3ps = self.deserialize(self.fmt,
@@ -3716,11 +3686,9 @@ class TestNetworkServicePolicy(ResourceMappingTestCase):
                             network_service_params=[
                                     {"type": "ip_single", "value": "nat_pool",
                                      "name": "vip"}],
-                            expected_res_status=webob.exc.HTTPCreated.code)[
-                                                    'network_service_policy']
+                            expected_res_status=webob.exc.HTTPCreated.code)
                 self.create_policy_target_group(
-                            expected_res_status=webob.exc.HTTPCreated.code)[
-                                                        'policy_target_group']
+                            expected_res_status=webob.exc.HTTPCreated.code)
                 req = self.new_delete_request('nat_pools', nat_pool['id'])
                 res = req.get_response(self.ext_api)
                 self.assertEqual(res.status_int, webob.exc.HTTPNoContent.code)

gbpservice/neutron/tests/unit/services/servicechain/ncp/test_heat_node_driver.py

@@ -148,7 +148,7 @@ class HeatNodeDriverTestCase(
                    new=MockHeatClient).start()
         super(HeatNodeDriverTestCase, self).setUp(
             node_drivers=['heat_node_driver'],
-            node_plumber='agnostic_plumber',
+            node_plumber='stitching_plumber',
             core_plugin=test_gp_driver.CORE_PLUGIN)
 
     def _create_network(self, fmt, name, admin_state_up, **kwargs):
@@ -263,7 +263,7 @@ class TestServiceChainInstance(HeatNodeDriverTestCase):
                     shared=True,
                     name="default",
                     external_routes=routes,
-                    subnet_id=sub['subnet']['id'])['external_segment']
+                    subnet_id=sub['subnet']['id'])
                 return self.create_external_policy(
                     consumed_policy_rule_sets={consumed_prs: ''})
 
@@ -280,9 +280,7 @@ class TestServiceChainInstance(HeatNodeDriverTestCase):
                 expected_res_status=201)['servicechain_spec']
 
             prs = self._create_redirect_prs(spec['id'])['policy_rule_set']
-            provider = self.create_policy_target_group(
-                provided_policy_rule_sets={prs['id']: ''})[
-                                                'policy_target_group']
+            provider = self.create_policy_target_group()['policy_target_group']
 
             _, port1 = self._create_policy_target_port(provider['id'])
             _, port2 = self._create_policy_target_port(provider['id'])
@@ -293,6 +291,8 @@ class TestServiceChainInstance(HeatNodeDriverTestCase):
                 self.create_policy_target_group(
                     consumed_policy_rule_sets={prs['id']: ''})
 
+            self.update_policy_target_group(
+                provider['id'], provided_policy_rule_sets={prs['id']: ''})
             created_stacks_map = self._get_node_instance_stacks(node_id)
             self.assertEqual(1, len(created_stacks_map))
 
@@ -408,18 +408,20 @@ class TestServiceChainInstance(HeatNodeDriverTestCase):
 
     def _get_firewall_rule_dict(self, rule_name, protocol, port, provider_cidr,
                                 consumer_cidr):
-        fw_rule = {rule_name: {'type': "OS::Neutron::FirewallRule",
-                               'properties': {
-                                    "protocol": protocol,
-                                    "enabled": True,
-                                    "destination_port": port,
-                                    "action": "allow",
-                                    "destination_ip_address": provider_cidr,
-                                    "source_ip_address": consumer_cidr
-                               }
-                               }
-                   }
-        return fw_rule
+        if provider_cidr and consumer_cidr:
+            fw_rule = {rule_name: {'type': "OS::Neutron::FirewallRule",
+                                   'properties': {
+                                       "protocol": protocol,
+                                       "enabled": True,
+                                       "destination_port": port,
+                                       "action": "allow",
+                                       "destination_ip_address": provider_cidr,
+                                       "source_ip_address": consumer_cidr
+                                   }
+                                   }
+                       }
+            return fw_rule
+        return {}
 
     def test_fw_node_east_west(self):
         classifier_port = '66'
@@ -433,22 +435,26 @@ class TestServiceChainInstance(HeatNodeDriverTestCase):
             provider = self.create_policy_target_group(
                 provided_policy_rule_sets={prs['id']: ''})[
                                                 'policy_target_group']
-            consumer = self.create_policy_target_group(
-                consumed_policy_rule_sets={prs['id']: ''})[
-                                                'policy_target_group']
+            self.create_policy_target_group(
+                consumed_policy_rule_sets={prs['id']: ''})
 
             created_stacks_map = self._get_node_instance_stacks(node_id)
             self.assertEqual(1, len(created_stacks_map))
             stack_id = created_stacks_map[0].stack_id
 
             provider_cidr = self._get_ptg_cidr(provider)
-            consumer_cidr = self._get_ptg_cidr(consumer)
+            # TODO(ivar): This has to be removed once support to consumer list
+            # is implemented
+            #consumer_cidr = self._get_ptg_cidr(consumer)
+            consumer_cidr = []
             fw_rule = self._get_firewall_rule_dict(
                 'Rule_1', classifier_protocol, classifier_port,
                 provider_cidr, consumer_cidr)
 
             expected_stack_template = copy.deepcopy(
                                         self.DEFAULT_FW_CONFIG_DICT)
+            expected_stack_template['resources'][
+                'test_fw_policy']['properties']['firewall_rules'] = []
             expected_stack_template['resources'].update(fw_rule)
             expected_stack_name = mock.ANY
             expected_stack_params = {}
@@ -457,7 +463,7 @@ class TestServiceChainInstance(HeatNodeDriverTestCase):
                     expected_stack_template,
                     expected_stack_params)
 
-            self._test_node_cleanup(consumer, stack_id)
+            self._test_node_cleanup(provider, stack_id)
 
     def _test_fw_node_north_south(self, consumer_cidrs):
         classifier_port = '66'
@@ -475,8 +481,11 @@ class TestServiceChainInstance(HeatNodeDriverTestCase):
             routes = []
             for consumer_cidr in consumer_cidrs:
                 routes.append({'destination': consumer_cidr, 'nexthop': None})
-            self._create_external_policy(
-                        prs['id'], routes=routes)['external_policy']
+            self._create_external_policy(prs['id'], routes=routes)
+
+            # TODO(ivar): This has to be removed once support to consumer list
+            # is implemented
+            consumer_cidrs = []
 
             created_stacks_map = self._get_node_instance_stacks(node_id)
             self.assertEqual(1, len(created_stacks_map))

gbpservice/neutron/tests/unit/services/servicechain/ncp/test_ncp_plugin.py

@@ -31,11 +31,8 @@ from gbpservice.neutron.services.servicechain.plugins.ncp import (
 from gbpservice.neutron.services.servicechain.plugins.ncp import (
     exceptions as exc)
 import gbpservice.neutron.services.servicechain.plugins.ncp.config  # noqa
-from gbpservice.neutron.services.servicechain.plugins.ncp import model
 from gbpservice.neutron.services.servicechain.plugins.ncp.node_drivers import (
     dummy_driver as dummy_driver)
-from gbpservice.neutron.tests.unit.services.grouppolicy import (
-    test_resource_mapping as test_gp_driver)
 from gbpservice.neutron.tests.unit.services.servicechain import (
     test_servicechain_plugin as test_base)
 
@@ -122,6 +119,8 @@ class NodeCompositionPluginTestCase(
 
     def setUp(self, core_plugin=None, gp_plugin=None, node_drivers=None,
               node_plumber=None):
+        cfg.CONF.set_override(
+            'extension_drivers', ['proxy_group'], group='group_policy')
         if node_drivers:
             cfg.CONF.set_override('node_drivers', node_drivers,
                                   group='node_composition_plugin')
@@ -178,14 +177,13 @@ class NodeCompositionPluginTestCase(
         spec = self.create_servicechain_spec(
             nodes=[node['id']])['servicechain_spec']
         provider = self.create_policy_target_group()['policy_target_group']
-        consumer = self.create_policy_target_group()['policy_target_group']
+        self.create_policy_target_group()
         management = self.create_policy_target_group(
             service_management=True,
             is_admin_context=True)['policy_target_group']
         classifier = self.create_policy_classifier()['policy_classifier']
-
         instance = self.create_servicechain_instance(
-            provider_ptg_id=provider['id'], consumer_ptg_id=consumer['id'],
+            provider_ptg_id=provider['id'], consumer_ptg_id='N/A',
             servicechain_specs=[spec['id']], classifier_id=classifier['id'])[
                                                     'servicechain_instance']
 
@@ -205,7 +203,7 @@ class NodeCompositionPluginTestCase(
         self.assertEqual(ctx.current_profile, profile)
         self.assertEqual(instance['id'], ctx.instance['id'])
         self.assertEqual(provider['id'], ctx.provider['id'])
-        self.assertEqual(consumer['id'], ctx.consumer['id'])
+        self.assertIsNone(ctx.consumer)
         self.assertEqual(management['id'], ctx.management['id'])
         self.assertEqual([spec['id']], [x['id'] for x in ctx.relevant_specs])
         self.assertIsNone(ctx.original_node)
@@ -415,10 +413,9 @@ class NodeCompositionPluginTestCase(
         spec = self.create_servicechain_spec(
             nodes=[node['id']])['servicechain_spec']
         provider = self.create_policy_target_group()['policy_target_group']
-        consumer = self.create_policy_target_group()['policy_target_group']
         classifier = self.create_policy_classifier()['policy_classifier']
         self.create_servicechain_instance(
-            provider_ptg_id=provider['id'], consumer_ptg_id=consumer['id'],
+            provider_ptg_id=provider['id'], consumer_ptg_id='N/A',
             servicechain_specs=[spec['id']], classifier_id=classifier['id'],
             expected_res_status=201)
 
@@ -440,10 +437,9 @@ class NodeCompositionPluginTestCase(
         spec = self.create_servicechain_spec(
             nodes=[node['id']])['servicechain_spec']
         provider = self.create_policy_target_group()['policy_target_group']
-        consumer = self.create_policy_target_group()['policy_target_group']
         classifier = self.create_policy_classifier()['policy_classifier']
         self.create_servicechain_instance(
-            provider_ptg_id=provider['id'], consumer_ptg_id=consumer['id'],
+            provider_ptg_id=provider['id'], consumer_ptg_id='N/A',
             servicechain_specs=[spec['id']], classifier_id=classifier['id'],
             expected_res_status=400)
 
@@ -543,8 +539,8 @@ class NodeCompositionPluginTestCase(
         prs = self._create_redirect_prs(spec['id'])['policy_rule_set']
         provider = self.create_policy_target_group(
             provided_policy_rule_sets={prs['id']: ''})['policy_target_group']
-        consumer = self.create_policy_target_group(
-            consumed_policy_rule_sets={prs['id']: ''})['policy_target_group']
+        self.create_policy_target_group(
+            consumed_policy_rule_sets={prs['id']: ''})
 
         # Verify notification issued for created PT in the provider
         pt = self.create_policy_target(
@@ -557,17 +553,6 @@ class NodeCompositionPluginTestCase(
         self.assertEqual(1, rem.call_count)
         rem.assert_called_with(mock.ANY, pt)
 
-        # Verify notification issued for created PT in the consumer
-        pt = self.create_policy_target(
-            policy_target_group_id=consumer['id'])['policy_target']
-        self.assertEqual(2, add.call_count)
-        add.assert_called_with(mock.ANY, pt)
-
-        # Verify notification issued for deleted PT in the consumer
-        self.delete_policy_target(pt['id'])
-        self.assertEqual(2, rem.call_count)
-        rem.assert_called_with(mock.ANY, pt)
-
     def test_irrelevant_ptg_update(self):
         add = self.driver.update_policy_target_added = mock.Mock()
         rem = self.driver.update_policy_target_removed = mock.Mock()
@@ -644,7 +629,6 @@ class NodeCompositionPluginTestCase(
         spec = self.create_servicechain_spec(
             nodes=[node['id']])['servicechain_spec']
         provider = self.create_policy_target_group()['policy_target_group']
-        consumer = self.create_policy_target_group()['policy_target_group']
 
         # Verify admin created SM is None
         management = self.create_policy_target_group(
@@ -652,7 +636,7 @@ class NodeCompositionPluginTestCase(
             is_admin_context=True)['policy_target_group']
         pc = self.create_policy_classifier()['policy_classifier']
         instance = self.create_servicechain_instance(
-            provider_ptg_id=provider['id'], consumer_ptg_id=consumer['id'],
+            provider_ptg_id=provider['id'], consumer_ptg_id='N/A',
             servicechain_specs=[spec['id']],
             classifier_id=pc['id'])['servicechain_instance']
         ctx = ncp_context.get_node_driver_context(
@@ -666,7 +650,7 @@ class NodeCompositionPluginTestCase(
             service_management=True, tenant_id='admin',
             is_admin_context=True, shared=True)['policy_target_group']
         instance = self.create_servicechain_instance(
-            provider_ptg_id=provider['id'], consumer_ptg_id=consumer['id'],
+            provider_ptg_id=provider['id'], consumer_ptg_id='N/A',
             servicechain_specs=[spec['id']],
             classifier_id=pc['id'])['servicechain_instance']
         # Now admin Service Management PTG is visible
@@ -679,7 +663,7 @@ class NodeCompositionPluginTestCase(
             service_management=True,
             is_admin_context=True)['policy_target_group']
         instance = self.create_servicechain_instance(
-            provider_ptg_id=provider['id'], consumer_ptg_id=consumer['id'],
+            provider_ptg_id=provider['id'], consumer_ptg_id='N/A',
             servicechain_specs=[spec['id']],
             classifier_id=pc['id'])['servicechain_instance']
         ctx = ncp_context.get_node_driver_context(
@@ -687,105 +671,6 @@ class NodeCompositionPluginTestCase(
         self.assertEqual(private_management['id'], ctx.management['id'])
 
 
-class AgnosticChainPlumberTestCase(NodeCompositionPluginTestCase):
-
-    def setUp(self):
-        cfg.CONF.set_override('policy_drivers', ['implicit_policy',
-                                                 'resource_mapping'],
-                              group='group_policy')
-        cfg.CONF.set_override('allow_overlapping_ips', True)
-
-        super(AgnosticChainPlumberTestCase, self).setUp(
-            node_drivers=['node_dummy'], node_plumber='agnostic_plumber',
-            core_plugin=test_gp_driver.CORE_PLUGIN)
-        res = mock.patch('neutron.db.l3_db.L3_NAT_dbonly_mixin.'
-                         '_check_router_needs_rescheduling').start()
-        res.return_value = None
-        self.driver = self.sc_plugin.driver_manager.ordered_drivers[0].obj
-        self.driver.get_plumbing_info = mock.Mock()
-        self.driver.get_plumbing_info.return_value = {}
-
-    def _assert_service_target_tenant(self, policy_target, provider):
-        self.assertEqual(provider['tenant_id'], policy_target['tenant_id'])
-
-    def _create_simple_chain(self):
-        node = self._create_profiled_servicechain_node(
-            service_type="LOADBALANCER",
-            config=self.DEFAULT_LB_CONFIG)['servicechain_node']
-        spec = self.create_servicechain_spec(
-            nodes=[node['id']])['servicechain_spec']
-
-        action = self.create_policy_action(
-            action_type='REDIRECT', action_value=spec['id'])['policy_action']
-        classifier = self.create_policy_classifier(
-            direction='bi', port_range=80, protocol='tcp')['policy_classifier']
-        rule = self.create_policy_rule(
-            policy_classifier_id=classifier['id'],
-            policy_actions=[action['id']])['policy_rule']
-
-        prs = self.create_policy_rule_set(
-            policy_rules=[rule['id']])['policy_rule_set']
-
-        provider = self.create_policy_target_group(
-            provided_policy_rule_sets={prs['id']: ''})['policy_target_group']
-        consumer = self.create_policy_target_group(
-            consumed_policy_rule_sets={prs['id']: ''})['policy_target_group']
-
-        return provider, consumer, node
-
-    def test_one_pt_prov_cons(self):
-        context = n_context.get_admin_context()
-        self.driver.get_plumbing_info.return_value = {'provider': [{}],
-                                                      'consumer': [{}]}
-        provider, consumer, node = self._create_simple_chain()
-
-        # Verify Service PT created and correctly placed
-        prov_cons = {'provider': provider, 'consumer': consumer}
-        targets = model.get_service_targets(context.session)
-        self.assertEqual(2, len(targets))
-        old_relationship = None
-        for target in targets:
-            self.assertEqual(node['id'], target.servicechain_node_id)
-            pt = self.show_policy_target(
-                target.policy_target_id,
-                is_admin_context=True)['policy_target']
-            self.assertEqual(prov_cons[target.relationship]['id'],
-                             pt['policy_target_group_id'])
-            self._assert_service_target_tenant(pt, provider)
-            self.assertNotEqual(old_relationship, target.relationship)
-            old_relationship = target.relationship
-
-        self.update_policy_target_group(
-            provider['id'], provided_policy_rule_sets={})
-        # With chain deletion, also the Service PTs are deleted
-        new_targets = model.get_service_targets(context.session)
-        self.assertEqual(0, len(new_targets))
-        for target in targets:
-            self.show_policy_target(
-                target.policy_target_id, is_admin_context=True,
-                expected_res_status=404)
-
-    def test_pt_override(self):
-        context = n_context.get_admin_context()
-        test_name = 'test_name'
-        self.driver.get_plumbing_info.return_value = {
-            'provider': [{'name': test_name}]}
-        self._create_simple_chain()
-        targets = model.get_service_targets(context.session)
-        self.assertEqual(1, len(targets))
-        pt = self.show_policy_target(
-            targets[0].policy_target_id,
-            is_admin_context=True)['policy_target']
-        self.assertEqual(test_name, pt['name'])
-
-    def test_ptg_delete(self):
-        self.driver.get_plumbing_info.return_value = {'provider': [{}],
-                                                      'consumer': [{}]}
-        provider, _, _ = self._create_simple_service_chain()
-        self.delete_policy_target_group(provider['id'],
-                                        expected_res_status=204)
-
-
 class TestQuotasForServiceChain(test_base.ServiceChainPluginTestCase):
 
     @property
@@ -861,30 +746,4 @@ class TestQuotasForServiceChain(test_base.ServiceChainPluginTestCase):
         # creation error
         self.assertRaises(webob.exc.HTTPClientError,
                           self.create_policy_target_group,
-                          consumed_policy_rule_sets={prs['id']: ''})
-
-
-class AgnosticChainPlumberAdminOwner(AgnosticChainPlumberTestCase):
-
-    def setUp(self):
-        mock.patch('gbpservice.neutron.services.grouppolicy.drivers.'
-                   'resource_mapping.ResourceMappingDriver.'
-                   'chain_tenant_keystone_client').start()
-        res = mock.patch('gbpservice.neutron.services.grouppolicy.drivers.'
-                         'resource_mapping.ResourceMappingDriver.'
-                         'chain_tenant_id').start()
-        res.return_value = CHAIN_TENANT_ID
-        super(AgnosticChainPlumberAdminOwner, self).setUp()
-
-    def _assert_service_target_tenant(self, policy_target, provider):
-        self.assertEqual(CHAIN_TENANT_ID, policy_target['tenant_id'])
-
-    def test_update_service_chain(self):
-        # This directly updates the SCI, which requires the right tenant to be
-        # done
-        pass
-
-    def test_instance_update(self):
-        # This directly updates the SCI, which requires the right tenant to be
-        # done
-        pass
+                          provided_policy_rule_sets={prs['id']: ''})

gbpservice/tests/contrib/devstack/local.conf

@@ -75,13 +75,14 @@ plugin_dirs=/opt/stack/gbpautomation/gbpautomation/heat
 [[post-config|/etc/neutron/neutron.conf]]
 [group_policy]
 policy_drivers=implicit_policy,resource_mapping
+extension_drivers=proxy_group
 
 [servicechain]
 servicechain_drivers = simplechain_driver
 #servicechain_drivers = chain_with_two_arm_appliance_driver
 
 [node_composition_plugin]
-node_plumber = agnostic_plumber
+node_plumber = stitching_plumber
 node_drivers = heat_node_driver
 
 [quotas]

gbpservice/tests/contrib/gbpfunctests/libs/config_libs.py

@@ -164,9 +164,13 @@ class Gbp_Config(object):
             cmd = 'gbp %s-update ' % cfgobj_dict[cfgobj] + str(name_uuid)
         # Build the cmd string for optional/non-default args/values
         for arg, value in kwargs.items():
-            if '_' in arg:
+            if arg.startswith('_'):
+                # Parameter not supported by CLI, leave it as is
+                arg = arg[1:]
+                cmd = cmd + " --" + "%s %s" % (arg, value)
+            else:
                 arg = string.replace(arg, '_', '-')
-            cmd = cmd + " --" + "%s=%s" % (arg, value)
+                cmd = cmd + " --" + "%s=%s" % (arg, value)
         _log.info(cmd)
         # Execute the cmd
         cmd_out = commands.getoutput(cmd)

gbpservice/tests/contrib/gbpfunctests/testcases/tc_gbp_ptg_func.py

@@ -113,7 +113,8 @@ class test_gbp_ptg_func(object):
             return 0
         l3p_uuid = self.gbpcfg.gbp_policy_cfg_all(
             1, 'l3p', self.l3p_name, ip_pool='20.20.0.0/24',
-            subnet_prefix_length='28')
+            subnet_prefix_length='28', _proxy_ip_pool='20.20.1.0/24',
+            _proxy_subnet_prefix_length='28')
         if l3p_uuid == 0:
             self._log.info(
                 "\n## Reqd L3Policy Create Failed, hence GBP Policy "

setup.cfg

@@ -70,7 +70,6 @@ gbpservice.neutron.servicechain.ncp_drivers =
     heat_node_driver = gbpservice.neutron.services.servicechain.plugins.ncp.node_drivers.heat_node_driver:HeatNodeDriver
 gbpservice.neutron.servicechain.ncp_plumbers =
     dummy_plumber = gbpservice.neutron.services.servicechain.plugins.ncp.node_plumbers.dummy_plumber:NoopPlumber
-    agnostic_plumber = gbpservice.neutron.services.servicechain.plugins.ncp.node_plumbers.chain_agnostic_plumber:ChainAgnosticPlumber
     stitching_plumber = gbpservice.neutron.services.servicechain.plugins.ncp.node_plumbers.traffic_stitching_plumber:TrafficStitchingPlumber
 
 [build_sphinx]