182 lines
8.1 KiB
Python
182 lines
8.1 KiB
Python
#!/usr/bin/env python3
|
|
"""routine-server: the relay that keeps the desktop and R1 routine apps in step, on a machine of
|
|
your own that both can reach (a home server, a VPN address).
|
|
|
|
Standard library only, and model.py beside it (scripts/deploy-server.sh copies both). Every
|
|
request but /health needs "Authorization: Bearer <token>" (made on first start in <data>/token,
|
|
mode 600). It speaks plain HTTP: bind it to an address only your devices reach (a private network
|
|
or VPN), not the open internet.
|
|
|
|
GET /health -> {"ok": true}
|
|
POST /sync {"since": <seq>, "days": [<day>, ...], "schedule_rev": n, "schedule": {...}?,
|
|
"streaks": {...}?, "streaks_t": t?}
|
|
-> {"seq": <seq>, "days": [<every stored day changed after since>], "schedule": {...}?,
|
|
"streaks": {...}?, "streaks_t": t?}
|
|
|
|
The routine itself rides along: a client may send its schedule (the desktop does after an
|
|
edit); the server keeps the highest rev and hands it to any client whose schedule_rev is lower.
|
|
The streak base rides the same way (model.streak_base plus "t" and the desktop's streak
|
|
settings): the desktop sends it, the server keeps the one with the highest "t" and answers
|
|
every sync with that t as "streaks_t" (the desktop's receipt); a client that sends "streaks_t"
|
|
(the R1) gets the base back whenever the server's is newer. Clients that send neither (older
|
|
apps) never see it, and older servers ignore both: the R1 then counts from its own days.
|
|
|
|
A pushed day is merged into the stored copy with model.merge (last writer wins per item and
|
|
for the note), and gets a new seq only if the merge changed it. A client keeps the returned
|
|
seq and sends it as since next time; since > the server's seq (a fresh server) means "all".
|
|
The server is a relay, not the record: days older than KEEP_DAYS are dropped; the desktop keeps
|
|
everything.
|
|
|
|
python3 routine_server.py --host ADDRESS --port 8070 --data DIR
|
|
"""
|
|
|
|
import argparse
|
|
import datetime as dt
|
|
import json
|
|
import os
|
|
import secrets
|
|
import sqlite3
|
|
import sys
|
|
import threading
|
|
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
|
|
|
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
|
import model # noqa: E402 (deployed beside this file)
|
|
|
|
KEEP_DAYS = 60
|
|
MAX_BODY = 4 * 1024 * 1024
|
|
LOCK = threading.Lock()
|
|
|
|
|
|
class Store:
|
|
def __init__(self, path):
|
|
self.db = sqlite3.connect(path, check_same_thread=False)
|
|
self.db.execute("CREATE TABLE IF NOT EXISTS days (date TEXT PRIMARY KEY, doc TEXT NOT NULL, seq INTEGER NOT NULL)")
|
|
self.db.execute("CREATE TABLE IF NOT EXISTS meta (k TEXT PRIMARY KEY, v TEXT NOT NULL)")
|
|
self.db.commit()
|
|
|
|
def seq(self):
|
|
return self.db.execute("SELECT COALESCE(MAX(seq), 0) FROM days").fetchone()[0]
|
|
|
|
def sync(self, since, pushed, schedule=None, schedule_rev=0, streaks=None, streaks_t=None):
|
|
with LOCK:
|
|
row = self.db.execute("SELECT v FROM meta WHERE k = 'streaks'").fetchone()
|
|
base = json.loads(row[0]) if row else None
|
|
if valid_streaks(streaks) and (base is None or streaks["t"] > base.get("t", 0)):
|
|
base = streaks
|
|
self.db.execute("INSERT OR REPLACE INTO meta (k, v) VALUES ('streaks', ?)", (json.dumps(base),))
|
|
row = self.db.execute("SELECT v FROM meta WHERE k = 'schedule'").fetchone()
|
|
stored = json.loads(row[0]) if row else None
|
|
if isinstance(schedule, dict) and isinstance(schedule.get("blocks"), list) and \
|
|
(stored is None or schedule.get("rev", 0) > stored.get("rev", 0)):
|
|
stored = schedule
|
|
self.db.execute("INSERT OR REPLACE INTO meta (k, v) VALUES ('schedule', ?)", (json.dumps(stored),))
|
|
cutoff = (dt.date.today() - dt.timedelta(days=KEEP_DAYS)).isoformat()
|
|
self.db.execute("DELETE FROM days WHERE date < ?", (cutoff,))
|
|
seq = self.seq()
|
|
for day in pushed:
|
|
date = day.get("date", "")
|
|
try:
|
|
dt.date.fromisoformat(date)
|
|
except (TypeError, ValueError):
|
|
continue
|
|
if date < cutoff:
|
|
continue
|
|
row = self.db.execute("SELECT doc FROM days WHERE date = ?", (date,)).fetchone()
|
|
old = json.loads(row[0]) if row else None
|
|
merged = model.merge(old, day)
|
|
if merged != old:
|
|
seq += 1
|
|
self.db.execute("INSERT OR REPLACE INTO days (date, doc, seq) VALUES (?, ?, ?)",
|
|
(date, json.dumps(merged, separators=(",", ":")), seq))
|
|
self.db.commit()
|
|
if since > seq:
|
|
since = 0
|
|
rows = self.db.execute("SELECT doc FROM days WHERE seq > ? ORDER BY date", (since,)).fetchall()
|
|
out = {"seq": seq, "days": [json.loads(r[0]) for r in rows]}
|
|
if stored is not None and stored.get("rev", 0) > schedule_rev:
|
|
out["schedule"] = stored
|
|
if base is not None:
|
|
out["streaks_t"] = base.get("t", 0)
|
|
if streaks_t is not None and base.get("t", 0) > streaks_t:
|
|
out["streaks"] = base
|
|
return out
|
|
|
|
|
|
def valid_streaks(s):
|
|
"""A streak base worth keeping: {"t": int, "asof": "YYYY-MM-DD", "items": {...}, ...}."""
|
|
if not isinstance(s, dict) or not isinstance(s.get("items"), dict) or type(s.get("t")) is not int:
|
|
return False
|
|
try:
|
|
dt.date.fromisoformat(s.get("asof"))
|
|
except (TypeError, ValueError):
|
|
return False
|
|
return True
|
|
|
|
|
|
class Handler(BaseHTTPRequestHandler):
|
|
server_version = "routine-server"
|
|
|
|
def _send(self, code, obj):
|
|
body = json.dumps(obj, separators=(",", ":")).encode()
|
|
self.send_response(code)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.send_header("Content-Length", str(len(body)))
|
|
self.end_headers()
|
|
self.wfile.write(body)
|
|
|
|
def _authed(self):
|
|
got = self.headers.get("Authorization", "")
|
|
return secrets.compare_digest(got.encode(), ("Bearer " + self.server.token).encode())
|
|
|
|
def do_GET(self):
|
|
if self.path == "/health":
|
|
return self._send(200, {"ok": True})
|
|
self._send(404, {"error": "not found"})
|
|
|
|
def do_POST(self):
|
|
if self.path != "/sync":
|
|
return self._send(404, {"error": "not found"})
|
|
if not self._authed():
|
|
return self._send(401, {"error": "unauthorized"})
|
|
n = int(self.headers.get("Content-Length") or 0)
|
|
if n > MAX_BODY:
|
|
return self._send(413, {"error": "too large"})
|
|
try:
|
|
req = json.loads(self.rfile.read(n) or b"{}")
|
|
since = int(req.get("since", 0))
|
|
days = req.get("days", [])
|
|
if not isinstance(days, list):
|
|
raise ValueError("days")
|
|
sched, srev = req.get("schedule"), int(req.get("schedule_rev", 0))
|
|
st = int(req["streaks_t"]) if req.get("streaks_t") is not None else None
|
|
except (ValueError, TypeError) as e:
|
|
return self._send(400, {"error": "bad request: %s" % e})
|
|
self._send(200, self.server.store.sync(since, days, sched, srev, req.get("streaks"), st))
|
|
|
|
def log_message(self, fmt, *args):
|
|
sys.stderr.write("%s %s\n" % (self.log_date_time_string(), fmt % args))
|
|
|
|
|
|
def main():
|
|
ap = argparse.ArgumentParser()
|
|
ap.add_argument("--host", default="127.0.0.1")
|
|
ap.add_argument("--port", type=int, default=8070)
|
|
ap.add_argument("--data", required=True)
|
|
a = ap.parse_args()
|
|
os.makedirs(a.data, exist_ok=True)
|
|
tok_path = os.path.join(a.data, "token")
|
|
if not os.path.exists(tok_path):
|
|
fd = os.open(tok_path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
|
|
with os.fdopen(fd, "w") as f:
|
|
f.write(secrets.token_urlsafe(32))
|
|
srv = ThreadingHTTPServer((a.host, a.port), Handler)
|
|
srv.token = open(tok_path).read().strip()
|
|
srv.store = Store(os.path.join(a.data, "routine.db"))
|
|
print("routine-server on %s:%d" % (a.host, a.port), flush=True)
|
|
srv.serve_forever()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|