Merge "Support neutron QoSDscpMarkingRule resource plugin"

heat/engine/resources/openstack/neutron/qos.py

@@ -213,8 +213,76 @@ class QoSBandwidthLimitRule(QoSRule):
             self.resource_id, self.policy_id)['bandwidth_limit_rule']
 
 
+class QoSDscpMarkingRule(QoSRule):
+    """A resource for Neutron QoS DSCP marking rule.
+
+    This rule can be associated with QoS policy, and then the policy
+    can be used by neutron port and network, to provide DSCP marking
+    QoS capabilities.
+
+    The default policy usage of this resource is limited to
+    administrators only.
+    """
+
+    support_status = support.SupportStatus(version='7.0.0')
+
+    PROPERTIES = (
+        DSCP_MARK,
+    ) = (
+        'dscp_mark',
+    )
+
+    properties_schema = {
+        DSCP_MARK: properties.Schema(
+            properties.Schema.INTEGER,
+            _('DSCP mark between 0 and 56, except 2-6, 42, 44, and 50-54.'),
+            required=True,
+            update_allowed=True,
+            constraints=[
+                constraints.AllowedValues([
+                    0, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34,
+                    36, 38, 40, 46, 48, 56]
+                )
+            ]
+        )
+    }
+
+    properties_schema.update(QoSRule.properties_schema)
+
+    def handle_create(self):
+        props = self.prepare_properties(self.properties,
+                                        self.physical_resource_name())
+        props.pop(self.POLICY)
+
+        rule = self.client().create_dscp_marking_rule(
+            self.policy_id,
+            {'dscp_marking_rule': props})['dscp_marking_rule']
+
+        self.resource_id_set(rule['id'])
+
+    def handle_delete(self):
+        if self.resource_id is None:
+            return
+
+        with self.client_plugin().ignore_not_found:
+            self.client().delete_dscp_marking_rule(
+                self.resource_id, self.policy_id)
+
+    def handle_update(self, json_snippet, tmpl_diff, prop_diff):
+        if prop_diff:
+            self.client().update_dscp_marking_rule(
+                self.resource_id,
+                self.policy_id,
+                {'dscp_marking_rule': prop_diff})
+
+    def _show_resource(self):
+        return self.client().show_dscp_marking_rule(
+            self.resource_id, self.policy_id)['dscp_marking_rule']
+
+
 def resource_mapping():
     return {
         'OS::Neutron::QoSPolicy': QoSPolicy,
-        'OS::Neutron::QoSBandwidthLimitRule': QoSBandwidthLimitRule
+        'OS::Neutron::QoSBandwidthLimitRule': QoSBandwidthLimitRule,
+        'OS::Neutron::QoSDscpMarkingRule': QoSDscpMarkingRule
     }

heat/tests/openstack/neutron/test_qos.py

