Merge "Send alarm transitioned events on patch and update"

monasca/common/repositories/mysql/alarms_repository.py

@@ -47,6 +47,24 @@ class AlarmsRepository(mysql_repository.MySQLRepository,
 
         super(AlarmsRepository, self).__init__()
 
+    @mysql_repository.mysql_try_catch_block
+    def get_alarm_definition(self, tenant_id, alarm_id):
+
+        query = """
+            select *
+            from alarm_definition as ad
+            inner join alarm as a on a.alarm_definition_id = ad.id
+            where ad.tenant_id = %s and a.id = %s"""
+
+        alarm_definition_rows = self._execute_query(query,
+                                                    (tenant_id, alarm_id))
+
+        if not alarm_definition_rows:
+            raise exceptions.DoesNotExistException
+
+        # There should only be 1 row.
+        return alarm_definition_rows[0]
+
     @mysql_repository.mysql_try_catch_block
     def get_alarm_metrics(self, alarm_id):
 
@@ -124,9 +142,6 @@ class AlarmsRepository(mysql_repository.MySQLRepository,
 
             cursor.execute(update_query, parms)
 
-            if cursor.rowcount < 1:
-                raise exceptions.DoesNotExistException
-
             return prev_state
 
     @mysql_repository.mysql_try_catch_block

monasca/v2/reference/alarming.py

@@ -35,9 +35,55 @@ class Alarming(object):
 
         super(Alarming, self).__init__()
 
-        self._message_queue = (
+        self._events_message_queue = (
             resource_api.init_driver('monasca.messaging',
-                                     cfg.CONF.messaging.driver, (['events'])))
+                                     cfg.CONF.messaging.driver,
+                                     (['events'])))
+
+        self._alarm_state_transitions_message_queue = (
+            resource_api.init_driver('monasca.messaging',
+                                     cfg.CONF.messaging.driver,
+                                     (['alarm-state-transitions'])))
+
+    def _send_alarm_transitioned_event(self, tenant_id, alarm_id,
+                                       alarm_definition_row,
+                                       alarm_metric_rows,
+                                       old_state, new_state):
+
+        metrics = []
+        alarm_transitioned_event_msg = {u'alarm-transitioned': {
+            u'tenantId': tenant_id,
+            u'alarmId': alarm_id,
+            u'alarmDefinitionId': alarm_definition_row['id'],
+            u'alarmName': alarm_definition_row['name'],
+            u'alarmDescription': alarm_definition_row['description'],
+            u'actionsEnabled': alarm_definition_row['actions_enabled'] == 1,
+            u'stateChangeReason': 'Alarm state updated via API',
+            u'severity': alarm_definition_row['severity'],
+            u'oldState': old_state,
+            u'newState': new_state,
+            u'metrics': metrics}
+        }
+
+        for alarm_metric_row in alarm_metric_rows:
+            metric = self._build_metric(alarm_metric_row)
+            metrics.append(metric)
+
+        self._send_event(self._alarm_state_transitions_message_queue,
+                         alarm_transitioned_event_msg)
+
+    def _build_metric(self, alarm_metric_row):
+
+        dimensions = {}
+
+        metric = {u'name': alarm_metric_row['name'],
+                  u'dimensions': dimensions}
+
+        for dimension in alarm_metric_row['dimensions'].split(','):
+            parsed_dimension = dimension.split('=')
+            dimensions[parsed_dimension[0]] = parsed_dimension[1]
+
+        return metric
 
     def _send_alarm_event(self, event_type, tenant_id, alarm_definition_id,
                           alarm_metric_rows, sub_alarm_rows, extra_info=None):
@@ -79,20 +125,16 @@ class Alarming(object):
 
                 prev_alarm_id = alarm_metric_row['alarm_id']
 
-            dimensions = {}
-            metric = {u'name': alarm_metric_row['name'],
-                      u'dimensions': dimensions}
-            for dimension in alarm_metric_row['dimensions'].split(','):
-                parsed_dimension = dimension.split('=')
-                dimensions[parsed_dimension[0]] = parsed_dimension[1]
-
+            metric = self._build_metric(alarm_metric_row)
             alarm_metrics_event_msg.append(metric)
 
         # Finish last alarm
         sub_alarms_event_msg = self._build_sub_alarm_event_msg(sub_alarm_dict,
                                                                prev_alarm_id)
         alarm_event_msg[event_type][u'subAlarms'] = sub_alarms_event_msg
-        self._send_event(alarm_event_msg)
+
+        self._send_event(self._events_message_queue,
+                         alarm_event_msg)
 
     def _build_sub_alarm_event_msg(self, sub_alarm_dict, alarm_id):
 
@@ -122,9 +164,9 @@ class Alarming(object):
 
         return sub_alarms_event_msg
 
-    def _send_event(self, event_msg):
+    def _send_event(self, message_queue, event_msg):
         try:
-            self._message_queue.send_message(
+            message_queue.send_message(
                 json.dumps(event_msg, ensure_ascii=False).encode('utf8'))
         except message_queue_exceptions.MessageQueueException as ex:
             LOG.exception(ex)

monasca/v2/reference/alarms.py

@@ -163,6 +163,21 @@ class Alarms(AlarmsV2API, Alarming):
                                alarm_definition_id, alarm_metric_rows,
                                sub_alarm_rows, state_info)
 
+        if old_state != new_state:
+            try:
+                alarm_definition_row = self._alarms_repo.get_alarm_definition(
+                    tenant_id, id)
+            except exceptions.DoesNotExistException:
+                # Alarm definition does not exist. May have been deleted
+                # in another transaction. In that case, all associated
+                # alarms were also deleted, so don't send transition events.
+                pass
+            else:
+                self._send_alarm_transitioned_event(tenant_id, id,
+                                                    alarm_definition_row,
+                                                    alarm_metric_rows,
+                                                    old_state, new_state)
+
     @resource_try_catch_block
     def _alarm_history_list(self, tenant_id, start_timestamp,
                             end_timestamp, query_parms):