osism 0.20250826.0__py3-none-any.whl → 0.20250827.0__py3-none-any.whl

osism/commands/apply.py

@@ -9,6 +9,7 @@ from cliff.command import Command
 from loguru import logger
 from tabulate import tabulate
 
+from osism import utils
 from osism.data import enums
 from osism.data.playbooks import MAP_ROLE2ENVIRONMENT, MAP_ROLE2RUNTIME
 from osism.tasks import ansible, ceph, kolla, kubernetes, handle_task
@@ -451,6 +452,9 @@ class Run(Command):
         return rc
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
         action = parsed_args.action
         arguments = parsed_args.arguments
         environment = parsed_args.environment

osism/commands/configuration.py

@@ -5,6 +5,7 @@ import argparse
 from cliff.command import Command
 from loguru import logger
 
+from osism import utils
 from osism.tasks import ansible, handle_task
 
 
@@ -17,6 +18,9 @@ class Sync(Command):
         return parser
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
         arguments = parsed_args.arguments
 
         t = ansible.run.delay(

osism/commands/lock.py

@@ -0,0 +1,91 @@
+# SPDX-License-Identifier: Apache-2.0
+
+from cliff.command import Command
+from loguru import logger
+
+from osism import utils
+
+
+class Lock(Command):
+    """Lock task execution to prevent new tasks from starting"""
+
+    def get_parser(self, prog_name):
+        parser = super(Lock, self).get_parser(prog_name)
+        parser.add_argument(
+            "--user",
+            help="User name to associate with the lock (defaults to dragon)",
+        )
+        parser.add_argument("--reason", help="Reason for locking tasks")
+        return parser
+
+    def take_action(self, parsed_args):
+        user = parsed_args.user or "dragon"
+        reason = parsed_args.reason
+
+        # Check if already locked
+        lock_info = utils.is_task_locked()
+        if lock_info and lock_info.get("locked"):
+            existing_user = lock_info.get("user", "unknown")
+            existing_timestamp = lock_info.get("timestamp", "unknown")
+            existing_reason = lock_info.get("reason")
+            logger.warning(
+                f"Tasks are already locked by {existing_user} at {existing_timestamp}"
+            )
+            if existing_reason:
+                logger.warning(f"Existing reason: {existing_reason}")
+            return
+
+        # Set the lock
+        if utils.set_task_lock(user, reason):
+            logger.info(f"Tasks locked by {user}")
+            if reason:
+                logger.info(f"Reason: {reason}")
+            logger.info("New tasks will be prevented from starting")
+            logger.info("Running tasks will continue normally")
+            logger.info("Use 'osism unlock' to remove the lock")
+        else:
+            logger.error("Failed to set task lock")
+            return 1
+
+
+class Unlock(Command):
+    """Unlock task execution to allow new tasks to start"""
+
+    def take_action(self, parsed_args):
+        # Check if currently locked
+        lock_info = utils.is_task_locked()
+        if not lock_info or not lock_info.get("locked"):
+            logger.info("Tasks are not currently locked")
+            return
+
+        existing_user = lock_info.get("user", "unknown")
+        existing_timestamp = lock_info.get("timestamp", "unknown")
+        existing_reason = lock_info.get("reason")
+
+        # Remove the lock
+        if utils.remove_task_lock():
+            logger.info(
+                f"Task lock removed (was set by {existing_user} at {existing_timestamp})"
+            )
+            if existing_reason:
+                logger.info(f"Previous reason: {existing_reason}")
+            logger.info("New tasks can now be started")
+        else:
+            logger.error("Failed to remove task lock")
+            return 1
+
+
+class LockStatus(Command):
+    """Show current task lock status"""
+
+    def take_action(self, parsed_args):
+        lock_info = utils.is_task_locked()
+        if lock_info and lock_info.get("locked"):
+            user = lock_info.get("user", "unknown")
+            timestamp = lock_info.get("timestamp", "unknown")
+            reason = lock_info.get("reason")
+            logger.info(f"Tasks are LOCKED by {user} at {timestamp}")
+            if reason:
+                logger.info(f"Reason: {reason}")
+        else:
+            logger.info("Tasks are UNLOCKED")

osism/commands/manage.py

@@ -9,10 +9,16 @@ from jinja2 import Template
 from loguru import logger
 import requests
 
-from osism.data import TEMPLATE_IMAGE_CLUSTERAPI, TEMPLATE_IMAGE_OCTAVIA
+from osism import utils
+from osism.data import (
+    TEMPLATE_IMAGE_CLUSTERAPI,
+    TEMPLATE_IMAGE_OCTAVIA,
+    TEMPLATE_IMAGE_GARDENLINUX,
+)
 from osism.tasks import openstack, ansible, handle_task
 
 SUPPORTED_CLUSTERAPI_K8S_IMAGES = ["1.31", "1.32", "1.33"]
+SUPPORTED_GARDENLINUX_VERSIONS = {"1877.2": "2025-08-07"}
 
 
 class ImageClusterapi(Command):
@@ -57,6 +63,9 @@ class ImageClusterapi(Command):
         return parser
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
         base_url = parsed_args.base_url
         cloud = parsed_args.cloud
         filter = parsed_args.filter
@@ -112,7 +121,112 @@ class ImageClusterapi(Command):
         if parsed_args.dry_run:
             args.append("--dry-run")
 
-        task_signature = openstack.image_manager.si(*args, configs=result)
+        task_signature = openstack.image_manager.si(*args, configs=result, cloud=cloud)
+        task = task_signature.apply_async()
+        if wait:
+            logger.info(
+                f"It takes a moment until task {task.task_id} (image-manager) has been started and output is visible here."
+            )
+
+        return handle_task(task, wait, format="script", timeout=3600)
+
+
+class ImageGardenlinux(Command):
+    def get_parser(self, prog_name):
+        parser = super(ImageGardenlinux, self).get_parser(prog_name)
+
+        parser.add_argument(
+            "--no-wait",
+            default=False,
+            help="Do not wait until image management has been completed",
+            action="store_true",
+        )
+        parser.add_argument(
+            "--base-url",
+            type=str,
+            help="Base URL",
+            default="https://swift.services.a.regiocloud.tech/swift/v1/AUTH_b182637428444b9aa302bb8d5a5a418c/openstack-images/gardenlinux/",
+        )
+        parser.add_argument(
+            "--cloud",
+            type=str,
+            help="Cloud name in clouds.yaml (will be overruled by OS_AUTH_URL envvar)",
+            default="admin",
+        )
+        parser.add_argument(
+            "--dry-run",
+            action="store_true",
+            help="Do not perform any changes (--dry-run passed to openstack-image-manager)",
+        )
+        parser.add_argument(
+            "--tag",
+            type=str,
+            help="Name of the tag used to identify managed images (use openstack-image-manager's default if unset)",
+            default=None,
+        )
+        parser.add_argument(
+            "--filter",
+            type=str,
+            help="Filter the version to be managed (e.g. 1877.2)",
+            default=None,
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
+        base_url = parsed_args.base_url
+        cloud = parsed_args.cloud
+        filter = parsed_args.filter
+        tag = parsed_args.tag
+        wait = not parsed_args.no_wait
+
+        if filter:
+            # For filter, we need to handle it as a dict with placeholder build date
+            supported_gardenlinux_versions = {filter: "unknown"}
+        else:
+            supported_gardenlinux_versions = SUPPORTED_GARDENLINUX_VERSIONS
+
+        result = []
+        for version, build_date in supported_gardenlinux_versions.items():
+            # Garden Linux uses direct URL construction instead of fetching last files
+            url = urljoin(
+                base_url, f"{version}/openstack-gardener_prod-amd64-{version}.qcow2"
+            )
+            logger.info(f"url: {url}")
+
+            # Get checksum file
+            checksum_url = f"{url}.sha256"
+            logger.info(f"checksum_url: {checksum_url}")
+            response_checksum = requests.get(checksum_url)
+            checksum = response_checksum.text.strip().split()[0]
+            logger.info(f"checksum: {checksum}")
+
+            template = Template(TEMPLATE_IMAGE_GARDENLINUX)
+            result.extend(
+                [
+                    template.render(
+                        image_url=url,
+                        image_checksum=f"sha256:{checksum}",
+                        image_version=version,
+                        image_builddate=build_date,
+                    )
+                ]
+            )
+
+        args = [
+            "--cloud",
+            cloud,
+            "--filter",
+            "garden-linux-image",
+        ]
+        if tag is not None:
+            args.extend(["--tag", tag])
+        if parsed_args.dry_run:
+            args.append("--dry-run")
+
+        task_signature = openstack.image_manager.si(*args, configs=result, cloud=cloud)
         task = task_signature.apply_async()
         if wait:
             logger.info(
@@ -147,6 +261,9 @@ class ImageOctavia(Command):
         return parser
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
         wait = not parsed_args.no_wait
         cloud = parsed_args.cloud
         base_url = parsed_args.base_url
@@ -189,7 +306,7 @@ class ImageOctavia(Command):
         ]
 
         task_signature = openstack.image_manager.si(
-            *arguments, configs=result, ignore_env=True
+            *arguments, configs=result, cloud=cloud
         )
         task = task_signature.apply_async()
         if wait:
@@ -258,6 +375,9 @@ class Images(Command):
         return parser
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
         wait = not parsed_args.no_wait
 
         arguments = []
@@ -283,7 +403,7 @@ class Images(Command):
         else:
             arguments.append("/etc/images")
 
-        task_signature = openstack.image_manager.si(*arguments)
+        task_signature = openstack.image_manager.si(*arguments, cloud=parsed_args.cloud)
         task = task_signature.apply_async()
         if wait:
             logger.info(
@@ -315,7 +435,7 @@ class Flavors(Command):
             "--name",
             type=str,
             help="Name of flavor definitions",
-            default="scs",
+            default="local",
             choices=["scs", "osism", "local", "url"],
         )
         parser.add_argument(
@@ -334,6 +454,9 @@ class Flavors(Command):
         return parser
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
         wait = not parsed_args.no_wait
         cloud = parsed_args.cloud
         name = parsed_args.name
@@ -352,7 +475,7 @@ class Flavors(Command):
             arguments.append("--url")
             arguments.append(url)
 
-        task_signature = openstack.flavor_manager.si(*arguments)
+        task_signature = openstack.flavor_manager.si(*arguments, cloud=cloud)
         task = task_signature.apply_async()
         if wait:
             logger.info(
@@ -374,6 +497,9 @@ class Dnsmasq(Command):
         return parser
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
         wait = not parsed_args.no_wait
 
         task_signature = ansible.run.si("infrastructure", "dnsmasq", [])

osism/commands/netbox.py

@@ -38,6 +38,9 @@ class Ironic(Command):
         return parser
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
         wait = not parsed_args.no_wait
         task_timeout = parsed_args.task_timeout
         node_name = parsed_args.node
@@ -87,6 +90,9 @@ class Sync(Command):
         return parser
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
         wait = not parsed_args.no_wait
 
         task = conductor.sync_netbox.delay()
@@ -145,6 +151,9 @@ class Manage(Command):
         return parser
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
         wait = not parsed_args.no_wait
         arguments = ["run"]
 
@@ -192,6 +201,9 @@ class Versions(Command):
         return parser
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
         task = netbox.ping.delay()
         task.wait(timeout=None, interval=0.5)
         result = task.get()

osism/commands/noset.py

@@ -3,6 +3,7 @@
 from cliff.command import Command
 from loguru import logger
 
+from osism import utils
 from osism.tasks import ansible
 
 
@@ -18,6 +19,9 @@ class NoMaintenance(Command):
         return parser
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
         host = parsed_args.host[0]
 
         logger.info(f"Set no maintenance state on host {host}")
@@ -46,6 +50,9 @@ class NoBootstrap(Command):
         return parser
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
         host = parsed_args.host[0]
 
         logger.info(f"Set not bootstrapped state on host {host}")

osism/commands/reconciler.py

@@ -47,6 +47,9 @@ class Sync(Command):
         return parser
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
         wait = not parsed_args.no_wait
         task_timeout = parsed_args.task_timeout
         flush_cache = parsed_args.flush_cache

osism/commands/redfish.py

@@ -5,6 +5,7 @@ from cliff.command import Command
 from loguru import logger
 from tabulate import tabulate
 
+from osism import utils
 from osism.tasks.conductor import get_redfish_resources
 
 
@@ -145,6 +146,9 @@ class List(Command):
         return parser
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
         hostname = parsed_args.hostname
         resourcetype = parsed_args.resourcetype
         output_format = parsed_args.format

osism/commands/service.py

@@ -7,6 +7,7 @@ from cliff.command import Command
 from watchdog.observers.polling import PollingObserver
 from watchdog.events import FileSystemEventHandler
 
+from osism import utils
 from osism.tasks import reconciler
 
 
@@ -17,6 +18,9 @@ class Run(Command):
         return parser
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
         service = parsed_args.type[0]
 
         if service == "api":

osism/commands/set.py

@@ -3,6 +3,7 @@
 from cliff.command import Command
 from loguru import logger
 
+from osism import utils
 from osism.tasks import ansible
 
 
@@ -18,6 +19,9 @@ class Maintenance(Command):
         return parser
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
         host = parsed_args.host[0]
 
         logger.info(f"Set maintenance state on host {host}")
@@ -46,6 +50,9 @@ class Bootstrap(Command):
         return parser
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
         host = parsed_args.host[0]
 
         logger.info(f"Set bootstraped state on host {host}")

osism/commands/sonic.py

@@ -738,6 +738,9 @@ class Reset(SonicCommandBase):
         return parser
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
         hostname = parsed_args.hostname
         force = parsed_args.force
 

osism/commands/sync.py

@@ -3,6 +3,7 @@
 from cliff.command import Command
 from loguru import logger
 
+from osism import utils
 from osism.tasks import ansible, conductor, handle_task
 
 
@@ -12,6 +13,9 @@ class Facts(Command):
         return parser
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
         arguments = []
         t = ansible.run.delay(
             "generic", "gather-facts", arguments, auto_release_time=3600
@@ -49,6 +53,9 @@ class Sonic(Command):
         return parser
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
         wait = not parsed_args.no_wait
         device_name = parsed_args.device
         show_diff = parsed_args.diff

osism/commands/validate.py

@@ -70,6 +70,9 @@ class Run(Command):
             return 0
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before proceeding
+        utils.check_task_lock_and_exit()
+
         arguments = parsed_args.arguments
         environment = parsed_args.environment
         validator = parsed_args.validator[0]

osism/commands/worker.py

@@ -4,6 +4,7 @@ import multiprocessing
 import subprocess
 
 from cliff.command import Command
+from osism import utils
 
 
 class Run(Command):
@@ -25,6 +26,9 @@ class Run(Command):
         return parser
 
     def take_action(self, parsed_args):
+        # Check if tasks are locked before starting workers
+        utils.check_task_lock_and_exit()
+
         queue = parsed_args.type[0]
         number_of_workers = parsed_args.number_of_workers
 

osism/data/__init__.py

@@ -65,3 +65,36 @@ images:
         build_date: {{ image_builddate }}
 
 """
+
+TEMPLATE_IMAGE_GARDENLINUX = """---
+images:
+  - name: garden-linux-image
+    enable: true
+    keep: true
+    separator: "-"
+    format: qcow2
+    login: garden
+    min_disk: 20
+    min_ram: 512
+    status: active
+    visibility: public
+    multi: false
+    meta:
+      architecture: x86_64
+      hw_disk_bus: scsi
+      hw_rng_model: virtio
+      hw_scsi_model: virtio-scsi
+      hw_watchdog_action: reset
+      hypervisor_type: qemu
+      os_distro: debian
+      replace_frequency: never
+      uuid_validity: none
+      provided_until: none
+    tags: []
+    versions:
+      - version: "{{ image_version }}"
+        url: "{{ image_url }}"
+        checksum: "{{ image_checksum }}"
+        build_date: {{ image_builddate }}
+
+"""

osism/tasks/ansible.py

@@ -37,6 +37,9 @@ def run(
     locking=False,
     auto_release_time=3600,
 ):
+    # Check if tasks are locked before execution
+    utils.check_task_lock_and_exit()
+
     return run_ansible_in_environment(
         self.request.id,
         "osism-ansible",

osism/tasks/ceph.py

@@ -2,6 +2,7 @@
 
 from celery import Celery
 
+from osism import utils
 from osism.tasks import Config, run_ansible_in_environment
 
 app = Celery("ceph")
@@ -15,6 +16,9 @@ def setup_periodic_tasks(sender, **kwargs):
 
 @app.task(bind=True, name="osism.tasks.ceph.run")
 def run(self, environment, playbook, arguments, publish=True, auto_release_time=3600):
+    # Check if tasks are locked before execution
+    utils.check_task_lock_and_exit()
+
     return run_ansible_in_environment(
         self.request.id,
         "ceph-ansible",

osism/tasks/conductor/__init__.py

@@ -5,6 +5,7 @@ from celery import Celery
 from celery.signals import worker_process_init
 from loguru import logger
 
+from osism import utils
 from osism.tasks import Config
 from osism.tasks.conductor.config import get_configuration
 from osism.tasks.conductor.ironic import sync_ironic as _sync_ironic
@@ -40,16 +41,25 @@ def get_ironic_parameters(self):
 
 @app.task(bind=True, name="osism.tasks.conductor.sync_netbox")
 def sync_netbox(self, force_update=False):
+    # Check if tasks are locked before execution
+    utils.check_task_lock_and_exit()
+
     logger.info("Not implemented")
 
 
 @app.task(bind=True, name="osism.tasks.conductor.sync_ironic")
 def sync_ironic(self, node_name=None, force_update=False):
+    # Check if tasks are locked before execution
+    utils.check_task_lock_and_exit()
+
     _sync_ironic(self.request.id, get_ironic_parameters, node_name, force_update)
 
 
 @app.task(bind=True, name="osism.tasks.conductor.sync_sonic")
 def sync_sonic(self, device_name=None, show_diff=True):
+    # Check if tasks are locked before execution
+    utils.check_task_lock_and_exit()
+
     return _sync_sonic(device_name, self.request.id, show_diff)
 
 

osism/tasks/kolla.py

@@ -2,6 +2,7 @@
 
 from celery import Celery
 
+from osism import utils
 from osism.tasks import Config, run_ansible_in_environment
 
 app = Celery("kolla")
@@ -15,6 +16,9 @@ def setup_periodic_tasks(sender, **kwargs):
 
 @app.task(bind=True, name="osism.tasks.kolla.run")
 def run(self, environment, playbook, arguments, publish=True, auto_release_time=3600):
+    # Check if tasks are locked before execution
+    utils.check_task_lock_and_exit()
+
     return run_ansible_in_environment(
         self.request.id,
         "kolla-ansible",

osism/tasks/kubernetes.py

@@ -2,6 +2,7 @@
 
 from celery import Celery
 
+from osism import utils
 from osism.tasks import Config, run_ansible_in_environment
 
 app = Celery("kubernetes")
@@ -15,6 +16,9 @@ def setup_periodic_tasks(sender, **kwargs):
 
 @app.task(bind=True, name="osism.tasks.kubernetes.run")
 def run(self, environment, playbook, arguments, publish=True, auto_release_time=3600):
+    # Check if tasks are locked before execution
+    utils.check_task_lock_and_exit()
+
     return run_ansible_in_environment(
         self.request.id,
         "kubernetes",