primitive 0.2.68__py3-none-any.whl → 0.2.72__py3-none-any.whl

primitive/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present Dylan Stein <dylan@primitive.tech>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "0.2.68"
+__version__ = "0.2.72"

primitive/agent/actions.py

@@ -96,11 +96,14 @@ class Agent(BaseAction):
                 job_run_status = job_run_data.get("status", None)
 
                 hardware_id = hardware.get("id", None) if hardware else None
-                execution_hardware_id = (
-                    job_run_data.get("executionHardware", {}).get("id", None)
-                    if job_run_data
-                    else None
-                )
+                execution_hardware_id = None
+                if job_run_data:
+                    execution_hardware = job_run_data.get("executionHardware", None)
+                    execution_hardware_id = (
+                        execution_hardware.get("id", None)
+                        if execution_hardware
+                        else None
+                    )
                 target_hardware_id = None
 
                 if (

primitive/agent/pxe.py

@@ -0,0 +1,71 @@
+from loguru import logger
+
+from primitive.network.redfish import RedfishClient
+from primitive.network.ssh import test_ssh_connection, run_command
+
+
+def pxe_boot_via_redfish(target_hardware_secret: dict):
+    bmc_host = target_hardware_secret.get("bmcHostname", None)
+    bmc_username = target_hardware_secret.get("bmcUsername", None)
+    bmc_password = target_hardware_secret.get("bmcPassword", "")
+
+    if bmc_host is None:
+        logger.error(
+            "No BMC host found in target hardware secret for out-of-band power cycle"
+        )
+        return True
+    if bmc_username is None:
+        logger.error(
+            "No BMC username found in target hardware secret for out-of-band power cycle"
+        )
+        return True
+
+    redfish = RedfishClient(host=bmc_host, username=bmc_username, password=bmc_password)
+    redfish.update_boot_options(
+        system_id="1",
+        boot_source_override_target="Pxe",
+        boot_source_override_enabled="Once",
+        boot_source_override_mode="UEFI",
+    )
+    redfish.compute_system_reset(system_id="1", reset_type="ForceRestart")
+
+
+def pxe_boot_via_efibootmgr(target_hardware_secret: dict):
+    run_command(
+        hostname=target_hardware_secret.get("hostname"),
+        username=target_hardware_secret.get("username"),
+        password=target_hardware_secret.get("password"),
+        command="sudo efibootmgr -n $(efibootmgr | awk '/PXE IPV4/ {print substr($1,5,4)}' | head -n1 || efibootmgr | awk '/ubuntu/ {print substr($1,5,4)}' | head -n1) && sudo reboot",
+        port=22,
+    )
+
+
+def pxe_boot(target_hardware_secret: dict) -> bool:
+    redfish_available = False
+    ssh_available = False
+
+    if target_hardware_secret.get("bmcHostname", None):
+        redfish_available = True
+    else:
+        logger.info(
+            "No BMC credentials found, skipping Redfish PXE boot method. Checking efiboot method."
+        )
+
+    ssh_available = test_ssh_connection(
+        hostname=target_hardware_secret.get("hostname"),
+        username=target_hardware_secret.get("username"),
+        password=target_hardware_secret.get("password"),
+        port=22,
+    )
+
+    if redfish_available:
+        pxe_boot_via_redfish(target_hardware_secret=target_hardware_secret)
+        return True
+    elif ssh_available:
+        pxe_boot_via_efibootmgr(target_hardware_secret=target_hardware_secret)
+        return True
+    else:
+        logger.error(
+            "No available method to PXE boot target hardware. Missing BMC credentials and SSH is not available."
+        )
+    return False

primitive/agent/runner.py

@@ -1,6 +1,7 @@
 import asyncio
 import os
 import shutil
+import time
 import typing
 from enum import Enum
 from pathlib import Path, PurePath
@@ -9,6 +10,7 @@ from datetime import datetime, timezone
 
 from loguru import logger
 
+from primitive.agent.pxe import pxe_boot
 from primitive.network.ssh import wait_for_ssh
 from primitive.utils.cache import get_artifacts_cache, get_logs_cache, get_sources_cache
 from primitive.utils.logging import fmt, log_context
@@ -231,6 +233,11 @@ class Runner:
         commands = task["cmd"].strip().split("\n")
 
         for i, cmd in enumerate(commands):
+            if cmd.strip() == "":
+                continue
+            if cmd.strip().startswith("#"):
+                logger.debug(f"Skipping comment line: {cmd.strip()}")
+                continue
             if cmd == "oobpowercycle":
                 logger.info("Performing out-of-band power cycle")
                 from primitive.network.redfish import RedfishClient
@@ -261,37 +268,29 @@ class Runner:
                         is_rebooting=True,
                         start_rebooting_at=str(datetime.now(timezone.utc)),
                     )
