arthexis 0.1.21__py3-none-any.whl → 0.1.23__py3-none-any.whl

nodes/admin.py

@@ -18,8 +18,10 @@ 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 urljoin, urlparse, urlsplit, urlunsplit
 import base64
+import ipaddress
 import json
 import subprocess
 import uuid
@@ -85,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.",
     )
@@ -234,6 +236,7 @@ class NodeAdmin(EntityModelAdmin):
         "role",
         "relation",
         "last_seen",
+        "visit_link",
         "proxy_link",
     )
     search_fields = ("hostname", "address", "mac_address")
@@ -284,7 +287,6 @@ class NodeAdmin(EntityModelAdmin):
         "register_visitor",
         "run_task",
         "take_screenshots",
-        "fetch_rfids_from_selected",
         "import_rfids_from_selected",
         "export_rfids_to_selected",
     ]
@@ -304,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 = [
@@ -395,6 +440,12 @@ class NodeAdmin(EntityModelAdmin):
             },
             "target": reverse("admin:index"),
         }
+        mac_address = str(local_node.mac_address or "").strip()
+        if mac_address:
+            payload["requester_mac"] = mac_address
+        public_key = local_node.public_key
+        if public_key:
+            payload["requester_public_key"] = public_key
         return payload
 
     def _start_proxy_session(self, request, node):
@@ -429,29 +480,64 @@ class NodeAdmin(EntityModelAdmin):
         }
 
         last_error = ""
+        redirect_codes = {301, 302, 303, 307, 308}
+
         for url in self._iter_remote_urls(node, "/nodes/proxy/session/"):
-            try:
-                response = requests.post(url, data=body, headers=headers, timeout=5)
-            except RequestException as exc:
-                last_error = str(exc)
-                continue
-            if not response.ok:
-                last_error = f"{response.status_code} {response.text}"
-                continue
-            try:
-                data = response.json()
-            except ValueError:
-                last_error = "Invalid JSON response"
-                continue
-            login_url = data.get("login_url")
-            if not login_url:
-                last_error = "login_url missing"
-                continue
-            return {
-                "ok": True,
-                "login_url": login_url,
-                "expires": data.get("expires"),
-            }
+            candidate_url = url
+            redirects_followed = 0
+            success = False
+
+            while True:
+                try:
+                    response = requests.post(
+                        candidate_url,
+                        data=body,
+                        headers=headers,
+                        timeout=5,
+                        allow_redirects=False,
+                    )
+                except RequestException as exc:
+                    last_error = str(exc)
+                    break
+
+                if response.status_code in redirect_codes:
+                    location = response.headers.get("Location")
+                    if not location:
+                        last_error = f"{response.status_code} redirect missing Location header"
+                        break
+
+                    redirects_followed += 1
+                    if redirects_followed > 3:
+                        last_error = "Too many redirects"
+                        break
+
+                    candidate_url = urljoin(candidate_url, location)
+                    continue
+
+                if not response.ok:
+                    last_error = f"{response.status_code} {response.text}"
+                    break
+
+                try:
+                    data = response.json()
+                except ValueError:
+                    last_error = "Invalid JSON response"
+                    break
+
+                login_url = data.get("login_url")
+                if not login_url:
+                    last_error = "login_url missing"
+                    break
+
+                success = True
+                break
+
+            if success:
+                return {
+                    "ok": True,
+                    "login_url": login_url,
+                    "expires": data.get("expires"),
+                }
 
         return {
             "ok": False,
@@ -598,6 +684,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")
@@ -677,40 +774,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
@@ -999,17 +1152,19 @@ class NodeAdmin(EntityModelAdmin):
         result["status"] = self._status_from_result(result)
         return result
 
-    def _run_rfid_fetch(self, request, queryset, *, operation):
+    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, operation, results, setup_error=error)
+            return self._render_rfid_sync(
+                request, "import", results, setup_error=error
+            )
 
         if not nodes:
             return self._render_rfid_sync(
                 request,
-                operation,
+                "import",
                 [],
                 setup_error=_("No nodes selected."),
             )
@@ -1032,15 +1187,11 @@ class NodeAdmin(EntityModelAdmin):
                 continue
             results.append(self._process_import_from_node(node, payload, headers))
 
-        return self._render_rfid_sync(request, operation, results)
-
-    @admin.action(description=_("Fetch RFIDs from selected"))
-    def fetch_rfids_from_selected(self, request, queryset):
-        return self._run_rfid_fetch(request, queryset, operation="fetch")
+        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_fetch(request, queryset, operation="import")
+        return self._run_rfid_import(request, queryset)
 
     @admin.action(description=_("Export RFIDs to selected"))
     def export_rfids_to_selected(self, request, 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

@@ -4,6 +4,7 @@ from collections.abc import Iterable
 from copy import deepcopy
 from dataclasses import dataclass
 from django.db import models
+from django.db.models import Q
 from django.db.utils import DatabaseError
 from django.db.models.signals import post_delete
 from django.dispatch import Signal, receiver
@@ -16,7 +17,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
@@ -294,7 +295,14 @@ class Node(Entity):
         """Return the node representing the current host if it exists."""
         mac = cls.get_current_mac()
         try:
-            return cls.objects.filter(mac_address=mac).first()
+            node = cls.objects.filter(mac_address__iexact=mac).first()
+            if node:
+                return node
+            return (
+                cls.objects.filter(current_relation=cls.Relation.SELF)
+                .filter(Q(mac_address__isnull=True) | Q(mac_address=""))
+                .first()
+            )
         except DatabaseError:
             logger.debug("nodes.Node.get_local skipped: database unavailable", exc_info=True)
             return None
@@ -481,7 +489,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 +519,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 +1115,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 +1569,7 @@ class NetMessage(Entity):
         payload = attachments if attachments is not None else self.attachments or []
         if not payload:
             return
+
         try:
             objects = list(
                 serializers.deserialize(