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

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.
@@ -31,6 +32,8 @@ class SimulatorConfig:
     repeat: bool = False
     username: Optional[str] = None
     password: Optional[str] = None
+    serial_number: str = ""
+    connector_id: int = 1
 
 
 class ChargePointSimulator:
@@ -40,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}"
@@ -113,6 +167,7 @@ class ChargePointSimulator:
                     {
                         "chargePointModel": "Simulator",
                         "chargePointVendor": "SimVendor",
+                        "serialNumber": cfg.serial_number,
                     },
                 ]
             )
@@ -131,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"
@@ -145,7 +201,7 @@ class ChargePointSimulator:
                                 "status",
                                 "StatusNotification",
                                 {
-                                    "connectorId": 1,
+                                    "connectorId": cfg.connector_id,
                                     "errorCode": "NoError",
                                     "status": "Available",
                                 },
@@ -162,10 +218,12 @@ class ChargePointSimulator:
                                 "meter",
                                 "MeterValues",
                                 {
-                                    "connectorId": 1,
+                                    "connectorId": cfg.connector_id,
                                     "meterValue": [
                                         {
-                                            "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
+                                            "timestamp": time.strftime(
+                                                "%Y-%m-%dT%H:%M:%SZ"
+                                            ),
                                             "sampledValue": [
                                                 {
                                                     "value": "0",
@@ -177,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(
@@ -190,7 +249,7 @@ class ChargePointSimulator:
                         "start",
                         "StartTransaction",
                         {
-                            "connectorId": 1,
+                            "connectorId": cfg.connector_id,
                             "idTag": cfg.rfid,
                             "meterStart": meter_start,
                             "vin": cfg.vin,
@@ -224,11 +283,13 @@ class ChargePointSimulator:
                             "meter",
                             "MeterValues",
                             {
-                                "connectorId": 1,
+                                "connectorId": cfg.connector_id,
                                 "transactionId": tx_id,
                                 "meterValue": [
                                     {
-                                        "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
+                                        "timestamp": time.strftime(
+                                            "%Y-%m-%dT%H:%M:%SZ"
+                                        ),
                                         "sampledValue": [
                                             {
                                                 "value": f"{meter_kw:.3f}",
@@ -243,6 +304,7 @@ class ChargePointSimulator:
                     )
                 )
                 await recv()
+                await self._maybe_send_door_event(send, recv)
                 await asyncio.sleep(cfg.interval)
 
             await send(
@@ -260,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"
@@ -329,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())

ocpp/store.py

@@ -6,21 +6,232 @@ from pathlib import Path
 from datetime import datetime
 import json
 import re
+import asyncio
 
-connections = {}
-transactions = {}
+from core.log_paths import select_log_dir
+
+IDENTITY_SEPARATOR = "#"
+AGGREGATE_SLUG = "all"
+PENDING_SLUG = "pending"
+
+MAX_CONNECTIONS_PER_IP = 2
+
+connections: dict[str, object] = {}
+transactions: dict[str, object] = {}
 logs: dict[str, dict[str, list[str]]] = {"charger": {}, "simulator": {}}
 # store per charger session logs before they are flushed to disk
 history: dict[str, dict[str, object]] = {}
 simulators = {}
+ip_connections: dict[str, set[object]] = {}
 
 # mapping of charger id / cp_path to friendly names used for log files
 log_names: dict[str, dict[str, str]] = {"charger": {}, "simulator": {}}
 
-LOG_DIR = Path(__file__).resolve().parent.parent / "logs"
-LOG_DIR.mkdir(exist_ok=True)
+BASE_DIR = Path(__file__).resolve().parent.parent
+LOG_DIR = select_log_dir(BASE_DIR)
 SESSION_DIR = LOG_DIR / "sessions"
 SESSION_DIR.mkdir(exist_ok=True)
+LOCK_DIR = BASE_DIR / "locks"
+LOCK_DIR.mkdir(exist_ok=True)
+SESSION_LOCK = LOCK_DIR / "charging.lck"
+_lock_task: asyncio.Task | None = None
+
+
+def connector_slug(value: int | str | None) -> str:
+    """Return the canonical slug for a connector value."""
+
+    if value in (None, "", AGGREGATE_SLUG):
+        return AGGREGATE_SLUG
+    try:
+        return str(int(value))
+    except (TypeError, ValueError):
+        return str(value)
+
+
+def identity_key(serial: str, connector: int | str | None) -> str:
+    """Return the identity key used for in-memory store lookups."""
+
+    return f"{serial}{IDENTITY_SEPARATOR}{connector_slug(connector)}"
+
+
+def register_ip_connection(ip: str | None, consumer: object) -> bool:
+    """Track a websocket connection for the provided client IP."""
+
+    if not ip:
+        return True
+    conns = ip_connections.setdefault(ip, set())
+    if consumer in conns:
+        return True
+    if len(conns) >= MAX_CONNECTIONS_PER_IP:
+        return False
+    conns.add(consumer)
+    return True
+
+
+def release_ip_connection(ip: str | None, consumer: object) -> None:
+    """Remove a websocket connection from the active client registry."""
+
+    if not ip:
+        return
+    conns = ip_connections.get(ip)
+    if not conns:
+        return
+    conns.discard(consumer)
+    if not conns:
+        ip_connections.pop(ip, None)
+
+
+def pending_key(serial: str) -> str:
+    """Return the key used before a connector id has been negotiated."""
+
+    return f"{serial}{IDENTITY_SEPARATOR}{PENDING_SLUG}"
+
+
+def _candidate_keys(serial: str, connector: int | str | None) -> list[str]:
+    """Return possible keys for lookups with fallbacks."""
+
+    keys: list[str] = []
+    if connector not in (None, "", AGGREGATE_SLUG):
+        keys.append(identity_key(serial, connector))
+    else:
+        keys.append(identity_key(serial, None))
+        prefix = f"{serial}{IDENTITY_SEPARATOR}"
+        for key in connections.keys():
+            if key.startswith(prefix) and key not in keys:
+                keys.append(key)
+    keys.append(pending_key(serial))
+    keys.append(serial)
+    seen: set[str] = set()
+    result: list[str] = []
+    for key in keys:
+        if key and key not in seen:
+            seen.add(key)
+            result.append(key)
+    return result
+
+
+def iter_identity_keys(serial: str) -> list[str]:
+    """Return all known keys for the provided serial."""
+
+    prefix = f"{serial}{IDENTITY_SEPARATOR}"
+    keys = [key for key in connections.keys() if key.startswith(prefix)]
+    if serial in connections:
+        keys.append(serial)
+    return keys
+
+
+def is_connected(serial: str, connector: int | str | None = None) -> bool:
+    """Return whether a connection exists for the provided charger identity."""
+
+    if connector in (None, "", AGGREGATE_SLUG):
+        prefix = f"{serial}{IDENTITY_SEPARATOR}"
+        return (
+            any(key.startswith(prefix) for key in connections) or serial in connections
+        )
+    return any(key in connections for key in _candidate_keys(serial, connector))
+
+
+def get_connection(serial: str, connector: int | str | None = None):
+    """Return the websocket consumer for the requested identity, if any."""
+
+    for key in _candidate_keys(serial, connector):
+        conn = connections.get(key)
+        if conn is not None:
+            return conn
+    return None
+
+
+def set_connection(serial: str, connector: int | str | None, consumer) -> str:
+    """Store a websocket consumer under the negotiated identity."""
+
+    key = identity_key(serial, connector)
+    connections[key] = consumer
+    return key
+
+
+def pop_connection(serial: str, connector: int | str | None = None):
+    """Remove a stored connection for the given identity."""
+
+    for key in _candidate_keys(serial, connector):
+        conn = connections.pop(key, None)
+        if conn is not None:
+            return conn
+    return None
+
+
+def get_transaction(serial: str, connector: int | str | None = None):
+    """Return the active transaction for the provided identity."""
+
+    for key in _candidate_keys(serial, connector):
+        tx = transactions.get(key)
+        if tx is not None:
+            return tx
+    return None
+
+
+def set_transaction(serial: str, connector: int | str | None, tx) -> str:
+    """Store an active transaction under the provided identity."""
+
+    key = identity_key(serial, connector)
+    transactions[key] = tx
+    return key
+
+
+def pop_transaction(serial: str, connector: int | str | None = None):
+    """Remove and return an active transaction for the identity."""
+
+    for key in _candidate_keys(serial, connector):
+        tx = transactions.pop(key, None)
+        if tx is not None:
+            return tx
+    return None
+
+
+def reassign_identity(old_key: str, new_key: str) -> str:
+    """Move any stored data from ``old_key`` to ``new_key``."""
+
+    if old_key == new_key:
+        return new_key
+    if not old_key:
+        return new_key
+    for mapping in (connections, transactions, history):
+        if old_key in mapping:
+            mapping[new_key] = mapping.pop(old_key)
+    for log_type in logs:
+        store = logs[log_type]
+        if old_key in store:
+            store[new_key] = store.pop(old_key)
+    for log_type in log_names:
+        names = log_names[log_type]
+        if old_key in names:
+            names[new_key] = names.pop(old_key)
+    return new_key
+
+
+async def _touch_lock() -> None:
+    try:
+        while True:
+            SESSION_LOCK.touch()
+            await asyncio.sleep(60)
+    except asyncio.CancelledError:
+        pass
+
+
+def start_session_lock() -> None:
+    global _lock_task
+    SESSION_LOCK.touch()
+    loop = asyncio.get_event_loop()
+    if _lock_task is None or _lock_task.done():
+        _lock_task = loop.create_task(_touch_lock())
+
+
+def stop_session_lock() -> None:
+    global _lock_task
+    if _lock_task:
+        _lock_task.cancel()
+        _lock_task = None
+    if SESSION_LOCK.exists():
+        SESSION_LOCK.unlink()
 
 
 def register_log_name(cid: str, name: str, log_type: str = "charger") -> None:
@@ -86,10 +297,12 @@ def add_session_message(cid: str, message: str) -> None:
     sess = history.get(cid)
     if not sess:
         return
-    sess["messages"].append({
-        "timestamp": datetime.utcnow().isoformat() + "Z",
-        "message": message,
-    })
+    sess["messages"].append(
+        {
+            "timestamp": datetime.utcnow().isoformat() + "Z",
+            "message": message,
+        }
+    )
 
 
 def end_session_log(cid: str) -> None:
@@ -107,15 +320,33 @@ def end_session_log(cid: str) -> None:
         json.dump(sess["messages"], handle, ensure_ascii=False, indent=2)
 
 
-def get_logs(cid: str, log_type: str = "charger") -> list[str]:
-    """Return all log entries for the given id and type."""
+def _log_key_candidates(cid: str, log_type: str) -> list[str]:
+    """Return log identifiers to inspect for the requested cid."""
+
+    if IDENTITY_SEPARATOR not in cid:
+        return [cid]
+    serial, slug = cid.split(IDENTITY_SEPARATOR, 1)
+    slug = slug or AGGREGATE_SLUG
+    if slug != AGGREGATE_SLUG:
+        return [cid]
+    keys: list[str] = [identity_key(serial, None)]
+    prefix = f"{serial}{IDENTITY_SEPARATOR}"
+    for source in (log_names[log_type], logs[log_type]):
+        for key in source.keys():
+            if key.startswith(prefix) and key not in keys:
+                keys.append(key)
+    return keys
+
+
+def _resolve_log_identifier(cid: str, log_type: str) -> tuple[str, str | None]:
+    """Return the canonical key and friendly name for ``cid``."""
 
     names = log_names[log_type]
-    # Try to find a matching log name case-insensitively
     name = names.get(cid)
     if name is None:
+        lower = cid.lower()
         for key, value in names.items():
-            if key.lower() == cid.lower():
+            if key.lower() == lower:
                 cid = key
                 name = value
                 break
@@ -132,14 +363,17 @@ def get_logs(cid: str, log_type: str = "charger") -> list[str]:
                 else:
                     from .models import Charger
 
-                    ch = Charger.objects.filter(charger_id__iexact=cid).first()
+                    serial = cid.split(IDENTITY_SEPARATOR, 1)[0]
+                    ch = Charger.objects.filter(charger_id__iexact=serial).first()
                     if ch and ch.name:
-                        cid = ch.charger_id
                         name = ch.name
                         names[cid] = name
             except Exception:  # pragma: no cover - best effort lookup
                 pass
+    return cid, name
+
 
+def _log_file_for_identifier(cid: str, name: str | None, log_type: str) -> Path:
     path = _file_path(cid, log_type)
     if not path.exists():
         target = f"{log_type}.{_safe_name(name or cid).lower()}"
@@ -147,29 +381,53 @@ def get_logs(cid: str, log_type: str = "charger") -> list[str]:
             if file.stem.lower() == target:
                 path = file
                 break
+    return path
 
-    if path.exists():
-        return path.read_text(encoding="utf-8").splitlines()
 
+def _memory_logs_for_identifier(cid: str, log_type: str) -> list[str]:
     store = logs[log_type]
+    lower = cid.lower()
     for key, entries in store.items():
-        if key.lower() == cid.lower():
+        if key.lower() == lower:
             return entries
     return []
 
 
+def get_logs(cid: str, log_type: str = "charger") -> list[str]:
+    """Return all log entries for the given id and type."""
+
+    entries: list[str] = []
+    seen_paths: set[Path] = set()
+    seen_keys: set[str] = set()
+    for key in _log_key_candidates(cid, log_type):
+        resolved, name = _resolve_log_identifier(key, log_type)
+        path = _log_file_for_identifier(resolved, name, log_type)
+        if path.exists() and path not in seen_paths:
+            entries.extend(path.read_text(encoding="utf-8").splitlines())
+            seen_paths.add(path)
+        memory_entries = _memory_logs_for_identifier(resolved, log_type)
+        lower_key = resolved.lower()
+        if memory_entries and lower_key not in seen_keys:
+            entries.extend(memory_entries)
+            seen_keys.add(lower_key)
+    return entries
+
+
 def clear_log(cid: str, log_type: str = "charger") -> None:
     """Remove any stored logs for the given id and type."""
-
-    store = logs[log_type]
-    key = next((k for k in list(store.keys()) if k.lower() == cid.lower()), cid)
-    store.pop(key, None)
-    path = _file_path(key, log_type)
-    if not path.exists():
-        target = f"{log_type}.{_safe_name(log_names[log_type].get(key, key)).lower()}"
-        for file in LOG_DIR.glob(f"{log_type}.*.log"):
-            if file.stem.lower() == target:
-                path = file
-                break
-    if path.exists():
-        path.unlink()
+    for key in _log_key_candidates(cid, log_type):
+        store_map = logs[log_type]
+        resolved = next(
+            (k for k in list(store_map.keys()) if k.lower() == key.lower()),
+            key,
+        )
+        store_map.pop(resolved, None)
+        path = _file_path(resolved, log_type)
+        if not path.exists():
+            target = f"{log_type}.{_safe_name(log_names[log_type].get(resolved, resolved)).lower()}"
+            for file in LOG_DIR.glob(f"{log_type}.*.log"):
+                if file.stem.lower() == target:
+                    path = file
+                    break
+        if path.exists():
+            path.unlink()

ocpp/tasks.py

@@ -5,23 +5,27 @@ from celery import shared_task
 from django.utils import timezone
 from django.db.models import Q
 
-from .models import MeterReading
+from .models import MeterValue
 
 logger = logging.getLogger(__name__)
 
 
 @shared_task
-def purge_meter_readings() -> int:
-    """Delete meter readings older than 7 days.
+def purge_meter_values() -> int:
+    """Delete meter values older than 7 days.
 
-    Readings tied to transactions without a recorded meter_stop are preserved so
+    Values tied to transactions without a recorded meter_stop are preserved so
     that ongoing or incomplete sessions retain their energy data.
-    Returns the number of deleted readings.
+    Returns the number of deleted rows.
     """
     cutoff = timezone.now() - timedelta(days=7)
-    qs = MeterReading.objects.filter(timestamp__lt=cutoff).filter(
+    qs = MeterValue.objects.filter(timestamp__lt=cutoff).filter(
         Q(transaction__isnull=True) | Q(transaction__meter_stop__isnull=False)
     )
     deleted, _ = qs.delete()
-    logger.info("Purged %s meter readings", deleted)
+    logger.info("Purged %s meter values", deleted)
     return deleted
+
+
+# Backwards compatibility alias
+purge_meter_readings = purge_meter_values

ocpp/test_export_import.py

@@ -10,7 +10,7 @@ from django.utils import timezone
 from django.urls import reverse
 from django.contrib.auth import get_user_model
 
-from ocpp.models import Charger, Transaction, MeterReading
+from ocpp.models import Charger, Transaction, MeterValue
 from core.models import EnergyAccount
 
 
@@ -29,12 +29,11 @@ class TransactionExportImportTests(TestCase):
             charger=self.ch2,
             start_time=now,
         )
-        MeterReading.objects.create(
+        MeterValue.objects.create(
             charger=self.ch1,
             transaction=self.tx_old,
             timestamp=now - timedelta(days=5),
-            value=1,
-            unit="kW",
+            energy=1,
         )
 
     def test_export_filters_and_import_creates_chargers(self):
@@ -55,7 +54,7 @@ class TransactionExportImportTests(TestCase):
         self.assertEqual(len(data["transactions"]), 1)
         self.assertEqual(data["transactions"][0]["charger"], "C2")
 
-        MeterReading.objects.all().delete()
+        MeterValue.objects.all().delete()
         Transaction.objects.all().delete()
         Charger.objects.all().delete()
 
@@ -117,7 +116,7 @@ class TransactionAdminExportImportTests(TestCase):
                     "meter_stop": 0,
                     "start_time": timezone.now().isoformat(),
                     "stop_time": None,
-                    "meter_readings": [],
+                    "meter_values": [],
                 }
             ],
         }
@@ -126,4 +125,6 @@ class TransactionAdminExportImportTests(TestCase):
         response = self.client.post(url, {"file": json_file})
         self.assertEqual(response.status_code, 302)
         self.assertTrue(Charger.objects.filter(charger_id="C9").exists())
-        self.assertEqual(Transaction.objects.filter(charger__charger_id="C9").count(), 1)
+        self.assertEqual(
+            Transaction.objects.filter(charger__charger_id="C9").count(), 1
+        )