+                    logger.info(
+                        "Box rebooting, waiting 30 seconds before beginning SSH connection."
+                    )
+                    time.sleep(30)
+                    wait_for_ssh(
+                        hostname=self.target_hardware_secret.get("hostname"),
+                        username=self.target_hardware_secret.get("username"),
+                        password=self.target_hardware_secret.get("password"),
+                        port=22,
+                    )
+                    logger.info("Reboot successful, SSH is now available")
+                    await self.primitive.hardware.aupdate_hardware(
+                        hardware_id=self.target_hardware_id,
+                        is_online=True,
+                        is_rebooting=False,
+                    )
                 continue
 
             if cmd == "pxeboot":
                 logger.info("Setting next boot to PXE and rebooting")
-                from primitive.network.redfish import RedfishClient
 
-                bmc_host = self.target_hardware_secret.get("bmcHostname", None)
-                bmc_username = self.target_hardware_secret.get("bmcUsername", None)
-                bmc_password = self.target_hardware_secret.get("bmcPassword", "")
-
-                if bmc_host is None:
-                    logger.error(
-                        "No BMC host found in target hardware secret for out-of-band power cycle"
-                    )
-                    return True
-                if bmc_username is None:
-                    logger.error(
-                        "No BMC username found in target hardware secret for out-of-band power cycle"
-                    )
-                    return True
+                pxe_boot(target_hardware_secret=self.target_hardware_secret)
 
-                redfish = RedfishClient(
-                    host=bmc_host, username=bmc_username, password=bmc_password
-                )
-                redfish.update_boot_options(
-                    system_id="1",
-                    boot_source_override_target="Pxe",
-                    boot_source_override_enabled="Once",
-                    boot_source_override_mode="UEFI",
-                )
-                redfish.compute_system_reset(system_id="1", reset_type="ForceRestart")
                 if self.target_hardware_id:
                     await self.primitive.hardware.aupdate_hardware(
                         hardware_id=self.target_hardware_id,
@@ -299,21 +298,29 @@ class Runner:
                         is_rebooting=True,
                         start_rebooting_at=str(datetime.now(timezone.utc)),
                     )
-                wait_for_ssh(
-                    hostname=self.target_hardware_secret.get("hostname"),
-                    username=self.target_hardware_secret.get("username"),
-                    password=self.target_hardware_secret.get("password"),
-                    port=22,
-                )
-                logger.info("PXE boot successful, SSH is now available")
+                    logger.info(
+                        "Box rebooting, waiting 30 seconds before beginning SSH connection."
+                    )
+                    time.sleep(30)
+                    wait_for_ssh(
+                        hostname=self.target_hardware_secret.get("hostname"),
+                        username=self.target_hardware_secret.get("username"),
+                        password=self.target_hardware_secret.get("password"),
+                        port=22,
+                    )
+                    logger.info("PXE boot successful, SSH is now available")
+                    await self.primitive.hardware.aupdate_hardware(
+                        hardware_id=self.target_hardware_id,
+                        is_online=True,
+                        is_rebooting=False,
+                    )
                 continue
 
-            args = ["/bin/bash", "-c", cmd]
             if self.target_hardware_secret:
                 username = self.target_hardware_secret.get("username")
                 password = self.target_hardware_secret.get("password")
                 hostname = self.target_hardware_secret.get("hostname")
