arthexis 0.1.16__py3-none-any.whl → 0.1.26__py3-none-any.whl

core/tasks.py

@@ -2,24 +2,51 @@ from __future__ import annotations
 
 import logging
 import shutil
+import re
 import subprocess
 from pathlib import Path
 import urllib.error
 import urllib.request
 
 from celery import shared_task
-from django.conf import settings
-from django.contrib.auth import get_user_model
-from core import mailer
 from core import github_issues
+from django.db import DatabaseError
 from django.utils import timezone
 
-from nodes.models import NetMessage
-
 
 AUTO_UPGRADE_HEALTH_DELAY_SECONDS = 30
 AUTO_UPGRADE_SKIP_LOCK_NAME = "auto_upgrade_skip_revisions.lck"
 
+SEVERITY_NORMAL = "normal"
+SEVERITY_LOW = "low"
+SEVERITY_CRITICAL = "critical"
+
+_PackageReleaseModel = None
+
+
+def _get_package_release_model():
+    """Return the :class:`core.models.PackageRelease` model when available."""
+
+    global _PackageReleaseModel
+
+    if _PackageReleaseModel is not None:
+        return _PackageReleaseModel
+
+    try:
+        from core.models import PackageRelease  # noqa: WPS433 - runtime import
+    except Exception:  # pragma: no cover - app registry not ready
+        return None
+
+    _PackageReleaseModel = PackageRelease
+    return PackageRelease
+
+
+model = _get_package_release_model()
+if model is not None:  # pragma: no branch - runtime constant setup
+    SEVERITY_NORMAL = model.Severity.NORMAL
+    SEVERITY_LOW = model.Severity.LOW
+    SEVERITY_CRITICAL = model.Severity.CRITICAL
+
 
 logger = logging.getLogger(__name__)
 
@@ -30,23 +57,6 @@ def heartbeat() -> None:
     logger.info("Heartbeat task executed")
 
 
-@shared_task
-def birthday_greetings() -> None:
-    """Send birthday greetings to users via Net Message and email."""
-    User = get_user_model()
-    today = timezone.localdate()
-    for user in User.objects.filter(birthday=today):
-        NetMessage.broadcast("Happy bday!", user.username)
-        if user.email:
-            mailer.send(
-                "Happy bday!",
-                f"Happy bday! {user.username}",
-                [user.email],
-                settings.DEFAULT_FROM_EMAIL,
-                fail_silently=True,
-            )
-
-
 def _auto_upgrade_log_path(base_dir: Path) -> Path:
     """Return the log file used for auto-upgrade events."""
 
@@ -67,6 +77,65 @@ def _append_auto_upgrade_log(base_dir: Path, message: str) -> None:
         logger.warning("Failed to append auto-upgrade log entry: %s", message)
 
 
+def _resolve_release_severity(version: str | None) -> str:
+    """Return the stored severity for *version*, defaulting to normal."""
+
+    if not version:
+        return SEVERITY_NORMAL
+
+    model = _get_package_release_model()
+    if model is None:
+        return SEVERITY_NORMAL
+
+    try:
+        queryset = model.objects.filter(version=version)
+        release = (
+            queryset.filter(package__is_active=True).first() or queryset.first()
+        )
+    except DatabaseError:  # pragma: no cover - depends on DB availability
+        return SEVERITY_NORMAL
+
+    if not release:
+        return SEVERITY_NORMAL
+
+    severity = getattr(release, "severity", None)
+    if not severity:
+        return SEVERITY_NORMAL
+    return severity
+
+
+def _read_local_version(base_dir: Path) -> str | None:
+    """Return the local VERSION file contents when readable."""
+
+    version_path = base_dir / "VERSION"
+    if not version_path.exists():
+        return None
+    try:
+        return version_path.read_text().strip()
+    except OSError:  # pragma: no cover - filesystem error
+        return None
+
+
+def _read_remote_version(base_dir: Path, branch: str) -> str | None:
+    """Return the VERSION file from ``origin/<branch>`` when available."""
+
+    try:
+        return (
+            subprocess.check_output(
+                [
+                    "git",
+                    "show",
+                    f"origin/{branch}:VERSION",
+                ],
+                cwd=base_dir,
+            )
+            .decode()
+            .strip()
+        )
+    except subprocess.CalledProcessError:  # pragma: no cover - git failure
+        return None
+
+
 def _skip_lock_path(base_dir: Path) -> Path:
     return base_dir / "locks" / AUTO_UPGRADE_SKIP_LOCK_NAME
 
@@ -124,6 +193,21 @@ def _resolve_service_url(base_dir: Path) -> str:
     return f"http://127.0.0.1:{port}/"
 
 
