osism 0.20250627.0__py3-none-any.whl → 0.20250701.0__py3-none-any.whl

osism/api.py

@@ -3,10 +3,11 @@
 import datetime
 from logging.config import dictConfig
 import logging
+from typing import Optional, Dict, Any
 from uuid import UUID
 
-from fastapi import FastAPI, Header, Request, Response
-from pydantic import BaseModel
+from fastapi import FastAPI, Header, Request, Response, HTTPException, status
+from pydantic import BaseModel, Field
 from starlette.middleware.cors import CORSMiddleware
 
 from osism.tasks import reconciler
@@ -15,186 +16,311 @@ from osism.services.listener import BaremetalEvents
 
 
 class NotificationBaremetal(BaseModel):
-    priority: str
-    event_type: str
-    timestamp: str
-    publisher_id: str
-    message_id: UUID
-    payload: dict
+    priority: str = Field(..., description="Notification priority level")
+    event_type: str = Field(..., description="Type of the event")
+    timestamp: str = Field(..., description="Event timestamp")
+    publisher_id: str = Field(..., description="ID of the event publisher")
+    message_id: UUID = Field(..., description="Unique message identifier")
+    payload: Dict[str, Any] = Field(..., description="Event payload data")
 
 
 class WebhookNetboxResponse(BaseModel):
-    result: str
+    result: str = Field(..., description="Operation result status")
 
 
 class WebhookNetboxData(BaseModel):
-    username: str
-    data: dict
-    snapshots: dict
-    event: str
-    timestamp: datetime.datetime
-    model: str
-    request_id: UUID
+    username: str = Field(..., description="Username triggering the webhook")
+    data: Dict[str, Any] = Field(..., description="Webhook data payload")
+    snapshots: Dict[str, Any] = Field(..., description="Data snapshots")
+    event: str = Field(..., description="Event type")
+    timestamp: datetime.datetime = Field(..., description="Event timestamp")
+    model: str = Field(..., description="Model type")
+    request_id: UUID = Field(..., description="Unique request identifier")
 
 
-# https://stackoverflow.com/questions/63510041/adding-python-logging-to-fastapi-endpoints-hosted-on-docker-doesnt-display-api
 class LogConfig(BaseModel):
-    """Logging configuration to be set for the server"""
+    """Logging configuration for the OSISM API server."""
 
     LOGGER_NAME: str = "osism"
-    LOG_FORMAT: str = "%(levelprefix)s | %(asctime)s | %(message)s"
-    LOG_LEVEL: str = "DEBUG"
+    LOG_FORMAT: str = "%(levelname)s | %(asctime)s | %(name)s | %(message)s"
+    LOG_LEVEL: str = "INFO"
 
     # Logging config
     version: int = 1
     disable_existing_loggers: bool = False
