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

nodes/utils.py

@@ -14,8 +14,12 @@ SCREENSHOT_DIR = settings.LOG_DIR / "screenshots"
 logger = logging.getLogger(__name__)
 
 
-def capture_screenshot(url: str) -> Path:
-    """Capture a screenshot of ``url`` and save it to :data:`SCREENSHOT_DIR`."""
+def capture_screenshot(url: str, cookies=None) -> Path:
+    """Capture a screenshot of ``url`` and save it to :data:`SCREENSHOT_DIR`.
+
+    ``cookies`` can be an iterable of Selenium cookie mappings which will be
+    applied after the initial navigation and before the screenshot is taken.
+    """
     options = Options()
     options.add_argument("-headless")
     try:
@@ -27,6 +31,13 @@ def capture_screenshot(url: str) -> Path:
                 browser.get(url)
             except WebDriverException as exc:
                 logger.error("Failed to load %s: %s", url, exc)
+            if cookies:
+                for cookie in cookies:
+                    try:
+                        browser.add_cookie(cookie)
+                    except WebDriverException as exc:
+                        logger.error("Failed to apply cookie for %s: %s", url, exc)
+                browser.get(url)
             if not browser.save_screenshot(str(filename)):
                 raise RuntimeError("Screenshot capture failed")
             return filename

nodes/views.py

@@ -1,34 +1,112 @@
-import json
 import base64
+import ipaddress
+import json
+import socket
 
 from django.http import JsonResponse
+from django.http.request import split_domain_port
 from django.views.decorators.csrf import csrf_exempt
 from django.shortcuts import get_object_or_404
 from django.conf import settings
 from pathlib import Path
+from django.utils.cache import patch_vary_headers
 
 from utils.api import api_login_required
 
 from cryptography.hazmat.primitives import serialization, hashes
 from cryptography.hazmat.primitives.asymmetric import padding
 
-from .models import Node, NetMessage, NodeRole
+from .models import Node, NetMessage, NodeRole, node_information_updated
 from .utils import capture_screenshot, save_screenshot
 
 
+def _get_client_ip(request):
+    """Return the client IP from the request headers."""
+
+    forwarded_for = request.META.get("HTTP_X_FORWARDED_FOR", "")
+    if forwarded_for:
+        for value in forwarded_for.split(","):
+            candidate = value.strip()
+            if candidate:
+                return candidate
+    return request.META.get("REMOTE_ADDR", "")
+
+
+def _get_route_address(remote_ip: str, port: int) -> str:
+    """Return the local address used to reach ``remote_ip``."""
+
+    if not remote_ip:
+        return ""
+    try:
+        parsed = ipaddress.ip_address(remote_ip)
+    except ValueError:
+        return ""
+
+    try:
+        target_port = int(port)
+    except (TypeError, ValueError):
+        target_port = 1
+    if target_port <= 0 or target_port > 65535:
+        target_port = 1
+
+    family = socket.AF_INET6 if parsed.version == 6 else socket.AF_INET
+    try:
+        with socket.socket(family, socket.SOCK_DGRAM) as sock:
+            if family == socket.AF_INET6:
+                sock.connect((remote_ip, target_port, 0, 0))
+            else:
+                sock.connect((remote_ip, target_port))
+            return sock.getsockname()[0]
+    except OSError:
+        return ""
+
+
+def _get_host_ip(request) -> str:
+    """Return the IP address from the host header if available."""
+
+    try:
+        host = request.get_host()
+    except Exception:  # pragma: no cover - defensive
+        return ""
+    if not host:
+        return ""
+    domain, _ = split_domain_port(host)
+    if not domain:
+        return ""
+    try:
+        ipaddress.ip_address(domain)
+    except ValueError:
+        return ""
+    return domain
+
+
+def _get_advertised_address(request, node) -> str:
+    """Return the best address for the client to reach this node."""
+
+    client_ip = _get_client_ip(request)
+    route_address = _get_route_address(client_ip, node.port)
+    if route_address:
+        return route_address
+    host_ip = _get_host_ip(request)
+    if host_ip:
+        return host_ip
+    return node.address
+
+
 @api_login_required
 def node_list(request):
     """Return a JSON list of all known nodes."""
 