+def _parse_major_minor(version: str) -> tuple[int, int] | None:
+    match = re.match(r"^\s*(\d+)\.(\d+)", version)
+    if not match:
+        return None
+    return int(match.group(1)), int(match.group(2))
+
+
+def _shares_stable_series(local: str, remote: str) -> bool:
+    local_parts = _parse_major_minor(local)
+    remote_parts = _parse_major_minor(remote)
+    if not local_parts or not remote_parts:
+        return False
+    return local_parts == remote_parts
+
+
 @shared_task
 def check_github_updates() -> None:
     """Check the GitHub repo for updates and upgrade if needed."""
@@ -179,48 +263,71 @@ def check_github_updates() -> None:
             startup()
         return
 
+    remote_version = _read_remote_version(base_dir, branch)
+    local_version = _read_local_version(base_dir)
+    remote_severity = _resolve_release_severity(remote_version)
+
     upgrade_stamp = timezone.now().strftime("@ %Y%m%d %H:%M")
 
     upgrade_was_applied = False
 
     if mode == "latest":
-        local = (
+        local_revision = (
             subprocess.check_output(["git", "rev-parse", branch], cwd=base_dir)
             .decode()
             .strip()
         )
-        if local == remote_revision:
+        if local_revision == remote_revision:
             if startup:
                 startup()
             return
+
+        if (
+            remote_version
+            and local_version
+            and remote_version != local_version
+            and remote_severity == SEVERITY_LOW
+            and _shares_stable_series(local_version, remote_version)
+        ):
+            _append_auto_upgrade_log(
+                base_dir,
+                f"Skipping auto-upgrade for low severity patch {remote_version}",
+            )
+            if startup:
+                startup()
+            return
+
         if notify:
             notify("Upgrading...", upgrade_stamp)
         args = ["./upgrade.sh", "--latest", "--no-restart"]
         upgrade_was_applied = True
     else:
-        local = "0"
-        version_file = base_dir / "VERSION"
-        if version_file.exists():
-            local = version_file.read_text().strip()
-        remote = (
-            subprocess.check_output(
-                [
-                    "git",
-                    "show",
-                    f"origin/{branch}:VERSION",
-                ],
-                cwd=base_dir,
-            )
-            .decode()
-            .strip()
-        )
-        if local == remote:
+        local_value = local_version or "0"
+        remote_value = remote_version or local_value
+
+        if local_value == remote_value:
             if startup:
                 startup()
             return
+
+        if (
+            mode == "stable"
+            and local_version
+            and remote_version
+            and remote_version != local_version
+            and _shares_stable_series(local_version, remote_version)
+            and remote_severity != SEVERITY_CRITICAL
+        ):
+            if startup:
+                startup()
+            return
+
         if notify:
             notify("Upgrading...", upgrade_stamp)
-        args = ["./upgrade.sh", "--no-restart"]
+        if mode == "stable":
+            args = ["./upgrade.sh", "--stable", "--no-restart"]
+        else:
+            args = ["./upgrade.sh", "--no-restart"]
         upgrade_was_applied = True
 
     with log_file.open("a") as fh:
@@ -230,12 +337,6 @@ def check_github_updates() -> None:
 
     subprocess.run(args, cwd=base_dir, check=True)
 
-    if shutil.which("gway"):
-        try:
-            subprocess.run(["gway", "upgrade"], check=True)
-        except subprocess.CalledProcessError:
-            logger.warning("gway upgrade failed; continuing anyway", exc_info=True)
-
     service_file = base_dir / "locks/service.lck"
     if service_file.exists():
         service = service_file.read_text().strip()
@@ -410,3 +511,28 @@ def run_client_report_schedule(schedule_id: int) -> None:
     except Exception:
         logger.exception("ClientReportSchedule %s failed", schedule_id)
         raise
+
+
+@shared_task
+def ensure_recurring_client_reports() -> None:
+    """Ensure scheduled consumer reports run for the current period."""
+
+    from core.models import ClientReportSchedule
+
+    reference = timezone.localdate()
+    schedules = ClientReportSchedule.objects.filter(
+        periodicity__in=[
+            ClientReportSchedule.PERIODICITY_DAILY,
+            ClientReportSchedule.PERIODICITY_WEEKLY,
+            ClientReportSchedule.PERIODICITY_MONTHLY,
+        ]
+    ).prefetch_related("chargers")
+
+    for schedule in schedules:
+        try:
+            schedule.generate_missing_reports(reference=reference)
+        except Exception:
+            logger.exception(
+                "Automatic consumer report generation failed for schedule %s",
+                schedule.pk,
+            )