osism 0.20250804.0__py3-none-any.whl → 0.20250824.0__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
+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,12 +119,46 @@ 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")
     device: Optional[str] = Field(None, description="Device name if found")
 
 
+class BaremetalNode(BaseModel):
+    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: Optional[bool] = Field(
+        None, description="Whether node is in maintenance mode"
+    )
+    instance_uuid: Optional[str] = Field(
+        None, description="UUID of associated instance"
+    )
+    driver: Optional[str] = Field(None, description="Driver used for the node")
+    resource_class: Optional[str] = Field(
+        None, description="Resource class of the node"
+    )
+    properties: Dict[str, Any] = Field(
+        default_factory=dict, description="Node properties"
+    )
+    extra: Dict[str, Any] = Field(
+        default_factory=dict, description="Extra node information"
+    )
+    last_error: Optional[str] = Field(None, description="Last error message")
+    created_at: Optional[str] = Field(None, description="Creation timestamp")
+    updated_at: Optional[str] = Field(None, description="Last update timestamp")
+
+
+class BaremetalNodesResponse(BaseModel):
+    nodes: list[BaremetalNode] = Field(..., description="List of baremetal nodes")
+    count: int = Field(..., description="Total number of nodes")
+
+
 def find_device_by_identifier(identifier: str):
     """Find a device in NetBox by various identifiers."""
     if not utils.nb:
@@ -148,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")
 
@@ -188,6 +248,31 @@ async def write_sink_events(request: Request) -> SinkResponse:
         )
 
 
+@app.get(
+    "/v1/baremetal/nodes", response_model=BaremetalNodesResponse, tags=["baremetal"]
+)
+async def get_baremetal_nodes_list() -> BaremetalNodesResponse:
+    """Get list of all baremetal nodes managed by Ironic.
+
+    Returns information similar to the 'baremetal list' command,
+    including node details, power state, provision state, and more.
+    """
+    try:
+        # Use the generalized function to get baremetal nodes
+        nodes_data = openstack.get_baremetal_nodes()
+
+        # Convert to response model
+        nodes = [BaremetalNode(**node) for node in nodes_data]
+
+        return BaremetalNodesResponse(nodes=nodes, count=len(nodes))
+    except Exception as e:
+        logger.error(f"Error retrieving baremetal nodes: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to retrieve baremetal nodes: {str(e)}",
+        )
+
+
 @app.post("/v1/notifications/baremetal", status_code=204, tags=["notifications"])
 async def notifications_baremetal(notification: NotificationBaremetal) -> None:
     """Handle baremetal notifications."""
@@ -294,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/commands/baremetal.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from cliff.command import Command
+from argparse import BooleanOptionalAction
 
 import tempfile
 import os
@@ -533,3 +534,170 @@ class BaremetalPing(Command):
         except Exception as e:
             logger.error(f"Error during ping operation: {e}")
             return
