argus-alm 0.12.9__py3-none-any.whl → 0.13.0__py3-none-any.whl

argus/backend/plugins/sct/testrun.py

@@ -1,272 +0,0 @@
-from enum import Enum
-import logging
-from datetime import datetime, timezone
-from dataclasses import dataclass, field
-from typing import Optional
-from uuid import UUID
-
-from cassandra.cqlengine import columns
-from cassandra.cqlengine.models import _DoesNotExist, 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.sct.resource_setup import ResourceSetup
-from argus.backend.plugins.sct.udt import (
-    CloudInstanceDetails,
-    CloudResource,
-    CloudSetupDetails,
-    EventsBySeverity,
-    NemesisRunInfo,
-    PackageVersion,
-    PerformanceHDRHistogram
-)
-
-LOGGER = logging.getLogger(__name__)
-SCT_REGION_PROPERTY_MAP = {
-    "aws": "region_name",
-    "aws-siren": "region_name",
-    "k8s-eks": "region_name",
-    "gce": "gce_datacenter",
-    "gce-siren": "gce_datacenter",
-    "k8s-gke": "gce_datacenter",
-    "azure": "azure_region_name",
-    "default": "region_name",
-}
-
-
-class SubtestType(str, Enum):
-    GEMINI = "gemini"
-    PERFORMANCE = "performance"
-
-
-@dataclass(init=True, repr=True, frozen=True)
-class SCTTestRunSubmissionRequest():
-    schema_version: str
-    run_id: str
-    job_name: str
-    job_url: str
-    started_by: str
-    commit_id: str
-    sct_config: dict | None
-    origin_url: Optional[str] = field(default=None)
-    branch_name: Optional[str] = field(default=None)
-    runner_public_ip: Optional[str] = field(default=None)
-    runner_private_ip: Optional[str] = field(default=None)
-
-
-class SCTTestRun(PluginModelBase):
-    __table_name__ = "sct_test_run"
-    _plugin_name = "scylla-cluster-tests"
-
-    # Test Details
-    test_name = columns.Text()
-    stress_duration = columns.Float()
-    scm_revision_id = columns.Text()
-    branch_name = columns.Text()
-    origin_url = columns.Text()
-    started_by = columns.Text()
-    config_files = columns.List(value_type=columns.Text())
-    packages = columns.List(value_type=columns.UserDefinedType(user_type=PackageVersion))
-    scylla_version = columns.Text()
-    yaml_test_duration = columns.Integer()
-
-    # Test Preset Resources
-    sct_runner_host = columns.UserDefinedType(user_type=CloudInstanceDetails)
-    region_name = columns.List(value_type=columns.Text())
-    cloud_setup = columns.UserDefinedType(user_type=CloudSetupDetails)
-
-    # Test Runtime Resources
-    allocated_resources = columns.List(value_type=columns.UserDefinedType(user_type=CloudResource))
-
-    # Test Results
-    events = columns.List(value_type=columns.UserDefinedType(user_type=EventsBySeverity))
-    nemesis_data = columns.List(value_type=columns.UserDefinedType(user_type=NemesisRunInfo))
-    screenshots = columns.List(value_type=columns.Text())
-
-    # Subtest
-    subtest_name = columns.Text()
-
-    # Gemini-related fields
-    oracle_nodes_count = columns.Integer()
-    oracle_node_ami_id = columns.Text()
-    oracle_node_instance_type = columns.Text()
-    oracle_node_scylla_version = columns.Text()
-    gemini_command = columns.Text()
-    gemini_version = columns.Text()
-    gemini_status = columns.Text()
-    gemini_seed = columns.Text()
-    gemini_write_ops = columns.Integer()
-    gemini_write_errors = columns.Integer()
-    gemini_read_ops = columns.Integer()
-    gemini_read_errors = columns.Integer()
-
-    # Performance fields
-    perf_op_rate_average = columns.Double()
-    perf_op_rate_total = columns.Double()
-    perf_avg_latency_99th = columns.Double()
-    perf_avg_latency_mean = columns.Double()
-    perf_total_errors = columns.Double()
-    stress_cmd = columns.Text()
-
-    histograms = columns.List(value_type=columns.Map(key_type=columns.Text(), value_type=columns.UserDefinedType(user_type=PerformanceHDRHistogram)))
-    test_method = columns.Ascii()
-
-    @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 build_id IN ? PER PARTITION LIMIT 15")
-
-    @classmethod
-    def load_test_run(cls, run_id: UUID) -> 'SCTTestRun':
-        return cls.get(id=run_id)
-
-    @classmethod
-    def submit_run(cls, request_data: dict) -> 'SCTTestRun':
-        req = SCTTestRunSubmissionRequest(**request_data)
-        return cls.from_sct_config(req=req)
-
-    @classmethod
-    def get_distinct_product_versions(cls, release: ArgusRelease) -> list[str]:
-        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)
-
-    @classmethod
-    def get_version_data_for_release(cls, release_name: str):
-        cluster = ScyllaCluster.get()
-        release = ArgusRelease.get(name=release_name)
-        query = cluster.prepare(f"SELECT scylla_version, packages, status FROM {cls.table_name()} WHERE release_id = ?")
-        rows = cluster.session.execute(query=query, parameters=(release.id,))
-
-        return list(rows)
-
-    @classmethod
-    def get_perf_results_for_test_name(cls, build_id: str, start_time: float, test_name: str):
-        cluster = ScyllaCluster.get()
-        query = cluster.prepare(f"SELECT build_id, packages, scylla_version, test_name, perf_op_rate_average, perf_op_rate_total, "
-                                "perf_avg_latency_99th, perf_avg_latency_mean, perf_total_errors, id, start_time, build_job_url"
-                                f" FROM {cls.table_name()} WHERE build_id = ? AND start_time < ? AND test_name = ? ALLOW FILTERING")
-        rows = cluster.session.execute(query=query, parameters=(build_id, start_time, test_name))
-
-        return list(rows)
-
-    @classmethod
-    def init_sct_run(cls, req: SCTTestRunSubmissionRequest):
-        run = cls()
-        run.build_id = req.job_name
-        run.assign_categories()
-        try:
-            run.assignee = run.get_scheduled_assignee()
-        except _DoesNotExist:
-            run.assignee = None
-        run.start_time = datetime.utcnow()
-        run.id = UUID(req.run_id)  # pylint: disable=invalid-name
-        run.scm_revision_id = req.commit_id
-        if req.origin_url:
-            run.origin_url = req.origin_url
-            run.branch_name = req.branch_name
-        run.started_by = req.started_by
-        run.build_job_url = req.job_url
-
-        return run
-
-    @classmethod
-    def from_sct_config(cls, req: SCTTestRunSubmissionRequest):
-        try:
-            run = cls.get(id=req.run_id)
-        except cls.DoesNotExist:
-            run = cls.init_sct_run(req)
-            run.save()
-
-        if req.sct_config:
-            backend = req.sct_config.get("cluster_backend")
-            if duration_override := req.sct_config.get("stress_duration"):
-                run.stress_duration = float(duration_override)
-            region_key = SCT_REGION_PROPERTY_MAP.get(backend, SCT_REGION_PROPERTY_MAP["default"])
-            raw_regions = req.sct_config.get(region_key) or "undefined_region"
-            regions = raw_regions.split() if isinstance(raw_regions, str) else raw_regions
-            primary_region = regions[0]
-            if req.runner_public_ip:  # NOTE: Legacy support, not needed otherwise
-                run.sct_runner_host = CloudInstanceDetails(
-                    public_ip=req.runner_public_ip,
-                    private_ip=req.runner_private_ip,
-                    provider=backend,
-                    region=primary_region,
-                )
-            run.cloud_setup = ResourceSetup.get_resource_setup(backend=backend, sct_config=req.sct_config)
-
-            run.config_files = req.sct_config.get("config_files")
-            run.region_name = regions
-            run.test_method = req.sct_config.get("test_method")
-            run.save()
-
-        return run
-
-    def get_resources(self) -> list[CloudResource]:
-        return self.allocated_resources
-
-    def get_nemeses(self) -> list[NemesisRunInfo]:
-        return self.nemesis_data
-
-    def get_events(self) -> list[EventsBySeverity]:
-        return self.events
-
-    def submit_product_version(self, version: str):
-        self.scylla_version = version
-
-    def finish_run(self, payload: dict = None):
-        self.end_time = datetime.utcnow()
-
-    def submit_logs(self, logs: list[dict]):
-        for log in logs:
-            self.logs.append((log["log_name"], log["log_link"]))
-
-    def add_screenshot(self, screenshot_link: str):
-        self.screenshots.append(screenshot_link)
-
-    def add_nemesis(self, nemesis: NemesisRunInfo):
-        self.nemesis_data.append(nemesis)
-
-    def _add_new_event_type(self, event: EventsBySeverity):
-        self.events.append(event)
-
-    def _collect_event_message(self, event: EventsBySeverity, message: str):
-        if len(event.last_events) >= 100:
-            event.last_events = event.last_events[1:]
-
-        event.event_amount += 1
-        event.last_events.append(message)
-
-    def add_event(self, event_severity: str, event_message: str):
-        try:
-            event = next(filter(lambda v: v.severity ==
-                         event_severity, self.events))
-        except StopIteration:
-            event = EventsBySeverity(
-                severity=event_severity, event_amount=0, last_events=[])
-            self._add_new_event_type(event)
-
-        self._collect_event_message(event, event_message)
-
-    def sut_timestamp(self) -> float:
-        """converts scylla-server date to timestamp and adds revision in subseconds precision to diffirentiate
-        scylla versions from the same day. It's not perfect, but we don't know exact version time."""
-        try:
-            scylla_package_upgraded = [package for package in self.packages if package.name == "scylla-server-upgraded"][0]
-        except IndexError:
-            scylla_package_upgraded = None
-        try:
-            scylla_package = [package for package in self.packages if package.name == "scylla-server"][0]
-        except IndexError:
-            raise ValueError("Scylla package not found in packages - cannot determine SUT timestamp")
-        return (datetime.strptime(scylla_package.date, '%Y%m%d').replace(tzinfo=timezone.utc).timestamp()
-                + int(scylla_package.revision_id, 16) % 1000000 / 1000000)
-
-
-class SCTJunitReports(Model):
-    test_id = columns.UUID(primary_key=True, partition_key=True, required=True)
-    file_name = columns.Text(primary_key=True, required=True)
-    report = columns.Text(required=True)

