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

core/system.py

@@ -1,23 +1,93 @@
 from __future__ import annotations
 
+from contextlib import closing
 from pathlib import Path
-import io
+import re
 import socket
 import subprocess
 import shutil
-import argparse
-import time
 
-from django import forms
 from django.conf import settings
-from django.contrib import admin, messages
-from django.core.management import get_commands, load_command_class
-from django.http import Http404
-from django.shortcuts import redirect
+from django.contrib import admin
 from django.template.response import TemplateResponse
-from django.urls import path, reverse
+from django.urls import path
 from django.utils.translation import gettext_lazy as _
 
+from utils import revision
+
+
+_RUNSERVER_PORT_PATTERN = re.compile(r":(\d{2,5})(?:\D|$)")
+_RUNSERVER_PORT_FLAG_PATTERN = re.compile(r"--port(?:=|\s+)(\d{2,5})", re.IGNORECASE)
+
+
+def _parse_runserver_port(command_line: str) -> int | None:
+    """Extract the HTTP port from a runserver command line."""
+
+    for pattern in (_RUNSERVER_PORT_PATTERN, _RUNSERVER_PORT_FLAG_PATTERN):
+        match = pattern.search(command_line)
+        if match:
+            try:
+                return int(match.group(1))
+            except ValueError:
+                continue
+    return None
+
+
+def _detect_runserver_process() -> tuple[bool, int | None]:
+    """Return whether the dev server is running and the port if available."""
+
+    try:
+        result = subprocess.run(
+            ["pgrep", "-af", "manage.py runserver"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+    except FileNotFoundError:
+        return False, None
+    except Exception:
+        return False, None
+
+    if result.returncode != 0:
+        return False, None
+
+    output = result.stdout.strip()
+    if not output:
+        return False, None
+
+    port = None
+    for line in output.splitlines():
+        port = _parse_runserver_port(line)
+        if port is not None:
+            break
+
+    if port is None:
+        port = 8000
+
+    return True, port
+
+
+def _probe_ports(candidates: list[int]) -> tuple[bool, int | None]:
+    """Attempt to connect to localhost on the provided ports."""
+
+    for port in candidates:
+        try:
+            with closing(socket.create_connection(("localhost", port), timeout=0.25)):
+                return True, port
+        except OSError:
+            continue
+    return False, None
+
+
+def _port_candidates(default_port: int) -> list[int]:
+    """Return a prioritized list of ports to probe for the HTTP service."""
+
+    candidates = [default_port]
+    for port in (8000, 8888):
+        if port not in candidates:
+            candidates.append(port)
+    return candidates
+
 
 def _gather_info() -> dict:
     """Collect basic system information similar to status.sh."""
@@ -26,6 +96,7 @@ def _gather_info() -> dict:
     info: dict[str, object] = {}
 
     info["installed"] = (base_dir / ".venv").exists()
+    info["revision"] = revision.get_revision()
 
     service_file = lock_dir / "service.lck"
     info["service"] = service_file.read_text().strip() if service_file.exists() else ""
@@ -33,7 +104,8 @@ def _gather_info() -> dict:
     mode_file = lock_dir / "nginx_mode.lck"
     mode = mode_file.read_text().strip() if mode_file.exists() else "internal"
     info["mode"] = mode
-    info["port"] = 8000 if mode == "public" else 8888
+    default_port = 8000 if mode == "public" else 8888
+    detected_port: int | None = None
 
     screen_file = lock_dir / "screen_mode.lck"
     info["screen_mode"] = (
@@ -43,11 +115,68 @@ def _gather_info() -> dict:
     # Use settings.NODE_ROLE as the single source of truth for the node role.
     info["role"] = getattr(settings, "NODE_ROLE", "Terminal")
 
-    info["features"] = {
-        "celery": (lock_dir / "celery.lck").exists(),
-        "lcd_screen": (lock_dir / "lcd_screen.lck").exists(),
-        "control": (lock_dir / "control.lck").exists(),
-    }
+    features: list[dict[str, object]] = []
+    try:
+        from nodes.models import Node, NodeFeature
+    except Exception:
+        info["features"] = features
+    else:
+        feature_map: dict[str, dict[str, object]] = {}
+
+        def _add_feature(feature: NodeFeature, flag: str) -> None:
+            slug = getattr(feature, "slug", "") or ""
+            if not slug:
+                return
+            display = (getattr(feature, "display", "") or "").strip()
+            normalized = display or slug.replace("-", " ").title()
+            entry = feature_map.setdefault(
+                slug,
+                {
+                    "slug": slug,
+                    "display": normalized,
+                    "expected": False,
+                    "actual": False,
+                },
+            )
+            if display:
+                entry["display"] = display
+            entry[flag] = True
+
+        try:
+            expected_features = (
+                NodeFeature.objects.filter(roles__name=info["role"]).only("slug", "display").distinct()
+            )
+        except Exception:
+            expected_features = []
+        try:
+            for feature in expected_features:
+                _add_feature(feature, "expected")
+        except Exception:
+            pass
+
+        try:
+            local_node = Node.get_local()
+        except Exception:
+            local_node = None
+
+        actual_features = []
+        if local_node:
+            try:
+                actual_features = list(local_node.features.only("slug", "display"))
+            except Exception:
+                actual_features = []
+
+        try:
+            for feature in actual_features:
+                _add_feature(feature, "actual")
+        except Exception:
+            pass
+
+        features = sorted(
+            feature_map.values(),
+            key=lambda item: str(item.get("display", "")).lower(),
+        )
+        info["features"] = features
 
     running = False
     service_status = ""
@@ -65,17 +194,20 @@ def _gather_info() -> dict:
         except Exception:
             pass
     else:
-        try:
-            subprocess.run(
-                ["pgrep", "-f", "manage.py runserver"],
-                check=True,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-            )
+        process_running, process_port = _detect_runserver_process()
+        if process_running:
             running = True
-        except Exception:
-            running = False
+            detected_port = process_port
+
+        if not running or detected_port is None:
+            probe_running, probe_port = _probe_ports(_port_candidates(default_port))
+            if probe_running:
+                running = True
+                if detected_port is None:
+                    detected_port = probe_port
+
     info["running"] = running
+    info["port"] = detected_port if detected_port is not None else default_port
     info["service_status"] = service_status
 
     try:
@@ -92,125 +224,12 @@ def _gather_info() -> dict:
 
 def _system_view(request):
     info = _gather_info()
-    if request.method == "POST" and request.user.is_superuser:
-        action = request.POST.get("action")
-        stop_script = Path(settings.BASE_DIR) / "stop.sh"
-        args = [str(stop_script)]
-        if action == "stop":
-            password = request.POST.get("password", "")
-            if not request.user.check_password(password):
-                messages.error(request, _("Incorrect password."))
-            else:
-                lock_file = Path(settings.BASE_DIR) / "locks" / "charging.lck"
-                age = None
-                if lock_file.exists():
-                    age = time.time() - lock_file.stat().st_mtime
-                if lock_file.exists() and age is not None and age <= 600:
-                    messages.error(request, _("Charging session in progress."))
-                else:
-                    if info["service"]:
-                        args.append("--all")
-                    subprocess.Popen(args)
-                    return redirect(reverse("admin:index"))
-        elif action == "restart":
-            subprocess.Popen(args)
-            return redirect(reverse("admin:index"))
-
-    excluded = {
-        "shell",
-        "dbshell",
-        "createsuperuser",
-        "changepassword",
-        "startapp",
-        "startproject",
-        "runserver",
-    }
-    commands = sorted(cmd for cmd in get_commands().keys() if cmd not in excluded)
 
     context = admin.site.each_context(request)
-    context.update({"title": _("System"), "info": info, "commands": commands})
+    context.update({"title": _("System"), "info": info})
     return TemplateResponse(request, "admin/system.html", context)
 
 
-def _build_form(parser: argparse.ArgumentParser) -> type[forms.Form]:
-    fields: dict[str, forms.Field] = {}
-    for action in parser._actions:
-        if action.help == argparse.SUPPRESS or action.dest == "help":
-            continue
-        label = action.option_strings[0] if action.option_strings else action.dest
-        required = (
-            action.required
-            if action.option_strings
-            else action.nargs not in ["?", "*", argparse.OPTIONAL]
-        )
-        fields[action.dest] = forms.CharField(label=label, required=required)
-    return type("CommandForm", (forms.Form,), fields)
-
-
-def _system_command_view(request, command):
-    commands = get_commands()
-    if command not in commands:
-        raise Http404
-    app_name = commands[command]
-    cmd_instance = load_command_class(app_name, command)
-    parser = cmd_instance.create_parser("manage.py", command)
-    form_class = _build_form(parser)
-    form = form_class(request.POST or None)
-    output = ""
-
-    has_required = any(
-        (a.option_strings and a.required)
-        or (not a.option_strings and a.nargs not in ["?", "*", argparse.OPTIONAL])
-        for a in parser._actions
-        if a.help != argparse.SUPPRESS and a.dest != "help"
-    )
-
-    if not has_required and request.method == "GET":
-        out = io.StringIO()
-        cmd_instance.stdout = out
-        cmd_instance.stderr = out
-        try:
-            cmd_instance.run_from_argv(["manage.py", command])
-        except Exception as exc:
-            out.write(str(exc))
-        output = out.getvalue()
-        form = None
-    elif request.method == "POST" and form.is_valid():
-        argv = ["manage.py", command]
-        for action in parser._actions:
-            if action.help == argparse.SUPPRESS or action.dest == "help":
-                continue
-            val = form.cleaned_data.get(action.dest)
-            if val in (None, ""):
-                continue
-            if action.option_strings:
-                argv.append(action.option_strings[0])
-                if action.nargs != 0:
-                    argv.append(val)
-            else:
-                argv.append(val)
-        out = io.StringIO()
-        cmd_instance.stdout = out
-        cmd_instance.stderr = out
-        try:
-            cmd_instance.run_from_argv(argv)
-        except Exception as exc:
-            out.write(str(exc))
-        output = out.getvalue()
-        form = None
-
-    context = admin.site.each_context(request)
-    context.update(
-        {
-            "title": command,
-            "command_name": command,
-            "form": form,
-            "output": output,
-        }
-    )
-    return TemplateResponse(request, "admin/system_command.html", context)
-
-
 def patch_admin_system_view() -> None:
     """Add custom admin view for system information."""
     original_get_urls = admin.site.get_urls
@@ -219,11 +238,6 @@ def patch_admin_system_view() -> None:
         urls = original_get_urls()
         custom = [
             path("system/", admin.site.admin_view(_system_view), name="system"),
-            path(
-                "system/command/<str:command>/",
-                admin.site.admin_view(_system_command_view),
-                name="system_command",
-            ),
         ]
         return custom + urls
 

core/tasks.py

@@ -2,8 +2,9 @@ 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
@@ -15,6 +16,10 @@ 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__)
 
 
@@ -41,6 +46,41 @@ def birthday_greetings() -> None:
             )
 
 
+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."""
@@ -53,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
@@ -70,6 +110,10 @@ 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)
@@ -93,8 +137,9 @@ def check_github_updates() -> None:
                 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"
@@ -117,11 +162,14 @@ def check_github_updates() -> None:
                 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)
 
@@ -140,6 +188,16 @@ def check_github_updates() -> None:
     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:
@@ -181,6 +239,91 @@ def report_runtime_issue(
     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."""

core/test_system_info.py

@@ -1,5 +1,8 @@
 import os
 from pathlib import Path
+from subprocess import CompletedProcess
+from unittest.mock import patch
+
 
 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
 
@@ -8,7 +11,8 @@ import django
 django.setup()
 
 from django.conf import settings
-from django.test import SimpleTestCase, override_settings
+from django.test import SimpleTestCase, TestCase, override_settings
+from nodes.models import Node, NodeFeature, NodeRole
 from core.system import _gather_info
 
 
@@ -41,3 +45,35 @@ class SystemInfoScreenModeTests(SimpleTestCase):
             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)
+