osism 0.20250823.0__py3-none-any.whl → 0.20250824.1__py3-none-any.whl

osism/api.py

@@ -3,16 +3,28 @@
 import datetime
 from logging.config import dictConfig
 import logging
+import json
 from typing import Optional, Dict, Any
 from uuid import UUID
 
-from fastapi import FastAPI, Header, Request, Response, HTTPException, status
+from fastapi import (
+    FastAPI,
+    Header,
+    Request,
+    Response,
+    HTTPException,
+    status,
+    WebSocket,
+    WebSocketDisconnect,
+)
 from pydantic import BaseModel, Field
 from starlette.middleware.cors import CORSMiddleware
 
 from osism.tasks import reconciler, openstack
 from osism import utils
 from osism.services.listener import BaremetalEvents
+from osism.services.websocket_manager import websocket_manager
+from osism.services.event_bridge import event_bridge
 
 
 class NotificationBaremetal(BaseModel):
@@ -95,6 +107,10 @@ app.add_middleware(
         "Content-Type",
         "Authorization",
         "X-Hook-Signature",
+        "Sec-WebSocket-Protocol",
+        "Sec-WebSocket-Key",
+        "Sec-WebSocket-Version",
+        "Sec-WebSocket-Extensions",
     ],
 )
 
@@ -103,6 +119,9 @@ logger = logging.getLogger("osism.api")
 
 baremetal_events = BaremetalEvents()
 
+# Connect event bridge to WebSocket manager
+event_bridge.set_websocket_manager(websocket_manager)
+
 
 class DeviceSearchResult(BaseModel):
     result: str = Field(..., description="Operation result status")
@@ -110,11 +129,13 @@ class DeviceSearchResult(BaseModel):
 
 
 class BaremetalNode(BaseModel):
-    uuid: str = Field(..., description="Unique identifier of the node")
+    uuid: Optional[str] = Field(None, description="Unique identifier of the node")
     name: Optional[str] = Field(None, description="Name of the node")
     power_state: Optional[str] = Field(None, description="Current power state")
     provision_state: Optional[str] = Field(None, description="Current provision state")
-    maintenance: bool = Field(..., description="Whether node is in maintenance mode")
+    maintenance: Optional[bool] = Field(
+        None, description="Whether node is in maintenance mode"
+    )
     instance_uuid: Optional[str] = Field(
         None, description="UUID of associated instance"
     )
@@ -177,6 +198,16 @@ async def v1() -> Dict[str, str]:
     return {"result": "ok"}
 
 
+@app.get("/v1/events", tags=["events"])
+async def events_info() -> Dict[str, str]:
+    """Events endpoint info - WebSocket available at /v1/events/openstack."""
+    return {
+        "result": "ok",
+        "websocket_endpoint": "/v1/events/openstack",
+        "description": "Real-time OpenStack events via WebSocket",
+    }
+
+
 class SinkResponse(BaseModel):
     result: str = Field(..., description="Operation result status")
 
@@ -348,6 +379,73 @@ def process_netbox_webhook(webhook_input: WebhookNetboxData) -> None:
         logger.info(f"Ignoring change for unmanaged device {name}")
 
 
