primitive 0.2.51__tar.gz → 0.2.53__tar.gz

{primitive-0.2.51 → primitive-0.2.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: primitive
-Version: 0.2.51
+Version: 0.2.53
 Project-URL: Documentation, https://github.com//primitivecorp/primitive-cli#readme
 Project-URL: Issues, https://github.com//primitivecorp/primitive-cli/issues
 Project-URL: Source, https://github.com//primitivecorp/primitive-cli

{primitive-0.2.51 → primitive-0.2.53}/src/primitive/__about__.py

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

{primitive-0.2.51 → primitive-0.2.53}/src/primitive/agent/actions.py

@@ -89,71 +89,84 @@ class Agent(BaseAction):
                 logger.debug(f"Job Run ID: {job_run_data.get('id')}")
                 logger.debug(f"Job Name: {job_run_data.get('job').get('name')}")
 
-                logger.info(
-                    f"Setting JobRun {job_run_data.get('job').get('name')} to request_in_progress"
-                )
+                job_run_status = job_run_data.get("status", None)
 
-                job_run_status = job_run_data.get("jobRun", {}).get("status", None)
-
-                while job_run_status != "in_progress":
-                    if job_run_status == "request_completed":
-                        logger.error(
-                            f"JobRun {job_run_data.get('name')} is already completed. Exiting."
-                        )
-                        if RUNNING_IN_CONTAINER:
-                            logger.info("Running in container, exiting after job run")
-                            return
-                    elif job_run_status == "pending":
+                while True:
+                    if job_run_status == "pending":
                         # we are setting to request_in_progress here which puts a started_at time on the JobRun in the API's database
                         # any time spent pulling Git repositories, setting up, etc, counts as compute time
-                        self.primitive.jobs.job_run_update(
+                        logger.info(
+                            f"Setting JobRun {job_run_data.get('id')} to request_in_progress."
+                        )
+                        # get the status back from the job run update, this should be 'in progress'
+                        job_run_update_result = self.primitive.jobs.job_run_update(
                             id=job_run_id, status="request_in_progress"
                         )
-                    logger.info(
-                        f"Waiting for JobRun {job_run_data.get('name')} to be in_progress. Current status: {job_run_status}"
-                    )
-                    sleep(1)
+                        job_run_update_data = job_run_update_result.data
+                        if job_run_update_data is not None:
+                            # if the job_run_status is not in "in_progress", short circuit
+                            job_run_status = job_run_update_data.get(
+                                "jobRunUpdate", {}
+                            ).get("status", None)
+                    if job_run_status == "in_progress":
+                        logger.info(f"JobRun {job_run_data.get('id')} in progress.")
+                        break
+                    if (
+                        job_run_status == "request_completed"
+                        or job_run_status == "completed"
+                    ):
+                        logger.error(
+                            f"JobRun {job_run_data.get('name')} is already completed with conclusion {job_run_data.get('jobRun', {}).get('conclusion', 'unknown')}. Exiting."
+                        )
+                        break
+
                     job_run_result = self.primitive.jobs.get_job_run(id=job_run_id)
                     if job_run_result.data is not None:
                         job_run_data = job_run_result.data.get("jobRun", {})
                         job_run_status = job_run_data.get("status", None)
-
-                try:
-                    runner = Runner(
-                        primitive=self.primitive,
-                        job_run=job_run_data,
-                    )
-                    runner.setup()
-                except Exception as exception:
-                    logger.exception(
-                        f"Exception while initializing runner: {exception}"
-                    )
-                    self.primitive.jobs.job_run_update(
-                        id=job_run_id,
-                        status="request_completed",
-                        conclusion="failure",
+                    logger.info(
+                        f"Waiting for JobRun {job_run_data.get('id')} to be in_progress. Current status: {job_run_status}"
                     )
-                    continue
+                    sleep(1)
 
-                try:
-                    runner.execute_job_run()
-                except Exception as exception:
-                    logger.exception(f"Exception while executing job: {exception}")
-                    self.primitive.jobs.job_run_update(
-                        id=job_run_id,
-                        status="request_completed",
-                        conclusion="failure",
-                    )
-                finally:
-                    runner.cleanup()
+                # the backend has said it's okay for the agent to run this job
+                if job_run_status == "in_progress":
+                    try:
+                        runner = Runner(
+                            primitive=self.primitive,
+                            job_run=job_run_data,
+                        )
+                        runner.setup()
+                    except Exception as exception:
+                        logger.exception(
+                            f"Exception while initializing runner: {exception}"
+                        )
+                        self.primitive.jobs.job_run_update(
+                            id=job_run_id,
+                            status="request_completed",
+                            conclusion="failure",
+                        )
+                        continue
 
-                    # NOTE: also run scan here to force upload of artifacts
-                    # This should probably eventually be another daemon?
-                    uploader.scan()
+                    try:
+                        runner.execute_job_run()
+                    except Exception as exception:
+                        logger.exception(f"Exception while executing job: {exception}")
+                        self.primitive.jobs.job_run_update(
+                            id=job_run_id,
+                            status="request_completed",
+                            conclusion="failure",
+                        )
+                    finally:
+                        runner.cleanup()
 
-                if RUNNING_IN_CONTAINER:
-                    logger.info("Running in container, exiting after job run")
-                    break
+                        # NOTE: also run scan here to force upload of artifacts
+                        # This should probably eventually be another daemon?
+                        uploader.scan()
+
+                    if RUNNING_IN_CONTAINER:
+                        logger.info("Running in container, exiting after job run")
+                        break
 
                 sleep(5)
         except KeyboardInterrupt:

{primitive-0.2.51 → primitive-0.2.53}/src/primitive/agent/uploader.py

@@ -46,22 +46,24 @@ class Uploader:
 
         for file in files:
             try:
-                result = self.primitive.files.upload_file_direct(
+                upload_file_result = self.primitive.files.upload_file_direct(
                     path=file,
                     key_prefix=str(PurePath(file).relative_to(cache.parent).parent),
                 )
-            except Exception as exception:
-                if "is empty" in str(exception):
-                    logger.warning(f"{file} is empty, skipping upload")
-                continue
 
-            upload_id = result.data["fileUpdate"]["id"]
+                if upload_file_result and upload_file_result.data is not None:
+                    upload_file_data = upload_file_result.data
+                    upload_id = upload_file_data.get("fileUpdate", {}).get("id")
 
-            if upload_id:
-                file_ids.append(upload_id)
-                continue
+                    if upload_id:
+                        file_ids.append(upload_id)
+                        continue
 
-            logger.error(f"Unable to upload file {file}")
+                logger.error(f"Unable to upload file {file}")
+            except Exception as exception:
+                if "is empty" in str(exception):
+                    logger.warning(f"{file} is empty, skipping upload")
+                    continue
 
         # Clean up job cache
         shutil.rmtree(path=cache)