Implement neutron health monitor resource

The branch adds a new resource creating health-monitor instances in
Neutron LBAAS.

Implements: blueprint lbaas-resources
Change-Id: Ie133f9c55bf57166e1999bbc0f11fd9b9519c1c2

diff --git a/heat/engine/resources/neutron/loadbalancer.py b/heat/engine/resources/neutron/loadbalancer.py
new file mode 100644 (file)
index 0000000..a6dc9ff
--- /dev/null
+++ b/heat/engine/resources/neutron/loadbalancer.py
@@ -0,0 +1,97 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#
+#    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 heat.engine import clients
+from heat.engine import scheduler
+from heat.engine.resources.neutron import neutron
+
+if clients.neutronclient is not None:
+    from neutronclient.common.exceptions import NeutronClientException
+
+
+class HealthMonitor(neutron.NeutronResource):
+    """
+    A resource for managing health monitors for load balancers in Neutron.
+    """
+
+    properties_schema = {
+        'delay': {'Type': 'Integer', 'Required': True},
+        'type': {'Type': 'String', 'Required': True,
+                 'AllowedValues': ['PING', 'TCP', 'HTTP', 'HTTPS']},
+        'max_retries': {'Type': 'Integer', 'Required': True},
+        'timeout': {'Type': 'Integer', 'Required': True},
+        'admin_state_up': {'Default': True, 'Type': 'Boolean'},
+        'http_method': {'Type': 'String'},
+        'expected_codes': {'Type': 'String'},
+        'url_path': {'Type': 'String'},
+    }
+
+    update_allowed_keys = ('Properties',)
+    update_allowed_properties = ('delay', 'max_retries', 'timeout',
+                                 'admin_state_up', 'http_method',
+                                 'expected_codes', 'url_path')
+
+    attributes_schema = {
+        'admin_state_up': 'the administrative state of this port',
+        'delay': 'the minimum time in seconds between regular connections '
+                 'of the member',
+        'expected_codes': 'the list of HTTP status codes expected in '
+                          'response from the member to declare it healthy',
+        'http_method': 'the HTTP method used for requests by the monitor of '
+                       'type HTTP',
+        'id': 'unique identifier for this health monitor',
+        'max_retries': 'number of permissible connection failures before '
+                       'changing the member status to INACTIVE.',
+        'timeout': 'maximum number of seconds for a monitor to wait for a '
+                   'connection to be established before it times out',
+        'type': 'one of predefined health monitor types',
+        'url_path': 'the HTTP path used in the HTTP request used by the '
+                    'monitor to test a member health',
+        'tenant_id': 'tenant owning the health monitor',
+    }
+
+    def handle_create(self):
+        properties = self.prepare_properties(
+            self.properties,
+            self.physical_resource_name())
+        health_monitor = self.neutron().create_health_monitor(
+            {'health_monitor': properties})['health_monitor']
+        self.resource_id_set(health_monitor['id'])
+
+    def _show_resource(self):
+        return self.neutron().show_health_monitor(
+            self.resource_id)['health_monitor']
+
+    def handle_update(self, json_snippet, tmpl_diff, prop_diff):
+        self.neutron().update_health_monitor(
+            self.resource_id, {'health_monitor': prop_diff})
+
+    def handle_delete(self):
+        try:
+            self.neutron().delete_health_monitor(self.resource_id)
+        except NeutronClientException as ex:
+            if ex.status_code != 404:
+                raise ex
+        else:
+            return scheduler.TaskRunner(self._confirm_delete)()
+
+
+def resource_mapping():
+    if clients.neutronclient is None:
+        return {}
+
+    return {
+        'OS::Neutron::HealthMonitor': HealthMonitor,
+    }

