You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4562 lines
196 KiB
4562 lines
196 KiB
# |
|
# 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 collections |
|
import datetime |
|
import eventlet |
|
import itertools |
|
import json |
|
import os |
|
import sys |
|
import uuid |
|
|
|
import mock |
|
from oslo_config import cfg |
|
import six |
|
|
|
from heat.common import exception |
|
from heat.common.i18n import _ |
|
from heat.common import short_id |
|
from heat.common import timeutils |
|
from heat.db.sqlalchemy import api as db_api |
|
from heat.db.sqlalchemy import models |
|
from heat.engine import attributes |
|
from heat.engine.cfn import functions as cfn_funcs |
|
from heat.engine import clients |
|
from heat.engine import constraints |
|
from heat.engine import dependencies |
|
from heat.engine import environment |
|
from heat.engine import node_data |
|
from heat.engine import plugin_manager |
|
from heat.engine import properties |
|
from heat.engine import resource |
|
from heat.engine import resources |
|
from heat.engine.resources.openstack.heat import none_resource |
|
from heat.engine.resources.openstack.heat import test_resource |
|
from heat.engine import rsrc_defn |
|
from heat.engine import scheduler |
|
from heat.engine import stack as parser |
|
from heat.engine import support |
|
from heat.engine import template |
|
from heat.engine import translation |
|
from heat.objects import resource as resource_objects |
|
from heat.objects import resource_data as resource_data_object |
|
from heat.objects import resource_properties_data as rpd_object |
|
from heat.tests import common |
|
from heat.tests.engine import tools |
|
from heat.tests import generic_resource as generic_rsrc |
|
from heat.tests import utils |
|
|
|
import neutronclient.common.exceptions as neutron_exp |
|
|
|
|
|
empty_template = {"HeatTemplateFormatVersion": "2012-12-12"} |
|
|
|
|
|
class ResourceTest(common.HeatTestCase): |
|
def setUp(self): |
|
super(ResourceTest, self).setUp() |
|
|
|
self.env = environment.Environment() |
|
self.env.load({u'resource_registry': |
|
{u'OS::Test::GenericResource': u'GenericResourceType', |
|
u'OS::Test::ResourceWithCustomConstraint': |
|
u'ResourceWithCustomConstraint'}}) |
|
|
|
self.stack = parser.Stack(utils.dummy_context(), 'test_stack', |
|
template.Template(empty_template, |
|
env=self.env), |
|
stack_id=str(uuid.uuid4())) |
|
self.dummy_timeout = 10 |
|
self.dummy_event = eventlet.event.Event() |
|
|
|
def test_get_class_ok(self): |
|
cls = resources.global_env().get_class_to_instantiate( |
|
'GenericResourceType') |
|
self.assertEqual(generic_rsrc.GenericResource, cls) |
|
|
|
def test_get_class_noexist(self): |
|
self.assertRaises(exception.StackValidationFailed, |
|
resources.global_env().get_class_to_instantiate, |
|
'NoExistResourceType') |
|
|
|
def test_resource_new_ok(self): |
|
snippet = rsrc_defn.ResourceDefinition('aresource', |
|
'GenericResourceType') |
|
res = resource.Resource('aresource', snippet, self.stack) |
|
self.assertIsInstance(res, generic_rsrc.GenericResource) |
|
self.assertEqual("INIT", res.action) |
|
|
|
def test_resource_load_with_state(self): |
|
self.stack = parser.Stack(utils.dummy_context(), 'test_stack', |
|
template.Template(empty_template)) |
|
self.stack.store() |
|
snippet = rsrc_defn.ResourceDefinition('aresource', |
|
'GenericResourceType') |
|
# Store Resource |
|
res = resource.Resource('aresource', snippet, self.stack) |
|
res.current_template_id = self.stack.t.id |
|
res.state_set('CREATE', 'IN_PROGRESS') |
|
self.stack.add_resource(res) |
|
loaded_res, res_owning_stack, stack = resource.Resource.load( |
|
self.stack.context, res.id, |
|
self.stack.current_traversal, True, {}) |
|
self.assertEqual(loaded_res.id, res.id) |
|
self.assertEqual(self.stack.t, stack.t) |
|
|
|
def test_resource_load_with_state_cleanup(self): |
|
self.old_stack = parser.Stack( |
|
utils.dummy_context(), 'test_old_stack', |
|
template.Template({ |
|
'HeatTemplateFormatVersion': '2012-12-12', |
|
'Resources': { |
|
'test_res': {'Type': 'ResourceWithPropsType', |
|
'Properties': {'Foo': 'abc'}}}})) |
|
self.old_stack.store() |
|
self.new_stack = parser.Stack(utils.dummy_context(), 'test_new_stack', |
|
template.Template(empty_template)) |
|
self.new_stack.store() |
|
snippet = rsrc_defn.ResourceDefinition('aresource', |
|
'GenericResourceType') |
|
# Store Resource |
|
res = resource.Resource('aresource', snippet, self.old_stack) |
|
res.current_template_id = self.old_stack.t.id |
|
res.state_set('CREATE', 'IN_PROGRESS') |
|
self.old_stack.add_resource(res) |
|
loaded_res, res_owning_stack, stack = resource.Resource.load( |
|
self.old_stack.context, res.id, |
|
self.stack.current_traversal, False, {}) |
|
self.assertEqual(loaded_res.id, res.id) |
|
self.assertEqual(self.old_stack.t, stack.t) |
|
self.assertNotEqual(self.new_stack.t, stack.t) |
|
|
|
def test_resource_load_with_no_resources(self): |
|
self.stack = parser.Stack( |
|
utils.dummy_context(), 'test_old_stack', |
|
template.Template({ |
|
'HeatTemplateFormatVersion': '2012-12-12', |
|
'Resources': { |
|
'test_res': {'Type': 'ResourceWithPropsType', |
|
'Properties': {'Foo': 'abc'}}}})) |
|
self.stack.store() |
|
snippet = rsrc_defn.ResourceDefinition('aresource', |
|
'GenericResourceType') |
|
# Store Resource |
|
res = resource.Resource('aresource', snippet, self.stack) |
|
res.current_template_id = self.stack.t.id |
|
res.state_set('CREATE', 'IN_PROGRESS') |
|
self.stack.add_resource(res) |
|
origin_resources = self.stack.resources |
|
self.stack._resources = None |
|
|
|
loaded_res, res_owning_stack, stack = resource.Resource.load( |
|
self.stack.context, res.id, |
|
self.stack.current_traversal, False, {}) |
|
self.assertEqual(origin_resources, stack.resources) |
|
self.assertEqual(loaded_res.id, res.id) |
|
self.assertEqual(self.stack.t, stack.t) |
|
|
|
def test_resource_invalid_name(self): |
|
snippet = rsrc_defn.ResourceDefinition('wrong/name', |
|
'GenericResourceType') |
|
ex = self.assertRaises(exception.StackValidationFailed, |
|
resource.Resource, 'wrong/name', |
|
snippet, self.stack) |
|
self.assertEqual('Resource name may not contain "/"', |
|
six.text_type(ex)) |
|
|
|
@mock.patch.object(translation, 'resolve_and_find') |
|
@mock.patch.object(parser.Stack, 'db_resource_get') |
|
@mock.patch.object(resource.Resource, '_load_data') |
|
@mock.patch.object(resource.Resource, 'translate_properties') |
|
def test_stack_resources(self, mock_translate, mock_load, |
|
mock_db_get, mock_resolve): |
|
tpl = {'HeatTemplateFormatVersion': '2012-12-12', |
|
'Resources': |
|
{'A': {'Type': 'ResourceWithPropsType', |
|
'Properties': {'Foo': 'abc'}}}} |
|
|
|
stack = parser.Stack(utils.dummy_context(), |
|
'test_stack', |
|
template.Template(tpl)) |
|
stack.store() |
|
mock_db_get.return_value = None |
|
self.assertEqual(1, len(stack.resources)) |
|
self.assertEqual(1, mock_translate.call_count) |
|
self.assertEqual(0, mock_load.call_count) |
|
|
|
# set stack._resources = None to reload the resources |
|
stack._resources = None |
|
mock_db_get.return_value = mock.Mock() |
|
self.assertEqual(1, len(stack.resources)) |
|
self.assertEqual(2, mock_translate.call_count) |
|
self.assertEqual(1, mock_load.call_count) |
|
self.assertEqual(0, mock_resolve.call_count) |
|
|
|
def test_resource_new_stack_not_stored(self): |
|
snippet = rsrc_defn.ResourceDefinition('aresource', |
|
'GenericResourceType') |
|
self.stack.id = None |
|
db_method = 'get_by_name_and_stack' |
|
with mock.patch.object(resource_objects.Resource, |
|
db_method) as resource_get: |
|
res = resource.Resource('aresource', snippet, self.stack) |
|
self.assertEqual("INIT", res.action) |
|
self.assertIs(False, resource_get.called) |
|
|
|
def test_resource_new_err(self): |
|
snippet = rsrc_defn.ResourceDefinition('aresource', |
|
'NoExistResourceType') |
|
self.assertRaises(exception.StackValidationFailed, |
|
resource.Resource, 'aresource', snippet, self.stack) |
|
|
|
def test_resource_non_type(self): |
|
resource_name = 'aresource' |
|
snippet = rsrc_defn.ResourceDefinition(resource_name, '') |
|
ex = self.assertRaises(exception.StackValidationFailed, |
|
resource.Resource, resource_name, |
|
snippet, self.stack) |
|
self.assertIn(_('Resource "%s" has no type') % resource_name, |
|
six.text_type(ex)) |
|
|
|
def test_state_defaults(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_res_def', 'Foo') |
|
res = generic_rsrc.GenericResource('test_res_def', tmpl, self.stack) |
|
self.assertEqual((res.INIT, res.COMPLETE), res.state) |
|
self.assertEqual('', res.status_reason) |
|
|
|
def test_signal_wrong_action_state(self): |
|
snippet = rsrc_defn.ResourceDefinition('res', |
|
'GenericResourceType') |
|
res = resource.Resource('res', snippet, self.stack) |
|
actions = [res.SUSPEND, res.DELETE] |
|
for action in actions: |
|
for status in res.STATUSES: |
|
res.state_set(action, status) |
|
ev = self.patchobject(res, '_add_event') |
|
ex = self.assertRaises(exception.NotSupported, |
|
res.signal) |
|
self.assertEqual('Signal resource during %s is not ' |
|
'supported.' % action, six.text_type(ex)) |
|
ev.assert_called_with( |
|
action, status, |
|
'Cannot signal resource during %s' % action) |
|
|
|
def test_resource_str_repr_stack_id_resource_id(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_res_str_repr', 'Foo') |
|
res = generic_rsrc.GenericResource('test_res_str_repr', tmpl, |
|
self.stack) |
|
res.stack.id = "123" |
|
res.resource_id = "456" |
|
expected = ('GenericResource "test_res_str_repr" [456] Stack ' |
|
'"test_stack" [123]') |
|
observed = str(res) |
|
self.assertEqual(expected, observed) |
|
|
|
def test_resource_str_repr_stack_id_no_resource_id(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_res_str_repr', 'Foo') |
|
res = generic_rsrc.GenericResource('test_res_str_repr', tmpl, |
|
self.stack) |
|
res.stack.id = "123" |
|
res.resource_id = None |
|
expected = ('GenericResource "test_res_str_repr" Stack "test_stack" ' |
|
'[123]') |
|
observed = str(res) |
|
self.assertEqual(expected, observed) |
|
|
|
def test_resource_str_repr_no_stack_id(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_res_str_repr', 'Foo') |
|
res = generic_rsrc.GenericResource('test_res_str_repr', tmpl, |
|
self.stack) |
|
res.stack.id = None |
|
expected = ('GenericResource "test_res_str_repr"') |
|
observed = str(res) |
|
self.assertEqual(expected, observed) |
|
|
|
def test_state_set(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) |
|
res.state_set(res.CREATE, res.IN_PROGRESS, 'test_state_set') |
|
self.assertIsNotNone(res.id) |
|
self.assertEqual(res.CREATE, res.action) |
|
self.assertEqual(res.IN_PROGRESS, res.status) |
|
self.assertEqual('test_state_set', res.status_reason) |
|
|
|
db_res = resource_objects.Resource.get_obj(res.context, res.id) |
|
self.assertEqual(res.CREATE, db_res.action) |
|
self.assertEqual(res.IN_PROGRESS, db_res.status) |
|
self.assertEqual('test_state_set', db_res.status_reason) |
|
|
|
res.state_set(res.CREATE, res.COMPLETE, 'test_update') |
|
self.assertEqual(res.CREATE, res.action) |
|
self.assertEqual(res.COMPLETE, res.status) |
|
self.assertEqual('test_update', res.status_reason) |
|
db_res.refresh() |
|
self.assertEqual(res.CREATE, db_res.action) |
|
self.assertEqual(res.COMPLETE, db_res.status) |
|
self.assertEqual('test_update', db_res.status_reason) |
|
|
|
def test_physical_resource_name_or_FnGetRefId(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) |
|
scheduler.TaskRunner(res.create)() |
|
self.assertEqual((res.CREATE, res.COMPLETE), res.state) |
|
|
|
# use physical_resource_name when res.id is not None |
|
self.assertIsNotNone(res.id) |
|
expected = '%s-%s-%s' % (self.stack.name, |
|
res.name, |
|
short_id.get_id(res.uuid)) |
|
self.assertEqual(expected, res.physical_resource_name_or_FnGetRefId()) |
|
|
|
# otherwise use parent method |
|
res.id = None |
|
self.assertIsNone(res.resource_id) |
|
self.assertEqual('test_resource', |
|
res.physical_resource_name_or_FnGetRefId()) |
|
|
|
def test_prepare_abandon(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) |
|
expected = { |
|
'action': 'INIT', |
|
'metadata': {}, |
|
'name': 'test_resource', |
|
'resource_data': {}, |
|
'resource_id': None, |
|
'status': 'COMPLETE', |
|
'type': 'Foo' |
|
} |
|
actual = res.prepare_abandon() |
|
self.assertEqual(expected, actual) |
|
|
|
def test_abandon_with_resource_data(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) |
|
res._data = {"test-key": "test-value"} |
|
|
|
expected = { |
|
'action': 'INIT', |
|
'metadata': {}, |
|
'name': 'test_resource', |
|
'resource_data': {"test-key": "test-value"}, |
|
'resource_id': None, |
|
'status': 'COMPLETE', |
|
'type': 'Foo' |
|
} |
|
actual = res.prepare_abandon() |
|
self.assertEqual(expected, actual) |
|
|
|
def test_create_from_external(self): |
|
tmpl = rsrc_defn.ResourceDefinition( |
|
'test_resource', 'GenericResourceType', |
|
external_id='f00d') |
|
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) |
|
scheduler.TaskRunner(res.create)() |
|
self.assertEqual((res.CHECK, res.COMPLETE), res.state) |
|
self.assertEqual('f00d', res.resource_id) |
|
|
|
def test_create_from_external_not_found(self): |
|
external_id = 'f00d' |
|
tmpl = rsrc_defn.ResourceDefinition( |
|
'test_resource', 'GenericResourceType', |
|
external_id=external_id) |
|
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) |
|
res.client_plugin = mock.Mock() |
|
self.patchobject(res.client_plugin, 'is_not_found', |
|
return_value=True) |
|
self.patchobject(res, '_show_resource', side_effect=Exception()) |
|
e = self.assertRaises(exception.StackValidationFailed, |
|
res.validate_external) |
|
message = (("Invalid external resource: Resource %(external_id)s " |
|
"(%(type)s) can not be found.") % |
|
{'external_id': external_id, |
|
'type': res.type()}) |
|
self.assertEqual(message, six.text_type(e)) |
|
|
|
def test_updated_from_external(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType') |
|
utmpl = rsrc_defn.ResourceDefinition( |
|
'test_resource', 'GenericResourceType', |
|
external_id='f00d') |
|
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) |
|
expected_err_msg = ('NotSupported: resources.test_resource: Update ' |
|
'to property external_id of test_resource ' |
|
'(GenericResourceType) is not supported.') |
|
err = self.assertRaises(exception.ResourceFailure, |
|
scheduler.TaskRunner(res.update, utmpl) |
|
) |
|
self.assertEqual(expected_err_msg, six.text_type(err)) |
|
|
|
def test_state_set_invalid(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) |
|
self.assertRaises(ValueError, res.state_set, 'foo', 'bla') |
|
self.assertRaises(ValueError, res.state_set, 'foo', res.COMPLETE) |
|
self.assertRaises(ValueError, res.state_set, res.CREATE, 'bla') |
|
|
|
def test_state_del_stack(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
self.stack.action = self.stack.DELETE |
|
self.stack.status = self.stack.IN_PROGRESS |
|
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) |
|
self.assertEqual(res.DELETE, res.action) |
|
self.assertEqual(res.COMPLETE, res.status) |
|
|
|
def test_type(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) |
|
self.assertEqual('Foo', res.type()) |
|
|
|
def test_has_interface_direct_match(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType') |
|
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) |
|
self.assertTrue(res.has_interface('GenericResourceType')) |
|
|
|
def test_has_interface_no_match(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType') |
|
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) |
|
self.assertFalse(res.has_interface('LookingForAnotherType')) |
|
|
|
def test_has_interface_mapping(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'OS::Test::GenericResource') |
|
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) |
|
self.assertTrue(res.has_interface('GenericResourceType')) |
|
|
|
def test_has_interface_mapping_no_match(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'OS::Test::GenoricResort') |
|
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) |
|
self.assertFalse(res.has_interface('GenericResourceType')) |
|
|
|
def test_created_time(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
res = generic_rsrc.GenericResource('test_res_new', tmpl, self.stack) |
|
self.assertIsNone(res.created_time) |
|
res.store() |
|
self.assertIsNotNone(res.created_time) |
|
|
|
def test_updated_time(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType') |
|
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) |
|
res.store() |
|
stored_time = res.updated_time |
|
|
|
utmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
res.state_set(res.CREATE, res.COMPLETE) |
|
scheduler.TaskRunner(res.update, utmpl)() |
|
self.assertIsNotNone(res.updated_time) |
|
self.assertNotEqual(res.updated_time, stored_time) |
|
|
|
def _setup_resource_for_update(self, res_name): |
|
class TestResource(resource.Resource): |
|
properties_schema = {'a_string': {'Type': 'String'}} |
|
update_allowed_properties = ('a_string',) |
|
|
|
resource._register_class('TestResource', TestResource) |
|
|
|
tmpl = rsrc_defn.ResourceDefinition(res_name, |
|
'TestResource') |
|
res = TestResource('test_resource', tmpl, self.stack) |
|
|
|
utmpl = rsrc_defn.ResourceDefinition(res_name, 'TestResource', |
|
{'a_string': 'foo'}) |
|
|
|
return res, utmpl |
|
|
|
def test_update_replace(self): |
|
res, utmpl = self._setup_resource_for_update( |
|
res_name='test_update_replace') |
|
self.assertEqual((res.INIT, res.COMPLETE), res.state) |
|
res.prepare_for_replace = mock.Mock() |
|
# resource replaced if in INIT_COMPLETE |
|
self.assertRaises( |
|
resource.UpdateReplace, scheduler.TaskRunner(res.update, utmpl)) |
|
self.assertTrue(res.prepare_for_replace.called) |
|
|
|
def test_update_replace_in_check_failed(self): |
|
res, utmpl = self._setup_resource_for_update( |
|
res_name='test_update_replace') |
|
res.state_set(res.CHECK, res.FAILED) |
|
res.prepare_for_replace = mock.Mock() |
|
res.needs_replace_failed = mock.MagicMock(return_value=False) |
|
|
|
self.assertRaises( |
|
resource.UpdateReplace, scheduler.TaskRunner(res.update, utmpl)) |
|
self.assertFalse(res.needs_replace_failed.called) |
|
self.assertTrue(res.prepare_for_replace.called) |
|
|
|
def test_no_update_or_replace_in_failed(self): |
|
res, utmpl = self._setup_resource_for_update( |
|
res_name='test_failed_res_no_update_or_replace') |
|
res.state_set(res.CREATE, res.FAILED) |
|
res.prepare_for_replace = mock.Mock() |
|
res.needs_replace_failed = mock.MagicMock(return_value=False) |
|
|
|
scheduler.TaskRunner(res.update, res.t)() |
|
self.assertTrue(res.needs_replace_failed.called) |
|
self.assertFalse(res.prepare_for_replace.called) |
|
self.assertEqual((res.CREATE, res.COMPLETE), res.state) |
|
status_reason = _('Update status to COMPLETE for ' |
|
'FAILED resource neither update ' |
|
'nor replace.') |
|
self.assertEqual(status_reason, res.status_reason) |
|
|
|
def test_update_replace_prepare_replace_error(self): |
|
# test if any error happened when prepare_for_replace, |
|
# whether the resource will go to FAILED |
|
res, utmpl = self._setup_resource_for_update( |
|
res_name='test_update_replace_prepare_replace_error') |
|
res.prepare_for_replace = mock.Mock(side_effect=Exception) |
|
|
|
self.assertRaises( |
|
exception.ResourceFailure, |
|
scheduler.TaskRunner(res.update, utmpl)) |
|
self.assertTrue(res.prepare_for_replace.called) |
|
self.assertEqual((res.UPDATE, res.FAILED), res.state) |
|
|
|
def test_update_rsrc_in_progress_raises_exception(self): |
|
res, utmpl = self._setup_resource_for_update( |
|
res_name='test_update_rsrc_in_progress_raises_exception') |
|
|
|
cfg.CONF.set_override('convergence_engine', False) |
|
|
|
res.action = res.UPDATE |
|
res.status = res.IN_PROGRESS |
|
self.assertRaises( |
|
exception.ResourceFailure, scheduler.TaskRunner(res.update, utmpl)) |
|
|
|
def test_update_replace_rollback(self): |
|
cfg.CONF.set_override('convergence_engine', False) |
|
res, utmpl = self._setup_resource_for_update( |
|
res_name='test_update_replace_rollback') |
|
res.restore_prev_rsrc = mock.Mock() |
|
self.stack.state_set('ROLLBACK', 'IN_PROGRESS', 'Simulate rollback') |
|
|
|
self.assertRaises( |
|
resource.UpdateReplace, scheduler.TaskRunner(res.update, utmpl)) |
|
self.assertTrue(res.restore_prev_rsrc.called) |
|
|
|
def test_update_replace_rollback_restore_prev_rsrc_error(self): |
|
cfg.CONF.set_override('convergence_engine', False) |
|
res, utmpl = self._setup_resource_for_update( |
|
res_name='restore_prev_rsrc_error') |
|
res.restore_prev_rsrc = mock.Mock(side_effect=Exception) |
|
self.stack.state_set('ROLLBACK', 'IN_PROGRESS', 'Simulate rollback') |
|
|
|
self.assertRaises( |
|
exception.ResourceFailure, scheduler.TaskRunner(res.update, utmpl)) |
|
self.assertTrue(res.restore_prev_rsrc.called) |
|
self.assertEqual((res.UPDATE, res.FAILED), res.state) |
|
|
|
def test_update_replace_in_failed_without_nested(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
res.update_allowed_properties = ('Foo',) |
|
self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_create') |
|
generic_rsrc.ResourceWithProps.handle_create().AndRaise( |
|
exception.ResourceFailure) |
|
self.m.ReplayAll() |
|
|
|
self.assertRaises(exception.ResourceFailure, |
|
scheduler.TaskRunner(res.create)) |
|
self.assertEqual((res.CREATE, res.FAILED), res.state) |
|
|
|
utmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType', |
|
{'Foo': 'xyz'}) |
|
# resource in failed status and hasn't nested will enter |
|
# UpdateReplace flow |
|
self.assertRaises( |
|
resource.UpdateReplace, scheduler.TaskRunner(res.update, utmpl)) |
|
|
|
self.m.VerifyAll() |
|
|
|
def test_updated_time_changes_only_when_it_changed(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType') |
|
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) |
|
res.store() |
|
self.assertIsNone(res.updated_time) |
|
res.updated_time = datetime.datetime.utcnow() |
|
res.store() |
|
self.assertIsNotNone(res.updated_time) |
|
|
|
def test_resource_object_get_obj_fields(self): |
|
snippet = rsrc_defn.ResourceDefinition('aresource', |
|
'GenericResourceType') |
|
res = resource.Resource('aresource', snippet, self.stack) |
|
res.store() |
|
res_obj = resource_objects.Resource.get_obj( |
|
res.context, res.id, refresh=False, fields=('status', )) |
|
self.assertEqual(res_obj.status, res.COMPLETE) |
|
self.assertRaises(AttributeError, getattr, res_obj, 'action') |
|
|
|
def test_attributes_store(self): |
|
res_def = rsrc_defn.ResourceDefinition('test_resource', |
|
'ResWithStringPropAndAttr') |
|
res = generic_rsrc.ResWithStringPropAndAttr( |
|
'test_res_attr_store', res_def, self.stack) |
|
|
|
res.action = res.CREATE |
|
res.status = res.COMPLETE |
|
res.store() |
|
res.store_attributes() |
|
# attr was not resolved, cache was not warmed, nothing to store |
|
self.assertIsNone(res._attr_data_id) |
|
|
|
with mock.patch.object(res, '_resolve_attribute') as res_attr: |
|
attr_val = '0123 four' |
|
res_attr.return_value = attr_val |
|
res.attributes['string'] |
|
|
|
# attr cache is warmed, now store_attributes persists something |
|
res.store_attributes() |
|
self.assertIsNotNone(res._attr_data_id) |
|
|
|
# verify the attribute rpd obj that was stored matches |
|
self.assertEqual({'string': attr_val}, |
|
rpd_object.ResourcePropertiesData.get_by_id( |
|
res.context, res._attr_data_id).data) |
|
|
|
def test_attributes_load_stored(self): |
|
res_def = rsrc_defn.ResourceDefinition('test_resource', |
|
'ResWithStringPropAndAttr') |
|
res = generic_rsrc.ResWithStringPropAndAttr( |
|
'test_res_attr_store', res_def, self.stack) |
|
|
|
res.action = res.UPDATE |
|
res.status = res.COMPLETE |
|
res.store() |
|
attr_data = {'string': 'word'} |
|
resource_objects.Resource.store_attributes( |
|
res.context, res.id, res._atomic_key, attr_data, None) |
|
res._load_data(resource_objects.Resource.get_obj( |
|
res.context, res.id)) |
|
with mock.patch.object(res, '_resolve_attribute') as res_attr: |
|
self.assertEqual(attr_data, res.attributes._resolved_values) |
|
self.assertEqual('word', res.attributes['string']) |
|
self.assertEqual(0, res_attr.call_count) |
|
|
|
def test_store_attributes_fail(self): |
|
res_def = rsrc_defn.ResourceDefinition('test_resource', |
|
'ResWithStringPropAndAttr') |
|
res = generic_rsrc.ResWithStringPropAndAttr( |
|
'test_res_attr_store', res_def, self.stack) |
|
|
|
res.action = res.UPDATE |
|
res.status = res.COMPLETE |
|
res.store() |
|
attr_data = {'string': 'word'} |
|
# set the attr_data_id first |
|
resource_objects.Resource.update_by_id(res.context, res.id, |
|
{'attr_data_id': 99}) |
|
new_attr_data_id = resource_objects.Resource.store_attributes( |
|
res.context, res.id, res._atomic_key, attr_data, None) |
|
# fail to store new attr data |
|
self.assertIsNone(new_attr_data_id) |
|
res._load_data(resource_objects.Resource.get_obj( |
|
res.context, res.id)) |
|
self.assertEqual({}, res.attributes._resolved_values) |
|
|
|
def test_resource_object_resource_properties_data(self): |
|
cfg.CONF.set_override('encrypt_parameters_and_properties', True) |
|
data = {'p1': 'i see', |
|
'p2': 'good times, good times'} |
|
rpd_obj = rpd_object.ResourcePropertiesData().create_or_update( |
|
self.stack.context, data) |
|
rpd_db_obj = self.stack.context.session.query( |
|
models.ResourcePropertiesData).get(rpd_obj.id) |
|
res_obj1 = resource_objects.Resource().create( |
|
self.stack.context, |
|
{'stack_id': self.stack.id, |
|
'uuid': str(uuid.uuid4()), |
|
'rsrc_prop_data': rpd_db_obj}) |
|
res_obj2 = resource_objects.Resource().create( |
|
self.stack.context, |
|
{'stack_id': self.stack.id, |
|
'uuid': str(uuid.uuid4()), |
|
'rsrc_prop_data_id': rpd_db_obj.id}) |
|
ctx2 = utils.dummy_context() |
|
res_obj1 = resource_objects.Resource().get_obj( |
|
ctx2, res_obj1.id) |
|
res_obj2 = resource_objects.Resource().get_obj( |
|
ctx2, res_obj2.id) |
|
|
|
# verify the resource_properties_data association |
|
# can be set by id |
|
self.assertEqual(rpd_db_obj.id, res_obj1.rsrc_prop_data_id) |
|
self.assertEqual(res_obj1.rsrc_prop_data_id, |
|
res_obj2.rsrc_prop_data_id) |
|
# properties data appears unencrypted to resource object |
|
self.assertEqual(data, res_obj1.properties_data) |
|
self.assertEqual(data, res_obj2.properties_data) |
|
|
|
def test_make_replacement(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
res = generic_rsrc.GenericResource('test_res_upd', tmpl, self.stack) |
|
res.store() |
|
new_tmpl_id = 2 |
|
self.assertIsNotNone(res.id) |
|
new_id = res.make_replacement(new_tmpl_id) |
|
new_res = resource_objects.Resource.get_obj(res.context, new_id) |
|
|
|
self.assertEqual(new_id, res.replaced_by) |
|
self.assertEqual(res.id, new_res.replaces) |
|
self.assertIsNone(new_res.physical_resource_id) |
|
self.assertEqual(new_tmpl_id, new_res.current_template_id) |
|
|
|
def test_metadata_default(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) |
|
self.assertEqual({}, res.metadata_get()) |
|
|
|
def test_metadata_set_when_deleted(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) |
|
res.store() |
|
md = {"don't": "care"} |
|
res.action = 'CREATE' |
|
res.metadata_set(md) |
|
self.assertFalse(hasattr(res, '_db_res_is_deleted')) |
|
|
|
res_obj = self.stack.context.session.query( |
|
models.Resource).get(res.id) |
|
res_obj.update({'action': 'DELETE'}) |
|
|
|
self.assertRaises(exception.ResourceNotAvailable, |
|
res.metadata_set, md) |
|
self.assertTrue(res._db_res_is_deleted) |
|
|
|
def test_equals_different_stacks(self): |
|
tmpl1 = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
tmpl2 = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
tmpl3 = rsrc_defn.ResourceDefinition('test_resource2', 'Bar') |
|
stack2 = parser.Stack(utils.dummy_context(), 'test_stack', |
|
template.Template(empty_template), stack_id=-1) |
|
res1 = generic_rsrc.GenericResource('test_resource', tmpl1, self.stack) |
|
res2 = generic_rsrc.GenericResource('test_resource', tmpl2, stack2) |
|
res3 = generic_rsrc.GenericResource('test_resource2', tmpl3, stack2) |
|
|
|
self.assertEqual(res1, res2) |
|
self.assertNotEqual(res1, res3) |
|
|
|
def test_equals_names(self): |
|
tmpl1 = rsrc_defn.ResourceDefinition('test_resource1', 'Foo') |
|
tmpl2 = rsrc_defn.ResourceDefinition('test_resource2', 'Foo') |
|
res1 = generic_rsrc.GenericResource('test_resource1', |
|
tmpl1, self.stack) |
|
res2 = generic_rsrc.GenericResource('test_resource2', tmpl2, |
|
self.stack) |
|
|
|
self.assertNotEqual(res1, res2) |
|
|
|
def test_update_template_diff_changed_modified(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo', |
|
metadata={'foo': 123}) |
|
update_snippet = rsrc_defn.ResourceDefinition('test_resource', 'Foo', |
|
metadata={'foo': 456}) |
|
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) |
|
diff = res.update_template_diff(update_snippet, tmpl) |
|
self.assertFalse(diff.properties_changed()) |
|
self.assertTrue(diff.metadata_changed()) |
|
self.assertFalse(diff.update_policy_changed()) |
|
|
|
def test_update_template_diff_changed_add(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
update_snippet = rsrc_defn.ResourceDefinition('test_resource', 'Foo', |
|
metadata={'foo': 123}) |
|
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) |
|
diff = res.update_template_diff(update_snippet, tmpl) |
|
self.assertFalse(diff.properties_changed()) |
|
self.assertTrue(diff.metadata_changed()) |
|
self.assertFalse(diff.update_policy_changed()) |
|
|
|
def test_update_template_diff_changed_remove(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo', |
|
metadata={'foo': 123}) |
|
update_snippet = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) |
|
diff = res.update_template_diff(update_snippet, tmpl) |
|
self.assertFalse(diff.properties_changed()) |
|
self.assertTrue(diff.metadata_changed()) |
|
self.assertFalse(diff.update_policy_changed()) |
|
|
|
def test_update_template_diff_properties_none(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
before_props = tmpl.properties(res.properties_schema, |
|
self.stack.context) |
|
after_props = tmpl.properties(res.properties_schema, |
|
self.stack.context) |
|
diff = res.update_template_diff_properties(after_props, before_props) |
|
self.assertEqual({}, diff) |
|
|
|
def test_update_template_diff_properties_added(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
update_defn = rsrc_defn.ResourceDefinition('test_resource', 'Foo', |
|
properties={'Foo': 123}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
res.update_allowed_properties = ('Foo',) |
|
before_props = tmpl.properties(res.properties_schema, |
|
self.stack.context) |
|
after_props = update_defn.properties(res.properties_schema, |
|
self.stack.context) |
|
diff = res.update_template_diff_properties(after_props, before_props) |
|
self.assertEqual({'Foo': '123'}, diff) |
|
|
|
def test_update_template_diff_properties_removed_no_default_value(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo', |
|
{'Foo': '123'}) |
|
new_t = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
|
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
res.update_allowed_properties = ('Foo',) |
|
before_props = tmpl.properties(res.properties_schema, |
|
self.stack.context) |
|
after_props = new_t.properties(res.properties_schema, |
|
self.stack.context) |
|
diff = res.update_template_diff_properties(after_props, before_props) |
|
self.assertEqual({'Foo': None}, diff) |
|
|
|
def test_update_template_diff_properties_removed_with_default_value(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo', |
|
{'Foo': '123'}) |
|
schema = {'Foo': {'Type': 'String', 'Default': '567'}} |
|
self.patchobject(generic_rsrc.ResourceWithProps, 'properties_schema', |
|
new=schema) |
|
new_t = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
|
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
res.update_allowed_properties = ('Foo',) |
|
before_props = tmpl.properties(res.properties_schema, |
|
self.stack.context) |
|
after_props = new_t.properties(res.properties_schema, |
|
self.stack.context) |
|
diff = res.update_template_diff_properties(after_props, before_props) |
|
self.assertEqual({'Foo': '567'}, diff) |
|
|
|
def test_update_template_diff_properties_changed(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo', |
|
{'Foo': '123'}) |
|
new_t = rsrc_defn.ResourceDefinition('test_resource', 'Foo', |
|
{'Foo': '456'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
res.update_allowed_properties = ('Foo',) |
|
before_props = tmpl.properties(res.properties_schema, |
|
self.stack.context) |
|
after_props = new_t.properties(res.properties_schema, |
|
self.stack.context) |
|
diff = res.update_template_diff_properties(after_props, before_props) |
|
self.assertEqual({'Foo': '456'}, diff) |
|
|
|
def test_update_template_diff_properties_notallowed(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo', |
|
{'Foo': '123'}) |
|
new_t = rsrc_defn.ResourceDefinition('test_resource', 'Foo', |
|
{'Bar': '456'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
res.update_allowed_properties = ('Cat',) |
|
before_props = tmpl.properties(res.properties_schema, |
|
self.stack.context) |
|
after_props = new_t.properties(res.properties_schema, |
|
self.stack.context) |
|
self.assertRaises(resource.UpdateReplace, |
|
res.update_template_diff_properties, |
|
after_props, before_props) |
|
|
|
def test_update_template_diff_properties_immutable_notsupported(self): |
|
before = {'Foo': 'bar', 'Parrot': 'dead', |
|
'Spam': 'ham', 'Viking': 'axe'} |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo', |
|
before) |
|
schema = {'Foo': {'Type': 'String'}, |
|
'Viking': {'Type': 'String', 'Immutable': True}, |
|
'Spam': {'Type': 'String', 'Immutable': True}, |
|
'Parrot': {'Type': 'String', 'Immutable': True}, |
|
} |
|
after = {'Foo': 'baz', 'Parrot': 'dead', |
|
'Spam': 'eggs', 'Viking': 'sword'} |
|
new_t = rsrc_defn.ResourceDefinition('test_resource', 'Foo', |
|
after) |
|
|
|
self.patchobject(generic_rsrc.ResourceWithProps, |
|
'properties_schema', new=schema) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, |
|
self.stack) |
|
before_props = tmpl.properties(res.properties_schema, |
|
self.stack.context) |
|
after_props = new_t.properties(res.properties_schema, |
|
self.stack.context) |
|
ex = self.assertRaises(exception.NotSupported, |
|
res.update_template_diff_properties, |
|
after_props, before_props) |
|
self.assertIn("Update to properties Spam, Viking of", |
|
six.text_type(ex)) |
|
|
|
def test_resource(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
scheduler.TaskRunner(res.create)() |
|
self.assertEqual((res.CREATE, res.COMPLETE), res.state) |
|
|
|
def test_deprecated_prop_data_updated(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
scheduler.TaskRunner(res.create)() |
|
|
|
res_obj = db_api.resource_get(self.stack.context, res.id) |
|
self.assertIsNone(res_obj.properties_data) |
|
self.assertIsNone(res_obj.properties_data_encrypted) |
|
# Now that we've established these couple of depcrated fields |
|
# are not populated, let's populate them. |
|
db_api.resource_update_and_save(self.stack.context, res_obj.id, |
|
{'properties_data': {'Foo': 'lucky'}, |
|
'properties_data_encrypted': False, |
|
'rsrc_prop_data': None}) |
|
res._rsrc_prop_data = None |
|
res._load_data(res_obj) |
|
# Legacy properties_data slurped into res._stored_properties_data |
|
self.assertEqual(res._stored_properties_data, {'Foo': 'lucky'}) |
|
|
|
res._rsrc_prop_data = None |
|
res.state_set(res.CREATE, res.IN_PROGRESS, 'test_rpd') |
|
|
|
# Modernity, the data is where it belongs |
|
rsrc_prop_data_db_obj = db_api.resource_prop_data_get( |
|
self.stack.context, res._rsrc_prop_data_id) |
|
self.assertEqual(rsrc_prop_data_db_obj['data'], {'Foo': 'lucky'}) |
|
# legacy locations aren't being used anymore |
|
self.assertFalse(hasattr(res, 'properties_data')) |
|
self.assertFalse(hasattr(res, 'properties_data_encrypted')) |
|
|
|
def test_deprecated_encrypted_prop_data_updated(self): |
|
cfg.CONF.set_override('encrypt_parameters_and_properties', True) |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
scheduler.TaskRunner(res.create)() |
|
|
|
res_obj = db_api.resource_get(self.stack.context, res.id) |
|
self.assertIsNone(res_obj.properties_data) |
|
self.assertIsNone(res_obj.properties_data_encrypted) |
|
# Now that we've established these couple of depcrated fields |
|
# are not populated, let's populate them. |
|
encrypted_data = \ |
|
rpd_object.ResourcePropertiesData.encrypt_properties_data( |
|
{'Foo': 'lucky'})[1] |
|
|
|
db_api.resource_update_and_save(self.stack.context, res_obj.id, |
|
{'properties_data': encrypted_data, |
|
'properties_data_encrypted': True, |
|
'rsrc_prop_data': None}) |
|
# This is where the decrypting of legacy data happens |
|
res_obj = resource_objects.Resource._from_db_object( |
|
resource_objects.Resource(), self.stack.context, res_obj) |
|
self.assertEqual('lucky', |
|
res_obj.properties_data['Foo']) |
|
|
|
res._rsrc_prop_data = None |
|
res._load_data(res_obj) |
|
# Legacy properties_data slurped into res._stored_properties_data |
|
self.assertEqual(res._stored_properties_data, {'Foo': 'lucky'}) |
|
|
|
res._rsrc_prop_data = None |
|
res.state_set(res.CREATE, res.IN_PROGRESS, 'test_store') |
|
|
|
# Modernity, the data is where it belongs |
|
# The db object data is encrypted |
|
rsrc_prop_data_db_obj = db_api.resource_prop_data_get( |
|
self.stack.context, res._rsrc_prop_data_id) |
|
self.assertNotEqual(rsrc_prop_data_db_obj['data'], {'Foo': 'lucky'}) |
|
# But the objects/ rsrc_prop_data.data is always unencrypted |
|
rsrc_prop_data_obj = rpd_object.ResourcePropertiesData._from_db_object( |
|
rpd_object.ResourcePropertiesData(), self.stack.context, |
|
rsrc_prop_data_db_obj) |
|
self.assertEqual(rsrc_prop_data_obj.data, {'Foo': 'lucky'}) |
|
# legacy locations aren't being used anymore |
|
self.assertFalse(hasattr(res, 'properties_data')) |
|
self.assertFalse(hasattr(res, 'properties_data_encrypted')) |
|
|
|
def test_create_fail_missing_req_prop(self): |
|
rname = 'test_resource' |
|
tmpl = rsrc_defn.ResourceDefinition(rname, 'Foo', {}) |
|
res = generic_rsrc.ResourceWithRequiredProps(rname, tmpl, self.stack) |
|
|
|
estr = ('Property error: test_resource.Properties: ' |
|
'Property Foo not assigned') |
|
create = scheduler.TaskRunner(res.create) |
|
err = self.assertRaises(exception.ResourceFailure, create) |
|
self.assertIn(estr, six.text_type(err)) |
|
self.assertEqual((res.CREATE, res.FAILED), res.state) |
|
|
|
def test_create_fail_prop_typo(self): |
|
rname = 'test_resource' |
|
tmpl = rsrc_defn.ResourceDefinition(rname, 'GenericResourceType', |
|
{'Food': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps(rname, tmpl, self.stack) |
|
|
|
estr = ('StackValidationFailed: resources.test_resource: ' |
|
'Property error: test_resource.Properties: ' |
|
'Unknown Property Food') |
|
create = scheduler.TaskRunner(res.create) |
|
err = self.assertRaises(exception.ResourceFailure, create) |
|
self.assertIn(estr, six.text_type(err)) |
|
self.assertEqual((res.CREATE, res.FAILED), res.state) |
|
|
|
def test_create_fail_metadata_parse_error(self): |
|
rname = 'test_resource' |
|
get_att = cfn_funcs.GetAtt(self.stack, 'Fn::GetAtt', |
|
["ResourceA", "abc"]) |
|
tmpl = rsrc_defn.ResourceDefinition(rname, 'GenericResourceType', |
|
properties={}, |
|
metadata={'foo': get_att}) |
|
res = generic_rsrc.ResourceWithProps(rname, tmpl, self.stack) |
|
|
|
create = scheduler.TaskRunner(res.create) |
|
self.assertRaises(exception.ResourceFailure, create) |
|
self.assertEqual((res.CREATE, res.FAILED), res.state) |
|
|
|
def test_create_resource_after_destroy(self): |
|
rname = 'test_res_id_none' |
|
tmpl = rsrc_defn.ResourceDefinition(rname, 'GenericResourceType') |
|
res = generic_rsrc.ResourceWithProps(rname, tmpl, self.stack) |
|
res.id = 'test_res_id' |
|
(res.action, res.status) = (res.INIT, res.DELETE) |
|
create = scheduler.TaskRunner(res.create) |
|
self.assertRaises(exception.ResourceFailure, create) |
|
scheduler.TaskRunner(res.destroy)() |
|
res.state_reset() |
|
scheduler.TaskRunner(res.create)() |
|
self.assertEqual((res.CREATE, res.COMPLETE), res.state) |
|
|
|
@mock.patch.object(properties.Properties, 'validate') |
|
@mock.patch.object(timeutils, 'retry_backoff_delay') |
|
def test_create_validate(self, m_re, m_v): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
|
|
generic_rsrc.ResourceWithProps.handle_create = mock.Mock() |
|
generic_rsrc.ResourceWithProps.handle_delete = mock.Mock() |
|
m_v.side_effect = [True, exception.StackValidationFailed()] |
|
generic_rsrc.ResourceWithProps.handle_create.side_effect = [ |
|
exception.ResourceInError(resource_name='test_resource', |
|
resource_status='ERROR', |
|
resource_type='GenericResourceType', |
|
resource_action='CREATE', |
|
status_reason='just because'), |
|
exception.ResourceInError(resource_name='test_resource', |
|
resource_status='ERROR', |
|
resource_type='GenericResourceType', |
|
resource_action='CREATE', |
|
status_reason='just because'), |
|
None |
|
] |
|
|
|
generic_rsrc.ResourceWithProps.handle_delete.return_value = None |
|
m_re.return_value = 0.01 |
|
scheduler.TaskRunner(res.create)() |
|
self.assertEqual(2, m_re.call_count) |
|
self.assertEqual(1, m_v.call_count) |
|
self.assertEqual((res.CREATE, res.COMPLETE), res.state) |
|
|
|
def test_create_fail_retry(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
self.m.StubOutWithMock(timeutils, 'retry_backoff_delay') |
|
self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_create') |
|
self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_delete') |
|
|
|
# first attempt to create fails |
|
generic_rsrc.ResourceWithProps.handle_create().AndRaise( |
|
exception.ResourceInError(resource_name='test_resource', |
|
resource_status='ERROR', |
|
resource_type='GenericResourceType', |
|
resource_action='CREATE', |
|
status_reason='just because')) |
|
# delete error resource from first attempt |
|
generic_rsrc.ResourceWithProps.handle_delete().AndReturn(None) |
|
|
|
# second attempt to create succeeds |
|
timeutils.retry_backoff_delay(1, jitter_max=2.0).AndReturn(0.01) |
|
generic_rsrc.ResourceWithProps.handle_create().AndReturn(None) |
|
self.m.ReplayAll() |
|
|
|
scheduler.TaskRunner(res.create)() |
|
self.assertEqual((res.CREATE, res.COMPLETE), res.state) |
|
self.m.VerifyAll() |
|
|
|
def test_create_fail_retry_disabled(self): |
|
cfg.CONF.set_override('action_retry_limit', 0) |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
|
|
self.m.StubOutWithMock(timeutils, 'retry_backoff_delay') |
|
self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_create') |
|
self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_delete') |
|
|
|
# attempt to create fails |
|
generic_rsrc.ResourceWithProps.handle_create().AndRaise( |
|
exception.ResourceInError(resource_name='test_resource', |
|
resource_status='ERROR', |
|
resource_type='GenericResourceType', |
|
resource_action='CREATE', |
|
status_reason='just because')) |
|
self.m.ReplayAll() |
|
|
|
estr = ('ResourceInError: resources.test_resource: ' |
|
'Went to status ERROR due to "just because"') |
|
create = scheduler.TaskRunner(res.create) |
|
err = self.assertRaises(exception.ResourceFailure, create) |
|
self.assertEqual(estr, six.text_type(err)) |
|
self.assertEqual((res.CREATE, res.FAILED), res.state) |
|
|
|
self.m.VerifyAll() |
|
|
|
def test_create_deletes_fail_retry(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
|
|
self.m.StubOutWithMock(timeutils, 'retry_backoff_delay') |
|
self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_create') |
|
self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_delete') |
|
|
|
# first attempt to create fails |
|
generic_rsrc.ResourceWithProps.handle_create().AndRaise( |
|
exception.ResourceInError(resource_name='test_resource', |
|
resource_status='ERROR', |
|
resource_type='GenericResourceType', |
|
resource_action='CREATE', |
|
status_reason='just because')) |
|
# first attempt to delete fails |
|
generic_rsrc.ResourceWithProps.handle_delete().AndRaise( |
|
exception.ResourceInError(resource_name='test_resource', |
|
resource_status='ERROR', |
|
resource_type='GenericResourceType', |
|
resource_action='DELETE', |
|
status_reason='delete failed')) |
|
# second attempt to delete fails |
|
timeutils.retry_backoff_delay(1, jitter_max=2.0).AndReturn(0.01) |
|
generic_rsrc.ResourceWithProps.handle_delete().AndRaise( |
|
exception.ResourceInError(resource_name='test_resource', |
|
resource_status='ERROR', |
|
resource_type='GenericResourceType', |
|
resource_action='DELETE', |
|
status_reason='delete failed again')) |
|
|
|
# third attempt to delete succeeds |
|
timeutils.retry_backoff_delay(2, jitter_max=2.0).AndReturn(0.01) |
|
generic_rsrc.ResourceWithProps.handle_delete().AndReturn(None) |
|
|
|
# second attempt to create succeeds |
|
timeutils.retry_backoff_delay(1, jitter_max=2.0).AndReturn(0.01) |
|
generic_rsrc.ResourceWithProps.handle_create().AndReturn(None) |
|
self.m.ReplayAll() |
|
|
|
scheduler.TaskRunner(res.create)() |
|
self.assertEqual((res.CREATE, res.COMPLETE), res.state) |
|
self.m.VerifyAll() |
|
|
|
def test_creates_fail_retry(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
|
|
self.m.StubOutWithMock(timeutils, 'retry_backoff_delay') |
|
self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_create') |
|
self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_delete') |
|
|
|
# first attempt to create fails |
|
generic_rsrc.ResourceWithProps.handle_create().AndRaise( |
|
exception.ResourceInError(resource_name='test_resource', |
|
resource_status='ERROR', |
|
resource_type='GenericResourceType', |
|
resource_action='CREATE', |
|
status_reason='just because')) |
|
# delete error resource from first attempt |
|
generic_rsrc.ResourceWithProps.handle_delete().AndReturn(None) |
|
|
|
# second attempt to create fails |
|
timeutils.retry_backoff_delay(1, jitter_max=2.0).AndReturn(0.01) |
|
generic_rsrc.ResourceWithProps.handle_create().AndRaise( |
|
exception.ResourceInError(resource_name='test_resource', |
|
resource_status='ERROR', |
|
resource_type='GenericResourceType', |
|
resource_action='CREATE', |
|
status_reason='just because')) |
|
# delete error resource from second attempt |
|
generic_rsrc.ResourceWithProps.handle_delete().AndReturn(None) |
|
|
|
# third attempt to create succeeds |
|
timeutils.retry_backoff_delay(2, jitter_max=2.0).AndReturn(0.01) |
|
generic_rsrc.ResourceWithProps.handle_create().AndReturn(None) |
|
self.m.ReplayAll() |
|
|
|
scheduler.TaskRunner(res.create)() |
|
self.assertEqual((res.CREATE, res.COMPLETE), res.state) |
|
self.m.VerifyAll() |
|
|
|
def test_create_cancel(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
res = generic_rsrc.CancellableResource('test_resource', tmpl, |
|
self.stack) |
|
|
|
self.m.StubOutWithMock(res, 'handle_create') |
|
self.m.StubOutWithMock(res, 'check_create_complete') |
|
self.m.StubOutWithMock(res, 'handle_create_cancel') |
|
|
|
cookie = object() |
|
res.handle_create().AndReturn(cookie) |
|
res.check_create_complete(cookie).AndReturn(False) |
|
res.handle_create_cancel(cookie).AndReturn(None) |
|
|
|
self.m.ReplayAll() |
|
|
|
runner = scheduler.TaskRunner(res.create) |
|
runner.start() |
|
runner.step() |
|
runner.cancel() |
|
|
|
self.m.VerifyAll() |
|
|
|
def test_create_cancel_exception(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
res = generic_rsrc.CancellableResource('test_resource', tmpl, |
|
self.stack) |
|
|
|
self.m.StubOutWithMock(res, 'handle_create') |
|
self.m.StubOutWithMock(res, 'check_create_complete') |
|
self.m.StubOutWithMock(res, 'handle_create_cancel') |
|
|
|
cookie = object() |
|
res.handle_create().AndReturn(cookie) |
|
res.check_create_complete(cookie).AndReturn(False) |
|
res.handle_create_cancel(cookie).AndRaise(Exception) |
|
|
|
self.m.ReplayAll() |
|
|
|
runner = scheduler.TaskRunner(res.create) |
|
runner.start() |
|
runner.step() |
|
runner.cancel() |
|
|
|
self.m.VerifyAll() |
|
|
|
def test_preview(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType') |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
self.assertEqual(res, res.preview()) |
|
|
|
def test_update_ok(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
res.update_allowed_properties = ('Foo',) |
|
scheduler.TaskRunner(res.create)() |
|
self.assertEqual((res.CREATE, res.COMPLETE), res.state) |
|
|
|
utmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType', |
|
{'Foo': 'xyz'}) |
|
prop_diff = {'Foo': 'xyz'} |
|
self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_update') |
|
generic_rsrc.ResourceWithProps.handle_update( |
|
utmpl, mock.ANY, prop_diff).AndReturn(None) |
|
self.m.ReplayAll() |
|
|
|
scheduler.TaskRunner(res.update, utmpl)() |
|
self.assertEqual((res.UPDATE, res.COMPLETE), res.state) |
|
|
|
self.assertEqual({'Foo': 'xyz'}, res._stored_properties_data) |
|
|
|
self.m.VerifyAll() |
|
|
|
def test_update_replace_with_resource_name(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
res.update_allowed_properties = ('Foo',) |
|
scheduler.TaskRunner(res.create)() |
|
self.assertEqual((res.CREATE, res.COMPLETE), res.state) |
|
|
|
utmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType', |
|
{'Foo': 'xyz'}) |
|
self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_update') |
|
prop_diff = {'Foo': 'xyz'} |
|
generic_rsrc.ResourceWithProps.handle_update( |
|
utmpl, mock.ANY, prop_diff).AndRaise(resource.UpdateReplace( |
|
res.name)) |
|
self.m.ReplayAll() |
|
# should be re-raised so parser.Stack can handle replacement |
|
updater = scheduler.TaskRunner(res.update, utmpl) |
|
ex = self.assertRaises(resource.UpdateReplace, updater) |
|
self.assertEqual('The Resource test_resource requires replacement.', |
|
six.text_type(ex)) |
|
self.m.VerifyAll() |
|
|
|
def test_update_replace_without_resource_name(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
res.update_allowed_properties = ('Foo',) |
|
scheduler.TaskRunner(res.create)() |
|
self.assertEqual((res.CREATE, res.COMPLETE), res.state) |
|
|
|
utmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType', |
|
{'Foo': 'xyz'}) |
|
self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_update') |
|
prop_diff = {'Foo': 'xyz'} |
|
generic_rsrc.ResourceWithProps.handle_update( |
|
utmpl, mock.ANY, prop_diff).AndRaise(resource.UpdateReplace()) |
|
self.m.ReplayAll() |
|
# should be re-raised so parser.Stack can handle replacement |
|
updater = scheduler.TaskRunner(res.update, utmpl) |
|
ex = self.assertRaises(resource.UpdateReplace, updater) |
|
self.assertEqual('The Resource Unknown requires replacement.', |
|
six.text_type(ex)) |
|
self.m.VerifyAll() |
|
|
|
def test_need_update_in_init_complete_state_for_resource(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
res.update_allowed_properties = ('Foo',) |
|
self.assertEqual((res.INIT, res.COMPLETE), res.state) |
|
|
|
prop = {'Foo': 'abc'} |
|
self.assertRaises(resource.UpdateReplace, |
|
res._needs_update, tmpl, tmpl, prop, prop, res) |
|
|
|
def test_need_update_in_create_failed_state_for_resource(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, |
|
self.stack) |
|
res.update_allowed_properties = ('Foo',) |
|
res.state_set(res.CREATE, res.FAILED) |
|
prop = {'Foo': 'abc'} |
|
self.assertRaises(resource.UpdateReplace, |
|
res._needs_update, tmpl, tmpl, prop, prop, res) |
|
|
|
def test_convg_need_update_in_delete_complete_state_for_resource(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, |
|
self.stack) |
|
res.update_allowed_properties = ('Foo',) |
|
res.stack.convergence = True |
|
res.state_set(res.DELETE, res.COMPLETE) |
|
prop = {'Foo': 'abc'} |
|
self.assertRaises(resource.UpdateReplace, |
|
res._needs_update, tmpl, tmpl, prop, prop, res) |
|
|
|
def test_update_fail_missing_req_prop(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithRequiredProps('test_resource', |
|
tmpl, self.stack) |
|
res.update_allowed_properties = ('Foo',) |
|
scheduler.TaskRunner(res.create)() |
|
self.assertEqual((res.CREATE, res.COMPLETE), res.state) |
|
|
|
utmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType', |
|
{}) |
|
|
|
updater = scheduler.TaskRunner(res.update, utmpl) |
|
self.assertRaises(exception.ResourceFailure, updater) |
|
self.assertEqual((res.UPDATE, res.FAILED), res.state) |
|
|
|
def test_update_fail_prop_typo(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
res.update_allowed_properties = ('Foo',) |
|
scheduler.TaskRunner(res.create)() |
|
self.assertEqual((res.CREATE, res.COMPLETE), res.state) |
|
|
|
utmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType', |
|
{'Food': 'xyz'}) |
|
|
|
updater = scheduler.TaskRunner(res.update, utmpl) |
|
self.assertRaises(exception.ResourceFailure, updater) |
|
self.assertEqual((res.UPDATE, res.FAILED), res.state) |
|
|
|
def test_update_not_implemented(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
res.update_allowed_properties = ('Foo',) |
|
scheduler.TaskRunner(res.create)() |
|
self.assertEqual((res.CREATE, res.COMPLETE), res.state) |
|
|
|
utmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType', |
|
{'Foo': 'xyz'}) |
|
tmpl_diff = {'Properties': {'Foo': 'xyz'}} |
|
prop_diff = {'Foo': 'xyz'} |
|
self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_update') |
|
generic_rsrc.ResourceWithProps.handle_update( |
|
utmpl, tmpl_diff, prop_diff).AndRaise(NotImplementedError) |
|
self.m.ReplayAll() |
|
updater = scheduler.TaskRunner(res.update, utmpl) |
|
self.assertRaises(exception.ResourceFailure, updater) |
|
self.assertEqual((res.UPDATE, res.FAILED), res.state) |
|
self.m.VerifyAll() |
|
|
|
def test_update_cancel(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo') |
|
res = generic_rsrc.CancellableResource('test_resource', tmpl, |
|
self.stack) |
|
|
|
self.m.StubOutWithMock(res, '_needs_update') |
|
self.m.StubOutWithMock(res, 'handle_update') |
|
self.m.StubOutWithMock(res, 'check_update_complete') |
|
self.m.StubOutWithMock(res, 'handle_update_cancel') |
|
|
|
res._needs_update(mock.ANY, mock.ANY, |
|
mock.ANY, mock.ANY, |
|
None).AndReturn(True) |
|
cookie = object() |
|
res.handle_update(mock.ANY, mock.ANY, mock.ANY).AndReturn(cookie) |
|
res.check_update_complete(cookie).AndReturn(False) |
|
res.handle_update_cancel(cookie).AndReturn(None) |
|
|
|
self.m.ReplayAll() |
|
|
|
scheduler.TaskRunner(res.create)() |
|
|
|
runner = scheduler.TaskRunner(res.update, tmpl) |
|
runner.start() |
|
runner.step() |
|
runner.cancel() |
|
|
|
self.m.VerifyAll() |
|
|
|
def _mock_check_res(self, mock_check=True): |
|
tmpl = rsrc_defn.ResourceDefinition('test_res', 'GenericResourceType') |
|
res = generic_rsrc.ResourceWithProps('test_res', tmpl, self.stack) |
|
res.state_set(res.CREATE, res.COMPLETE) |
|
if mock_check: |
|
res.handle_check = mock.Mock() |
|
|
|
return res |
|
|
|
def test_check_supported(self): |
|
res = self._mock_check_res() |
|
|
|
scheduler.TaskRunner(res.check)() |
|
|
|
self.assertTrue(res.handle_check.called) |
|
self.assertEqual(res.CHECK, res.action) |
|
self.assertEqual(res.COMPLETE, res.status) |
|
self.assertNotIn('not supported', res.status_reason) |
|
|
|
def test_check_not_supported(self): |
|
res = self._mock_check_res(mock_check=False) |
|
scheduler.TaskRunner(res.check)() |
|
|
|
self.assertIn('not supported', res.status_reason) |
|
self.assertEqual(res.CHECK, res.action) |
|
self.assertEqual(res.COMPLETE, res.status) |
|
|
|
def test_check_failed(self): |
|
res = self._mock_check_res() |
|
res.handle_check.side_effect = Exception('boom') |
|
|
|
self.assertRaises(exception.ResourceFailure, |
|
scheduler.TaskRunner(res.check)) |
|
self.assertTrue(res.handle_check.called) |
|
self.assertEqual(res.CHECK, res.action) |
|
self.assertEqual(res.FAILED, res.status) |
|
self.assertIn('boom', res.status_reason) |
|
|
|
def test_verify_check_conditions(self): |
|
valid_foos = ['foo1', 'foo2'] |
|
checks = [ |
|
{'attr': 'foo1', 'expected': 'bar1', 'current': 'baz1'}, |
|
{'attr': 'foo2', 'expected': valid_foos, 'current': 'foo2'}, |
|
{'attr': 'foo3', 'expected': 'bar3', 'current': 'baz3'}, |
|
{'attr': 'foo4', 'expected': 'foo4', 'current': 'foo4'}, |
|
{'attr': 'foo5', 'expected': valid_foos, 'current': 'baz5'}, |
|
] |
|
tmpl = rsrc_defn.ResourceDefinition('test_res', 'GenericResourceType') |
|
res = generic_rsrc.ResourceWithProps('test_res', tmpl, self.stack) |
|
|
|
exc = self.assertRaises(exception.Error, |
|
res._verify_check_conditions, checks) |
|
exc_text = six.text_type(exc) |
|
self.assertNotIn("'foo2':", exc_text) |
|
self.assertNotIn("'foo4':", exc_text) |
|
self.assertIn("'foo1': expected 'bar1', got 'baz1'", exc_text) |
|
self.assertIn("'foo3': expected 'bar3', got 'baz3'", exc_text) |
|
self.assertIn("'foo5': expected '['foo1', 'foo2']', got 'baz5'", |
|
exc_text) |
|
|
|
def test_suspend_resume_ok(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
res.update_allowed_properties = ('Foo',) |
|
scheduler.TaskRunner(res.create)() |
|
self.assertEqual((res.CREATE, res.COMPLETE), res.state) |
|
scheduler.TaskRunner(res.suspend)() |
|
self.assertEqual((res.SUSPEND, res.COMPLETE), res.state) |
|
scheduler.TaskRunner(res.resume)() |
|
self.assertEqual((res.RESUME, res.COMPLETE), res.state) |
|
|
|
def test_suspend_fail_invalid_states(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
scheduler.TaskRunner(res.create)() |
|
self.assertEqual((res.CREATE, res.COMPLETE), res.state) |
|
|
|
invalid_actions = (a for a in res.ACTIONS if a != res.SUSPEND) |
|
invalid_status = (s for s in res.STATUSES if s != res.COMPLETE) |
|
invalid_states = [s for s in |
|
itertools.product(invalid_actions, invalid_status)] |
|
|
|
for state in invalid_states: |
|
res.state_set(*state) |
|
suspend = scheduler.TaskRunner(res.suspend) |
|
expected = 'State %s invalid for suspend' % six.text_type(state) |
|
exc = self.assertRaises(exception.ResourceFailure, suspend) |
|
self.assertIn(expected, six.text_type(exc)) |
|
|
|
def test_resume_fail_invalid_states(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
scheduler.TaskRunner(res.create)() |
|
self.assertEqual((res.CREATE, res.COMPLETE), res.state) |
|
|
|
invalid_states = [s for s in |
|
itertools.product(res.ACTIONS, res.STATUSES) |
|
if s not in ((res.SUSPEND, res.COMPLETE), |
|
(res.RESUME, res.FAILED), |
|
(res.RESUME, res.COMPLETE))] |
|
for state in invalid_states: |
|
res.state_set(*state) |
|
resume = scheduler.TaskRunner(res.resume) |
|
expected = 'State %s invalid for resume' % six.text_type(state) |
|
exc = self.assertRaises(exception.ResourceFailure, resume) |
|
self.assertIn(expected, six.text_type(exc)) |
|
|
|
def test_suspend_fail_exception(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
scheduler.TaskRunner(res.create)() |
|
self.assertEqual((res.CREATE, res.COMPLETE), res.state) |
|
|
|
self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, |
|
'handle_suspend') |
|
generic_rsrc.ResourceWithProps.handle_suspend().AndRaise(Exception()) |
|
self.m.ReplayAll() |
|
|
|
suspend = scheduler.TaskRunner(res.suspend) |
|
self.assertRaises(exception.ResourceFailure, suspend) |
|
self.assertEqual((res.SUSPEND, res.FAILED), res.state) |
|
|
|
def test_resume_fail_exception(self): |
|
tmpl = rsrc_defn.ResourceDefinition('test_resource', |
|
'GenericResourceType', |
|
{'Foo': 'abc'}) |
|
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) |
|
scheduler.TaskRunner(res.create)() |
|
self.assertEqual((res.CREATE, res.COMPLETE), res.state) |
|
|
|
self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_resume') |
|
generic_rsrc.ResourceWithProps.handle_resume().AndRaise(Exception()) |
|
self.m.ReplayAll() |
|
|
|
res.state_set(res.SUSPEND, res.COMPLETE) |
|
|
|
resume = scheduler.TaskRunner(res.resume) |
|
self.assertRaises(exception.ResourceFailure, resume) |
|
self.assertEqual((res.RESUME, res.FAILED), res.state) |
|
|
|
def test_resource_class_to_cfn_template(self): |
|
|
|
class TestResource(resource.Resource): |
|
list_schema = {'wont_show_up': {'Type': 'Number'}} |
|
map_schema = {'will_show_up': {'Type': 'Integer'}} |
|
|
|
properties_schema = { |
|
'name': {'Type': 'String'}, |
|
'bool': {'Type': 'Boolean'}, |
|
'implemented': {'Type': 'String', |
|
'Implemented': True, |
|
'AllowedPattern': '.*', |
|
'MaxLength': 7, |
|
'MinLength': 2, |
|
'Required': True}, |
|
'not_implemented': {'Type': 'String', |
|
'Implemented': False}, |
|
'number': {'Type': 'Number', |
|
'MaxValue': 77, |
|
'MinValue': 41, |
|
'Default': 42}, |
|
'list': {'Type': 'List', 'Schema': {'Type': 'Map', |
|
'Schema': list_schema}}, |
|
'map': {'Type': 'Map', 'Schema': map_schema}, |
|
'hidden': properties.Schema( |
|
properties.Schema.STRING, |
|
support_status=support.SupportStatus( |
|
status=support.HIDDEN)) |
|
} |
|
|
|
attributes_schema = { |
|
'output1': attributes.Schema('output1_desc'), |
|
'output2': attributes.Schema('output2_desc') |
|
} |
|
|
|
expected_template = { |
|
'HeatTemplateFormatVersion': '2012-12-12', |
|
'Description': 'Initial template of TestResource', |
|
'Parameters': { |
|
'name': {'Type': 'String'}, |
|
'bool': {'Type': 'Boolean', |
|
'AllowedValues': ['True', 'true', 'False', 'false']}, |
|
'implemented': { |
|
'Type': 'String', |
|
'AllowedPattern': '.*', |
|
'MaxLength': 7, |
|
'MinLength': 2 |
|
}, |
|
'number': {'Type': 'Number', |
|
'MaxValue': 77, |
|
'MinValue': 41, |
|
'Default': 42}, |
|
'list': {'Type': 'CommaDelimitedList'}, |
|
'map': {'Type': 'Json'} |
|
}, |
|
'Resources': { |
|
'TestResource': { |
|
'Type': 'Test::Resource::resource', |
|
'Properties': { |
|
'name': {'Ref': 'name'}, |
|
'bool': {'Ref': 'bool'}, |
|
'implemented': {'Ref': 'implemented'}, |
|
'number': {'Ref': 'number'}, |
|
'list': {'Fn::Split': [",", {'Ref': 'list'}]}, |
|
'map': {'Ref': 'map'} |
|
} |
|
} |
|
}, |
|
'Outputs': { |
|
'output1': { |
|
'Description': 'output1_desc', |
|
'Value': {"Fn::GetAtt": ["TestResource", "output1"]} |
|
}, |
|
'output2': { |
|
'Description': 'output2_desc', |
|
'Value': {"Fn::GetAtt": ["TestResource", "output2"]} |
|
}, |
|
'show': { |
|
'Description': u'Detailed information about resource.', |
|
'Value': {"Fn::GetAtt": ["TestResource", "show"]} |
|
}, |
|
'OS::stack_id': { |
|
'Value': {"Ref": "TestResource"} |
|
} |
|
} |
|
} |
|
self.assertEqual(expected_template, |
|
TestResource.resource_to_template( |
|
'Test::Resource::resource')) |
|
|
|
def test_resource_class_to_hot_template(self): |
|
|
|
class TestResource(resource.Resource): |
|
list_schema = {'wont_show_up': {'Type': 'Number'}} |
|
map_schema = {'will_show_up': {'Type': 'Integer'}} |
|
|
|
properties_schema = { |
|
'name': {'Type': 'String'}, |
|
'bool': {'Type': 'Boolean'}, |
|
'implemented': {'Type': 'String', |
|
'Implemented': True, |
|
'AllowedPattern': '.*', |
|
'MaxLength': 7, |
|
'MinLength': 2, |
|
'Required': True}, |
|
'not_implemented': {'Type': 'String', |
|
'Implemented': False}, |
|
'number': {'Type': 'Number', |
|
'MaxValue': 77, |
|
'MinValue': 41, |
|
'Default': 42}, |
|
'list': {'Type': 'List', 'Schema': {'Type': 'Map', |
|
'Schema': list_schema}}, |
|
'map': {'Type': 'Map', 'Schema': map_schema}, |
|
'hidden': properties.Schema( |
|
properties.Schema.STRING, |
|
support_status=support.SupportStatus( |
|
status=support.HIDDEN)) |
|
} |
|
|
|
attributes_schema = { |
|
'output1': attributes.Schema('output1_desc'), |
|
'output2': attributes.Schema('output2_desc') |
|
} |
|
|
|
expected_template = { |
|
'heat_template_version': '2016-10-14', |
|
'description': 'Initial template of TestResource', |
|
'parameters': { |
|
'name': {'type': 'string'}, |
|
'bool': {'type': 'boolean'}, |
|
'implemented': { |
|
'type': 'string', |
|
'constraints': [{'length': {'max': 7, 'min': 2}}, |
|
{'allowed_pattern': '.*'}] |
|
}, |
|
'number': {'type': 'number', |
|
'constraints': [{'range': {'max': 77, 'min': 41}}], |
|
'default': 42}, |
|
'list': {'type': 'comma_delimited_list'}, |
|
'map': {'type': 'json'} |
|
}, |
|
'resources': { |
|
'TestResource': { |
|
'type': 'Test::Resource::resource', |
|
'properties': { |
|
'name': {'get_param': 'name'}, |
|
'bool': {'get_param': 'bool'}, |
|
'implemented': {'get_param': 'implemented'}, |
|
'number': {'get_param': 'number'}, |
|
'list': {'get_param': 'list'}, |
|
'map': {'get_param': 'map'} |
|
} |
|
} |
|
}, |
|
'outputs': { |
|
'output1': { |
|
'description': 'output1_desc', |
|
'value': {"get_attr": ["TestResource", "output1"]} |
|
}, |
|
'output2': { |
|
'description': 'output2_desc', |
|
'value': {"get_attr": ["TestResource", "output2"]} |
|
}, |
|
'show': { |
|
'description': u'Detailed information about resource.', |
|
'value': {"get_attr": ["TestResource", "show"]} |
|
}, |
|
'OS::stack_id': { |
|
'value': {"get_resource": "TestResource"} |
|
} |
|
} |
|
} |
|
self.assertEqual(expected_template, |
|
TestResource.resource_to_template( |
|
'Test::Resource::resource', |
|
template_type='hot')) |
|
|
|
def test_is_not_using_neutron_exception(self): |
|
snippet = rsrc_defn.ResourceDefinition('aresource', |
|
'GenericResourceType') |
|
res = resource.Resource('aresource', snippet, self.stack) |
|
mock_create = self.patch( |
|
'heat.engine.clients.os.neutron.NeutronClientPlugin._create') |
|
mock_create.side_effect = Exception() |
|
self.assertFalse(res.is_using_neutron()) |
|
|
|
def test_is_using_neutron_endpoint_lookup(self): |
|
snippet = rsrc_defn.ResourceDefinition('aresource', |
|
'GenericResourceType') |
|
res = resource.Resource('aresource', snippet, self.stack) |
|
client = mock.Mock() |
|
self.patchobject(client.httpclient, 'get_endpoint', |
|
return_value=None) |
|
self.patch( |
|
'heat.engine.clients.os.neutron.NeutronClientPlugin._create', |
|
return_value=client) |
|
self.assertFalse(res.is_using_neutron()) |
|
self.patchobject(client.httpclient, 'get_endpoint', |
|
return_value=mock.Mock()) |
|
self.assertTrue(res.is_using_neutron()) |
|
|
|
def _test_skip_validation_if_custom_constraint(self, tmpl): |
|
stack = parser.Stack(utils.dummy_context(), 'test', tmpl) |
|
stack.store() |
|
path = ('heat.engine.clients.os.neutron.neutron_constraints.' |
|
'NetworkConstraint.validate_with_client') |
|
with mock.patch(path) as mock_validate: |
|
mock_validate.side_effect = neutron_exp.NeutronClientException |
|
rsrc2 = stack['bar'] |
|
self.assertIsNone(rsrc2.validate()) |
|
|
|
def test_ref_skip_validation_if_custom_constraint(self): |
|
tmpl = template.Template({ |
|
'HeatTemplateFormatVersion': '2012-12-12', |
|
'Resources': { |
|
'foo': {'Type': 'OS::Test::GenericResource'}, |
|
'bar': { |
|
'Type': 'OS::Test::ResourceWithCustomConstraint', |
|
'Properties': { |
|
'Foo': {'Ref': 'foo'}, |
|
} |
|
} |
|
} |
|
}, env=self.env) |
|
self._test_skip_validation_if_custom_constraint(tmpl) |
|
|
|
def test_hot_ref_skip_validation_if_custom_constraint(self): |
|
tmpl = template.Template({ |
|
'heat_template_version': '2013-05-23', |
|
'resources': { |
|
'foo': {'type': 'GenericResourceType'}, |
|
'bar': { |
|
'type': 'ResourceWithCustomConstraint', |
|
'properties': { |
|
'Foo': {'get_resource': 'foo'}, |
|
} |
|
} |
|
} |
|
}, env=self.env) |
|
self._test_skip_validation_if_custom_constraint(tmpl) |
|
|
|
def test_no_resource_properties_required_default(self): |
|
"""Test that there is no required properties with default value |
|
|
|
Check all resources if they have properties with required flag and |
|
default value because it is ambiguous. |
|
""" |
|
env = environment.Environment({}, user_env=False) |
|
resources._load_global_environment(env) |
|
|
|
# change loading mechanism for resources that require template files |
|
mod_dir = os.path.dirname(sys.modules[__name__].__file__) |
|
project_dir = os.path.abspath(os.path.join(mod_dir, '../../')) |
|
template_path = os.path.join(project_dir, 'etc', 'heat', 'templates') |
|
|
|
tri_db_instance = env.get_resource_info( |
|
'AWS::RDS::DBInstance', |
|
registry_type=environment.TemplateResourceInfo) |
|
tri_db_instance.template_name = tri_db_instance.template_name.replace( |
|
'/etc/heat/templates', template_path) |
|
tri_alarm = env.get_resource_info( |
|
'AWS::CloudWatch::Alarm', |
|
registry_type=environment.TemplateResourceInfo) |
|
tri_alarm.template_name = tri_alarm.template_name.replace( |
|
'/etc/heat/templates', template_path) |
|
|
|
def _validate_property_schema(prop_name, prop, res_name): |
|
if isinstance(prop, properties.Schema) and prop.implemented: |
|
ambiguous = (prop.default is not None) and prop.required |
|
self.assertFalse(ambiguous, |
|
"The definition of the property '{0}' " |
|
"in resource '{1}' is ambiguous: it " |
|
"has default value and required flag. " |
|
"Please delete one of these options." |
|
.format(prop_name, res_name)) |
|
|
|
if prop.schema is not None: |
|
if isinstance(prop.schema, constraints.AnyIndexDict): |
|
_validate_property_schema( |
|
prop_name, |
|
prop.schema.value, |
|
res_name) |
|
else: |
|
for nest_prop_name, nest_prop in six.iteritems( |
|
prop.schema): |
|
_validate_property_schema(nest_prop_name, |
|
nest_prop, |
|
res_name) |
|
|
|
resource_types = env.get_types() |
|
for res_type in resource_types: |
|
res_class = env.get_class(res_type) |
|
if hasattr(res_class, "properties_schema"): |
|
for property_schema_name, property_schema in six.iteritems( |
|
res_class.properties_schema): |
|
_validate_property_schema( |
|
property_schema_name, property_schema, |
|
res_class.__name__) |
|
|
|
def test_getatt_invalid_type(self): |
|
|
|
tmpl = template.Template({ |
|
'heat_template_version': '2013-05-23', |
|
'resources': { |
|
'res': { |
|
'type': 'ResourceWithAttributeType' |
|
} |
|
} |
|
}) |
|
stack = parser.Stack(utils.dummy_context(), 'test', tmpl) |
|
res = stack['res'] |
|
self.assertEqual('valid_sting', res.FnGetAtt('attr1')) |
|
|
|
res.FnGetAtt('attr2') |
|
self.assertIn("Attribute attr2 is not of type Map", self.LOG.output) |
|
|
|