Shore up status indicator and notification logic

Author: MrEricSir

api/check_status.py

@@ -263,41 +263,64 @@ def check_status(should_write_cache=False, interval_seconds=None):
             else:
                 print(f"  Badge cache failed")
 
-            # Notify all channels — done early so notifications aren't lost to timeouts.
-            # Determines whether to notify due to a new transition or a missed previous notification.
-            should_notify = False
+            # Notify channels — done early so notifications aren't lost to timeouts.
+            # Per-channel tracking: each channel independently tracks its last notified status.
             current_reported = reported_status['status']
             previous_reported = None
 
+            # Backward compatibility: migrate string to per-channel dict
+            if isinstance(previous_last_notified, str):
+                from lib.notifiers import ALL_CHANNELS
+                previous_last_notified = {ch: previous_last_notified for ch in ALL_CHANNELS}
+            elif previous_last_notified is None:
+                previous_last_notified = {}
+
+            notified_status = dict(previous_last_notified)
+            notify_channels = None  # None means all channels
+
             if hysteresis_result['status_changed'] and previous_reported_status is not None:
-                should_notify = True
+                # Full transition — dispatch to ALL channels
                 previous_reported = previous_reported_status['status']
                 print(f"\nReported status changed: {previous_reported} -> {current_reported}")
-            elif previous_last_notified is not None and previous_last_notified != current_reported:
-                should_notify = True
-                previous_reported = previous_last_notified
-                print(f"\nRecovering missed notification: {previous_reported} -> {current_reported}")
+            else:
+                # Recovery — only dispatch to channels that are tracked but stale.
+                # Channels absent from the dict are not tracked (unconfigured).
+                stale_channels = set()
+                from lib.notifiers import ALL_CHANNELS
+                for ch in ALL_CHANNELS:
+                    if ch in notified_status and notified_status[ch] != current_reported:
+                        stale_channels.add(ch)
+                if stale_channels:
+                    previous_reported = notified_status.get(next(iter(stale_channels)))
+                    print(f"\nRecovering missed notification for channels: {sorted(stale_channels)}")
+                    notify_channels = stale_channels
+
+            should_notify = (hysteresis_result['status_changed'] and previous_reported_status is not None) or \
+                            (notify_channels is not None and len(notify_channels) > 0)
 
             if should_notify:
                 delay_summaries = reported_status.get('detection', {}).get('delay_summaries', [])
                 notify_results = notify_status_change(
                     status=current_reported,
                     previous_status=previous_reported,
                     delay_summaries=delay_summaries,
-                    timestamp=reported_status['timestamp']
+                    timestamp=reported_status['timestamp'],
+                    channels=notify_channels
                 )
-                any_failed = False
                 for channel, notify_result in notify_results.items():
                     if notify_result['success']:
                         print(f"  {channel}: OK")
+                        notified_status[channel] = current_reported
                     elif notify_result.get('skipped'):
-                        pass  # Unconfigured channels are not failures
+                        # Unconfigured channels: remove from tracking so they
+                        # don't appear stale and trigger infinite retries
+                        notified_status.pop(channel, None)
                     else:
                         print(f"  {channel}: Failed - {notify_result.get('error', 'Unknown error')}")
-                        any_failed = True
-                if not any_failed:
-                    cache_data['last_notified_status'] = current_reported
-                    write_cache(cache_data)
+                        # Leave unchanged — will retry next cycle
+
+            cache_data['last_notified_status'] = notified_status
+            write_cache(cache_data)
 
             # Archive image for debugging/auditing (cloud only, best-effort)
             archive_reasons = []

lib/muni_lib.py

@@ -12,6 +12,7 @@
 import os
 import requests
 import json
+import tempfile
 from datetime import datetime
 from pathlib import Path
 from PIL import Image
@@ -131,10 +132,20 @@ def write_cache(data):
             )
             return True
         else:
-            # Write to local file
-            os.makedirs(os.path.dirname(cache_path), exist_ok=True)
-            with open(cache_path, 'w') as f:
-                json.dump(data, f, indent=2)
+            # Write to local file atomically via temp file + os.replace()
+            cache_dir = os.path.dirname(cache_path)
+            os.makedirs(cache_dir, exist_ok=True)
+            fd, tmp_path = tempfile.mkstemp(dir=cache_dir, prefix='.cache_tmp_', suffix='.json')
+            try:
+                with os.fdopen(fd, 'w') as f:
+                    json.dump(data, f, indent=2)
+                os.replace(tmp_path, cache_path)  # atomic on POSIX
+            except:
+                try:
+                    os.unlink(tmp_path)
+                except OSError:
+                    pass
+                raise
             return True
     except Exception as e:
         print(f"Error writing cache: {e}")

lib/notifiers/__init__.py