diff --git a/heat/tests/test_neutron_loadbalancer.py b/heat/tests/test_neutron_loadbalancer.py
new file mode 100644 (file)
index 0000000..a4cbbe8
--- /dev/null
+++ b/heat/tests/test_neutron_loadbalancer.py
@@ -0,0 +1,168 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#    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.
+
+import copy
+
+from testtools import skipIf
+
+from heat.common import exception
+from heat.common import template_format
+from heat.engine import clients
+from heat.engine import scheduler
+from heat.engine.resources.neutron import loadbalancer
+from heat.openstack.common.importutils import try_import
+from heat.tests import fakes
+from heat.tests import utils
+from heat.tests.common import HeatTestCase
+
+neutronclient = try_import('neutronclient.v2_0.client')
+
+health_monitor_template = '''
+{
+  "AWSTemplateFormatVersion" : "2010-09-09",
+  "Description" : "Template to test load balancer resources",
+  "Parameters" : {},
+  "Resources" : {
+    "monitor": {
+      "Type": "OS::Neutron::HealthMonitor",
+      "Properties": {
+        "type": "HTTP",
+        "delay": 3,
+        "max_retries": 5,
+        "timeout": 10
+      }
+    }
+  }
+}
+'''
+
+
+@skipIf(neutronclient is None, 'neutronclient unavailable')
+class HealthMonitorTest(HeatTestCase):
+
+    def setUp(self):
+        super(HealthMonitorTest, self).setUp()
+        self.m.StubOutWithMock(neutronclient.Client, 'create_health_monitor')
+        self.m.StubOutWithMock(neutronclient.Client, 'delete_health_monitor')
+        self.m.StubOutWithMock(neutronclient.Client, 'show_health_monitor')
+        self.m.StubOutWithMock(neutronclient.Client, 'update_health_monitor')
+        self.m.StubOutWithMock(clients.OpenStackClients, 'keystone')
+        utils.setup_dummy_db()
+
+    def create_health_monitor(self):
+        clients.OpenStackClients.keystone().AndReturn(
+            fakes.FakeKeystoneClient())
+        neutronclient.Client.create_health_monitor({
+            'health_monitor': {
+                'delay': 3, 'max_retries': 5, 'type': u'HTTP',
+                'timeout': 10, 'admin_state_up': True}}
+        ).AndReturn({'health_monitor': {'id': '5678'}})
+
+        snippet = template_format.parse(health_monitor_template)
+        stack = utils.parse_stack(snippet)
+        return loadbalancer.HealthMonitor(
+            'monitor', snippet['Resources']['monitor'], stack)
+
+    def test_create(self):
+        rsrc = self.create_health_monitor()
+        self.m.ReplayAll()
+        scheduler.TaskRunner(rsrc.create)()
+        self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
+        self.m.VerifyAll()
+
+    def test_create_failed(self):
+        clients.OpenStackClients.keystone().AndReturn(
+            fakes.FakeKeystoneClient())
+        neutronclient.Client.create_health_monitor({
+            'health_monitor': {
+                'delay': 3, 'max_retries': 5, 'type': u'HTTP',
+                'timeout': 10, 'admin_state_up': True}}
+        ).AndRaise(loadbalancer.NeutronClientException())
+        self.m.ReplayAll()
+
+        snippet = template_format.parse(health_monitor_template)
+        stack = utils.parse_stack(snippet)
+        rsrc = loadbalancer.HealthMonitor(
+            'monitor', snippet['Resources']['monitor'], stack)
+        self.assertRaises(exception.ResourceFailure,
+                          scheduler.TaskRunner(rsrc.create))
+        self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state)
+        self.m.VerifyAll()
+
+    def test_delete(self):
+        neutronclient.Client.delete_health_monitor('5678').AndReturn(None)
+        neutronclient.Client.show_health_monitor('5678').AndRaise(
+            loadbalancer.NeutronClientException(status_code=404))
+
+        rsrc = self.create_health_monitor()
+        self.m.ReplayAll()
+        scheduler.TaskRunner(rsrc.create)()
+        scheduler.TaskRunner(rsrc.delete)()
+        self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state)
+        self.m.VerifyAll()
+
+    def test_delete_already_gone(self):
+        neutronclient.Client.delete_health_monitor('5678').AndRaise(
+            loadbalancer.NeutronClientException(status_code=404))
+
+        rsrc = self.create_health_monitor()
+        self.m.ReplayAll()
+        scheduler.TaskRunner(rsrc.create)()
+        scheduler.TaskRunner(rsrc.delete)()
+        self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state)
+        self.m.VerifyAll()
+
+    def test_delete_failed(self):
+        neutronclient.Client.delete_health_monitor('5678').AndRaise(
+            loadbalancer.NeutronClientException(status_code=400))
+
+        rsrc = self.create_health_monitor()
+        self.m.ReplayAll()
+        scheduler.TaskRunner(rsrc.create)()
+        self.assertRaises(exception.ResourceFailure,
+                          scheduler.TaskRunner(rsrc.delete))
+        self.assertEqual((rsrc.DELETE, rsrc.FAILED), rsrc.state)
+        self.m.VerifyAll()
+
+    def test_attribute(self):
+        rsrc = self.create_health_monitor()
+        neutronclient.Client.show_health_monitor('5678').MultipleTimes(
+        ).AndReturn(
+            {'health_monitor': {'admin_state_up': True, 'delay': 3}})
+        self.m.ReplayAll()
+        scheduler.TaskRunner(rsrc.create)()
+        self.assertEqual(True, rsrc.FnGetAtt('admin_state_up'))
+        self.assertEqual(3, rsrc.FnGetAtt('delay'))
+        self.m.VerifyAll()
+
+    def test_attribute_failed(self):
+        rsrc = self.create_health_monitor()
+        self.m.ReplayAll()
+        scheduler.TaskRunner(rsrc.create)()
+        self.assertRaises(exception.InvalidTemplateAttribute,
+                          rsrc.FnGetAtt, 'subnet_id')
+        self.m.VerifyAll()
+
+    def test_update(self):
+        rsrc = self.create_health_monitor()
+        neutronclient.Client.update_health_monitor(
+            '5678', {'health_monitor': {'delay': 10}}).AndReturn(None)
+        self.m.ReplayAll()
+        scheduler.TaskRunner(rsrc.create)()
+
+        update_template = copy.deepcopy(rsrc.t)
+        update_template['Properties']['delay'] = 10
+        self.assertEqual(None, rsrc.update(update_template))
+
+        self.m.VerifyAll()