osism 0.20250326.0__py3-none-any.whl → 0.20250407.0__py3-none-any.whl

osism/api.py

@@ -11,7 +11,7 @@ import pynetbox
 from starlette.middleware.cors import CORSMiddleware
 
 from osism.tasks import reconciler
-from osism import settings
+from osism import settings, utils
 from osism.services.listener import BaremetalEvents
 
 
@@ -75,16 +75,13 @@ app.add_middleware(CORSMiddleware)
 dictConfig(LogConfig().dict())
 logger = logging.getLogger("api")
 
-nb = None
 baremetal_events = BaremetalEvents()
 
 
 @app.on_event("startup")
 async def startup_event():
-    global nb
-
     if settings.NETBOX_URL and settings.NETBOX_TOKEN:
-        nb = pynetbox.api(settings.NETBOX_URL, token=settings.NETBOX_TOKEN)
+        utils.nb = pynetbox.api(settings.NETBOX_URL, token=settings.NETBOX_TOKEN)
 
         if settings.IGNORE_SSL_ERRORS:
             import requests
@@ -92,7 +89,7 @@ async def startup_event():
             requests.packages.urllib3.disable_warnings()
             session = requests.Session()
             session.verify = False
-            nb.http_session = session
+            utils.nb.http_session = session
 
 
 @app.get("/")
@@ -125,9 +122,7 @@ async def webhook(
     content_length: int = Header(...),
     x_hook_signature: str = Header(None),
 ):
-    global nb
-
-    if nb:
+    if utils.nb:
         data = webhook_input.data
         url = data["url"]
         name = data["name"]
@@ -146,7 +141,7 @@ async def webhook(
             device_type = "interface"
 
             device_id = data["device"]["id"]
-            device = nb.dcim.devices.get(id=device_id)
+            device = utils.nb.dcim.devices.get(id=device_id)
             tags = [str(x) for x in device.tags]
             custom_fields = device.custom_fields
 

osism/commands/manage.py

@@ -12,7 +12,7 @@ import requests
 from osism.data import TEMPLATE_IMAGE_CLUSTERAPI, TEMPLATE_IMAGE_OCTAVIA
 from osism.tasks import openstack, handle_task
 
-SUPPORTED_CLUSTERAPI_K8S_IMAGES = ["1.29", "1.30", "1.31"]
+SUPPORTED_CLUSTERAPI_K8S_IMAGES = ["1.30", "1.31", "1.32"]
 
 
 class ImageClusterapi(Command):
@@ -51,7 +51,7 @@ class ImageClusterapi(Command):
         parser.add_argument(
             "--filter",
             type=str,
-            help="Filter the version to be managed (e.g. 1.31)",
+            help="Filter the version to be managed (e.g. 1.32)",
             default=None,
         )
         return parser

osism/commands/netbox.py

@@ -2,36 +2,34 @@
 
 from cliff.command import Command
 from loguru import logger
-from redis import Redis
 
-from osism import settings
-from osism.tasks import conductor, netbox, reconciler, openstack, handle_task
-
-
-redis = Redis(host=settings.REDIS_HOST, port=settings.REDIS_PORT, db=settings.REDIS_DB)
-redis.ping()
+from osism.tasks import conductor, netbox, reconciler, handle_task
 
 
 class Ironic(Command):
     def get_parser(self, prog_name):
         parser = super(Ironic, self).get_parser(prog_name)
+        parser.add_argument(
+            "--no-wait",
+            help="Do not wait until the sync has been completed",
+            action="store_true",
+        )
+        parser.add_argument(
+            "--force-update",
+            help="Force update of baremetal nodes (Used to update non-comparable items like passwords)",
+            action="store_true",
+        )
         return parser
 
     def take_action(self, parsed_args):
-        # Get Ironic parameters from the conductor
-        task = conductor.get_ironic_parameters.delay()
-        task.wait(timeout=None, interval=0.5)
-        ironic_parameters = task.get()
+        wait = not parsed_args.no_wait
 
-        # Add all unregistered systems from the Netbox in Ironic
-        netbox.get_devices_not_yet_registered_in_ironic.apply_async(
-            (), link=openstack.baremetal_create_nodes.s(ironic_parameters)
+        task = conductor.sync_netbox_with_ironic.delay(
+            force_update=parsed_args.force_update
         )
-
-        # Synchronize the current status in Ironic with the Netbox
-        # openstack.baremetal_node_list.apply_async((), link=netbox.synchronize_device_state.s())
-
-        # Remove systems from Ironic that are no longer present in the Netbox
+        if wait:
+            logger.info(f"Task {task.task_id} is running. Wait. No more output.")
+            task.wait(timeout=None, interval=0.5)
 
 
 class Sync(Command):
@@ -39,7 +37,6 @@ class Sync(Command):
         parser = super(Sync, self).get_parser(prog_name)
         parser.add_argument(
             "--no-wait",
-            default=False,
             help="Do not wait until the sync has been completed",
             action="store_true",
         )

osism/commands/wait.py

@@ -6,8 +6,7 @@ from celery import Celery
 from celery.result import AsyncResult
 from cliff.command import Command
 from loguru import logger
-from redis import Redis
-from osism import settings
+from osism import utils
 from osism.tasks import Config
 
 
@@ -119,18 +118,12 @@ class Run(Command):
                         print(f"{task_id} = STARTED")
 
                     if live:
-                        redis = Redis(
-                            host=settings.REDIS_HOST,
-                            port=settings.REDIS_PORT,
-                            db=settings.REDIS_DB,
-                            socket_keepalive=True,
-                        )
-                        redis.ping()
+                        utils.redis.ping()
 
                         last_id = 0
                         while_True = True
                         while while_True:
-                            data = redis.xread(
+                            data = utils.redis.xread(
                                 {str(task_id): last_id}, count=1, block=1000
                             )
                             if data:
@@ -143,7 +136,7 @@ class Run(Command):
                                     logger.debug(
                                         f"Processing message {last_id} of type {message_type}"
                                     )
-                                    redis.xdel(str(task_id), last_id)
+                                    utils.redis.xdel(str(task_id), last_id)
 
                                     if message_type == "stdout":
                                         print(message_content, end="")
@@ -153,7 +146,7 @@ class Run(Command):
                                         message_type == "action"
                                         and message_content == "quit"
                                     ):
-                                        redis.close()
+                                        utils.redis.close()
                                         if len(task_ids) == 1:
                                             return rc
                                         else:

osism/core/enums.py

@@ -107,6 +107,7 @@ VALIDATE_PLAYBOOKS = {
     "ntp": {"environment": "generic", "runtime": "osism-ansible"},
     "system-encoding": {"environment": "generic", "runtime": "osism-ansible"},
     "ulimits": {"environment": "generic", "runtime": "osism-ansible"},
+    "stress": {"environment": "generic", "runtime": "osism-ansible"},
 }
 
 MAP_ROLE2ROLE = {
@@ -187,7 +188,7 @@ MAP_ROLE2ROLE = {
         [
             "common",
             [
-                ["loadbalancer", ["opensearch", "mariadb-ng"]],
+                ["loadbalancer", ["letsencrypt", "opensearch", "mariadb-ng"]],
                 ["openvswitch", ["ovn"]],
                 "memcached",
                 "redis",
@@ -198,6 +199,19 @@ MAP_ROLE2ROLE = {
     "collection-kubernetes": [
         ["kubernetes", ["kubeconfig", ["copy-kubeconfig"]]],
     ],
+    "collection-openstack-core": [
+        "horizon",
+        [
+            "keystone",
+            [
+                "glance",
+                "cinder",
+                ["neutron", ["octavia"]],
+                "designate",
+                ["placement", ["nova"]],
+            ],
+        ],
+    ],
     "collection-openstack": [
         "horizon",
         [

osism/services/listener.py

@@ -11,8 +11,7 @@ from loguru import logger
 import json
 import requests
 
-from osism import utils
-from osism.tasks import netbox, openstack
+from osism.tasks import netbox
 from osism import settings
 
 EXCHANGE_NAME = "ironic"
@@ -40,16 +39,13 @@ class BaremetalEvents:
                     },
                     "maintenance_set": {"end": self.node_maintenance_set_end},
                     "provision_set": {
+                        "start": self.node_provision_set_start,
                         "end": self.node_provision_set_end,
                         "success": self.node_provision_set_success,
                     },
                     "delete": {"end": self.node_delete_end},
                     "create": {"end": self.node_create_end},
                 },
-                "port": {
-                    "create": {"end": self.port_create_end},
-                    "update": {"end": self.port_update_end},
-                },
             }
         }
 
@@ -78,7 +74,7 @@ class BaremetalEvents:
         logger.info(
             f"baremetal.node.power_set.end ## {name} ## {object_data['power_state']}"
         )
-        netbox.set_state.delay(name, object_data["power_state"], "power")
+        netbox.set_power_state.delay(name, object_data["power_state"])
 
     def node_power_state_corrected_success(self, payload: dict[Any, Any]) -> None:
         object_data = self.get_object_data(payload)
@@ -86,7 +82,7 @@ class BaremetalEvents:
         logger.info(
             f"baremetal.node.power_state_corrected.success ## {name} ## {object_data['power_state']}"
         )
-        netbox.set_state.delay(name, object_data["power_state"], "power")
+        netbox.set_power_state.delay(name, object_data["power_state"])
 
     def node_maintenance_set_end(self, payload: dict[Any, Any]) -> None:
         object_data = self.get_object_data(payload)
@@ -94,7 +90,7 @@ class BaremetalEvents:
         logger.info(
             f"baremetal.node.maintenance_set.end ## {name} ## {object_data['maintenance']}"
         )
-        netbox.set_maintenance.delay(name, object_data["maintenance"])
+        netbox.set_maintenance.delay(name, state=object_data["maintenance"])
 
     def node_provision_set_success(self, payload: dict[Any, Any]) -> None:
         # A provision status was successfully set, update it in the netbox
@@ -103,80 +99,37 @@ class BaremetalEvents:
         logger.info(
             f"baremetal.node.provision_set.success ## {name} ## {object_data['provision_state']}"
         )
-        netbox.set_state.delay(name, object_data["provision_state"], "provision")
+        netbox.set_provision_state.delay(name, object_data["provision_state"])
 
-    def node_provision_set_end(self, payload: dict[Any, Any]) -> None:
+    def node_provision_set_start(self, payload: dict[Any, Any]) -> None:
         object_data = self.get_object_data(payload)
         name = object_data["name"]
         logger.info(
-            f"baremetal.node.provision_set.end ## {name} ## {object_data['provision_state']}"
-        )
-        netbox.set_state.delay(name, object_data["provision_state"], "provision")
-
-        if (
-            object_data["previous_provision_state"] == "inspect wait"
-            and object_data["event"] == "done"
-        ):
-            netbox.set_state.delay(name, "introspected", "introspection")
-            openstack.baremetal_set_node_provision_state.delay(name, "provide")
-
-    def port_create_end(self, payload: dict[Any, Any]) -> None:
-        object_data = self.get_object_data(payload)
-        name = object_data["name"]
-        logger.info(f"baremetal.port.create.end ## {object_data['uuid']}")
-
-        mac_address = object_data["address"]
-        interface_a = utils.nb.dcim.interfaces.get(mac_address=mac_address)
-        device_a = interface_a.device
-
-        task = openstack.baremetal_get_network_interface_name.delay(
-            device_a.name, mac_address
-        )
-        task.wait(timeout=None, interval=0.5)
-        network_interface_name = task.get()
-
-        netbox.update_network_interface_name.delay(
-            object_data["address"], network_interface_name
+            f"baremetal.node.provision_set.start ## {name} ## {object_data['provision_state']}"
         )
+        netbox.set_provision_state.delay(name, object_data["provision_state"])
 
-    def port_update_end(self, payload: dict[Any, Any]) -> None:
+    def node_provision_set_end(self, payload: dict[Any, Any]) -> None:
         object_data = self.get_object_data(payload)
         name = object_data["name"]
-        logger.info(f"baremetal.port.update.end ## {object_data['uuid']}")
-
-        mac_address = object_data["address"]
-        interface_a = utils.nb.dcim.interfaces.get(mac_address=mac_address)
-        device_a = interface_a.device
-
-        task = openstack.baremetal_get_network_interface_name.delay(
-            device_a.name, mac_address
-        )
-        task.wait(timeout=None, interval=0.5)
-        network_interface_name = task.get()
-
-        netbox.update_network_interface_name.delay(
-            object_data["address"], network_interface_name
+        logger.info(
+            f"baremetal.node.provision_set.end ## {name} ## {object_data['provision_state']}"
         )
+        netbox.set_provision_state.delay(name, object_data["provision_state"])
 
     def node_delete_end(self, payload: dict[Any, Any]) -> None:
         object_data = self.get_object_data(payload)
         name = object_data["name"]
         logger.info(f"baremetal.node.delete.end ## {name}")
-
-        netbox.set_state.delay(name, "unregistered", "ironic")
-        netbox.set_state.delay(name, None, "provision")
-        netbox.set_state.delay(name, None, "power")
-        netbox.set_state.delay(name, None, "introspection")
-        netbox.set_state.delay(name, None, "deployment")
-
-        # remove internal flavor
-        openstack.baremetal_delete_internal_flavor.delay(name)
+        netbox.set_provision_state.delay(name, None)
+        netbox.set_power_state.delay(name, None)
 
     def node_create_end(self, payload: dict[Any, Any]) -> None:
         object_data = self.get_object_data(payload)
         name = object_data["name"]
         logger.info(f"baremetal.node.create.end ## {name}")
-        netbox.set_state.delay(name, "registered", "ironic")
+        netbox.set_provision_state.delay(name, object_data["provision_state"])
+        netbox.set_power_state.delay(name, object_data["power_state"])
 
 
 class NotificationsDump(ConsumerMixin):
@@ -207,7 +160,17 @@ class NotificationsDump(ConsumerMixin):
 
     def on_message(self, body, message):
         data = json.loads(body["oslo.message"])
-        # logger.info(data)
+        logger.debug(
+            data["event_type"]
+            + ": "
+            + str(
+                {
+                    k: v
+                    for k, v in data["payload"]["ironic_object.data"].items()
+                    if k in ["provision_state", "power_state"]
+                }
+            )
+        )
 
         if self.osism_api_session:
             tries = 1
@@ -268,8 +231,6 @@ class NotificationsDump(ConsumerMixin):
             handler = self.baremetal_events.get_handler(data["event_type"])
             handler(data["payload"])
 
-        logger.info(self.baremetal_events.get_object_data(data["payload"]))
-
 
 def main():
     while True:

osism/tasks/__init__.py

@@ -5,14 +5,10 @@ import re
 import subprocess
 import time
 
-from celery.signals import worker_process_init
 from loguru import logger
-from redis import Redis
 from pottery import Redlock
 
-from osism import settings
-
-redis = None
+from osism import utils
 
 
 class Config:
@@ -36,19 +32,6 @@ class Config:
     }
 
 
-@worker_process_init.connect
-def celery_init_worker(**kwargs):
-    global redis
-
-    redis = Redis(
-        host=settings.REDIS_HOST,
-        port=settings.REDIS_PORT,
-        db=settings.REDIS_DB,
-        socket_keepalive=True,
-    )
-    redis.ping()
-
-
 def run_ansible_in_environment(
     request_id,
     worker,
@@ -88,7 +71,7 @@ def run_ansible_in_environment(
 
     # NOTE: This is a first step to make Ansible Vault usable via OSISM workers.
     #       It's not ready in that form yet.
-    ansible_vault_password = redis.get("ansible_vault_password")
+    ansible_vault_password = utils.redis.get("ansible_vault_password")
     if ansible_vault_password:
         env["VAULT"] = "/ansible-vault.py"
 
@@ -96,7 +79,7 @@ def run_ansible_in_environment(
     if locking:
         lock = Redlock(
             key=f"lock-ansible-{environment}-{role}",
-            masters={redis},
+            masters={utils.redis},
             auto_release_time=auto_release_time,
         )
 
@@ -178,14 +161,14 @@ def run_ansible_in_environment(
     while p.poll() is None:
         line = p.stdout.readline().decode("utf-8")
         if publish:
-            redis.xadd(request_id, {"type": "stdout", "content": line})
+            utils.redis.xadd(request_id, {"type": "stdout", "content": line})
         result += line
 
     rc = p.wait(timeout=60)
 
     if publish:
-        redis.xadd(request_id, {"type": "rc", "content": rc})
-        redis.xadd(request_id, {"type": "action", "content": "quit"})
+        utils.redis.xadd(request_id, {"type": "rc", "content": rc})
+        utils.redis.xadd(request_id, {"type": "action", "content": "quit"})
 
     if locking:
         lock.release()
@@ -209,7 +192,7 @@ def run_command(
     if locking:
         lock = Redlock(
             key=f"lock-{command}",
-            masters={redis},
+            masters={utils.redis},
             auto_release_time=auto_release_time,
         )
 
@@ -222,14 +205,14 @@ def run_command(
     while p.poll() is None:
         line = p.stdout.readline().decode("utf-8")
         if publish:
-            redis.xadd(request_id, {"type": "stdout", "content": line})
+            utils.redis.xadd(request_id, {"type": "stdout", "content": line})
         result += line
 
     rc = p.wait(timeout=60)
 
     if publish:
-        redis.xadd(request_id, {"type": "rc", "content": rc})
-        redis.xadd(request_id, {"type": "action", "content": "quit"})
+        utils.redis.xadd(request_id, {"type": "rc", "content": rc})
+        utils.redis.xadd(request_id, {"type": "action", "content": "quit"})
 
     if locking:
         lock.release()
@@ -238,23 +221,12 @@ def run_command(
 
 
 def handle_task(t, wait=True, format="log", timeout=3600):
-    global redis
-
-    if not redis:
-        redis = Redis(
-            host=settings.REDIS_HOST,
-            port=settings.REDIS_PORT,
-            db=settings.REDIS_DB,
-            socket_keepalive=True,
-        )
-        redis.ping()
-
     rc = 0
     if wait:
         stoptime = time.time() + timeout
         last_id = 0
         while time.time() < stoptime:
-            data = redis.xread(
+            data = utils.redis.xread(
                 {str(t.task_id): last_id}, count=1, block=(timeout * 1000)
             )
             if data:
@@ -266,7 +238,7 @@ def handle_task(t, wait=True, format="log", timeout=3600):
                     message_content = message[b"content"].decode()
 
                     logger.debug(f"Processing message {last_id} of type {message_type}")
-                    redis.xdel(str(t.task_id), last_id)
+                    utils.redis.xdel(str(t.task_id), last_id)
 
                     if message_type == "stdout":
                         print(message_content, end="", flush=True)
@@ -279,7 +251,7 @@ def handle_task(t, wait=True, format="log", timeout=3600):
                     elif message_type == "rc":
                         rc = int(message_content)
                     elif message_type == "action" and message_content == "quit":
-                        redis.close()
+                        utils.redis.close()
                         return rc
         else:
             logger.info(