237 lines
9.7 KiB
Python
237 lines
9.7 KiB
Python
"""
|
|
Notifications through Apprise (v2.14.0, ADR-074)
|
|
|
|
The owner hears about new responses (received webmentions and backfeed
|
|
alike) and about crossposting problems, on whatever service the Apprise
|
|
URLs in NOTIFY_URLS point at (Gotify, ntfy, Pushover, email, an
|
|
apprise-api server…).
|
|
|
|
Responses are sent by a sweep (`sweep`) in the webmention worker, which
|
|
runs in one process at a time: each response with `notified_at` empty is
|
|
sent once and marked. Likes, reposts and bookmarks are grouped per note.
|
|
Failed sends are retried with backoff; responses still unsent after 24
|
|
hours are dropped. Problems (`problem`) are sent at once, without retry.
|
|
|
|
Nothing here may break validation, crossposting or backfeed: every send is
|
|
wrapped, and failures are only logged and shown in the admin.
|
|
"""
|
|
|
|
import html
|
|
import logging
|
|
import re
|
|
import sqlite3
|
|
import time
|
|
from typing import Dict, List, Optional, Tuple
|
|
from urllib.parse import parse_qsl, urlsplit
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
RESPONSE_EVENTS = ("reply", "mention", "quote", "like", "repost", "bookmark")
|
|
EVENTS = RESPONSE_EVENTS + ("problems",)
|
|
DEFAULT_EVENTS = "reply,mention,quote,problems"
|
|
GROUPED = ("like", "repost", "bookmark")
|
|
DROP_AFTER_HOURS = 24
|
|
MAX_BACKOFF = 15 * 60
|
|
SEND_TIMEOUT = 15
|
|
|
|
HEADINGS = {
|
|
"reply": "↩ Reply from {who}",
|
|
"mention": "💬 Mention from {who}",
|
|
"quote": "❝ Quote from {who}",
|
|
}
|
|
GROUP_HEADINGS = {
|
|
"like": ("♥", "like", "likes"),
|
|
"repost": ("🔁", "repost", "reposts"),
|
|
"bookmark": ("🔖", "bookmark", "bookmarks"),
|
|
}
|
|
|
|
|
|
# --- Settings ---------------------------------------------------------------------
|
|
|
|
def urls(config) -> List[str]:
|
|
"""NOTIFY_URLS as a list (space- or comma-separated)"""
|
|
return [u for u in re.split(r"[\s,]+", config.get("NOTIFY_URLS") or "") if u]
|
|
|
|
|
|
def events(config) -> set:
|
|
"""NOTIFY_EVENTS as a set of known event names"""
|
|
chosen = {e.strip().lower() for e in (config.get("NOTIFY_EVENTS") or DEFAULT_EVENTS).split(",")}
|
|
return chosen & set(EVENTS)
|
|
|
|
|
|
def enabled(config) -> bool:
|
|
return bool(urls(config))
|
|
|
|
|
|
def with_priority(url: str, priority: str) -> str:
|
|
"""The URL with `priority=` added, unless it sets one itself"""
|
|
if not priority or any(k == "priority" for k, _ in parse_qsl(urlsplit(url).query)):
|
|
return url
|
|
return url + ("&" if "?" in url else "?") + "priority=" + priority
|
|
|
|
|
|
# --- Sending ----------------------------------------------------------------------------
|
|
|
|
def _deliver(targets: List[str], title: str, body: str) -> Tuple[bool, str]:
|
|
"""Send one message to every URL. Returns (all sent, error text)."""
|
|
import apprise
|
|
|
|
sender = apprise.Apprise()
|
|
bad = [u.split("://", 1)[0] + "://…" for u in targets if not sender.add(u)]
|
|
if bad:
|
|
return False, f"Not a usable Apprise URL: {', '.join(bad)}"
|
|
with apprise.LogCapture(level=logging.WARNING, fmt="%(message)s") as log:
|
|
result = sender.notify(body, title=title, body_format=apprise.NotifyFormat.MARKDOWN,
|
|
timeout=SEND_TIMEOUT)
|
|
return bool(result), log.getvalue().strip()[:500]
|
|
|
|
|
|
def send(config, title: str, body: str) -> Tuple[bool, str]:
|
|
"""Send to all NOTIFY_URLS at NOTIFY_PRIORITY. Never raises."""
|
|
targets = [with_priority(u, config.get("NOTIFY_PRIORITY") or "normal") for u in urls(config)]
|
|
if not targets:
|
|
return False, "No NOTIFY_URLS set"
|
|
try:
|
|
ok, error = _deliver(targets, title, body)
|
|
except Exception as e: # a broken service mustn't break the caller
|
|
ok, error = False, f"{type(e).__name__}: {e}"
|
|
if not ok:
|
|
logger.warning(f"Notification '{title}' not sent: {error or 'unknown error'}")
|
|
return ok, error
|
|
|
|
|
|
def problem(config, db_path, title: str, detail: str, link: str) -> None:
|
|
"""A crosspost or backfeed problem, sent at once if 'problems' is selected"""
|
|
if not enabled(config) or "problems" not in events(config):
|
|
return
|
|
ok, error = send(config, f"⚠ {title}", f"{detail}\n\n[Open in StarPunk]({link})")
|
|
_record(db_path, ok, error)
|
|
|
|
|
|
def _record(db_path, ok: bool, error: str) -> None:
|
|
"""Remember the last failure for the admin page (cleared by a success)"""
|
|
try:
|
|
conn = sqlite3.connect(db_path)
|
|
try:
|
|
conn.execute("INSERT INTO site_state (key, value) VALUES ('notify_last_error', ?) "
|
|
"ON CONFLICT(key) DO UPDATE SET value = excluded.value",
|
|
("" if ok else time.strftime("%Y-%m-%d %H:%M:%S UTC ", time.gmtime())
|
|
+ (error or "unknown error"),))
|
|
conn.commit()
|
|
finally:
|
|
conn.close()
|
|
except sqlite3.Error as e:
|
|
logger.warning(f"Could not record notification result: {e}")
|
|
|
|
|
|
def last_error(db) -> str:
|
|
row = db.execute("SELECT value FROM site_state WHERE key = 'notify_last_error'").fetchone()
|
|
return row[0] if row else ""
|
|
|
|
|
|
# --- Messages -----------------------------------------------------------------------------
|
|
|
|
def _plain(snippet: Optional[str], limit: int = 300) -> str:
|
|
text = html.unescape(re.sub(r"<[^>]+>", " ", snippet or ""))
|
|
text = re.sub(r"\s+", " ", text).strip()
|
|
return text if len(text) <= limit else text[:limit - 1].rsplit(" ", 1)[0] + "…"
|
|
|
|
|
|
def _note_label(conn, note_id: int) -> str:
|
|
from starpunk.notes import get_note
|
|
|
|
try:
|
|
note = get_note(id=note_id, load_content=True)
|
|
label = " ".join((note.title or "").split()) if note else ""
|
|
except Exception:
|
|
label = ""
|
|
return (label[:57] + "…") if len(label) > 60 else (label or "a note")
|
|
|
|
|
|
def _messages(rows, site_url: str, conn) -> List[Tuple[str, str, List[int]]]:
|
|
"""(title, body, webmention ids) for a batch of responses"""
|
|
site = site_url.rstrip("/")
|
|
names = {"gotosocial": "GoToSocial", "bluesky": "Bluesky", "threads": "Threads"}
|
|
messages, groups = [], {}
|
|
for row in rows:
|
|
via = names.get(row["origin"]) if row["origin"] != "webmention" else None
|
|
who = (row["author_name"] or "someone") + (f" via {via}" if via else "")
|
|
pending = row["moderation_status"] == "pending"
|
|
link = (f"{site}/admin/webmentions/{row['id']}" if pending
|
|
else f"{site}/note/{row['slug']}#responses")
|
|
if row["mention_type"] in GROUPED:
|
|
groups.setdefault((row["target_note_id"], row["mention_type"], row["slug"], pending), []).append(
|
|
(row["id"], row["author_name"] or "someone", link))
|
|
continue
|
|
title = HEADINGS.get(row["mention_type"], "Response from {who}").format(who=who)
|
|
if pending:
|
|
title += " (awaiting moderation)"
|
|
text = _plain(row["content_snippet"])
|
|
body = (f"{text}\n\n" if text else "") + f"On “{_note_label(conn, row['target_note_id'])}”: [open]({link})"
|
|
messages.append((title, body, [row["id"]]))
|
|
for (note_id, kind, slug, pending), items in groups.items():
|
|
icon, one, many = GROUP_HEADINGS[kind]
|
|
n = len(items)
|
|
title = f"{icon} {n} new {one if n == 1 else many} on “{_note_label(conn, note_id)}”"
|
|
if pending:
|
|
title += " (awaiting moderation)"
|
|
people = ", ".join(name for _, name, _ in items[:5]) + (f" and {n - 5} more" if n > 5 else "")
|
|
messages.append((title, f"{people}\n\n[open]({items[0][2]})", [i for i, _, _ in items]))
|
|
return messages
|
|
|
|
|
|
# --- Sweep ----------------------------------------------------------------------------------
|
|
|
|
class Sweeper:
|
|
"""Sends new responses; one instance per webmention worker"""
|
|
|
|
def __init__(self):
|
|
self._failures = 0
|
|
self._next_try = 0.0
|
|
|
|
def run(self, config, db_path, site_url: str) -> int:
|
|
"""Send what's due. Returns how many responses were sent."""
|
|
if not enabled(config) or time.time() < self._next_try:
|
|
return 0
|
|
chosen = events(config)
|
|
conn = sqlite3.connect(db_path)
|
|
conn.row_factory = sqlite3.Row
|
|
try:
|
|
# Too old to be news (an outage, say): drop quietly
|
|
dropped = conn.execute(
|
|
f"""UPDATE webmentions SET notified_at = CURRENT_TIMESTAMP
|
|
WHERE notified_at IS NULL
|
|
AND received_at < datetime('now', '-{DROP_AFTER_HOURS} hours')""").rowcount
|
|
if dropped:
|
|
logger.warning(f"Dropped {dropped} notification(s) older than {DROP_AFTER_HOURS} hours")
|
|
rows = conn.execute(
|
|
"""
|
|
SELECT w.*, n.slug FROM webmentions w JOIN notes n ON n.id = w.target_note_id
|
|
WHERE w.notified_at IS NULL AND w.validation_status = 'valid'
|
|
AND w.moderation_status IN ('approved', 'pending')
|
|
ORDER BY w.id LIMIT 100
|
|
"""
|
|
).fetchall()
|
|
skip = [r["id"] for r in rows if r["mention_type"] not in chosen]
|
|
if skip:
|
|
conn.execute(f"UPDATE webmentions SET notified_at = CURRENT_TIMESTAMP "
|
|
f"WHERE id IN ({','.join('?' * len(skip))})", skip)
|
|
conn.commit()
|
|
due = [r for r in rows if r["mention_type"] in chosen]
|
|
sent = 0
|
|
for title, body, ids in _messages(due, site_url, conn):
|
|
ok, error = send(config, title, body)
|
|
_record(db_path, ok, error)
|
|
if not ok:
|
|
self._failures += 1
|
|
self._next_try = time.time() + min(10 * 2 ** self._failures, MAX_BACKOFF)
|
|
break
|
|
self._failures = 0
|
|
conn.execute(f"UPDATE webmentions SET notified_at = CURRENT_TIMESTAMP "
|
|
f"WHERE id IN ({','.join('?' * len(ids))})", ids)
|
|
conn.commit()
|
|
sent += len(ids)
|
|
return sent
|
|
finally:
|
|
conn.close()
|