primitive 0.2.66__py3-none-any.whl → 0.2.70__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.66"
+__version__ = "0.2.70"

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/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.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
 from primitive.utils.psutil import kill_process_and_children
@@ -230,7 +232,13 @@ 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
 
                 bmc_host = self.target_hardware_secret.get("bmcHostname", None)
@@ -253,15 +261,32 @@ class Runner:
                 )
                 redfish.compute_system_reset(system_id="1", reset_type="ForceRestart")
                 if self.target_hardware_id:
-                    self.primitive.hardware.update_hardware(
+                    await self.primitive.hardware.aupdate_hardware(
                         hardware_id=self.target_hardware_id,
                         is_online=False,
                         is_rebooting=True,
-                        start_rebooting_at=datetime.now(timezone.utc),
+                        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)
@@ -290,20 +315,35 @@ class Runner:
                 )
                 redfish.compute_system_reset(system_id="1", reset_type="ForceRestart")
                 if self.target_hardware_id:
-                    self.primitive.hardware.update_hardware(
+                    await self.primitive.hardware.aupdate_hardware(
                         hardware_id=self.target_hardware_id,
                         is_online=False,
                         is_rebooting=True,
-                        start_rebooting_at=datetime.now(timezone.utc),
+                        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("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,
@@ -316,15 +356,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,
@@ -388,15 +431,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,177 @@ 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"])
+                .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 +464,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 +481,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,
@@ -981,3 +1170,39 @@ class Hardware(BaseAction):
         logger.info(message)
 
         return result
+
+    @guard
+    async def aupdate_hardware(
+        self,
+        hardware_id: str,
+        is_online: Optional[bool] = None,
+        is_rebooting: Optional[bool] = None,
+        start_rebooting_at: Optional[str] = None,
+    ):
+        new_state: dict = {
+            "id": hardware_id,
+        }
+        if is_online is not None:
+            new_state["isOnline"] = is_online
+        if is_rebooting is not None:
+            new_state["isRebooting"] = is_rebooting
+        if start_rebooting_at is not None:
+            new_state["startRebootingAt"] = start_rebooting_at
+
+        mutation = gql(hardware_update_mutation)
+
+        input = new_state
+        variables = {"input": input}
+        try:
+            result = await self.primitive.session.execute_async(
+                mutation, variable_values=variables, get_execution_result=True
+            )
+        except client_exceptions.ClientConnectorError as exception:
+            message = "Failed to update hardware! "
+            logger.exception(message)
+            raise exception
+
+        message = "Updated hardware successfully! "
+        logger.info(message)
+
+        return result

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/monitor/actions.py

@@ -191,11 +191,16 @@ class Monitor(BaseAction):
                         job_run_id = None
                     else:
                         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
+                            )
 
                         if (
                             hardware_id is not None