def _stack_action(stack, parsed_args, heat_client, action, action_name=None):
if parsed_args.wait:
# find the last event to use as the marker
events = event_utils.get_events(heat_client,
stack_id=stack,
event_args={'sort_dir': 'desc',
'limit': 1})
marker = events[0].id if events else None
try:
action(stack)
except heat_exc.HTTPNotFound:
msg = _('Stack not found: %s') % stack
raise exc.CommandError(msg)
if parsed_args.wait:
s = heat_client.stacks.get(stack)
stack_status, msg = event_utils.poll_for_events(
heat_client, s.stack_name, action=action_name, marker=marker)
if action_name:
if stack_status == '%s_FAILED' % action_name:
raise exc.CommandError(msg)
else:
if stack_status.endswith('_FAILED'):
raise exc.CommandError(msg)
return heat_client.stacks.get(stack)
def take_action(self, parsed_args):
self.log.debug('take_action(%s)', parsed_args)
client = self.app.client_manager.orchestration
columns = [
'id', 'resource_status', 'resource_status_reason', 'event_time',
'physical_resource_id'
]
kwargs = {
'resource_name': parsed_args.resource,
'limit': parsed_args.limit,
'marker': parsed_args.marker,
# 'filters': heat_utils.format_parameters(parsed_args.filter),
'sort_dir': 'asc'
}
# if parsed_args.resource and parsed_args.nested_depth:
# msg = _('--nested-depth cannot be specified with --resource')
# raise exc.CommandError(msg)
# if parsed_args.nested_depth:
# # Until the API supports recursive event listing we'll have to do
# # the marker/limit filtering client-side
# del kwargs['marker']
# del kwargs['limit']
# columns.append('stack_name')
# # nested_depth = parsed_args.nested_depth
# else:
# nested_depth = 0
if parsed_args.follow:
if parsed_args.formatter != 'value':
msg = _('--follow can only be specified with --format value')
raise exc.CommandError(msg)
marker = parsed_args.marker
try:
while True:
kwargs['marker'] = marker
events = event_utils.get_events(
client,
stack_id=parsed_args.stack,
event_args=kwargs,
# nested_depth=nested_depth,
nested_depth=0,
marker=marker)
if events:
marker = getattr(events[-1], 'id', None)
events_log = heat_utils.event_log_formatter(events)
self.app.stdout.write(events_log)
self.app.stdout.write('\n')
time.sleep(5)
# this loop never exits
except (KeyboardInterrupt, EOFError): # ctrl-c, ctrl-d
return [], []
events = event_utils.get_events(
client,
stack_id=parsed_args.stack,
event_args=kwargs,
# nested_depth=nested_depth,
nested_depth=0,
marker=parsed_args.marker,
limit=parsed_args.limit)
if parsed_args.sort:
events = utils.sort_items(events, ','.join(parsed_args.sort))
if parsed_args.formatter == 'value':
events = heat_utils.event_log_formatter(events).split('\n')
return [], [e.split(' ') for e in events]
if len(events):
if hasattr(events[0], 'resource_name'):
columns.insert(0, 'resource_name')
columns.append('logical_resource_id')
else:
columns.insert(0, 'logical_resource_id')
return (columns, (utils.get_item_properties(s, columns)
for s in events))
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
heat_client = self.app.client_manager.orchestration
try:
if not parsed_args.yes and sys.stdin.isatty():
sys.stdout.write(
_("Are you sure you want to delete this stack(s) [y/N]? "))
prompt_response = sys.stdin.readline().lower()
if not prompt_response.startswith('y'):
self.log.info(_LI('User did not confirm stack delete so '
'taking no action.'))
return
except KeyboardInterrupt: # ctrl-c
self.log.info(_LI('User did not confirm stack delete '
'(ctrl-c) so taking no action.'))
return
except EOFError: # ctrl-d
self.log.info(_LI('User did not confirm stack delete '
'(ctrl-d) so taking no action.'))
return
failure_count = 0
stacks_waiting = []
for sid in parsed_args.stack:
marker = None
if parsed_args.wait:
try:
# find the last event to use as the marker
events = event_utils.get_events(heat_client,
stack_id=sid,
event_args={
'sort_dir': 'desc',
'limit': 1})
if events:
marker = events[0].id
except heat_exc.CommandError as ex:
failure_count += 1
print(ex)
continue
try:
heat_client.stacks.delete(sid)
stacks_waiting.append((sid, marker))
except heat_exc.HTTPNotFound:
failure_count += 1
print(_('Stack not found: %s') % sid)
if parsed_args.wait:
for sid, marker in stacks_waiting:
try:
stack_status, msg = event_utils.poll_for_events(
heat_client, sid, action='DELETE', marker=marker)
except heat_exc.CommandError:
continue
if stack_status == 'DELETE_FAILED':
failure_count += 1
print(msg)
if failure_count:
msg = (_('Unable to delete %(count)d of the %(total)d stacks.') %
{'count': failure_count, 'total': len(parsed_args.stack)})
raise exc.CommandError(msg)
def take_action(self, parsed_args):
self.log.debug('take_action(%s)', parsed_args)
client = self.app.client_manager.orchestration
tpl_files, template = template_utils.process_template_path(
parsed_args.template,
object_request=_authenticated_fetcher(client),
existing=parsed_args.existing)
env_files, env = (
template_utils.process_multiple_environments_and_files(
env_paths=parsed_args.environment))
parameters = heat_utils.format_all_parameters(
parsed_args.parameter,
parsed_args.parameter_file,
parsed_args.template)
if parsed_args.pre_update:
template_utils.hooks_to_env(env, parsed_args.pre_update,
'pre-update')
fields = {
'stack_id': parsed_args.stack,
'parameters': parameters,
'existing': parsed_args.existing,
'template': template,
'files': dict(list(tpl_files.items()) + list(env_files.items())),
'environment': env
}
if parsed_args.tags:
fields['tags'] = parsed_args.tags
if parsed_args.timeout:
fields['timeout_mins'] = parsed_args.timeout
if parsed_args.clear_parameter:
fields['clear_parameters'] = list(parsed_args.clear_parameter)
if parsed_args.rollback:
rollback = parsed_args.rollback.strip().lower()
if rollback not in ('enabled', 'disabled', 'keep'):
msg = _('--rollback invalid value: %s') % parsed_args.rollback
raise exc.CommandError(msg)
if rollback != 'keep':
fields['disable_rollback'] = rollback == 'disabled'
if parsed_args.dry_run:
changes = client.stacks.preview_update(**fields)
fields = ['state', 'resource_name', 'resource_type',
'resource_identity']
columns = sorted(changes.get("resource_changes", {}).keys())
data = [heat_utils.json_formatter(changes["resource_changes"][key])
for key in columns]
return columns, data
if parsed_args.wait:
# find the last event to use as the marker
events = event_utils.get_events(client,
stack_id=parsed_args.stack,
event_args={'sort_dir': 'desc',
'limit': 1})
marker = events[0].id if events else None
client.stacks.update(**fields)
if parsed_args.wait:
stack = client.stacks.get(parsed_args.stack)
stack_status, msg = event_utils.poll_for_events(
client, stack.stack_name, action='UPDATE', marker=marker)
if stack_status == 'UPDATE_FAILED':
raise exc.CommandError(msg)
return _show_stack(client, parsed_args.stack, format='table',
short=True)