argus/backend/plugins/sct/udt.py

@@ -1,101 +0,0 @@
-from time import time
-from cassandra.cqlengine.usertype import UserType
-from cassandra.cqlengine import columns
-
-from argus.backend.util.enums import ResourceState
-
-
-class PackageVersion(UserType):
-    __type_name__ = "PackageVersion_v2"
-    name = columns.Text()
-    version = columns.Text()
-    date = columns.Text()
-    revision_id = columns.Text()
-    build_id = columns.Text()
-
-
-    def __eq__(self, other):
-        if isinstance(other, PackageVersion):
-            return all(getattr(self, a) == getattr(other, a) for a in ["name", "version", "date", "revision_id", "build_id"])
-        return super().__eq__(other)
-
-
-class CloudInstanceDetails(UserType):
-    __type_name__ = "CloudInstanceDetails_v3"
-    provider = columns.Text()
-    region = columns.Text()
-    public_ip = columns.Text()
-    private_ip = columns.Text()
-    dc_name = columns.Text()
-    rack_name = columns.Text()
-    creation_time = columns.Integer(default=lambda: int(time()))
-    termination_time = columns.Integer(default=lambda: 0)
-    termination_reason = columns.Text(default=lambda: "")
-    shards_amount = columns.Integer(default=lambda: 0)
-
-
-class CloudNodesInfo(UserType):
-    __type_name__ = "CloudNodesInfo"
-    image_id = columns.Text()
-    instance_type = columns.Text()
-    node_amount = columns.Integer()
-    post_behaviour = columns.Text()
-
-
-class CloudSetupDetails(UserType):
-    __type_name__ = "CloudSetupDetails"
-    db_node = columns.UserDefinedType(user_type=CloudNodesInfo)
-    loader_node = columns.UserDefinedType(user_type=CloudNodesInfo)
-    monitor_node = columns.UserDefinedType(user_type=CloudNodesInfo)
-    backend = columns.Text()
-
-
-class CloudResource(UserType):
-    __type_name__ = "CloudResource_v3"
-    name = columns.Text()
-    state = columns.Text(default=lambda: ResourceState.RUNNING)
-    resource_type = columns.Text()
-    instance_info = columns.UserDefinedType(user_type=CloudInstanceDetails)
-
-    def get_instance_info(self) -> CloudInstanceDetails:
-        return self.instance_info
-
-
-class EventsBySeverity(UserType):
-    __type_name__ = "EventsBySeverity"
-    severity = columns.Text()
-    event_amount = columns.Integer()
-    last_events = columns.List(value_type=columns.Text())
-
-
-class NodeDescription(UserType):
-    __type_name__ = "NodeDescription"
-    name = columns.Text()
-    ip = columns.Text()
-    shards = columns.Integer()
-
-
-class NemesisRunInfo(UserType):
-    __type_name__ = "NemesisRunInfo"
-
-    class_name = columns.Text()
-    name = columns.Text()
-    duration = columns.Integer()
-    target_node = columns.UserDefinedType(user_type=NodeDescription)
-    status = columns.Text()
-    start_time = columns.Integer()
-    end_time = columns.Integer()
-    stack_trace = columns.Text()
-
-
-class PerformanceHDRHistogram(UserType):
-    start_time = columns.Integer()
-    percentile_90 = columns.Float()
-    percentile_50 = columns.Float()
-    percentile_99_999 = columns.Float()
-    percentile_95 = columns.Float()
-    end_time = columns.Float()
-    percentile_99_99 = columns.Float()
-    percentile_99 = columns.Float()
-    stddev = columns.Float()
-    percentile_99_9 = columns.Float()

argus/backend/plugins/sirenada/model.py

@@ -1,113 +0,0 @@
-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 build_id IN ? PER PARTITION LIMIT 15")
-
-    @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, payload: dict = None):
-        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"] # FIXME: Validate pls
-            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/backend/plugins/sirenada/plugin.py

@@ -1,17 +0,0 @@
-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/backend/service/admin.py

@@ -1,27 +0,0 @@
-
-from flask import g, current_app, session
-
-from argus.backend.db import ScyllaCluster
-from argus.backend.models.web import (
-    ArgusGithubIssue,
-    ArgusRelease,
-    ArgusGroup,
-    ArgusTest,
-    ArgusSchedule,
-    ArgusScheduleAssignee,
-    ArgusScheduleGroup,
-    ArgusScheduleTest,
-    ArgusTestRunComment,
-    ArgusEvent,
-    ArgusEventTypes,
-    ReleasePlannerComment,
-    User,
-    UserOauthToken,
-    WebFileStorage,
-)
-
-
-class AdminService:
-    def __init__(self, database_session=None):
-        self.session = database_session if database_session else ScyllaCluster.get_session()
-        self.database = ScyllaCluster.get()