hbc proper termination, hbd config reloadable

hbd/server/main.py

@@ -50,19 +50,78 @@ def cleanup_function(config, hbdclass):
     logger.info("Cleanup complete.")
 
 
-async def _run_async(config):
+async def reload_configuration(config_obj, config_path, components):
+    """Reload configuration and update all components.
+    
+    Args:
+        config_obj: ReloadableConfig instance
+        config_path: Path to config file
+        components: Dict with threshold_checker and other components
+        
+    Returns:
+        True if reload succeeded, False otherwise
+    """
+    try:
+        logger.info("=" * 60)
+        logger.info("Starting configuration reload...")
+        logger.info("=" * 60)
+        
+        # Reload config file
+        new_config = await config_obj.reload(config_path)
+        
+        # Update notify module
+        notify_mod.reload_config(new_config)
+        
+        # Reload threshold checker
+        if 'threshold_checker' in components:
+            components['threshold_checker'].reload(new_config)
+        
+        # Note: Changes to the following require restart:
+        # - hb_port, hbd_port, ws_port (already bound)
+        # - SSL certificates (already loaded)
+        # - pickfile (already opened)
+        # - journal settings (journal already initialized)
+        
+        # These are reloadable and effective immediately:
+        # - notification_channels
+        # - threshold_configs
+        # - hosts (watchhosts, dyndnshosts, notification_channels)
+        # - grace period (used on next heartbeat)
+        # - debug/verbose flags (used on next message)
+        
+        logger.info("=" * 60)
+        logger.info("Configuration reload completed successfully")
+        logger.info("=" * 60)
+        return True
+        
+    except Exception as e:
+        logger.error("=" * 60)
+        logger.error(f"Failed to reload configuration: {e}", exc_info=True)
+        logger.error("Keeping previous configuration")
+        logger.error("=" * 60)
+        return False
+
+
+async def _run_async(config, config_path=None):
     loop = asyncio.get_running_loop()
     shutdown_event = asyncio.Event()
+    reload_event = asyncio.Event()
 
-    # Signal handlers for graceful shutdown
+    # Signal handlers for graceful shutdown and reload
     def signal_handler(signum, frame):
         sig_name = signal.Signals(signum).name if hasattr(signal, "Signals") else signum
         logger.info(f"Received {sig_name}, initiating shutdown...")
         loop.call_soon_threadsafe(shutdown_event.set)
+    
+    def reload_handler(signum, frame):
+        sig_name = signal.Signals(signum).name if hasattr(signal, "Signals") else signum
+        logger.info(f"Received {sig_name}, initiating config reload...")
+        loop.call_soon_threadsafe(reload_event.set)
 
     # Register signal handlers
     loop.add_signal_handler(signal.SIGINT, signal_handler, signal.SIGINT, None)
     loop.add_signal_handler(signal.SIGTERM, signal_handler, signal.SIGTERM, None)
+    loop.add_signal_handler(signal.SIGHUP, reload_handler, signal.SIGHUP, None)
 
     from . import http as http_mod
     from . import dns as dns_mod
@@ -83,6 +142,12 @@ async def _run_async(config):
         journal=msg_journal,
     )
     logger.info("Threshold checker initialized")
+    
+    # Components dict for reload orchestration
+    components = {
+        'threshold_checker': threshold_checker,
+        'msg_journal': msg_journal,
+    }
 
     sock = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
     # Disable IPV6_V6ONLY option to enable dual-stack (listen on IPv4 as well)
@@ -128,7 +193,6 @@ async def _run_async(config):
                 port=config.get("hbd_port", 50004),
                 config=config,
                 hbdclass=hbdclass,
-                threshold_checker=threshold_checker,
                 tcss=None,
                 verbose=config.get("verbose", False),
                 get_now=lambda: time.time(),
@@ -193,10 +257,43 @@ async def _run_async(config):
     except Exception as e:
         logger.exception("websocket server failed to start: %s", e)
 
+    # Main event loop - monitor shutdown and reload events
     try:
-        # run forever until shutdown event is set
-        await shutdown_event.wait()
-        logger.info("Shutdown signal received, stopping services...")
+        while True:
+            # Wait for either shutdown or reload event
+            done, pending = await asyncio.wait(
+                [
+                    asyncio.create_task(shutdown_event.wait()),
+                    asyncio.create_task(reload_event.wait()),
+                ],
+                return_when=asyncio.FIRST_COMPLETED
+            )
+            
+            # Check which event was triggered
+            if shutdown_event.is_set():
+                logger.info("Shutdown signal received, stopping services...")
+                # Cancel pending wait tasks
+                for task in pending:
+                    task.cancel()
+                break
+            
+            if reload_event.is_set():
+                # Clear the event for next reload
+                reload_event.clear()
+                
+                # Cancel pending wait tasks
+                for task in pending:
+                    task.cancel()
+                
+                # Perform reload if config_path is available
+                if config_path:
+                    await reload_configuration(config, config_path, components)
+                else:
+                    logger.warning("Cannot reload: no config path available")
+                
+                # Continue main loop
+                continue
+                
     except Exception as e:
         logger.exception("Error in main loop: %s", e)
     finally:
@@ -298,10 +395,14 @@ def load_pickled_hosts(config, hbdclass):
             logger.info("no pickled data")
 
 
-def run(config):
+def run(config, config_path=None):
     """Start the hbd service (blocking).
 
     Manually manages the event loop to ensure clean shutdown.
+    
+    Args:
+        config: Configuration dictionary
+        config_path: Path to config file (for reload support)
     """
     import os
 
@@ -312,13 +413,18 @@ def run(config):
 
     notify_mod.initlog(logfile=config.get("logfile", "messages.log"))
     eventlog(None, "INFO", f"hbd version {__version__} starting up")
+    
+    if config_path:
+        logger.info(f"Config file: {config_path} (reload with SIGHUP)")
+    else:
+        logger.warning("No config path provided - reload via SIGHUP disabled")
 
     # Create and set the event loop manually
     loop = asyncio.new_event_loop()
     asyncio.set_event_loop(loop)
 
     try:
-        loop.run_until_complete(_run_async(config))
+        loop.run_until_complete(_run_async(config, config_path=config_path))
     except KeyboardInterrupt:
         logger.info("Received KeyboardInterrupt, shutting down...")
     except Exception as e: