arthexis 0.1.20__py3-none-any.whl → 0.1.22__py3-none-any.whl

nodes/admin.py

@@ -11,14 +11,17 @@ from django.db.models import Count
 from django.http import Http404, HttpResponse, JsonResponse
 from django.shortcuts import redirect, render
 from django.template.response import TemplateResponse
+from django.test import signals
 from django.urls import NoReverseMatch, path, reverse
 from django.utils import timezone
 from django.utils.dateparse import parse_datetime
 from django.utils.html import format_html, format_html_join
 from django.utils.translation import gettext_lazy as _
 from pathlib import Path
-from urllib.parse import urlsplit, urlunsplit
+from types import SimpleNamespace
+from urllib.parse import urlparse, urlsplit, urlunsplit
 import base64
+import ipaddress
 import json
 import subprocess
 import uuid
@@ -84,7 +87,7 @@ class NodeFeatureAssignmentInline(admin.TabularInline):
 
 class DeployDNSRecordsForm(forms.Form):
     manager = forms.ModelChoiceField(
-        label="Node Manager",
+        label="Node Profile",
         queryset=NodeManager.objects.none(),
         help_text="Credentials used to authenticate with the DNS provider.",
     )
@@ -233,6 +236,7 @@ class NodeAdmin(EntityModelAdmin):
         "role",
         "relation",
         "last_seen",
+        "visit_link",
         "proxy_link",
     )
     search_fields = ("hostname", "address", "mac_address")
@@ -302,6 +306,49 @@ class NodeAdmin(EntityModelAdmin):
             return ""
         return format_html('<a class="button" href="{}">{}</a>', url, _("Proxy"))
 
+    @admin.display(description=_("Visit"))
+    def visit_link(self, obj):
+        if not obj:
+            return ""
+        if obj.is_local:
+            try:
+                url = reverse("admin:index")
+            except NoReverseMatch:
+                return ""
+            return format_html(
+                '<a href="{}" target="_blank" rel="noopener noreferrer">{}</a>',
+                url,
+                _("Visit"),
+            )
+
+        host_values: list[str] = []
+        for attr in ("hostname", "address", "public_endpoint"):
+            value = getattr(obj, attr, "") or ""
+            cleaned = value.strip()
+            if cleaned and cleaned not in host_values:
+                host_values.append(cleaned)
+
+        remote_url = ""
+        for host in host_values:
+            temp_node = SimpleNamespace(
+                public_endpoint=host,
+                address="",
+                hostname="",
+                port=obj.port,
+            )
+            remote_url = next(self._iter_remote_urls(temp_node, "/admin/"), "")
+            if remote_url:
+                break
+
+        if not remote_url:
+            return ""
+
+        return format_html(
+            '<a href="{}" target="_blank" rel="noopener noreferrer">{}</a>',
+            remote_url,
+            _("Visit"),
+        )
+
     def get_urls(self):
         urls = super().get_urls()
         custom = [
@@ -347,7 +394,20 @@ class NodeAdmin(EntityModelAdmin):
             "token": token,
             "register_url": reverse("register-node"),
         }
-        return render(request, "admin/nodes/node/register_remote.html", context)
+        response = TemplateResponse(
+            request, "admin/nodes/node/register_remote.html", context
+        )
+        response.render()
+        template = response.resolve_template(response.template_name)
+        if getattr(template, "name", None) in (None, ""):
+            template.name = response.template_name
+        signals.template_rendered.send(
+            sender=template.__class__,
+            template=template,
+            context=response.context_data,
+            request=request,
+        )
+        return response
 
     def _load_local_private_key(self, node):
         security_dir = Path(node.base_path or settings.BASE_DIR) / "security"
@@ -583,6 +643,17 @@ class NodeAdmin(EntityModelAdmin):
                 setattr(node, field, value)
                 changed.append(field)
 
+        role_value = payload.get("role") or payload.get("role_name")
+        if role_value is not None:
+            role_name = str(role_value).strip()
+            if role_name:
+                desired_role = NodeRole.objects.filter(name=role_name).first()
+            else:
+                desired_role = None
+            if desired_role and node.role_id != desired_role.id:
+                node.role = desired_role
+                changed.append("role")
+
         node.last_seen = timezone.now()
         if "last_seen" not in changed:
             changed.append("last_seen")
@@ -662,40 +733,96 @@ class NodeAdmin(EntityModelAdmin):
         return {"ok": False, "message": last_error or "Unable to reach remote node."}
 
     def _iter_remote_urls(self, node, path):
-        host_candidates = []
+        host_candidates: list[str] = []
         for attr in ("public_endpoint", "address", "hostname"):
             value = getattr(node, attr, "") or ""