-                args = [
+                command_args = [
                     "sshpass",
                     "-p",
                     password,
@@ -326,15 +333,18 @@ class Runner:
                     "IdentitiesOnly=yes",
                     f"{username}@{hostname}",
                     "--",
-                    f'/bin/bash -c "cd {task.get("workdir", "~/")} && {cmd}"',
+                    f"{cmd}",
                 ]
+                print(" ".join(command_args))
+            else:
+                command_args = ["/bin/bash", "--login", "-c", cmd]
 
             logger.info(
                 f"Executing command {i + 1}/{len(commands)}: {cmd} at {self.source_dir / task.get('workdir', '')}"
             )
 
             process = await asyncio.create_subprocess_exec(
-                *args,
+                *command_args,
                 env=self.modified_env,
                 cwd=str(Path(self.source_dir / task.get("workdir", ""))),
                 stdout=asyncio.subprocess.PIPE,
@@ -398,15 +408,16 @@ class Runner:
 
     @log_context(label="cleanup")
     def cleanup(self) -> None:
-        for glob in self.config.get("stores", []):
-            # Glob relative to the source directory
-            matches = self.source_dir.rglob(glob)
-
-            for match in matches:
-                relative_path = PurePath(match).relative_to(self.source_dir)
-                dest = Path(get_artifacts_cache(self.job_run["id"]) / relative_path)
-                dest.parent.mkdir(parents=True, exist_ok=True)
-                Path(match).replace(dest)
+        if stores := self.config.get("stores"):
+            for glob in stores:
+                # Glob relative to the source directory
+                matches = self.source_dir.rglob(glob)
+
+                for match in matches:
+                    relative_path = PurePath(match).relative_to(self.source_dir)
+                    dest = Path(get_artifacts_cache(self.job_run["id"]) / relative_path)
+                    dest.parent.mkdir(parents=True, exist_ok=True)
+                    Path(match).replace(dest)
 
         shutil.rmtree(path=self.source_dir)
 

primitive/cli.py

@@ -18,6 +18,7 @@ from .projects.commands import cli as projects_commands
 from .reservations.commands import cli as reservations_commands
 from .monitor.commands import cli as monitor_commands
 from .network.commands import cli as network_commands
+from .operating_systems.commands import cli as operating_system_commands
 
 
 @click.group()
@@ -75,6 +76,7 @@ cli.add_command(reservations_commands, "reservations")
 cli.add_command(exec_commands, "exec")
 cli.add_command(monitor_commands, "monitor")
 cli.add_command(network_commands, "network")
+cli.add_command(operating_system_commands, "operating-systems")
 
 if __name__ == "__main__":
     cli(obj={})

primitive/client.py

@@ -17,6 +17,7 @@ from .hardware.actions import Hardware
 from .jobs.actions import Jobs
 from .monitor.actions import Monitor
 from .network.actions import Network
+from .operating_systems.actions import OperatingSystems
 from .organizations.actions import Organizations
 from .projects.actions import Projects
 from .provisioning.actions import Provisioning
@@ -99,6 +100,7 @@ class Primitive:
         self.provisioning: Provisioning = Provisioning(self)
         self.monitor: Monitor = Monitor(self)
         self.network: Network = Network(self)
+        self.operating_systems: OperatingSystems = OperatingSystems(self)
 
     def get_host_config(self):
         self.full_config = read_config_file()

primitive/files/actions.py

@@ -62,6 +62,7 @@ class Files(BaseAction):
         chunk_size: int,
         number_of_parts: int,
         is_public: bool = False,
+        organization_id: Optional[str] = None,
     ):
         mutation = gql(pending_file_create_mutation)
         input = {
@@ -74,6 +75,8 @@ class Files(BaseAction):
             "chunkSize": chunk_size,
             "numberOfParts": number_of_parts,
         }
+        if organization_id:
+            input["organizationId"] = organization_id
         variables = {"input": input}
         result = self.primitive.session.execute(
             mutation, variable_values=variables, get_execution_result=True
@@ -223,6 +226,7 @@ class Files(BaseAction):
         is_public: bool = False,
         key_prefix: str = "",
         file_id: Optional[str] = None,
+        organization_id: Optional[str] = None,
     ):
         if path.exists() is False:
             raise Exception(f"File {path} does not exist.")
@@ -262,6 +266,7 @@ class Files(BaseAction):
                 is_public=is_public,
                 chunk_size=chunk_size,
                 number_of_parts=number_of_parts,
+                organization_id=organization_id,
             )
             file_id = pending_file_create.get("id")
             parts_details = pending_file_create.get("partsDetails")
@@ -332,6 +337,7 @@ class Files(BaseAction):
         path: Path,
         is_public: bool = False,
         key_prefix: str = "",
+        organization_id: Optional[str] = None,
     ):
         """
         This method uploads a file via the Primitive API.
@@ -347,6 +353,11 @@ class Files(BaseAction):
                 + file_path
                 + """\", "keyPrefix": \""""
                 + key_prefix
+                + (
+                    f'", "organizationId": "{organization_id}'
+                    if organization_id
+                    else ""
+                )
                 + """\" } } }"""
             )  # noqa
 
