def test_disable_rollback_extract_false(self):
args = api.extract_args({"disable_rollback": False})
self.assertIn("disable_rollback", args)
self.assertFalse(args.get("disable_rollback"))
args = api.extract_args({"disable_rollback": "False"})
self.assertIn("disable_rollback", args)
self.assertFalse(args.get("disable_rollback"))
args = api.extract_args({"disable_rollback": "false"})
self.assertIn("disable_rollback", args)
self.assertFalse(args.get("disable_rollback"))
def test_disable_rollback_extract_true(self):
args = api.extract_args({'disable_rollback': True})
self.assertIn('disable_rollback', args)
self.assertTrue(args.get('disable_rollback'))
args = api.extract_args({'disable_rollback': 'True'})
self.assertIn('disable_rollback', args)
self.assertTrue(args.get('disable_rollback'))
args = api.extract_args({'disable_rollback': 'true'})
self.assertIn('disable_rollback', args)
self.assertTrue(args.get('disable_rollback'))
def test_disable_rollback_extract_true(self):
args = api.extract_args({"disable_rollback": True})
self.assertIn("disable_rollback", args)
self.assertTrue(args.get("disable_rollback"))
args = api.extract_args({"disable_rollback": "True"})
self.assertIn("disable_rollback", args)
self.assertTrue(args.get("disable_rollback"))
args = api.extract_args({"disable_rollback": "true"})
self.assertIn("disable_rollback", args)
self.assertTrue(args.get("disable_rollback"))
def test_disable_rollback_extract_false(self):
args = api.extract_args({'disable_rollback': False})
self.assertIn('disable_rollback', args)
self.assertFalse(args.get('disable_rollback'))
args = api.extract_args({'disable_rollback': 'False'})
self.assertIn('disable_rollback', args)
self.assertFalse(args.get('disable_rollback'))
args = api.extract_args({'disable_rollback': 'false'})
self.assertIn('disable_rollback', args)
self.assertFalse(args.get('disable_rollback'))
def test_disable_rollback_extract_true(self):
args = api.extract_args({'disable_rollback': True})
self.assertIn('disable_rollback', args)
self.assertTrue(args.get('disable_rollback'))
args = api.extract_args({'disable_rollback': 'True'})
self.assertIn('disable_rollback', args)
self.assertTrue(args.get('disable_rollback'))
args = api.extract_args({'disable_rollback': 'true'})
self.assertIn('disable_rollback', args)
self.assertTrue(args.get('disable_rollback'))
def test_disable_rollback_extract_false(self):
args = api.extract_args({'disable_rollback': False})
self.assertIn('disable_rollback', args)
self.assertFalse(args.get('disable_rollback'))
args = api.extract_args({'disable_rollback': 'False'})
self.assertIn('disable_rollback', args)
self.assertFalse(args.get('disable_rollback'))
args = api.extract_args({'disable_rollback': 'false'})
self.assertIn('disable_rollback', args)
self.assertFalse(args.get('disable_rollback'))
def update_stack(self, cnxt, stack_identity, template, params, args):
"""
The update_stack method updates an existing stack based on the
provided template and parameters.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
arg1 -> RPC context.
arg2 -> Name of the stack you want to create.
arg3 -> Template of stack you want to create.
arg4 -> Stack Input Params
arg4 -> Request parameters/args passed from API
"""
logger.info('template is %s' % template)
# Get the database representation of the existing stack
db_stack = self._get_stack(cnxt, stack_identity)
current_stack = parser.Stack.load(cnxt, stack=db_stack)
# Now parse the template and any parameters for the updated
# stack definition.
tmpl = parser.Template(template)
stack_name = current_stack.name
template_params = parser.Parameters(stack_name, tmpl, params)
common_params = api.extract_args(args)
updated_stack = parser.Stack(cnxt, stack_name, tmpl, template_params,
**common_params)
updated_stack.validate()
self._start_in_thread(db_stack.id, current_stack.update, updated_stack)
return dict(current_stack.identifier())
def create_stack(self, context, stack_name, template, params, args):
"""
The create_stack method creates a new stack using the template
provided.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
arg1 -> RPC context.
arg2 -> Name of the stack you want to create.
arg3 -> Template of stack you want to create.
arg4 -> Stack Input Params
arg4 -> Request parameters/args passed from API
"""
logger.info('template is %s' % template)
if db_api.stack_get_by_name(None, stack_name):
raise AttributeError('Stack already exists with that name')
tmpl = parser.Template(template)
# Extract the template parameters, and any common query parameters
template_params = parser.Parameters(stack_name, tmpl, params)
common_params = api.extract_args(args)
stack = parser.Stack(context, stack_name, tmpl, template_params,
**common_params)
response = stack.validate()
if response['Description'] != 'Successfully validated':
return response
stack_id = stack.store()
greenpool.spawn_n(stack.create)
return dict(stack.identifier())
def preview_stack(self, cnxt, stack_name, template, params, files, args):
"""
Simulates a new stack using the provided template.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
:param cnxt: RPC context.
:param stack_name: Name of the stack you want to create.
:param template: Template of stack you want to create.
:param params: Stack Input Params
:param files: Files referenced from the template
:param args: Request parameters/args passed from API
"""
LOG.info(_('previewing stack %s') % stack_name)
tmpl = parser.Template(template, files=files)
self._validate_new_stack(cnxt, stack_name, tmpl)
common_params = api.extract_args(args)
env = environment.Environment(params)
stack = parser.Stack(cnxt, stack_name, tmpl, env, **common_params)
self._validate_deferred_auth_context(cnxt, stack)
stack.validate()
return api.format_stack_preview(stack)
def preview_stack(self, cnxt, stack_name, template, params, files, args):
"""
Simulates a new stack using the provided template.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
:param cnxt: RPC context.
:param stack_name: Name of the stack you want to create.
:param template: Template of stack you want to create.
:param params: Stack Input Params
:param files: Files referenced from the template
:param args: Request parameters/args passed from API
"""
LOG.info(_('previewing stack %s') % stack_name)
tmpl = parser.Template(template, files=files)
self._validate_new_stack(cnxt, stack_name, tmpl)
common_params = api.extract_args(args)
env = environment.Environment(params)
stack = parser.Stack(cnxt, stack_name, tmpl, env, **common_params)
self._validate_deferred_auth_context(cnxt, stack)
stack.validate()
return api.format_stack_preview(stack)
def update_stack(self, cnxt, stack_identity, template, params, args):
"""
The update_stack method updates an existing stack based on the
provided template and parameters.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
arg1 -> RPC context.
arg2 -> Name of the stack you want to create.
arg3 -> Template of stack you want to create.
arg4 -> Stack Input Params
arg4 -> Request parameters/args passed from API
"""
logger.info('template is %s' % template)
# Get the database representation of the existing stack
db_stack = self._get_stack(cnxt, stack_identity)
current_stack = parser.Stack.load(cnxt, stack=db_stack)
# Now parse the template and any parameters for the updated
# stack definition.
tmpl = parser.Template(template)
stack_name = current_stack.name
template_params = parser.Parameters(stack_name, tmpl, params)
common_params = api.extract_args(args)
updated_stack = parser.Stack(cnxt, stack_name, tmpl,
template_params, **common_params)
updated_stack.validate()
self._start_in_thread(db_stack.id, current_stack.update, updated_stack)
return dict(current_stack.identifier())
def create_stack(self, cnxt, stack_name, template, params, files, args):
"""
The create_stack method creates a new stack using the template
provided.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
:param cnxt: RPC context.
:param stack_name: Name of the stack you want to create.
:param template: Template of stack you want to create.
:param params: Stack Input Params
:param files: Files referenced from the template
(currently provider templates).
:param args: Request parameters/args passed from API
"""
logger.info('template is %s' % template)
def _stack_create(stack):
# Create the stack, and create the periodic task if successful
stack.create()
if stack.action == stack.CREATE and stack.status == stack.COMPLETE:
# Schedule a periodic watcher task for this stack
self._start_watch_task(stack.id, cnxt)
else:
logger.warning("Stack create failed, status %s" % stack.status)
if db_api.stack_get_by_name(cnxt, stack_name):
raise exception.StackExists(stack_name=stack_name)
tenant_limit = cfg.CONF.max_stacks_per_tenant
if db_api.stack_count_all_by_tenant(cnxt) >= tenant_limit:
message = _("You have reached the maximum stacks per tenant, %d."
" Please delete some stacks.") % tenant_limit
raise exception.RequestLimitExceeded(message=message)
tmpl = parser.Template(template, files=files)
if len(tmpl[tpl.RESOURCES]) > cfg.CONF.max_resources_per_stack:
raise exception.StackResourceLimitExceeded()
# Extract the common query parameters
common_params = api.extract_args(args)
env = environment.Environment(params)
stack = parser.Stack(cnxt, stack_name, tmpl,
env, **common_params)
self._validate_deferred_auth_context(cnxt, stack)
stack.validate()
# Creates a trust and sets the trust_id and trustor_user_id in
# the current context, before we store it in stack.store()
# Does nothing if deferred_auth_method is 'password'
stack.clients.keystone().create_trust_context()
stack_id = stack.store()
self._start_in_thread(stack_id, _stack_create, stack)
return dict(stack.identifier())
def update_stack(self, cnxt, stack_identity, template, params, files,
args):
"""
The update_stack method updates an existing stack based on the
provided template and parameters.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
:param cnxt: RPC context.
:param stack_identity: Name of the stack you want to create.
:param template: Template of stack you want to create.
:param params: Stack Input Params
:param files: Files referenced from the template
:param args: Request parameters/args passed from API
"""
LOG.info(_('template is %s') % template)
# Get the database representation of the existing stack
db_stack = self._get_stack(cnxt, stack_identity)
current_stack = parser.Stack.load(cnxt, stack=db_stack)
if current_stack.action == current_stack.SUSPEND:
msg = _('Updating a stack when it is suspended')
raise exception.NotSupported(feature=msg)
if current_stack.status == current_stack.IN_PROGRESS:
msg = _('Updating a stack when another action is in progress')
raise exception.NotSupported(feature=msg)
# Now parse the template and any parameters for the updated
# stack definition.
tmpl = parser.Template(template, files=files)
if len(tmpl[tmpl.RESOURCES]) > cfg.CONF.max_resources_per_stack:
raise exception.RequestLimitExceeded(
message=exception.StackResourceLimitExceeded.msg_fmt)
stack_name = current_stack.name
common_params = api.extract_args(args)
common_params.setdefault(rpc_api.PARAM_TIMEOUT,
current_stack.timeout_mins)
env = environment.Environment(params)
updated_stack = parser.Stack(cnxt, stack_name, tmpl, env,
**common_params)
updated_stack.parameters.set_stack_id(current_stack.identifier())
self._validate_deferred_auth_context(cnxt, updated_stack)
updated_stack.validate()
self.thread_group_mgr.start_with_lock(cnxt, current_stack,
self.engine_id,
current_stack.update,
updated_stack)
return dict(current_stack.identifier())
def create_stack(self, cnxt, stack_name, template, params, files, args):
"""
The create_stack method creates a new stack using the template
provided.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
:param cnxt: RPC context.
:param stack_name: Name of the stack you want to create.
:param template: Template of stack you want to create.
:param params: Stack Input Params
:param files: Files referenced from the template
:param args: Request parameters/args passed from API
"""
logger.info(_('template is %s') % template)
def _stack_create(stack):
# Create the stack, and create the periodic task if successful
stack.create()
if stack.action == stack.CREATE and stack.status == stack.COMPLETE:
# Schedule a periodic watcher task for this stack
self._start_watch_task(stack.id, cnxt)
else:
logger.warning(
_("Stack create failed, status %s") % stack.status)
if db_api.stack_get_by_name(cnxt, stack_name):
raise exception.StackExists(stack_name=stack_name)
tenant_limit = cfg.CONF.max_stacks_per_tenant
if db_api.stack_count_all_by_tenant(cnxt) >= tenant_limit:
message = _("You have reached the maximum stacks per tenant, %d."
" Please delete some stacks.") % tenant_limit
raise exception.RequestLimitExceeded(message=message)
tmpl = parser.Template(template, files=files)
if len(tmpl[tpl.RESOURCES]) > cfg.CONF.max_resources_per_stack:
raise exception.RequestLimitExceeded(
message=exception.StackResourceLimitExceeded.msg_fmt)
# Extract the common query parameters
common_params = api.extract_args(args)
env = environment.Environment(params)
stack = parser.Stack(cnxt, stack_name, tmpl, env, **common_params)
self._validate_deferred_auth_context(cnxt, stack)
stack.validate()
stack_id = stack.store()
self._start_in_thread(stack_id, _stack_create, stack)
return dict(stack.identifier())
def update_stack(self, cnxt, stack_identity, template, params,
files, args):
"""
The update_stack method updates an existing stack based on the
provided template and parameters.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
:param cnxt: RPC context.
:param stack_identity: Name of the stack you want to create.
:param template: Template of stack you want to create.
:param params: Stack Input Params
:param files: Files referenced from the template
:param args: Request parameters/args passed from API
"""
logger.info(_('template is %s') % template)
# Get the database representation of the existing stack
db_stack = self._get_stack(cnxt, stack_identity)
current_stack = parser.Stack.load(cnxt, stack=db_stack)
if current_stack.action == current_stack.SUSPEND:
msg = _('Updating a stack when it is suspended')
raise exception.NotSupported(feature=msg)
if current_stack.status == current_stack.IN_PROGRESS:
msg = _('Updating a stack when another action is in progress')
raise exception.NotSupported(feature=msg)
# Now parse the template and any parameters for the updated
# stack definition.
tmpl = parser.Template(template, files=files)
if len(tmpl[tmpl.RESOURCES]) > cfg.CONF.max_resources_per_stack:
raise exception.RequestLimitExceeded(
message=exception.StackResourceLimitExceeded.msg_fmt)
stack_name = current_stack.name
common_params = api.extract_args(args)
common_params.setdefault(rpc_api.PARAM_TIMEOUT,
current_stack.timeout_mins)
env = environment.Environment(params)
updated_stack = parser.Stack(cnxt, stack_name, tmpl,
env, **common_params)
updated_stack.parameters.set_stack_id(current_stack.identifier())
self._validate_deferred_auth_context(cnxt, updated_stack)
updated_stack.validate()
self.thread_group_mgr.start_with_lock(cnxt, current_stack,
self.engine_id,
current_stack.update,
updated_stack)
return dict(current_stack.identifier())
def _parse_template_and_validate_stack(self, cnxt, stack_name, template,
params, files, args):
tmpl = parser.Template(template, files=files)
self._validate_new_stack(cnxt, stack_name, tmpl)
common_params = api.extract_args(args)
env = environment.Environment(params)
stack = parser.Stack(cnxt, stack_name, tmpl, env, **common_params)
self._validate_deferred_auth_context(cnxt, stack)
stack.validate()
return stack
def _parse_template_and_validate_stack(self, cnxt, stack_name, template,
params, files, args):
tmpl = parser.Template(template, files=files)
self._validate_new_stack(cnxt, stack_name, tmpl)
common_params = api.extract_args(args)
env = environment.Environment(params)
stack = parser.Stack(cnxt, stack_name, tmpl, env, **common_params)
self._validate_deferred_auth_context(cnxt, stack)
stack.validate()
return stack
def create_stack(self, cnxt, stack_name, template, params, files, args):
"""
The create_stack method creates a new stack using the template
provided.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
:param cnxt: RPC context.
:param stack_name: Name of the stack you want to create.
:param template: Template of stack you want to create.
:param params: Stack Input Params
:param files: Files referenced from the template
:param args: Request parameters/args passed from API
"""
logger.info(_('template is %s') % template)
def _stack_create(stack):
# Create/Adopt a stack, and create the periodic task if successful
if stack.adopt_stack_data:
stack.adopt()
else:
stack.create()
if (stack.action in (stack.CREATE, stack.ADOPT)
and stack.status == stack.COMPLETE):
# Schedule a periodic watcher task for this stack
self.stack_watch.start_watch_task(stack.id, cnxt)
else:
logger.warning(_("Stack create failed, status %s") %
stack.status)
tmpl = parser.Template(template, files=files)
self._validate_new_stack(cnxt, stack_name, tmpl)
# Extract the common query parameters
common_params = api.extract_args(args)
env = environment.Environment(params)
stack = parser.Stack(cnxt, stack_name, tmpl,
env, **common_params)
self._validate_deferred_auth_context(cnxt, stack)
stack.validate()
stack.store()
self.thread_group_mgr.start_with_lock(cnxt, stack, self.engine_id,
_stack_create, stack)
return dict(stack.identifier())
def create_stack(self, cnxt, stack_name, template, params, files, args):
"""
The create_stack method creates a new stack using the template
provided.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
:param cnxt: RPC context.
:param stack_name: Name of the stack you want to create.
:param template: Template of stack you want to create.
:param params: Stack Input Params
:param files: Files referenced from the template
:param args: Request parameters/args passed from API
"""
logger.info(_('template is %s') % template)
def _stack_create(stack):
# Create/Adopt a stack, and create the periodic task if successful
if stack.adopt_stack_data:
stack.adopt()
else:
stack.create()
if (stack.action in (stack.CREATE, stack.ADOPT)
and stack.status == stack.COMPLETE):
# Schedule a periodic watcher task for this stack
self.stack_watch.start_watch_task(stack.id, cnxt)
else:
logger.warning(_("Stack create failed, status %s") %
stack.status)
tmpl = parser.Template(template, files=files)
self._validate_new_stack(cnxt, stack_name, tmpl)
# Extract the common query parameters
common_params = api.extract_args(args)
env = environment.Environment(params)
stack = parser.Stack(cnxt, stack_name, tmpl,
env, **common_params)
self._validate_deferred_auth_context(cnxt, stack)
stack.validate()
stack.store()
self.thread_group_mgr.start_with_lock(cnxt, stack, self.engine_id,
_stack_create, stack)
return dict(stack.identifier())
def create_stack(self, cnxt, stack_name, template, params, files, args):
"""
The create_stack method creates a new stack using the template
provided.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
:param cnxt: RPC context.
:param stack_name: Name of the stack you want to create.
:param template: Template of stack you want to create.
:param params: Stack Input Params
:param files: Files referenced from the template
(currently provider templates).
:param args: Request parameters/args passed from API
"""
logger.info('template is %s' % template)
self._validate_mandatory_credentials(cnxt)
def _stack_create(stack):
# Create the stack, and create the periodic task if successful
stack.create()
if stack.action == stack.CREATE and stack.status == stack.COMPLETE:
# Schedule a periodic watcher task for this stack
self._timer_in_thread(stack.id, self._periodic_watcher_task,
sid=stack.id)
else:
logger.warning("Stack create failed, status %s" % stack.status)
if db_api.stack_get_by_name(cnxt, stack_name):
raise exception.StackExists(stack_name=stack_name)
tmpl = parser.Template(template, files=files)
# Extract the common query parameters
common_params = api.extract_args(args)
env = environment.Environment(params)
stack = parser.Stack(cnxt, stack_name, tmpl,
env, **common_params)
stack.validate()
stack_id = stack.store()
self._start_in_thread(stack_id, _stack_create, stack)
return dict(stack.identifier())
def update_stack(self, cnxt, stack_identity, template, params, files,
args):
"""
The update_stack method updates an existing stack based on the
provided template and parameters.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
arg1 -> RPC context.
arg2 -> Name of the stack you want to create.
arg3 -> Template of stack you want to create.
arg4 -> Stack Input Params
arg4 -> Request parameters/args passed from API
"""
logger.info('template is %s' % template)
# Get the database representation of the existing stack
db_stack = self._get_stack(cnxt, stack_identity)
current_stack = parser.Stack.load(cnxt, stack=db_stack)
if current_stack.action == current_stack.SUSPEND:
msg = _('Updating a stack when it is suspended')
raise exception.NotSupported(feature=msg)
if current_stack.status == current_stack.IN_PROGRESS:
msg = _('Updating a stack when another action is in progress')
raise exception.NotSupported(feature=msg)
# Now parse the template and any parameters for the updated
# stack definition.
tmpl = parser.Template(template, files=files)
if len(tmpl[tpl.RESOURCES]) > cfg.CONF.max_resources_per_stack:
raise exception.RequestLimitExceeded(
message=exception.StackResourceLimitExceeded.msg_fmt)
stack_name = current_stack.name
common_params = api.extract_args(args)
env = environment.Environment(params)
updated_stack = parser.Stack(cnxt, stack_name, tmpl, env,
**common_params)
self._validate_deferred_auth_context(cnxt, updated_stack)
updated_stack.validate()
self._start_in_thread(db_stack.id, current_stack.update, updated_stack)
return dict(current_stack.identifier())
def create_stack(self, context, stack_name, template, params, args):
"""
The create_stack method creates a new stack using the template
provided.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
arg1 -> RPC context.
arg2 -> Name of the stack you want to create.
arg3 -> Template of stack you want to create.
arg4 -> Stack Input Params
arg4 -> Request parameters/args passed from API
"""
logger.info('template is %s' % template)
def _stack_create(stack):
# Create the stack, and create the periodic task if successful
stack.create()
if stack.state == stack.CREATE_COMPLETE:
# Schedule a periodic watcher task for this stack
self._timer_in_thread(stack.id, self._periodic_watcher_task,
sid=stack.id)
else:
logger.warning("Stack create failed, state %s" % stack.state)
if db_api.stack_get_by_name(context, stack_name):
raise exception.StackExists(stack_name=stack_name)
tmpl = parser.Template(template)
# Extract the template parameters, and any common query parameters
template_params = parser.Parameters(stack_name, tmpl, params)
common_params = api.extract_args(args)
stack = parser.Stack(context, stack_name, tmpl, template_params,
**common_params)
response = stack.validate()
if response:
return {'Description': response}
stack_id = stack.store()
self._start_in_thread(stack_id, _stack_create, stack)
return dict(stack.identifier())
def create_stack(self, cnxt, stack_name, template, params, args):
"""
The create_stack method creates a new stack using the template
provided.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
arg1 -> RPC context.
arg2 -> Name of the stack you want to create.
arg3 -> Template of stack you want to create.
arg4 -> Stack Input Params
arg4 -> Request parameters/args passed from API
"""
logger.info('template is %s' % template)
def _stack_create(stack):
# Create the stack, and create the periodic task if successful
stack.create()
if stack.state == stack.CREATE_COMPLETE:
# Schedule a periodic watcher task for this stack
self._timer_in_thread(stack.id,
self._periodic_watcher_task,
sid=stack.id)
else:
logger.warning("Stack create failed, state %s" % stack.state)
if db_api.stack_get_by_name(cnxt, stack_name):
raise exception.StackExists(stack_name=stack_name)
tmpl = parser.Template(template)
# Extract the template parameters, and any common query parameters
template_params = parser.Parameters(stack_name, tmpl, params)
common_params = api.extract_args(args)
stack = parser.Stack(cnxt, stack_name, tmpl, template_params,
**common_params)
stack.validate()
stack_id = stack.store()
self._start_in_thread(stack_id, _stack_create, stack)
return dict(stack.identifier())
def create_stack(self, cnxt, stack_name, template, params, files, args):
"""
The create_stack method creates a new stack using the template
provided.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
:param cnxt: RPC context.
:param stack_name: Name of the stack you want to create.
:param template: Template of stack you want to create.
:param params: Stack Input Params
:param files: Files referenced from the template
(currently provider templates).
:param args: Request parameters/args passed from API
"""
logger.info('template is %s' % template)
self._validate_mandatory_credentials(cnxt)
def _stack_create(stack):
# Create the stack, and create the periodic task if successful
stack.create()
if stack.action == stack.CREATE and stack.status == stack.COMPLETE:
# Schedule a periodic watcher task for this stack
self._start_watch_task(stack.id, cnxt)
else:
logger.warning("Stack create failed, status %s" % stack.status)
if db_api.stack_get_by_name(cnxt, stack_name):
raise exception.StackExists(stack_name=stack_name)
tmpl = parser.Template(template, files=files)
# Extract the common query parameters
common_params = api.extract_args(args)
env = environment.Environment(params)
stack = parser.Stack(cnxt, stack_name, tmpl, env, **common_params)
stack.validate()
stack_id = stack.store()
self._start_in_thread(stack_id, _stack_create, stack)
return dict(stack.identifier())
def update_stack(self, cnxt, stack_identity, template, params, files, args):
"""
The update_stack method updates an existing stack based on the
provided template and parameters.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
arg1 -> RPC context.
arg2 -> Name of the stack you want to create.
arg3 -> Template of stack you want to create.
arg4 -> Stack Input Params
arg4 -> Request parameters/args passed from API
"""
logger.info("template is %s" % template)
# Get the database representation of the existing stack
db_stack = self._get_stack(cnxt, stack_identity)
current_stack = parser.Stack.load(cnxt, stack=db_stack)
if current_stack.action == current_stack.SUSPEND:
msg = _("Updating a stack when it is suspended")
raise exception.NotSupported(feature=msg)
if current_stack.status == current_stack.IN_PROGRESS:
msg = _("Updating a stack when another action is in progress")
raise exception.NotSupported(feature=msg)
# Now parse the template and any parameters for the updated
# stack definition.
tmpl = parser.Template(template, files=files)
if len(tmpl[tpl.RESOURCES]) > cfg.CONF.max_resources_per_stack:
raise exception.RequestLimitExceeded(message=exception.StackResourceLimitExceeded.message)
stack_name = current_stack.name
common_params = api.extract_args(args)
env = environment.Environment(params)
updated_stack = parser.Stack(cnxt, stack_name, tmpl, env, **common_params)
self._validate_deferred_auth_context(cnxt, updated_stack)
updated_stack.validate()
self._start_in_thread(db_stack.id, current_stack.update, updated_stack)
return dict(current_stack.identifier())
def create_stack(self, context, stack_name, template, params, args):
"""
The create_stack method creates a new stack using the template
provided.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
arg1 -> RPC context.
arg2 -> Name of the stack you want to create.
arg3 -> Template of stack you want to create.
arg4 -> Stack Input Params
arg4 -> Request parameters/args passed from API
"""
logger.info('template is %s' % template)
if db_api.stack_get_by_name(context, stack_name):
raise AttributeError('Stack already exists with that name')
tmpl = parser.Template(template)
# Extract the template parameters, and any common query parameters
template_params = parser.Parameters(stack_name, tmpl, params)
common_params = api.extract_args(args)
stack = parser.Stack(context, stack_name, tmpl, template_params,
**common_params)
response = stack.validate()
if response:
return {'Description': response}
stack_id = stack.store()
self._start_in_thread(stack_id, stack_name, stack.create)
# Schedule a periodic watcher task for this stack
self._timer_in_thread(stack_id,
stack_name,
self._periodic_watcher_task,
sid=stack_id)
return dict(stack.identifier())
def update_stack(self, context, stack_identity, template, params, args):
"""
The update_stack method updates an existing stack based on the
provided template and parameters.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
arg1 -> RPC context.
arg2 -> Name of the stack you want to create.
arg3 -> Template of stack you want to create.
arg4 -> Stack Input Params
arg4 -> Request parameters/args passed from API
"""
logger.info('template is %s' % template)
# Get the database representation of the existing stack
db_stack = self._get_stack(context, stack_identity)
current_stack = parser.Stack.load(context, db_stack.id)
# Now parse the template and any parameters for the updated
# stack definition.
tmpl = parser.Template(template)
stack_name = current_stack.name
template_params = parser.Parameters(stack_name, tmpl, params)
common_params = api.extract_args(args)
updated_stack = parser.Stack(context, stack_name, tmpl,
template_params, **common_params)
response = updated_stack.validate()
if response['Description'] != 'Successfully validated':
return response
# Spawn a greenthread to do the update, and register a
# callback to remove the thread from stack_threads when done
gt = greenpool.spawn(current_stack.update, updated_stack)
gt.link(self._gt_done_callback, stack_id=db_stack.id)
self.stack_threads[db_stack.id].add(gt)
return dict(current_stack.identifier())
def update_stack(self, context, stack_identity, template, params, args):
"""
The update_stack method updates an existing stack based on the
provided template and parameters.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
arg1 -> RPC context.
arg2 -> Name of the stack you want to create.
arg3 -> Template of stack you want to create.
arg4 -> Stack Input Params
arg4 -> Request parameters/args passed from API
"""
logger.info('template is %s' % template)
# Get the database representation of the existing stack
db_stack = self._get_stack(context, stack_identity)
current_stack = parser.Stack.load(context, db_stack.id)
# Now parse the template and any parameters for the updated
# stack definition.
tmpl = parser.Template(template)
stack_name = current_stack.name
template_params = parser.Parameters(stack_name, tmpl, params)
common_params = api.extract_args(args)
updated_stack = parser.Stack(context, stack_name, tmpl,
template_params, **common_params)
response = updated_stack.validate()
if response['Description'] != 'Successfully validated':
return response
# Spawn a greenthread to do the update, and register a
# callback to remove the thread from stack_threads when done
gt = greenpool.spawn(current_stack.update, updated_stack)
gt.link(self._gt_done_callback, stack_id=db_stack.id)
self.stack_threads[db_stack.id].add(gt)
return dict(current_stack.identifier())
def create_stack(self, context, stack_name, template, params, args):
"""
The create_stack method creates a new stack using the template
provided.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
arg1 -> RPC context.
arg2 -> Name of the stack you want to create.
arg3 -> Template of stack you want to create.
arg4 -> Stack Input Params
arg4 -> Request parameters/args passed from API
"""
logger.info('template is %s' % template)
if db_api.stack_get_by_name(None, stack_name):
raise AttributeError('Stack already exists with that name')
tmpl = parser.Template(template)
# Extract the template parameters, and any common query parameters
template_params = parser.Parameters(stack_name, tmpl, params)
common_params = api.extract_args(args)
stack = parser.Stack(context, stack_name, tmpl, template_params,
**common_params)
response = stack.validate()
if response['Description'] != 'Successfully validated':
return response
stack_id = stack.store()
# Spawn a greenthread to do the create, and register a
# callback to remove the thread from stack_threads when done
gt = greenpool.spawn(stack.create)
gt.link(self._gt_done_callback, stack_id=stack_id)
self.stack_threads[stack_id].add(gt)
return dict(stack.identifier())
def update_stack(self, context, stack_name, template, params, args):
"""
The update_stack method updates an existing stack based on the
provided template and parameters.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
arg1 -> RPC context.
arg2 -> Name of the stack you want to create.
arg3 -> Template of stack you want to create.
arg4 -> Stack Input Params
arg4 -> Request parameters/args passed from API
"""
logger.info('template is %s' % template)
auth.authenticate(context)
# Get the database representation of the existing stack
db_stack = db_api.stack_get_by_name(None, stack_name)
if not db_stack:
raise AttributeError('No stack exists with that name')
current_stack = parser.Stack.load(context, db_stack.id)
# Now parse the template and any parameters for the updated
# stack definition.
tmpl = parser.Template(template)
template_params = parser.Parameters(stack_name, tmpl, params)
common_params = api.extract_args(args)
updated_stack = parser.Stack(context, stack_name, tmpl,
template_params, **common_params)
response = updated_stack.validate()
if response['Description'] != 'Successfully validated':
return response
greenpool.spawn_n(current_stack.update, updated_stack)
return {'StackName': current_stack.name, 'StackId': current_stack.id}
def update_stack(self, cnxt, stack_identity, template, params, files, args):
"""
The update_stack method updates an existing stack based on the
provided template and parameters.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
arg1 -> RPC context.
arg2 -> Name of the stack you want to create.
arg3 -> Template of stack you want to create.
arg4 -> Stack Input Params
arg4 -> Request parameters/args passed from API
"""
logger.info("template is %s" % template)
self._validate_mandatory_credentials(cnxt)
# Get the database representation of the existing stack
db_stack = self._get_stack(cnxt, stack_identity)
if db_stack.status != parser.Stack.COMPLETE:
raise exception.ActionInProgress(stack_name=db_stack.name, action=db_stack.action)
current_stack = parser.Stack.load(cnxt, stack=db_stack)
# Now parse the template and any parameters for the updated
# stack definition.
tmpl = parser.Template(template, files=files)
stack_name = current_stack.name
common_params = api.extract_args(args)
env = environment.Environment(params)
updated_stack = parser.Stack(cnxt, stack_name, tmpl, env, **common_params)
updated_stack.validate()
self._start_in_thread(db_stack.id, current_stack.update, updated_stack)
return dict(current_stack.identifier())
def create_stack(self, context, stack_name, template, params, args):
"""
The create_stack method creates a new stack using the template
provided.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
arg1 -> RPC context.
arg2 -> Name of the stack you want to create.
arg3 -> Template of stack you want to create.
arg4 -> Stack Input Params
arg4 -> Request parameters/args passed from API
"""
logger.info("template is %s" % template)
if db_api.stack_get_by_name(context, stack_name):
raise AttributeError("Stack already exists with that name")
tmpl = parser.Template(template)
# Extract the template parameters, and any common query parameters
template_params = parser.Parameters(stack_name, tmpl, params)
common_params = api.extract_args(args)
stack = parser.Stack(context, stack_name, tmpl, template_params, **common_params)
response = stack.validate()
if response:
return {"Description": response}
stack_id = stack.store()
self._start_in_thread(stack_id, stack_name, stack.create)
# Schedule a periodic watcher task for this stack
self._timer_in_thread(stack_id, stack_name, self._periodic_watcher_task, sid=stack_id)
return dict(stack.identifier())
def test_tags_extract_not_present(self):
args = api.extract_args({})
self.assertNotIn('tags', args)
def test_timeout_extract(self):
p = {'timeout_mins': '5'}
args = api.extract_args(p)
self.assertEqual(5, args['timeout_mins'])
def test_timeout_extract_garbage(self):
p = {'timeout_mins': 'wibble'}
args = api.extract_args(p)
self.assertTrue('timeout_mins' not in args)
def test_tags_extract(self):
p = {'tags': ["tag1", "tag2"]}
args = api.extract_args(p)
self.assertEqual(['tag1', 'tag2'], args['tags'])
def test_adopt_stack_data_extract_not_present(self):
args = api.extract_args({})
self.assertNotIn('adopt_stack_data', args)
def test_timeout_extract_none(self):
p = {'timeout_mins': None}
args = api.extract_args(p)
self.assertTrue('timeout_mins' not in args)
def test_timeout_extract_not_present(self):
args = api.extract_args({})
self.assertTrue('timeout_mins' not in args)
def test_adopt_stack_data_extract_present(self):
p = {'adopt_stack_data': json.dumps({'Resources': {}})}
args = api.extract_args(p)
self.assertTrue(args.get('adopt_stack_data'))
def test_adopt_stack_data_extract_present(self):
p = {'adopt_stack_data': json.dumps({'Resources': {}})}
args = api.extract_args(p)
self.assertTrue(args.get('adopt_stack_data'))
def test_timeout_extract_zero(self):
p = {'timeout_mins': '0'}
args = api.extract_args(p)
self.assertTrue('timeout_mins' not in args)
def test_timeout_extract_none(self):
p = {'timeout_mins': None}
args = api.extract_args(p)
self.assertNotIn('timeout_mins', args)
def test_timeout_extract_zero(self):
p = {'timeout_mins': '0'}
args = api.extract_args(p)
self.assertNotIn('timeout_mins', args)
def test_timeout_extract_not_present(self):
args = api.extract_args({})
self.assertTrue('timeout_mins' not in args)
def test_timeout_extract_none(self):
p = {'timeout_mins': None}
args = api.extract_args(p)
self.assertTrue('timeout_mins' not in args)
def test_timeout_extract_garbage(self):
p = {'timeout_mins': 'wibble'}
args = api.extract_args(p)
self.assertTrue('timeout_mins' not in args)
def test_timeout_extract_garbage(self):
p = {'timeout_mins': 'wibble'}
args = api.extract_args(p)
self.assertNotIn('timeout_mins', args)
def test_timeout_extract_zero(self):
p = {'timeout_mins': '0'}
args = api.extract_args(p)
self.assertNotIn('timeout_mins', args)
def test_timeout_extract_not_present(self):
args = api.extract_args({})
self.assertNotIn('timeout_mins', args)
def test_timeout_extract_garbage(self):
p = {'timeout_mins': 'wibble'}
args = api.extract_args(p)
self.assertNotIn('timeout_mins', args)
def test_adopt_stack_data_extract_not_present(self):
args = api.extract_args({})
self.assertNotIn('adopt_stack_data', args)
def test_timeout_extract_none(self):
p = {'timeout_mins': None}
args = api.extract_args(p)
self.assertNotIn('timeout_mins', args)
def test_timeout_extract(self):
p = {'timeout_mins': '5'}
args = api.extract_args(p)
self.assertEqual(5, args['timeout_mins'])
def test_timeout_extract_not_present(self):
args = api.extract_args({})
self.assertNotIn('timeout_mins', args)
