argus-alm 0.15.2__py3-none-any.whl → 0.15.3__py3-none-any.whl

argus/backend/service/views_widgets/graphed_stats.py

@@ -1,180 +0,0 @@
-import logging
-from uuid import UUID
-import json
-import re
-from argus.backend.db import ScyllaCluster
-from argus.backend.plugins.sct.testrun import SCTTestRun
-from argus.backend.models.github_issue import GithubIssue, IssueLink
-from argus.backend.util.common import chunk, get_build_number
-
-LOGGER = logging.getLogger(__name__)
-
-
-class GraphedStatsService:
-    def __init__(self) -> None:
-        self.cluster = ScyllaCluster.get()
-
-    def get_graphed_stats(self, test_id: UUID, filters=None):
-        rows = SCTTestRun.filter(test_id=test_id).only([
-            "build_id",
-            "start_time",
-            "end_time",
-            "id",
-            "nemesis_data",
-            "investigation_status",
-            "packages",
-            "status"
-        ]).all()
-
-        release_data = {
-            "test_runs": [],
-            "nemesis_data": []
-        }
-
-        filter_patterns = []
-        if filters:
-            try:
-                filter_patterns = [re.compile(pattern) for pattern in json.loads(filters)]
-            except (json.JSONDecodeError, re.error) as e:
-                LOGGER.error(f"Error parsing filters: {e}")
-
-        for run in [row for row in rows if row["investigation_status"].lower() != "ignored"]:
-            # Skip if build_id matches any filter pattern
-            if filter_patterns and any(pattern.search(run["build_id"]) for pattern in filter_patterns):
-                continue
-            try:
-                version = [package.version for package in run["packages"] if package.name == "scylla-server"][0]
-            except (IndexError, TypeError):
-                version = "unknown"
-
-            duration = (run["end_time"] - run["start_time"]).total_seconds() if run["end_time"] else 0
-            release_data["test_runs"].append({
-                "build_id": run["build_id"],
-                "start_time": run["start_time"].timestamp(),
-                "duration": duration if duration > 0 else 0,
-                "status": run["status"],
-                "version": version,
-                "run_id": str(run["id"]),
-                "investigation_status": run["investigation_status"]
-            })
-
-            if run["nemesis_data"]:
-                for nemesis in [n for n in run["nemesis_data"] if n.status in ("succeeded", "failed")]:
-                    release_data["nemesis_data"].append({
-                        "version": version,
-                        "name": nemesis.name.split("disrupt_")[-1],
-                        "start_time": nemesis.start_time,
-                        "duration": nemesis.end_time - nemesis.start_time,
-                        "status": nemesis.status,
-                        "run_id": str(run["id"]),
-                        "stack_trace": nemesis.stack_trace,
-                        "build_id": run["build_id"]
-                    })
-
-        return release_data
-
-    def get_runs_details(self, run_ids: list[str]):
-        """Get detailed information for provided test runs including assignee and attached issues.
-
-        Args:
-            run_ids: List of run IDs to fetch detailed information for
-
-        Returns:
-            Dictionary mapping run IDs to their detailed information (build_id, start_time, assignee, version, and issues)
-        """
-        result = {}
-
-        if not run_ids:
-            return result
-
-        # Step 1: Get issue links for all run_ids in batches
-        all_issue_links = {}
-        for batch_run_ids in chunk(run_ids):
-            batch_links = IssueLink.objects.filter(run_id__in=batch_run_ids).only(["run_id", "issue_id"]).all()
-
-            for link in batch_links:
-                run_id_str = str(link.run_id)
-                if run_id_str not in all_issue_links:
-                    all_issue_links[run_id_str] = []
-                all_issue_links[run_id_str].append(link.issue_id)
-
-        # Step 2: Fetch all unique issue details
-        all_issue_ids = set()
-        for links in all_issue_links.values():
-            all_issue_ids.update(links)
-
-        issues_by_id = {}
-        if all_issue_ids:
-            for batch_issue_ids in chunk(list(all_issue_ids)):
-                batch_issues = GithubIssue.filter(id__in=batch_issue_ids).only(
-                    ["id", "state", "title", "number", "url"]).all()
-
-                for issue in batch_issues:
-                    issues_by_id[issue.id] = issue
-
-        # Step 3: Fetch test runs for all provided run_ids
-        test_runs = {}
-        for run_id in run_ids:
-            try:
-                test_run = SCTTestRun.filter(id=run_id).only(
-                    ["id", "status", "build_id", "start_time", "assignee", "investigation_status", "packages", "build_job_url"]).get()
-                test_runs[run_id] = test_run
-            except Exception as e:
-                LOGGER.error(f"Failed to fetch test run {run_id}: {str(e)}")
-
-        # Step 4: Build result with run and issue details
-        for run_id in run_ids:
-            try:
-                test_run = test_runs.get(run_id)
-                if not test_run:
-                    result[run_id] = {
-                        "build_id": None,
-                        "start_time": None,
-                        "assignee": None,
-                        "version": "unknown",
-                        "issues": []
-                    }
-                    continue
-
-                links = all_issue_links.get(run_id, [])
-                issues = [issues_by_id[issue_id] for issue_id in links if issue_id in issues_by_id]
-
-                build_number = get_build_number(test_run.build_job_url)
-
-                # Get Scylla version from packages
-                for pkg_name in ["scylla-server-upgraded", "scylla-server-upgrade-target", "scylla-server", "scylla-server-target"]:
-                    sut_version = next(
-                        (f"{pkg.version}-{pkg.date}" for pkg in test_run.packages if pkg.name == pkg_name), None)
-                    if sut_version:
-                        break
-                else:
-                    sut_version = "unknown"
-
-                result[run_id] = {
-                    "build_id": f"{test_run.build_id}#{build_number}",
-                    "status": test_run.status,
-                    "start_time": test_run.start_time.isoformat(),
-                    "assignee": test_run.assignee,
-                    "version": sut_version,
-                    "investigation_status": test_run.investigation_status,
-                    "issues": [
-                        {
-                            "number": issue.number,
-                            "state": issue.state,
-                            "title": issue.title,
-                            "url": issue.url,
-                        }
-                        for issue in issues
-                    ],
-                }
-            except Exception as e:
-                LOGGER.error(f"Error fetching details for run {run_id}: {str(e)}")
-                result[run_id] = {
-                    "build_id": None,
-                    "start_time": None,
-                    "assignee": None,
-                    "version": "unknown",
-                    "issues": []
-                }
-
-        return result

