def format_stack(stack): ''' Return a representation of the given stack that matches the API output expectations. ''' info = { STACK_NAME: stack.name, STACK_ID: stack.id, STACK_CREATION_TIME: heat_utils.strtime(stack.created_time), STACK_UPDATED_TIME: heat_utils.strtime(stack.updated_time), STACK_NOTIFICATION_TOPICS: [], # TODO Not implemented yet STACK_PARAMETERS: stack.t[parser.PARAMETERS], STACK_DESCRIPTION: stack.t[parser.DESCRIPTION], STACK_TMPL_DESCRIPTION: stack.t[parser.DESCRIPTION], STACK_STATUS: stack.state, STACK_STATUS_DATA: stack.state_description, STACK_CAPABILITIES: [], # TODO Not implemented yet STACK_DISABLE_ROLLBACK: True, # TODO Not implemented yet STACK_TIMEOUT: stack.timeout_mins, } # only show the outputs on a completely created stack if stack.state == stack.CREATE_COMPLETE: info[STACK_OUTPUTS] = format_stack_outputs(stack, stack.outputs) return info
def format_watch(watch): result = { WATCH_ACTIONS_ENABLED: watch.rule.get(RULE_ACTIONS_ENABLED), WATCH_ALARM_ACTIONS: watch.rule.get(RULE_ALARM_ACTIONS), WATCH_TOPIC: watch.rule.get(RULE_TOPIC), WATCH_UPDATED_TIME: heat_utils.strtime(watch.updated_at), WATCH_DESCRIPTION: watch.rule.get(RULE_DESCRIPTION), WATCH_NAME: watch.name, WATCH_COMPARISON: watch.rule.get(RULE_COMPARISON), WATCH_DIMENSIONS: watch.rule.get(RULE_DIMENSIONS) or [], WATCH_PERIODS: watch.rule.get(RULE_PERIODS), WATCH_INSUFFICIENT_ACTIONS: watch.rule.get(RULE_INSUFFICIENT_ACTIONS), WATCH_METRIC_NAME: watch.rule.get(RULE_METRIC_NAME), WATCH_NAMESPACE: watch.rule.get(RULE_NAMESPACE), WATCH_OK_ACTIONS: watch.rule.get(RULE_OK_ACTIONS), WATCH_PERIOD: watch.rule.get(RULE_PERIOD), WATCH_STATE_REASON: watch.rule.get(RULE_STATE_REASON), WATCH_STATE_REASON_DATA: watch.rule.get(RULE_STATE_REASON_DATA), WATCH_STATE_UPDATED_TIME: heat_utils.strtime( watch.rule.get(RULE_STATE_UPDATED_TIME)), WATCH_STATE_VALUE: watch.state, WATCH_STATISTIC: watch.rule.get(RULE_STATISTIC), WATCH_THRESHOLD: watch.rule.get(RULE_THRESHOLD), WATCH_UNIT: watch.rule.get(RULE_UNIT), WATCH_STACK_NAME: watch.stack_name } return result
def to_dict(self): return {'user_id': self.user_id, 'project_id': self.project_id, 'is_admin': self.is_admin, 'read_deleted': self.read_deleted, 'roles': self.roles, 'remote_address': self.remote_address, 'timestamp': heat_utils.strtime(self.timestamp), 'request_id': self.request_id, 'auth_token': self.auth_token}
def format_event(event): s = event.stack result = { EVENT_ID: event.id, EVENT_STACK_ID: s.id, EVENT_STACK_NAME: s.name, EVENT_TIMESTAMP: heat_utils.strtime(event.created_at), EVENT_RES_NAME: event.logical_resource_id, EVENT_RES_PHYSICAL_ID: event.physical_resource_id, EVENT_RES_STATUS: event.name, EVENT_RES_STATUS_DATA: event.resource_status_reason, EVENT_RES_TYPE: event.resource_type, EVENT_RES_PROPERTIES: event.resource_properties, } return result
def format_stack_resource(resource): ''' Return a representation of the given resource that matches the API output expectations. ''' last_updated_time = resource.updated_time or resource.created_time res = { RES_DESCRIPTION: resource.parsed_template().get('Description', ''), RES_UPDATED_TIME: heat_utils.strtime(last_updated_time), RES_NAME: resource.name, RES_PHYSICAL_ID: resource.instance_id or '', RES_METADATA: resource.metadata, RES_STATUS: resource.state, RES_STATUS_DATA: resource.state_description, RES_TYPE: resource.t['Type'], RES_STACK_ID: resource.stack.id, RES_STACK_NAME: resource.stack.name, } return res
def format_watch_data(wd): # Demangle DB format data into something more easily used in the API # We are expecting a dict with exactly two items, Namespace and # a metric key namespace = wd.data['Namespace'] metric = [(k, v) for k, v in wd.data.items() if k != 'Namespace'] if len(metric) == 1: metric_name, metric_data = metric[0] else: logger.error("Unexpected number of keys in watch_data.data!") return result = { WATCH_DATA_ALARM: wd.watch_rule.name, WATCH_DATA_METRIC: metric_name, WATCH_DATA_TIME: heat_utils.strtime(wd.created_at), WATCH_DATA_NAMESPACE: namespace, WATCH_DATA: metric_data } return result