From b9da1c07f12c534d0bd924dcad48327ada864d43 Mon Sep 17 00:00:00 2001 From: Thomas Herve Date: Tue, 6 Aug 2013 11:32:40 +0200 Subject: [PATCH] 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 --- heat/engine/resources/neutron/loadbalancer.py | 97 ++++++++++ heat/tests/test_neutron_loadbalancer.py | 168 ++++++++++++++++++ 2 files changed, 265 insertions(+) create mode 100644 heat/engine/resources/neutron/loadbalancer.py create mode 100644 heat/tests/test_neutron_loadbalancer.py diff --git a/heat/engine/resources/neutron/loadbalancer.py b/heat/engine/resources/neutron/loadbalancer.py new file mode 100644 index 00000000..a6dc9ffb --- /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 index 00000000..a4cbbe8b --- /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() -- 2.45.2