310 lines
11 KiB
Python
310 lines
11 KiB
Python
"""Abstraction main entry point."""
|
|
|
|
import asyncio
|
|
import json
|
|
import logging
|
|
import os
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
import redis.asyncio as aioredis
|
|
import yaml
|
|
from aiomqtt import Client
|
|
|
|
# Configure logging
|
|
logging.basicConfig(
|
|
level=logging.INFO,
|
|
format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
|
|
)
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def load_config(config_path: Path) -> dict[str, Any]:
|
|
"""Load configuration from YAML file.
|
|
|
|
Args:
|
|
config_path: Path to the configuration file
|
|
|
|
Returns:
|
|
dict: Configuration dictionary
|
|
"""
|
|
if not config_path.exists():
|
|
logger.warning(f"Config file not found: {config_path}, using defaults")
|
|
return {
|
|
"mqtt": {
|
|
"broker": "172.16.2.16",
|
|
"port": 1883,
|
|
"client_id": "home-automation-abstraction",
|
|
"keepalive": 60
|
|
},
|
|
"devices": []
|
|
}
|
|
|
|
with open(config_path, "r") as f:
|
|
config = yaml.safe_load(f)
|
|
|
|
# Normalize device entries: accept both 'id' and 'device_id', use 'device_id' internally
|
|
devices = config.get("devices", [])
|
|
for device in devices:
|
|
device["device_id"] = device.pop("device_id", device.pop("id", None))
|
|
|
|
logger.info(f"Loaded configuration from {config_path}")
|
|
return config
|
|
|
|
|
|
def validate_devices(devices: list[dict[str, Any]]) -> None:
|
|
"""Validate device configuration.
|
|
|
|
Args:
|
|
devices: List of device configurations
|
|
|
|
Raises:
|
|
ValueError: If device configuration is invalid
|
|
"""
|
|
required_fields = ["device_id", "type", "cap_version", "technology"]
|
|
|
|
for device in devices:
|
|
# Check for device_id
|
|
if "device_id" not in device or device["device_id"] is None:
|
|
raise ValueError(f"Device entry requires 'id' or 'device_id': {device}")
|
|
|
|
device_id = device["device_id"]
|
|
|
|
# Check required top-level fields
|
|
for field in required_fields:
|
|
if field not in device:
|
|
raise ValueError(f"Device {device_id} missing '{field}'")
|
|
|
|
# Check topics structure
|
|
if "topics" not in device:
|
|
raise ValueError(f"Device {device_id} missing 'topics'")
|
|
|
|
if "set" not in device["topics"]:
|
|
raise ValueError(f"Device {device_id} missing 'topics.set'")
|
|
|
|
if "state" not in device["topics"]:
|
|
raise ValueError(f"Device {device_id} missing 'topics.state'")
|
|
|
|
# Log loaded devices
|
|
device_ids = [d["device_id"] for d in devices]
|
|
logger.info(f"Loaded {len(devices)} device(s): {', '.join(device_ids)}")
|
|
|
|
|
|
async def get_redis_client(redis_url: str, max_retries: int = 5) -> aioredis.Redis:
|
|
"""Connect to Redis with exponential backoff.
|
|
|
|
Args:
|
|
redis_url: Redis connection URL
|
|
max_retries: Maximum number of connection attempts
|
|
|
|
Returns:
|
|
Redis client instance
|
|
"""
|
|
retry_delay = 1
|
|
for attempt in range(max_retries):
|
|
try:
|
|
redis_client = await aioredis.from_url(redis_url, decode_responses=True)
|
|
await redis_client.ping()
|
|
logger.info(f"Connected to Redis: {redis_url}")
|
|
return redis_client
|
|
except Exception as e:
|
|
if attempt < max_retries - 1:
|
|
logger.warning(f"Redis connection failed (attempt {attempt + 1}/{max_retries}): {e}")
|
|
await asyncio.sleep(retry_delay)
|
|
retry_delay = min(retry_delay * 2, 30) # Exponential backoff, max 30s
|
|
else:
|
|
logger.error(f"Failed to connect to Redis after {max_retries} attempts")
|
|
raise
|
|
|
|
|
|
async def handle_abstract_set(
|
|
mqtt_client: Client,
|
|
device_id: str,
|
|
device_type: str,
|
|
vendor_topic: str,
|
|
payload: dict[str, Any]
|
|
) -> None:
|
|
"""Handle abstract SET message and publish to vendor topic.
|
|
|
|
Args:
|
|
mqtt_client: MQTT client instance
|
|
device_id: Device identifier
|
|
device_type: Device type (e.g., 'light')
|
|
vendor_topic: Vendor-specific SET topic
|
|
payload: Message payload
|
|
"""
|
|
# Extract actual payload (remove type wrapper if present)
|
|
vendor_payload = payload.get("payload", payload)
|
|
vendor_message = json.dumps(vendor_payload)
|
|
|
|
logger.info(f"→ vendor SET {device_id}: {vendor_topic} ← {vendor_message}")
|
|
await mqtt_client.publish(vendor_topic, vendor_message, qos=1)
|
|
|
|
|
|
async def handle_vendor_state(
|
|
mqtt_client: Client,
|
|
redis_client: aioredis.Redis,
|
|
device_id: str,
|
|
device_type: str,
|
|
payload: dict[str, Any],
|
|
redis_channel: str = "ui:updates"
|
|
) -> None:
|
|
"""Handle vendor STATE message and publish to abstract topic + Redis.
|
|
|
|
Args:
|
|
mqtt_client: MQTT client instance
|
|
redis_client: Redis client instance
|
|
device_id: Device identifier
|
|
device_type: Device type (e.g., 'light')
|
|
payload: State payload
|
|
redis_channel: Redis channel for UI updates
|
|
"""
|
|
# Publish to abstract state topic (retained)
|
|
abstract_topic = f"home/{device_type}/{device_id}/state"
|
|
abstract_message = json.dumps(payload)
|
|
|
|
logger.info(f"← abstract STATE {device_id}: {abstract_topic} → {abstract_message}")
|
|
await mqtt_client.publish(abstract_topic, abstract_message, qos=1, retain=True)
|
|
|
|
# Publish to Redis for UI updates
|
|
ui_update = {
|
|
"type": "state",
|
|
"device_id": device_id,
|
|
"payload": payload
|
|
}
|
|
redis_message = json.dumps(ui_update)
|
|
|
|
logger.info(f"← Redis PUBLISH {redis_channel} → {redis_message}")
|
|
await redis_client.publish(redis_channel, redis_message)
|
|
|
|
|
|
async def mqtt_worker(config: dict[str, Any], redis_client: aioredis.Redis) -> None:
|
|
"""MQTT worker that handles device communication.
|
|
|
|
Args:
|
|
config: Configuration dictionary containing MQTT settings
|
|
redis_client: Redis client for UI updates
|
|
"""
|
|
mqtt_config = config.get("mqtt", {})
|
|
broker = mqtt_config.get("broker", "172.16.2.16")
|
|
port = mqtt_config.get("port", 1883)
|
|
client_id = mqtt_config.get("client_id", "home-automation-abstraction")
|
|
keepalive = mqtt_config.get("keepalive", 60)
|
|
|
|
redis_config = config.get("redis", {})
|
|
redis_channel = redis_config.get("channel", "ui:updates")
|
|
|
|
devices = {d["device_id"]: d for d in config.get("devices", [])}
|
|
|
|
retry_delay = 1
|
|
max_retry_delay = 60
|
|
|
|
while True:
|
|
try:
|
|
logger.info(f"Connecting to MQTT broker: {broker}:{port}")
|
|
|
|
async with Client(
|
|
hostname=broker,
|
|
port=port,
|
|
identifier=client_id,
|
|
keepalive=keepalive
|
|
) as client:
|
|
logger.info(f"Connected to MQTT broker as {client_id}")
|
|
|
|
# Subscribe to abstract SET topics for all devices
|
|
for device in devices.values():
|
|
abstract_set_topic = f"home/{device['type']}/{device['device_id']}/set"
|
|
await client.subscribe(abstract_set_topic)
|
|
logger.info(f"Subscribed to abstract SET: {abstract_set_topic}")
|
|
|
|
# Subscribe to vendor STATE topics
|
|
vendor_state_topic = device["topics"]["state"]
|
|
await client.subscribe(vendor_state_topic)
|
|
logger.info(f"Subscribed to vendor STATE: {vendor_state_topic}")
|
|
|
|
# Reset retry delay on successful connection
|
|
retry_delay = 1
|
|
|
|
# Process messages
|
|
async for message in client.messages:
|
|
topic = str(message.topic)
|
|
payload_str = message.payload.decode()
|
|
|
|
try:
|
|
payload = json.loads(payload_str)
|
|
except json.JSONDecodeError:
|
|
logger.warning(f"Invalid JSON on {topic}: {payload_str}")
|
|
continue
|
|
|
|
# Check if this is an abstract SET message
|
|
if topic.startswith("home/") and topic.endswith("/set"):
|
|
# Extract device_type and device_id from topic
|
|
parts = topic.split("/")
|
|
if len(parts) == 4: # home/<type>/<id>/set
|
|
device_type = parts[1]
|
|
device_id = parts[2]
|
|
|
|
if device_id in devices:
|
|
device = devices[device_id]
|
|
vendor_topic = device["topics"]["set"]
|
|
await handle_abstract_set(
|
|
client, device_id, device_type, vendor_topic, payload
|
|
)
|
|
|
|
# Check if this is a vendor STATE message
|
|
else:
|
|
# Find device by vendor state topic
|
|
for device_id, device in devices.items():
|
|
if topic == device["topics"]["state"]:
|
|
await handle_vendor_state(
|
|
client, redis_client, device_id, device["type"], payload, redis_channel
|
|
)
|
|
break
|
|
|
|
except Exception as e:
|
|
logger.error(f"MQTT error: {e}")
|
|
logger.info(f"Reconnecting in {retry_delay}s...")
|
|
await asyncio.sleep(retry_delay)
|
|
retry_delay = min(retry_delay * 2, max_retry_delay)
|
|
|
|
|
|
async def async_main() -> None:
|
|
"""Async main function for the abstraction worker."""
|
|
# Determine config path
|
|
config_path = Path(__file__).parent.parent.parent / "config" / "devices.yaml"
|
|
|
|
# Load configuration
|
|
config = load_config(config_path)
|
|
|
|
# Validate devices
|
|
devices = config.get("devices") or []
|
|
validate_devices(devices)
|
|
logger.info(f"Loaded {len(devices)} device(s) from configuration")
|
|
|
|
# Get Redis URL from config or environment variable or use default
|
|
redis_config = config.get("redis", {})
|
|
redis_url = redis_config.get("url") or os.environ.get("REDIS_URL", "redis://localhost:6379/0")
|
|
|
|
# Connect to Redis with retry
|
|
redis_client = await get_redis_client(redis_url)
|
|
|
|
logger.info("Abstraction worker started")
|
|
|
|
# Start MQTT worker
|
|
await mqtt_worker(config, redis_client)
|
|
|
|
|
|
def main() -> None:
|
|
"""Run the abstraction application."""
|
|
try:
|
|
asyncio.run(async_main())
|
|
except KeyboardInterrupt:
|
|
logger.info("Abstraction worker stopped by user")
|
|
except Exception as e:
|
|
logger.error(f"Fatal error: {e}")
|
|
raise
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|