+@app.websocket("/v1/events/openstack")
+async def websocket_openstack_events(websocket: WebSocket):
+    """WebSocket endpoint for streaming all OpenStack events in real-time.
+
+    Supports events from all OpenStack services: Ironic, Nova, Neutron, Cinder, Glance, Keystone
+
+    Clients can send filter messages in JSON format:
+    {
+        "action": "set_filters",
+        "event_filters": ["baremetal.node.power_set.end", "compute.instance.create.end", "network.port.create.end"],
+        "node_filters": ["server-01", "server-02"],
+        "service_filters": ["baremetal", "compute", "network"]
+    }
+    """
+    await websocket_manager.connect(websocket)
+    try:
+        # Keep the connection alive and listen for client messages
+        while True:
+            try:
+                # Receive messages from client for filtering configuration
+                data = await websocket.receive_text()
+                logger.debug(f"Received WebSocket message: {data}")
+
+                try:
+                    message = json.loads(data)
+                    if message.get("action") == "set_filters":
+                        event_filters = message.get("event_filters")
+                        node_filters = message.get("node_filters")
+                        service_filters = message.get("service_filters")
+
+                        await websocket_manager.update_filters(
+                            websocket,
+                            event_filters=event_filters,
+                            node_filters=node_filters,
+                            service_filters=service_filters,
+                        )
+
+                        # Send acknowledgment
+                        response = {
+                            "type": "filter_update",
+                            "status": "success",
+                            "event_filters": event_filters,
+                            "node_filters": node_filters,
+                            "service_filters": service_filters,
+                        }
+                        await websocket.send_text(json.dumps(response))
+
+                except json.JSONDecodeError:
+                    logger.warning(
+                        f"Invalid JSON received from WebSocket client: {data}"
+                    )
+                except Exception as e:
+                    logger.error(f"Error processing WebSocket filter message: {e}")
+
+            except WebSocketDisconnect:
+                logger.info("WebSocket client disconnected")
+                break
+            except Exception as e:
+                logger.error(f"Error handling WebSocket message: {e}")
+                break
+
+    except WebSocketDisconnect:
+        logger.info("WebSocket client disconnected")
+    finally:
+        await websocket_manager.disconnect(websocket)
+
+
 @app.post(
     "/v1/webhook/netbox",
     response_model=WebhookNetboxResponse,

osism/services/event_bridge.py

@@ -0,0 +1,304 @@
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Event bridge for sharing events between RabbitMQ listener and WebSocket manager.
+This module provides a Redis-based way to forward events from the listener service
+to the WebSocket manager across different containers.
+"""
+
+import threading
+import queue
+import logging
+import json
+import os
+from typing import Dict, Any
+
+try:
+    import redis
+
+    REDIS_AVAILABLE = True
+except ImportError:
+    REDIS_AVAILABLE = False
+
+logger = logging.getLogger("osism.event_bridge")
+
+
+class EventBridge:
+    """Redis-based bridge for forwarding events between RabbitMQ listener and WebSocket manager across containers."""
+
+    def __init__(self):
+        self._event_queue = queue.Queue()
+        self._websocket_manager = None
+        self._processor_thread = None
+        self._subscriber_thread = None
+        self._shutdown_event = threading.Event()
+        self._redis_client = None
+        self._redis_subscriber = None
+
+        # Initialize Redis connection
+        self._init_redis()
+
+    def _init_redis(self):
+        """Initialize Redis connection."""
+        if not REDIS_AVAILABLE:
+            logger.warning(
+                "Redis not available - event bridge will use local queue only"
+            )
+            return
+
+        try:
+            redis_host = os.getenv("REDIS_HOST", "redis")
+            redis_port = int(os.getenv("REDIS_PORT", "6379"))
+            redis_db = int(os.getenv("REDIS_DB", "0"))
+
+            self._redis_client = redis.Redis(
+                host=redis_host,
+                port=redis_port,
+                db=redis_db,
+                decode_responses=True,
+                socket_connect_timeout=10,
+                socket_timeout=None,  # No timeout for blocking operations
+                health_check_interval=30,
+            )
+
+            # Test connection
+            self._redis_client.ping()
+            logger.info(f"Connected to Redis at {redis_host}:{redis_port}")
+
+            # Create subscriber for WebSocket manager (API container)
+            self._redis_subscriber = self._redis_client.pubsub()
+
+        except Exception as e:
+            logger.error(f"Failed to connect to Redis: {e}")
+            self._redis_client = None
+            self._redis_subscriber = None
+
+    def set_websocket_manager(self, websocket_manager):
+        """Set the WebSocket manager instance and start Redis subscriber."""
+        self._websocket_manager = websocket_manager
+        logger.info("WebSocket manager connected to event bridge")
+
+        # Start Redis subscriber thread if Redis is available
+        if self._redis_client and not self._subscriber_thread:
+            self._start_redis_subscriber()
+
+        # Start local processor thread if not already running
+        if not self._processor_thread or not self._processor_thread.is_alive():
+            self._start_processor_thread()
+
+    def add_event(self, event_type: str, payload: Dict[str, Any]) -> None:
+        """Add an event to be forwarded to WebSocket clients via Redis."""
+        try:
+            event_data = {"event_type": event_type, "payload": payload}
+
+            if self._redis_client:
+                # Publish to Redis for cross-container communication
+                try:
+                    message = json.dumps(event_data)
+                    subscribers = self._redis_client.publish("osism:events", message)
+                    logger.info(
+                        f"Published event to Redis: {event_type} (subscribers: {subscribers})"
+                    )
+
+                    if subscribers == 0:
+                        logger.warning(f"No Redis subscribers for event: {event_type}")
+
+                except Exception as redis_error:
+                    logger.error(f"Failed to publish event to Redis: {redis_error}")
+                    # Try to reconnect Redis
+                    try:
+                        self._init_redis()
+                        if self._redis_client:
+                            message = json.dumps(event_data)
+                            subscribers = self._redis_client.publish(
+                                "osism:events", message
+                            )
+                            logger.info(
+                                f"Published event to Redis after reconnect: {event_type} (subscribers: {subscribers})"
+                            )
+                        else:
+                            raise Exception("Redis reconnection failed")
+                    except Exception as reconnect_error:
+                        logger.error(f"Redis reconnection failed: {reconnect_error}")
+                        # Fallback to local queue
+                        self._event_queue.put_nowait(event_data)
+                        logger.debug(
+                            f"Added event to local fallback queue: {event_type}"
+                        )
+            else:
+                # Local queue fallback
+                self._event_queue.put_nowait(event_data)
+                logger.debug(f"Added event to local queue: {event_type}")
+
+        except queue.Full:
+            logger.warning("Event bridge queue is full, dropping event")
+        except Exception as e:
+            logger.error(f"Error adding event to bridge: {e}")
+
+    def _start_redis_subscriber(self):
+        """Start Redis subscriber thread for receiving events from other containers."""
+        self._subscriber_thread = threading.Thread(
+            target=self._redis_subscriber_loop, name="RedisEventSubscriber", daemon=True
+        )
+        self._subscriber_thread.start()
+        logger.info("Started Redis event subscriber thread")
+
+    def _start_processor_thread(self):
+        """Start the background thread that processes local events."""
+        self._processor_thread = threading.Thread(
+            target=self._process_events, name="EventBridgeProcessor", daemon=True
+        )
+        self._processor_thread.start()
+        logger.info("Started event bridge processor thread")
+
+    def _redis_subscriber_loop(self):
+        """Redis subscriber loop for receiving events from other containers with auto-reconnect."""
+        retry_count = 0
+        max_retries = 5
+        retry_delay = 5  # seconds
+
+        while not self._shutdown_event.is_set() and retry_count < max_retries:
+            try:
+                if not self._redis_subscriber:
+                    logger.error("Redis subscriber not available")
+                    return
+
+                logger.info(
+                    f"Starting Redis subscriber (attempt {retry_count + 1}/{max_retries})"
+                )
+                self._redis_subscriber.subscribe("osism:events")
+                logger.info("Subscribed to Redis events channel")
+                retry_count = 0  # Reset retry count on successful connection
+
+                # Use get_message with timeout instead of listen() to avoid hanging
+                while not self._shutdown_event.is_set():
+                    try:
+                        # Check for messages with timeout
+                        message = self._redis_subscriber.get_message(timeout=10.0)
+
+                        if message is None:
+                            continue  # Timeout, check shutdown and continue
+
+                        if message["type"] == "message":
+                            try:
+                                event_data = json.loads(message["data"])
+                                logger.info(
+                                    f"Received event from Redis: {event_data.get('event_type')}"
+                                )
+
+                                if self._websocket_manager:
+                                    # Process event directly
+                                    self._process_single_event(event_data)
+                                else:
+                                    # Add to local queue for later processing
+                                    self._event_queue.put_nowait(event_data)
+
+                            except json.JSONDecodeError as e:
+                                logger.error(
+                                    f"Failed to decode Redis event message: {e}"
+                                )
+                            except Exception as e:
+                                logger.error(f"Error processing Redis event: {e}")
+
+                    except Exception as get_msg_error:
+                        logger.error(f"Error getting Redis message: {get_msg_error}")
+                        break  # Break inner loop to trigger reconnect
+
+            except Exception as e:
+                retry_count += 1
+                logger.error(
+                    f"Redis subscriber error (attempt {retry_count}/{max_retries}): {e}"
+                )
+
+                if retry_count < max_retries:
+                    logger.info(
+                        f"Retrying Redis subscription in {retry_delay} seconds..."
+                    )
+                    self._shutdown_event.wait(retry_delay)
+
+                    # Recreate Redis connection
+                    try:
+                        self._init_redis()
+                    except Exception as init_error:
+                        logger.error(f"Failed to reinitialize Redis: {init_error}")
+
+            finally:
+                if self._redis_subscriber:
+                    try:
+                        self._redis_subscriber.close()
+                    except Exception:
+                        pass  # Ignore errors during cleanup
+
+        if retry_count >= max_retries:
+            logger.error("Max Redis reconnection attempts reached, giving up")
+        else:
+            logger.info("Redis subscriber stopped")
+
+    def _process_single_event(self, event_data: Dict[str, Any]):
+        """Process a single event with WebSocket manager."""
+        if not self._websocket_manager:
+            logger.warning("No WebSocket manager available, dropping event")
+            return
+
+        try:
+            import asyncio
+
+            # Create new event loop for this thread
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+            # Process the event
+            loop.run_until_complete(
+                self._websocket_manager.broadcast_event_from_notification(
+                    event_data["event_type"], event_data["payload"]
+                )
+            )
+
+            loop.close()
+            logger.debug(f"Processed event via bridge: {event_data['event_type']}")
+
+        except Exception as e:
+            logger.error(f"Error processing event via bridge: {e}")
+
+    def _process_events(self):
+        """Background thread that processes events from the local queue."""
+        logger.info("Event bridge processor started")
+
+        while not self._shutdown_event.is_set():
+            try:
+                # Get event with timeout to check shutdown periodically
+                try:
+                    event_data = self._event_queue.get(timeout=1.0)
+                except queue.Empty:
+                    continue
+
+                self._process_single_event(event_data)
+                self._event_queue.task_done()
+
+            except Exception as e:
+                logger.error(f"Unexpected error in event bridge processor: {e}")
+
+        logger.info("Event bridge processor stopped")
+
+    def shutdown(self):
+        """Shutdown the event bridge."""
+        logger.info("Shutting down event bridge")
+        self._shutdown_event.set()
+
+        # Close Redis subscriber
+        if self._redis_subscriber:
+            try:
+                self._redis_subscriber.close()
+            except Exception as e:
+                logger.error(f"Error closing Redis subscriber: {e}")
+
+        # Wait for threads to finish
+        if self._processor_thread and self._processor_thread.is_alive():
+            self._processor_thread.join(timeout=5.0)
+
+        if self._subscriber_thread and self._subscriber_thread.is_alive():
+            self._subscriber_thread.join(timeout=5.0)
+
+
+# Global event bridge instance
+event_bridge = EventBridge()

osism/services/listener.py

@@ -14,6 +14,41 @@ import requests
 from osism.tasks import netbox
 from osism import settings
 
+# Multiple exchanges for different OpenStack services
+EXCHANGES_CONFIG = {
+    "ironic": {
+        "exchange": "ironic",
+        "routing_key": "ironic_versioned_notifications.info",
+        "queue": "osism-listener-ironic",
+    },
+    "nova": {
+        "exchange": "nova",
+        "routing_key": "nova_versioned_notifications.info",
+        "queue": "osism-listener-nova",
+    },
+    "neutron": {
+        "exchange": "neutron",
+        "routing_key": "neutron_versioned_notifications.info",
+        "queue": "osism-listener-neutron",
+    },
+    "cinder": {
+        "exchange": "cinder",
+        "routing_key": "cinder_versioned_notifications.info",
+        "queue": "osism-listener-cinder",
+    },
+    "keystone": {
+        "exchange": "keystone",
+        "routing_key": "keystone_versioned_notifications.info",
+        "queue": "osism-listener-keystone",
+    },
+    "glance": {
+        "exchange": "glance",
+        "routing_key": "glance_versioned_notifications.info",
+        "queue": "osism-listener-glance",
+    },
+}
+
+# Legacy constants for backward compatibility
 EXCHANGE_NAME = "ironic"
 ROUTING_KEY = "ironic_versioned_notifications.info"
 QUEUE_NAME = "osism-listener-ironic"
@@ -138,39 +173,115 @@ class NotificationsDump(ConsumerMixin):
         self.baremetal_events = BaremetalEvents()
         self.osism_api_session: None | requests.Session = None
         self.osism_baremetal_api_url: None | str = None
+        self.websocket_manager = None
+
         if settings.OSISM_API_URL:
             logger.info("Setting up OSISM API")
             self.osism_api_session = requests.Session()
             self.osism_baremetal_api_url = (
                 settings.OSISM_API_URL.rstrip("/") + "/notifications/baremetal"
             )
+
+        # Import event_bridge for WebSocket forwarding
+        try:
+            from osism.services.event_bridge import event_bridge
+
+            self.event_bridge = event_bridge
+            logger.info("Event bridge connected to RabbitMQ listener")
+        except ImportError:
+            logger.warning("Event bridge not available")
+            self.event_bridge = None
+
         return
 
     def get_consumers(self, consumer, channel):
-        exchange = Exchange(EXCHANGE_NAME, type="topic", durable=False)
-        queue = Queue(
-            QUEUE_NAME,
-            exchange,
-            routing_key=ROUTING_KEY,
-            durable=False,
-            auto_delete=True,
-            no_ack=True,
-        )
-        return [consumer(queue, callbacks=[self.on_message])]
+        consumers = []
+
+        # Create consumers for all configured exchanges
+        for service_name, config in EXCHANGES_CONFIG.items():
+            try:
+                exchange = Exchange(config["exchange"], type="topic", durable=False)
+                queue = Queue(
+                    config["queue"],
+                    exchange,
+                    routing_key=config["routing_key"],
+                    durable=False,
+                    auto_delete=True,
+                    no_ack=True,
+                )
+                consumers.append(consumer(queue, callbacks=[self.on_message]))
+                logger.info(
+                    f"Configured consumer for {service_name} exchange: {config['exchange']}"
+                )
+            except Exception as e:
+                logger.error(f"Failed to configure consumer for {service_name}: {e}")
+
+        if not consumers:
+            logger.warning(
+                "No consumers configured, falling back to legacy ironic consumer"
+            )
+            # Fallback to legacy configuration
+            exchange = Exchange(EXCHANGE_NAME, type="topic", durable=False)
+            queue = Queue(
+                QUEUE_NAME,
+                exchange,
+                routing_key=ROUTING_KEY,
+                durable=False,
+                auto_delete=True,
+                no_ack=True,
+            )
+            consumers.append(consumer(queue, callbacks=[self.on_message]))
+
+        return consumers
 
     def on_message(self, body, message):
         data = json.loads(body["oslo.message"])
-        logger.debug(
-            data["event_type"]
-            + ": "
-            + str(
-                {
+
+        # Log event with service type detection
+        event_type = data.get("event_type", "")
+        service_type = event_type.split(".")[0] if event_type else "unknown"
+
+        # Enhanced logging for different event types
+        payload_info = {}
+        if "payload" in data:
+            payload = data["payload"]
+
+            # Extract relevant info based on service type
+            if service_type == "baremetal" and "ironic_object.data" in payload:
+                ironic_data = payload["ironic_object.data"]
+                payload_info = {
                     k: v
-                    for k, v in data["payload"]["ironic_object.data"].items()
-                    if k in ["provision_state", "power_state"]
+                    for k, v in ironic_data.items()
+                    if k in ["name", "provision_state", "power_state"]
                 }
-            )
-        )
+            elif service_type in ["compute", "nova"] and "nova_object.data" in payload:
+                nova_data = payload["nova_object.data"]
+                payload_info = {
+                    k: v
+                    for k, v in nova_data.items()
+                    if k in ["uuid", "host", "state", "task_state"]
+                }
+            elif service_type in ["network", "neutron"]:
+                # Neutron events might have different structures
+                payload_info = {"service": "neutron"}
+            else:
+                # Generic payload info
+                payload_info = {"service": service_type}
+
+        logger.debug(f"{event_type}: {payload_info}")
+        logger.info(f"Received {service_type} event: {event_type}")
+
+        # Send event to WebSocket clients via event bridge
+        if self.event_bridge:
+            try:
+                logger.debug(f"Forwarding event to WebSocket via bridge: {event_type}")
+                self.event_bridge.add_event(data["event_type"], data["payload"])
+                logger.debug(f"Successfully forwarded event to bridge: {event_type}")
+            except Exception as e:
+                logger.error(f"Error forwarding event to bridge: {e}")
+                logger.error(
+                    f"Event data was: {data['event_type']} - {data.get('payload', {}).get('ironic_object.data', {}).get('name', 'unknown')}"
+                )
 
         if self.osism_api_session:
             tries = 1

osism/services/websocket_manager.py

@@ -0,0 +1,271 @@
+# SPDX-License-Identifier: Apache-2.0
+
+import asyncio
+import json
+import logging
+from datetime import datetime
+from typing import Dict, Any, Optional, List
+from uuid import uuid4
+
+from fastapi import WebSocket, WebSocketDisconnect
+
+logger = logging.getLogger("osism.websocket")
+
+
+class EventMessage:
+    """Represents an event message for WebSocket streaming."""
+
+    def __init__(
+        self,
+        event_type: str,
+        source: str,
+        data: Dict[str, Any],
+        node_name: Optional[str] = None,
+    ):
+        self.id = str(uuid4())
+        self.timestamp = datetime.utcnow().isoformat() + "Z"
+        self.event_type = event_type
+        self.source = source
+        self.node_name = node_name
+        self.data = data
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert event message to dictionary for JSON serialization."""
+        return {
+            "id": self.id,
+            "timestamp": self.timestamp,
+            "event_type": self.event_type,
+            "source": self.source,
+            "node_name": self.node_name,
+            "data": self.data,
+        }
+
+    def to_json(self) -> str:
+        """Convert event message to JSON string."""
+        return json.dumps(self.to_dict())
+
+
+class WebSocketConnection:
+    """Represents a WebSocket connection with filtering options."""
+
+    def __init__(self, websocket: WebSocket):
+        self.websocket = websocket
+        self.event_filters: List[str] = []  # List of event types to filter
+        self.node_filters: List[str] = []  # List of node names to filter
+        self.service_filters: List[str] = []  # List of service types to filter
+
+    def matches_filters(self, event: "EventMessage") -> bool:
+        """Check if event matches this connection's filters."""
+        # If no filters are set, pass all events
+        if (
+            not self.event_filters
+            and not self.node_filters
+            and not self.service_filters
+        ):
+            return True
+
+        # Check event type filters
+        event_match = not self.event_filters or event.event_type in self.event_filters
+
+        # Check node filters
+        node_match = not self.node_filters or (
+            event.node_name is not None and event.node_name in self.node_filters
+        )
+
+        # Check service filters
+        service_type = event.event_type.split(".")[0] if event.event_type else "unknown"
+        service_match = not self.service_filters or service_type in self.service_filters
+
+        return event_match and node_match and service_match
+
+
+class WebSocketManager:
+    """Manages WebSocket connections and event broadcasting."""
+
+    def __init__(self):
+        # Store active WebSocket connections with filtering support
+        self.connections: Dict[WebSocket, WebSocketConnection] = {}
+        # Event queue for broadcasting
+        self.event_queue: asyncio.Queue = asyncio.Queue()
+        # Background task for event broadcasting
+        self._broadcaster_task: Optional[asyncio.Task] = None
+        # Lock for thread-safe operations
+        self._lock = asyncio.Lock()
+
+    async def connect(self, websocket: WebSocket) -> None:
+        """Accept a new WebSocket connection."""
+        await websocket.accept()
+        async with self._lock:
+            self.connections[websocket] = WebSocketConnection(websocket)
+        logger.info(f"WebSocket connected. Total connections: {len(self.connections)}")
+
+        # Start broadcaster if this is the first connection
+        if not self._broadcaster_task or self._broadcaster_task.done():
+            self._broadcaster_task = asyncio.create_task(self._broadcast_events())
+
+    async def disconnect(self, websocket: WebSocket) -> None:
+        """Remove a WebSocket connection."""
+        async with self._lock:
+            self.connections.pop(websocket, None)
+        logger.info(
+            f"WebSocket disconnected. Total connections: {len(self.connections)}"
+        )
+
+    async def update_filters(
+        self,
+        websocket: WebSocket,
+        event_filters: Optional[List[str]] = None,
+        node_filters: Optional[List[str]] = None,
+        service_filters: Optional[List[str]] = None,
+    ) -> None:
+        """Update filters for a specific WebSocket connection."""
+        async with self._lock:
+            if websocket in self.connections:
+                connection = self.connections[websocket]
+                if event_filters is not None:
+                    connection.event_filters = event_filters
+                if node_filters is not None:
+                    connection.node_filters = node_filters
+                if service_filters is not None:
+                    connection.service_filters = service_filters
+                logger.debug(
+                    f"Updated filters for WebSocket: events={connection.event_filters}, "
+                    f"nodes={connection.node_filters}, services={connection.service_filters}"
+                )
+
+    async def add_event(self, event: EventMessage) -> None:
+        """Add an event to the broadcast queue."""
+        await self.event_queue.put(event)
+
+    async def broadcast_event_from_notification(
+        self, event_type: str, payload: Dict[str, Any]
+    ) -> None:
+        """Create and broadcast an event from RabbitMQ notification."""
+        try:
+            logger.info(f"Processing event for WebSocket broadcast: {event_type}")
+            logger.debug(f"Active WebSocket connections: {len(self.connections)}")
+
+            # Extract relevant identifiers from different service types
+            node_name = None
+            resource_id = None
+            service_type = event_type.split(".")[0] if event_type else "unknown"
+
+            # Extract identifiers based on service type
+            if service_type == "baremetal" and "ironic_object.data" in payload:
+                ironic_data = payload["ironic_object.data"]
+                node_name = ironic_data.get("name")
+                resource_id = ironic_data.get("uuid")
+            elif service_type in ["compute", "nova"] and "nova_object.data" in payload:
+                nova_data = payload["nova_object.data"]
+                node_name = nova_data.get("host") or nova_data.get("name")
+                resource_id = nova_data.get("uuid")
+            elif service_type in ["network", "neutron"]:
+                # Neutron events may have different payload structures
+                if "neutron_object.data" in payload:
+                    neutron_data = payload["neutron_object.data"]
+                    resource_id = neutron_data.get("id") or neutron_data.get("uuid")
+                    node_name = neutron_data.get("name") or neutron_data.get(
+                        "device_id"
+                    )
+            elif service_type == "volume" and "cinder_object.data" in payload:
+                cinder_data = payload["cinder_object.data"]
+                resource_id = cinder_data.get("id") or cinder_data.get("uuid")
+                node_name = cinder_data.get("name") or cinder_data.get("display_name")
+            elif service_type == "image" and "glance_object.data" in payload:
+                glance_data = payload["glance_object.data"]
+                resource_id = glance_data.get("id") or glance_data.get("uuid")
+                node_name = glance_data.get("name")
+            elif service_type == "identity" and "keystone_object.data" in payload:
+                keystone_data = payload["keystone_object.data"]
+                resource_id = keystone_data.get("id") or keystone_data.get("uuid")
+                node_name = keystone_data.get("name")
+
+            # Create event message with enhanced metadata
+            event_data = payload.copy()
+            event_data["service_type"] = service_type
+            event_data["resource_id"] = resource_id
+
+            event = EventMessage(
+                event_type=event_type,
+                source="openstack",
+                data=event_data,
+                node_name=node_name,
+            )
+
+            await self.add_event(event)
+            logger.info(
+                f"Added {service_type} event to WebSocket queue: {event_type} for resource {node_name or resource_id}"
+            )
+            logger.debug(f"Event queue size: {self.event_queue.qsize()}")
+
+        except Exception as e:
+            logger.error(f"Error creating event from notification: {e}")
+
+    async def _broadcast_events(self) -> None:
+        """Background task to broadcast events to all connected clients."""
+        logger.info("Starting WebSocket event broadcaster")
+
+        while True:
+            try:
+                # Wait for an event
+                event = await self.event_queue.get()
+
+                if not self.connections:
+                    # No connections, skip broadcasting
+                    continue
+
+                # Broadcast to filtered connections
+                message = event.to_json()
+                disconnected_connections = set()
+                sent_count = 0
+
+                async with self._lock:
+                    connections_copy = dict(self.connections)
+
+                for websocket, connection in connections_copy.items():
+                    try:
+                        # Check if event matches connection filters
+                        if connection.matches_filters(event):
+                            await websocket.send_text(message)
+                            sent_count += 1
+                    except WebSocketDisconnect:
+                        disconnected_connections.add(websocket)
+                    except Exception as e:
+                        logger.error(f"Error sending message to WebSocket: {e}")
+                        disconnected_connections.add(websocket)
+
+                # Remove disconnected connections
+                if disconnected_connections:
+                    async with self._lock:
+                        for websocket in disconnected_connections:
+                            self.connections.pop(websocket, None)
+                    logger.info(
+                        f"Removed {len(disconnected_connections)} disconnected WebSocket(s). "
+                        f"Active connections: {len(self.connections)}"
+                    )
+
+                logger.info(
+                    f"Broadcasted event {event.event_type} to {sent_count}/{len(self.connections)} connection(s)"
+                )
+
+            except asyncio.CancelledError:
+                logger.info("WebSocket broadcaster task cancelled")
+                break
+            except Exception as e:
+                logger.error(f"Error in WebSocket broadcaster: {e}")
+                # Continue broadcasting even if there's an error
+
+    async def send_heartbeat(self) -> None:
+        """Send heartbeat to all connected clients."""
+        if not self.connections:
+            return
+
+        heartbeat_event = EventMessage(
+            event_type="heartbeat", source="osism", data={"message": "ping"}
+        )
+
+        await self.add_event(heartbeat_event)
+
+
+# Global WebSocket manager instance
+websocket_manager = WebSocketManager()

osism/tasks/openstack.py

@@ -84,20 +84,21 @@ def get_baremetal_nodes():
     # Convert generator to list and extract relevant fields
     node_list = []
     for node in nodes:
+        # OpenStack SDK returns Resource objects, not dicts - use attribute access
         node_info = {
-            "uuid": node.get("uuid"),
-            "name": node.get("name"),
-            "power_state": node.get("power_state"),
-            "provision_state": node.get("provision_state"),
-            "maintenance": node.get("maintenance"),
-            "instance_uuid": node.get("instance_uuid"),
-            "driver": node.get("driver"),
-            "resource_class": node.get("resource_class"),
-            "properties": node.get("properties", {}),
-            "extra": node.get("extra", {}),
-            "last_error": node.get("last_error"),
-            "created_at": node.get("created_at"),
-            "updated_at": node.get("updated_at"),
+            "uuid": getattr(node, "uuid", None) or getattr(node, "id", None),
+            "name": getattr(node, "name", None),
+            "power_state": getattr(node, "power_state", None),
+            "provision_state": getattr(node, "provision_state", None),
+            "maintenance": getattr(node, "maintenance", None),
+            "instance_uuid": getattr(node, "instance_uuid", None),
+            "driver": getattr(node, "driver", None),
+            "resource_class": getattr(node, "resource_class", None),
+            "properties": getattr(node, "properties", {}),
+            "extra": getattr(node, "extra", {}),
+            "last_error": getattr(node, "last_error", None),
+            "created_at": getattr(node, "created_at", None),
+            "updated_at": getattr(node, "updated_at", None),
         }
         node_list.append(node_info)
 

{osism-0.20250823.0.dist-info → osism-0.20250824.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: osism
-Version: 0.20250823.0
+Version: 0.20250824.1
 Summary: OSISM manager interface
 Home-page: https://github.com/osism/python-osism
 Author: OSISM GmbH
@@ -56,6 +56,7 @@ Requires-Dist: transitions==0.9.3
 Requires-Dist: uvicorn[standard]==0.35.0
 Requires-Dist: validators==0.35.0
 Requires-Dist: watchdog==6.0.0
+Requires-Dist: websockets==15.0.1
 Provides-Extra: ansible
 Requires-Dist: ansible-runner==2.4.1; extra == "ansible"
 Requires-Dist: ansible-core==2.19.0; extra == "ansible"

{osism-0.20250823.0.dist-info → osism-0.20250824.1.dist-info}/RECORD

@@ -1,6 +1,6 @@
 osism/__init__.py,sha256=1UiNTBus0V0f2AbZQzAtVtu6zkfCCrw0OTq--NwFAqY,341
 osism/__main__.py,sha256=ILe4gu61xEISiBsxanqTQIdSkV-YhpZXTRlguCYyssk,141
-osism/api.py,sha256=hhRgBswe3Tem6eTMor54PttNhBhAts2AEDBsxQfqRyU,13363
+osism/api.py,sha256=wVPLhPPdBcFx6vss5pX1Y2JxbaNSMh_Bqo4AB529QWI,16945
 osism/main.py,sha256=Dt2-9sLXcS-Ny4DAz7hrha-KRc7zd7BFUTRdfs_X8z4,893
 osism/settings.py,sha256=VZT1muZVYWM5Ov1eFRC7a4ZGYIdI2AFmudCm0wZ1C2Q,1898
 osism/commands/__init__.py,sha256=Ag4wX_DCgXRdoLn6t069jqb3DdRylsX2nyYkiyCx4uk,456
@@ -34,7 +34,9 @@ osism/data/__init__.py,sha256=izXdh0J3vPLQI7kBhJI7ibJQzPqU_nlONP0L4Cf_k6A,1504
 osism/data/enums.py,sha256=gItIjOK6xWuOZSkMxpMdYLRyt4ezyhzkqA7BGiah2o0,10030
 osism/data/playbooks.py,sha256=M3T3ajV-8Lt-orsRO3jAoukhaoYFr4EZ2dzYXQjt1kg,728
 osism/services/__init__.py,sha256=bG7Ffen4LvQtgnYPFEpFccsWs81t4zqqeqn9ZeirH6E,38
-osism/services/listener.py,sha256=Vf8LOZkHzlspm40BZ1az3o1O_ar34_i6C83p-D8KzzM,9783
+osism/services/event_bridge.py,sha256=roV90o9UgTnwoVbXnPR3muBk04IriVYCO_fewZ46Mq8,12016
+osism/services/listener.py,sha256=O8Xq5fEEVoNFIgFPE7GqfVqx6C4QkdWhUPUGzODFnws,14211
+osism/services/websocket_manager.py,sha256=F147kWOg8PAvbVG4aVYQVtK4mFMfPVtHxxYJXaqiAjg,11051
 osism/tasks/__init__.py,sha256=iAUs-ttUMw1nZElL631sT1ke29RvTjQjlhWPl_kGrEw,9003
 osism/tasks/ansible.py,sha256=-gUe6uZFhPLI3DGZHlpQlghuDKpp4Drn5IEctlV6Sv8,1300
 osism/tasks/ceph.py,sha256=eIQkah3Kj4INtOkF9kTjHbXJ3_J2lg48EWJKfHc-UYw,615
@@ -42,7 +44,7 @@ osism/tasks/conductor.py,sha256=WBLsoPtr0iGUzRGERs0Xt7CMYrnHQVEwNV9qXBssI3s,274
 osism/tasks/kolla.py,sha256=wJQpWn_01iWLkr7l7T7RNrQGfRgsgmYi4WQlTmNGvew,618
 osism/tasks/kubernetes.py,sha256=VzXq_VrYU_CLm4cOruqnE3Kq2ydfO9glZ3p0bp3OYoc,625
 osism/tasks/netbox.py,sha256=QGQGz3s0V8WvPvhEJWwo0H24aLFaZrSl-voN-axzRwY,5846
-osism/tasks/openstack.py,sha256=VeNfEcv4JHx_oJxpAb2QO2adlk--hlSqo_2iVQbOtpE,7142
+osism/tasks/openstack.py,sha256=v9kkwKIr9nsedUgSQYSDW0kZBAGoE9MjKithXXeRm_I,7385
 osism/tasks/reconciler.py,sha256=PnGWfvfmomzbgddvyCdxul-z5ZLXxWAmrQyRCN874-s,1958
 osism/tasks/conductor/__init__.py,sha256=eAiaM69sVbTTDam7gCLyjF7wBCt7rd__pRFu7VdY-f8,1930
 osism/tasks/conductor/config.py,sha256=n1H9_8DY90p5E4mygzKyJUl8G3WdDuGHFTp-SrmZmgU,4543
@@ -62,11 +64,11 @@ osism/tasks/conductor/sonic/interface.py,sha256=M876LHdFqGxUfTizzDusdzvCkDI0vCgq
 osism/tasks/conductor/sonic/sync.py,sha256=fpgsQVwq6Hb7eeDHhLkAqx5BkaK3Ce_m_WvmWEsJyOo,9182
 osism/utils/__init__.py,sha256=370UHVU5BFy-1wDAxBFaRjSA-zR0KNadJPWQ6zcYRf0,7806
 osism/utils/ssh.py,sha256=nxeEgwjJWvQCybKDp-NelMeWyODCYpaXFCBchAv4-bg,8691
-osism-0.20250823.0.dist-info/licenses/AUTHORS,sha256=EKFIR9F27AvoEXp1cA6FkGbjEOFt4Rcbipr5RJc7jSs,64
-osism-0.20250823.0.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-osism-0.20250823.0.dist-info/METADATA,sha256=ZwWM7UZEXo9p5LSTB5v65qa2aEt3o7UOi7LNSrjkBXE,2937
-osism-0.20250823.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-osism-0.20250823.0.dist-info/entry_points.txt,sha256=h9YS3gfPc5ueU9ZXtCc60e8p4NQEuvtIH_zE0cfVqy0,4439
-osism-0.20250823.0.dist-info/pbr.json,sha256=t633u2SKCZHSfZL7F8jKzAb9107KiG9OydBqGXdZPNQ,47
-osism-0.20250823.0.dist-info/top_level.txt,sha256=8L8dsI9hcaGHsdnR4k_LN9EM78EhwrXRFHyAryPXZtY,6
-osism-0.20250823.0.dist-info/RECORD,,
+osism-0.20250824.1.dist-info/licenses/AUTHORS,sha256=oWotd63qsnNR945QLJP9mEXaXNtCMaesfo8ZNuLjwpU,39
+osism-0.20250824.1.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+osism-0.20250824.1.dist-info/METADATA,sha256=euXrln8TtOYB_fMaByv11BY0sNMaN3mjtSt_IYMvevA,2971
+osism-0.20250824.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+osism-0.20250824.1.dist-info/entry_points.txt,sha256=h9YS3gfPc5ueU9ZXtCc60e8p4NQEuvtIH_zE0cfVqy0,4439
+osism-0.20250824.1.dist-info/pbr.json,sha256=9hAzFUnge6s4hnmBQ2eKo9TQlUJoLcBNpoC0DfrZRjo,47
+osism-0.20250824.1.dist-info/top_level.txt,sha256=8L8dsI9hcaGHsdnR4k_LN9EM78EhwrXRFHyAryPXZtY,6
+osism-0.20250824.1.dist-info/RECORD,,

osism-0.20250824.1.dist-info/licenses/AUTHORS

@@ -0,0 +1 @@
+Christian Berendt <berendt@osism.tech>

osism-0.20250824.1.dist-info/pbr.json

@@ -0,0 +1 @@
+{"git_version": "2d93840", "is_release": false}

osism-0.20250823.0.dist-info/licenses/AUTHORS

@@ -1 +0,0 @@
-renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

osism-0.20250823.0.dist-info/pbr.json

@@ -1 +0,0 @@
-{"git_version": "eaafb18", "is_release": false}