arthexis 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

core/tasks.py

@@ -1,17 +1,91 @@
 from __future__ import annotations
 
+import logging
 import subprocess
-from datetime import datetime
 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.utils import timezone
+
+from nodes.models import NetMessage
+
+
+AUTO_UPGRADE_HEALTH_DELAY_SECONDS = 30
+AUTO_UPGRADE_HEALTH_MAX_ATTEMPTS = 3
+
+
+logger = logging.getLogger(__name__)
+
+
+@shared_task
+def heartbeat() -> None:
+    """Log a simple heartbeat message."""
+    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."""
+
+    log_dir = base_dir / "logs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    return log_dir / "auto-upgrade.log"
+
+
+def _append_auto_upgrade_log(base_dir: Path, message: str) -> None:
+    """Append ``message`` to the auto-upgrade log, ignoring errors."""
+
+    try:
+        log_file = _auto_upgrade_log_path(base_dir)
+        timestamp = timezone.now().isoformat()
+        with log_file.open("a") as fh:
+            fh.write(f"{timestamp} {message}\n")
+    except Exception:  # pragma: no cover - best effort logging only
+        logger.warning("Failed to append auto-upgrade log entry: %s", message)
+
+
+def _resolve_service_url(base_dir: Path) -> str:
+    """Return the local URL used to probe the Django suite."""
+
+    lock_dir = base_dir / "locks"
+    mode_file = lock_dir / "nginx_mode.lck"
+    mode = "internal"
+    if mode_file.exists():
+        try:
+            mode = mode_file.read_text().strip() or "internal"
+        except OSError:
+            mode = "internal"
+    port = 8000 if mode == "public" else 8888
+    return f"http://127.0.0.1:{port}/"
 
 
 @shared_task
 def check_github_updates() -> None:
     """Check the GitHub repo for updates and upgrade if needed."""
     base_dir = Path(__file__).resolve().parent.parent
-    mode_file = base_dir / "AUTO_UPGRADE"
+    mode_file = base_dir / "locks" / "auto_upgrade.lck"
     mode = "version"
     if mode_file.exists():
         mode = mode_file.read_text().strip()
@@ -19,11 +93,11 @@ def check_github_updates() -> None:
     branch = "main"
     subprocess.run(["git", "fetch", "origin", branch], cwd=base_dir, check=True)
 
-    log_dir = base_dir / "logs"
-    log_dir.mkdir(parents=True, exist_ok=True)
-    log_file = log_dir / "auto-upgrade.log"
+    log_file = _auto_upgrade_log_path(base_dir)
     with log_file.open("a") as fh:
-        fh.write(f"{datetime.utcnow().isoformat()} check_github_updates triggered\n")
+        fh.write(
+            f"{timezone.now().isoformat()} check_github_updates triggered\n"
+        )
 
     notify = None
     startup = None
@@ -36,56 +110,94 @@ def check_github_updates() -> None:
     except Exception:
         startup = None
 
+    upgrade_stamp = timezone.now().strftime("@ %Y%m%d %H:%M")
+
+    upgrade_was_applied = False
+
     if mode == "latest":
-        local = subprocess.check_output(["git", "rev-parse", branch], cwd=base_dir).decode().strip()
-        remote = subprocess.check_output([
-            "git",
-            "rev-parse",
-            f"origin/{branch}",
-        ], cwd=base_dir).decode().strip()
+        local = (
+            subprocess.check_output(["git", "rev-parse", branch], cwd=base_dir)
+            .decode()
+            .strip()
+        )
+        remote = (
+            subprocess.check_output(
+                [
+                    "git",
+                    "rev-parse",
+                    f"origin/{branch}",
+                ],
+                cwd=base_dir,
+            )
+            .decode()
+            .strip()
+        )
         if local == remote:
             if startup:
                 startup()
             return
         if notify:
-            notify("Upgrading...", "")
+            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()
+        remote = (
+            subprocess.check_output(
+                [
+                    "git",
+                    "show",
+                    f"origin/{branch}:VERSION",
+                ],
+                cwd=base_dir,
+            )
+            .decode()
+            .strip()
+        )
         if local == remote:
             if startup:
                 startup()
             return
         if notify:
-            notify("Upgrading...", "")
+            notify("Upgrading...", upgrade_stamp)
         args = ["./upgrade.sh", "--no-restart"]
+        upgrade_was_applied = True
 
     with log_file.open("a") as fh:
-        fh.write(f"{datetime.utcnow().isoformat()} running: {' '.join(args)}\n")
+        fh.write(
+            f"{timezone.now().isoformat()} running: {' '.join(args)}\n"
+        )
 
     subprocess.run(args, cwd=base_dir, check=True)
 
     service_file = base_dir / "locks/service.lck"
     if service_file.exists():
         service = service_file.read_text().strip()
-        subprocess.run([
-            "sudo",
-            "systemctl",
-            "kill",
-            "--signal=TERM",
-            service,
-        ])
+        subprocess.run(
+            [
+                "sudo",
+                "systemctl",
+                "kill",
+                "--signal=TERM",
+                service,
+            ]
+        )
     else:
         subprocess.run(["pkill", "-f", "manage.py runserver"])
 
+    if upgrade_was_applied:
+        _append_auto_upgrade_log(
+            base_dir,
+            (
+                "Scheduled post-upgrade health check in %s seconds"
+                % AUTO_UPGRADE_HEALTH_DELAY_SECONDS
+            ),
+        )
+        _schedule_health_check(1)
+
 
 @shared_task
 def poll_email_collectors() -> None:
@@ -98,3 +210,133 @@ def poll_email_collectors() -> None:
     for collector in EmailCollector.objects.all():
         collector.collect()
 
+
+@shared_task
+def report_runtime_issue(
+    title: str,
+    body: str,
+    labels: list[str] | None = None,
+    fingerprint: str | None = None,
+):
+    """Report a runtime issue to GitHub using :mod:`core.github_issues`."""
+
+    try:
+        response = github_issues.create_issue(
+            title,
+            body,
+            labels=labels,
+            fingerprint=fingerprint,
+        )
+    except Exception:
+        logger.exception("Failed to report runtime issue '%s'", title)
+        raise
+
+    if response is None:
+        logger.info("Skipped GitHub issue creation for fingerprint %s", fingerprint)
+    else:
+        logger.info("Reported runtime issue '%s' to GitHub", title)
+
+    return response
+
+
+def _record_health_check_result(
+    base_dir: Path, attempt: int, status: int | None, detail: str
+) -> None:
+    status_display = status if status is not None else "unreachable"
+    message = "Health check attempt %s %s (%s)" % (attempt, detail, status_display)
+    _append_auto_upgrade_log(base_dir, message)
+
+
+def _schedule_health_check(next_attempt: int) -> None:
+    verify_auto_upgrade_health.apply_async(
+        kwargs={"attempt": next_attempt},
+        countdown=AUTO_UPGRADE_HEALTH_DELAY_SECONDS,
+    )
+
+
+@shared_task
+def verify_auto_upgrade_health(attempt: int = 1) -> bool | None:
+    """Verify the upgraded suite responds successfully.
+
+    When the check fails three times in a row the upgrade is rolled back by
+    invoking ``upgrade.sh --revert``.
+    """
+
+    base_dir = Path(__file__).resolve().parent.parent
+    url = _resolve_service_url(base_dir)
+    request = urllib.request.Request(
+        url,
+        headers={"User-Agent": "Arthexis-AutoUpgrade/1.0"},
+    )
+
+    status: int | None = None
+    try:
+        with urllib.request.urlopen(request, timeout=10) as response:
+            status = getattr(response, "status", response.getcode())
+    except urllib.error.HTTPError as exc:
+        status = exc.code
+        logger.warning(
+            "Auto-upgrade health check attempt %s returned HTTP %s", attempt, exc.code
+        )
+    except urllib.error.URLError as exc:
+        logger.warning(
+            "Auto-upgrade health check attempt %s failed: %s", attempt, exc
+        )
+    except Exception as exc:  # pragma: no cover - unexpected network error
+        logger.exception(
+            "Unexpected error probing suite during auto-upgrade attempt %s", attempt
+        )
+        detail = f"failed with {exc}"
+        _record_health_check_result(base_dir, attempt, status, detail)
+        if attempt >= AUTO_UPGRADE_HEALTH_MAX_ATTEMPTS:
+            _append_auto_upgrade_log(
+                base_dir,
+                "Health check raised unexpected error; reverting upgrade",
+            )
+            subprocess.run(["./upgrade.sh", "--revert"], cwd=base_dir, check=True)
+        else:
+            _schedule_health_check(attempt + 1)
+        return None
+
+    if status == 200:
+        _record_health_check_result(base_dir, attempt, status, "succeeded")
+        logger.info(
+            "Auto-upgrade health check succeeded on attempt %s with HTTP %s",
+            attempt,
+            status,
+        )
+        return True
+
+    _record_health_check_result(base_dir, attempt, status, "failed")
+
+    if attempt >= AUTO_UPGRADE_HEALTH_MAX_ATTEMPTS:
+        logger.error(
+            "Auto-upgrade health check failed after %s attempts; reverting", attempt
+        )
+        _append_auto_upgrade_log(
+            base_dir,
+            "Health check failed three times; reverting upgrade",
+        )
+        subprocess.run(["./upgrade.sh", "--revert"], cwd=base_dir, check=True)
+        return False
+
+    _schedule_health_check(attempt + 1)
+    return None
+
+
+@shared_task
+def run_client_report_schedule(schedule_id: int) -> None:
+    """Execute a :class:`core.models.ClientReportSchedule` run."""
+
+    from core.models import ClientReportSchedule
+
+    schedule = ClientReportSchedule.objects.filter(pk=schedule_id).first()
+    if not schedule:
+        logger.warning("ClientReportSchedule %s no longer exists", schedule_id)
+        return
+
+    try:
+        schedule.run()
+    except Exception:
+        logger.exception("ClientReportSchedule %s failed", schedule_id)
+        raise

core/test_system_info.py

@@ -1,11 +1,18 @@
 import os
+from pathlib import Path
+from subprocess import CompletedProcess
+from unittest.mock import patch
+
 
 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
 
 import django
+
 django.setup()
 
-from django.test import SimpleTestCase, override_settings
+from django.conf import settings
+from django.test import SimpleTestCase, TestCase, override_settings
+from nodes.models import Node, NodeFeature, NodeRole
 from core.system import _gather_info
 
 
@@ -19,3 +26,54 @@ class SystemInfoRoleTests(SimpleTestCase):
     def test_uses_settings_role(self):
         info = _gather_info()
         self.assertEqual(info["role"], "Satellite")
+
+
+class SystemInfoScreenModeTests(SimpleTestCase):
+    def test_without_lockfile(self):
+        info = _gather_info()
+        self.assertEqual(info["screen_mode"], "")
+
+    def test_with_lockfile(self):
+        lock_dir = Path(settings.BASE_DIR) / "locks"
+        lock_dir.mkdir(exist_ok=True)
+        lock_file = lock_dir / "screen_mode.lck"
+        lock_file.write_text("tft")
+        try:
+            info = _gather_info()
+            self.assertEqual(info["screen_mode"], "tft")
+        finally:
+            lock_file.unlink()
+            if not any(lock_dir.iterdir()):
+                lock_dir.rmdir()
+
+
+class SystemInfoRevisionTests(SimpleTestCase):
+    @patch("core.system.revision.get_revision", return_value="abcdef1234567890")
+    def test_includes_full_revision(self, mock_revision):
+        info = _gather_info()
+        self.assertEqual(info["revision"], "abcdef1234567890")
+        mock_revision.assert_called_once()
+
+
+class SystemInfoRunserverDetectionTests(SimpleTestCase):
+    @patch("core.system.subprocess.run")
+    def test_detects_runserver_process_port(self, mock_run):
+        mock_run.return_value = CompletedProcess(
+            args=["pgrep"],
+            returncode=0,
+            stdout="123 python manage.py runserver 0.0.0.0:8000 --noreload\n",
+        )
+
+        info = _gather_info()
+
+        self.assertTrue(info["running"])
+        self.assertEqual(info["port"], 8000)
+
+    @patch("core.system._probe_ports", return_value=(True, 8000))
+    @patch("core.system.subprocess.run", side_effect=FileNotFoundError)
+    def test_falls_back_to_port_probe_when_pgrep_missing(self, mock_run, mock_probe):
+        info = _gather_info()
+
+        self.assertTrue(info["running"])
+        self.assertEqual(info["port"], 8000)
+