-    nodes = list(
-        Node.objects.values(
-            "hostname",
-            "address",
-            "port",
-            "last_seen",
-            "has_lcd_screen",
-        )
-    )
+    nodes = [
+        {
+            "hostname": node.hostname,
+            "address": node.address,
+            "port": node.port,
+            "last_seen": node.last_seen,
+            "features": list(node.features.values_list("slug", flat=True)),
+        }
+        for node in Node.objects.prefetch_related("features")
+    ]
     return JsonResponse({"nodes": nodes})
 
 
@@ -41,13 +119,14 @@ def node_info(request):
         node, _ = Node.register_current()
 
     token = request.GET.get("token", "")
+    address = _get_advertised_address(request, node)
     data = {
         "hostname": node.hostname,
-        "address": node.address,
+        "address": address,
         "port": node.port,
         "mac_address": node.mac_address,
         "public_key": node.public_key,
-        "has_lcd_screen": node.has_lcd_screen,
+        "features": list(node.features.values_list("slug", flat=True)),
     }
 
     if token:
@@ -74,19 +153,48 @@ def node_info(request):
     return response
 
 
+def _add_cors_headers(request, response):
+    origin = request.headers.get("Origin")
+    if origin:
+        response["Access-Control-Allow-Origin"] = origin
+        response["Access-Control-Allow-Credentials"] = "true"
+        allow_headers = request.headers.get(
+            "Access-Control-Request-Headers", "Content-Type"
+        )
+        response["Access-Control-Allow-Headers"] = allow_headers
+        response["Access-Control-Allow-Methods"] = "POST, OPTIONS"
+        patch_vary_headers(response, ["Origin"])
+    return response
+
+
 @csrf_exempt
-@api_login_required
 def register_node(request):
     """Register or update a node from POSTed JSON data."""
 
+    if request.method == "OPTIONS":
+        response = JsonResponse({"detail": "ok"})
+        return _add_cors_headers(request, response)
+
     if request.method != "POST":
-        return JsonResponse({"detail": "POST required"}, status=400)
+        response = JsonResponse({"detail": "POST required"}, status=400)
+        return _add_cors_headers(request, response)
 
     try:
         data = json.loads(request.body.decode())
     except json.JSONDecodeError:
         data = request.POST
 
+    if hasattr(data, "getlist"):
+        raw_features = data.getlist("features")
+        if not raw_features:
+            features = None
+        elif len(raw_features) == 1:
+            features = raw_features[0]
+        else:
+            features = raw_features
+    else:
+        features = data.get("features")
+
     hostname = data.get("hostname")
     address = data.get("address")
     port = data.get("port", 8000)
@@ -94,12 +202,14 @@ def register_node(request):
     public_key = data.get("public_key")
     token = data.get("token")
     signature = data.get("signature")
-    has_lcd_screen = data.get("has_lcd_screen")
+    installed_version = data.get("installed_version")
+    installed_revision = data.get("installed_revision")
 
     if not hostname or not address or not mac_address:
-        return JsonResponse(
+        response = JsonResponse(
             {"detail": "hostname, address and mac_address required"}, status=400
         )
+        return _add_cors_headers(request, response)
 
     verified = False
     if public_key and token and signature:
@@ -113,23 +223,33 @@ def register_node(request):
             )
             verified = True
         except Exception:
-            return JsonResponse({"detail": "invalid signature"}, status=403)
+            response = JsonResponse({"detail": "invalid signature"}, status=403)
+            return _add_cors_headers(request, response)
+
+    if not verified and not request.user.is_authenticated:
+        response = JsonResponse({"detail": "authentication required"}, status=401)
+        return _add_cors_headers(request, response)
 
     mac_address = mac_address.lower()
     defaults = {
         "hostname": hostname,
         "address": address,
         "port": port,
-        "has_lcd_screen": bool(has_lcd_screen),
     }
     if verified:
         defaults["public_key"] = public_key
+    if installed_version is not None:
+        defaults["installed_version"] = str(installed_version)[:20]
+    if installed_revision is not None:
+        defaults["installed_revision"] = str(installed_revision)[:40]
 
     node, created = Node.objects.get_or_create(
         mac_address=mac_address,
         defaults=defaults,
     )
     if not created:
