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

nodes/admin.py

@@ -16,22 +16,23 @@ 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 django.utils.translation import gettext_lazy as _, ngettext
 from pathlib import Path
 from types import SimpleNamespace
-from urllib.parse import urljoin, urlparse, urlsplit, urlunsplit
+from urllib.parse import urlsplit, urlunsplit, quote
 import base64
-import ipaddress
 import json
 import subprocess
 import uuid
 
+import asyncio
 import pyperclip
 import requests
 from cryptography.hazmat.primitives import hashes, serialization
 from cryptography.hazmat.primitives.asymmetric import padding
 from pyperclip import PyperclipException
 from requests import RequestException
+import websockets
 
 from .classifiers import run_default_classifiers, suppress_default_classifiers
 from .rfid_sync import apply_rfid_payload, serialize_rfid
@@ -60,6 +61,9 @@ from .models import (
 )
 from . import dns as dns_utils
 from core.models import RFID
+from ocpp.models import Charger
+from ocpp.network import serialize_charger_for_network
+from ocpp.tasks import push_forwarded_charge_points
 from core.user_data import EntityModelAdmin
 
 
@@ -230,34 +234,37 @@ class DNSRecordAdmin(EntityModelAdmin):
 class NodeAdmin(EntityModelAdmin):
     list_display = (
         "hostname",
-        "mac_address",
-        "address",
+        "network_hostname",
+        "ipv4_address",
+        "ipv6_address",
         "port",
         "role",
         "relation",
         "last_seen",
         "visit_link",
-        "proxy_link",
     )
-    search_fields = ("hostname", "address", "mac_address")
+    search_fields = ("hostname", "network_hostname", "address", "mac_address")
     change_list_template = "admin/nodes/node/change_list.html"
     change_form_template = "admin/nodes/node/change_form.html"
     form = NodeAdminForm
     fieldsets = (
         (
-            _("Node"),
+            _("Network"),
             {
                 "fields": (
                     "hostname",
+                    "network_hostname",
+                    "ipv4_address",
+                    "ipv6_address",
                     "address",
                     "mac_address",
                     "port",
                     "message_queue_length",
-                    "role",
                     "current_relation",
                 )
             },
         ),
+        (_("Role"), {"fields": ("role",)}),
         (
             _("Public endpoint"),
             {
@@ -287,25 +294,43 @@ class NodeAdmin(EntityModelAdmin):
         "register_visitor",
         "run_task",
         "take_screenshots",
+        "start_charge_point_forwarding",
+        "stop_charge_point_forwarding",
         "import_rfids_from_selected",
         "export_rfids_to_selected",
+        "send_net_message",
     ]
     inlines = [NodeFeatureAssignmentInline]
 
+    class SendNetMessageForm(forms.Form):
+        subject = forms.CharField(
+            label=_("Subject"),
+            max_length=NetMessage._meta.get_field("subject").max_length,
+            required=False,
+        )
+        body = forms.CharField(
+            label=_("Body"),
+            max_length=NetMessage._meta.get_field("body").max_length,
+            required=False,
+            widget=forms.Textarea(attrs={"rows": 4}),
+        )
+
+        def clean(self):
+            cleaned = super().clean()
+            subject = (cleaned.get("subject") or "").strip()
+            body = (cleaned.get("body") or "").strip()
+            if not subject and not body:
+                raise forms.ValidationError(
+                    _("Enter a subject or body to send.")
+                )
+            cleaned["subject"] = subject
+            cleaned["body"] = body
+            return cleaned
+
     @admin.display(description=_("Relation"), ordering="current_relation")
     def relation(self, obj):
         return obj.get_current_relation_display()
 
-    @admin.display(description=_("Proxy"))
-    def proxy_link(self, obj):
-        if not obj or obj.is_local:
-            return ""
-        try:
-            url = reverse("admin:nodes_node_proxy", args=[obj.pk])
-        except NoReverseMatch:
-            return ""
-        return format_html('<a class="button" href="{}">{}</a>', url, _("Proxy"))
-
     @admin.display(description=_("Visit"))
     def visit_link(self, obj):
         if not obj:
@@ -321,12 +346,7 @@ class NodeAdmin(EntityModelAdmin):
                 _("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)
+        host_values = obj.get_remote_host_candidates()
 
         remote_url = ""
         for host in host_values:
@@ -372,11 +392,6 @@ class NodeAdmin(EntityModelAdmin):
                 self.admin_site.admin_view(self.update_selected_progress),
                 name="nodes_node_update_selected_progress",
             ),
-            path(
-                "<int:node_id>/proxy/",
-                self.admin_site.admin_view(self.proxy_node),
-                name="nodes_node_proxy",
-            ),
         ]
         return custom + urls
 
@@ -409,162 +424,6 @@ class NodeAdmin(EntityModelAdmin):
         )
         return response
 