+
+
+class BaremetalBurnIn(Command):
+    def get_parser(self, prog_name):
+        parser = super(BaremetalBurnIn, self).get_parser(prog_name)
+
+        parser.add_argument(
+            "name",
+            nargs="?",
+            type=str,
+            help="Run burn-in on given baremetal node when in provision state available",
+        )
+        parser.add_argument(
+            "--all",
+            default=False,
+            help="Run burn-in on all baremetal nodes in provision state available",
+            action="store_true",
+        )
+        parser.add_argument(
+            "--cpu",
+            default=True,
+            help="Enable CPU burn-in",
+            action=BooleanOptionalAction,
+        )
+        parser.add_argument(
+            "--memory",
+            default=True,
+            help="Enable memory burn-in",
+            action=BooleanOptionalAction,
+        )
+        parser.add_argument(
+            "--disk",
+            default=True,
+            help="Enable disk burn-in",
+            action=BooleanOptionalAction,
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        all_nodes = parsed_args.all
+        name = parsed_args.name
+
+        stressor = {}
+        stressor["cpu"] = parsed_args.cpu
+        stressor["memory"] = parsed_args.memory
+        stressor["disk"] = parsed_args.disk
+
+        if not all_nodes and not name:
+            logger.error("Please specify a node name or use --all")
+            return
+
+        clean_steps = []
+        for step, activated in stressor.items():
+            if activated:
+                clean_steps.append({"step": "burnin_" + step, "interface": "deploy"})
+        if not clean_steps:
+            logger.error(
+                f"Please specify at least one of {', '.join(stressor.keys())} for burn-in"
+            )
+            return
+
+        conn = get_cloud_connection()
+
+        if all_nodes:
+            burn_in_nodes = list(conn.baremetal.nodes(details=True))
+        else:
+            node = conn.baremetal.find_node(name, ignore_missing=True, details=True)
+            if not node:
+                logger.warning(f"Could not find node {name}")
+                return
+            burn_in_nodes = [node]
+
+        for node in burn_in_nodes:
+            if not node:
+                continue
+
+            if node.provision_state in ["available"]:
+                # NOTE: Burn-In is available in the "manageable" provision state, so we move the node into this state
+                try:
+                    node = conn.baremetal.set_node_provision_state(node.id, "manage")
+                    node = conn.baremetal.wait_for_nodes_provision_state(
+                        [node.id], "manageable"
+                    )[0]
+                except Exception as exc:
+                    logger.warning(
+                        f"Node {node.name} ({node.id}) could not be moved to manageable state: {exc}"
+                    )
+                    continue
+
+            if node.provision_state in ["manageable"]:
+                try:
+                    conn.baremetal.set_node_provision_state(
+                        node.id, "clean", clean_steps=clean_steps
+                    )
+                except Exception as exc:
+                    logger.warning(
+                        f"Burn-In of node {node.name} ({node.id}) failed: {exc}"
+                    )
+                    continue
+            else:
+                logger.warning(
+                    f"Node {node.name} ({node.id}) not in supported state! Provision state: {node.provision_state}, maintenance mode: {node['maintenance']}"
+                )
+                continue
+
+
+class BaremetalMaintenanceSet(Command):
+    def get_parser(self, prog_name):
+        parser = super(BaremetalMaintenanceSet, self).get_parser(prog_name)
+
+        parser.add_argument(
+            "name",
+            nargs="?",
+            type=str,
+            help="Set maintenance on given baremetal node",
+        )
+        parser.add_argument(
+            "--reason",
+            default=None,
+            type=str,
+            help="Reason for maintenance",
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        name = parsed_args.name
+        reason = parsed_args.reason
+
+        conn = get_cloud_connection()
+        node = conn.baremetal.find_node(name, ignore_missing=True, details=True)
+        if not node:
+            logger.warning(f"Could not find node {name}")
+            return
+        try:
+            conn.baremetal.set_node_maintenance(node, reason=reason)
+        except Exception as exc:
+            logger.error(
+                f"Setting maintenance mode on node {node.name} ({node.id}) failed: {exc}"
+            )
+
+
+class BaremetalMaintenanceUnset(Command):
+    def get_parser(self, prog_name):
+        parser = super(BaremetalMaintenanceUnset, self).get_parser(prog_name)
+
+        parser.add_argument(
+            "name",
+            nargs="?",
+            type=str,
+            help="Unset maintenance on given baremetal node",
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        name = parsed_args.name
+
+        conn = get_cloud_connection()
+        node = conn.baremetal.find_node(name, ignore_missing=True, details=True)
+        if not node:
+            logger.warning(f"Could not find node {name}")
+            return
+        try:
+            conn.baremetal.unset_node_maintenance(node)
+        except Exception as exc:
+            logger.error(
+                f"Unsetting maintenance mode on node {node.name} ({node.id}) failed: {exc}"
+            )

osism/commands/netbox.py

@@ -228,9 +228,9 @@ class Console(Command):
         if not os.path.exists(nbcli_file):
             try:
                 with open("/run/secrets/NETBOX_TOKEN", "r") as fp:
-                    token = fp.read().strip()
+                    token = str(fp.read().strip())
             except FileNotFoundError:
-                token = None
+                token = ""
 
             url = os.environ.get("NETBOX_API", None)