"""Orchestrator daemon wiring watcher, SQLite store, uploader, and IPC server.""" from __future__ import annotations import logging import os import threading from dataclasses import replace from pathlib import Path from typing import Any from .config import ( DEFAULT_TARGET_PORT, VALID_THEMES, DaemonConfig, WatchedFolder, add_watched_folder, default_config_path, load_daemon_config, remove_watched_folder, save_daemon_config, ) from .ipc import IpcServer, default_sock_path from .store import SyncStore, compute_sha256, default_db_path, is_media_file from .uploader import Uploader from .watcher import InotifyWatcher, is_ignored_name, scan_folder logger = logging.getLogger(__name__) def _safe_int(value: str | None, default: int = 0) -> int: if value is None: return default try: return int(value) except ValueError: return default def _has_ignored_dir_part(parts: tuple[str, ...], ignore_prefixes: list[str]) -> bool: return any(is_ignored_name(part, ignore_prefixes) for part in parts) class SyncDaemon: """On-device CardputerZero photo sync daemon.""" def __init__( self, config_path: Path | None = None, db_path: Path | None = None, sock_path: Path | None = None, probe_timeout: float = 3.0, watcher_poll_interval: float = 0.5, ) -> None: self.config_path = Path(config_path).expanduser() if config_path is not None else default_config_path() self.db_path = Path(db_path).expanduser() if db_path is not None else default_db_path() self.sock_path = Path(sock_path).expanduser() if sock_path is not None else default_sock_path() self._config_lock = threading.RLock() self.config: DaemonConfig = load_daemon_config(self.config_path) self.store = SyncStore(self.db_path) self._recover_interrupted_uploads() self.wake_event = threading.Event() self.uploader = Uploader( store=self.store, get_config=self.get_config, wake_event=self.wake_event, probe_timeout=probe_timeout, ) self.watcher = InotifyWatcher( on_file_ready=self._on_file_ready, on_dir_created=self._on_dir_created, poll_interval=watcher_poll_interval, ignore_prefixes=self.config.ignore_prefixes, get_ignore_prefixes=lambda: self.get_config().ignore_prefixes, ) self.ipc_server = IpcServer(self.sock_path, self.handle_ipc) self._started = False def _recover_interrupted_uploads(self) -> int: recovered = self.store.recover_interrupted_uploads() if recovered > 0: self.store.log("WARN", f"Recovered {recovered} interrupted upload(s) to PENDING") return recovered def get_config(self) -> DaemonConfig: """Return the current DaemonConfig safely across threads.""" with self._config_lock: return self.config def scan_all(self) -> int: """Recursively scan all enabled watched folders and enqueue unseen media files.""" cfg = self.get_config() total = 0 for folder in cfg.watched_folders: total += scan_folder(folder, cfg, self.store) if total > 0: self.uploader.notify_new_file() return total def _on_file_ready(self, folder: WatchedFolder, file_path: Path) -> None: cfg = self.get_config() active = next((wf for wf in cfg.watched_folders if wf.id == folder.id and wf.enabled), None) if active is None: return root = Path(os.path.expanduser(active.path)) try: rel_obj = file_path.relative_to(root) except ValueError: return if _has_ignored_dir_part(rel_obj.parts[:-1], cfg.ignore_prefixes): return if not is_media_file(file_path, cfg, store=self.store): return try: st = file_path.stat() if st.st_size <= 0: return sha256 = compute_sha256(file_path) rel_path = rel_obj.as_posix() except OSError: return outcome = self.store.enqueue_file( active.id, str(file_path), rel_path, st.st_size, st.st_mtime_ns, sha256, ) if outcome == "enqueued": self.uploader.notify_new_file() def _on_dir_created(self, folder: WatchedFolder, dir_path: Path) -> None: cfg = self.get_config() active = next((wf for wf in cfg.watched_folders if wf.id == folder.id and wf.enabled), None) if active is None: return root = Path(os.path.expanduser(active.path)) try: rel_parts = dir_path.relative_to(root).parts except ValueError: return if rel_parts and _has_ignored_dir_part(rel_parts, cfg.ignore_prefixes): return added = scan_folder(active, cfg, self.store) if added > 0: self.uploader.notify_new_file() def start(self) -> None: """Start watcher, initial scan, IPC server, and uploader loop.""" if self._started: return self._started = True self.store.log("INFO", "cp0-syncd started") self._recover_interrupted_uploads() self.watcher.sync_folders(self.get_config().watched_folders) self.watcher.start() self.scan_all() self.ipc_server.start() self.uploader.start() def stop(self) -> None: """Stop IPC server, watcher, uploader, and close the SQLite store.""" self.ipc_server.stop() self.watcher.stop() self.uploader.stop() self.store.close() self._started = False def run_forever(self, stop_event: threading.Event | None = None) -> None: """Run the daemon until stop_event is set.""" waiter = stop_event if stop_event is not None else threading.Event() self.start() try: waiter.wait() finally: self.stop() def handle_ipc(self, req: dict[str, Any]) -> dict[str, Any]: """Dispatch a parsed IPC JSON request dict and return a JSON-serializable response.""" cmd = req.get("cmd") if not isinstance(cmd, str) or not cmd: return {"ok": False, "error": "Missing 'cmd' field"} if cmd == "status": return self._cmd_status() if cmd == "sync_now": return self._cmd_sync_now() if cmd == "add_folder": return self._cmd_add_folder(req) if cmd == "remove_folder": return self._cmd_remove_folder(req) if cmd == "set_target": return self._cmd_set_target(req) if cmd == "set_theme": return self._cmd_set_theme(req) if cmd == "retry_failed": return self._cmd_retry_failed() return {"ok": False, "error": f"Unknown command: {cmd}"} def _cmd_status(self) -> dict[str, Any]: cfg = self.get_config() snap = self.store.get_status_snapshot(cfg.watched_folders) meta: dict[str, str] = snap["meta"] counts: dict[str, int] = snap["counts"] return { "ok": True, "target_host": cfg.target_host, "target_port": cfg.target_port, "theme": cfg.theme, "mac_online": meta.get("mac_online") == "true", "mac_dest_root": meta.get("mac_dest_root", ""), "syncing": self.uploader.syncing, "current_file": self.uploader.current_file, "pending_count": counts["pending"], "pending_bytes": counts["pending_bytes"], "synced_count": counts["synced"], "failed_count": counts["failed"], "next_retry_sec": self.uploader.next_retry_sec(), "last_sync_ts": _safe_int(meta.get("last_sync_ts"), 0), "last_synced_file": meta.get("last_synced_file", ""), "last_error": meta.get("last_error", ""), "folders": [ { "id": str(item["id"]), "path": str(item["path"]), "label": str(item["label"]), "enabled": bool(item["enabled"]), "exists": bool(item["exists"]), "pending": int(item["pending"]), "synced": int(item["synced"]), } for item in snap["folders"] ], "logs": snap["logs"], } def _cmd_sync_now(self) -> dict[str, Any]: added = self.scan_all() self.uploader.wake(reset_backoff=True, probe=True) return {"ok": True, "enqueued": added} def _cmd_add_folder(self, req: dict[str, Any]) -> dict[str, Any]: path = req.get("path") label = req.get("label") if label is not None and not isinstance(label, str): return {"ok": False, "error": "Folder label must be a string"} with self._config_lock: try: new_cfg, folder = add_watched_folder(self.config, path, label=label) # type: ignore[arg-type] except ValueError as exc: return {"ok": False, "error": str(exc)} save_daemon_config(new_cfg, self.config_path) self.config = new_cfg self.watcher.add_folder(folder) added = scan_folder(folder, new_cfg, self.store) self.store.log("INFO", f"Added watched folder: {folder.path} ({folder.label})") self.uploader.wake(reset_backoff=True, probe=False) return { "ok": True, "folder": { "id": folder.id, "path": folder.path, "label": folder.label, "enabled": folder.enabled, }, "enqueued": added, } def _cmd_remove_folder(self, req: dict[str, Any]) -> dict[str, Any]: folder_id = req.get("folder_id") if not isinstance(folder_id, str) or not folder_id.strip(): return {"ok": False, "error": "Missing or invalid 'folder_id'"} with self._config_lock: if not any(wf.id == folder_id for wf in self.config.watched_folders): return {"ok": False, "error": f"Unknown folder_id: {folder_id}"} new_cfg = remove_watched_folder(self.config, folder_id) save_daemon_config(new_cfg, self.config_path) self.config = new_cfg self.watcher.remove_folder(folder_id) purged = self.store.purge_pending_for_folder(folder_id) self.store.log("INFO", f"Removed watched folder {folder_id} (purged {purged} pending)") return {"ok": True, "purged": purged} def _cmd_set_target(self, req: dict[str, Any]) -> dict[str, Any]: raw_host = req.get("host") if not isinstance(raw_host, str): return {"ok": False, "error": "Target host must be a string"} host = raw_host.strip() if not host or any(ch.isspace() for ch in host) or "/" in host: return {"ok": False, "error": "Invalid target host"} port = req.get("port", DEFAULT_TARGET_PORT) if not isinstance(port, int) or isinstance(port, bool) or not (1 <= port <= 65535): return {"ok": False, "error": "Target port must be an integer between 1 and 65535"} with self._config_lock: new_cfg = replace(self.config, target_host=host, target_port=port) save_daemon_config(new_cfg, self.config_path) self.config = new_cfg self.store.set_meta("mac_online", "false") self.store.set_meta("mac_dest_root", "") self.store.set_meta("last_error", "") self.store.log("INFO", f"Updated target to {host}:{port}") self.uploader.wake(reset_backoff=True, probe=True) return {"ok": True, "target_host": host, "target_port": port} def _cmd_set_theme(self, req: dict[str, Any]) -> dict[str, Any]: theme = req.get("theme") if not isinstance(theme, str) or theme not in VALID_THEMES: return {"ok": False, "error": "Theme must be 'dark' or 'light'"} with self._config_lock: new_cfg = replace(self.config, theme=theme) save_daemon_config(new_cfg, self.config_path) self.config = new_cfg return {"ok": True, "theme": theme} def _cmd_retry_failed(self) -> dict[str, Any]: retried = self.store.retry_all_failed() if retried > 0: self.store.log("INFO", f"Queued {retried} failed files for retry") self.uploader.wake(reset_backoff=True, probe=True) return {"ok": True, "retried": retried}