Andreas Wrede
255 lines
8.0 KiB
Python
255 lines
8.0 KiB
Python
"""Configuration loader and defaults for hbd (HeartBeat Daemon/Server)."""
|
|
|
|
import logging
|
|
import os
|
|
|
|
try:
|
|
import yaml
|
|
except Exception:
|
|
yaml = None
|
|
|
|
SERVER_DEFAULTS = {
|
|
# Network settings
|
|
"hb_port": 50003, # Port to listen for heartbeats
|
|
"hbd_port": 50004, # HTTP API port
|
|
"hbd_host": "", # Bind address (empty = all interfaces)
|
|
|
|
# Persistence
|
|
"pickfile": "/tmp/hb.pick",
|
|
|
|
# Logging
|
|
"logfile": "/var/log/heartbeat.log",
|
|
"logfmt": "text", # text or msg or json
|
|
|
|
# Notification channels
|
|
"notification_channels": {}, # Named channels with type and credentials
|
|
"default_notification_channels": [], # Default channels if host doesn't specify
|
|
|
|
# Monitoring settings
|
|
"interval": 20, # Expected heartbeat interval (for server checks)
|
|
"grace": 2, # Grace multiplier (interval * grace = timeout)
|
|
"threshold_renotify_interval": 3600, # Seconds between threshold re-notifications
|
|
|
|
# Host management
|
|
"hosts": {}, # New unified host definitions (optional)
|
|
"watchhosts": [], # Hosts to monitor and notify about (legacy)
|
|
"dyndnshosts": [], # Hosts with dynamic DNS (legacy)
|
|
"drophosts": [], # Hosts to ignore
|
|
"dyndomains": ["wrede.org"],
|
|
|
|
# DNS updates
|
|
"nsupdate_bin": "/usr/bin/nsupdate",
|
|
|
|
# WebSocket settings
|
|
"ws_port": 50005,
|
|
"wss_port": None,
|
|
"cert_path": "/usr/local/etc/ssl/",
|
|
"wss_pem": "fullchain.pem",
|
|
"wss_key": "privkey.pem",
|
|
|
|
# Message journal configuration
|
|
"journal_enabled": True,
|
|
"journal_dir": "/var/log/heartbeat",
|
|
"journal_file": "messages.journal",
|
|
"journal_max_size": 100 * 1024 * 1024, # 100MB
|
|
"journal_max_backups": 10,
|
|
|
|
# Runtime flags
|
|
"foreground": False,
|
|
"verbose": False,
|
|
"debug": 0,
|
|
|
|
# Plugin/threshold configs (for clients reporting to this server)
|
|
"plugins": {},
|
|
"thresholds": {},
|
|
}
|
|
|
|
|
|
def load_config(path=None):
|
|
"""Load configuration from a YAML file and merge with server defaults.
|
|
|
|
If YAML is not available or the file does not exist, defaults are returned.
|
|
|
|
Args:
|
|
path: Path to YAML config file (default: ~/.hb.yaml)
|
|
|
|
Returns:
|
|
Dictionary with configuration
|
|
"""
|
|
cfg = SERVER_DEFAULTS.copy()
|
|
if not path:
|
|
# default path (~/.hb.yaml)
|
|
path = os.path.join(os.path.expanduser("~"), ".hb.yaml")
|
|
|
|
if os.path.exists(path):
|
|
if yaml:
|
|
with open(path) as fh:
|
|
data = yaml.safe_load(fh)
|
|
# Merge YAML data with defaults
|
|
# Keep all keys from YAML to support plugin configs and future extensions
|
|
for k, v in data.items():
|
|
cfg[k] = v
|
|
else:
|
|
# yaml not installed: do not attempt to parse; user must ensure defaults
|
|
pass
|
|
return cfg
|
|
|
|
|
|
def get_watchhosts(config):
|
|
"""Extract watchhosts from config, supporting both new and legacy formats.
|
|
|
|
Args:
|
|
config: Configuration dictionary
|
|
|
|
Returns:
|
|
List of hostnames to watch
|
|
"""
|
|
watchhosts = []
|
|
|
|
# New format: hosts section with watch attribute
|
|
if "hosts" in config:
|
|
hosts_config = config["hosts"]
|
|
if isinstance(hosts_config, dict):
|
|
for host_name, host_attrs in hosts_config.items():
|
|
if isinstance(host_attrs, dict) and host_attrs.get("watch", False):
|
|
watchhosts.append(host_name)
|
|
|
|
# Legacy format: watchhosts list
|
|
if "watchhosts" in config:
|
|
legacy_watchhosts = config.get("watchhosts", [])
|
|
if isinstance(legacy_watchhosts, (list, set)):
|
|
watchhosts.extend(legacy_watchhosts)
|
|
elif isinstance(legacy_watchhosts, dict):
|
|
# Old dict format: {"host1": {attrs}, "host2": {attrs}}
|
|
watchhosts.extend(legacy_watchhosts.keys())
|
|
|
|
return list(set(watchhosts)) # Remove duplicates
|
|
|
|
|
|
def get_dyndnshosts(config):
|
|
"""Extract dyndnshosts from config, supporting both new and legacy formats.
|
|
|
|
Args:
|
|
config: Configuration dictionary
|
|
|
|
Returns:
|
|
List of hostnames with dynamic DNS
|
|
"""
|
|
dyndnshosts = []
|
|
|
|
# New format: hosts section with dyndns attribute
|
|
if "hosts" in config:
|
|
hosts_config = config["hosts"]
|
|
if isinstance(hosts_config, dict):
|
|
for host_name, host_attrs in hosts_config.items():
|
|
if isinstance(host_attrs, dict) and host_attrs.get("dyndns", False):
|
|
dyndnshosts.append(host_name)
|
|
|
|
# Legacy format: dyndnshosts list/set
|
|
if "dyndnshosts" in config:
|
|
legacy_dyndnshosts = config.get("dyndnshosts", [])
|
|
if isinstance(legacy_dyndnshosts, (list, set)):
|
|
dyndnshosts.extend(legacy_dyndnshosts)
|
|
|
|
return list(set(dyndnshosts)) # Remove duplicates
|
|
|
|
|
|
def get_host_config(config, hostname):
|
|
"""Get configuration for a specific host.
|
|
|
|
Args:
|
|
config: Configuration dictionary
|
|
hostname: Host name
|
|
|
|
Returns:
|
|
Dictionary with host attributes or empty dict
|
|
"""
|
|
if "hosts" in config:
|
|
hosts_config = config.get("hosts", {})
|
|
if isinstance(hosts_config, dict) and hostname in hosts_config:
|
|
return hosts_config[hostname] if isinstance(hosts_config[hostname], dict) else {}
|
|
|
|
# Check legacy watchhosts for notification settings
|
|
if "watchhosts" in config:
|
|
watchhosts = config.get("watchhosts", {})
|
|
if isinstance(watchhosts, dict) and hostname in watchhosts:
|
|
legacy_attrs = watchhosts[hostname]
|
|
if isinstance(legacy_attrs, dict):
|
|
# Convert legacy format to new format
|
|
return {
|
|
"watch": True,
|
|
"notify": legacy_attrs.get("notify"),
|
|
"notify_src": legacy_attrs.get("src"),
|
|
}
|
|
|
|
return {}
|
|
|
|
|
|
def get_notification_channels_for_host(config, hostname):
|
|
"""Get notification channels configured for a specific host.
|
|
|
|
Args:
|
|
config: Configuration dictionary
|
|
hostname: Host name
|
|
|
|
Returns:
|
|
List of channel names to use for this host
|
|
"""
|
|
host_config = get_host_config(config, hostname)
|
|
|
|
# Check if host specifies notification channels
|
|
channels = host_config.get("notification_channels", [])
|
|
if channels:
|
|
if isinstance(channels, str):
|
|
return [channels]
|
|
elif isinstance(channels, list):
|
|
return channels
|
|
|
|
# Fall back to default channels
|
|
default_channels = config.get("default_notification_channels", [])
|
|
if default_channels:
|
|
if isinstance(default_channels, str):
|
|
return [default_channels]
|
|
elif isinstance(default_channels, list):
|
|
return default_channels
|
|
|
|
# No channels configured, return empty list (will use legacy global config)
|
|
return []
|
|
|
|
|
|
def get_channel_config(config, channel_name):
|
|
"""Get configuration for a specific notification channel.
|
|
|
|
Args:
|
|
config: Configuration dictionary
|
|
channel_name: Name of the notification channel
|
|
|
|
Returns:
|
|
Dictionary with channel configuration or None if not found
|
|
"""
|
|
channels = config.get("notification_channels", {})
|
|
if isinstance(channels, dict) and channel_name in channels:
|
|
return channels[channel_name]
|
|
return None
|
|
|
|
|
|
def get_notification_channels_config(config, hostname):
|
|
"""Get list of notification channel configurations for a host.
|
|
|
|
Args:
|
|
config: Configuration dictionary
|
|
hostname: Host name
|
|
|
|
Returns:
|
|
List of (channel_name, channel_config) tuples
|
|
"""
|
|
channel_names = get_notification_channels_for_host(config, hostname)
|
|
|
|
channels = []
|
|
for channel_name in channel_names:
|
|
channel_config = get_channel_config(config, channel_name)
|
|
if channel_config and channel_config.get("type"):
|
|
channels.append((channel_name, channel_config))
|
|
|
|
return channels
|