-    formatters: dict = {
+    formatters: Dict[str, Any] = {
         "default": {
-            "()": "uvicorn.logging.DefaultFormatter",
-            "fmt": LOG_FORMAT,
+            "format": LOG_FORMAT,
             "datefmt": "%Y-%m-%d %H:%M:%S",
         },
     }
-    handlers: dict = {
+    handlers: Dict[str, Any] = {
         "default": {
             "formatter": "default",
             "class": "logging.StreamHandler",
             "stream": "ext://sys.stderr",
         },
     }
-    loggers: dict = {
-        "api": {"handlers": ["default"], "level": LOG_LEVEL},
+    loggers: Dict[str, Any] = {
+        "osism": {"handlers": ["default"], "level": LOG_LEVEL, "propagate": False},
+        "api": {"handlers": ["default"], "level": LOG_LEVEL, "propagate": False},
+        "uvicorn": {"handlers": ["default"], "level": "INFO", "propagate": False},
+        "uvicorn.error": {"handlers": ["default"], "level": "INFO", "propagate": False},
+        "uvicorn.access": {
+            "handlers": ["default"],
+            "level": "INFO",
+            "propagate": False,
+        },
     }
 
 
-app = FastAPI()
-
-app.add_middleware(CORSMiddleware)
-
-dictConfig(LogConfig().dict())
-logger = logging.getLogger("api")
+app = FastAPI(
+    title="OSISM API",
+    description="API for OpenStack Infrastructure & Service Manager",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc",
+)
+
+# Configure CORS - in production, replace with specific origins
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # TODO: Replace with actual allowed origins in production
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+    allow_headers=[
+        "Accept",
+        "Accept-Language",
+        "Content-Language",
+        "Content-Type",
+        "Authorization",
+        "X-Hook-Signature",
+    ],
+)
+
+dictConfig(LogConfig().model_dump())
+logger = logging.getLogger("osism.api")
 
 baremetal_events = BaremetalEvents()
 
 
-@app.get("/")
-async def root():
-    return {"result": "ok"}
-
-
-@app.get("/v1")
-async def v1():
-    return {"result": "ok"}
-
-
-@app.post("/v1/meters/sink")
-async def write_sink_meters(request: Request):
-    data = await request.json()
-
-
-@app.post("/v1/events/sink")
-async def write_sink_events(request: Request):
-    data = await request.json()
-
-
-@app.post("/v1/notifications/baremetal", status_code=204)
-async def notifications_baremetal(notification: NotificationBaremetal) -> None:
-
-    handler = baremetal_events.get_handler(notification.event_type)
-    handler(notification.payload)
+class DeviceSearchResult(BaseModel):
+    result: str = Field(..., description="Operation result status")
+    device: Optional[str] = Field(None, description="Device name if found")
 
 
-@app.post("/v1/switches/{identifier}/ztp/complete")
-async def switches_ztp_complete(identifier: str):
+def find_device_by_identifier(identifier: str):
+    """Find a device in NetBox by various identifiers."""
     if not utils.nb:
-        return {"result": "netbox not enabled"}
+        return None
 
     device = None
 
     # Search by device name
     devices = utils.nb.dcim.devices.filter(name=identifier)
     if devices:
-        device = devices[0]
+        device = list(devices)[0]
 
     # Search by inventory_hostname custom field
     if not device:
         devices = utils.nb.dcim.devices.filter(cf_inventory_hostname=identifier)
         if devices:
-            device = devices[0]
+            device = list(devices)[0]
 
     # Search by serial number
     if not device:
         devices = utils.nb.dcim.devices.filter(serial=identifier)
         if devices:
-            device = devices[0]
+            device = list(devices)[0]
 
-    if device:
+    return device
+
+
+@app.get("/", tags=["health"])
+async def root() -> Dict[str, str]:
+    """Health check endpoint."""
+    return {"result": "ok"}
+
+
+@app.get("/v1", tags=["health"])
+async def v1() -> Dict[str, str]:
+    """API version 1 health check endpoint."""
+    return {"result": "ok"}
+
+
+class SinkResponse(BaseModel):
+    result: str = Field(..., description="Operation result status")
+
+
+@app.post("/v1/meters/sink", response_model=SinkResponse, tags=["telemetry"])
+async def write_sink_meters(request: Request) -> SinkResponse:
+    """Write telemetry meters to sink."""
+    try:
+        data = await request.json()
+        # TODO: Implement meter processing logic
         logger.info(
-            f"Found device {device.name} for ZTP complete with identifier {identifier}"
+            f"Received meters data: {len(data) if isinstance(data, list) else 1} entries"
+        )
+        return SinkResponse(result="ok")
+    except Exception as e:
+        logger.error(f"Error processing meters: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to process meters data",
         )
 
-        # Set provision_state custom field to active
-        device.custom_fields["provision_state"] = "active"
-        device.save()
 
-        return {"result": "ok", "device": device.name}
+@app.post("/v1/events/sink", response_model=SinkResponse, tags=["telemetry"])
+async def write_sink_events(request: Request) -> SinkResponse:
+    """Write telemetry events to sink."""
+    try:
+        data = await request.json()
+        # TODO: Implement event processing logic
+        logger.info(
+            f"Received events data: {len(data) if isinstance(data, list) else 1} entries"
+        )
+        return SinkResponse(result="ok")
+    except Exception as e:
+        logger.error(f"Error processing events: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to process events data",
+        )
+
+
+@app.post("/v1/notifications/baremetal", status_code=204, tags=["notifications"])
+async def notifications_baremetal(notification: NotificationBaremetal) -> None:
+    """Handle baremetal notifications."""
+    try:
+        handler = baremetal_events.get_handler(notification.event_type)
+        handler(notification.payload)
+        logger.info(
+            f"Successfully processed baremetal notification: {notification.event_type}"
+        )
+    except Exception as e:
+        logger.error(f"Error processing baremetal notification: {str(e)}")
+        if isinstance(e, HTTPException):
+            raise
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to process baremetal notification",
+        )
+
+
+@app.post(
+    "/v1/switches/{identifier}/ztp/complete",
+    response_model=DeviceSearchResult,
+    tags=["switches"],
+)
+async def switches_ztp_complete(identifier: str) -> DeviceSearchResult:
+    """Mark a switch as ZTP complete by setting provision_state to active."""
+    if not utils.nb:
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="NetBox is not enabled",
+        )
+
+    try:
+        device = find_device_by_identifier(identifier)
+
+        if device:
+            logger.info(
+                f"Found device {device.name} for ZTP complete with identifier {identifier}"
+            )
+
+            # Set provision_state custom field to active
+            device.custom_fields["provision_state"] = "active"
+            device.save()
+
+            return DeviceSearchResult(result="ok", device=device.name)
+        else:
+            logger.warning(
+                f"No device found for ZTP complete with identifier {identifier}"
+            )
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Device not found with identifier: {identifier}",
+            )
+    except Exception as e:
+        logger.error(f"Error completing ZTP for device {identifier}: {str(e)}")
+        if isinstance(e, HTTPException):
+            raise
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to complete ZTP process",
+        )
+
+
+def process_netbox_webhook(webhook_input: WebhookNetboxData) -> None:
+    """Process NetBox webhook data."""
+    data = webhook_input.data
+    url = data["url"]
+    name = data["name"]
+
+    if "devices" in url:
+        tags = [x["name"] for x in data["tags"]]
+        custom_fields = data["custom_fields"]
+        device_type = custom_fields.get("device_type") or "node"
+
+    elif "interfaces" in url:
+        device_type = "interface"
+        device_id = data["device"]["id"]
+        device = utils.nb.dcim.devices.get(id=device_id)
+        tags = [str(x) for x in device.tags]
+        custom_fields = device.custom_fields
+    else:
+        logger.warning(f"Unknown webhook URL type: {url}")
+        return
+
+    if "Managed by OSISM" in tags:
+        if device_type == "server":
+            logger.info(
+                f"Handling change for managed device {name} of type {device_type}"
+            )
+            reconciler.run.delay()
+        elif device_type == "switch":
+            logger.info(
+                f"Handling change for managed device {name} of type {device_type}"
+            )
+            # TODO: Implement switch configuration generation
+            # netbox.generate.delay(name, custom_fields['configuration_template'])
+        elif device_type == "interface":
+            logger.info(
+                f"Handling change for interface {name} on managed device {device.name} of type {custom_fields['device_type']}"
+            )
+            # TODO: Implement interface configuration generation
+            # netbox.generate.delay(device.name, custom_fields['configuration_template'])
     else:
