aboutsummaryrefslogtreecommitdiff
path: root/webmentions_ssg/views
diff options
context:
space:
mode:
Diffstat (limited to 'webmentions_ssg/views')
-rw-r--r--webmentions_ssg/views/__init__.py16
-rw-r--r--webmentions_ssg/views/admin.py217
-rw-r--r--webmentions_ssg/views/endpoint.py150
-rw-r--r--webmentions_ssg/views/session.py93
4 files changed, 476 insertions, 0 deletions
diff --git a/webmentions_ssg/views/__init__.py b/webmentions_ssg/views/__init__.py
new file mode 100644
index 0000000..91966d4
--- /dev/null
+++ b/webmentions_ssg/views/__init__.py
@@ -0,0 +1,16 @@
+# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Register all views under the historic root Blueprint."""
+
+from flask import Blueprint
+
+root_page = Blueprint("root", __name__)
+
+
+def register_routes() -> Blueprint:
+ """Import task-backed view handlers after Huey initialization and return the Blueprint."""
+ from . import admin, endpoint, session # noqa: F401
+
+ return root_page
diff --git a/webmentions_ssg/views/admin.py b/webmentions_ssg/views/admin.py
new file mode 100644
index 0000000..46e3b18
--- /dev/null
+++ b/webmentions_ssg/views/admin.py
@@ -0,0 +1,217 @@
+# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Authenticated incoming and outgoing Webmention management."""
+
+import uuid
+
+import sqlalchemy as sa
+from flask import abort, flash, redirect, render_template, request, url_for
+from flask.typing import ResponseReturnValue
+from flask_login import login_required
+from sqlalchemy.orm import selectinload
+
+from .. import forms
+from ..extensions import DATABASE as db
+from ..models import ReceivedWebmention, SentWebmention, Source
+from ..tasks.receiver import verify_webmention
+from ..tasks.scanner import manual_scan_sources
+from ..tasks.sender import send_webmention
+from . import root_page
+
+
+@root_page.route("/received")
+@login_required
+def received() -> ResponseReturnValue:
+ """
+ Display received Webmentions.
+
+ :return: Rendered page containing the paginated received Webmentions.
+ """
+ webmentions = db.paginate(
+ sa.select(ReceivedWebmention).order_by(ReceivedWebmention.uuid.desc()),
+ per_page=25,
+ )
+
+ return render_template(
+ "received.html",
+ title="Received Webmentions",
+ webmentions=webmentions,
+ action_form=forms.AdminActionForm(),
+ )
+
+
+@root_page.post("/received/<uuid:identifier>/delete")
+@login_required
+def delete_received_webmention(identifier: uuid.UUID) -> ResponseReturnValue:
+ """
+ Delete a received Webmention.
+
+ :param identifier: Identifier of the Webmention to delete.
+ :return: Redirect response to the received Webmentions view.
+ """
+ form = forms.AdminActionForm()
+
+ if not form.validate_on_submit():
+ return abort(400)
+
+ webmention = db.session.get(ReceivedWebmention, identifier)
+
+ if webmention is None:
+ return abort(404)
+
+ db.session.delete(webmention)
+ db.session.commit()
+
+ flash(f"Webmention {webmention.uuid} deleted.", "success")
+
+ return redirect(
+ url_for("root.received", page=request.args.get("page", 1, type=int))
+ )
+
+
+@root_page.post("/received/<uuid:identifier>/reverify")
+@login_required
+def reverify_received_webmention(identifier: uuid.UUID) -> ResponseReturnValue:
+ """
+ Queue a received Webmention for reverification.
+
+ The Webmention status is reset before a new verification task is queued.
+
+ :param identifier: Identifier of the Webmention to reverify.
+ :return: Redirect response to the received Webmentions view.
+ """
+ form = forms.AdminActionForm()
+
+ if not form.validate_on_submit():
+ return abort(400)
+
+ webmention = db.session.get(ReceivedWebmention, identifier)
+
+ if webmention is None:
+ return abort(404)
+
+ webmention = webmention.reset_for_verification()
+
+ db.session.commit()
+
+ verify_webmention(identifier)
+
+ flash(f"Webmention {webmention.uuid} queued for reverification.", "success")
+
+ return redirect(
+ url_for("root.received", page=request.args.get("page", 1, type=int))
+ )
+
+
+@root_page.route("/sent")
+@login_required
+def sent() -> ResponseReturnValue:
+ """
+ Display sources with sent Webmentions.
+
+ :return: Rendered page containing the paginated source list.
+ """
+ sources = db.paginate(
+ sa.select(Source)
+ .options(selectinload(Source.sent_webmentions))
+ .order_by(Source.last_seen_at.desc()),
+ per_page=25,
+ )
+ return render_template(
+ "sent.html",
+ title="Sent Webmentions",
+ sources=sources,
+ action_form=forms.AdminActionForm(),
+ )
+
+
+@root_page.post("/sent/rescan")
+@login_required
+def rescan_sent_sources() -> ResponseReturnValue:
+ """
+ Queue a manual scan of sent Webmention sources.
+
+ :return: Redirect response to the sent Webmentions view.
+ """
+ form = forms.AdminActionForm()
+ if form.validate_on_submit():
+ manual_scan_sources()
+ flash("Source rescan queued.", "success")
+ return redirect(url_for("root.sent"))
+
+
+@root_page.route("/sent/<uuid:source_identifier>")
+@login_required
+def sent_source(source_identifier: uuid.UUID) -> ResponseReturnValue:
+ """
+ Display the sent Webmentions associated with a source.
+
+ :param source_identifier: Identifier of the source to display.
+ :return: Rendered source details page.
+ """
+ source = db.session.scalar(
+ sa.select(Source).where(Source.uuid == source_identifier)
+ )
+
+ if source is None:
+ return abort(404)
+
+ webmentions = db.paginate(
+ sa.select(SentWebmention)
+ .where(SentWebmention.source_id == source.uuid)
+ .order_by(SentWebmention.target, SentWebmention.uuid),
+ per_page=25,
+ )
+
+ return render_template(
+ "sent_source.html",
+ title="Sent Webmentions",
+ source=source,
+ webmentions=webmentions,
+ action_form=forms.AdminActionForm(),
+ )
+
+
+@root_page.post("/sent/<uuid:source_identifier>/<uuid:webmention_identifier>/resend")
+@login_required
+def resend_sent_webmention(
+ source_identifier: uuid.UUID, webmention_identifier: uuid.UUID
+) -> ResponseReturnValue:
+ """
+ Queue an outgoing Webmention to be sent again.
+
+ The current desired source revision is reopened for processing so the
+ sender task does not treat the Webmention as already completed. Historical
+ successful-send fields are preserved, while result fields from the previous
+ attempt are cleared.
+
+ :param source_identifier: Identifier of the source owning the Webmention.
+ :param webmention_identifier: Identifier of the sent Webmention to resend.
+ :return: Redirect response to the source details view.
+ """
+ form = forms.AdminActionForm()
+
+ if not form.validate_on_submit():
+ return abort(400)
+
+ webmention = db.session.get(SentWebmention, webmention_identifier)
+
+ if webmention is None or webmention.source_id != source_identifier:
+ return abort(404)
+
+ # Reopen the existing desired revision instead of inventing a new source
+ # revision. send_webmention() otherwise exits when this revision has already
+ # been processed.
+ webmention = webmention.reopen(
+ webmention.desired_revision, webmention.active, resend=True
+ )
+
+ db.session.commit()
+
+ send_webmention(webmention_identifier)
+
+ flash(f"Webmention {webmention.uuid} queued for resend.", "success")
+
+ return redirect(url_for("root.sent_source", source_identifier=source_identifier))
diff --git a/webmentions_ssg/views/endpoint.py b/webmentions_ssg/views/endpoint.py
new file mode 100644
index 0000000..1c2fe13
--- /dev/null
+++ b/webmentions_ssg/views/endpoint.py
@@ -0,0 +1,150 @@
+# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Public Webmention endpoint and verification status view."""
+
+import uuid
+from datetime import UTC, datetime, timedelta
+from typing import Any, cast
+
+import sqlalchemy as sa
+import sqlalchemy.exc as sa_exc
+from flask import Response, abort, current_app, render_template, url_for
+from flask.typing import ResponseReturnValue
+from sqlalchemy.engine import CursorResult
+
+from .. import forms
+from ..extensions import CSRF, LIMITER
+from ..extensions import DATABASE as db
+from ..models import ReceivedWebmention, received_url_digest
+from ..tasks.receiver import verify_webmention
+from . import root_page
+
+
+def submit_received(source: str, target: str) -> tuple[uuid.UUID, bool] | None:
+ """Upsert a submission atomically and return (identifier, enqueue flag).
+
+ ``None`` means that the URL fingerprint matches a different source/target.
+ No background task is enqueued until the transaction is committed.
+ """
+ url_digest = received_url_digest(source, target)
+ webmention = db.session.execute(
+ sa.select(ReceivedWebmention).where(ReceivedWebmention.url_digest == url_digest)
+ ).scalar_one_or_none()
+
+ # A SHA-256 collision must never cause an unrelated Webmention to be overwritten.
+ if webmention is not None and (webmention.source, webmention.target) != (
+ source,
+ target,
+ ):
+ return None
+
+ should_verify = False
+
+ if webmention is None:
+ identifier = uuid.uuid7()
+ webmention = ReceivedWebmention(uuid=identifier, source=source, target=target)
+ db.session.add(webmention)
+
+ try:
+ db.session.commit()
+ should_verify = True
+ except sa_exc.IntegrityError:
+ db.session.rollback()
+
+ # Another request may have inserted the same source/target pair
+ # after our SELECT but before our COMMIT.
+ webmention = db.session.execute(
+ sa.select(ReceivedWebmention).where(
+ ReceivedWebmention.url_digest == url_digest
+ )
+ ).scalar_one_or_none()
+ if webmention is None or (webmention.source, webmention.target) != (
+ source,
+ target,
+ ):
+ return None
+
+ else:
+ now = datetime.now(UTC)
+ cutoff = now - timedelta(
+ seconds=current_app.config["ENDPOINT_REVERIFY_COOLDOWN_SECONDS"]
+ )
+
+ # Atomic conditional update: only one concurrent request can reopen an expired verification.
+ result = cast(
+ CursorResult[Any],
+ db.session.execute(
+ sa.update(ReceivedWebmention)
+ .where(
+ ReceivedWebmention.uuid == webmention.uuid,
+ ReceivedWebmention.updated_at <= cutoff,
+ )
+ .values(ReceivedWebmention.verification_reset_values(at=now))
+ .execution_options(synchronize_session=False)
+ ),
+ )
+ should_verify = result.rowcount == 1
+ db.session.commit()
+
+ return webmention.uuid, should_verify
+
+
+@root_page.post("/endpoint")
+@LIMITER.limit(
+ lambda: current_app.config["ENDPOINT_GLOBAL_RATE_LIMIT"],
+ key_func=lambda: "all-clients",
+)
+@LIMITER.limit(lambda: current_app.config["ENDPOINT_RATE_LIMIT"])
+@CSRF.exempt
+def endpoint() -> ResponseReturnValue:
+ """
+ Receive and queue a Webmention for verification.
+
+ Existing Webmentions with the same source and target are reset for
+ reverification. Concurrent insertion of the same Webmention is handled by
+ retrieving and updating the row created by the competing request.
+
+ :return: HTTP 201 response with the Webmention status URL in the
+ ``Location`` header, or validation errors with HTTP 400.
+ """
+ form = forms.EndpointForm(meta={"csrf": False})
+
+ if not form.validate_on_submit():
+ return form.errors, 400
+
+ source = cast(str, form.source.data)
+ target = cast(str, form.target.data)
+
+ result = submit_received(source, target)
+
+ if result is None:
+ return {"error": "Webmention URL fingerprint conflict"}, 409
+
+ identifier, should_verify = result
+
+ if should_verify:
+ verify_webmention(identifier)
+
+ status_url = url_for("root.status", identifier=str(identifier), _external=True)
+
+ return Response(status=201, headers={"Location": status_url})
+
+
+@root_page.route("/status/<uuid:identifier>")
+def status(identifier: uuid.UUID) -> ResponseReturnValue:
+ """
+ Display the verification status of a received Webmention.
+
+ :param identifier: Identifier of the Webmention to display.
+ :return: Rendered Webmention status page.
+ """
+ webmention = db.session.get(ReceivedWebmention, identifier)
+
+ if webmention is None:
+ return abort(404)
+
+ return render_template(
+ "status.html", title="Webmention status", webmention=webmention
+ )
diff --git a/webmentions_ssg/views/session.py b/webmentions_ssg/views/session.py
new file mode 100644
index 0000000..7bd8a10
--- /dev/null
+++ b/webmentions_ssg/views/session.py
@@ -0,0 +1,93 @@
+# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Authentication and session routes."""
+
+import sqlalchemy as sa
+from flask import current_app, flash, redirect, render_template, request, url_for
+from flask.typing import ResponseReturnValue
+from flask_login import current_user, login_required, login_user, logout_user
+
+from .. import forms
+from ..auth import DUMMY_USER, is_safe_next_url, login_username_limit_key
+from ..extensions import DATABASE as db
+from ..extensions import LIMITER
+from ..models import User
+from . import root_page
+
+
+@root_page.route("/")
+def index() -> ResponseReturnValue:
+ """
+ Redirect to the received Webmentions view.
+
+ :return: Redirect response to the received Webmentions view.
+ """
+ return redirect(url_for("root.received"))
+
+
+@root_page.route("/login", methods=["GET", "POST"])
+@LIMITER.limit(
+ lambda: current_app.config["LOGIN_USERNAME_RATE_LIMIT"],
+ key_func=login_username_limit_key,
+ methods=["POST"],
+ error_message="Too many login attempts. Please try again later.",
+)
+@LIMITER.limit(
+ lambda: current_app.config["LOGIN_RATE_LIMIT"],
+ methods=["POST"],
+ error_message="Too many login attempts. Please try again later.",
+)
+def login() -> ResponseReturnValue:
+ """
+ Authenticate a user and start a login session.
+
+ Authenticated users are redirected to the application index. After a
+ successful login, the user is redirected to the requested local URL when
+ provided.
+
+ :return: Rendered login page or redirect response.
+ """
+ if current_user.is_authenticated:
+ return redirect(url_for("root.index"))
+
+ form = forms.LoginForm()
+
+ if form.validate_on_submit():
+ user = db.session.scalar(
+ sa.select(User).where(User.username == form.username.data)
+ )
+
+ user_exists = user is not None
+
+ if user is None:
+ user = DUMMY_USER
+
+ if (
+ form.password.data is None
+ or not user.check_password(form.password.data)
+ or not user_exists
+ ):
+ flash("Invalid username or password", "danger")
+ return redirect(url_for("root.login"))
+ login_user(user)
+
+ next_url = request.args.get("next")
+ if not next_url or not is_safe_next_url(next_url):
+ next_url = url_for("root.index")
+ return redirect(next_url)
+
+ return render_template("login.html", form=form)
+
+
+@root_page.route("/logout", methods=("POST",))
+@login_required
+def logout() -> ResponseReturnValue:
+ """
+ End the current user's login session.
+
+ :return: Redirect response to the application index.
+ """
+ logout_user()
+ return redirect(url_for("root.index"))