arthexis 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

ocpp/consumers.py

@@ -1,8 +1,11 @@
+import asyncio
 import json
 import base64
+import ipaddress
+import re
 from datetime import datetime
 from django.utils import timezone
-from core.models import EnergyAccount, RFID as CoreRFID
+from core.models import EnergyAccount, Reference, RFID as CoreRFID
 from nodes.models import NetMessage
 
 from channels.generic.websocket import AsyncWebsocketConsumer
@@ -14,6 +17,83 @@ from . import store
 from decimal import Decimal
 from django.utils.dateparse import parse_datetime
 from .models import Transaction, Charger, MeterValue
+from .reference_utils import host_is_local_loopback
+
+FORWARDED_PAIR_RE = re.compile(r"for=(?:\"?)(?P<value>[^;,\"\s]+)(?:\"?)", re.IGNORECASE)
+
+
+def _parse_ip(value: str | None):
+    """Return an :mod:`ipaddress` object for the provided value, if valid."""
+
+    candidate = (value or "").strip()
+    if not candidate or candidate.lower() == "unknown":
+        return None
+    if candidate.lower().startswith("for="):
+        candidate = candidate[4:].strip()
+    candidate = candidate.strip("'\"")
+    if candidate.startswith("["):
+        closing = candidate.find("]")
+        if closing != -1:
+            candidate = candidate[1:closing]
+        else:
+            candidate = candidate[1:]
+    # Remove any comma separated values that may remain.
+    if "," in candidate:
+        candidate = candidate.split(",", 1)[0].strip()
+    try:
+        parsed = ipaddress.ip_address(candidate)
+    except ValueError:
+        host, sep, maybe_port = candidate.rpartition(":")
+        if not sep or not maybe_port.isdigit():
+            return None
+        try:
+            parsed = ipaddress.ip_address(host)
+        except ValueError:
+            return None
+    return parsed
+
+
+def _resolve_client_ip(scope: dict) -> str | None:
+    """Return the most useful client IP for the provided ASGI scope."""
+
+    headers = scope.get("headers") or []
+    header_map: dict[str, list[str]] = {}
+    for key_bytes, value_bytes in headers:
+        try:
+            key = key_bytes.decode("latin1").lower()
+        except Exception:
+            continue
+        try:
+            value = value_bytes.decode("latin1")
+        except Exception:
+            value = ""
+        header_map.setdefault(key, []).append(value)
+
+    candidates: list[str] = []
+    for raw in header_map.get("x-forwarded-for", []):
+        candidates.extend(part.strip() for part in raw.split(","))
+    for raw in header_map.get("forwarded", []):
+        for segment in raw.split(","):
+            match = FORWARDED_PAIR_RE.search(segment)
+            if match:
+                candidates.append(match.group("value"))
+    candidates.extend(header_map.get("x-real-ip", []))
+    client = scope.get("client")
+    if client:
+        candidates.append((client[0] or "").strip())
+
+    fallback: str | None = None
+    for raw in candidates:
+        parsed = _parse_ip(raw)
+        if not parsed:
+            continue
+        ip_text = str(parsed)
+        if parsed.is_loopback:
+            if fallback is None:
+                fallback = ip_text
+            continue
+        return ip_text
+    return fallback
 
 
 class SinkConsumer(AsyncWebsocketConsumer):
@@ -21,8 +101,15 @@ class SinkConsumer(AsyncWebsocketConsumer):
 
     @requires_network
     async def connect(self) -> None:
+        self.client_ip = _resolve_client_ip(self.scope)
+        if not store.register_ip_connection(self.client_ip, self):
+            await self.close(code=4003)
+            return
         await self.accept()
 
+    async def disconnect(self, close_code):
+        store.release_ip_connection(getattr(self, "client_ip", None), self)
+
     async def receive(
         self, text_data: str | None = None, bytes_data: bytes | None = None
     ) -> None:
@@ -39,22 +126,37 @@ class SinkConsumer(AsyncWebsocketConsumer):
 class CSMSConsumer(AsyncWebsocketConsumer):
     """Very small subset of OCPP 1.6 CSMS behaviour."""
 
+    consumption_update_interval = 300
+
     @requires_network
     async def connect(self):
         self.charger_id = self.scope["url_route"]["kwargs"].get("cid", "")
         self.connector_value: int | None = None
         self.store_key = store.pending_key(self.charger_id)
         self.aggregate_charger: Charger | None = None