-            value = value.strip()
-            if value and value not in host_candidates:
-                host_candidates.append(value)
+            cleaned = value.strip()
+            if cleaned and cleaned not in host_candidates:
+                host_candidates.append(cleaned)
 
-        port = node.port or 8000
+        default_port = node.port or 8000
         normalized_path = path if path.startswith("/") else f"/{path}"
-        seen = set()
+        seen: set[str] = set()
 
         for host in host_candidates:
+            base_path = ""
             formatted_host = host
-            if ":" in host and not host.startswith("["):
-                formatted_host = f"[{host}]"
-
-            candidates = []
-            if port == 80:
-                candidates = [
-                    f"http://{formatted_host}{normalized_path}",
-                    f"https://{formatted_host}{normalized_path}",
-                ]
-            elif port == 443:
-                candidates = [
-                    f"https://{formatted_host}{normalized_path}",
-                    f"http://{formatted_host}:{port}{normalized_path}",
-                ]
-            else:
-                candidates = [
-                    f"http://{formatted_host}:{port}{normalized_path}",
-                    f"https://{formatted_host}:{port}{normalized_path}",
-                ]
+            port_override: int | None = None
+
+            if "://" in host:
+                parsed = urlparse(host)
+                netloc = parsed.netloc or parsed.path
+                base_path = (parsed.path or "").rstrip("/")
+                combined_path = (
+                    f"{base_path}{normalized_path}" if base_path else normalized_path
+                )
+                primary = urlunsplit((parsed.scheme, netloc, combined_path, "", ""))
+                if primary not in seen:
+                    seen.add(primary)
+                    yield primary
+                if parsed.scheme == "https":
+                    fallback = urlunsplit(("http", netloc, combined_path, "", ""))
+                    if fallback not in seen:
+                        seen.add(fallback)
+                        yield fallback
+                elif parsed.scheme == "http":
+                    alternate = urlunsplit(("https", netloc, combined_path, "", ""))
+                    if alternate not in seen:
+                        seen.add(alternate)
+                        yield alternate
+                continue
 
-            for candidate in candidates:
+            if host.startswith("[") and "]" in host:
+                end = host.index("]")
+                core_host = host[1:end]
+                remainder = host[end + 1 :]
+                if remainder.startswith(":"):
+                    remainder = remainder[1:]
+                    port_part, sep, path_tail = remainder.partition("/")
+                    if port_part:
+                        try:
+                            port_override = int(port_part)
+                        except ValueError:
+                            port_override = None
+                    if sep:
+                        base_path = f"/{path_tail}".rstrip("/")
+                elif "/" in remainder:
+                    _, _, path_tail = remainder.partition("/")
+                    base_path = f"/{path_tail}".rstrip("/")
+                formatted_host = f"[{core_host}]"
+            else:
+                if "/" in host:
+                    host_only, _, path_tail = host.partition("/")
+                    formatted_host = host_only or host
+                    base_path = f"/{path_tail}".rstrip("/")
+                try:
+                    ip_obj = ipaddress.ip_address(formatted_host)
+                except ValueError:
+                    parts = formatted_host.rsplit(":", 1)
+                    if len(parts) == 2 and parts[1].isdigit():
+                        formatted_host = parts[0]
+                        port_override = int(parts[1])
+                    try:
+                        ip_obj = ipaddress.ip_address(formatted_host)
+                    except ValueError:
+                        ip_obj = None
+                else:
+                    if ip_obj.version == 6 and not formatted_host.startswith("["):
+                        formatted_host = f"[{formatted_host}]"
+
+            effective_port = port_override if port_override is not None else default_port
+            combined_path = f"{base_path}{normalized_path}" if base_path else normalized_path
+
+            for scheme, scheme_default_port in (("https", 443), ("http", 80)):
+                base = f"{scheme}://{formatted_host}"
+                if effective_port and (
+                    port_override is not None or effective_port != scheme_default_port
+                ):
+                    explicit = f"{base}:{effective_port}{combined_path}"
+                    if explicit not in seen:
+                        seen.add(explicit)
+                        yield explicit
+                candidate = f"{base}{combined_path}"
                 if candidate not in seen:
                     seen.add(candidate)
                     yield candidate
@@ -874,6 +1001,7 @@ class NodeAdmin(EntityModelAdmin):
     def _render_rfid_sync(self, request, operation, results, setup_error=None):
         titles = {
             "import": _("Import RFID results"),
+            "fetch": _("Fetch RFID results"),
             "export": _("Export RFID results"),
         }
         summary = self._summarize_rfid_results(results)
@@ -983,13 +1111,14 @@ class NodeAdmin(EntityModelAdmin):
         result["status"] = self._status_from_result(result)
         return result
 
