shared_store.py

"""
Bullet-proof shared key-value store.
- Atomic writes (tmp -> fsync -> rename)
- File locking (fcntl), lock omvat de volledige read-modify-write cyclus
- Lock is per bestand (afgeleid van path), geen onnodige contentie tussen files
- No race conditions
- Never produces corrupt JSON
"""
import json
import os
import fcntl
from pathlib import Path
from typing import Any, Dict, Optional
import sys

DEFAULT_PATH = Path("/home/pi/share/shared_data.json")


class SharedStoreError(Exception):
    pass


def _lock_path(path: Path) -> Path:
    return path.with_suffix(".lock")


def _acquire_lock(lockfile):
    """Exclusive lock. Blocks until available."""
    fcntl.flock(lockfile, fcntl.LOCK_EX)


def _release_lock(lockfile):
    fcntl.flock(lockfile, fcntl.LOCK_UN)


def _read_unlocked(path: Path) -> Dict[str, Any]:
    if not path.exists():
        return {}
    try:
        with path.open("r", encoding="utf-8") as f:
            return json.load(f)
    except json.JSONDecodeError:
        return {}


def _write_unlocked(data: Dict[str, Any], path: Path) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    tmp_path = path.with_suffix(".json.tmp")
    with tmp_path.open("w", encoding="utf-8") as f:
        json.dump(data, f, ensure_ascii=False, indent=2)
        f.flush()
        os.fsync(f.fileno())
    os.replace(tmp_path, path)


def _read_raw(path: Path = DEFAULT_PATH) -> Dict[str, Any]:
    lock_path = _lock_path(path)
    lock_path.parent.mkdir(parents=True, exist_ok=True)
    with open(lock_path, "a") as lock:
        _acquire_lock(lock)
        try:
            return _read_unlocked(path)
        finally:
            _release_lock(lock)


def _write_raw(data: Dict[str, Any], path: Path = DEFAULT_PATH) -> None:
    lock_path = _lock_path(path)
    lock_path.parent.mkdir(parents=True, exist_ok=True)
    with open(lock_path, "a") as lock:
        _acquire_lock(lock)
        try:
            _write_unlocked(data, path)
        finally:
            _release_lock(lock)


def set_key(key: str, value: Any, path: Path = DEFAULT_PATH) -> None:
    lock_path = _lock_path(path)
    lock_path.parent.mkdir(parents=True, exist_ok=True)
    with open(lock_path, "a") as lock:
        _acquire_lock(lock)
        try:
            data = _read_unlocked(path)
            # Als zowel bestaande waarde als nieuwe waarde dicts zijn -> merge
            if isinstance(value, dict) and isinstance(data.get(key), dict):
                for k, v in value.items():
                    data[key][k] = v
            else:
                # Anders gewoon vervangen
                data[key] = value
            _write_unlocked(data, path)
        finally:
            _release_lock(lock)


def get_key(key: str, default: Optional[Any] = None, path: Path = DEFAULT_PATH) -> Any:
    return _read_raw(path).get(key, default)


def update_many(values: Dict[str, Any], path: Path = DEFAULT_PATH) -> None:
    lock_path = _lock_path(path)
    lock_path.parent.mkdir(parents=True, exist_ok=True)
    with open(lock_path, "a") as lock:
        _acquire_lock(lock)
        try:
            data = _read_unlocked(path)
            data.update(values)
            _write_unlocked(data, path)
        finally:
            _release_lock(lock)


def read_all(path: Path = DEFAULT_PATH) -> Dict[str, Any]:
    return _read_raw(path)