@@ -46,6 +46,18 @@ resources:
       tenant_id: d66c74c01d6c41b9846088c1ad9634d0
 '''
 
+dscp_marking_rule_template = '''
+heat_template_version: 2016-04-08
+description: This template to define a neutron DSCP marking rule.
+resources:
+  my_dscp_marking_rule:
+    type: OS::Neutron::QoSDscpMarkingRule
+    properties:
+      policy: 477e8273-60a7-4c41-b683-fdb0bc7cd151
+      dscp_mark: 16
+      tenant_id: d66c74c01d6c41b9846088c1ad9634d0
+'''
+
 
 class NeutronQoSPolicyTest(common.HeatTestCase):
     def setUp(self):
@@ -276,3 +288,110 @@ class NeutronQoSBandwidthLimitRuleTest(common.HeatTestCase):
 
         self.neutronclient.show_bandwidth_limit_rule.assert_called_once_with(
             self.bandwidth_limit_rule.resource_id, self.policy_id)
+
+
+class NeutronQoSDscpMarkingRuleTest(common.HeatTestCase):
+    def setUp(self):
+        super(NeutronQoSDscpMarkingRuleTest, self).setUp()
+
+        utils.setup_dummy_db()
+        self.ctx = utils.dummy_context()
+
+        tpl = template_format.parse(dscp_marking_rule_template)
+        self.stack = stack.Stack(
+            self.ctx,
+            'neutron_dscp_marking_rule_test',
+            template.Template(tpl)
+        )
+
+        self.neutronclient = mock.MagicMock()
+        self.patchobject(neutron.NeutronClientPlugin, 'has_extension',
+                         return_value=True)
+        self.dscp_marking_rule = self.stack['my_dscp_marking_rule']
+        self.dscp_marking_rule.client = mock.MagicMock(
+            return_value=self.neutronclient)
+        self.find_mock = self.patchobject(
+            neutron.neutronV20,
+            'find_resourceid_by_name_or_id')
+        self.policy_id = '477e8273-60a7-4c41-b683-fdb0bc7cd151'
+        self.find_mock.return_value = self.policy_id
+
+    def test_rule_handle_create(self):
+        rule = {
+            'dscp_marking_rule': {
+                'id': 'cf0eab12-ef8b-4a62-98d0-70576583c17a',
+                'dscp_mark': 16,
+                'tenant_id': 'd66c74c01d6c41b9846088c1ad9634d0'
+            }
+        }
+
+        create_props = {'dscp_mark': 16,
+                        'tenant_id': 'd66c74c01d6c41b9846088c1ad9634d0'}
+        self.neutronclient.create_dscp_marking_rule.return_value = rule
+
+        self.dscp_marking_rule.handle_create()
+        self.assertEqual('cf0eab12-ef8b-4a62-98d0-70576583c17a',
+                         self.dscp_marking_rule.resource_id)
+        self.neutronclient.create_dscp_marking_rule.assert_called_once_with(
+            self.policy_id,
+            {'dscp_marking_rule': create_props})
+
+    def test_rule_handle_delete(self):
+        rule_id = 'cf0eab12-ef8b-4a62-98d0-70576583c17a'
+        self.dscp_marking_rule.resource_id = rule_id
+        self.neutronclient.delete_dscp_marking_rule.return_value = None
+
+        self.assertIsNone(self.dscp_marking_rule.handle_delete())
+        self.neutronclient.delete_dscp_marking_rule.assert_called_once_with(
+            rule_id, self.policy_id)
+
+    def test_rule_handle_delete_not_found(self):
+        rule_id = 'cf0eab12-ef8b-4a62-98d0-70576583c17a'
+        self.dscp_marking_rule.resource_id = rule_id
+        not_found = self.neutronclient.NotFound
+        self.neutronclient.delete_dscp_marking_rule.side_effect = not_found
+
+        self.assertIsNone(self.dscp_marking_rule.handle_delete())
+        self.neutronclient.delete_dscp_marking_rule.assert_called_once_with(
+            rule_id, self.policy_id)
+
+    def test_rule_handle_delete_resource_id_is_none(self):
+        self.dscp_marking_rule.resource_id = None
+        self.assertIsNone(self.dscp_marking_rule.handle_delete())
+        self.assertEqual(0,
+                         self.neutronclient.dscp_marking_rule.call_count)
+
+    def test_rule_handle_update(self):
+        rule_id = 'cf0eab12-ef8b-4a62-98d0-70576583c17a'
+        self.dscp_marking_rule.resource_id = rule_id
+
+        prop_diff = {
+            'dscp_mark': 8
+        }
+
+        self.dscp_marking_rule.handle_update(
+            json_snippet={},
+            tmpl_diff={},
+            prop_diff=prop_diff)
+
+        self.neutronclient.update_dscp_marking_rule.assert_called_once_with(
+            rule_id,
+            self.policy_id,
+            {'dscp_marking_rule': prop_diff})
+
+    def test_rule_get_attr(self):
+        self.dscp_marking_rule.resource_id = 'test rule'
+        rule = {
+            'dscp_marking_rule': {
+                'id': 'cf0eab12-ef8b-4a62-98d0-70576583c17a',
+                'dscp_mark': 8,
+                'tenant_id': 'd66c74c01d6c41b9846088c1ad9634d0'
+            }
+        }
+        self.neutronclient.show_dscp_marking_rule.return_value = rule
+
+        self.assertEqual(rule['dscp_marking_rule'],
+                         self.dscp_marking_rule.FnGetAtt('show'))
+
+        self.neutronclient.show_dscp_marking_rule.assert_called_once_with(
+            self.dscp_marking_rule.resource_id, self.policy_id)