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

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/temp_passwords.py

@@ -0,0 +1,181 @@
+"""Utilities for temporary password lock files."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import secrets
+import string
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Optional
+
+from django.conf import settings
+from django.contrib.auth.hashers import check_password, make_password
+from django.utils import timezone
+from django.utils.dateparse import parse_datetime
+
+
+DEFAULT_PASSWORD_LENGTH = 16
+DEFAULT_EXPIRATION = timedelta(hours=1)
+_SAFE_COMPONENT_RE = re.compile(r"[^A-Za-z0-9_.-]+")
+
+
+def _base_lock_dir() -> Path:
+    """Return the root directory used for temporary password lock files."""
+
+    configured = getattr(settings, "TEMP_PASSWORD_LOCK_DIR", None)
+    if configured:
+        path = Path(configured)
+    else:
+        path = Path(settings.BASE_DIR) / "locks" / "temp-passwords"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _safe_component(value: str) -> str:
+    """Return a filesystem safe component derived from ``value``."""
+
+    if not value:
+        return ""
+    safe = _SAFE_COMPONENT_RE.sub("_", value)
+    safe = safe.strip("._")
+    return safe[:64]
+
+
+def _lockfile_name(username: str) -> str:
+    """Return the filename used for the provided ``username``."""
+
+    digest = hashlib.sha256(username.encode("utf-8")).hexdigest()[:12]
+    safe = _safe_component(username)
+    if safe:
+        return f"{safe}-{digest}.json"
+    return f"user-{digest}.json"
+
+
+def _lockfile_path(username: str) -> Path:
+    """Return the lockfile path for ``username``."""
+
+    return _base_lock_dir() / _lockfile_name(username)
+
+
+def _parse_timestamp(value: str | None) -> Optional[datetime]:
+    """Return a timezone aware datetime parsed from ``value``."""
+
+    if not value:
+        return None
+    parsed = parse_datetime(value)
+    if parsed is None:
+        return None
+    if timezone.is_naive(parsed):
+        parsed = timezone.make_aware(parsed)
+    return parsed
+
+
+@dataclass(frozen=True)
+class TempPasswordEntry:
+    """Details for a temporary password stored on disk."""
+
+    username: str
+    password_hash: str
+    expires_at: datetime
+    created_at: datetime
+    path: Path
+    allow_change: bool = False
+
+    @property
+    def is_expired(self) -> bool:
+        return timezone.now() >= self.expires_at
+
+    def check_password(self, raw_password: str) -> bool:
+        """Return ``True`` if ``raw_password`` matches this entry."""
+
+        return check_password(raw_password, self.password_hash)
+
+
+def generate_password(length: int = DEFAULT_PASSWORD_LENGTH) -> str:
+    """Return a random password composed of letters and digits."""
+
+    if length <= 0:
+        raise ValueError("length must be a positive integer")
+    alphabet = string.ascii_letters + string.digits
+    return "".join(secrets.choice(alphabet) for _ in range(length))
+
+
+def store_temp_password(
+    username: str,
+    raw_password: str,
+    expires_at: Optional[datetime] = None,
+    *,
+    allow_change: bool = False,
+) -> TempPasswordEntry:
+    """Persist a temporary password for ``username`` and return the entry."""
+
+    if expires_at is None:
+        expires_at = timezone.now() + DEFAULT_EXPIRATION
+    if timezone.is_naive(expires_at):
+        expires_at = timezone.make_aware(expires_at)
+    created_at = timezone.now()
+    path = _lockfile_path(username)
+    data = {
+        "username": username,
+        "password_hash": make_password(raw_password),
+        "expires_at": expires_at.isoformat(),
+        "created_at": created_at.isoformat(),
+        "allow_change": allow_change,
+    }
+    path.write_text(json.dumps(data, indent=2, sort_keys=True))
+    return TempPasswordEntry(
+        username=username,
+        password_hash=data["password_hash"],
+        expires_at=expires_at,
+        created_at=created_at,
+        path=path,
+        allow_change=allow_change,
+    )
+
+
+def load_temp_password(username: str) -> Optional[TempPasswordEntry]:
+    """Return the stored temporary password for ``username``, if any."""
+
+    path = _lockfile_path(username)
+    if not path.exists():
+        return None
+    try:
+        data = json.loads(path.read_text())
+    except (json.JSONDecodeError, UnicodeDecodeError):
+        path.unlink(missing_ok=True)
+        return None
+
+    expires_at = _parse_timestamp(data.get("expires_at"))
+    created_at = _parse_timestamp(data.get("created_at")) or timezone.now()
+    password_hash = data.get("password_hash")
+    if not expires_at or not password_hash:
+        path.unlink(missing_ok=True)
+        return None
+
+    username = data.get("username") or username
+    allow_change_value = data.get("allow_change", False)
+    if isinstance(allow_change_value, str):
+        allow_change = allow_change_value.lower() in {"1", "true", "yes", "on"}
+    else:
+        allow_change = bool(allow_change_value)
+
+    return TempPasswordEntry(
+        username=username,
+        password_hash=password_hash,
+        expires_at=expires_at,
+        created_at=created_at,
+        path=path,
+        allow_change=allow_change,
+    )
+
+
+def discard_temp_password(username: str) -> None:
+    """Remove any stored temporary password for ``username``."""
+
+    path = _lockfile_path(username)
+    path.unlink(missing_ok=True)
+

core/test_system_info.py

@@ -1,5 +1,9 @@
+import json
 import os
 from pathlib import Path
+from subprocess import CompletedProcess
+from unittest.mock import patch
+
 
 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
 
@@ -9,7 +13,8 @@ django.setup()
 
 from django.conf import settings
 from django.test import SimpleTestCase, override_settings
-from core.system import _gather_info
+from nodes.models import Node, NodeFeature, NodeRole
+from core.system import _gather_info, get_system_sigil_values
 
 
 class SystemInfoRoleTests(SimpleTestCase):
@@ -41,3 +46,94 @@ 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 SystemInfoDatabaseTests(SimpleTestCase):
+    def test_collects_database_definitions(self):
+        info = _gather_info()
+        self.assertIn("databases", info)
+        aliases = {entry["alias"] for entry in info["databases"]}
+        self.assertIn("default", aliases)
+
+    @override_settings(
+        DATABASES={
+            "default": {
+                "ENGINE": "django.db.backends.sqlite3",
+                "NAME": Path("/tmp/db.sqlite3"),
+            }
+        }
+    )
+    def test_serializes_path_database_names(self):
+        info = _gather_info()
+        databases = info["databases"]
+        self.assertEqual(databases[0]["name"], "/tmp/db.sqlite3")
+
+
+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)
+
+
+class SystemSigilValueTests(SimpleTestCase):
+    def test_exports_values_for_sigil_resolution(self):
+        sample_info = {
+            "installed": True,
+            "revision": "abcdef",
+            "service": "gunicorn",
+            "mode": "internal",
+            "port": 8888,
+            "role": "Terminal",
+            "screen_mode": "",
+            "features": [
+                {"display": "Feature", "expected": True, "actual": False, "slug": "feature"}
+            ],
+            "running": True,
+            "service_status": "active",
+            "hostname": "example.local",
+            "ip_addresses": ["127.0.0.1"],
+            "databases": [
+                {
+                    "alias": "default",
+                    "engine": "django.db.backends.sqlite3",
+                    "name": "db.sqlite3",
+                }
+            ],
+        }
+        with patch("core.system._gather_info", return_value=sample_info):
+            values = get_system_sigil_values()
+
+        self.assertEqual(values["REVISION"], "abcdef")
+        self.assertEqual(values["RUNNING"], "True")
+        self.assertEqual(values["NGINX_MODE"], "internal (8888)")
+        self.assertEqual(values["IP_ADDRESSES"], "127.0.0.1")
+        features = json.loads(values["FEATURES"])
+        self.assertEqual(features[0]["display"], "Feature")
+        databases = json.loads(values["DATABASES"])
+        self.assertEqual(databases[0]["alias"], "default")
+