Home Information - Your home, your data, organized.
Python
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,
)