argus-alm 0.10.2__tar.gz → 0.11.0__tar.gz

{argus-alm-0.10.2 → argus_alm-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: argus-alm
-Version: 0.10.2
+Version: 0.11.0
 Summary: Argus
 Home-page: https://github.com/scylladb/argus
 License: Apache-2.0
@@ -10,9 +10,8 @@ Requires-Python: >=3.10,<4.0
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
-Requires-Dist: PyYAML (>=5.4.1,<6.0.0)
-Requires-Dist: pydantic (>=1.8.2,<2.0.0)
-Requires-Dist: scylla-driver (>=3.24.8,<4.0.0)
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: requests (>=2.26.0,<3.0.0)
 Project-URL: Repository, https://github.com/scylladb/argus
 Description-Content-Type: text/markdown
 

{argus-alm-0.10.2 → argus_alm-0.11.0}/argus/backend/plugins/core.py

@@ -122,6 +122,24 @@ class PluginModelBase(Model):
 
         return list(rows)
 
+    @classmethod
+    def get_run_meta_by_build_id(cls, build_id: str, limit: int = 10):
+        cluster = ScyllaCluster.get()
+        query = cluster.prepare("SELECT id, test_id, group_id, release_id, status, start_time, build_job_url, build_id, "
+                                f"assignee, end_time, investigation_status, heartbeat FROM {cls.table_name()} WHERE build_id = ? LIMIT ?")
+        rows = cluster.session.execute(query=query, parameters=(build_id, limit))
+
+        return list(rows)
+
+    @classmethod
+    def get_run_meta_by_run_id(cls, run_id: UUID | str):
+        cluster = ScyllaCluster.get()
+        query = cluster.prepare("SELECT id, test_id, group_id, release_id, status, start_time, build_job_url, build_id, "
+                                f"assignee, end_time, investigation_status, heartbeat FROM {cls.table_name()} WHERE id = ?")
+        rows = cluster.session.execute(query=query, parameters=(run_id,))
+
+        return list(rows)
+
     @classmethod
     def load_test_run(cls, run_id: UUID) -> 'PluginModelBase':
         raise NotImplementedError()

{argus-alm-0.10.2 → argus_alm-0.11.0}/argus/backend/plugins/sct/testrun.py

@@ -45,7 +45,7 @@ class SCTTestRunSubmissionRequest():
 
 
 class SCTTestRun(PluginModelBase):
-    __table_name__ = "test_runs_v8"
+    __table_name__ = "sct_test_run"
     _plugin_name = "scylla-cluster-tests"
 
     # Test Details

argus_alm-0.11.0/argus/backend/plugins/sirenada/model.py

@@ -0,0 +1,113 @@
+from datetime import datetime
+from uuid import UUID, uuid4
+from cassandra.cqlengine import columns
+from cassandra.cqlengine.usertype import UserType
+from cassandra.cqlengine.models import Model
+from argus.backend.db import ScyllaCluster
+from argus.backend.models.web import ArgusRelease
+from argus.backend.plugins.core import PluginModelBase
+from argus.backend.plugins.sirenada.types import RawSirenadaRequest, SirenadaPluginException
+from argus.backend.util.enums import TestStatus
+
+
+class SirenadaTest(UserType):
+    test_name = columns.Text()
+    class_name = columns.Text()
+    file_name = columns.Text()
+    browser_type = columns.Text()
+    cluster_type = columns.Text()
+    status = columns.Text()
+    duration = columns.Float()
+    message = columns.Text()
+    start_time = columns.DateTime()
+    stack_trace = columns.Text()
+    screenshot_file = columns.Text()
+    s3_folder_id = columns.Text()
+    requests_file = columns.Text()
+    sirenada_test_id = columns.Text()
+    sirenada_user = columns.Text()
+    sirenada_password = columns.Text()
+
+
+
+class SirenadaRun(PluginModelBase):
+    _plugin_name = "sirenada"
+    __table_name__ = "sirenada_run"
+    logs = columns.Map(key_type=columns.Text(), value_type=columns.Text())
+    # TODO: Legacy field name, should be renamed to product_version and abstracted
+    scylla_version = columns.Text()
+    region = columns.Text()
+    sirenada_test_ids = columns.List(value_type=columns.Text())
+    s3_folder_ids = columns.List(value_type=columns.Tuple(columns.Text(), columns.Text()))
+    browsers = columns.List(value_type=columns.Text())
+    clusters = columns.List(value_type=columns.Text())
+    sct_test_id = columns.UUID()
+    results = columns.List(value_type=columns.UserDefinedType(user_type=SirenadaTest))
+
+    @classmethod
+    def _stats_query(cls) -> str:
+        return ("SELECT id, test_id, group_id, release_id, status, start_time, build_job_url, build_id, "
+                f"assignee, end_time, investigation_status, heartbeat, scylla_version FROM {cls.table_name()} WHERE release_id = ?")
+
+    @classmethod
+    def get_distinct_product_versions(cls, release: ArgusRelease, cluster: ScyllaCluster = None) -> list[str]:
+        if not cluster:
+            cluster = ScyllaCluster.get()
+        statement = cluster.prepare(f"SELECT scylla_version FROM {cls.table_name()} WHERE release_id = ?")
+        rows = cluster.session.execute(query=statement, parameters=(release.id,))
+        unique_versions = {r["scylla_version"] for r in rows if r["scylla_version"]}
+
+        return sorted(list(unique_versions), reverse=True)
+
+    def submit_product_version(self, version: str):
+        self.scylla_version = version
+
+    def submit_logs(self, logs: dict[str, str]):
+        raise SirenadaPluginException("Log submission is not supported for Sirenada")
+
+    def finish_run(self):
+        raise SirenadaPluginException("Sirenada runs do not need finalization")
+
+    @classmethod
+    def load_test_run(cls, run_id: UUID) -> 'SirenadaRun':
+        return cls.get(id=run_id)
+
+    @classmethod
+    def submit_run(cls, request_data: RawSirenadaRequest) -> 'SirenadaRun':
+        try:
+            run = cls.get(id=UUID(request_data["run_id"]))
+        except cls.DoesNotExist:
+            run = cls()
+            run.id = request_data["run_id"]
+            run.build_id = request_data["build_id"]
+            run.start_time = datetime.utcnow()
+            run.assign_categories()
+            run.build_job_url = request_data["build_job_url"]
+            run.region = request_data["region"]
+            run.status = TestStatus.PASSED.value
+            try:
+                run.assignee = run.get_scheduled_assignee()
+            except Model.DoesNotExist:
+                run.assignee = None
+
+        for raw_case in request_data["results"]:
+            case = SirenadaTest(**raw_case)
+            if case.status in ["failed", "error"] and run.status not in [TestStatus.FAILED.value, TestStatus.ABORTED.value]:
+                run.status = TestStatus.FAILED.value
+            run.results.append(case)
+
+            if case.sirenada_test_id not in run.sirenada_test_ids:
+                run.sirenada_test_ids.append(case.sirenada_test_id)
+
+            if case.browser_type not in run.browsers:
+                run.browsers.append(case.browser_type)
+
+            if case.cluster_type not in run.clusters:
+                run.clusters.append(case.cluster_type)
+
+            if (case.s3_folder_id, case.sirenada_test_id) not in run.s3_folder_ids and case.s3_folder_id:
+                run.s3_folder_ids.append((case.s3_folder_id, case.sirenada_test_id))
+
+        run.save()
+
+        return run

argus_alm-0.11.0/argus/backend/plugins/sirenada/plugin.py

@@ -0,0 +1,17 @@
+from flask import Blueprint
+
+from argus.backend.plugins.core import PluginInfoBase, PluginModelBase
+from argus.backend.plugins.sirenada.model import SirenadaRun, SirenadaTest
+
+
+class PluginInfo(PluginInfoBase):
+    # pylint: disable=too-few-public-methods
+    name: str = "sirenada"
+    model: PluginModelBase = SirenadaRun
+    controller: Blueprint = None
+    all_models = [
+        SirenadaRun
+    ]
+    all_types = [
+        SirenadaTest
+    ]

argus_alm-0.11.0/argus/backend/plugins/sirenada/types.py

@@ -0,0 +1,35 @@
+from typing import TypedDict
+
+
+class RawSirenadaTestCase(TypedDict):
+    test_name: str
+    class_name: str
+    file_name: str
+    browser_type: str
+    cluster_type: str
+    status: str
+    duration: float
+    message: str
+    start_time: str
+    stack_trace: str
+    screenshot_file: str
+    s3_folder_id: str
+    requests_file: str
+    sirenada_test_id: str
+    sirenada_user: str
+    sirenada_password: str
+
+
+class RawSirenadaRequest(TypedDict):
+    build_id: str
+    build_job_url: str
+    run_id: str # UUID
+    region: list[str]
+    browsers: list[str]
+    clusters: list[str]
+    sct_test_id: str
+    results: list[RawSirenadaTestCase]
+
+
+class SirenadaPluginException(Exception):
+    pass

{argus-alm-0.10.2 → argus_alm-0.11.0}/argus/backend/service/stats.py

@@ -3,6 +3,7 @@ import logging
 from datetime import datetime
 from typing import TypedDict
 from uuid import UUID
+
 from argus.backend.plugins.loader import all_plugin_models
 from argus.backend.util.common import get_build_number
 from argus.backend.util.enums import TestStatus, TestInvestigationStatus
@@ -92,16 +93,28 @@ class ReleaseStats:
         self.all_tests = []
 
     def to_dict(self) -> dict:
+        converted_groups = {str(group.group.id): group.to_dict() for group in self.groups}
+        aggregated_investigation_status = {}
+        for group in converted_groups.values():
+            for investigation_status in TestInvestigationStatus:
+                current_status = aggregated_investigation_status.get(investigation_status.value, {})
+                result = {
+                    status.value: current_status.get(status.value, 0) + group.get(investigation_status.value, {}).get(status, 0)
+                    for status in TestStatus
+                }
+                aggregated_investigation_status[investigation_status.value] = result
+
         return {
             "release": dict(self.release.items()),
-            "groups": {str(group.group.id): group.to_dict() for group in self.groups},
+            "groups": converted_groups,
             "total": self.total_tests,
             **self.status_map,
             "disabled": not self.release.enabled,
             "perpetual": self.release.perpetual,
             "lastStatus": self.last_investigation_status,
             "lastInvestigationStatus": self.last_investigation_status,
-            "hasBugReport": self.has_bug_report
+            "hasBugReport": self.has_bug_report,
+            **aggregated_investigation_status
         }
 
     def collect(self, rows: list[TestRunStatRow], limited=False, force=False) -> None:
@@ -144,6 +157,15 @@ class GroupStats:
         self.tests: list[TestStats] = []
 
     def to_dict(self) -> dict:
+        converted_tests = {str(test.test.id): test.to_dict() for test in self.tests}
+        investigation_progress = {}
+        for test in converted_tests.values():
+            progress_for_status = investigation_progress.get(test["investigation_status"], {})
+            status_count = progress_for_status.get(test["status"], 0)
+            status_count += 1
+            progress_for_status[test["status"]] = status_count
+            investigation_progress[test["investigation_status"]] = progress_for_status
+
         return {
             "group": dict(self.group.items()),
             "total": self.total_tests,
@@ -151,7 +173,8 @@ class GroupStats:
             "lastStatus": self.last_status,
             "lastInvestigationStatus": self.last_investigation_status,
             "disabled": self.disabled,
-            "tests": {str(test.test.id): test.to_dict() for test in self.tests}
+            "tests": converted_tests,
+            **investigation_progress
         }
 
     def collect(self, limited=False):

{argus-alm-0.10.2 → argus_alm-0.11.0}/argus/backend/service/testrun.py

@@ -68,14 +68,14 @@ class TestRunService:
         if not plugin:
             return []
 
-        last_runs: list[PluginModelBase] = list(plugin.model.filter(build_id=test.build_system_id).limit(limit).all())
-        last_runs_ids = [run.id for run in last_runs]
+        last_runs: list[dict] = plugin.model.get_run_meta_by_build_id(build_id=test.build_system_id, limit=limit)
+        last_runs_ids = [run["id"] for run in last_runs]
         for added_run in additional_runs:
             if added_run not in last_runs_ids:
-                last_runs.append(plugin.model.get(id=added_run))
+                last_runs.extend(plugin.model.get_run_meta_by_run_id(run_id=added_run))
 
         for row in last_runs:
-            setattr(row, "build_number", get_build_number(build_job_url=row.build_job_url))
+            row["build_number"] = get_build_number(build_job_url=row["build_job_url"])
 
         return last_runs
 
@@ -391,7 +391,7 @@ class TestRunService:
             response = []
             for issue in all_issues:
                 runs = runs_by_issue.get(issue, [])
-                runs.append(issue.run_id)
+                runs.append({"test_id": issue.test_id, "run_id": issue.run_id})
                 runs_by_issue[issue] = runs
 
             for issue, runs in runs_by_issue.items():

argus_alm-0.11.0/argus/client/sirenada/client.py

@@ -0,0 +1,151 @@
+import json
+import logging
+from glob import glob, escape
+from pathlib import Path
+from typing import TypedDict
+from xml.etree import ElementTree
+
+from argus.backend.plugins.sirenada.types import RawSirenadaRequest, RawSirenadaTestCase
+
+from argus.client.base import ArgusClient
+
+
+LOGGER = logging.getLogger(__name__)
+
+class SirenadaEnv(TypedDict):
+    SIRENADA_JOB_ID: str
+    SIRENADA_BROWSER: str
+    SIRENADA_REGION: str
+    SIRENADA_CLUSTER: str
+    WORKSPACE: str
+    BUILD_NUMBER: str
+    BUILD_URL: str
+    JOB_NAME: str
+
+
+class TestCredentials(TypedDict):
+    SIRENADA_TEST_ID: str
+    SIRENADA_USER_NAME: str
+    SIRENADA_USER_PASS: str
+    SIRENADA_OTP_SECRET: str
+    ClusterID: str
+    region: str
+
+class ArgusSirenadaClient(ArgusClient):
+    test_type = "sirenada"
+    schema_version: None = "v1"
+    _junit_xml_filename = "junit_results.xml"
+    _credentials_filename = "test_credentials.json"
+    _bucket_url_template = "https://sirenada-results.s3.us-east-1.amazonaws.com/{s3_id}/{test_results_dir}/{filename}"
+    TEST_TAG_MAPPING = {
+        "failure": "failed",
+        "error": "aborted",
+        "skipped": "skipped"
+    }
+
+    def __init__(self, auth_token: str, base_url: str, api_version="v1") -> None:
+        self.results_path: Path | None = None
+        super().__init__(auth_token, base_url, api_version)
+
+    def _verify_required_files_exist(self, results_path: Path):
+        assert (results_path / self._junit_xml_filename).exists(), "Missing jUnit XML results file!"
+        assert (results_path / self._credentials_filename).exists(), "Missing test credentials file!"
+
+    @staticmethod
+    def _verify_env(env: SirenadaEnv):
+        for key in SirenadaEnv.__annotations__.keys():
+            assert env.get(key), f"Missing required key {key} in the environment"
+
+    def _set_files_for_failed_test(self, test_case: RawSirenadaTestCase):
+        test_results_dir = f"sirenada-{test_case['sirenada_test_id']}"
+        results_dir: Path = self.results_path / test_results_dir
+
+        just_class_name = test_case.get("class_name").split(".")[-1]
+        requests_pattern = f"{just_class_name}-{test_case.get('test_name')}.requests.json"
+        screenshot_pattern = f"{just_class_name}-{escape(test_case.get('test_name'))}-*.png"
+
+        if not results_dir.exists():
+            return
+
+        if not (s3_bucket_id_path := (results_dir / "s3_id")).exists():
+            return
+
+        with open(s3_bucket_id_path, "rt") as s3_id_file:
+            test_case["s3_folder_id"] = s3_id_file.read().strip()
+
+        test_case["requests_file"] = self._bucket_url_template.format(
+            s3_id=test_case.get("s3_folder_id"),
+            test_results_dir=test_results_dir,
+            filename=requests_pattern,
+        )
+
+        screenshots = glob(pathname=screenshot_pattern, root_dir=results_dir)
+        if len(screenshots) > 0:
+            test_case["screenshot_file"] = self._bucket_url_template.format(
+                s3_id=test_case.get("s3_folder_id"),
+                test_results_dir=test_results_dir,
+                filename=screenshots[0],
+            )
+
+    def _set_case_status(self, raw_case: RawSirenadaTestCase, junit_case: ElementTree.Element):
+        subelements = list(junit_case.iter())
+        if len(subelements) == 2:
+            status_node = subelements[1]
+            raw_case["status"] = self.TEST_TAG_MAPPING.get(status_node.tag, "failed")
+            raw_case["message"] = status_node.get("message", "#NO_MESSAGE")
+            raw_case["stack_trace"] = status_node.text
+            self._set_files_for_failed_test(raw_case)
+        else:
+            raw_case["status"] = "passed"
+
+    def _parse_junit_results(self, junit_xml: Path, credentials: TestCredentials, env: SirenadaEnv) -> list[RawSirenadaTestCase]:
+        etree = ElementTree.parse(source=junit_xml)
+        cases = list(etree.iter("testcase"))
+        assert len(cases) > 0, "No test cases found in test results XML."
+
+        parsed_cases: list[RawSirenadaTestCase] = []
+        for case in cases:
+            raw_case: RawSirenadaTestCase = {}
+            raw_case["class_name"] = case.get("classname", "#NO_CLASSNAME")
+            raw_case["file_name"] = case.get("file", "#NO_FILE")
+            raw_case["test_name"] = case.get("name", "#NO_TEST_NAME")
+            raw_case["browser_type"] = env.get("SIRENADA_BROWSER")
+            raw_case["cluster_type"] = env.get("SIRENADA_CLUSTER")
+            raw_case["duration"] = float(case.attrib.get("time", "0.0"))
+            raw_case["sirenada_test_id"] = credentials.get("SIRENADA_TEST_ID")
+            raw_case["sirenada_user"] = credentials.get("SIRENADA_USER_NAME")
+            raw_case["sirenada_password"] = credentials.get("SIRENADA_USER_PASS")
+            self._set_case_status(raw_case, case)
+            parsed_cases.append(raw_case)
+
+        return parsed_cases
+
+    @staticmethod
+    def _read_credentials(credentials_path: Path) -> TestCredentials:
+        with open(credentials_path, "rt") as creds_file:
+            credentials: TestCredentials = json.load(creds_file)
+
+        assert credentials.get("SIRENADA_TEST_ID"), "Credentials are missing required field: SIRENADA_TEST_ID"
+        return credentials
+
+    def submit_sirenada_run(self, env: SirenadaEnv, test_results_path: Path):
+        self.results_path = test_results_path
+        try:
+            self._verify_env(env)
+            self._verify_required_files_exist(self.results_path)
+        except AssertionError as exc:
+            LOGGER.critical("%s", exc.args[0])
+            raise exc
+
+        credentials = self._read_credentials(self.results_path / self._credentials_filename)
+        results = self._parse_junit_results(junit_xml=self.results_path / self._junit_xml_filename, credentials=credentials, env=env)
+        request_body: RawSirenadaRequest = {}
+
+        request_body["run_id"] = env.get("SIRENADA_JOB_ID")
+        request_body["build_id"] = env.get("JOB_NAME")
+        request_body["build_job_url"] = env.get("BUILD_URL")
+        request_body["region"] = env.get("SIRENADA_REGION")
+        request_body["results"] = results
+
+        response = self.submit_run(run_type=self.test_type, run_body=request_body)
+        self.check_response(response)

{argus-alm-0.10.2 → argus_alm-0.11.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "argus-alm"
-version = "0.10.2"
+version = "0.11.0"
 description = "Argus"
 authors = ["Alexey Kartashov <alexey.kartashov@scylladb.com>"]
 license = "Apache-2.0"
@@ -15,19 +15,17 @@ optional = true
 optional = true
 
 [tool.poetry.dependencies]
+requests = "^2.26.0"
 python = "^3.10"
-pydantic = "^1.8.2"
-PyYAML = "^5.4.1"
-scylla-driver = "^3.24.8"
-
 
 [tool.poetry.group.web-backend.dependencies]
+PyYAML = "^5.4.1"
+scylla-driver = "^3.24.8"
 Flask = "2.0.2"
 Flask-WTF = "1.0.0"
 Flask-Login = "0.5.0"
 humanize = "3.13.1"
 python-magic = "0.4.24"
-requests = "2.26.0"
 uwsgi = "2.0.20"
 python-jenkins = "^1.7.0"
 python-slugify = "^6.1.1"

{argus-alm-0.10.2 → argus_alm-0.11.0}/setup.py

@@ -10,24 +10,24 @@ packages = \
  'argus.backend.plugins',
  'argus.backend.plugins.driver_matrix_tests',
  'argus.backend.plugins.sct',
+ 'argus.backend.plugins.sirenada',
  'argus.backend.service',
  'argus.backend.util',
  'argus.client',
  'argus.client.driver_matrix_tests',
  'argus.client.sct',
+ 'argus.client.sirenada',
  'argus.db']
 
 package_data = \
 {'': ['*']}
 
 install_requires = \
-['PyYAML>=5.4.1,<6.0.0',
- 'pydantic>=1.8.2,<2.0.0',
- 'scylla-driver>=3.24.8,<4.0.0']
+['requests>=2.26.0,<3.0.0']
 
 setup_kwargs = {
     'name': 'argus-alm',
-    'version': '0.10.2',
+    'version': '0.11.0',
     'description': 'Argus',
     'long_description': '# Argus\n\n## Description\n\nArgus is a test tracking system intended to provide observability into automated test pipelines which use long-running resources. It allows observation of a test status, its events and its allocated resources. It also allows easy comparison between particular runs of a specific test.\n\n## Installation notes\n\n### Prerequisites\n\n- Python >=3.10.0 (system-wide or pyenv)\n\n- NodeJS >=16 (with npm)\n\n- Yarn (can be installed globally with `npm -g install yarn`)\n\n- nginx\n\n- poetry >=1.2.0b1\n\n### From source\n\n#### Production\n\nPerform the following steps:\n\nCreate a user that will be used by uwsgi:\n\n```bash\nuseradd -m -s /bin/bash argus\nsudo -iu argus\n```\n\n(Optional) Install pyenv and create a virtualenv for this user:\n\n```bash\npyenv install 3.10.0\npyenv virtualenv argus\npyenv activate argus\n```\n\nClone the project into a directory somewhere where user has full write permissions\n\n```bash\ngit clone https://github.com/scylladb/argus ~/app\ncd ~/app\n```\n\nInstall project dependencies:\n\n```bash\npoetry install --with default,dev,web-backend,docker-image\nyarn install\n```\n\nCompile frontend files from `/frontend` into `/public/dist`\n\n```bash\nyarn webpack\n```\n\nCreate a `argus.local.yaml` configuration file (used to configure database connection) and a `argus_web.yaml` (used for webapp secrets) in your application install directory.\n\n```bash\ncp argus_web.example.yaml argus_web.yaml\ncp argus.yaml argus.local.yaml\n```\n\nOpen `argus.local.yaml` and add the database connection information (contact_points, user, password and keyspace name).\n\nOpen `argus_web.yaml` and change the `SECRET_KEY` value to something secure, like a sha512 digest of random bytes. Fill out GITHUB_* variables with their respective values.\n\nCopy nginx configuration file from `docs/configs/argus.nginx.conf` to nginx virtual hosts directory:\n\nUbuntu:\n\n```bash\nsudo cp docs/configs/argus.nginx.conf /etc/nginx/sites-available/argus\nsudo ln -s /etc/nginx/sites-enabled/argus /etc/nginx/sites-available/argus\n```\n\nRHEL/Centos/Alma/Fedora:\n\n```bash\nsudo cp docs/configs/argus.nginx.conf /etc/nginx/conf.d/argus.conf\n```\n\nAdjust the webhost settings in that file as necessary, particularly `listen` and `server_name` directives.\n\nCopy systemd service file from `docs/config/argus.service` to `/etc/systemd/system` directory:\n\n```bash\nsudo cp docs/config/argus.service /etc/systemd/system\n```\n\nOpen it and adjust the path to the `start_argus.sh` script in the `ExecStart=` directive and the user/group, then reload systemd daemon configuration and enable (and optionally start) the service.\n\nWARNING: `start_argus.sh` assumes pyenv is installed into `~/.pyenv`\n\n```bash\nsudo systemctl daemon-reload\nsudo systemctl enable --now argus.service\n```\n\n#### Development\n\nClone the project into a directory somewhere\n\n```bash\ngit clone https://github.com/scylladb/argus\ncd argus\n```\n\nInstall project dependencies:\n\n```bash\npoetry install --with default,dev,web-backend,docker-image\nyarn install\n```\n\nCompile frontend files from `/frontend` into `/public/dist`. Add --watch to recompile files on change.\n\n```bash\nyarn webpack --watch\n```\n##### Configuration\nCreate a `argus.local.yaml` configuration file (used to configure database connection) and a `argus_web.yaml` (used for webapp secrets) in your application install directory.\n\nSee `Production` section for more details.\nTo configure Github authentication follow steps:\n1. Authorize OAuth App\n   1. go to your Account Settings (top right corner) -> Developer settings (left pane) -> OAuth Apps\n   2. Click Create New OAuth App button\n   3. Fill the fields (app name: `argus-dev`, homepage URL `http://localhost:5000`, Auth callback URL: `http://localhost:5000/profile/oauth/github`)\n   4. Confirm and get the tokens/ids required for config\n2. Create Jenkins token for your account\n   1. Go to `Configure` in top right corner\n   2. Click `Add new Token`\n   3. Get it and paste to config to `JENKINS_API_TOKEN` param\n##### Database Initialization\n\nYou can initialize a scylla cluster in any way you like, either using docker image with docker-compose or using cassandra cluster manager. You will need to create the keyspace manually before you can sync database models.\n\nCreate keyspace according to your configuration.\ne.g. (need to test if it works with RF=1 if not, make it 3)\n```\nCREATE KEYSPACE argus WITH replication = {\'class\': \'SimpleStrategy\', \'replication_factor\' : 1}\n```\n\nInitial sync can be done as follows:\n\n```py\nfrom argus.backend.db import ScyllaCluster\nfrom argus.db.testrun import TestRun\ndb = ScyllaCluster.get()\n\ndb.sync_models() # Syncronizes Object Mapper models\nTestRun.init_own_table() # Syncronizes TestRun table (separate from python-driver Object Mapper)\n\n```\n\nYou can also use `flask sync-models` afterwards during development when making small changes to models.\n\nIt is recommended to set up jenkins api key and run `flask scan-jenkins` afterwards to get basic release/group/test structure.\n\nThere are scripts in `./scripts` directory that can be used to download data from production, upload them into your dev db and fix their relations to other models in your instance of the application. Specifically, `download_runs_from_prod.py` requires additional config, `argus.local.prod.yaml` which is the config used to connect to the production cluster. The scripts are split to prevent mistakes and accidentally affecting production cluster.\n\n##### Configuration\n\nCreate a `argus.local.yaml` configuration file (used to configure database connection) and a `argus_web.yaml` (used for webapp secrets) in your application install directory.\n\n```bash\ncp argus_web.example.yaml argus_web.yaml\ncp argus.yaml argus.local.yaml\n```\n\nOpen `argus.local.yaml` and add the database connection information (contact_points, user, password and keyspace name).\n\nOpen `argus_web.yaml` and change the `SECRET_KEY` value to something secure, like a sha512 digest of random bytes. Fill out GITHUB_* and JENKINS_* variables with their respective values.\n\nRun the application from CLI using:\n\n```bash\nFLASK_ENV="development" FLASK_APP="argus_backend:start_server" FLASK_DEBUG=1 CQLENG_ALLOW_SCHEMA_MANAGEMENT=1 flask run\n```\n\nOmit `FLASK_DEBUG` if running your own debugger (pdb, pycharm, vscode)\n',
     'author': 'Alexey Kartashov',