def test_validate_volumeattach_valid(self):
t = template_format.parse(test_template_volumeattach % 'vdq')
stack = parser.Stack(None, 'test_stack', parser.Template(t))
self.m.StubOutWithMock(db_api, 'resource_get_by_name_and_stack')
db_api.resource_get_by_name_and_stack(None, 'test_resource_name',
stack).AndReturn(None)
self.m.ReplayAll()
volumeattach = stack.resources['MountPoint']
self.assertTrue(volumeattach.validate() is None)
def test_validate_volumeattach_valid(self):
t = template_format.parse(test_template_volumeattach % 'vdq')
stack = parser.Stack(None, 'test_stack', parser.Template(t))
self.m.StubOutWithMock(db_api, 'resource_get_by_name_and_stack')
db_api.resource_get_by_name_and_stack(None, 'test_resource_name',
stack).AndReturn(None)
self.m.ReplayAll()
volumeattach = stack.resources['MountPoint']
self.assertTrue(volumeattach.validate() is None)
def test_validate_volumeattach_invalid(self):
t = template_format.parse(test_template_volumeattach % 'sda')
stack = parser.Stack(None, 'test_stack', parser.Template(t))
self.m.StubOutWithMock(db_api, 'resource_get_by_name_and_stack')
db_api.resource_get_by_name_and_stack(None, 'test_resource_name',
stack).AndReturn(None)
self.m.ReplayAll()
volumeattach = stack.resources['MountPoint']
self.assertRaises(exception.StackValidationFailed,
volumeattach.validate)
def test_validate_volumeattach_invalid(self):
t = template_format.parse(test_template_volumeattach % 'sda')
stack = parser.Stack(None, 'test_stack', parser.Template(t))
self.m.StubOutWithMock(db_api, 'resource_get_by_name_and_stack')
db_api.resource_get_by_name_and_stack(None, 'test_resource_name',
stack).AndReturn(None)
self.m.ReplayAll()
volumeattach = stack.resources['MountPoint']
self.assertRaises(exception.StackValidationFailed,
volumeattach.validate)
def __init__(self, name, json_snippet, stack):
if "/" in name:
raise ValueError(_('Resource name may not contain "/"'))
self.stack = stack
self.context = stack.context
self.name = name
self.json_snippet = json_snippet
self.t = stack.resolve_static_data(json_snippet)
self.properties = Properties(
self.properties_schema, self.t.get("Properties", {}), self.stack.resolve_runtime_data, self.name
)
self.attributes = Attributes(self.name, self.attributes_schema, self._resolve_attribute)
resource = db_api.resource_get_by_name_and_stack(self.context, name, stack.id)
if resource:
self.resource_id = resource.nova_instance
self.action = resource.action
self.status = resource.status
self.status_reason = resource.status_reason
self.id = resource.id
self.data = resource.data
else:
self.resource_id = None
# if the stack is being deleted, assume we've already been deleted
if stack.action == stack.DELETE:
self.action = self.DELETE
else:
self.action = self.INIT
self.status = self.COMPLETE
self.status_reason = ""
self.id = None
self.data = []
def __init__(self, name, json_snippet, stack):
if '/' in name:
raise ValueError(_('Resource name may not contain "/"'))
self.stack = stack
self.context = stack.context
self.name = name
self.json_snippet = json_snippet
self.t = stack.resolve_static_data(json_snippet)
self.properties = Properties(self.properties_schema,
self.t.get('Properties', {}),
self.stack.resolve_runtime_data,
self.name)
self.attributes = Attributes(self.name,
self.attributes_schema,
self._resolve_attribute)
resource = db_api.resource_get_by_name_and_stack(self.context,
name, stack.id)
if resource:
self.resource_id = resource.nova_instance
self.action = resource.action
self.status = resource.status
self.status_reason = resource.status_reason
self.id = resource.id
self.data = resource.data
else:
self.resource_id = None
self.action = self.INIT
self.status = self.COMPLETE
self.status_reason = ''
self.id = None
self.data = []
def get_by_name_and_stack(cls, context, resource_name, stack_id):
resource_db = db_api.resource_get_by_name_and_stack(
context,
resource_name,
stack_id)
resource = cls._from_db_object(cls(context), context, resource_db)
return resource
def __init__(self, name, json_snippet, stack):
if "/" in name:
raise ValueError(_('Resource name may not contain "/"'))
self.stack = stack
self.context = stack.context
self.name = name
self.json_snippet = json_snippet
self.t = stack.resolve_static_data(json_snippet)
self.cached_t = None
self.properties = Properties(
self.properties_schema, self.t.get("Properties", {}), self.stack.resolve_runtime_data, self.name
)
resource = db_api.resource_get_by_name_and_stack(self.context, name, stack.id)
if resource:
self.resource_id = resource.nova_instance
self.state = resource.state
self.state_description = resource.state_description
self.id = resource.id
else:
self.resource_id = None
self.state = None
self.state_description = ""
self.id = None
def event_create(self, context, event):
stack_name = event['stack']
resource_name = event['resource']
stack = db_api.stack_get_by_name(context, stack_name)
resource = db_api.resource_get_by_name_and_stack(
context, resource_name, stack.id)
if not resource:
return ['Unknown resource', None]
new_event = {
'name': event['message'],
'resource_status_reason': event['reason'],
'StackId': stack.id,
'LogicalResourceId': resource.name,
'PhysicalResourceId': None,
'ResourceType': event['resource_type'],
'ResourceProperties': {},
}
try:
result = db_api.event_create(context, new_event)
new_event['id'] = result.id
return [None, new_event]
except Exception as ex:
logger.warn('db error %s' % str(ex))
msg = 'Error creating event'
return [msg, None]
def event_create(self, context, event):
stack_name = event['stack']
resource_name = event['resource']
stack = db_api.stack_get_by_name(context, stack_name)
resource = db_api.resource_get_by_name_and_stack(context,
resource_name,
stack.id)
if not resource:
return ['Unknown resource', None]
new_event = {
'name': event['message'],
'resource_status_reason': event['reason'],
'StackId': stack.id,
'LogicalResourceId': resource.name,
'PhysicalResourceId': None,
'ResourceType': event['resource_type'],
'ResourceProperties': {},
}
try:
result = db_api.event_create(context, new_event)
new_event['id'] = result.id
return [None, new_event]
except Exception as ex:
logger.warn('db error %s' % str(ex))
msg = 'Error creating event'
return [msg, None]
def __init__(self, name, json_snippet, stack):
if '/' in name:
raise ValueError(_('Resource name may not contain "/"'))
self.stack = stack
self.context = stack.context
self.name = name
self.json_snippet = json_snippet
self.t = stack.resolve_static_data(json_snippet)
self.cached_t = None
self.properties = Properties(self.properties_schema,
self.t.get('Properties', {}),
self.stack.resolve_runtime_data,
self.name)
resource = db_api.resource_get_by_name_and_stack(
self.context, name, stack.id)
if resource:
self.resource_id = resource.nova_instance
self.state = resource.state
self.state_description = resource.state_description
self.id = resource.id
else:
self.resource_id = None
self.state = None
self.state_description = ''
self.id = None
def __init__(self, name, json_snippet, stack):
if '/' in name:
raise ValueError(_('Resource name may not contain "/"'))
self.references = []
self.stack = stack
self.context = stack.context
self.name = name
self.t = stack.resolve_static_data(json_snippet)
self.properties = Properties(self.properties_schema,
self.t.get('Properties', {}),
self.stack.resolve_runtime_data,
self.name)
resource = db_api.resource_get_by_name_and_stack(self.context,
name, stack.id)
if resource:
self.resource_id = resource.nova_instance
self.state = resource.state
self.state_description = resource.state_description
self.id = resource.id
else:
self.resource_id = None
self.state = None
self.state_description = ''
self.id = None
self._nova = {}
self._keystone = None
self._swift = None
self._quantum = None
def __init__(self, name, json_snippet, stack):
if '/' in name:
raise ValueError(_('Resource name may not contain "/"'))
self.stack = stack
self.context = stack.context
self.name = name
self.json_snippet = json_snippet
self.t = stack.resolve_static_data(json_snippet)
self.properties = Properties(self.properties_schema,
self.t.get('Properties', {}),
self._resolve_runtime_data, self.name)
self.attributes = Attributes(self.name, self.attributes_schema,
self._resolve_attribute)
resource = db_api.resource_get_by_name_and_stack(
self.context, name, stack.id)
if resource:
self.resource_id = resource.nova_instance
self.action = resource.action
self.status = resource.status
self.status_reason = resource.status_reason
self.id = resource.id
self.data = resource.data
else:
self.resource_id = None
# if the stack is being deleted, assume we've already been deleted
if stack.action == stack.DELETE:
self.action = self.DELETE
else:
self.action = self.INIT
self.status = self.COMPLETE
self.status_reason = ''
self.id = None
self.data = []
def _update_resource(self, res_name):
if res_name in self.current_snippets.keys():
# Resource is in new template, update it if it's in old template
# otherwise create a new one
#old_resource = resource.Resource.load(self.context,
# res_name,
# self.stack)
old_resource = db_api.resource_get_by_name_and_stack(self.context, res_name, self.stack_id)
new_resource = self.stack.resources[res_name]
if old_resource:
# update this
LOG.debug("==== Resource found in both template")
return self._process_new_resource_update(new_resource,
old_resource.rsrc_defn,
old_resource.nova_instance,
old_resource.version + 1)
else:
# new resource to be created
LOG.debug("==== Resource found in new template only...creating it")
return self._create_resource(new_resource)
else:
LOG.debug("==== Resource not found in new template...deleting")
# resource not in new template; mark as deleted
old_resource = db_api.resource_get_by_name_and_stack(
self.context, res_name, self.stack_id)
new_resource = old_resource
new_resource.version = old_resource.version + 1
new_resource.resource_id = old_resource.resource_id
new_resource.id = None
new_resource.store_update(old_resource.DELETE,
old_resource.INIT,
"Resource not in new template")
# set physical resource id to none for old resource
old_resource.resource_id = None
old_resource.store_update(old_resource.action,
old_resource.status,
old_resource.status_reason)
self.stack.add_resource(new_resource)
return
def load(cls, context, name, definition, stack):
'''
Create a resource and load any associated state from the DB.
Note that this is really inefficient if you have to do it for a group
of resources. Use Resource.load_all_from_stack() where possible
instead.
'''
resource = cls(name, definition, stack)
if stack.id is not None:
db_res = db_api.resource_get_by_name_and_stack(context, name,
stack.id)
if db_res is not None:
resource._load_data(db_res)
return resource
def load(cls, context, name, definition, stack):
'''
Create a resource and load any associated state from the DB.
Note that this is really inefficient if you have to do it for a group
of resources. Use Resource.load_all_from_stack() where possible
instead.
'''
resource = cls(name, definition, stack)
if stack.id is not None:
db_res = db_api.resource_get_by_name_and_stack(
context, name, stack.id)
if db_res is not None:
resource._load_data(db_res)
return resource
def test_private_key(self):
stack_name = "test_private_key"
(t, stack) = self._setup_test_stack(stack_name)
cs = cloud_server.CloudServer("cs_private_key", t["Resources"]["WebServer"], stack)
# This gives the fake cloud server an id and created_time attribute
cs._store_or_update(cs.CREATE, cs.IN_PROGRESS, "test_store")
cs.private_key = "fake private key"
self.ctx = utils.dummy_context()
rs = db_api.resource_get_by_name_and_stack(self.ctx, "cs_private_key", stack.id)
encrypted_key = rs.data[0]["value"]
self.assertNotEqual(encrypted_key, "fake private key")
decrypted_key = cs.private_key
self.assertEqual(decrypted_key, "fake private key")
def test_post_success_to_handle(self):
self.stack = self.create_stack()
wc.WaitConditionHandle.get_status().AndReturn([])
wc.WaitConditionHandle.get_status().AndReturn([])
wc.WaitConditionHandle.get_status().AndReturn(["SUCCESS"])
self.m.ReplayAll()
self.stack.create()
rsrc = self.stack["WaitForTheHandle"]
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
r = db_api.resource_get_by_name_and_stack(None, "WaitHandle", self.stack.id)
self.assertEqual("WaitHandle", r.name)
self.m.VerifyAll()
def test_private_key(self):
stack_name = 'test_private_key'
(t, stack) = self._setup_test_stack(stack_name)
cs = cloud_server.CloudServer('cs_private_key',
t['Resources']['WebServer'], stack)
# This gives the fake cloud server an id and created_time attribute
cs._store_or_update(cs.CREATE, cs.IN_PROGRESS, 'test_store')
cs.private_key = 'fake private key'
rs = db_api.resource_get_by_name_and_stack(None, 'cs_private_key',
stack.id)
encrypted_key = rs.data[0]['value']
self.assertNotEqual(encrypted_key, "fake private key")
decrypted_key = cs.private_key
self.assertEqual(decrypted_key, "fake private key")
def test_post_success_to_handle(self):
self.stack = self.create_stack()
wc.WaitConditionHandle.get_status().AndReturn([])
wc.WaitConditionHandle.get_status().AndReturn([])
wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS'])
self.m.ReplayAll()
self.stack.create()
rsrc = self.stack['WaitForTheHandle']
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.id)
self.assertEqual('WaitHandle', r.name)
self.m.VerifyAll()
def __init__(self, name, json_snippet, stack):
if '/' in name:
raise ValueError(_('Resource name may not contain "/"'))
self.stack = stack
self.context = stack.context
self.name = name
self.json_snippet = json_snippet
self.reparse()
self.attributes = Attributes(self.name,
self.attributes_schema,
self._resolve_attribute)
self.abandon_in_progress = False
if stack.id:
resource = db_api.resource_get_by_name_and_stack(self.context,
name, stack.id)
else:
resource = None
if resource:
self.resource_id = resource.nova_instance
self.action = resource.action
self.status = resource.status
self.status_reason = resource.status_reason
self.id = resource.id
try:
self._data = db_api.resource_data_get_all(self, resource.data)
except exception.NotFound:
self._data = {}
self.created_time = resource.created_at
self.updated_time = resource.updated_at
else:
self.resource_id = None
# if the stack is being deleted, assume we've already been deleted
if stack.action == stack.DELETE:
self.action = self.DELETE
else:
self.action = self.INIT
self.status = self.COMPLETE
self.status_reason = ''
self.id = None
self._data = {}
self.created_time = None
self.updated_time = None
def test_private_key(self):
stack_name = 'test_private_key'
(t, stack) = self._setup_test_stack(stack_name)
cs = cloud_server.CloudServer('cs_private_key',
t['Resources']['WebServer'],
stack)
# This gives the fake cloud server an id and created_time attribute
cs._store_or_update(cs.CREATE, cs.IN_PROGRESS, 'test_store')
cs.private_key = 'fake private key'
rs = db_api.resource_get_by_name_and_stack(None,
'cs_private_key',
stack.id)
encrypted_key = rs.data[0]['value']
self.assertNotEqual(encrypted_key, "fake private key")
decrypted_key = cs.private_key
self.assertEqual(decrypted_key, "fake private key")
def test_post_success_to_handle(self):
self.stack = self.create_stack()
wc.WaitConditionHandle.get_status().AndReturn([])
wc.WaitConditionHandle.get_status().AndReturn([])
wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS'])
self.m.ReplayAll()
self.stack.create()
rsrc = self.stack.resources['WaitForTheHandle']
self.assertEqual(rsrc.state,
(rsrc.CREATE, rsrc.COMPLETE))
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.id)
self.assertEqual(r.name, 'WaitHandle')
self.m.VerifyAll()
def test_post_failure_to_handle_count(self):
self.stack = self.create_stack(template=test_template_wc_count)
wc.WaitConditionHandle.get_status().AndReturn([])
wc.WaitConditionHandle.get_status().AndReturn(["SUCCESS"])
wc.WaitConditionHandle.get_status().AndReturn(["SUCCESS", "FAILURE"])
self.m.ReplayAll()
self.stack.create()
rsrc = self.stack["WaitForTheHandle"]
self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state)
reason = rsrc.status_reason
self.assertTrue(reason.startswith("WaitConditionFailure:"))
r = db_api.resource_get_by_name_and_stack(None, "WaitHandle", self.stack.id)
self.assertEqual("WaitHandle", r.name)
self.m.VerifyAll()
def test_post_success_to_handle(self):
self.stack = self.create_stack()
wc.WaitConditionHandle.get_status().AndReturn([])
scheduler.TaskRunner._sleep(mox.IsA(int)).AndReturn(None)
wc.WaitConditionHandle.get_status().AndReturn([])
scheduler.TaskRunner._sleep(mox.IsA(int)).AndReturn(None)
wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS'])
self.m.ReplayAll()
self.stack.create()
rsrc = self.stack.resources['WaitForTheHandle']
self.assertEqual(rsrc.state, 'CREATE_COMPLETE')
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.id)
self.assertEqual(r.name, 'WaitHandle')
self.m.VerifyAll()
def test_private_key(self):
stack_name = 'test_private_key'
(t, stack) = self._setup_test_stack(stack_name)
server = cloud_server.CloudServer('server_private_key',
t['Resources']['WebServer'], stack)
# This gives the fake cloud server an id and created_time attribute
server._store_or_update(server.CREATE, server.IN_PROGRESS,
'test_store')
server.private_key = 'fake private key'
self.ctx = utils.dummy_context()
rs = db_api.resource_get_by_name_and_stack(self.ctx,
'server_private_key',
stack.id)
encrypted_key = rs.data[0]['value']
self.assertNotEqual(encrypted_key, "fake private key")
decrypted_key = server.private_key
self.assertEqual("fake private key", decrypted_key)
def test_post_success_to_handle(self):
self.stack = self.create_stack()
wc.WaitConditionHandle.get_status().AndReturn([])
eventlet.sleep(1).AndReturn(None)
wc.WaitConditionHandle.get_status().AndReturn([])
eventlet.sleep(1).AndReturn(None)
wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS'])
self.m.ReplayAll()
self.stack.create()
resource = self.stack.resources['WaitForTheHandle']
self.assertEqual(resource.state, 'CREATE_COMPLETE')
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.id)
self.assertEqual(r.name, 'WaitHandle')
self.m.VerifyAll()
def test_post_success_to_handle_count(self):
self.stack = self.create_stack(template=test_template_wc_count)
wc.WaitConditionHandle.get_status().AndReturn([])
wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS'])
wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS', 'SUCCESS'])
wc.WaitConditionHandle.get_status().AndReturn(
['SUCCESS', 'SUCCESS', 'SUCCESS'])
self.m.ReplayAll()
self.stack.create()
rsrc = self.stack.resources['WaitForTheHandle']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.id)
self.assertEqual(r.name, 'WaitHandle')
self.m.VerifyAll()
def test_post_failure_to_handle(self):
self.stack = self.create_stack()
wc.WaitConditionHandle.get_status().AndReturn([])
wc.WaitConditionHandle.get_status().AndReturn([])
wc.WaitConditionHandle.get_status().AndReturn(['FAILURE'])
self.m.ReplayAll()
self.stack.create()
rsrc = self.stack.resources['WaitForTheHandle']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.FAILED))
reason = rsrc.status_reason
self.assertTrue(reason.startswith('WaitConditionFailure:'))
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.id)
self.assertEqual(r.name, 'WaitHandle')
self.m.VerifyAll()
def test_post_failure_to_handle_count(self):
self.stack = self.create_stack(template=test_template_wc_count)
wc.WaitConditionHandle.get_status().AndReturn([])
wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS'])
wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS', 'FAILURE'])
self.m.ReplayAll()
self.stack.create()
rsrc = self.stack['WaitForTheHandle']
self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state)
reason = rsrc.status_reason
self.assertTrue(reason.startswith('WaitConditionFailure:'))
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.id)
self.assertEqual('WaitHandle', r.name)
self.m.VerifyAll()
def test_post_failure_to_handle(self):
self.stack = self.create_stack()
wc.WaitConditionHandle.get_status().AndReturn([])
wc.WaitConditionHandle.get_status().AndReturn([])
wc.WaitConditionHandle.get_status().AndReturn(['FAILURE'])
self.m.ReplayAll()
self.stack.create()
rsrc = self.stack['WaitForTheHandle']
self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state)
reason = rsrc.status_reason
self.assertTrue(reason.startswith('WaitConditionFailure:'))
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.id)
self.assertEqual('WaitHandle', r.name)
self.m.VerifyAll()
def test_post_complete_to_handle(self):
self.stack = self.create_stack()
heat_wch.HeatWaitConditionHandle.get_status().AndReturn(['SUCCESS'])
heat_wch.HeatWaitConditionHandle.get_status().AndReturn(
['SUCCESS', 'SUCCESS'])
heat_wch.HeatWaitConditionHandle.get_status().AndReturn(
['SUCCESS', 'SUCCESS', 'SUCCESS'])
self.m.ReplayAll()
self.stack.create()
rsrc = self.stack['wait_condition']
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
r = db_api.resource_get_by_name_and_stack(None, 'wait_handle',
self.stack.id)
self.assertEqual('wait_handle', r.name)
self.m.VerifyAll()
def test_post_failure_to_handle_count(self):
self.stack = self.create_stack(template=test_template_wc_count)
wc.WaitConditionHandle.get_status().AndReturn([])
wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS'])
wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS', 'FAILURE'])
self.m.ReplayAll()
self.stack.create()
rsrc = self.stack.resources['WaitForTheHandle']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.FAILED))
reason = rsrc.status_reason
self.assertTrue(reason.startswith('WaitConditionFailure:'))
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.id)
self.assertEqual(r.name, 'WaitHandle')
self.m.VerifyAll()
def test_private_key(self):
stack_name = 'test_private_key'
(t, stack) = self._setup_test_stack(stack_name)
server = cloud_server.CloudServer('server_private_key',
t['Resources']['WebServer'],
stack)
# This gives the fake cloud server an id and created_time attribute
server._store_or_update(server.CREATE, server.IN_PROGRESS,
'test_store')
server.private_key = 'fake private key'
self.ctx = utils.dummy_context()
rs = db_api.resource_get_by_name_and_stack(self.ctx,
'server_private_key',
stack.id)
encrypted_key = rs.data[0]['value']
self.assertNotEqual(encrypted_key, "fake private key")
decrypted_key = server.private_key
self.assertEqual("fake private key", decrypted_key)
def test_post_success_to_handle_count(self):
self.stack = self.create_stack(template=test_template_wc_count)
wc.WaitConditionHandle.get_status().AndReturn([])
wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS'])
wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS', 'SUCCESS'])
wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS', 'SUCCESS',
'SUCCESS'])
self.m.ReplayAll()
self.stack.create()
rsrc = self.stack['WaitForTheHandle']
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE),
rsrc.state)
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.id)
self.assertEqual('WaitHandle', r.name)
self.m.VerifyAll()
def test_post_success_to_handle(self):
self.stack = self.create_stack()
wc.WaitConditionHandle.get_status().AndReturn([])
scheduler.TaskRunner._sleep(mox.IsA(int)).AndReturn(None)
wc.WaitConditionHandle.get_status().AndReturn([])
scheduler.TaskRunner._sleep(mox.IsA(int)).AndReturn(None)
wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS'])
self.m.ReplayAll()
self.stack.create()
rsrc = self.stack.resources['WaitForTheHandle']
self.assertEqual(rsrc.state,
'CREATE_COMPLETE')
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.id)
self.assertEqual(r.name, 'WaitHandle')
self.m.VerifyAll()
def test_post_complete_to_handle(self):
self.stack = self.create_stack()
wc.HeatWaitConditionHandle.get_status().AndReturn(['SUCCESS'])
wc.HeatWaitConditionHandle.get_status().AndReturn(['SUCCESS',
'SUCCESS'])
wc.HeatWaitConditionHandle.get_status().AndReturn(['SUCCESS',
'SUCCESS',
'SUCCESS'])
self.m.ReplayAll()
self.stack.create()
rsrc = self.stack['wait_condition']
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE),
rsrc.state)
r = db_api.resource_get_by_name_and_stack(None, 'wait_handle',
self.stack.id)
self.assertEqual('wait_handle', r.name)
self.m.VerifyAll()
def test_post_failure_to_handle(self):
self.stack = self.create_stack()
wc.WaitConditionHandle.get_status().AndReturn([])
scheduler.TaskRunner._sleep(mox.IsA(int)).AndReturn(None)
wc.WaitConditionHandle.get_status().AndReturn([])
scheduler.TaskRunner._sleep(mox.IsA(int)).AndReturn(None)
wc.WaitConditionHandle.get_status().AndReturn(['FAILURE'])
self.m.ReplayAll()
self.stack.create()
rsrc = self.stack.resources['WaitForTheHandle']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.FAILED))
reason = rsrc.status_reason
self.assertTrue(reason.startswith('WaitConditionFailure:'))
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.id)
self.assertEqual(r.name, 'WaitHandle')
self.m.VerifyAll()
def test_post_failure_to_handle_count(self):
self.stack = self.create_stack(template=test_template_wc_count)
wc.WaitConditionHandle.get_status().AndReturn([])
eventlet.sleep(1).AndReturn(None)
wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS'])
eventlet.sleep(1).AndReturn(None)
wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS', 'FAILURE'])
self.m.ReplayAll()
self.stack.create()
resource = self.stack.resources['WaitForTheHandle']
self.assertEqual(resource.state, resource.CREATE_FAILED)
reason = resource.state_description
self.assertTrue(reason.startswith('WaitConditionFailure:'))
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.id)
self.assertEqual(r.name, 'WaitHandle')
self.m.VerifyAll()
def test_post_failure_to_handle(self):
self.stack = self.create_stack()
wc.WaitConditionHandle.get_status().AndReturn([])
eventlet.sleep(1).AndReturn(None)
wc.WaitConditionHandle.get_status().AndReturn([])
eventlet.sleep(1).AndReturn(None)
wc.WaitConditionHandle.get_status().AndReturn(['FAILURE'])
self.m.ReplayAll()
self.stack.create()
resource = self.stack.resources['WaitForTheHandle']
self.assertEqual(resource.state, resource.CREATE_FAILED)
reason = resource.state_description
self.assertTrue(reason.startswith('WaitConditionFailure:'))
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.id)
self.assertEqual(r.name, 'WaitHandle')
self.m.VerifyAll()
def test_post_failed_to_handle(self):
self.stack = self.create_stack()
heat_wch.HeatWaitConditionHandle.get_status().AndReturn(['SUCCESS'])
heat_wch.HeatWaitConditionHandle.get_status().AndReturn(
['SUCCESS', 'SUCCESS'])
heat_wch.HeatWaitConditionHandle.get_status().AndReturn(
['SUCCESS', 'SUCCESS', 'FAILURE'])
self.m.ReplayAll()
self.stack.create()
rsrc = self.stack['wait_condition']
self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state)
reason = rsrc.status_reason
self.assertTrue(reason.startswith('WaitConditionFailure:'))
r = db_api.resource_get_by_name_and_stack(None, 'wait_handle',
self.stack.id)
self.assertEqual('wait_handle', r.name)
self.m.VerifyAll()
def __init__(self, name, json_snippet, stack):
self.references = []
self.stack = stack
self.context = stack.context
self.name = name
self.t = stack.resolve_static_data(json_snippet)
self.properties = checkeddict.Properties(name, self.properties_schema)
resource = db_api.resource_get_by_name_and_stack(self.context,
name, stack.id)
if resource:
self.instance_id = resource.nova_instance
self.state = resource.state
self.state_description = resource.state_description
self.id = resource.id
else:
self.instance_id = None
self.state = None
self.state_description = ''
self.id = None
self._nova = {}
self._keystone = None
def __init__(self, name, json_snippet, stack):
self.references = []
self.stack = stack
self.context = stack.context
self.name = name
self.t = stack.resolve_static_data(json_snippet)
self.properties = checkeddict.Properties(name, self.properties_schema)
resource = db_api.resource_get_by_name_and_stack(
self.context, name, stack.id)
if resource:
self.instance_id = resource.nova_instance
self.state = resource.state
self.state_description = resource.state_description
self.id = resource.id
else:
self.instance_id = None
self.state = None
self.state_description = ''
self.id = None
self._nova = {}
self._keystone = None
self._swift = None
def test_post_success_to_handle_count(self):
self.stack = self.create_stack(template=test_template_wc_count)
wc.WaitConditionHandle.get_status().AndReturn([])
eventlet.sleep(1).AndReturn(None)
wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS'])
eventlet.sleep(1).AndReturn(None)
wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS', 'SUCCESS'])
eventlet.sleep(1).AndReturn(None)
wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS', 'SUCCESS',
'SUCCESS'])
self.m.ReplayAll()
self.stack.create()
resource = self.stack.resources['WaitForTheHandle']
self.assertEqual(resource.state,
'CREATE_COMPLETE')
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.id)
self.assertEqual(r.name, 'WaitHandle')
self.m.VerifyAll()
def __init__(self, name, json_snippet, stack):
self.t = json_snippet
self.depends_on = []
self.references = []
self.stack = stack
self.name = name
resource = db_api.resource_get_by_name_and_stack(None, name, stack.id)
if resource:
self.instance_id = resource.nova_instance
self.state = resource.state
self.id = resource.id
else:
self.instance_id = None
self.state = None
self.id = None
self._nova = {}
if not 'Properties' in self.t:
# make a dummy entry to prevent having to check all over the
# place for it.
self.t['Properties'] = {}
stack.resolve_static_refs(self.t)
stack.resolve_find_in_map(self.t)
def __init__(self, name, json_snippet, stack):
if '/' in name:
raise ValueError(_('Resource name may not contain "/"'))
self.stack = stack
self.context = stack.context
self.name = name
self.json_snippet = json_snippet
self.reparse()
self.attributes = Attributes(self.name,
self.attributes_schema,
self._resolve_attribute)
if stack.id:
resource = db_api.resource_get_by_name_and_stack(self.context,
name, stack.id)
else:
resource = None
if resource:
self.resource_id = resource.nova_instance
self.action = resource.action
self.status = resource.status
self.status_reason = resource.status_reason
self.id = resource.id
self.data = resource.data
else:
self.resource_id = None
# if the stack is being deleted, assume we've already been deleted
if stack.action == stack.DELETE:
self.action = self.DELETE
else:
self.action = self.INIT
self.status = self.COMPLETE
self.status_reason = ''
self.id = None
self.data = []
def event_create(self, context, event):
stack_name = event["stack"]
resource_name = event["resource"]
stack = db_api.stack_get(None, stack_name)
resource = db_api.resource_get_by_name_and_stack(None, resource_name, stack.id)
if not resource:
return ["Unknown resource", None]
new_event = {
"name": event["message"],
"resource_status_reason": event["reason"],
"stack_id": stack.id,
"logical_resource_id": resource.name,
"physical_resource_id": None,
"resource_type": event["resource_type"],
"resource_properties": {},
}
try:
result = db_api.event_create(None, new_event)
new_event["id"] = result.id
return [None, new_event]
except Exception as ex:
logger.warn("db error %s" % str(ex))
msg = "Error creating event"
return [msg, None]
def get_by_name_and_stack(cls, context, resource_name, stack_id):
resource_db = db_api.resource_get_by_name_and_stack(
context, resource_name, stack_id)
return cls._from_db_object(cls(context), context, resource_db)
def load(cls, context, res_name, stack):
resource = db_api.resource_get_by_name_and_stack(context, res_name, stack.id)
return cls._from_db(resource)