@@ -356,6 +367,11 @@ class Files(BaseAction):
                 + file_path
                 + """\", "keyPrefix": \""""
                 + key_prefix
+                + (
+                    f'", "organizationId": "{organization_id}'
+                    if organization_id
+                    else ""
+                )
                 + """\" } } }"""
             )  # noqa
         body = {
@@ -385,6 +401,7 @@ class Files(BaseAction):
         output_path: Path = Path().cwd(),
     ) -> Path:
         file_pk = None
+        file_size = None
 
         files_result = self.primitive.files.files(
             file_id=file_id,
@@ -396,6 +413,7 @@ class Files(BaseAction):
             file = files_data["files"]["edges"][0]["node"]
             file_pk = file["pk"]
             file_name = file["fileName"]
+            file_size = int(file["fileSize"])
 
         if not file_pk:
             raise Exception(
@@ -404,7 +422,11 @@ class Files(BaseAction):
 
         session = create_requests_session(host_config=self.primitive.host_config)
         transport = self.primitive.host_config.get("transport")
-        url = f"{transport}://{self.primitive.host}/files/{file_pk}/stream/"
+
+        if file_size and file_size < 5 * 1024 * 1024:
+            url = f"{transport}://{self.primitive.host}/files/{file_pk}/stream/"
+        else:
+            url = f"{transport}://{self.primitive.host}/files/{file_pk}/presigned-url/"
 
         downloaded_file = output_path / file_name
 

primitive/hardware/actions.py

@@ -283,7 +283,180 @@ class Hardware(BaseAction):
             return {"linux_machine_id": machine_id}
         return {}
 
-    def get_system_info(self):
+    def _get_homebrew_installed(self):
+        try:
+            raw = json.loads(
+                subprocess.check_output(["brew", "info", "--json=v2", "--installed"])
+            )
+
+            if isinstance(raw, Dict):
+                raw_formulae = raw.get("formulae", [])
+                raw_casks = raw.get("casks", [])
+
+                formulae = []
+                casks = []
+
+                if isinstance(raw_formulae, List):
+                    for raw_formula in raw_formulae:
+                        try:
+                            formulae.append(
+                                {
+                                    "full_name": raw_formula["full_name"],
+                                    "tap": raw_formula["tap"],
+                                    "version": raw_formula["versions"]["stable"],
+                                }
+                            )
+                        except Exception:
+                            pass
+
+                if isinstance(raw_casks, List):
+                    for raw_cask in raw_casks:
+                        try:
+                            casks.append(
+                                {
+                                    "full_token": raw_cask["full_token"],
+                                    "name": raw_cask["name"][0],
+                                    "version": raw_cask["installed"],
+                                }
+                            )
+                        except Exception:
+                            pass
+
+                return {
+                    "formulae": formulae,
+                    "casks": casks,
+                }
+        except Exception:
+            pass
+
+    def _get_darwin_md_application(self, application_path: str):
+        lines = (
+            subprocess.check_output(
+                [
+                    "mdls",
+                    "-name",
+                    "kMDItemDisplayName",
+                    "-name",
+                    "kMDItemVersion",
+                    "-name",
+                    "kMDItemCFBundleIdentifier",
+                    application_path,
+                ]
+            )
+            .strip()
+            .decode("utf-8")
+            .split("\n")
+        )
+
+        item = {
+            "path": application_path,
+        }
+
+        for line in lines:
+            raw_key, raw_value = line.split(" = ")
+
+            key = raw_key.strip()
+
+            if raw_value == "(null)":
+                item[key] = None
+            elif raw_value.startswith('"') and raw_value.endswith('"'):
+                item[key] = raw_value[1:-1]
+
+        return item
+
+    def _get_darwin_md_applications(self):
+        import concurrent.futures
+
+        try:
+            application_paths = (
+                subprocess.check_output(["mdfind", "kMDItemKind == 'Application'"])
+                .strip()
+                .decode("utf-8")
+                .split("\n")
+            )
+
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                return list(
+                    executor.map(self._get_darwin_md_application, application_paths)
+                )
+
+        except Exception:
+            pass
+
+    def _get_fedora_installed_packages(self):
+        try:
+            lines = (
+                subprocess.check_output(
+                    [
+                        "dnf",
+                        "repoquery",
+                        "--installed",
+                        "--qf",
+                        "%{name} , %{version}\n",
+                    ]
+                )
+                .decode("utf-8")
+                .strip()
+                .split("\n")
+            )
+
+            items = []
+
+            for line in lines:
+                try:
+                    name, version = line.split(" , ")
+
+                    items.append(
+                        {
+                            "name": name,
+                            "version": version,
+                        }
+                    )
+                except Exception:
+                    pass
+            return items
+        except Exception:
+            pass
+
+    def _get_ubuntu_installed_packages(self):
+        try:
+            lines = (
+                subprocess.check_output(
+                    ["apt", "list", "--installed"],
+                    stderr=subprocess.DEVNULL,
+                )
+                .decode("utf-8")
+                .strip()
+                .split("\n")
+            )
+
+            lines.pop()
+
+            items = []
+
+            for line in lines:
+                try:
+                    columns = line.split()
+
+                    if len(columns) < 2:
+                        continue
+
+                    name, version, *_ = columns
+                    items.append(
+                        {
+                            "name": name.split("/")[0],
+                            "version": version,
+                        }
+                    )
+                except Exception:
+                    pass
+
+            return items
+
+        except Exception:
+            pass
+
+    def get_system_info(self, with_installed_applications: bool = False):
         os_family = platform.system()
         system_info = {}
         if os_family == "Darwin":
@@ -294,6 +467,13 @@ class Hardware(BaseAction):
                 .decode("utf-8")
             )
             system_info["apple_mac_os_version"] = platform.mac_ver()[0]
+            system_info["homebrew_installed"] = self._get_homebrew_installed()
+
+            if with_installed_applications:
+                system_info["darwin_md_applications"] = (
+                    self._get_darwin_md_applications()
+                )
+
         elif os_family == "Linux":
             # Support for Linux-based VMs in Windows
             if "WSL2" in platform.platform():
@@ -304,6 +484,18 @@ class Hardware(BaseAction):
                 }
             else:
                 system_info = {**system_info, **self._get_ubuntu_values()}
