arthexis 0.1.8__py3-none-any.whl → 0.1.10__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,44 +1,182 @@
 from __future__ import annotations
 
+from contextlib import closing
 from pathlib import Path
+import re
 import socket
 import subprocess
 import shutil
 
 from django.conf import settings
 from django.contrib import admin
-from django.shortcuts import redirect
 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-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] = {}
 
     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 ""
-    )
+    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
+    default_port = 8000 if mode == "public" else 8888
+    detected_port: int | None = None
+
+    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")
 
-    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 = ""
@@ -56,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:
@@ -83,14 +224,6 @@ 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" and info["service"]:
-            args.append("--all")
-        subprocess.Popen(args)
-        return redirect(reverse("admin:index"))
 
     context = admin.site.each_context(request)
     context.update({"title": _("System"), "info": info})