-    def _load_local_private_key(self, node):
-        security_dir = Path(node.base_path or settings.BASE_DIR) / "security"
-        priv_path = security_dir / f"{node.public_endpoint}"
-        if not priv_path.exists():
-            return None, _("Local node private key not found.")
-        try:
-            return (
-                serialization.load_pem_private_key(
-                    priv_path.read_bytes(), password=None
-                ),
-                "",
-            )
-        except Exception as exc:  # pragma: no cover - unexpected errors
-            return None, str(exc)
-
-    def _build_proxy_payload(self, request, local_node):
-        user = request.user
-        payload = {
-            "requester": str(local_node.uuid),
-            "user": {
-                "username": user.get_username(),
-                "email": user.email or "",
-                "first_name": user.first_name or "",
-                "last_name": user.last_name or "",
-                "is_staff": user.is_staff,
-                "is_superuser": user.is_superuser,
-                "groups": list(user.groups.values_list("name", flat=True)),
-                "permissions": sorted(user.get_all_permissions()),
-            },
-            "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):
-        if node.is_local:
-            return {"ok": False, "message": _("Local node cannot be proxied.")}
-
-        local_node = Node.get_local()
-        if local_node is None:
-            try:
-                local_node, _ = Node.register_current()
-            except Exception as exc:  # pragma: no cover - unexpected errors
-                return {"ok": False, "message": str(exc)}
-
-        private_key, error = self._load_local_private_key(local_node)
-        if private_key is None:
-            return {"ok": False, "message": error}
-
-        payload = self._build_proxy_payload(request, local_node)
-        body = json.dumps(payload, separators=(",", ":"), sort_keys=True)
-        try:
-            signature = private_key.sign(
-                body.encode(),
-                padding.PKCS1v15(),
-                hashes.SHA256(),
-            )
-        except Exception as exc:  # pragma: no cover - unexpected errors
-            return {"ok": False, "message": str(exc)}
-
-        headers = {
-            "Content-Type": "application/json",
-            "X-Signature": base64.b64encode(signature).decode(),
-        }
-
-        last_error = ""
-        redirect_codes = {301, 302, 303, 307, 308}
-
-        for url in self._iter_remote_urls(node, "/nodes/proxy/session/"):
-            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,
-            "message": last_error or "Unable to initiate proxy.",
-        }
-
-    def proxy_node(self, request, node_id):
-        node = self.get_queryset(request).filter(pk=node_id).first()
-        if not node:
-            raise Http404
-        if not self.has_view_permission(request):
-            raise PermissionDenied
-        result = self._start_proxy_session(request, node)
-        if not result.get("ok"):
-            message = result.get("message") or _("Unable to proxy node.")
-            self.message_user(request, message, messages.ERROR)
-            return redirect("admin:nodes_node_changelist")
-
-        context = {
-            **self.admin_site.each_context(request),
-            "opts": self.model._meta,
-            "node": node,
-            "frame_url": result.get("login_url"),
-            "expires": result.get("expires"),
-        }
-        return TemplateResponse(request, "admin/nodes/node/proxy.html", context)
-
     @admin.action(description="Register Visitor")
     def register_visitor(self, request, queryset=None):
         return self.register_visitor_view(request)
@@ -587,6 +446,75 @@ class NodeAdmin(EntityModelAdmin):
             request, "admin/nodes/node/update_selected.html", context
         )
 