+                system_info["linux_release"] = platform.freedesktop_os_release()
+
+                match system_info["linux_release"]["ID"]:
+                    case "ubuntu":
+                        system_info["ubuntu_installed_packages"] = (
+                            self._get_ubuntu_installed_packages()
+                        )
+                    case "fedora":
+                        system_info["fedora_installed_packages"] = (
+                            self._get_fedora_installed_packages()
+                        )
+
         elif os_family == "Windows":
             system_info = {
                 **system_info,
@@ -604,7 +796,7 @@ class Hardware(BaseAction):
         if slug is not None:
             filters["slug"] = {"exact": slug}
         if id is not None:
-            filters["id"] = {"exact": id}
+            filters["id"] = id
         # if nested_children is True:
         #     filters["hasParent"] = {"exact": False}
 
@@ -1017,3 +1209,11 @@ class Hardware(BaseAction):
         logger.info(message)
 
         return result
+
+    def push_own_system_info(self):
+        if self.primitive.messaging.ready:
+            message = {"system_info": self.primitive.hardware.get_system_info()}
+            self.primitive.messaging.send_message(
+                message_type=MESSAGE_TYPES.SYSTEM_INFO,
+                message=message,
+            )

primitive/hardware/commands.py

@@ -22,11 +22,22 @@ def cli(context):
 
 
 @cli.command("systeminfo")
+@click.option(
+    "--with-installed-applications",
+    is_flag=True,
+    default=False,
+    help="Only for MacOS, list installed applications using metadata commands",
+)
 @click.pass_context
-def systeminfo_command(context):
+def systeminfo_command(
+    context,
+    with_installed_applications: bool = False,
+):
     """Get System Info"""
     primitive: Primitive = context.obj.get("PRIMITIVE")
-    message = primitive.hardware.get_system_info()
+    message = primitive.hardware.get_system_info(
+        with_installed_applications=with_installed_applications
+    )
     print_result(message=message, context=context)
 
 

primitive/messaging/provider.py

@@ -27,6 +27,7 @@ CELERY_TASK_NAME = "hardware.tasks.task_receive_hardware_message"
 
 class MESSAGE_TYPES(enum.Enum):
     CHECK_IN = "CHECK_IN"
+    SYSTEM_INFO = "SYSTEM_INFO"
     METRICS = "METRICS"
     SWITCH_AND_INTERFACES_INFO = "SWITCH_AND_INTERFACES_INFO"
     OWN_NETWORK_INTERFACES = "OWN_NETWORK_INTERFACES"