+        previous_version = (node.installed_version or "").strip()
+        previous_revision = (node.installed_revision or "").strip()
         node.hostname = hostname
         node.address = address
         node.port = port
@@ -137,15 +257,58 @@ def register_node(request):
         if verified:
             node.public_key = public_key
             update_fields.append("public_key")
-        if has_lcd_screen is not None:
-            node.has_lcd_screen = bool(has_lcd_screen)
-            update_fields.append("has_lcd_screen")
+        if installed_version is not None:
+            node.installed_version = str(installed_version)[:20]
+            if "installed_version" not in update_fields:
+                update_fields.append("installed_version")
+        if installed_revision is not None:
+            node.installed_revision = str(installed_revision)[:40]
+            if "installed_revision" not in update_fields:
+                update_fields.append("installed_revision")
         node.save(update_fields=update_fields)
-        return JsonResponse(
+        current_version = (node.installed_version or "").strip()
+        current_revision = (node.installed_revision or "").strip()
+        node_information_updated.send(
+            sender=Node,
+            node=node,
+            previous_version=previous_version,
+            previous_revision=previous_revision,
+            current_version=current_version,
+            current_revision=current_revision,
+            request=request,
+        )
+        if features is not None and (verified or request.user.is_authenticated):
+            if isinstance(features, (str, bytes)):
+                feature_list = [features]
+            else:
+                feature_list = list(features)
+            node.update_manual_features(feature_list)
+        response = JsonResponse(
             {"id": node.id, "detail": f"Node already exists (id: {node.id})"}
         )
+        return _add_cors_headers(request, response)
+
+    if features is not None and (verified or request.user.is_authenticated):
+        if isinstance(features, (str, bytes)):
+            feature_list = [features]
+        else:
+            feature_list = list(features)
+        node.update_manual_features(feature_list)
+
+    current_version = (node.installed_version or "").strip()
+    current_revision = (node.installed_revision or "").strip()
+    node_information_updated.send(
+        sender=Node,
+        node=node,
+        previous_version="",
+        previous_revision="",
+        current_version=current_version,
+        current_revision=current_revision,
+        request=request,
+    )
 
-    return JsonResponse({"id": node.id})
+    response = JsonResponse({"id": node.id})
+    return _add_cors_headers(request, response)
 
 
 @api_login_required
@@ -172,9 +335,7 @@ def public_node_endpoint(request, endpoint):
     - ``POST`` broadcasts the request body as a :class:`NetMessage`.
     """
 
-    node = get_object_or_404(
-        Node, public_endpoint=endpoint, enable_public_api=True
-    )
+    node = get_object_or_404(Node, public_endpoint=endpoint, enable_public_api=True)
 
     if request.method == "GET":
         data = {
@@ -183,6 +344,7 @@ def public_node_endpoint(request, endpoint):
             "port": node.port,
             "badge_color": node.badge_color,
             "last_seen": node.last_seen,
+            "features": list(node.features.values_list("slug", flat=True)),
         }
         return JsonResponse(data)
 
@@ -234,11 +396,22 @@ def net_message(request):
     if reach_name:
         reach_role = NodeRole.objects.filter(name=reach_name).first()
     seen = data.get("seen", [])
+    origin_id = data.get("origin")
+    origin_node = None
+    if origin_id:
+        origin_node = Node.objects.filter(uuid=origin_id).first()
+    if not origin_node:
+        origin_node = node
     if not msg_uuid:
         return JsonResponse({"detail": "uuid required"}, status=400)
     msg, created = NetMessage.objects.get_or_create(
         uuid=msg_uuid,
-        defaults={"subject": subject[:64], "body": body[:256], "reach": reach_role},
+        defaults={
+            "subject": subject[:64],
+            "body": body[:256],
+            "reach": reach_role,
+            "node_origin": origin_node,
+        },
     )
     if not created:
         msg.subject = subject[:64]
@@ -247,6 +420,9 @@ def net_message(request):
         if reach_role and msg.reach_id != reach_role.id:
             msg.reach = reach_role
             update_fields.append("reach")
+        if msg.node_origin_id is None and origin_node:
+            msg.node_origin = origin_node
+            update_fields.append("node_origin")
         msg.save(update_fields=update_fields)
     msg.propagate(seen=seen)
     return JsonResponse({"status": "propagated", "complete": msg.complete})