Beispiel #1
0
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
Beispiel #2
0
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
Beispiel #3
0
 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}
Beispiel #4
0
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
Beispiel #5
0
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
Beispiel #6
0
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