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

core/sigil_resolver.py

@@ -0,0 +1,284 @@
+import logging
+import os
+import shutil
+import subprocess
+from functools import lru_cache
+from typing import Optional
+
+from django.apps import apps
+from django.conf import settings
+from django.core import serializers
+from django.db import models
+
+from .sigil_context import get_context
+
+logger = logging.getLogger("core.entity")
+
+
+def _is_wizard_mode() -> bool:
+    """Return ``True`` when the application is running in wizard mode."""
+
+    flag = getattr(settings, "WIZARD_MODE", False)
+    if isinstance(flag, str):
+        return flag.lower() in {"1", "true", "yes", "on"}
+    return bool(flag)
+
+
+def _first_instance(model: type[models.Model]) -> Optional[models.Model]:
+    qs = model.objects
+    ordering = list(getattr(model._meta, "ordering", []))
+    if ordering:
+        qs = qs.order_by(*ordering)
+    else:
+        qs = qs.order_by("?")
+    return qs.first()
+
+
+@lru_cache(maxsize=1)
+def _find_gway_command() -> Optional[str]:
+    path = shutil.which("gway")
+    if path:
+        return path
+    for candidate in ("~/.local/bin/gway", "/usr/local/bin/gway"):
+        expanded = os.path.expanduser(candidate)
+        if os.path.isfile(expanded) and os.access(expanded, os.X_OK):
+            return expanded
+    return None
+
+
+def _resolve_with_gway(sigil: str) -> Optional[str]:
+    command = _find_gway_command()
+    if not command:
+        return None
+    timeout = 60 if _is_wizard_mode() else 1
+    try:
+        result = subprocess.run(
+            [command, "-e", sigil],
+            check=False,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            timeout=timeout,
+        )
+    except subprocess.TimeoutExpired:
+        logger.warning(
+            "gway timed out after %s seconds while resolving sigil %s",
+            timeout,
+            sigil,
+        )
+        return None
+    except Exception:
+        logger.exception("Failed executing gway for sigil %s", sigil)
+        return None
+    if result.returncode != 0:
+        logger.warning(
+            "gway exited with status %s while resolving sigil %s",
+            result.returncode,
+            sigil,
+        )
+        return None
+    return result.stdout.strip()
+
+
+def _failed_resolution(token: str) -> str:
+    sigil = f"[{token}]"
+    resolved = _resolve_with_gway(sigil)
+    if resolved is not None:
+        return resolved
+    return sigil
+
+
+def _resolve_token(token: str, current: Optional[models.Model] = None) -> str:
+    original_token = token
+    i = 0
+    n = len(token)
+    root_name = ""
+    while i < n and token[i] not in ":=.":
+        root_name += token[i]
+        i += 1
+    if not root_name:
+        return _failed_resolution(original_token)
+    filter_field = None
+    if i < n and token[i] == ":":
+        i += 1
+        field = ""
+        while i < n and token[i] != "=":
+            field += token[i]
+            i += 1
+        if i == n:
+            return _failed_resolution(original_token)
+        filter_field = field.replace("-", "_")
+    instance_id = None
+    if i < n and token[i] == "=":
+        i += 1
+        start = i
+        depth = 0
+        while i < n:
+            ch = token[i]
+            if ch == "[":
+                depth += 1
+            elif ch == "]" and depth:
+                depth -= 1
+            elif ch == "." and depth == 0:
+                break
+            i += 1
+        instance_id = token[start:i]
+    key = None
+    if i < n and token[i] == ".":
+        i += 1
+        start = i
+        while i < n and token[i] != "=":
+            i += 1
+        key = token[start:i]
+    param = None
+    if i < n and token[i] == "=":
+        param = token[i + 1 :]
+    normalized_root = root_name.replace("-", "_")
+    lookup_root = normalized_root.upper()
+    raw_key = key
+    normalized_key = None
+    key_upper = None
+    key_lower = None
+    if key:
+        normalized_key = key.replace("-", "_")
+        key_upper = normalized_key.upper()
+        key_lower = normalized_key.lower()
+    if param:
+        param = resolve_sigils(param, current)
+    if instance_id:
+        instance_id = resolve_sigils(instance_id, current)
+    SigilRoot = apps.get_model("core", "SigilRoot")
+    try:
+        root = SigilRoot.objects.get(prefix__iexact=lookup_root)
+        if root.context_type == SigilRoot.Context.CONFIG:
+            if not normalized_key:
+                return ""
+            if root.prefix.upper() == "ENV":
+                candidates = []
+                if raw_key:
+                    candidates.append(raw_key.replace("-", "_"))
+                if normalized_key:
+                    candidates.append(normalized_key)
+                if key_upper:
+                    candidates.append(key_upper)
+                if key_lower:
+                    candidates.append(key_lower)
+                seen_candidates: set[str] = set()
+                for candidate in candidates:
+                    if not candidate or candidate in seen_candidates:
+                        continue
+                    seen_candidates.add(candidate)
+                    val = os.environ.get(candidate)
+                    if val is not None:
+                        return val
+                logger.warning(
+                    "Missing environment variable for sigil [ENV.%s]",
+                    key_upper or normalized_key or raw_key or "",
+                )
+                return _failed_resolution(original_token)
+            if root.prefix.upper() == "SYS":
+                for candidate in [normalized_key, key_upper, key_lower]:
+                    if not candidate:
+                        continue
+                    sentinel = object()
+                    value = getattr(settings, candidate, sentinel)
+                    if value is not sentinel:
+                        return str(value)
+                fallback = _resolve_with_gway(f"[{original_token}]")
+                if fallback is not None:
+                    return fallback
+                return ""
+        elif root.context_type == SigilRoot.Context.ENTITY:
+            model = root.content_type.model_class() if root.content_type else None
+            instance = None
+            if model:
+                if instance_id:
+                    try:
+                        if filter_field:
+                            field_name = filter_field.lower()
+                            try:
+                                field_obj = model._meta.get_field(field_name)
+                            except Exception:
+                                field_obj = None
+                            lookup: dict[str, str] = {}
+                            if field_obj and isinstance(field_obj, models.CharField):
+                                lookup = {f"{field_name}__iexact": instance_id}
+                            else:
+                                lookup = {field_name: instance_id}
+                            instance = model.objects.filter(**lookup).first()
+                        else:
+                            instance = model.objects.filter(pk=instance_id).first()
+                    except Exception:
+                        instance = None
+                    if instance is None and not filter_field:
+                        for field in model._meta.fields:
+                            if field.unique and isinstance(field, models.CharField):
+                                instance = model.objects.filter(
+                                    **{f"{field.name}__iexact": instance_id}
+                                ).first()
+                                if instance:
+                                    break
+                elif current and isinstance(current, model):
+                    instance = current
+                else:
+                    ctx = get_context()
+                    inst_pk = ctx.get(model)
+                    if inst_pk is not None:
+                        instance = model.objects.filter(pk=inst_pk).first()
+                    if instance is None:
+                        instance = _first_instance(model)
+            if instance:
+                if normalized_key:
+                    field = next(
+                        (
+                            f
+                            for f in model._meta.fields
+                            if f.name.lower() == (key_lower or "")
+                        ),
+                        None,
+                    )
+                    if field:
+                        val = getattr(instance, field.attname)
+                        return "" if val is None else str(val)
+                    return _failed_resolution(original_token)
+                return serializers.serialize("json", [instance])
+        return _failed_resolution(original_token)
+    except SigilRoot.DoesNotExist:
+        logger.warning("Unknown sigil root [%s]", lookup_root)
+    except Exception:
+        logger.exception(
+            "Error resolving sigil [%s.%s]",
+            lookup_root,
+            key_upper or normalized_key or raw_key,
+        )
+    return _failed_resolution(original_token)
+
+
+def resolve_sigils(text: str, current: Optional[models.Model] = None) -> str:
+    result = ""
+    i = 0
+    while i < len(text):
+        if text[i] == "[":
+            depth = 1
+            j = i + 1
+            while j < len(text) and depth:
+                if text[j] == "[":
+                    depth += 1
+                elif text[j] == "]":
+                    depth -= 1
+                j += 1
+            if depth:
+                result += text[i]
+                i += 1
+                continue
+            token = text[i + 1 : j - 1]
+            result += _resolve_token(token, current)
+            i = j
+        else:
+            result += text[i]
+            i += 1
+    return result
+
+
+def resolve_sigil(sigil: str, current: Optional[models.Model] = None) -> str:
+    return resolve_sigils(sigil, current)