+    @admin.action(description=_("Send Net Message"))
+    def send_net_message(self, request, queryset):
+        is_submit = "apply" in request.POST
+        form = self.SendNetMessageForm(request.POST if is_submit else None)
+        selected_ids = request.POST.getlist(helpers.ACTION_CHECKBOX_NAME)
+        if not selected_ids:
+            selected_ids = [str(pk) for pk in queryset.values_list("pk", flat=True)]
+        nodes: list[Node] = []
+        cleaned_ids: list[int] = []
+        for value in selected_ids:
+            try:
+                cleaned_ids.append(int(value))
+            except (TypeError, ValueError):
+                continue
+        if cleaned_ids:
+            base_queryset = self.get_queryset(request).filter(pk__in=cleaned_ids)
+            nodes_by_pk = {str(node.pk): node for node in base_queryset}
+            nodes = [nodes_by_pk[value] for value in selected_ids if value in nodes_by_pk]
+        if not nodes:
+            nodes = list(queryset)
+            selected_ids = [str(node.pk) for node in nodes]
+        if not nodes:
+            self.message_user(request, _("No nodes selected."), messages.INFO)
+            return None
+        if is_submit and form.is_valid():
+            subject = form.cleaned_data["subject"]
+            body = form.cleaned_data["body"]
+            created = 0
+            for node in nodes:
+                message = NetMessage.objects.create(
+                    subject=subject,
+                    body=body,
+                    filter_node=node,
+                )
+                message.propagate()
+                created += 1
+            if created:
+                success_message = ngettext(
+                    "Sent %(count)d net message.",
+                    "Sent %(count)d net messages.",
+                    created,
+                ) % {"count": created}
+                self.message_user(request, success_message, messages.SUCCESS)
+            else:
+                self.message_user(
+                    request, _("No net messages were sent."), messages.INFO
+                )
+            return None
+        context = {
+            **self.admin_site.each_context(request),
+            "opts": self.model._meta,
+            "title": _("Send Net Message"),
+            "nodes": nodes,
+            "selected_ids": selected_ids,
+            "action_name": request.POST.get("action", "send_net_message"),
+            "select_across": request.POST.get("select_across", "0"),
+            "action_checkbox_name": helpers.ACTION_CHECKBOX_NAME,
+            "adminform": helpers.AdminForm(
+                form,
+                [(None, {"fields": ("subject", "body")})],
+                {},
+            ),
+            "form": form,
+            "media": self.media + form.media,
+        }
+        return TemplateResponse(
+            request, "admin/nodes/node/send_net_message.html", context
+        )
+
     def update_selected_progress(self, request):
         if request.method != "POST":
             return JsonResponse({"detail": "POST required"}, status=405)
@@ -631,6 +559,7 @@ class NodeAdmin(EntityModelAdmin):
             }
 
         last_error = ""
+        host_candidates = node.get_remote_host_candidates()
         for url in self._iter_remote_urls(node, "/nodes/info/"):
             try:
                 response = requests.get(url, timeout=5)
@@ -657,13 +586,19 @@ class NodeAdmin(EntityModelAdmin):
                 "updated_fields": updated,
                 "message": message,
             }
-        return {"ok": False, "message": last_error or "Unable to reach remote node."}
+        return {
+            "ok": False,
+            "message": self._build_connectivity_hint(last_error, host_candidates),
+        }
 
     def _apply_remote_node_info(self, node, payload):
         changed = []
         field_map = {
             "hostname": payload.get("hostname"),
+            "network_hostname": payload.get("network_hostname"),
             "address": payload.get("address"),
+            "ipv4_address": payload.get("ipv4_address"),
+            "ipv6_address": payload.get("ipv6_address"),
             "public_key": payload.get("public_key"),
         }
         port_value = payload.get("port")