-        logger.warning(f"No device found for ZTP complete with identifier {identifier}")
-        return {"result": "device not found"}
+        logger.info(f"Ignoring change for unmanaged device {name}")
 
 
-@app.post("/v1/webhook/netbox", response_model=WebhookNetboxResponse, status_code=200)
+@app.post(
+    "/v1/webhook/netbox",
+    response_model=WebhookNetboxResponse,
+    status_code=200,
+    tags=["webhooks"],
+)
 async def webhook(
     webhook_input: WebhookNetboxData,
     request: Request,
     response: Response,
     content_length: int = Header(...),
-    x_hook_signature: str = Header(None),
-):
-    if utils.nb:
-        data = webhook_input.data
-        url = data["url"]
-        name = data["name"]
-
-        if "devices" in url:
-            tags = [x["name"] for x in data["tags"]]
-
-            custom_fields = data["custom_fields"]
-            device_type = custom_fields["device_type"]
-
-            # NOTE: device without a defined device_type are nodes
-            if not device_type:
-                device_type = "node"
-
-        elif "interfaces" in url:
-            device_type = "interface"
-
-            device_id = data["device"]["id"]
-            device = utils.nb.dcim.devices.get(id=device_id)
-            tags = [str(x) for x in device.tags]
-            custom_fields = device.custom_fields
-
-        if "Managed by OSISM" in tags:
-            if device_type == "server":
-                logger.info(
-                    f"Handling change for managed device {name} of type {device_type}"
-                )
-                reconciler.run.delay()
-            elif device_type == "switch":
-                logger.info(
-                    f"Handling change for managed device {name} of type {device_type}"
-                )
-                # netbox.generate.delay(name, custom_fields['configuration_template'])
-            elif device_type == "interface":
-                logger.info(
-                    f"Handling change for interface {name} on managed device {device.name} of type {custom_fields['device_type']}"
-                )
-                # netbox.generate.delay(device.name, custom_fields['configuration_template'])
-
-        else:
-            logger.info(f"Ignoring change for unmanaged device {name}")
-
-        return {"result": "ok"}
+    x_hook_signature: Optional[str] = Header(None),
+) -> WebhookNetboxResponse:
+    """Handle NetBox webhook notifications."""
+    if not utils.nb:
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="NetBox webhook processing is not enabled",
+        )
 