argus/backend/service/views_widgets/highlights.py

@@ -1,374 +0,0 @@
-from dataclasses import dataclass
-from datetime import datetime, UTC
-from uuid import UUID
-import re
-
-from flask import abort, g
-
-from argus.backend.db import ScyllaCluster
-from argus.backend.models.view_widgets import WidgetHighlights, WidgetComment
-from argus.backend.models.web import ArgusNotificationTypes, ArgusNotificationSourceTypes, ArgusUserView, User
-from argus.backend.service.notification_manager import NotificationManagerService
-from argus.backend.util.common import strip_html_tags
-
-
-@dataclass
-class Highlight:
-    view_id: UUID
-    index: int
-    created_at: datetime
-    creator_id: UUID
-    content: str
-    archived_at: datetime
-    comments_count: int
-
-    @classmethod
-    def from_db_model(cls, model: WidgetHighlights):
-        created_at = model.created_at.replace(tzinfo=UTC).timestamp()
-        archived_at = model.archived_at.replace(tzinfo=UTC).timestamp() if model.archived_at else None
-        return cls(
-            view_id=model.view_id,
-            index=model.index,
-            created_at=created_at,
-            creator_id=model.creator_id,
-            content=model.content,
-            archived_at=archived_at,
-            comments_count=model.comments_count,
-        )
-
-
-@dataclass
-class ActionItem(Highlight):
-    assignee_id: UUID | None
-    completed: bool
-
-    @classmethod
-    def from_db_model(cls, model: WidgetHighlights):
-        created_at = model.created_at.replace(tzinfo=UTC).timestamp()
-        archived_at = model.archived_at.replace(tzinfo=UTC).timestamp() if model.archived_at else None
-        return cls(
-            view_id=model.view_id,
-            index=model.index,
-            created_at=created_at,
-            creator_id=model.creator_id,
-            content=model.content,
-            archived_at=archived_at,
-            comments_count=model.comments_count,
-            assignee_id=model.assignee_id,
-            completed=model.completed,
-        )
-
-
-@dataclass
-class CommentCreate:
-    view_id: UUID
-    index: int
-    highlight_created_at: float
-    content: str
-
-
-@dataclass
-class CommentUpdate:
-    view_id: UUID
-    index: int
-    highlight_created_at: float
-    created_at: float
-    content: str
-
-
-@dataclass
-class CommentDelete:
-    view_id: UUID
-    index: int
-    highlight_created_at: float
-    created_at: float
-
-
-@dataclass
-class Comment:
-    view_id: UUID
-    index: int
-    highlight_created_at: datetime
-    created_at: datetime
-    creator_id: UUID
-    content: str
-
-    @classmethod
-    def from_db_model(cls, model: WidgetComment):
-        highlight_created_at = model.highlight_at.replace(tzinfo=UTC).timestamp()
-        created_at = model.created_at.replace(tzinfo=UTC).timestamp()
-        return cls(
-            view_id=model.view_id,
-            index=model.index,
-            highlight_created_at=highlight_created_at,
-            created_at=created_at,
-            creator_id=model.creator_id,
-            content=model.content,
-        )
-
-
-@dataclass
-class HighlightCreate:
-    view_id: UUID
-    index: int
-    content: str
-    is_task: bool
-
-
-@dataclass
-class HighlightArchive:
-    view_id: UUID
-    index: int
-    created_at: float
-
-
-@dataclass
-class HighlightUpdate:
-    view_id: UUID
-    index: int
-    created_at: float
-    content: str
-
-
-@dataclass
-class HighlightSetAssignee:
-    view_id: UUID
-    index: int
-    created_at: float
-    assignee_id: UUID | None = None
-
-    def __post_init__(self):
-        if self.assignee_id and not isinstance(self.assignee_id, UUID):
-            self.assignee_id = UUID(self.assignee_id)
-
-
-@dataclass
-class HighlightSetCompleted:
-    view_id: UUID
-    index: int
-    created_at: float
-    completed: bool
-
-
-class HighlightsService:
-
-    def __init__(self) -> None:
-        self.cluster = ScyllaCluster.get()
-        self.RE_MENTION = r"@[\w-]+"
-
-    def _process_mentions(self, content: str) -> set:
-        """Process mentions from content and return set of users to notify."""
-        content_stripped = strip_html_tags(content)
-        mentions = set()
-        for potential_mention in re.findall(self.RE_MENTION, content_stripped):
-            if user := User.exists_by_name(potential_mention.lstrip("@")):
-                mentions.add(user) if user.id != g.user.id else None
-        return mentions, content_stripped
-
-    def _send_highlight_notifications(self, mentions: set, content: str, view_id: UUID, sender_id: UUID, is_action_item: bool, is_comment: bool = False):
-        """Send notifications to mentioned users."""
-        view = ArgusUserView.get(id=view_id)
-        highlight_type = "action item" if is_action_item else "highlight"
-        for mention in mentions:
-            NotificationManagerService().send_notification(
-                receiver=mention.id,
-                sender=sender_id,
-                notification_type=ArgusNotificationTypes.ViewHighlightMention,
-                source_type=ArgusNotificationSourceTypes.ViewActionItem if is_action_item else ArgusNotificationSourceTypes.ViewHighlight,
-                source_id=view_id,
-                source_message=content,
-                content_params={
-                    "username": g.user.username,
-                    "view_id": view.id,
-                    "view_name": view.name,
-                    "display_name": view.display_name,
-                    "highlight_type": f'{highlight_type}{" comment" if is_comment else ""}',
-                    "message": content,
-                }
-            )
-
-    def create(
-            self,
-            creator: UUID,
-            payload: HighlightCreate,
-    ) -> Highlight | ActionItem:
-        mentions, content_stripped = self._process_mentions(payload.content)
-
-        highlight = WidgetHighlights(
-            view_id=payload.view_id,
-            index=payload.index,
-            created_at=datetime.now(UTC),
-            creator_id=creator,
-            content=content_stripped,
-            completed=None if not payload.is_task else False,
-            archived=datetime.fromtimestamp(0, tz=UTC),
-            comments_count=0,
-        )
-        highlight.save()
-
-        self._send_highlight_notifications(mentions, content_stripped, payload.view_id, creator, payload.is_task)
-
-        if payload.is_task:
-            return ActionItem.from_db_model(highlight)
-        return Highlight.from_db_model(highlight)
-
-    def archive_highlight(self, payload: HighlightArchive):
-        entry = WidgetHighlights.objects(
-            view_id=payload.view_id, index=payload.index, created_at=datetime.fromtimestamp(payload.created_at, tz=UTC)
-        ).first()
-        if entry:
-            entry.archived_at = datetime.now(UTC)
-            entry.save()
-
-    def unarchive_highlight(self, payload: HighlightArchive):
-        entry = WidgetHighlights.objects(
-            view_id=payload.view_id,
-            index=payload.index,
-            created_at=datetime.fromtimestamp(payload.created_at, tz=UTC)
-        ).first()
-        if entry:
-            entry.archived_at = datetime.fromtimestamp(0, tz=UTC)
-            entry.save()
-
-    def update_highlight(self, user_id: UUID, payload: HighlightUpdate) -> Highlight | ActionItem:
-        entry = WidgetHighlights.objects(
-            view_id=payload.view_id,
-            index=payload.index,
-            created_at=datetime.fromtimestamp(payload.created_at, tz=UTC)
-        ).first()
-        if not entry:
-            abort(404, description="Highlight not found")
-        if entry.creator_id != user_id:
-            abort(403, description="Not authorized to update highlight")
-
-        mentions, content_stripped = self._process_mentions(payload.content)
-        entry.content = content_stripped
-        entry.save()
-
-        self._send_highlight_notifications(mentions, content_stripped, payload.view_id,
-                                           user_id, entry.completed is not None)
-
-        if entry.completed is None:
-            return Highlight.from_db_model(entry)
-        else:
-            return ActionItem.from_db_model(entry)
-
-    def set_assignee(self, payload: HighlightSetAssignee) -> ActionItem:
-        entry = WidgetHighlights.objects(
-            view_id=payload.view_id,
-            index=payload.index,
-            created_at=datetime.fromtimestamp(payload.created_at, tz=UTC)
-        ).first()
-        if not entry or entry.completed is None:
-            abort(404, description="ActionItem not found")
-        if payload.assignee_id is None:
-            entry.assignee_id = None
-        else:
-            entry.assignee_id = payload.assignee_id
-        entry.save()
-        return ActionItem.from_db_model(entry)
-
-    def set_completed(self, payload: HighlightSetCompleted) -> ActionItem:
-        entry = WidgetHighlights.objects(
-            view_id=payload.view_id,
-            index=payload.index,
-            created_at=datetime.fromtimestamp(payload.created_at, tz=UTC)
-        ).first()
-        if not entry or entry.completed is None:
-            abort(404, description="ActionItem not found")
-        entry.completed = payload.completed
-        entry.save()
-        return ActionItem.from_db_model(entry)
-
-    def get_highlights(self, view_id: UUID, index: int) -> tuple[list[Highlight], list[ActionItem]]:
-        entries = WidgetHighlights.objects(view_id=view_id, index=index)
-        highlights = [Highlight.from_db_model(entry) for entry in entries if entry.completed is None]
-        action_items = [ActionItem.from_db_model(entry) for entry in entries if entry.completed is not None]
-        return highlights, action_items
-
-    def create_comment(self, creator_id: UUID, payload: CommentCreate) -> Comment:
-        highlight_created_at = datetime.fromtimestamp(payload.highlight_created_at, tz=UTC)
-        highlight = WidgetHighlights.objects(
-            view_id=payload.view_id, index=payload.index, created_at=highlight_created_at).first()
-        if not highlight:
-            abort(404, description="Highlight not found")
-        created_at = datetime.now(UTC)
-        mentions, content_stripped = self._process_mentions(payload.content)
-        comment = WidgetComment(
-            view_id=payload.view_id,
-            index=payload.index,
-            highlight_at=highlight_created_at,
-            created_at=created_at,
-            creator_id=creator_id,
-            content=payload.content,
-        )
-        comment.save()
-        highlight.comments_count += 1
-        highlight.save()
-        self._send_highlight_notifications(mentions, content_stripped, payload.view_id,
-                                           creator_id, highlight.completed is not None, is_comment=True)
-        return Comment.from_db_model(comment)
-
-    def update_comment(self, user_id: UUID, payload: CommentUpdate) -> Comment:
-        highlight_created_at = datetime.fromtimestamp(payload.highlight_created_at, tz=UTC)
-        created_at = datetime.fromtimestamp(payload.created_at, tz=UTC)
-        comment = WidgetComment.objects(
-            view_id=payload.view_id,
-            index=payload.index,
-            highlight_at=highlight_created_at,
-            created_at=created_at,
-        ).first()
-        if not comment:
-            abort(404, description="Comment not found")
-        if comment.creator_id != user_id:
-            abort(403, description="Not authorized to update comment")
-        mentions, content_stripped = self._process_mentions(payload.content)
-        comment.content = payload.content
-        comment.save()
-        self._send_highlight_notifications(mentions, content_stripped, payload.view_id, user_id, WidgetHighlights.objects(
-            view_id=payload.view_id, index=payload.index, created_at=highlight_created_at).first().completed is not None, is_comment=True)
-        return Comment.from_db_model(comment)
-
-    def delete_comment(self, user_id: UUID, payload: CommentDelete):
-        index = int(payload.index)
-        highlight_created_at = datetime.fromtimestamp(payload.highlight_created_at, tz=UTC)
-        created_at = datetime.fromtimestamp(payload.created_at, tz=UTC)
-        comment = WidgetComment.objects(
-            view_id=payload.view_id,
-            index=index,
-            highlight_at=highlight_created_at,
-            created_at=created_at,
-        ).first()
-        if not comment:
-            abort(404, description="Comment not found")
-        if comment.creator_id != user_id:
-            abort(403, description="Not authorized to delete comment")
-        comment.delete()
-        highlight = WidgetHighlights.objects(view_id=payload.view_id, index=index,
-                                             created_at=highlight_created_at).first()
-        if not highlight:
-            abort(404, description="Highlight not found")
-        highlight.comments_count -= 1
-        highlight.save()
-
-    def get_comments(self, view_id: UUID, index: int, highlight_created_at: float) -> list[Comment]:
-        highlight_created_at = datetime.fromtimestamp(highlight_created_at, tz=UTC)
-        comments = WidgetComment.objects(view_id=view_id, index=index, highlight_at=highlight_created_at)
-        return [Comment.from_db_model(c) for c in comments]
-
-    def send_action_notification(self, sender_id: UUID, username: str, view_id: UUID, assignee_id: UUID, action: str):
-        view = ArgusUserView.get(id=view_id)
-        NotificationManagerService().send_notification(
-            receiver=assignee_id,
-            sender=sender_id,
-            notification_type=ArgusNotificationTypes.ViewActionItemAssignee,
-            source_type=ArgusNotificationSourceTypes.ViewActionItem,
-            source_id=view_id,
-            source_message="",
-            content_params={
-                "username": username,
-                "view_name": view.name,
-                "display_name": view.display_name,
-                "action": action,
-            }
-        )