@@ -741,7 +676,10 @@ class NodeAdmin(EntityModelAdmin):
 
         payload = {
             "hostname": local_node.hostname,
+            "network_hostname": local_node.network_hostname,
             "address": local_node.address,
+            "ipv4_address": local_node.ipv4_address,
+            "ipv6_address": local_node.ipv6_address,
             "port": local_node.port,
             "mac_address": local_node.mac_address,
             "public_key": local_node.public_key,
@@ -757,6 +695,7 @@ class NodeAdmin(EntityModelAdmin):
         headers = {"Content-Type": "application/json"}
 
         last_error = ""
+        host_candidates = node.get_remote_host_candidates()
         for url in self._iter_remote_urls(node, "/nodes/register/"):
             try:
                 response = requests.post(
@@ -771,102 +710,52 @@ class NodeAdmin(EntityModelAdmin):
             if response.ok:
                 return {"ok": True, "url": url, "message": "Remote updated."}
             last_error = f"{response.status_code} {response.text}"
-        return {"ok": False, "message": last_error or "Unable to reach remote node."}
+        return {
+            "ok": False,
+            "message": self._build_connectivity_hint(last_error, host_candidates),
+        }
 
-    def _iter_remote_urls(self, node, path):
-        host_candidates: list[str] = []
-        for attr in ("public_endpoint", "address", "hostname"):
-            value = getattr(node, attr, "") or ""
-            cleaned = value.strip()
-            if cleaned and cleaned not in host_candidates:
-                host_candidates.append(cleaned)
-
-        default_port = node.port or 8000
-        normalized_path = path if path.startswith("/") else f"/{path}"
-        seen: set[str] = set()
-
-        for host in host_candidates:
-            base_path = ""
-            formatted_host = host
-            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
+    def _build_connectivity_hint(self, last_error: str, hosts: list[str]) -> str:
+        base_message = last_error or _("Unable to reach remote node.")
+        if hosts:
+            host_text = ", ".join(hosts)
+            return _("%(message)s Tried hosts: %(hosts)s.") % {
+                "message": base_message,
+                "hosts": host_text,
+            }
+        return _("%(message)s No remote hosts were available for contact.") % {
+            "message": base_message
+        }
+
+    def _primary_remote_url(self, node, path: str) -> str:
+        return next(self._iter_remote_urls(node, path), "")
+
+    def _request_remote(self, node, path: str, request_callable):
+        errors: list[str] = []
+        for url in self._iter_remote_urls(node, path):
+            try:
+                response = request_callable(url)
+            except RequestException as exc:
+                errors.append(f"{url}: {exc}")
                 continue
+            return url, response, errors
+        return "", None, errors
 
-            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
+    def _iter_remote_urls(self, node, path):
+        if hasattr(node, "iter_remote_urls"):
+            yield from node.iter_remote_urls(path)
+            return
+
+        temp = Node(
+            public_endpoint=getattr(node, "public_endpoint", ""),
+            address=getattr(node, "address", ""),
+            hostname=getattr(node, "hostname", ""),
+            port=getattr(node, "port", None),
+        )
+        temp.network_hostname = getattr(node, "network_hostname", "")
+        temp.ipv4_address = getattr(node, "ipv4_address", "")
+        temp.ipv6_address = getattr(node, "ipv6_address", "")
+        yield from temp.iter_remote_urls(path)
 
     def register_visitor_view(self, request):
         """Exchange registration data with the visiting node."""
@@ -940,11 +829,28 @@ class NodeAdmin(EntityModelAdmin):
         for node in queryset:
             for source in sources:
                 try:
-                    url = source.format(node=node, address=node.address, port=node.port)
+                    contact_host = node.get_primary_contact()
+                    url = source.format(
+                        node=node, address=contact_host, port=node.port
+                    )
                 except Exception:
                     url = source
                 if not url.startswith("http"):
-                    url = f"http://{node.address}:{node.port}{url}"
+                    candidate = next(
+                        self._iter_remote_urls(node, url),
+                        "",
+                    )
+                    if not candidate:
+                        self.message_user(
+                            request,
+                            _(
+                                "No reachable host was available for %(node)s while generating %(path)s"
+                            )
+                            % {"node": node, "path": url},
+                            messages.WARNING,
+                        )
+                        continue
+                    url = candidate
                 try:
                     path = capture_screenshot(url)
                 except Exception as exc:  # pragma: no cover - selenium issues
@@ -1064,12 +970,19 @@ class NodeAdmin(EntityModelAdmin):
 
     def _process_import_from_node(self, node, payload, headers):
         result = self._init_rfid_result(node)
-        url = f"http://{node.address}:{node.port}/nodes/rfid/export/"
-        try:
-            response = requests.post(url, data=payload, headers=headers, timeout=5)
-        except RequestException as exc:
+        _, response, attempt_errors = self._request_remote(
+            node,
+            "/nodes/rfid/export/",
+            lambda url: requests.post(url, data=payload, headers=headers, timeout=5),
+        )
+        if response is None:
             result["status"] = "error"
-            result["errors"].append(str(exc))
+            if attempt_errors:
+                result["errors"].extend(attempt_errors)
+            else:
+                result["errors"].append(
+                    _("No remote hosts were available for %(node)s.") % {"node": node}
+                )
             return result
 
         if response.status_code != 200:
@@ -1109,12 +1022,19 @@ class NodeAdmin(EntityModelAdmin):
 
     def _post_export_to_node(self, node, payload, headers):
         result = self._init_rfid_result(node)
-        url = f"http://{node.address}:{node.port}/nodes/rfid/import/"
-        try:
-            response = requests.post(url, data=payload, headers=headers, timeout=5)
-        except RequestException as exc:
+        _, response, attempt_errors = self._request_remote(
+            node,
+            "/nodes/rfid/import/",
+            lambda url: requests.post(url, data=payload, headers=headers, timeout=5),
+        )
+        if response is None:
             result["status"] = "error"
-            result["errors"].append(str(exc))
+            if attempt_errors:
+                result["errors"].extend(attempt_errors)
+            else:
+                result["errors"].append(
+                    _("No remote hosts were available for %(node)s.") % {"node": node}
+                )
             return result
 
         if response.status_code != 200:
@@ -1230,6 +1150,259 @@ class NodeAdmin(EntityModelAdmin):
 
         return self._render_rfid_sync(request, "export", results)
 
+    async def _probe_websocket(self, url: str) -> bool:
+        try:
+            async with websockets.connect(url, open_timeout=3, close_timeout=1):
+                return True
+        except Exception:
+            return False
+
+    def _attempt_forwarding_probe(self, node, charger_id: str) -> bool:
+        if not charger_id:
+            return False
+        safe_id = quote(str(charger_id))
+        candidates: list[str] = []
+        for base in node.iter_remote_urls("/"):
+            parsed = urlsplit(base)
+            if parsed.scheme not in {"http", "https"}:
+                continue
+            scheme = "wss" if parsed.scheme == "https" else "ws"
+            base_path = parsed.path.rstrip("/")
+            for prefix in ("", "/ws"):
+                path = f"{base_path}{prefix}/{safe_id}".replace("//", "/")
+                if not path.startswith("/"):
+                    path = f"/{path}"
+                candidates.append(urlunsplit((scheme, parsed.netloc, path, "", "")))
+
+        for url in candidates:
+            loop = asyncio.new_event_loop()
+            try:
+                result = loop.run_until_complete(self._probe_websocket(url))
+            except Exception:
+                result = False
+            finally:
+                loop.close()
+            if result:
+                return True
+        return False
+
+    def _send_forwarding_metadata(
+        self,
+        request,
+        node: Node,
+        chargers: list[Charger],
+        local_node: Node,
+        private_key,
+    ) -> bool:
+        if not chargers:
+            return True
+        payload = {
+            "requester": str(local_node.uuid),
+            "requester_mac": local_node.mac_address,
+            "requester_public_key": local_node.public_key,
+            "chargers": [serialize_charger_for_network(charger) for charger in chargers],
+            "transactions": {"chargers": [], "transactions": []},
+        }
+        payload_json = json.dumps(payload, separators=(",", ":"), sort_keys=True)
+        signature = self._sign_payload(private_key, payload_json)
+        headers = {"Content-Type": "application/json"}
+        if signature:
+            headers["X-Signature"] = signature
+
+        url = next(node.iter_remote_urls("/nodes/network/chargers/forward/"), "")
+        if not url:
+            self.message_user(
+                request,
+                _("No reachable host found for %(node)s.") % {"node": node},
+                level=messages.WARNING,
+            )
+            return False
+        try:
+            response = requests.post(url, data=payload_json, headers=headers, timeout=5)
+        except RequestException as exc:
+            self.message_user(
+                request,
+                _("Failed to send forwarding metadata to %(node)s (%(error)s).")
+                % {"node": node, "error": exc},
+                level=messages.WARNING,
+            )
+            return False
+
+        try:
+            data = response.json()
+        except ValueError:
+            data = {}
+
+        if not response.ok or not isinstance(data, dict) or data.get("status") != "ok":
+            detail = ""
+            if isinstance(data, dict):
+                detail = data.get("detail") or ""
+            message = _("Forwarding metadata to %(node)s failed: %(status)s %(detail)s") % {
+                "node": node,
+                "status": response.status_code,
+                "detail": detail,
+            }
+            self.message_user(request, message.strip(), level=messages.WARNING)
+            return False
+
+        return True
+
+    @admin.action(description=_("Start Charge Point Forwarding"))
+    def start_charge_point_forwarding(self, request, queryset):
+        if queryset.count() != 1:
+            self.message_user(
+                request,
+                _("Select a single remote node."),
+                level=messages.ERROR,
+            )
+            return
+
+        target = queryset.first()
+        local_node, private_key, error = self._load_local_node_credentials()
+        if error:
+            self.message_user(request, error, level=messages.ERROR)
+            return
+
+        if local_node.pk and target.pk == local_node.pk:
+            self.message_user(
+                request,
+                _("Cannot forward charge points to the local node."),
+                level=messages.ERROR,
+            )
+            return
+
+        eligible = Charger.objects.filter(export_transactions=True)
+        if local_node.pk:
+            eligible = eligible.filter(
+                Q(node_origin=local_node) | Q(node_origin__isnull=True)
+            )
+
+        chargers = list(eligible.select_related("forwarded_to"))
+        if not chargers:
+            self.message_user(
+                request,
+                _("No eligible charge points available for forwarding."),
+                level=messages.WARNING,
+            )
+            return
+
+        conflicts = [
+            charger
+            for charger in chargers
+            if charger.forwarded_to_id
+            and charger.forwarded_to_id not in {None, target.pk}
+        ]
+        if conflicts:
+            self.message_user(
+                request,
+                ngettext(
+                    "Skipped %(count)s charge point already forwarded to another node.",
+                    "Skipped %(count)s charge points already forwarded to another node.",
+                    len(conflicts),
+                )
+                % {"count": len(conflicts)},
+                level=messages.WARNING,
+            )
+
+        chargers_to_update = [
+            charger
+            for charger in chargers
+            if charger.forwarded_to_id in (None, target.pk)
+        ]
+        if not chargers_to_update:
+            self.message_user(
+                request,
+                _("No charge points were updated."),
+                level=messages.WARNING,
+            )
+            return
+
+        charger_pks = [c.pk for c in chargers_to_update]
+        Charger.objects.filter(pk__in=charger_pks).update(forwarded_to=target)
+
+        for charger in chargers_to_update:
+            charger.forwarded_to = target
+
+        sample = next((charger for charger in chargers_to_update if charger.charger_id), None)
+        if sample and not self._attempt_forwarding_probe(target, sample.charger_id):
+            self.message_user(
+                request,
+                _(
+                    "Unable to establish a websocket connection to %(node)s for charge point %(charger)s."
+                )
+                % {"node": target, "charger": sample.charger_id},
+                level=messages.WARNING,
+            )
+
+        success = self._send_forwarding_metadata(
+            request, target, chargers_to_update, local_node, private_key
+        )
+
+        if success:
+            now = timezone.now()
+            Charger.objects.filter(pk__in=charger_pks).update(
+                forwarding_watermark=now
+            )
+            self.message_user(
+                request,
+                ngettext(
+                    "Forwarding enabled for %(count)s charge point.",
+                    "Forwarding enabled for %(count)s charge points.",
+                    len(chargers_to_update),
+                )
+                % {"count": len(chargers_to_update)},
+                level=messages.SUCCESS,
+            )
+        else:
+            self.message_user(
+                request,
+                ngettext(
+                    "Marked %(count)s charge point for forwarding; awaiting remote acknowledgment.",
+                    "Marked %(count)s charge points for forwarding; awaiting remote acknowledgment.",
+                    len(chargers_to_update),
+                )
+                % {"count": len(chargers_to_update)},
+                level=messages.INFO,
+            )
+
+        try:
+            push_forwarded_charge_points.delay()
+        except Exception:
+            pass
+
+    @admin.action(description=_("Stop Charge Point Forwarding"))
+    def stop_charge_point_forwarding(self, request, queryset):
+        node_ids = [node.pk for node in queryset if node.pk]
+        if not node_ids:
+            self.message_user(
+                request,
+                _("No remote nodes selected."),
+                level=messages.WARNING,
+            )
+            return
+
+        cleared = Charger.objects.filter(forwarded_to_id__in=node_ids).update(
+            forwarded_to=None, forwarding_watermark=None
+        )
+
+        if cleared:
+            self.message_user(
+                request,
+                ngettext(
+                    "Stopped forwarding for %(count)s charge point.",
+                    "Stopped forwarding for %(count)s charge points.",
+                    cleared,
+                )
+                % {"count": cleared},
+                level=messages.SUCCESS,
+            )
+        else:
+            self.message_user(
+                request,
+                _("No forwarded charge points were updated."),
+                level=messages.WARNING,
+            )
+
     def changeform_view(self, request, object_id=None, form_url="", extra_context=None):
         extra_context = extra_context or {}
         if object_id: