Add sensor-service microservice with FastAPI, models, and WebSocket

manager
2025-09-10 14:43:41 +01:00
parent 5fdce00e5d
commit fa694443e7
7 changed files with 1221 additions and 0 deletions
--- a/microservices/sensor-service/main.py
+++ b/microservices/sensor-service/main.py
@@ -0,0 +1,531 @@
+"""
+Sensor Management Microservice
+Handles sensors, rooms, real-time data, and analytics from the original dashboard.
+Integrates all existing functionality with the microservices architecture.
+Port: 8007
+"""
+
+import asyncio
+from datetime import datetime, timedelta
+from fastapi import FastAPI, HTTPException, Depends, WebSocket, WebSocketDisconnect, Query, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from contextual import asynccontextmanager
+import logging
+from typing import List, Optional, Dict, Any
+import json
+
+from models import (
+    SensorReading, SensorMetadata, RoomMetrics, SystemEvent, DataQuery, DataResponse,
+    SensorType, SensorStatus, CO2Status, OccupancyLevel, HealthResponse
+)
+from database import connect_to_mongo, close_mongo_connection, get_database, connect_to_redis, get_redis
+from sensor_service import SensorService
+from room_service import RoomService  
+from analytics_service import AnalyticsService
+from websocket_manager import WebSocketManager
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# WebSocket manager for real-time updates
+websocket_manager = WebSocketManager()
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan manager"""
+    logger.info("Sensor Service starting up...")
+    await connect_to_mongo()
+    await connect_to_redis()
+    
+    # Start background tasks
+    asyncio.create_task(redis_subscriber_task())
+    asyncio.create_task(room_metrics_aggregation_task())
+    asyncio.create_task(data_cleanup_task())
+    
+    logger.info("Sensor Service startup complete")
+    
+    yield
+    
+    logger.info("Sensor Service shutting down...")
+    await close_mongo_connection()
+    logger.info("Sensor Service shutdown complete")
+
+app = FastAPI(
+    title="Sensor Management Service",
+    description="Comprehensive sensor, room, and analytics management microservice",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Dependencies
+async def get_db():
+    return await get_database()
+
+async def get_sensor_service(db=Depends(get_db)):
+    redis = await get_redis()
+    return SensorService(db, redis)
+
+async def get_room_service(db=Depends(get_db)):
+    redis = await get_redis()
+    return RoomService(db, redis)
+
+async def get_analytics_service(db=Depends(get_db)):
+    redis = await get_redis()
+    return AnalyticsService(db, redis)
+
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """Health check endpoint"""
+    try:
+        db = await get_database()
+        await db.command("ping")
+        
+        redis = await get_redis()
+        await redis.ping()
+        
+        return HealthResponse(
+            service="sensor-service",
+            status="healthy",
+            timestamp=datetime.utcnow(),
+            version="1.0.0"
+        )
+    except Exception as e:
+        logger.error(f"Health check failed: {e}")
+        raise HTTPException(status_code=503, detail="Service Unavailable")
+
+# WebSocket endpoint for real-time data
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    """WebSocket endpoint for real-time sensor data"""
+    await websocket_manager.connect(websocket)
+    try:
+        while True:
+            # Keep connection alive and handle any incoming messages
+            await websocket.receive_text()
+    except WebSocketDisconnect:
+        await websocket_manager.disconnect(websocket)
+
+# Original Dashboard API Endpoints
+
+# Sensor Management
+@app.get("/sensors")
+async def get_sensors(
+    room: Optional[str] = Query(None, description="Filter by room"),
+    sensor_type: Optional[SensorType] = Query(None, description="Filter by sensor type"),
+    status: Optional[SensorStatus] = Query(None, description="Filter by status"),
+    service: SensorService = Depends(get_sensor_service)
+):
+    """Get all sensors with optional filtering"""
+    try:
+        sensors = await service.get_sensors(room=room, sensor_type=sensor_type, status=status)
+        return {
+            "sensors": sensors,
+            "count": len(sensors),
+            "filters": {
+                "room": room,
+                "sensor_type": sensor_type.value if sensor_type else None,
+                "status": status.value if status else None
+            }
+        }
+    except Exception as e:
+        logger.error(f"Error getting sensors: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+@app.get("/sensors/{sensor_id}")
+async def get_sensor(sensor_id: str, service: SensorService = Depends(get_sensor_service)):
+    """Get detailed sensor information"""
+    try:
+        sensor = await service.get_sensor_details(sensor_id)
+        if not sensor:
+            raise HTTPException(status_code=404, detail="Sensor not found")
+        
+        return sensor
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting sensor {sensor_id}: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+@app.get("/sensors/{sensor_id}/data")
+async def get_sensor_data(
+    sensor_id: str,
+    start_time: Optional[int] = Query(None, description="Start timestamp (Unix)"),
+    end_time: Optional[int] = Query(None, description="End timestamp (Unix)"),
+    limit: int = Query(100, description="Maximum records to return"),
+    offset: int = Query(0, description="Records to skip"),
+    service: SensorService = Depends(get_sensor_service)
+):
+    """Get historical data for a specific sensor"""
+    try:
+        data = await service.get_sensor_data(
+            sensor_id=sensor_id,
+            start_time=start_time,
+            end_time=end_time,
+            limit=limit,
+            offset=offset
+        )
+        
+        return DataResponse(
+            data=data["readings"],
+            total_count=data["total_count"],
+            query=DataQuery(
+                sensor_ids=[sensor_id],
+                start_time=start_time,
+                end_time=end_time,
+                limit=limit,
+                offset=offset
+            ),
+            execution_time_ms=data.get("execution_time_ms", 0)
+        )
+    except Exception as e:
+        logger.error(f"Error getting sensor data for {sensor_id}: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+@app.post("/sensors")
+async def create_sensor(
+    sensor_data: SensorMetadata,
+    service: SensorService = Depends(get_sensor_service)
+):
+    """Register a new sensor"""
+    try:
+        result = await service.create_sensor(sensor_data)
+        return {
+            "message": "Sensor created successfully",
+            "sensor_id": sensor_data.sensor_id,
+            "created_at": result.get("created_at")
+        }
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error creating sensor: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+@app.put("/sensors/{sensor_id}")
+async def update_sensor(
+    sensor_id: str,
+    update_data: dict,
+    service: SensorService = Depends(get_sensor_service)
+):
+    """Update sensor metadata"""
+    try:
+        result = await service.update_sensor(sensor_id, update_data)
+        if not result:
+            raise HTTPException(status_code=404, detail="Sensor not found")
+        
+        return {
+            "message": "Sensor updated successfully",
+            "sensor_id": sensor_id,
+            "updated_at": datetime.utcnow().isoformat()
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error updating sensor {sensor_id}: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+@app.delete("/sensors/{sensor_id}")
+async def delete_sensor(
+    sensor_id: str,
+    service: SensorService = Depends(get_sensor_service)
+):
+    """Delete a sensor and all its data"""
+    try:
+        result = await service.delete_sensor(sensor_id)
+        return {
+            "message": "Sensor deleted successfully",
+            "sensor_id": sensor_id,
+            "readings_deleted": result.get("readings_deleted", 0)
+        }
+    except Exception as e:
+        logger.error(f"Error deleting sensor {sensor_id}: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+# Room Management
+@app.get("/rooms")
+async def get_rooms(service: RoomService = Depends(get_room_service)):
+    """Get all rooms with sensor counts and metrics"""
+    try:
+        rooms = await service.get_rooms()
+        return {
+            "rooms": rooms,
+            "count": len(rooms)
+        }
+    except Exception as e:
+        logger.error(f"Error getting rooms: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+@app.post("/rooms")
+async def create_room(
+    room_data: dict,
+    service: RoomService = Depends(get_room_service)
+):
+    """Create a new room"""
+    try:
+        result = await service.create_room(room_data)
+        return {
+            "message": "Room created successfully",
+            "room": room_data.get("name"),
+            "created_at": result.get("created_at")
+        }
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error creating room: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+@app.get("/rooms/{room_name}")
+async def get_room(room_name: str, service: RoomService = Depends(get_room_service)):
+    """Get detailed room information"""
+    try:
+        room = await service.get_room_details(room_name)
+        if not room:
+            raise HTTPException(status_code=404, detail="Room not found")
+        
+        return room
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting room {room_name}: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+@app.get("/rooms/{room_name}/data")
+async def get_room_data(
+    room_name: str,
+    start_time: Optional[int] = Query(None, description="Start timestamp (Unix)"),
+    end_time: Optional[int] = Query(None, description="End timestamp (Unix)"),
+    limit: int = Query(100, description="Maximum records to return"),
+    service: RoomService = Depends(get_room_service)
+):
+    """Get historical data for a specific room"""
+    try:
+        data = await service.get_room_data(
+            room_name=room_name,
+            start_time=start_time,
+            end_time=end_time,
+            limit=limit
+        )
+        
+        return {
+            "room": room_name,
+            "room_metrics": data.get("room_metrics", []),
+            "sensor_readings": data.get("sensor_readings", []),
+            "period": {
+                "start_time": start_time,
+                "end_time": end_time
+            }
+        }
+    except Exception as e:
+        logger.error(f"Error getting room data for {room_name}: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+# Analytics
+@app.post("/data/query")
+async def query_data(
+    query_params: DataQuery,
+    service: AnalyticsService = Depends(get_analytics_service)
+):
+    """Advanced data querying with multiple filters"""
+    try:
+        result = await service.query_data(query_params)
+        return result
+    except Exception as e:
+        logger.error(f"Error executing data query: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+@app.get("/analytics/summary")
+async def get_analytics_summary(
+    hours: int = Query(24, description="Hours of data to analyze"),
+    service: AnalyticsService = Depends(get_analytics_service)
+):
+    """Get comprehensive analytics summary"""
+    try:
+        analytics = await service.get_analytics_summary(hours)
+        return analytics
+    except Exception as e:
+        logger.error(f"Error getting analytics summary: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+@app.get("/analytics/energy")
+async def get_energy_analytics(
+    hours: int = Query(24),
+    room: Optional[str] = Query(None),
+    service: AnalyticsService = Depends(get_analytics_service)
+):
+    """Get energy-specific analytics"""
+    try:
+        analytics = await service.get_energy_analytics(hours, room)
+        return analytics
+    except Exception as e:
+        logger.error(f"Error getting energy analytics: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+# Data Export
+@app.get("/export")
+async def export_data(
+    start_time: int = Query(..., description="Start timestamp (Unix)"),
+    end_time: int = Query(..., description="End timestamp (Unix)"),
+    sensor_ids: Optional[str] = Query(None, description="Comma-separated sensor IDs"),
+    format: str = Query("json", description="Export format (json, csv)"),
+    service: SensorService = Depends(get_sensor_service)
+):
+    """Export sensor data"""
+    try:
+        export_data = await service.export_data(
+            start_time=start_time,
+            end_time=end_time,
+            sensor_ids=sensor_ids,
+            format=format
+        )
+        
+        return export_data
+    except Exception as e:
+        logger.error(f"Error exporting data: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+# System Events
+@app.get("/events")
+async def get_events(
+    severity: Optional[str] = Query(None, description="Filter by severity"),
+    event_type: Optional[str] = Query(None, description="Filter by event type"),
+    hours: int = Query(24, description="Hours of events to retrieve"),
+    limit: int = Query(50, description="Maximum events to return"),
+    service: SensorService = Depends(get_sensor_service)
+):
+    """Get system events and alerts"""
+    try:
+        events = await service.get_events(
+            severity=severity,
+            event_type=event_type,
+            hours=hours,
+            limit=limit
+        )
+        
+        return {
+            "events": events,
+            "count": len(events),
+            "period_hours": hours
+        }
+    except Exception as e:
+        logger.error(f"Error getting events: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+# Real-time data ingestion endpoint (for simulators)
+@app.post("/data/ingest")
+async def ingest_sensor_data(
+    sensor_data: SensorReading,
+    background_tasks: BackgroundTasks,
+    service: SensorService = Depends(get_sensor_service)
+):
+    """Ingest real-time sensor data"""
+    try:
+        # Process and store sensor data
+        result = await service.ingest_sensor_data(sensor_data)
+        
+        # Schedule background tasks for analytics
+        background_tasks.add_task(update_room_metrics, sensor_data)
+        background_tasks.add_task(broadcast_sensor_data, sensor_data)
+        
+        return {
+            "message": "Sensor data ingested successfully",
+            "sensor_id": sensor_data.sensor_id,
+            "timestamp": sensor_data.timestamp
+        }
+    except Exception as e:
+        logger.error(f"Error ingesting sensor data: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+# Background task functions
+async def update_room_metrics(sensor_data: SensorReading):
+    """Update room-level metrics when sensor data is received"""
+    if sensor_data.room:
+        try:
+            db = await get_database()
+            redis = await get_redis()
+            room_service = RoomService(db, redis)
+            await room_service.update_room_metrics(sensor_data)
+        except Exception as e:
+            logger.error(f"Error updating room metrics: {e}")
+
+async def broadcast_sensor_data(sensor_data: SensorReading):
+    """Broadcast sensor data to WebSocket clients"""
+    try:
+        await websocket_manager.broadcast_sensor_data(sensor_data)
+    except Exception as e:
+        logger.error(f"Error broadcasting sensor data: {e}")
+
+# Background tasks
+async def redis_subscriber_task():
+    """Subscribe to Redis channels for real-time data"""
+    logger.info("Starting Redis subscriber task")
+    
+    try:
+        redis = await get_redis()
+        pubsub = redis.pubsub()
+        await pubsub.subscribe("energy_data", "sensor_events")
+        
+        while True:
+            try:
+                message = await pubsub.get_message(ignore_subscribe_messages=True, timeout=1.0)
+                if message:
+                    # Process incoming message and broadcast to WebSocket clients
+                    await websocket_manager.broadcast_raw_data(message['data'])
+                    
+            except Exception as e:
+                logger.error(f"Error processing Redis message: {e}")
+                await asyncio.sleep(5)
+                
+    except Exception as e:
+        logger.error(f"Redis subscriber task failed: {e}")
+
+async def room_metrics_aggregation_task():
+    """Periodically aggregate room-level metrics"""
+    logger.info("Starting room metrics aggregation task")
+    
+    while True:
+        try:
+            db = await get_database()
+            redis = await get_redis()
+            room_service = RoomService(db, redis)
+            
+            # Aggregate metrics for all rooms
+            await room_service.aggregate_all_room_metrics()
+            
+            # Sleep for 5 minutes between aggregations
+            await asyncio.sleep(300)
+            
+        except Exception as e:
+            logger.error(f"Error in room metrics aggregation: {e}")
+            await asyncio.sleep(600)  # Wait longer on error
+
+async def data_cleanup_task():
+    """Periodic cleanup of old data"""
+    logger.info("Starting data cleanup task")
+    
+    while True:
+        try:
+            db = await get_database()
+            service = SensorService(db, None)
+            
+            # Clean up data older than 90 days
+            cleanup_date = datetime.utcnow() - timedelta(days=90)
+            await service.cleanup_old_data(cleanup_date)
+            
+            # Sleep for 24 hours between cleanups
+            await asyncio.sleep(86400)
+            
+        except Exception as e:
+            logger.error(f"Error in data cleanup task: {e}")
+            await asyncio.sleep(7200)  # Wait 2 hours on error
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8007)