Files

337 lines
12 KiB
Python
Raw Permalink Normal View History

"""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}