-    else:
-        return {"result": "webhook netbox not enabled"}
+    try:
+        # TODO: Validate webhook signature if x_hook_signature is provided
+        process_netbox_webhook(webhook_input)
+        return WebhookNetboxResponse(result="ok")
+    except Exception as e:
+        logger.error(f"Error processing NetBox webhook: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to process NetBox webhook",
+        )

osism/commands/apply.py

@@ -9,8 +9,8 @@ from cliff.command import Command
 from loguru import logger
 from tabulate import tabulate
 
-from osism.core import enums
-from osism.core.playbooks import MAP_ROLE2ENVIRONMENT, MAP_ROLE2RUNTIME
+from osism.data import enums
+from osism.data.playbooks import MAP_ROLE2ENVIRONMENT, MAP_ROLE2RUNTIME
 from osism.tasks import ansible, ceph, kolla, kubernetes, handle_task
 
 

osism/commands/baremetal.py

@@ -12,6 +12,7 @@ import yaml
 from openstack.baremetal import configdrive as configdrive_builder
 
 from osism.commands import get_cloud_connection
+from osism import utils
 
 
 class BaremetalList(Command):
@@ -169,16 +170,51 @@ class BaremetalDeploy(Command):
                 continue
             # NOTE: Prepare osism config drive
             try:
+                # Get default vars from NetBox local_context_data if available
+                default_vars = {}
+                if utils.nb:
+                    try:
+                        # Try to find device by name first
+                        device = utils.nb.dcim.devices.get(name=node.name)
+
+                        # If not found by name, try by inventory_hostname custom field
+                        if not device:
+                            devices = utils.nb.dcim.devices.filter(
+                                cf_inventory_hostname=node.name
+                            )
+                            if devices:
+                                device = devices[0]
+
+                        # Extract local_context_data if device found and has the field
+                        if (
+                            device
+                            and hasattr(device, "local_context_data")
+                            and device.local_context_data
+                        ):
+                            default_vars = device.local_context_data
+                            logger.info(
+                                f"Using NetBox local_context_data for node {node.name}"
+                            )
+                        else:
+                            logger.debug(
+                                f"No local_context_data found for node {node.name} in NetBox"
+                            )
+                    except Exception as e:
+                        logger.warning(
+                            f"Failed to fetch NetBox data for node {node.name}: {e}"
+                        )
+
                 playbook = []
                 play = {
                     "name": "Run bootstrap - part 2",
                     "hosts": "localhost",
                     "connection": "local",
                     "gather_facts": True,
-                    "vars": {},
+                    "vars": default_vars.copy(),
                     "roles": [
                         "osism.commons.hostname",
                         "osism.commons.hosts",
+                        "osism.commons.operator",
                     ],
                 }
                 play["vars"].update(
@@ -293,11 +329,6 @@ class BaremetalUndeploy(Command):
                         f"Node {node.name} ({node.id}) could not be moved to available state: {exc}"
                     )
                     continue
-                # NOTE: Ironic removes "instance_info" on undeploy. It was saved to "extra" during sync and needs to be refreshed here.
-                if "instance_info" in node["extra"]:
-                    node = conn.baremetal.update_node(
-                        node, instance_info=json.loads(node.extra["instance_info"])
-                    )
             else:
                 logger.warning(
                     f"Node {node.name} ({node.id}) not in supported provision state"