@@ -17,14 +17,16 @@
     )
 """
 
-from .dispatcher import notify_status_change
+from .dispatcher import notify_status_change, VALID_STATUSES, ALL_CHANNELS
 from .bluesky import post_to_bluesky
 from .mastodon import post_to_mastodon
 from .rss import update_rss_feed, read_rss_feed, generate_empty_feed
 from .webhooks import send_webhooks
 
 __all__ = [
     'notify_status_change',
+    'VALID_STATUSES',
+    'ALL_CHANNELS',
     'post_to_bluesky',
     'post_to_mastodon',
     'update_rss_feed',

lib/notifiers/dispatcher.py

@@ -8,8 +8,12 @@
 from . import bluesky, mastodon, rss, webhooks
 from .messages import STATUS_MESSAGES
 
+VALID_STATUSES = {'green', 'yellow', 'red'}
+ALL_CHANNELS = {'bluesky', 'mastodon', 'rss', 'webhooks'}
 
-def notify_status_change(status, previous_status, delay_summaries=None, timestamp=None):
+
+def notify_status_change(status, previous_status, delay_summaries=None,
+                         timestamp=None, channels=None):
     """
     Dispatch status change notification to all enabled channels.
 
@@ -18,6 +22,9 @@ def notify_status_change(status, previous_status, delay_summaries=None, timestam
         previous_status: Previous status for context
         delay_summaries: List of delay summary strings (optional)
         timestamp: ISO timestamp string (optional)
+        channels: Set of channel names to dispatch to (optional).
+                  When None, dispatches to all channels. When provided,
+                  only dispatches to channels in the intersection with ALL_CHANNELS.
 
     Returns:
         dict: Results from each notifier channel
@@ -28,11 +35,20 @@ def notify_status_change(status, previous_status, delay_summaries=None, timestam
                 'webhooks': {'success': bool, 'skipped': bool, 'sent': int, 'failed': int, 'error': str}
             }
             'skipped' is True when the channel is not configured (no credentials/URLs set).
+
+    Raises:
+        ValueError: If status is not one of VALID_STATUSES
     """
+    if not isinstance(status, str) or status not in VALID_STATUSES:
+        raise ValueError(f"Invalid status {status!r}; must be one of {sorted(VALID_STATUSES)}")
+
+    dispatch_channels = ALL_CHANNELS if channels is None else channels & ALL_CHANNELS
     results = {}
 
     # Bluesky (if credentials configured)
-    if os.getenv('BLUESKY_HANDLE') and os.getenv('BLUESKY_APP_PASSWORD'):
+    if 'bluesky' not in dispatch_channels:
+        pass
+    elif os.getenv('BLUESKY_HANDLE') and os.getenv('BLUESKY_APP_PASSWORD'):
         results['bluesky'] = bluesky.post_to_bluesky(
             status=status,
             previous_status=previous_status,
@@ -47,7 +63,9 @@ def notify_status_change(status, previous_status, delay_summaries=None, timestam
         }
 
     # Mastodon (if credentials configured)
-    if os.getenv('MASTODON_INSTANCE') and os.getenv('MASTODON_ACCESS_TOKEN'):
+    if 'mastodon' not in dispatch_channels:
+        pass
+    elif os.getenv('MASTODON_INSTANCE') and os.getenv('MASTODON_ACCESS_TOKEN'):
         results['mastodon'] = mastodon.post_to_mastodon(
             status=status,
             previous_status=previous_status,
@@ -62,21 +80,25 @@ def notify_status_change(status, previous_status, delay_summaries=None, timestam
         }
 
     # RSS feed (always enabled - no credentials needed)
-    # Use same status message as Bluesky/Mastodon
-    description = STATUS_MESSAGES.get(status, f'Status: {status}')
-    results['rss'] = rss.update_rss_feed(
-        status=status,
-        description=description,
-        delay_summaries=delay_summaries,
-        timestamp=timestamp
-    )
+    if 'rss' in dispatch_channels:
+        # Use same status message as Bluesky/Mastodon
+        description = STATUS_MESSAGES.get(status, f'Status: {status}')
+        results['rss'] = rss.update_rss_feed(
+            status=status,
+            description=description,
+            delay_summaries=delay_summaries,
+            timestamp=timestamp
+        )
 
     # Webhooks (if URLs configured)
-    results['webhooks'] = webhooks.send_webhooks(
-        status=status,
-        previous_status=previous_status,
-        delay_summaries=delay_summaries,
-        timestamp=timestamp
-    )
+    if 'webhooks' not in dispatch_channels:
+        pass
+    else:
+        results['webhooks'] = webhooks.send_webhooks(
+            status=status,
+            previous_status=previous_status,
+            delay_summaries=delay_summaries,
+            timestamp=timestamp
+        )
 
     return results