argus/backend/service/views_widgets/nemesis_stats.py

@@ -1,34 +0,0 @@
-from uuid import UUID
-
-
-from argus.backend.db import ScyllaCluster
-from argus.backend.plugins.sct.testrun import SCTTestRun
-
-
-class NemesisStatsService:
-    def __init__(self) -> None:
-        self.cluster = ScyllaCluster.get()
-
-    def get_nemesis_data(self, test_id: UUID):
-        rows = SCTTestRun.filter(test_id=test_id).only(["id", "nemesis_data", "investigation_status", "packages"]).all()
-        nemesis_data = []
-        for run in [row for row in rows if row["investigation_status"].lower() != "ignored"]:
-            try:
-                version = [package.version for package in run["packages"] if package.name == "scylla-server"][0]
-            except (IndexError, TypeError):
-                continue
-            if not run["nemesis_data"]:
-                continue
-            for nemesis in [nemesis for nemesis in run["nemesis_data"] if nemesis.status in ("succeeded", "failed")]:
-                nemesis_data.append(
-                    {
-                        "version": version,
-                        "name": nemesis.name.split("disrupt_")[-1],
-                        "start_time": nemesis.start_time,
-                        "duration": nemesis.end_time - nemesis.start_time,
-                        "status": nemesis.status,
-                        "run_id": run["id"],
-                        "stack_trace": nemesis.stack_trace,
-                    }
-                )
-        return nemesis_data

argus/backend/template_filters.py

@@ -1,27 +0,0 @@
-from functools import partial
-from datetime import datetime
-
-from argus.backend.models.web import User
-from argus.backend.util.module_loaders import is_filter, export_functions
-
-
-export_filters = partial(export_functions, module_name=__name__, attr="is_filter")
-
-
-@is_filter("from_timestamp")
-def from_timestamp_filter(timestamp: int):
-    return datetime.utcfromtimestamp(timestamp)
-
-
-@is_filter("safe_user")
-def safe_user(user: User):
-    user_dict = dict(user.items())
-    del user_dict["password"]
-    return user_dict
-
-
-@is_filter("formatted_date")
-def formatted_date(date: datetime | None):
-    if date:
-        return date.strftime("%d/%m/%Y %H:%M:%S")
-    return "#unknown"