Example #1
0
    def _create_vertex(self, entity_event):

        entity_event['timestamp'] = format_unix_timestamp(
            entity_event[CProps.TIME], tbase.TIMESTAMP_FORMAT)

        update_timestamp = entity_event['timestamp']

        vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE]

        entity_state = AlarmProps.INACTIVE_STATE \
            if self._ok_status(entity_event) else AlarmProps.ACTIVE_STATE

        metadata = {
            VProps.NAME: entity_event[CProps.MESSAGE],
            VProps.SEVERITY: entity_event[CProps.SEVERITY],
            VProps.RAWTEXT: self.generate_raw_text(entity_event),
            VProps.RESOURCE_NAME: entity_event[CProps.RESOURCE_NAME]
        }

        return graph_utils.create_vertex(
            self._create_entity_key(entity_event),
            vitrage_category=Category.ALARM,
            vitrage_type=entity_event[DSProps.ENTITY_TYPE],
            vitrage_sample_timestamp=vitrage_sample_timestamp,
            entity_state=entity_state,
            update_timestamp=update_timestamp,
            metadata=metadata)
Example #2
0
 def _unify_time_format(entity_event):
     try:
         entity_event[ZProps.TIMESTAMP] = format_unix_timestamp(
             entity_event[ZProps.LAST_CHANGE], tbase.TIMESTAMP_FORMAT)
     except ValueError:
         entity_event[ZProps.TIMESTAMP] = change_time_str_format(
             entity_event[ZProps.LAST_CHANGE],
             ZProps.ZABBIX_TIMESTAMP_FORMAT, tbase.TIMESTAMP_FORMAT)
Example #3
0
 def _unify_time_format(entity_event):
     try:
         entity_event[ZProps.TIMESTAMP] = format_unix_timestamp(
             entity_event[ZProps.LAST_CHANGE], tbase.TIMESTAMP_FORMAT)
     except ValueError:
         entity_event[ZProps.TIMESTAMP] = change_time_str_format(
             entity_event[ZProps.LAST_CHANGE],
             ZProps.ZABBIX_TIMESTAMP_FORMAT,
             tbase.TIMESTAMP_FORMAT)
Example #4
0
    def _assert_collectd_vertex_equals(self, collectd_vertex, expected_time,
                                       expected_resource_type,
                                       expected_resource_name,
                                       expected_severity):

        self.assertEqual(format_unix_timestamp(expected_time),
                         collectd_vertex[VProps.VITRAGE_SAMPLE_TIMESTAMP])
        self.assertEqual(expected_resource_type,
                         collectd_vertex[VProps.VITRAGE_RESOURCE_TYPE])
        self.assertEqual(expected_resource_name,
                         collectd_vertex[CProps.RESOURCE_NAME])
        self.assertEqual(expected_severity, collectd_vertex[VProps.SEVERITY])
    def _generate_event(time, hostname, severity):
        update_vals = {
            CProps.HOST: hostname,
            CProps.SEVERITY: severity,
            CProps.TIME: time,
            DSProps.SAMPLE_DATE: format_unix_timestamp(time),
            CProps.RESOURCE_NAME: hostname
        }

        generators = mock_transformer.simple_collectd_alarm_generators(
            update_vals=update_vals)

        return mock_transformer.generate_random_events_list(generators)[0]
Example #6
0
    def _create_collectd_event(time, resource_type, resource_name, host_name,
                               severity, message):
        update_vals = {
            CProps.TIME: time,
            DSProps.SAMPLE_DATE: format_unix_timestamp(time),
            CProps.HOST: host_name,
            CProps.RESOURCE_TYPE: resource_type,
            CProps.RESOURCE_NAME: resource_name,
            CProps.MESSAGE: message,
            CProps.SEVERITY: severity
        }

        spec_list = mock_transformer.simple_collectd_alarm_generators(
            update_vals=update_vals)
        static_events = mock_transformer.generate_random_events_list(spec_list)

        return static_events[0]
    def _generate_event(time, hostname, severity):
        # fake query result to be used by the transformer for determining
        # the neighbor
        query_result = [{VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE,
                         VProps.ID: hostname}]

        update_vals = {CProps.HOST: hostname,
                       CProps.SEVERITY: severity,
                       CProps.TIME: time,
                       DSProps.SAMPLE_DATE: format_unix_timestamp(time),
                       CProps.RESOURCE_NAME: hostname,
                       TransformerBase.QUERY_RESULT: query_result}

        generators = mock_transformer.simple_collectd_alarm_generators(
            update_vals=update_vals)

        return mock_transformer.generate_random_events_list(generators)[0]
Example #8
0
 def enrich_event(event, format_timestamp=True):
     if format_timestamp:
         event[ZabbixProps.TIMESTAMP] = format_unix_timestamp(
             event[ZabbixProps.LAST_CHANGE], tbase.TIMESTAMP_FORMAT)
 def _validate_vertex_props(self, vertex, event):
     timestamp = format_unix_timestamp(event[CProps.TIME])
     self._validate_alarm_vertex_props(vertex, event[CProps.MESSAGE],
                                       COLLECTD_DATASOURCE, timestamp)
 def enrich_event(event, format_timestamp=True):
     if format_timestamp:
         event[ZabbixProps.TIMESTAMP] = format_unix_timestamp(
             event[ZabbixProps.LAST_CHANGE], tbase.TIMESTAMP_FORMAT)