core/system.py

@@ -1,12 +1,18 @@
 from __future__ import annotations
 
 from pathlib import Path
+import io
 import socket
 import subprocess
 import shutil
+import argparse
+import time
 
+from django import forms
 from django.conf import settings
-from django.contrib import admin
+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.template.response import TemplateResponse
 from django.urls import path, reverse
@@ -14,7 +20,7 @@ from django.utils.translation import gettext_lazy as _
 
 
 def _gather_info() -> dict:
-    """Collect basic system information similar to status-check.sh."""
+    """Collect basic system information similar to status.sh."""
     base_dir = Path(settings.BASE_DIR)
     lock_dir = base_dir / "locks"
     info: dict[str, object] = {}
@@ -22,15 +28,18 @@ def _gather_info() -> dict:
     info["installed"] = (base_dir / ".venv").exists()
 
     service_file = lock_dir / "service.lck"
-    info["service"] = (
-        service_file.read_text().strip() if service_file.exists() else ""
-    )
+    info["service"] = service_file.read_text().strip() if service_file.exists() else ""
 
     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
 
+    screen_file = lock_dir / "screen_mode.lck"
+    info["screen_mode"] = (
+        screen_file.read_text().strip() if screen_file.exists() else ""
+    )
+
     # Use settings.NODE_ROLE as the single source of truth for the node role.
     info["role"] = getattr(settings, "NODE_ROLE", "Terminal")
 
@@ -87,16 +96,121 @@ def _system_view(request):
         action = request.POST.get("action")
         stop_script = Path(settings.BASE_DIR) / "stop.sh"
         args = [str(stop_script)]
-        if action == "stop" and info["service"]:
-            args.append("--all")
-        subprocess.Popen(args)
-        return redirect(reverse("admin:index"))
+        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})
+    context.update({"title": _("System"), "info": info, "commands": commands})
     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
@@ -105,6 +219,11 @@ 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

@@ -1,17 +1,51 @@
 from __future__ import annotations
 
+import logging
 import subprocess
 from datetime import datetime
 from pathlib import Path
 
 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
+
+
+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,
+            )
 
 
 @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()
@@ -37,12 +71,23 @@ def check_github_updates() -> None:
         startup = None
 
     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()
@@ -55,11 +100,18 @@ def check_github_updates() -> None:
         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()
@@ -76,13 +128,15 @@ def check_github_updates() -> None:
     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"])
 
@@ -98,3 +152,48 @@ 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
+
+
+@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,10 +1,13 @@
 import os
+from pathlib import Path
 
 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
 
 import django
+
 django.setup()
 
+from django.conf import settings
 from django.test import SimpleTestCase, override_settings
 from core.system import _gather_info
 
@@ -19,3 +22,22 @@ 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()