def test_resource_init_from_dict(self):
hi = identifier.HeatIdentifier('t', 's', 'i', '/resources/r')
ri = identifier.ResourceIdentifier(**hi)
self.assertEqual(ri, hi)
def identifier(self):
'''Return an identifier for this resource.'''
return identifier.ResourceIdentifier(resource_name=self.name,
**self.stack.identifier())
def test_resource_init_path(self):
si = identifier.HeatIdentifier('t', 's', 'i')
pi = identifier.ResourceIdentifier(resource_name='p', **si)
ri = identifier.ResourceIdentifier(resource_name='r', **pi)
self.assertEqual(ri.path, '/resources/p/resources/r')
def test_wait_metadata(self, mock_identifier, mock_sleep, mock_check,
mock_handle, *args):
"""Tests a wait condition metadata update after a signal call."""
# Setup Stack
temp = template_format.parse(TEST_TEMPLATE_WAIT_CONDITION)
template = tmpl.Template(temp)
ctx = utils.dummy_context()
stack = stk.Stack(ctx, 'test-stack', template, disable_rollback=True)
stack.store()
self.stub_KeypairConstraint_validate()
res_id = identifier.ResourceIdentifier('test_tenant_id', stack.name,
stack.id, '', 'WH')
mock_identifier.return_value = res_id
watch = stack['WC']
inst = stack['S2']
# Setup Sleep Behavior
self.run_empty = True
def check_empty(sleep_time):
self.assertEqual('{}', watch.FnGetAtt('Data'))
self.assertIsNone(inst.metadata_get()['test'])
def update_metadata(unique_id, data, reason):
self.man.resource_signal(ctx,
dict(stack.identifier()),
'WH', {
'Data': data,
'Reason': reason,
'Status': 'SUCCESS',
'UniqueId': unique_id
},
sync_call=True)
def post_success(sleep_time):
update_metadata('123', 'foo', 'bar')
def side_effect_popper(sleep_time):
wh = stack['WH']
if wh.status == wh.IN_PROGRESS:
return
elif self.run_empty:
self.run_empty = False
check_empty(sleep_time)
else:
post_success(sleep_time)
mock_sleep.side_effect = side_effect_popper
# Test Initial Creation
stack.create()
self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state)
self.assertEqual('{"123": "foo"}', watch.FnGetAtt('Data'))
self.assertEqual('{"123": "foo"}', inst.metadata_get()['test'])
# Test Update
update_metadata('456', 'blarg', 'wibble')
self.assertEqual({
'123': 'foo',
'456': 'blarg'
}, jsonutils.loads(watch.FnGetAtt('Data')))
self.assertEqual('{"123": "foo"}', inst.metadata_get()['test'])
self.assertEqual({
'123': 'foo',
'456': 'blarg'
}, jsonutils.loads(inst.metadata_get(refresh=True)['test']))
# Verify outgoing calls
self.assertEqual(2, mock_handle.call_count)
self.assertEqual(2, mock_check.call_count)
def _test_resource_index(self, event_id, mock_enforce):
self._mock_enforce_setup(mock_enforce, 'index', True)
res_name = 'WikiDatabase'
stack_identity = identifier.HeatIdentifier(self.tenant,
'wordpress', '6')
res_identity = identifier.ResourceIdentifier(resource_name=res_name,
**stack_identity)
ev_identity = identifier.EventIdentifier(event_id=event_id,
**res_identity)
req = self._get(stack_identity._tenant_path() +
'/resources/' + res_name + '/events')
kwargs = {'stack_identity': stack_identity,
'limit': None, 'sort_keys': None, 'marker': None,
'sort_dir': None, 'filters': {'resource_name': res_name}}
engine_resp = [
{
u'stack_name': u'wordpress',
u'event_time': u'2012-07-23T13:05:39Z',
u'stack_identity': dict(stack_identity),
u'resource_name': res_name,
u'resource_status_reason': u'state changed',
u'event_identity': dict(ev_identity),
u'resource_action': u'CREATE',
u'resource_status': u'IN_PROGRESS',
u'physical_resource_id': None,
u'resource_properties': {u'UserData': u'blah'},
u'resource_type': u'AWS::EC2::Instance',
}
]
self.m.StubOutWithMock(rpc_client.EngineClient, 'call')
rpc_client.EngineClient.call(
req.context, ('list_events', kwargs)
).AndReturn(engine_resp)
self.m.ReplayAll()
result = self.controller.index(req, tenant_id=self.tenant,
stack_name=stack_identity.stack_name,
stack_id=stack_identity.stack_id,
resource_name=res_name)
expected = {
'events': [
{
'id': event_id,
'links': [
{'href': self._url(ev_identity), 'rel': 'self'},
{'href': self._url(res_identity), 'rel': 'resource'},
{'href': self._url(stack_identity), 'rel': 'stack'},
],
u'resource_name': res_name,
u'logical_resource_id': res_name,
u'resource_status_reason': u'state changed',
u'event_time': u'2012-07-23T13:05:39Z',
u'resource_status': u'CREATE_IN_PROGRESS',
u'physical_resource_id': None,
}
]
}
self.assertEqual(expected, result)
self.m.VerifyAll()
def _test_show(self, event_id, mock_enforce):
self._mock_enforce_setup(mock_enforce, 'show', True)
res_name = 'WikiDatabase'
stack_identity = identifier.HeatIdentifier(self.tenant,
'wordpress', '6')
res_identity = identifier.ResourceIdentifier(resource_name=res_name,
**stack_identity)
ev_identity = identifier.EventIdentifier(event_id=event_id,
**res_identity)
req = self._get(stack_identity._tenant_path() +
'/resources/' + res_name + '/events/' + event_id)
kwargs = {'stack_identity': stack_identity,
'limit': None, 'sort_keys': None, 'marker': None,
'sort_dir': None, 'nested_depth': None,
'filters': {'resource_name': res_name, 'uuid': event_id}}
engine_resp = [
{
u'stack_name': u'wordpress',
u'event_time': u'2012-07-23T13:06:00Z',
u'stack_identity': dict(stack_identity),
u'resource_name': res_name,
u'resource_status_reason': u'state changed',
u'event_identity': dict(ev_identity),
u'resource_action': u'CREATE',
u'resource_status': u'COMPLETE',
u'physical_resource_id':
u'a3455d8c-9f88-404d-a85b-5315293e67de',
u'resource_properties': {u'UserData': u'blah'},
u'resource_type': u'AWS::EC2::Instance',
}
]
mock_call = self.patchobject(rpc_client.EngineClient, 'call',
return_value=engine_resp)
result = self.controller.show(req, tenant_id=self.tenant,
stack_name=stack_identity.stack_name,
stack_id=stack_identity.stack_id,
resource_name=res_name,
event_id=event_id)
expected = {
'event': {
'id': event_id,
'links': [
{'href': self._url(ev_identity), 'rel': 'self'},
{'href': self._url(res_identity), 'rel': 'resource'},
{'href': self._url(stack_identity), 'rel': 'stack'},
],
u'resource_name': res_name,
u'logical_resource_id': res_name,
u'resource_status_reason': u'state changed',
u'event_time': u'2012-07-23T13:06:00Z',
u'resource_status': u'CREATE_COMPLETE',
u'physical_resource_id':
u'a3455d8c-9f88-404d-a85b-5315293e67de',
u'resource_type': u'AWS::EC2::Instance',
u'resource_properties': {u'UserData': u'blah'},
}
}
self.assertEqual(expected, result)
mock_call.assert_called_once_with(
req.context,
('list_events', kwargs),
version='1.31'
)
def test_event_resource(self):
si = identifier.HeatIdentifier('t', 's', 'i')
pi = identifier.ResourceIdentifier(resource_name='r', **si)
ei = identifier.EventIdentifier(event_id='e', **pi)
self.assertEqual(pi, ei.resource())
def test_index(self, mock_enforce):
self._mock_enforce_setup(mock_enforce, 'index', True)
res_name = 'WikiDatabase'
stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress',
'1')
res_identity = identifier.ResourceIdentifier(resource_name=res_name,
**stack_identity)
req = self._get(stack_identity._tenant_path() + '/resources')
engine_resp = [{
u'resource_identity': dict(res_identity),
u'stack_name': stack_identity.stack_name,
u'resource_name': res_name,
u'resource_status_reason': None,
u'updated_time': u'2012-07-23T13:06:00Z',
u'stack_identity': stack_identity,
u'resource_action': u'CREATE',
u'resource_status': u'COMPLETE',
u'physical_resource_id': u'a3455d8c-9f88-404d-a85b-5315293e67de',
u'resource_type': u'AWS::EC2::Instance',
}]
self.m.StubOutWithMock(rpc_client.EngineClient, 'call')
rpc_client.EngineClient.call(req.context, ('list_stack_resources', {
'stack_identity': stack_identity,
'nested_depth': 0,
'with_detail': False,
}),
version='1.12').AndReturn(engine_resp)
self.m.ReplayAll()
result = self.controller.index(req,
tenant_id=self.tenant,
stack_name=stack_identity.stack_name,
stack_id=stack_identity.stack_id)
expected = {
'resources': [{
'links': [{
'href': self._url(res_identity),
'rel': 'self'
}, {
'href': self._url(stack_identity),
'rel': 'stack'
}],
u'resource_name':
res_name,
u'logical_resource_id':
res_name,
u'resource_status_reason':
None,
u'updated_time':
u'2012-07-23T13:06:00Z',
u'resource_status':
u'CREATE_COMPLETE',
u'physical_resource_id':
u'a3455d8c-9f88-404d-a85b-5315293e67de',
u'resource_type':
u'AWS::EC2::Instance'
}]
}
self.assertEqual(expected, result)
self.m.VerifyAll()
def test_resource_init_no_path(self):
si = identifier.HeatIdentifier('t', 's', 'i')
ri = identifier.ResourceIdentifier(resource_name='r', **si)
self.assertEqual('/resources/r', ri.path)
def test_index_detail(self, mock_enforce):
self._mock_enforce_setup(mock_enforce, 'index', True)
res_name = 'WikiDatabase'
stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress',
'1')
res_identity = identifier.ResourceIdentifier(resource_name=res_name,
**stack_identity)
req = self._get(stack_identity._tenant_path() + '/resources',
{'with_detail': 'true'})
resp_parameters = {
"OS::project_id": "3ab5b02fa01f4f95afa1e254afc4a435",
"network": "cf05086d-07c7-4ed6-95e5-e4af724677e6",
"OS::stack_name": "s1",
"admin_pass": "******",
"key_name": "kk",
"image": "fa5d387e-541f-4dfb-ae8a-83a614683f84",
"db_port": "50000",
"OS::stack_id": "723d7cee-46b3-4433-9c21-f3378eb0bfc4",
"flavor": "1"
},
engine_resp = [{
u'resource_identity':
dict(res_identity),
u'stack_name':
stack_identity.stack_name,
u'resource_name':
res_name,
u'resource_status_reason':
None,
u'updated_time':
u'2012-07-23T13:06:00Z',
u'stack_identity':
stack_identity,
u'resource_action':
u'CREATE',
u'resource_status':
u'COMPLETE',
u'physical_resource_id':
u'a3455d8c-9f88-404d-a85b-5315293e67de',
u'resource_type':
u'AWS::EC2::Instance',
u'parameters':
resp_parameters,
u'description':
u'Hello description',
u'stack_user_project_id':
u'6f38bcfebbc4400b82d50c1a2ea3057d',
}]
self.m.StubOutWithMock(rpc_client.EngineClient, 'call')
rpc_client.EngineClient.call(req.context, ('list_stack_resources', {
'stack_identity': stack_identity,
'nested_depth': 0,
'with_detail': True
}),
version='1.12').AndReturn(engine_resp)
self.m.ReplayAll()
result = self.controller.index(req,
tenant_id=self.tenant,
stack_name=stack_identity.stack_name,
stack_id=stack_identity.stack_id)
expected = {
'resources': [{
'links': [{
'href': self._url(res_identity),
'rel': 'self'
}, {
'href': self._url(stack_identity),
'rel': 'stack'
}],
u'resource_name':
res_name,
u'logical_resource_id':
res_name,
u'resource_status_reason':
None,
u'updated_time':
u'2012-07-23T13:06:00Z',
u'resource_status':
u'CREATE_COMPLETE',
u'physical_resource_id':
u'a3455d8c-9f88-404d-a85b-5315293e67de',
u'resource_type':
u'AWS::EC2::Instance',
u'parameters':
resp_parameters,
u'description':
u'Hello description',
u'stack_user_project_id':
u'6f38bcfebbc4400b82d50c1a2ea3057d'
}]
}
self.assertEqual(expected, result)
self.m.VerifyAll()
def test_show(self, mock_enforce):
self._mock_enforce_setup(mock_enforce, 'show', True)
res_name = 'WikiDatabase'
stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress',
'6')
res_identity = identifier.ResourceIdentifier(resource_name=res_name,
**stack_identity)
req = self._get(stack_identity._tenant_path())
engine_resp = {
u'description': u'',
u'resource_identity': dict(res_identity),
u'stack_name': stack_identity.stack_name,
u'resource_name': res_name,
u'resource_status_reason': None,
u'updated_time': u'2012-07-23T13:06:00Z',
u'stack_identity': dict(stack_identity),
u'resource_action': u'CREATE',
u'resource_status': u'COMPLETE',
u'physical_resource_id': u'a3455d8c-9f88-404d-a85b-5315293e67de',
u'resource_type': u'AWS::EC2::Instance',
u'metadata': {
u'ensureRunning': u'true'
}
}
self.m.StubOutWithMock(rpc_client.EngineClient, 'call')
rpc_client.EngineClient.call(req.context, ('describe_stack_resource', {
'stack_identity': stack_identity,
'resource_name': res_name,
'with_attr': None
}),
version='1.2').AndReturn(engine_resp)
self.m.ReplayAll()
result = self.controller.show(req,
tenant_id=self.tenant,
stack_name=stack_identity.stack_name,
stack_id=stack_identity.stack_id,
resource_name=res_name)
expected = {
'resource': {
'links': [
{
'href': self._url(res_identity),
'rel': 'self'
},
{
'href': self._url(stack_identity),
'rel': 'stack'
},
],
u'description':
u'',
u'resource_name':
res_name,
u'logical_resource_id':
res_name,
u'resource_status_reason':
None,
u'updated_time':
u'2012-07-23T13:06:00Z',
u'resource_status':
u'CREATE_COMPLETE',
u'physical_resource_id':
u'a3455d8c-9f88-404d-a85b-5315293e67de',
u'resource_type':
u'AWS::EC2::Instance',
}
}
self.assertEqual(expected, result)
self.m.VerifyAll()
def test_event_init(self):
si = identifier.HeatIdentifier('t', 's', 'i')
pi = identifier.ResourceIdentifier(resource_name='p', **si)
ei = identifier.EventIdentifier(event_id='e', **pi)
self.assertEqual(ei.path, '/resources/p/events/e')
def handle_stack_method(controller, stack_identity, resource_name,
**kwargs):
resource_identity = identifier.ResourceIdentifier(
stack_identity, resource_name)
return handler(controller, req, dict(resource_identity), **kwargs)
def _test_resource_index(self, event_id, mock_enforce, nested_depth=None):
self._mock_enforce_setup(mock_enforce, 'index', True)
res_name = 'WikiDatabase'
params = {}
if nested_depth:
params['nested_depth'] = nested_depth
stack_identity = identifier.HeatIdentifier(self.tenant,
'wordpress', '6')
res_identity = identifier.ResourceIdentifier(resource_name=res_name,
**stack_identity)
ev_identity = identifier.EventIdentifier(event_id=event_id,
**res_identity)
req = self._get(stack_identity._tenant_path() +
'/resources/' + res_name + '/events',
params=params)
kwargs = {'stack_identity': stack_identity,
'nested_depth': nested_depth,
'limit': None, 'sort_keys': None, 'marker': None,
'sort_dir': None, 'filters': {'resource_name': res_name}}
engine_resp = [
{
u'stack_name': u'wordpress',
u'event_time': u'2012-07-23T13:05:39Z',
u'stack_identity': dict(stack_identity),
u'resource_name': res_name,
u'resource_status_reason': u'state changed',
u'event_identity': dict(ev_identity),
u'resource_action': u'CREATE',
u'resource_status': u'IN_PROGRESS',
u'physical_resource_id': None,
u'resource_type': u'AWS::EC2::Instance',
}
]
if nested_depth:
engine_resp[0]['root_stack_id'] = dict(stack_identity)
mock_call = self.patchobject(rpc_client.EngineClient, 'call',
return_value=engine_resp)
result = self.controller.index(req, tenant_id=self.tenant,
stack_name=stack_identity.stack_name,
stack_id=stack_identity.stack_id,
resource_name=res_name)
expected = {
'events': [
{
'id': event_id,
'links': [
{'href': self._url(ev_identity), 'rel': 'self'},
{'href': self._url(res_identity), 'rel': 'resource'},
{'href': self._url(stack_identity), 'rel': 'stack'},
],
u'resource_name': res_name,
u'logical_resource_id': res_name,
u'resource_status_reason': u'state changed',
u'event_time': u'2012-07-23T13:05:39Z',
u'resource_status': u'CREATE_IN_PROGRESS',
u'physical_resource_id': None,
}
]
}
if nested_depth:
expected['events'][0]['links'].append(
{'href': self._url(stack_identity), 'rel': 'root_stack'}
)
self.assertEqual(expected, result)
mock_call.assert_called_once_with(
req.context,
('list_events', kwargs),
version='1.31'
)
def test_resource_stack(self):
si = identifier.HeatIdentifier('t', 's', 'i')
ri = identifier.ResourceIdentifier(resource_name='r', **si)
self.assertEqual(ri.stack(), si)
def _test_event_init(self, event_id):
si = identifier.HeatIdentifier('t', 's', 'i')
pi = identifier.ResourceIdentifier(resource_name='p', **si)
ei = identifier.EventIdentifier(event_id=event_id, **pi)
self.assertEqual('/resources/p/events/{0}'.format(event_id), ei.path)
def test_resource_id(self):
ri = identifier.ResourceIdentifier('t', 's', 'i', '', 'r')
self.assertEqual(ri.resource_name, 'r')
def test_show_with_nested_stack(self, mock_enforce):
self._mock_enforce_setup(mock_enforce, 'show', True)
res_name = 'WikiDatabase'
stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress',
'6')
res_identity = identifier.ResourceIdentifier(resource_name=res_name,
**stack_identity)
nested_stack_identity = identifier.HeatIdentifier(
self.tenant, 'nested', 'some_id')
req = self._get(stack_identity._tenant_path())
engine_resp = {
u'description': u'',
u'resource_identity': dict(res_identity),
u'stack_name': stack_identity.stack_name,
u'resource_name': res_name,
u'resource_status_reason': None,
u'updated_time': u'2012-07-23T13:06:00Z',
u'stack_identity': dict(stack_identity),
u'resource_action': u'CREATE',
u'resource_status': u'COMPLETE',
u'physical_resource_id': u'a3455d8c-9f88-404d-a85b-5315293e67de',
u'resource_type': u'AWS::EC2::Instance',
u'attributes': {
u'foo': 'bar'
},
u'metadata': {
u'ensureRunning': u'true'
},
u'nested_stack_id': dict(nested_stack_identity)
}
mock_call = self.patchobject(rpc_client.EngineClient,
'call',
return_value=engine_resp)
result = self.controller.show(req,
tenant_id=self.tenant,
stack_name=stack_identity.stack_name,
stack_id=stack_identity.stack_id,
resource_name=res_name)
expected = [{
'href': self._url(res_identity),
'rel': 'self'
}, {
'href': self._url(stack_identity),
'rel': 'stack'
}, {
'href': self._url(nested_stack_identity),
'rel': 'nested'
}]
self.assertEqual(expected, result['resource']['links'])
self.assertIsNone(result.get(rpc_api.RES_NESTED_STACK_ID))
mock_call.assert_called_once_with(req.context,
('describe_stack_resource', {
'stack_identity': stack_identity,
'resource_name': res_name,
'with_attr': None
}),
version='1.2')