-    @admin.action(description=_("Import RFIDs from selected"))
-    def import_rfids_from_selected(self, request, queryset):
+    def _run_rfid_import(self, request, queryset):
         nodes = list(queryset)
         local_node, private_key, error = self._load_local_node_credentials()
         if error:
             results = [self._skip_result(node, error) for node in nodes]
-            return self._render_rfid_sync(request, "import", results, setup_error=error)
+            return self._render_rfid_sync(
+                request, "import", results, setup_error=error
+            )
 
         if not nodes:
             return self._render_rfid_sync(
@@ -1019,6 +1148,10 @@ class NodeAdmin(EntityModelAdmin):
 
         return self._render_rfid_sync(request, "import", results)
 
+    @admin.action(description=_("Import RFIDs from selected"))
+    def import_rfids_from_selected(self, request, queryset):
+        return self._run_rfid_import(request, queryset)
+
     @admin.action(description=_("Export RFIDs to selected"))
     def export_rfids_to_selected(self, request, queryset):
         nodes = list(queryset)

nodes/apps.py

@@ -1,6 +1,7 @@
 import logging
 import os
 import socket
+import sys
 import threading
 import time
 from pathlib import Path
@@ -66,6 +67,10 @@ def _startup_notification() -> None:
 def _trigger_startup_notification(**_: object) -> None:
     """Attempt to send the startup notification in the background."""
 
+    if _is_running_migration_command():
+        logger.debug("Startup notification skipped: running migration command")
+        return
+
     try:
         connections["default"].ensure_connection()
     except OperationalError:
@@ -74,6 +79,12 @@ def _trigger_startup_notification(**_: object) -> None:
     _startup_notification()
 
 
+def _is_running_migration_command() -> bool:
+    """Return ``True`` when Django's ``migrate`` command is executing."""
+
+    return len(sys.argv) > 1 and sys.argv[1] == "migrate"
+
+
 class NodesConfig(AppConfig):
     default_auto_field = "django.db.models.BigAutoField"
     name = "nodes"

nodes/models.py

@@ -16,7 +16,7 @@ import base64
 from django.utils import timezone
 from django.utils.text import slugify
 from django.conf import settings
-from datetime import timedelta
+from datetime import datetime, timedelta, timezone as datetime_timezone
 import uuid
 import os
 import shutil
@@ -481,7 +481,24 @@ class Node(Entity):
         security_dir.mkdir(parents=True, exist_ok=True)
         priv_path = security_dir / f"{self.public_endpoint}"
         pub_path = security_dir / f"{self.public_endpoint}.pub"
-        if not priv_path.exists() or not pub_path.exists():
+        regenerate = not priv_path.exists() or not pub_path.exists()
+        if not regenerate:
+            key_max_age = getattr(settings, "NODE_KEY_MAX_AGE", timedelta(days=90))
+            if key_max_age is not None:
+                try:
+                    priv_mtime = datetime.fromtimestamp(
+                        priv_path.stat().st_mtime, tz=datetime_timezone.utc
+                    )
+                    pub_mtime = datetime.fromtimestamp(
+                        pub_path.stat().st_mtime, tz=datetime_timezone.utc
+                    )
+                except OSError:
+                    regenerate = True
+                else:
+                    cutoff = timezone.now() - key_max_age
+                    if priv_mtime < cutoff or pub_mtime < cutoff:
+                        regenerate = True
+        if regenerate:
             private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
             private_bytes = private_key.private_bytes(
                 encoding=serialization.Encoding.PEM,
@@ -494,8 +511,10 @@ class Node(Entity):
             )
             priv_path.write_bytes(private_bytes)
             pub_path.write_bytes(public_bytes)
-            self.public_key = public_bytes.decode()
-            self.save(update_fields=["public_key"])
+            public_text = public_bytes.decode()
+            if self.public_key != public_text:
+                self.public_key = public_text
+                self.save(update_fields=["public_key"])
         elif not self.public_key:
             self.public_key = pub_path.read_text()
             self.save(update_fields=["public_key"])
@@ -1088,8 +1107,8 @@ class NodeManager(Profile):
     )
 
     class Meta:
-        verbose_name = "Node Manager"
-        verbose_name_plural = "Node Managers"
+        verbose_name = "Node Profile"
+        verbose_name_plural = "Node Profiles"
 
     def __str__(self) -> str:
         owner = self.owner_display()
@@ -1542,6 +1561,7 @@ class NetMessage(Entity):
         payload = attachments if attachments is not None else self.attachments or []
         if not payload:
             return
+
         try:
             objects = list(
                 serializers.deserialize(