artefacts-cli 0.9.3__py3-none-any.whl → 0.9.5__py3-none-any.whl

artefacts/cli/__init__.py

@@ -6,7 +6,6 @@ import glob
 import json
 import math
 import os
-import requests
 
 from .config import APIConf
 from .i18n import localise
@@ -33,7 +32,15 @@ except PackageNotFoundError:
         __version__ = "0.0.0"
 
 
-class AuthenticationError(Exception):
+class ArtefactsAPIError(Exception):
+    """
+    Tentative base error class for Artefacts API interactions
+    """
+
+    pass
+
+
+class AuthenticationError(ArtefactsAPIError):
     """Raised when artefacts authentication failed"""
 
     pass
@@ -52,6 +59,7 @@ class WarpJob:
         noisolation=False,
         context=None,
         run_offset=0,
+        n_subjobs=1,  # Total Number of Runs
     ):
         self.project_id = project_id
         self.job_id = os.environ.get("ARTEFACTS_JOB_ID", None)
@@ -67,28 +75,27 @@ class WarpJob:
         self.noupload = noupload
         self.noisolation = noisolation
         self.context = context
+        self.n_subjobs = n_subjobs
 
         if dryrun:
             self.job_id = "dryrun"
         if self.job_id is None:
             # Only create a new job if job_id is not specified
             data = {
+                "project_id": self.project_id,
                 "start": round(self.start),
                 "status": "in progress",
                 "params": json.dumps(self.params),
                 "project": self.project_id,
                 "jobname": self.jobname,
                 "timeout": self.params.get("timeout", 5) * 60,
+                "n_subjobs": self.n_subjobs,
             }
             if context is not None:
                 data["message"] = context["description"]
                 data["commit"] = context["commit"]
                 data["ref"] = context["ref"]
-            response = requests.post(
-                f"{api_conf.api_url}/{self.project_id}/job",
-                json=data,
-                headers=api_conf.headers,
-            )
+            response = self.api_conf.create("job", data)
             if response.status_code != 200:
                 if response.status_code == 403:
                     msg = response.json()["message"]
@@ -102,7 +109,7 @@ class WarpJob:
                     )
                 )
                 logger.warning(response.text)
-                raise AuthenticationError(str(response.status_code))
+                raise ArtefactsAPIError(str(response.status_code))
             self.job_id = response.json()["job_id"]
         self.output_path = self.params.get("output_path", f"/tmp/{self.job_id}")
         os.makedirs(self.output_path, exist_ok=True)
@@ -111,24 +118,21 @@ class WarpJob:
     def log_tests_result(self, success):
         self.success = success
 
-    def stop(self):
+    def update(self, last_run_success: bool) -> bool:
         end = datetime.now(timezone.utc).timestamp()
         if self.dryrun:
-            return
+            return True
         # Log metadata
         data = {
+            "project_id": self.project_id,
             "end": round(end),
             "duration": round(end - self.start),
-            "success": self.success,  # need to be determined based on all runs, can be an AND in the API
+            "success": last_run_success,
             "status": "finished",  # need to be determined based on all runs
         }
-        requests.put(
-            f"{self.api_conf.api_url}/{self.project_id}/job/{self.job_id}",
-            json=data,
-            headers=self.api_conf.headers,
-        )
+        response = self.api_conf.update("job", self.job_id, data)
 
-        return
+        return response.status_code == 200
 
     def new_run(self, scenario):
         run = WarpRun(self, scenario["name"], scenario, self.n_runs)
@@ -153,6 +157,7 @@ class WarpRun:
         self.logger = logger
         os.makedirs(self.output_path, exist_ok=True)
         data = {
+            "project_id": self.job.project_id,
             "job_id": job.job_id,
             "run_n": self.run_n,
             "start": round(self.start),
@@ -163,14 +168,8 @@ class WarpRun:
 
         if self.job.dryrun:
             return
-        query_url = (
-            f"{self.job.api_conf.api_url}/{self.job.project_id}/job/{job.job_id}/run"
-        )
-        response = requests.post(
-            query_url,
-            json=data,
-            headers=self.job.api_conf.headers,
-        )
+
+        response = self.job.api_conf.create("run", data)
         if response.status_code != 200:
             if response.status_code == 403:
                 msg = response.json()["message"]
@@ -184,7 +183,7 @@ class WarpRun:
                 )
             )
             self.logger.warning(response.text)
