arthexis 0.1.9__py3-none-any.whl → 0.1.10__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
@@ -15,14 +18,97 @@ from decimal import Decimal
 from django.utils.dateparse import parse_datetime
 from .models import Transaction, Charger, MeterValue
 
+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):
     """Accept any message without validation."""
 
     @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 +125,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 +171,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 +197,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 +220,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 +236,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 +250,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 +280,39 @@ 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
+        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.get_or_create(
+            alt_text=alt_text,
+            defaults={
+                "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 +454,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 +761,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 +788,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,
@@ -58,6 +59,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 +127,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 +253,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,11 +273,10 @@ 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 not self.reference or self.reference.value != ref_value:
@@ -266,6 +285,20 @@ class Charger(Entity):
             )
             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 +589,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 +607,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 +645,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/simulator.py

@@ -3,6 +3,7 @@ import base64
 import json
 import random
 import time
+import uuid
 from dataclasses import dataclass
 from typing import Optional
 import threading
@@ -18,7 +19,7 @@ class SimulatorConfig:
     """Configuration for a simulated charge point."""
 
     host: str = "127.0.0.1"
-    ws_port: int = 8000
+    ws_port: Optional[int] = 8000
     rfid: str = "FFFFFFFF"
     vin: str = ""
     # WebSocket path for the charge point. Defaults to just the charger ID at the root.
@@ -42,14 +43,65 @@ class ChargePointSimulator:
         self.config = config
         self._thread: Optional[threading.Thread] = None
         self._stop_event = threading.Event()
+        self._door_open_event = threading.Event()
         self.status = "stopped"
         self._connected = threading.Event()
         self._connect_error = ""
 
+    def trigger_door_open(self) -> None:
+        """Queue a DoorOpen status notification for the simulator."""
+
+        self._door_open_event.set()
+
+    async def _maybe_send_door_event(self, send, recv) -> None:
+        if not self._door_open_event.is_set():
+            return
+        self._door_open_event.clear()
+        cfg = self.config
+        store.add_log(
+            cfg.cp_path,
+            "Sending DoorOpen StatusNotification",
+            log_type="simulator",
+        )
+        event_id = uuid.uuid4().hex
+        await send(
+            json.dumps(
+                [
+                    2,
+                    f"door-open-{event_id}",
+                    "StatusNotification",
+                    {
+                        "connectorId": cfg.connector_id,
+                        "errorCode": "DoorOpen",
+                        "status": "Faulted",
+                    },
+                ]
+            )
+        )
+        await recv()
+        await send(
+            json.dumps(
+                [
+                    2,
+                    f"door-closed-{event_id}",
+                    "StatusNotification",
+                    {
+                        "connectorId": cfg.connector_id,
+                        "errorCode": "NoError",
+                        "status": "Available",
+                    },
+                ]
+            )
+        )
+        await recv()
+
     @requires_network
     async def _run_session(self) -> None:
         cfg = self.config
-        uri = f"ws://{cfg.host}:{cfg.ws_port}/{cfg.cp_path}"
+        if cfg.ws_port:
+            uri = f"ws://{cfg.host}:{cfg.ws_port}/{cfg.cp_path}"
+        else:
+            uri = f"ws://{cfg.host}/{cfg.cp_path}"
         headers = {}
         if cfg.username and cfg.password:
             userpass = f"{cfg.username}:{cfg.password}"
@@ -134,6 +186,7 @@ class ChargePointSimulator:
 
             await send(json.dumps([2, "auth", "Authorize", {"idTag": cfg.rfid}]))
             await recv()
+            await self._maybe_send_door_event(send, recv)
             if not self._connected.is_set():
                 self.status = "running"
                 self._connect_error = "accepted"
@@ -182,10 +235,11 @@ class ChargePointSimulator:
                                     ],
                                 },
                             ]
-                        )
                     )
-                    await recv()
-                    await asyncio.sleep(cfg.interval)
+                )
+                await recv()
+                await self._maybe_send_door_event(send, recv)
+                await asyncio.sleep(cfg.interval)
 
             meter_start = random.randint(1000, 2000)
             await send(
@@ -250,6 +304,7 @@ class ChargePointSimulator:
                     )
                 )
                 await recv()
+                await self._maybe_send_door_event(send, recv)
                 await asyncio.sleep(cfg.interval)
 
             await send(
@@ -267,6 +322,7 @@ class ChargePointSimulator:
                 )
             )
             await recv()
+            await self._maybe_send_door_event(send, recv)
         except asyncio.TimeoutError:
             if not self._connected.is_set():
                 self._connect_error = "Timeout waiting for response"
@@ -336,6 +392,7 @@ class ChargePointSimulator:
         self.status = "starting"
         self._connected.clear()
         self._connect_error = ""
+        self._door_open_event.clear()
 
         def _runner() -> None:
             asyncio.run(self._run())