+        self._consumption_task: asyncio.Task | None = None
+        self._consumption_message_uuid: str | None = None
         subprotocol = None
         offered = self.scope.get("subprotocols", [])
         if "ocpp1.6" in offered:
             subprotocol = "ocpp1.6"
+        self.client_ip = _resolve_client_ip(self.scope)
+        self._header_reference_created = False
         # Close any pending connection for this charger so reconnections do
         # not leak stale consumers when the connector id has not been
         # negotiated yet.
         existing = store.connections.get(self.store_key)
         if existing is not None:
+            store.release_ip_connection(getattr(existing, "client_ip", None), existing)
             await existing.close()
+        if not store.register_ip_connection(self.client_ip, self):
+            store.add_log(
+                self.store_key,
+                f"Rejected connection from {self.client_ip or 'unknown'}: rate limit exceeded",
+                log_type="charger",
+            )
+            await self.close(code=4003)
+            return
         await self.accept(subprotocol=subprotocol)
         store.add_log(
             self.store_key,
@@ -70,6 +172,7 @@ class CSMSConsumer(AsyncWebsocketConsumer):
             connector_id=None,
             defaults={"last_path": self.scope.get("path", "")},
         )
+        await database_sync_to_async(self.charger.refresh_manager_node)()
         self.aggregate_charger = self.charger
         location_name = await sync_to_async(
             lambda: self.charger.location.name if self.charger.location else ""
@@ -95,11 +198,19 @@ class CSMSConsumer(AsyncWebsocketConsumer):
 
     async def _assign_connector(self, connector: int | str | None) -> None:
         """Ensure ``self.charger`` matches the provided connector id."""
-        if connector is None:
-            return
-        try:
-            connector_value = int(connector)
-        except (TypeError, ValueError):
+        if connector in (None, "", "-"):
+            connector_value = None
+        else:
+            try:
+                connector_value = int(connector)
+                if connector_value == 0:
+                    connector_value = None
+            except (TypeError, ValueError):
+                return
+        if connector_value is None:
+            if not self._header_reference_created and self.client_ip:
+                await database_sync_to_async(self._ensure_console_reference)()
+                self._header_reference_created = True
             return
         if (
             self.connector_value == connector_value
@@ -110,15 +221,15 @@ class CSMSConsumer(AsyncWebsocketConsumer):
             not self.aggregate_charger
             or self.aggregate_charger.connector_id is not None
         ):
-            self.aggregate_charger = await database_sync_to_async(
+            aggregate, _ = await database_sync_to_async(
                 Charger.objects.get_or_create
             )(
                 charger_id=self.charger_id,
                 connector_id=None,
                 defaults={"last_path": self.scope.get("path", "")},
-            )[
-                0
-            ]
+            )
+            await database_sync_to_async(aggregate.refresh_manager_node)()
+            self.aggregate_charger = aggregate
         existing = await database_sync_to_async(
             Charger.objects.filter(
                 charger_id=self.charger_id, connector_id=connector_value
@@ -126,6 +237,7 @@ class CSMSConsumer(AsyncWebsocketConsumer):
         )()
         if existing:
             self.charger = existing
+            await database_sync_to_async(self.charger.refresh_manager_node)()
         else:
 
             def _create_connector():
@@ -139,6 +251,7 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                 ):
                     charger.last_path = self.scope.get("path")
                     charger.save(update_fields=["last_path"])
+                charger.refresh_manager_node()
                 return charger
 
             self.charger = await database_sync_to_async(_create_connector)()
@@ -168,6 +281,41 @@ class CSMSConsumer(AsyncWebsocketConsumer):
         self.store_key = new_key
         self.connector_value = connector_value
 
+    def _ensure_console_reference(self) -> None:
+        """Create or update a header reference for the connected charger."""
+
+        ip = (self.client_ip or "").strip()
+        serial = (self.charger_id or "").strip()
+        if not ip or not serial:
+            return
+        if host_is_local_loopback(ip):
+            return
+        host = ip
+        if ":" in host and not host.startswith("["):
+            host = f"[{host}]"
+        url = f"http://{host}:8900"
+        alt_text = f"{serial} Console"
+        reference = Reference.objects.filter(alt_text=alt_text).order_by("id").first()
+        if reference is None:
+            reference = Reference.objects.create(
+                alt_text=alt_text,
+                value=url,
+                show_in_header=True,
+                method="link",
+            )
+        updated_fields: list[str] = []
+        if reference.value != url:
+            reference.value = url
+            updated_fields.append("value")
+        if reference.method != "link":
+            reference.method = "link"
+            updated_fields.append("method")
+        if not reference.show_in_header:
+            reference.show_in_header = True
+            updated_fields.append("show_in_header")
+        if updated_fields:
+            reference.save(update_fields=updated_fields)
+
     async def _store_meter_values(self, payload: dict, raw_message: str) -> None:
         """Parse a MeterValues payload into MeterValue rows."""
         connector_raw = payload.get("connectorId")
@@ -309,46 +457,110 @@ class CSMSConsumer(AsyncWebsocketConsumer):
             target.firmware_status_info = status_info
             target.firmware_timestamp = timestamp
 
-    async def _broadcast_charging_started(self) -> None:
-        """Send a network message announcing a charging session."""
+    async def _cancel_consumption_message(self) -> None:
+        """Stop any scheduled consumption message updates."""
 
-        def _message_payload() -> dict[str, str] | None:
-            charger = self.charger
-            aggregate = self.aggregate_charger
-            if not charger:
-                return None
-            location_name = ""
-            if charger.location_id:
-                location_name = charger.location.name
-            elif aggregate and aggregate.location_id:
-                location_name = aggregate.location.name
-            cid_value = (
-                charger.connector_slug
-                if charger.connector_id is not None
-                else Charger.AGGREGATE_CONNECTOR_SLUG
+        task = self._consumption_task
+        self._consumption_task = None
+        if task:
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+        self._consumption_message_uuid = None
+
+    async def _update_consumption_message(self, tx_id: int) -> str | None:
+        """Create or update the Net Message for an active transaction."""
+
+        existing_uuid = self._consumption_message_uuid
+
+        def _persist() -> str | None:
+            tx = (
+                Transaction.objects.select_related("charger")
+                .filter(pk=tx_id)
+                .first()
             )
-            return {
-                "location": location_name,
-                "sn": charger.charger_id,
-                "cid": str(cid_value),
-            }
-
-        payload = await database_sync_to_async(_message_payload)()
-        if not payload:
-            return
+            if not tx:
+                return None
+            charger = tx.charger or self.charger
+            serial = ""
+            if charger and charger.charger_id:
+                serial = charger.charger_id
+            elif self.charger_id:
+                serial = self.charger_id
+            serial = serial[:64]
+            if not serial:
+                return None
+            now_local = timezone.localtime(timezone.now())
+            body_value = f"{tx.kw:.1f} kWh {now_local.strftime('%H:%M')}"[:256]
+            if existing_uuid:
+                msg = NetMessage.objects.filter(uuid=existing_uuid).first()
+                if msg:
+                    msg.subject = serial
+                    msg.body = body_value
+                    msg.save(update_fields=["subject", "body"])
+                    msg.propagate()
+                    return str(msg.uuid)
+            msg = NetMessage.broadcast(subject=serial, body=body_value)
+            return str(msg.uuid)
+
         try:
-            await database_sync_to_async(NetMessage.broadcast)(
-                subject="charging-started",
-                body=json.dumps(payload, separators=(",", ":")),
+            result = await database_sync_to_async(_persist)()
+        except Exception as exc:  # pragma: no cover - unexpected errors
+            store.add_log(
+                self.store_key,
+                f"Failed to broadcast consumption message: {exc}",
+                log_type="charger",
             )
-        except Exception as exc:  # pragma: no cover - logging of unexpected errors
+            return None
+        if result is None:
             store.add_log(
                 self.store_key,
-                f"Failed to broadcast charging start: {exc}",
+                "Unable to broadcast consumption message: missing data",
                 log_type="charger",
             )
+            return None
+        self._consumption_message_uuid = result
+        return result
+
+    async def _consumption_message_loop(self, tx_id: int) -> None:
+        """Periodically refresh the consumption Net Message."""
+
+        try:
+            while True:
+                await asyncio.sleep(self.consumption_update_interval)
+                updated = await self._update_consumption_message(tx_id)
+                if not updated:
+                    break
+        except asyncio.CancelledError:
+            pass
+        except Exception as exc:  # pragma: no cover - unexpected errors
+            store.add_log(
+                self.store_key,
+                f"Failed to refresh consumption message: {exc}",
+                log_type="charger",
+            )
+
+    async def _start_consumption_updates(self, tx_obj: Transaction) -> None:
+        """Send the initial consumption message and schedule updates."""
+
+        await self._cancel_consumption_message()
+        initial = await self._update_consumption_message(tx_obj.pk)
+        if not initial:
+            return
+        task = asyncio.create_task(self._consumption_message_loop(tx_obj.pk))
+        task.add_done_callback(lambda _: setattr(self, "_consumption_task", None))
+        self._consumption_task = task
 
     async def disconnect(self, close_code):
+        store.release_ip_connection(getattr(self, "client_ip", None), self)
+        tx_obj = None
+        if self.charger_id:
+            tx_obj = store.get_transaction(self.charger_id, self.connector_value)
+        if tx_obj:
+            await self._update_consumption_message(tx_obj.pk)
+        await self._cancel_consumption_message()
         store.connections.pop(self.store_key, None)
         pending_key = store.pending_key(self.charger_id)
         if self.store_key != pending_key:
@@ -552,7 +764,7 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                     store.start_session_log(self.store_key, tx_obj.pk)
                     store.start_session_lock()
                     store.add_session_message(self.store_key, text_data)
-                    await self._broadcast_charging_started()
+                    await self._start_consumption_updates(tx_obj)
                     reply_payload = {
                         "transactionId": tx_obj.pk,
                         "idTagInfo": {"status": "Accepted"},
@@ -579,6 +791,8 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                     tx_obj.meter_stop = payload.get("meterStop")
                     tx_obj.stop_time = timezone.now()
                     await database_sync_to_async(tx_obj.save)()
+                    await self._update_consumption_message(tx_obj.pk)
+                await self._cancel_consumption_message()
                 reply_payload = {"idTagInfo": {"status": "Accepted"}}
                 store.end_session_log(self.store_key)
                 store.stop_session_lock()

ocpp/evcs.py

@@ -172,7 +172,7 @@ for key, val in _load_state_file().items():  # pragma: no cover - simple load
 async def simulate_cp(
     cp_idx: int,
     host: str,
-    ws_port: int,
+    ws_port: Optional[int],
     rfid: str,
     vin: str,
     cp_path: str,
@@ -196,7 +196,10 @@ async def simulate_cp(
     if the server closes the connection.
     """
 
-    uri = f"ws://{host}:{ws_port}/{cp_path}"
+    if ws_port:
+        uri = f"ws://{host}:{ws_port}/{cp_path}"
+    else:
+        uri = f"ws://{host}/{cp_path}"
     headers = {}
     if username and password:
         userpass = f"{username}:{password}"
@@ -582,7 +585,7 @@ async def simulate_cp(
 def simulate(
     *,
     host: str = "127.0.0.1",
-    ws_port: int = 8000,
+    ws_port: Optional[int] = 8000,
     rfid: str = "FFFFFFFF",
     cp_path: str = "CPX",
     vin: str = "",

ocpp/models.py

@@ -8,6 +8,7 @@ from django.urls import reverse
 from django.utils.translation import gettext_lazy as _
 
 from core.entity import Entity, EntityManager
+from nodes.models import Node
 
 from core.models import (
     EnergyAccount,
@@ -17,6 +18,7 @@ from core.models import (
     Brand as CoreBrand,
     EVModel as CoreEVModel,
 )
+from .reference_utils import url_targets_local_loopback
 
 
 class Location(Entity):
@@ -58,6 +60,11 @@ class Charger(Entity):
         null=True,
         help_text="Optional connector identifier for multi-connector chargers.",
     )
+    public_display = models.BooleanField(
+        _("Show on Public Dashboard"),
+        default=True,
+        help_text="Display this charger on the public status dashboard.",
+    )
     require_rfid = models.BooleanField(
         _("Require RFID Authorization"),
         default=False,
@@ -121,6 +128,13 @@ class Charger(Entity):
         related_name="chargers",
     )
     last_path = models.CharField(max_length=255, blank=True)
+    manager_node = models.ForeignKey(
+        "nodes.Node",
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="managed_chargers",
+    )
 
     def __str__(self) -> str:  # pragma: no cover - simple representation
         return self.charger_id
@@ -240,6 +254,13 @@ class Charger(Entity):
 
     def save(self, *args, **kwargs):
         update_fields = kwargs.get("update_fields")
+        update_list = list(update_fields) if update_fields is not None else None
+        if not self.manager_node_id:
+            local_node = Node.get_local()
+            if local_node:
+                self.manager_node = local_node
+                if update_list is not None and "manager_node" not in update_list:
+                    update_list.append("manager_node")
         if not self.location_id:
             existing = (
                 type(self)
@@ -253,19 +274,34 @@ class Charger(Entity):
             else:
                 location, _ = Location.objects.get_or_create(name=self.charger_id)
                 self.location = location
-            if update_fields is not None:
-                update_list = list(update_fields)
-                if "location" not in update_list:
-                    update_list.append("location")
-                kwargs["update_fields"] = update_list
+            if update_list is not None and "location" not in update_list:
+                update_list.append("location")
+        if update_list is not None:
+            kwargs["update_fields"] = update_list
         super().save(*args, **kwargs)
         ref_value = self._full_url()
+        if url_targets_local_loopback(ref_value):
+            return
         if not self.reference or self.reference.value != ref_value:
             self.reference = Reference.objects.create(
                 value=ref_value, alt_text=self.charger_id
             )
             super().save(update_fields=["reference"])
 
+    def refresh_manager_node(self, node: Node | None = None) -> Node | None:
+        """Ensure ``manager_node`` matches the provided or local node."""
+
+        node = node or Node.get_local()
+        if not node:
+            return None
+        if self.pk is None:
+            self.manager_node = node
+            return node
+        if self.manager_node_id != node.pk:
+            type(self).objects.filter(pk=self.pk).update(manager_node=node)
+            self.manager_node = node
+        return node
+
     @property
     def name(self) -> str:
         if self.location:
@@ -556,7 +592,9 @@ class Simulator(Entity):
         _("Serial Number"), max_length=100, help_text=_("Charge Point WS path")
     )
     host = models.CharField(max_length=100, default="127.0.0.1")
-    ws_port = models.IntegerField(_("WS Port"), default=8000)
+    ws_port = models.IntegerField(
+        _("WS Port"), default=8000, null=True, blank=True
+    )
     rfid = models.CharField(
         max_length=255,
         default="FFFFFFFF",
@@ -572,6 +610,11 @@ class Simulator(Entity):
     repeat = models.BooleanField(default=False)
     username = models.CharField(max_length=100, blank=True)
     password = models.CharField(max_length=100, blank=True)
+    door_open = models.BooleanField(
+        _("Door Open"),
+        default=False,
+        help_text=_("Send a DoorOpen error StatusNotification when enabled."),
+    )
 
     def __str__(self) -> str:  # pragma: no cover - simple representation
         return self.name
@@ -605,7 +648,9 @@ class Simulator(Entity):
         path = self.cp_path
         if not path.endswith("/"):
             path += "/"
-        return f"ws://{self.host}:{self.ws_port}/{path}"
+        if self.ws_port:
+            return f"ws://{self.host}:{self.ws_port}/{path}"
+        return f"ws://{self.host}/{path}"
 
 
 class RFID(CoreRFID):

ocpp/reference_utils.py

@@ -0,0 +1,42 @@
+"""Helpers related to console Reference creation."""
+
+from __future__ import annotations
+
+import ipaddress
+from urllib.parse import urlparse
+
+
+def _normalize_host(host: str | None) -> str:
+    """Return a trimmed host string without surrounding brackets."""
+
+    if not host:
+        return ""
+    host = host.strip()
+    if host.startswith("[") and host.endswith("]"):
+        return host[1:-1]
+    return host
+
+
+def host_is_local_loopback(host: str | None) -> bool:
+    """Return ``True`` when the host string points to 127.0.0.1."""
+
+    normalized = _normalize_host(host)
+    if not normalized:
+        return False
+    try:
+        return ipaddress.ip_address(normalized) == ipaddress.ip_address("127.0.0.1")
+    except ValueError:
+        return False
+
+
+def url_targets_local_loopback(url: str | None) -> bool:
+    """Return ``True`` when the parsed URL host equals 127.0.0.1."""
+
+    if not url:
+        return False
+    parsed = urlparse(url)
+    return host_is_local_loopback(parsed.hostname)
+
+
+__all__ = ["host_is_local_loopback", "url_targets_local_loopback"]
+