Skip to content

Home Information - Your home, your data, organized.

Python
9.5 KB
Raw Blame
from datetime import datetime
import logging
import threading

import hi.apps.common.datetimeproxy as datetimeproxy

from .alarm import Alarm, AlarmSignature
from .alert import Alert
from .enums import AlarmLevel
from .transient_models import AlertQueueCleanupResult

logger = logging.getLogger(__name__)


class AlertQueue:

    # Caps the queue's memory of past (acknowledged) alerts. Active
    # (unacknowledged) alerts are never evicted by this cap -- the
    # operator must always see them. When a new alert would push the
    # queue past this size, the oldest acknowledged alert is dropped.
    MAX_ALERT_LIST_SIZE = 200

    TRACE = False  # for debugging
    
    def __init__(self):
        self._alert_list = list()
        self._active_alerts_lock = threading.Lock()
        self._last_changed_datetime = datetimeproxy.now()
        return

    def __bool__(self):
        return bool( self._alert_list )
    
    def __len__(self):
        return len( self._alert_list )

    @property
    def unacknowledged_alert_list(self):
        return [ x for x in self._alert_list if not x.is_acknowledged ]
    
    def get_alert( self, alert_id : str ) -> Alert:
        for alert in self._alert_list:
            if alert.id == alert_id:
                return alert
            continue
        raise KeyError( f'Alert not found for {alert_id}' )
        
    def get_most_important_unacknowledged_alert( self, since_datetime : datetime = None ):
        """
        Returns the active alert that has the highest priority and which was
        added to the queue since the "since_datetime" passed (if any).  If there are
        multiple events of the same priority, then an arbitrary one is
        returned. Returns None if there are no active alerts in the
        specified time frame.
        """
        with self._active_alerts_lock:
            if len(self._alert_list) < 1:
                return None
            
            if since_datetime is None:
                since_datetime = datetimeproxy.min()
                
            max_alert = None
            for alert in self._alert_list:
                if alert.is_acknowledged:
                    continue
                # Use queue_insertion_datetime instead of start_datetime for "new alert" detection
                if alert.queue_insertion_datetime is None or alert.queue_insertion_datetime <= since_datetime:
                    continue
                if max_alert is None:
                    max_alert = alert
                elif alert.alert_priority > max_alert.alert_priority:
                    max_alert = alert
                continue
        return max_alert

    def get_most_recent_alarm( self, since_datetime : datetime = None ):
        """
        Of all the alarms in all the alerts, return the most recent
        one that is new than "since_datetime".  Original use of this routine
        was to find a URL to switch to when automatically changing displays
        based on alarms.
        """
        latest_alarm = None
        
        with self._active_alerts_lock:
            if len(self._alert_list) < 1:
                return None
            
            if since_datetime is None:
                since_datetime = datetimeproxy.min()

            latest_alarm_datetime = datetimeproxy.min()
            for alert in self._alert_list:
                if alert.is_acknowledged:
                    continue
                alarm = alert.get_latest_alarm()
                if not alarm:
                    continue
                if alarm.timestamp <= since_datetime:
                    continue
                if alarm.timestamp >= latest_alarm_datetime:
                    latest_alarm = alarm
                    latest_alarm_datetime = alarm.timestamp
                continue
            
        return latest_alarm
    
    def add_alarm( self, alarm : Alarm ) -> Alert:
        if alarm.alarm_level == AlarmLevel.NONE:
            raise ValueError( f'Alarm not alert-worthy: {alarm}'  )
        with self._active_alerts_lock:
            for alert in self._alert_list:
                if not alert.is_matching_alarm( alarm = alarm ):
                    continue
                appended = alert.upsert_alarm( alarm = alarm )
                self._last_changed_datetime = datetimeproxy.now()
                if appended:
                    logger.debug( f'Added alarm to existing alert:'
                                  f' alarm={alarm}, alert={alert}' )
                else:
                    logger.debug( f'Discarded duplicate alarm'
                                  f' (source_alarm_id already tracked):'
                                  f' alarm={alarm}, alert={alert}' )
                return alert

            # No matching alert. Make room if needed by evicting the
            # oldest acknowledged alert. Unacknowledged alerts are
            # never evicted, so the queue can grow past the cap if all
            # entries are still active -- losing an active alert is
            # worse than briefly exceeding the soft cap.
            if len( self._alert_list ) >= self.MAX_ALERT_LIST_SIZE:
                self._evict_oldest_acknowledged_alert()

            new_alert = Alert( first_alarm = alarm )
            new_alert.queue_insertion_datetime = datetimeproxy.now()
            self._alert_list.append( new_alert )
            self._last_changed_datetime = datetimeproxy.now()
            logger.debug( f'Added new alert: {new_alert}' )
            return new_alert

        return

    def _evict_oldest_acknowledged_alert(self):
        # ``add_alarm`` always sets ``queue_insertion_datetime`` before
        # appending, so the field is non-None in practice. Treat a
        # missing value as the epoch so a stray ``None`` doesn't
        # silently freeze the eviction candidate on the first acked
        # entry encountered.
        oldest_index = None
        oldest_insertion_dt = None
        for index, alert in enumerate( self._alert_list ):
            if not alert.is_acknowledged:
                continue
            insertion_dt = alert.queue_insertion_datetime or datetimeproxy.min()
            if ( oldest_insertion_dt is None
                 or ( insertion_dt < oldest_insertion_dt )):
                oldest_insertion_dt = insertion_dt
                oldest_index = index
            continue
        if oldest_index is not None:
            evicted = self._alert_list.pop( oldest_index )
            logger.debug( f'Evicted oldest acknowledged alert to make room: {evicted}' )
        return

    def acknowledge_alert( self, alert_id : str ):
        logger.debug( f'Acknoweldging alert id: {alert_id}' )
        with self._active_alerts_lock:
            for alert in self._alert_list:
                if alert.id != alert_id:
                    continue
                alert.is_acknowledged = True
                self._last_changed_datetime = datetimeproxy.now()
                return True

            raise KeyError( f'Alert not found for {alert_id}' )

    def clear_signature( self, signature : AlarmSignature ) -> int:
        """Remove any alert -- acked or unacked -- whose signature
        matches, so the next bad-state alarm with the same signature
        creates a fresh alert and re-fires notification rather than
        being absorbed by the stale dedup anchor. Returns the number
        of alerts removed; zero is a normal outcome."""
        with self._active_alerts_lock:
            if len( self._alert_list ) < 1:
                return 0
            new_list = list()
            removed = 0
            for alert in self._alert_list:
                if alert.signature == signature:
                    removed += 1
                    continue
                new_list.append( alert )
                continue
            if removed > 0:
                self._alert_list = new_list
                self._last_changed_datetime = datetimeproxy.now()
                logger.debug( f'Cleared {removed} alert(s)'
                              f' with signature "{signature}".' )
        return removed

    def remove_expired_alerts(self):
        """Remove alerts whose ``end_datetime`` has passed. Acknowledged
        alerts are kept until their natural expiry so they continue to
        suppress duplicate alarms (the queue is the dedup memory)."""
        expired_removed = 0
        # Informational count of how many expired alerts had been
        # acknowledged. Acknowledgement is not itself a removal trigger.
        acknowledged_removed = 0

        with self._active_alerts_lock:
            if self.TRACE:
                logger.debug( f'Alert Check: List size = {len(self._alert_list)}')
            if len( self._alert_list ) < 1:
                return AlertQueueCleanupResult()

            now_datetime = datetimeproxy.now()
            new_list = list()
            for alert in self._alert_list:
                if alert.end_datetime <= now_datetime:
                    expired_removed += 1
                    if alert.is_acknowledged:
                        acknowledged_removed += 1
                    continue
                new_list.append( alert )
                continue

            logger.debug( f'Removed "{expired_removed}" expired alerts'
                          f' ({acknowledged_removed} had been acknowledged).' )
            if expired_removed > 0:
                self._alert_list = new_list
                self._last_changed_datetime = datetimeproxy.now()

        return AlertQueueCleanupResult(
            expired_removed = expired_removed,
            acknowledged_removed = acknowledged_removed,
            total_removed = expired_removed,
        )