-            raise AuthenticationError(str(response.status_code))
+            raise ArtefactsAPIError(str(response.status_code))
         return
 
     def log_params(self, params):
@@ -266,6 +265,7 @@ class WarpRun:
 
         # Log metadata
         data = {
+            "project_id": self.job.project_id,
             "job_id": self.job.job_id,
             "run_n": self.run_n,
             "start": math.floor(self.start),
@@ -280,11 +280,7 @@ class WarpRun:
         if not self.job.noupload:
             data["uploads"] = self.uploads
 
-        response = requests.put(
-            f"{self.job.api_conf.api_url}/{self.job.project_id}/job/{self.job.job_id}/run/{self.run_n}",
-            json=data,
-            headers=self.job.api_conf.headers,
-        )
+        response = self.job.api_conf.update("run", self.run_n, data)
 
         # use s3 presigned urls to upload the artifacts
         if self.job.noupload:
@@ -307,11 +303,8 @@ class WarpRun:
                             )
                         )
                     )
-                    # TODO: add a retry policy
-                    requests.post(
-                        upload_info["url"],
-                        data=upload_info["fields"],
-                        files=files,
+                    self.job.api_conf.upload(
+                        upload_info["url"], upload_info["fields"], files
                     )
                 except OverflowError:
                     self.logger.warning(
@@ -342,6 +335,7 @@ def init_job(
     noisolation: bool = False,
     context: Optional[dict] = None,
     run_offset=0,
+    n_subjobs: int = 1,
 ):
     return WarpJob(
         project_id,
@@ -354,6 +348,7 @@ def init_job(
         noisolation,
         context,
         run_offset,
+        n_subjobs,
     )
 
 

artefacts/cli/app.py

@@ -20,6 +20,7 @@ from artefacts.cli import (
     init_job,
     generate_scenarios,
     localise,
+    logger,
     AuthenticationError,
     __version__,
 )
@@ -32,6 +33,7 @@ from artefacts.cli.constants import (
 )
 from artefacts.cli.helpers import (
     add_key_to_conf,
+    endpoint_exists,
     get_conf_from_file,
     get_artefacts_api_url,
     get_git_revision_branch,
@@ -64,39 +66,70 @@ def add(project_name):
         profile = config[project_name]
     else:
         profile = {}
+
     api_url = get_artefacts_api_url(profile)
     dashboard_url = api_url.split("/api")[0]
+
     settings_page_url = f"{dashboard_url}/{project_name}/settings"
-    # Check if running on WSL
-    if "WSLENV" in os.environ:
-        os.system(f'cmd.exe /C start "" {settings_page_url} 2>/dev/null')
-    else:
-        webbrowser.open(settings_page_url)
     click.echo(
         localise("Opening the project settings page: {url}").format(
             url=settings_page_url
         )
     )
-    api_key = click.prompt(
-        localise("Please enter your API KEY for {project}").format(
-            project=project_name
-        ),
-        type=str,
-        hide_input=True,
-    )
-    add_key_to_conf(project_name, api_key)
-    click.echo(localise("API KEY saved for {project}").format(project=project_name))
-    if click.confirm(
-        localise(
-            "Would you like to download the generated artefacts.yaml file? This will overwrite any existing config file in the current directory."
+
+    if endpoint_exists(settings_page_url):
+        # Check if running on WSL
+        if "WSLENV" in os.environ:
+            os.system(f'cmd.exe /C start "" {settings_page_url} 2>/dev/null')
+        else:
+            webbrowser.open(settings_page_url)
+
+        api_key = click.prompt(
+            localise("Please enter your API KEY for {project}").format(
+                project=project_name
+            ),
+            type=str,
+            hide_input=True,
+        )
+        add_key_to_conf(project_name, api_key)
+        click.echo(localise("API KEY saved for {project}").format(project=project_name))
+        if click.confirm(
+            localise(
+                "Would you like to download a pregenerated artefacts.yaml file? This will overwrite any existing config file in the current directory."
+            )
+        ):
+            config_file_name = "artefacts.yaml"
+            config_file_url = f"{api_url}/{project_name}/{config_file_name}"
+            # Get credentials only now, as API key set just before.
+            api_conf = APIConf(project_name, __version__)
+            config_response = api_conf.read("url", config_file_url)
+            if config_response.status_code == 200:
+                with open(config_file_name, "wb") as f:
+                    f.write(config_response.content)
+            else:
+                click.echo(
+                    localise(
+                        "We encountered a problem in getting the generated configuration file. Please consider downloading it from the project page on the dashboard at {url}. Sorry for the inconvenience."
+                    ).format(url=settings_page_url)
+                )
+                logger.debug(
+                    localise(
+                        "If you are using an alternative server, please also consider checking the value of ARTEFACTS_API_URL in your environment."
+                    )
+                )
+    else:
+        click.echo(
+            localise(
+                "Our apologies: The project page does not seem available at the moment. If `{project_name}` is correct, please try again later.".format(
+                    project_name=project_name
+                )
+            )
+        )
+        click.echo(
+            localise(
+                "If you are using an alternative server, please also consider checking the value of ARTEFACTS_API_URL in your environment."
+            )
         )
-    ):
-        api_conf = APIConf(project_name, __version__)
-        config_file_name = "artefacts.yaml"
-        config_file_url = f"{api_url}/{project_name}/{config_file_name}"
-        r = requests.get(config_file_url, headers=api_conf.headers)
-        with open(config_file_name, "wb") as f:
-            f.write(r.content)
     return
 
 
@@ -118,10 +151,7 @@ def delete(project_name):
 def hello(project_name):
     """Show message to confirm credentials allow access to PROJECT_NAME"""
     api_conf = APIConf(project_name, __version__)
-    response = requests.get(
-        f"{api_conf.api_url}/{project_name}/info",
-        headers=api_conf.headers,
-    )
+    response = api_conf.read("url", f"{api_conf.api_url}/{project_name}/info")
     if response.status_code == 200:
         result = response.json()
         click.echo(
@@ -360,6 +390,7 @@ def run(
             noisolation,
             context,
             first,
+            len(scenarios),
         )
     except AuthenticationError:
         click.secho(
@@ -412,6 +443,8 @@ def run(
                 )
                 run.log_tests_results([result], False)
                 run.stop()
+                warpjob.update(last_run_success=False)
+                continue
             if dryrun:
                 click.echo(f"[{jobname}] " + localise("Performing dry run"))
                 results, success = {}, True
@@ -419,7 +452,8 @@ def run(
                 try:
                     results, success = run_ros2_tests(run)
                 except Exception as e:
-                    warpjob.stop()
+                    run.stop()
+                    warpjob.update(last_run_success=False)
                     warpjob.log_tests_result(False)
                     click.secho(e, bold=True, err=True)
                     click.secho(
@@ -428,10 +462,18 @@ def run(
                         err=True,
                         bold=True,
                     )
-                    raise click.Abort()
+                    continue
             if success is None:
+                result = get_TestSuite_error_result(
+                    scenario["name"],
+                    localise("ROS2 environment error"),
+                    localise(
+                        "Not able to execute tests. Make sure that ROS2 is sourced and that your launch file syntax is correct."
+                    ),
+                )
+                run.log_tests_results([result], False)
                 run.stop()
-                warpjob.stop()
+                warpjob.update(last_run_success=False)
                 warpjob.log_tests_result(job_success)
                 click.secho(
                     f"[{jobname}] "
@@ -441,7 +483,7 @@ def run(
                     err=True,
                     bold=True,
                 )
-                raise click.Abort()
+                continue
             if not success:
                 job_success = False
         elif framework is not None and framework.startswith("ros1:"):
@@ -454,7 +496,17 @@ def run(
                     err=True,
                     bold=True,
                 )
-                raise click.Abort()
+                result = get_TestSuite_error_result(
+                    scenario["name"],
+                    localise("launch_test file not specified error"),
+                    localise(
+                        "Please specify a `ros_testfile` in the artefacts.yaml scenario configuration."
+                    ),
+                )
+                run.log_tests_results([result], False)
+                run.stop()
+                warpjob.update(last_run_success=False)
+                continue
             if dryrun:
                 click.echo(f"[{jobname}] " + localise("Performing dry run"))
                 results, success = {}, True
@@ -472,7 +524,10 @@ def run(
                     err=True,
                     bold=True,
                 )
-                raise click.Abort()
+                run.stop()
+                warpjob.update(last_run_success=False)
+                warpjob.log_tests_result(False)
+                continue
             if dryrun:
                 click.echo(f"[{jobname}] " + localise("Performing dry run"))
                 results, success = {}, True
@@ -487,12 +542,11 @@ def run(
         add_output_from_default(run)
 
         run.stop()
-    warpjob.log_tests_result(job_success)
+        warpjob.log_tests_result(job_success)
+        warpjob.update(last_run_success=run.success)
     click.echo(f"[{jobname}] " + localise("Done"))
     time.sleep(random.random() * 1)
 
-    warpjob.stop()
-
 
 @click.command()
 @click.option(
@@ -590,9 +644,10 @@ def run_remote(config, description, jobname, skip_validation=False):
         temp_file.seek(0)
 
         # Request signed upload URLs
-        upload_urls_response = requests.put(
-            f"{api_conf.api_url}/{project_id}/upload_source",
-            headers=api_conf.headers,
+        # TODO Horrible approach, but the endpoint is neither CRUD nor REST, etc.
+        #      So the idea to remain horrible and change this soon.
+        upload_urls_response = api_conf.direct("put")(
+            f"{api_conf.api_url}/{project_id}/upload_source"
         )
 
         if not upload_urls_response.ok:
@@ -694,10 +749,10 @@ def run_remote(config, description, jobname, skip_validation=False):
             item_show_func=lambda x: x and x[0],
         ) as bar:
             for filename, file in bar:
-                response = requests.post(
+                response = api_conf.upload(
                     upload_urls[filename]["url"],
-                    data=upload_urls[filename]["fields"],
-                    files={"file": file},
+                    upload_urls[filename]["fields"],
+                    {"file": file},
                 )
                 if not response.ok:
                     raise click.ClickException(

artefacts/cli/config.py

@@ -1,8 +1,16 @@
+from collections.abc import Callable
+from contextlib import contextmanager
+from functools import partial
+import logging
 import os
 import platform
-from typing import Optional
+from typing import Optional, Tuple
 
 import click
+from requests import Response, Session
+from requests.adapters import HTTPAdapter
+from requests.exceptions import ConnectionError
+from urllib3.util import Retry
 
 from artefacts.cli.i18n import localise
 from artefacts.cli.helpers import (
@@ -10,10 +18,18 @@ from artefacts.cli.helpers import (
     get_artefacts_api_url,
 )
 
+# Mask warnings from urllib, typically when it retries failed API calls
+urllib3logger = logging.getLogger("urllib3")
+urllib3logger.setLevel(logging.ERROR)
+
 
 class APIConf:
     def __init__(
-        self, project_name: str, api_version: str, job_name: Optional[str] = None
+        self,
+        project_name: str,
+        api_version: str,
+        job_name: Optional[str] = None,
+        session: Optional[Session] = None,
     ) -> None:
         config = get_conf_from_file()
         if project_name in config:
@@ -60,3 +76,135 @@ class APIConf:
                     )
                 )
             )
+
+        #
+        # Retry settings
+        #
+        self.session = session or Session()
+        retries = Retry(
+            total=3,
+            backoff_factor=0.1,
+            status_forcelist=[502, 503, 504],
+            allowed_methods=Retry.DEFAULT_ALLOWED_METHODS | {"POST"},
+        )
+        # Default connect timeout set to a small value above the default 3s for TCP
+        # Default read timeout a typical value. Does not scale when too aggressive
+        #    (note: read timeout is between byte sent, not the whole read)
+        self.request_timeout = (3.03, 27)
+        self.session.mount("https://", HTTPAdapter(max_retries=retries))
+
+    @contextmanager
+    def _api(self):
+        try:
+            yield self.session
+        except ConnectionError as e:
+            raise click.ClickException(
+                localise(
+                    "Unable to complete the operation: Network error.\n"
+                    "This may be a problem with an Artefacts server, or your network.\n"
+                    "Please try again in a moment or confirm your internet connection.\n"
+                    "If the problem persists, please contact us (info@artefacts.com)!\n"
+                    f"All we know: {e}"
+                )
+            )
+
+    def _conn_info(self, obj: str, data: Optional[dict] = None) -> Tuple[str, dict]:
+        """
+        Prepare connection information for a given resource kind (`obj`).
+
+        Returns a tuple (url, payload), where url is the endpoint for
+        the resource, and payload the prepared data that needs be sent.
+
+        Note the prepared data does not validate the content. It simply
+        remove any extra data used internally to the code here.
+        """
+        try:
+            if "url" == obj:
+                return obj, None
+            elif "job" == obj:
+                return f"{self.api_url}/{data['project_id']}/job", data
+            elif "run" == obj:
+                project_id = data.pop("project_id")
+                return f"{self.api_url}/{project_id}/job/{data['job_id']}/run", data
+            else:
+                raise Exception(
+                    f"Unable to determine API URL for unknown object kind: {obj}"
+                )
+        except KeyError as e:
+            raise Exception(f"Missing parameter for building a {obj} URL: {e}")
+
+    def create(self, obj: str, data: dict) -> Response:
+        """
+        Create a resource. Typical for endpoints of the form POST /obj
+        """
+        url, payload = self._conn_info(obj, data)
+        with self._api() as session:
+            return session.post(
+                url,
+                json=payload,
+                headers=self.headers,
+                timeout=self.request_timeout,
+            )
+
+    def read(self, obj: str, obj_id: Optional[str]) -> Response:
+        """
+        Read a resource content. Typical for endpoints of the form GET /obj/id
+        """
+        url, _ = self._conn_info(obj)
+        if obj_id:
+            url = f"{url}/{obj_id}"
+        with self._api() as session:
+            return session.get(
+                url,
+                headers=self.headers,
+                timeout=self.request_timeout,
+            )
+
+    def update(self, obj: str, obj_id: str, data: dict) -> Response:
+        """
+        Update (modify) a resource content. Typical for endpoints of the form PUT /obj/id
+        """
+        url, payload = self._conn_info(obj, data)
+        with self._api() as session:
+            return session.put(
+                f"{url}/{obj_id}",
+                json=payload,
+                headers=self.headers,
+                timeout=self.request_timeout,
+            )
+
+    def upload(self, url: str, data: dict, files: list) -> Response:
+        """
+        Upload files.
+
+        Note this is temporary helper, as we expect to turn files as
+        first-order resource at the API level, so move to CRUD model, etc.
+
+        This facility disables all timeouts, as uploads can be very
+        long, and we'd better wait.
+        """
+        with self._api() as session:
+            return session.post(
+                url,
+                data=data,
+                files=files,
+                timeout=None,
+            )
+
+    def direct(self, verb: str) -> Callable:
+        """
+        Direct access to the common session.
+
+        Important: This exposes this object session. It is not the
+        guarded session from self._api, because:
+        1. This is temporary anyway to accommodate irregular API
+           calls (that is, breach to CRUD/REST models).
+        2. Using a context manager leads to "leaking" the session,
+           without the context extras (as this returns and so exits
+           the context).
+        """
+        return partial(
+            getattr(self.session, verb),
+            headers=self.headers,
+            timeout=self.request_timeout,
+        )

artefacts/cli/helpers.py

@@ -2,6 +2,8 @@ import configparser
 import os
 import subprocess
 
+import requests
+
 from artefacts.cli.constants import CONFIG_PATH, CONFIG_DIR
 
 
@@ -53,3 +55,13 @@ def add_key_to_conf(project_name, api_key):
     config[project_name] = {"ApiKey": api_key}
     with open(CONFIG_PATH, "w") as f:
         config.write(f)
+
+
+def endpoint_exists(url: str) -> bool:
+    """
+    Simplistic confirmation of the existance of an endpoint.
+
+    Under discussion: Use of HEAD verbs, etc.
+    """
+    access_test = requests.get(url)
+    return access_test.status_code < 400