dayfile 0.1.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- dayfile/__init__.py +1 -0
- dayfile/admin.py +467 -0
- dayfile/app.py +676 -0
- dayfile/auth/__init__.py +0 -0
- dayfile/auth/tokens.py +159 -0
- dayfile/cli.py +757 -0
- dayfile/cloudevents.py +130 -0
- dayfile/db.py +314 -0
- dayfile/event.schema.json +97 -0
- dayfile/feeds.py +124 -0
- dayfile/gen/__init__.py +0 -0
- dayfile/gen/digest.py +72 -0
- dayfile/gen/weather.py +91 -0
- dayfile/heartbeats.py +236 -0
- dayfile/icons.py +11 -0
- dayfile/ingest/__init__.py +0 -0
- dayfile/ingest/core.py +147 -0
- dayfile/ingest/email_in.py +253 -0
- dayfile/logsafe.py +38 -0
- dayfile/mcp_http.py +218 -0
- dayfile/mcp_server.py +208 -0
- dayfile/models.py +43 -0
- dayfile/notify/__init__.py +0 -0
- dayfile/notify/ntfy.py +39 -0
- dayfile/notify/scheduler.py +97 -0
- dayfile/ratelimit.py +73 -0
- dayfile/render/__init__.py +0 -0
- dayfile/render/atom.py +96 -0
- dayfile/render/jsonfeed.py +58 -0
- dayfile/render/query.py +78 -0
- dayfile/schema.sql +191 -0
- dayfile/signing.py +197 -0
- dayfile/static/favicon.ico +0 -0
- dayfile/static/favicon.svg +7 -0
- dayfile/static/icon-512.png +0 -0
- dayfile/static/icon-64.png +0 -0
- dayfile/stats.py +68 -0
- dayfile/tenancy.py +319 -0
- dayfile/timefmt.py +44 -0
- dayfile/ulid.py +13 -0
- dayfile/web/__init__.py +7 -0
- dayfile/web/accounts/__init__.py +5 -0
- dayfile/web/accounts/control.py +142 -0
- dayfile/web/accounts/github.py +125 -0
- dayfile/web/accounts/grants.py +286 -0
- dayfile/web/accounts/store.py +774 -0
- dayfile/web/admin.py +112 -0
- dayfile/web/app.py +1583 -0
- dayfile/web/client.py +123 -0
- dayfile/web/creds.py +45 -0
- dayfile/web/demo.py +64 -0
- dayfile/web/history.py +83 -0
- dayfile/web/oauth.py +378 -0
- dayfile/web/present.py +160 -0
- dayfile/web/static/fonts/fonts.NOTICE +195 -0
- dayfile/web/static/fonts/jetbrains-mono-variable-latin.woff2 +0 -0
- dayfile/web/static/fonts/source-sans-3-variable-latin.woff2 +0 -0
- dayfile/web/static/htmx.NOTICE +5 -0
- dayfile/web/static/htmx.min.js +1 -0
- dayfile/web/static/icons.NOTICE +9 -0
- dayfile/web/static/log.js +15 -0
- dayfile/web/static/settings.js +12 -0
- dayfile/web/static/site.css +369 -0
- dayfile/web/static/tokens.js +8 -0
- dayfile/web/templates/_diagram.html +36 -0
- dayfile/web/templates/_event.html +36 -0
- dayfile/web/templates/_feedtabs.html +1 -0
- dayfile/web/templates/_filters.html +13 -0
- dayfile/web/templates/_new.html +2 -0
- dayfile/web/templates/_post_form.html +10 -0
- dayfile/web/templates/account.html +17 -0
- dayfile/web/templates/base.html +33 -0
- dayfile/web/templates/deleted.html +7 -0
- dayfile/web/templates/demo.html +19 -0
- dayfile/web/templates/docs.html +174 -0
- dayfile/web/templates/error.html +7 -0
- dayfile/web/templates/feeds.html +42 -0
- dayfile/web/templates/heartbeats.html +29 -0
- dayfile/web/templates/index.html +109 -0
- dayfile/web/templates/log.html +48 -0
- dayfile/web/templates/login.html +20 -0
- dayfile/web/templates/oauth_consent.html +18 -0
- dayfile/web/templates/post.html +8 -0
- dayfile/web/templates/pricing.html +40 -0
- dayfile/web/templates/privacy.html +49 -0
- dayfile/web/templates/revoke.html +7 -0
- dayfile/web/templates/settings.html +100 -0
- dayfile/web/templates/signed_in.html +7 -0
- dayfile/web/templates/signup.html +15 -0
- dayfile/web/templates/status.html +45 -0
- dayfile/web/templates/terms.html +41 -0
- dayfile/web/templates/token_new.html +19 -0
- dayfile/web/templates/tokens.html +44 -0
- dayfile/web/uptimerobot.py +141 -0
- dayfile-0.1.0.dist-info/METADATA +160 -0
- dayfile-0.1.0.dist-info/RECORD +99 -0
- dayfile-0.1.0.dist-info/WHEEL +4 -0
- dayfile-0.1.0.dist-info/entry_points.txt +2 -0
- dayfile-0.1.0.dist-info/licenses/LICENSE +661 -0
dayfile/__init__.py
ADDED
|
@@ -0,0 +1 @@
|
|
|
1
|
+
"""dayfile: a personal, append-only event log exposed as feeds."""
|
dayfile/admin.py
ADDED
|
@@ -0,0 +1,467 @@
|
|
|
1
|
+
"""Admin API for a control plane (the web app): tenants and their tokens, under /internal/admin/.
|
|
2
|
+
|
|
3
|
+
Never routed by the proxy. Every call needs the shared secret read from a file; without the file
|
|
4
|
+
the routes do not exist. Token changes are recorded in the tenant's own log (tag dayfile-admin).
|
|
5
|
+
"""
|
|
6
|
+
|
|
7
|
+
import hmac
|
|
8
|
+
import json
|
|
9
|
+
import logging
|
|
10
|
+
from collections.abc import Callable
|
|
11
|
+
from pathlib import Path
|
|
12
|
+
from typing import Any
|
|
13
|
+
|
|
14
|
+
from fastapi import FastAPI, Request, Response
|
|
15
|
+
from fastapi.responses import JSONResponse
|
|
16
|
+
from starlette.concurrency import run_in_threadpool
|
|
17
|
+
|
|
18
|
+
from dayfile import db, feeds, heartbeats, timefmt
|
|
19
|
+
from dayfile.auth.tokens import LABEL, create_token, list_tokens, revoke_token
|
|
20
|
+
from dayfile.ingest.core import ingest_events
|
|
21
|
+
from dayfile.ratelimit import Window
|
|
22
|
+
from dayfile.tenancy import RESERVED, SLUG, DirectoryTenancy, TenancyError, Tenant
|
|
23
|
+
from dayfile.ulid import new_ulid
|
|
24
|
+
|
|
25
|
+
log = logging.getLogger("dayfile.admin")
|
|
26
|
+
PREFIX = "/internal/admin"
|
|
27
|
+
MAX_LIVE_TOKENS = 20
|
|
28
|
+
SHORT_LIVED = 3600 # tokens expiring this soon are session plumbing: uncapped and not logged
|
|
29
|
+
MIN_EXPIRY, MAX_EXPIRY = 60, 366 * 86400
|
|
30
|
+
NO_STORE = {"Cache-Control": "no-store"}
|
|
31
|
+
|
|
32
|
+
|
|
33
|
+
def read_secret(path: str | Path | None) -> str | None:
|
|
34
|
+
"""Return the shared secret from its file, or None if there is no usable file."""
|
|
35
|
+
if not path:
|
|
36
|
+
return None
|
|
37
|
+
try:
|
|
38
|
+
secret = Path(path).read_text().strip()
|
|
39
|
+
except OSError:
|
|
40
|
+
return None
|
|
41
|
+
return secret or None
|
|
42
|
+
|
|
43
|
+
|
|
44
|
+
def install(
|
|
45
|
+
app: FastAPI,
|
|
46
|
+
tenancy: DirectoryTenancy,
|
|
47
|
+
secret: str,
|
|
48
|
+
clock: Callable[[], str],
|
|
49
|
+
budget: Window,
|
|
50
|
+
limit: tuple[int, int],
|
|
51
|
+
) -> None:
|
|
52
|
+
"""Register the admin routes on `app`."""
|
|
53
|
+
|
|
54
|
+
def refuse(status: int, message: str) -> JSONResponse:
|
|
55
|
+
return JSONResponse({"error": message}, status_code=status, headers=NO_STORE)
|
|
56
|
+
|
|
57
|
+
def authorized(request: Request) -> bool:
|
|
58
|
+
header = request.headers.get("authorization", "")
|
|
59
|
+
scheme, _, value = header.partition(" ")
|
|
60
|
+
return scheme == "Bearer" and hmac.compare_digest(value.encode(), secret.encode())
|
|
61
|
+
|
|
62
|
+
def guard(request: Request, mutating: bool) -> JSONResponse | None:
|
|
63
|
+
if not authorized(request):
|
|
64
|
+
return JSONResponse(
|
|
65
|
+
{"error": "unauthorized"},
|
|
66
|
+
status_code=401,
|
|
67
|
+
headers={**NO_STORE, "WWW-Authenticate": 'Bearer realm="dayfile-admin"'},
|
|
68
|
+
)
|
|
69
|
+
if mutating and (wait := budget.charge("admin", 1, *limit)):
|
|
70
|
+
return JSONResponse(
|
|
71
|
+
{"error": "admin rate limit exceeded"},
|
|
72
|
+
status_code=429,
|
|
73
|
+
headers={**NO_STORE, "Retry-After": str(wait)},
|
|
74
|
+
)
|
|
75
|
+
return None
|
|
76
|
+
|
|
77
|
+
def known(slug: str) -> Tenant | None:
|
|
78
|
+
return tenancy.get(slug) if SLUG.fullmatch(slug) else None
|
|
79
|
+
|
|
80
|
+
async def body_of(request: Request) -> dict[str, Any] | None:
|
|
81
|
+
try:
|
|
82
|
+
body = json.loads(await request.body() or b"{}")
|
|
83
|
+
except ValueError:
|
|
84
|
+
return None
|
|
85
|
+
return body if isinstance(body, dict) else None
|
|
86
|
+
|
|
87
|
+
def describe(tenant: Tenant) -> dict[str, Any]:
|
|
88
|
+
usage = tenancy.usage(tenant.id)
|
|
89
|
+
return {
|
|
90
|
+
"slug": tenant.id,
|
|
91
|
+
"suspended": tenant.suspended,
|
|
92
|
+
"max_events": tenant.max_events,
|
|
93
|
+
"max_bytes": tenant.max_bytes,
|
|
94
|
+
"write_limit": list(tenant.write_limit) if tenant.write_limit else None,
|
|
95
|
+
**usage,
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
def log_event(tenant: Tenant, action: str, title: str, **payload: Any) -> None:
|
|
99
|
+
conn = db.connect(tenant.db_path)
|
|
100
|
+
try:
|
|
101
|
+
ingest_events(
|
|
102
|
+
conn,
|
|
103
|
+
[
|
|
104
|
+
{
|
|
105
|
+
"specversion": "dayfile/1",
|
|
106
|
+
"id": new_ulid(),
|
|
107
|
+
"source": {"id": "dayfile"},
|
|
108
|
+
"occurred_at": clock(),
|
|
109
|
+
"title": title,
|
|
110
|
+
"tags": ["dayfile-admin"],
|
|
111
|
+
"payload": {"action": action, **payload},
|
|
112
|
+
}
|
|
113
|
+
],
|
|
114
|
+
)
|
|
115
|
+
finally:
|
|
116
|
+
conn.close()
|
|
117
|
+
|
|
118
|
+
@app.put(PREFIX + "/tenants/{slug}")
|
|
119
|
+
async def put_tenant(request: Request, slug: str) -> Response:
|
|
120
|
+
if denied := guard(request, mutating=True):
|
|
121
|
+
return denied
|
|
122
|
+
body = await body_of(request)
|
|
123
|
+
if body is None:
|
|
124
|
+
return refuse(422, "body must be a JSON object")
|
|
125
|
+
existing = known(slug)
|
|
126
|
+
if existing:
|
|
127
|
+
return JSONResponse({**describe(existing), "created": False}, headers=NO_STORE)
|
|
128
|
+
if not SLUG.fullmatch(slug) or slug in RESERVED:
|
|
129
|
+
return refuse(422, "invalid tenant name")
|
|
130
|
+
limits = {k: body[k] for k in ("max_events", "max_bytes", "write_limit") if k in body}
|
|
131
|
+
if isinstance(limits.get("write_limit"), list):
|
|
132
|
+
limits["write_limit"] = tuple(limits["write_limit"])
|
|
133
|
+
try:
|
|
134
|
+
tenant = await run_in_threadpool(lambda: tenancy.create(slug, **limits))
|
|
135
|
+
except TenancyError as e:
|
|
136
|
+
return refuse(422, str(e))
|
|
137
|
+
out = await run_in_threadpool(describe, tenant)
|
|
138
|
+
return JSONResponse({**out, "created": True}, status_code=201, headers=NO_STORE)
|
|
139
|
+
|
|
140
|
+
@app.get(PREFIX + "/tenants/{slug}")
|
|
141
|
+
async def get_tenant(request: Request, slug: str) -> Response:
|
|
142
|
+
if denied := guard(request, mutating=False):
|
|
143
|
+
return denied
|
|
144
|
+
tenant = known(slug)
|
|
145
|
+
if tenant is None:
|
|
146
|
+
return refuse(404, "no such tenant")
|
|
147
|
+
return JSONResponse(await run_in_threadpool(describe, tenant), headers=NO_STORE)
|
|
148
|
+
|
|
149
|
+
@app.get(PREFIX + "/tenants/{slug}/export")
|
|
150
|
+
async def export_tenant(request: Request, slug: str) -> Response:
|
|
151
|
+
"""A gzip of a consistent, integrity-checked copy of the tenant's database."""
|
|
152
|
+
if denied := guard(request, mutating=False):
|
|
153
|
+
return denied
|
|
154
|
+
tenant = known(slug)
|
|
155
|
+
if tenant is None:
|
|
156
|
+
return refuse(404, "no such tenant")
|
|
157
|
+
|
|
158
|
+
def make() -> bytes:
|
|
159
|
+
import gzip
|
|
160
|
+
import tempfile
|
|
161
|
+
|
|
162
|
+
from dayfile.cli import copy_database
|
|
163
|
+
|
|
164
|
+
with tempfile.TemporaryDirectory() as scratch:
|
|
165
|
+
copy = Path(scratch) / "dayfile.db"
|
|
166
|
+
copy_database(tenant.db_path, copy)
|
|
167
|
+
return gzip.compress(copy.read_bytes(), compresslevel=6)
|
|
168
|
+
|
|
169
|
+
body = await run_in_threadpool(make)
|
|
170
|
+
log.info("export: tenant=%s bytes=%d", tenant.id, len(body))
|
|
171
|
+
return Response(body, media_type="application/gzip", headers=NO_STORE)
|
|
172
|
+
|
|
173
|
+
@app.delete(PREFIX + "/tenants/{slug}")
|
|
174
|
+
async def delete_tenant(request: Request, slug: str) -> Response:
|
|
175
|
+
if denied := guard(request, mutating=True):
|
|
176
|
+
return denied
|
|
177
|
+
if known(slug) is None:
|
|
178
|
+
return refuse(404, "no such tenant")
|
|
179
|
+
erase = request.query_params.get("erase") == "true"
|
|
180
|
+
await run_in_threadpool(tenancy.erase if erase else tenancy.delete, slug)
|
|
181
|
+
return Response(status_code=204, headers=NO_STORE)
|
|
182
|
+
|
|
183
|
+
@app.put(PREFIX + "/tenants/{slug}/feeds/{name}")
|
|
184
|
+
async def put_tenant_feed(request: Request, slug: str, name: str) -> Response:
|
|
185
|
+
if denied := guard(request, mutating=True):
|
|
186
|
+
return denied
|
|
187
|
+
tenant = known(slug)
|
|
188
|
+
if tenant is None:
|
|
189
|
+
return refuse(404, "no such tenant")
|
|
190
|
+
spec = await body_of(request)
|
|
191
|
+
if spec is None or set(spec) - {"title", "filter", "visibility"}:
|
|
192
|
+
return refuse(422, "body takes title, filter and visibility")
|
|
193
|
+
if "filter" in spec and not isinstance(spec["filter"], dict):
|
|
194
|
+
return refuse(422, 'filter must be an object like {"tag": ["work"]}')
|
|
195
|
+
|
|
196
|
+
def save() -> tuple[dict[str, Any], str | None]:
|
|
197
|
+
conn = db.connect(tenant.db_path)
|
|
198
|
+
try:
|
|
199
|
+
before = (feeds.get_feed(conn, name) or {}).get("visibility")
|
|
200
|
+
saved = feeds.save_feed(
|
|
201
|
+
conn,
|
|
202
|
+
name,
|
|
203
|
+
clock(),
|
|
204
|
+
title=spec.get("title"),
|
|
205
|
+
filter=spec.get("filter"),
|
|
206
|
+
visibility=spec.get("visibility"),
|
|
207
|
+
)
|
|
208
|
+
return saved, before
|
|
209
|
+
finally:
|
|
210
|
+
conn.close()
|
|
211
|
+
|
|
212
|
+
try:
|
|
213
|
+
saved, before = await run_in_threadpool(save)
|
|
214
|
+
except feeds.FeedError as e:
|
|
215
|
+
return refuse(422, str(e))
|
|
216
|
+
if saved["visibility"] != (before or "private"):
|
|
217
|
+
verb = "published" if saved["visibility"] == "public" else "made private"
|
|
218
|
+
await run_in_threadpool(
|
|
219
|
+
log_event, tenant, f"feed.{saved['visibility']}", f"Feed {name} {verb}", feed=name
|
|
220
|
+
)
|
|
221
|
+
return JSONResponse(saved, headers=NO_STORE)
|
|
222
|
+
|
|
223
|
+
@app.get(PREFIX + "/tenants/{slug}/feeds")
|
|
224
|
+
async def get_tenant_feeds(request: Request, slug: str) -> Response:
|
|
225
|
+
if denied := guard(request, mutating=False):
|
|
226
|
+
return denied
|
|
227
|
+
tenant = known(slug)
|
|
228
|
+
if tenant is None:
|
|
229
|
+
return refuse(404, "no such tenant")
|
|
230
|
+
|
|
231
|
+
def rows() -> list[dict[str, Any]]:
|
|
232
|
+
conn = db.connect(tenant.db_path)
|
|
233
|
+
try:
|
|
234
|
+
saved = {f["name"]: f for f in feeds.list_feeds(conn)}
|
|
235
|
+
return [saved.get(feeds.DEFAULT) or feeds.get_feed(conn, feeds.DEFAULT)] + [
|
|
236
|
+
f for n, f in saved.items() if n != feeds.DEFAULT
|
|
237
|
+
]
|
|
238
|
+
finally:
|
|
239
|
+
conn.close()
|
|
240
|
+
|
|
241
|
+
return JSONResponse(await run_in_threadpool(rows), headers=NO_STORE)
|
|
242
|
+
|
|
243
|
+
@app.delete(PREFIX + "/tenants/{slug}/feeds/{name}")
|
|
244
|
+
async def delete_tenant_feed(request: Request, slug: str, name: str) -> Response:
|
|
245
|
+
if denied := guard(request, mutating=True):
|
|
246
|
+
return denied
|
|
247
|
+
tenant = known(slug)
|
|
248
|
+
if tenant is None:
|
|
249
|
+
return refuse(404, "no such tenant")
|
|
250
|
+
|
|
251
|
+
def remove() -> None:
|
|
252
|
+
conn = db.connect(tenant.db_path)
|
|
253
|
+
try:
|
|
254
|
+
feeds.delete_feed(conn, name)
|
|
255
|
+
finally:
|
|
256
|
+
conn.close()
|
|
257
|
+
|
|
258
|
+
try:
|
|
259
|
+
await run_in_threadpool(remove)
|
|
260
|
+
except feeds.FeedError as e:
|
|
261
|
+
return refuse(422, str(e))
|
|
262
|
+
return Response(status_code=204, headers=NO_STORE)
|
|
263
|
+
|
|
264
|
+
@app.get(PREFIX + "/tenants/{slug}/heartbeats")
|
|
265
|
+
async def get_tenant_heartbeats(request: Request, slug: str) -> Response:
|
|
266
|
+
if denied := guard(request, mutating=False):
|
|
267
|
+
return denied
|
|
268
|
+
tenant = known(slug)
|
|
269
|
+
if tenant is None:
|
|
270
|
+
return refuse(404, "no such tenant")
|
|
271
|
+
|
|
272
|
+
def rows() -> list[dict[str, Any]]:
|
|
273
|
+
conn = db.connect(tenant.db_path)
|
|
274
|
+
try:
|
|
275
|
+
return heartbeats.list_heartbeats(conn)
|
|
276
|
+
finally:
|
|
277
|
+
conn.close()
|
|
278
|
+
|
|
279
|
+
return JSONResponse(await run_in_threadpool(rows), headers=NO_STORE)
|
|
280
|
+
|
|
281
|
+
@app.put(PREFIX + "/tenants/{slug}/heartbeats/{name}")
|
|
282
|
+
async def put_tenant_heartbeat(request: Request, slug: str, name: str) -> Response:
|
|
283
|
+
if denied := guard(request, mutating=True):
|
|
284
|
+
return denied
|
|
285
|
+
tenant = known(slug)
|
|
286
|
+
if tenant is None:
|
|
287
|
+
return refuse(404, "no such tenant")
|
|
288
|
+
spec = await body_of(request)
|
|
289
|
+
if spec is None or set(spec) - {"every", "source", "tag"}:
|
|
290
|
+
return refuse(422, "body takes every, and one of source or tag")
|
|
291
|
+
|
|
292
|
+
def save() -> dict[str, Any]:
|
|
293
|
+
conn = db.connect(tenant.db_path)
|
|
294
|
+
try:
|
|
295
|
+
return heartbeats.save_heartbeat(
|
|
296
|
+
conn, name, clock(), spec.get("every"), spec.get("source"), spec.get("tag")
|
|
297
|
+
)
|
|
298
|
+
finally:
|
|
299
|
+
conn.close()
|
|
300
|
+
|
|
301
|
+
try:
|
|
302
|
+
saved = await run_in_threadpool(save)
|
|
303
|
+
except heartbeats.HeartbeatError as e:
|
|
304
|
+
return refuse(422, str(e))
|
|
305
|
+
return JSONResponse(saved, headers=NO_STORE)
|
|
306
|
+
|
|
307
|
+
@app.delete(PREFIX + "/tenants/{slug}/heartbeats/{name}")
|
|
308
|
+
async def delete_tenant_heartbeat(request: Request, slug: str, name: str) -> Response:
|
|
309
|
+
if denied := guard(request, mutating=True):
|
|
310
|
+
return denied
|
|
311
|
+
tenant = known(slug)
|
|
312
|
+
if tenant is None:
|
|
313
|
+
return refuse(404, "no such tenant")
|
|
314
|
+
|
|
315
|
+
def remove() -> None:
|
|
316
|
+
conn = db.connect(tenant.db_path)
|
|
317
|
+
try:
|
|
318
|
+
heartbeats.delete_heartbeat(conn, name, clock())
|
|
319
|
+
finally:
|
|
320
|
+
conn.close()
|
|
321
|
+
|
|
322
|
+
await run_in_threadpool(remove)
|
|
323
|
+
return Response(status_code=204, headers=NO_STORE)
|
|
324
|
+
|
|
325
|
+
@app.post(PREFIX + "/tenants/{slug}/rename")
|
|
326
|
+
async def rename_tenant(request: Request, slug: str) -> Response:
|
|
327
|
+
if denied := guard(request, mutating=True):
|
|
328
|
+
return denied
|
|
329
|
+
tenant = known(slug)
|
|
330
|
+
if tenant is None:
|
|
331
|
+
return refuse(404, "no such tenant")
|
|
332
|
+
spec = await body_of(request)
|
|
333
|
+
new = spec.get("to") if spec else None
|
|
334
|
+
if not isinstance(new, str) or not SLUG.fullmatch(new) or new in RESERVED:
|
|
335
|
+
return refuse(422, "to must be a valid, unreserved tenant name")
|
|
336
|
+
if known(new) is not None or (tenancy.root / new).exists():
|
|
337
|
+
return refuse(409, "that name is taken")
|
|
338
|
+
try:
|
|
339
|
+
moved = await run_in_threadpool(tenancy.rename, slug, new)
|
|
340
|
+
except TenancyError as e:
|
|
341
|
+
return refuse(409, str(e))
|
|
342
|
+
await run_in_threadpool(
|
|
343
|
+
log_event, moved, "tenant.rename", f"Username changed from {slug} to {new}", old=slug
|
|
344
|
+
)
|
|
345
|
+
return JSONResponse({"slug": new}, headers=NO_STORE)
|
|
346
|
+
|
|
347
|
+
def lifecycle_route(action: str) -> None:
|
|
348
|
+
@app.post(PREFIX + "/tenants/{slug}/" + action)
|
|
349
|
+
async def lifecycle(request: Request, slug: str) -> Response:
|
|
350
|
+
if denied := guard(request, mutating=True):
|
|
351
|
+
return denied
|
|
352
|
+
if known(slug) is None:
|
|
353
|
+
return refuse(404, "no such tenant")
|
|
354
|
+
await run_in_threadpool(lambda: tenancy.update(slug, suspended=action == "suspend"))
|
|
355
|
+
return Response(status_code=204, headers=NO_STORE)
|
|
356
|
+
|
|
357
|
+
for name in ("suspend", "resume"):
|
|
358
|
+
lifecycle_route(name)
|
|
359
|
+
|
|
360
|
+
def mint(tenant: Tenant, spec: dict[str, Any]) -> tuple[int, dict[str, Any]]:
|
|
361
|
+
kind, labels = spec.get("kind"), spec.get("labels", ["self"])
|
|
362
|
+
expires_in, note = spec.get("expires_in"), spec.get("note")
|
|
363
|
+
source = spec.get("write_source")
|
|
364
|
+
if kind not in ("read", "write"):
|
|
365
|
+
return 422, {"error": "kind must be read or write"}
|
|
366
|
+
if (
|
|
367
|
+
not isinstance(labels, list)
|
|
368
|
+
or not labels
|
|
369
|
+
or not all(isinstance(x, str) and LABEL.match(x) for x in labels)
|
|
370
|
+
):
|
|
371
|
+
return 422, {"error": "labels must be names like self or family"}
|
|
372
|
+
if kind == "write" and not (isinstance(source, str) and source.strip()):
|
|
373
|
+
return 422, {"error": "a write token needs a write_source"}
|
|
374
|
+
if expires_in is not None and not (
|
|
375
|
+
isinstance(expires_in, int)
|
|
376
|
+
and not isinstance(expires_in, bool)
|
|
377
|
+
and MIN_EXPIRY <= expires_in <= MAX_EXPIRY
|
|
378
|
+
):
|
|
379
|
+
return 422, {"error": "expires_in must be 60 to 31622400 seconds"}
|
|
380
|
+
if note is not None and not (isinstance(note, str) and len(note) <= 80):
|
|
381
|
+
return 422, {"error": "note must be text of at most 80 characters"}
|
|
382
|
+
short = expires_in is not None and expires_in <= SHORT_LIVED
|
|
383
|
+
conn = db.connect(tenant.db_path)
|
|
384
|
+
try:
|
|
385
|
+
now = clock()
|
|
386
|
+
if not short and _live_tokens(conn, now) >= MAX_LIVE_TOKENS:
|
|
387
|
+
return 409, {"error": f"at most {MAX_LIVE_TOKENS} live tokens"}
|
|
388
|
+
issued = create_token(
|
|
389
|
+
conn,
|
|
390
|
+
labels,
|
|
391
|
+
expires_at=timefmt.plus(now, expires_in) if expires_in else None,
|
|
392
|
+
note=note,
|
|
393
|
+
now=now,
|
|
394
|
+
write_sources=[source] if kind == "write" else None,
|
|
395
|
+
)
|
|
396
|
+
finally:
|
|
397
|
+
conn.close()
|
|
398
|
+
log.info("token created: tenant=%s id=%s kind=%s", tenant.id, issued.id, kind)
|
|
399
|
+
if not short:
|
|
400
|
+
log_event(
|
|
401
|
+
tenant, "token.create", f"Token {issued.id} created ({kind})", token=issued.id
|
|
402
|
+
)
|
|
403
|
+
return 201, {"id": issued.id, "token": issued.value, "kind": kind}
|
|
404
|
+
|
|
405
|
+
@app.post(PREFIX + "/tenants/{slug}/tokens")
|
|
406
|
+
async def create_tenant_token(request: Request, slug: str) -> Response:
|
|
407
|
+
if denied := guard(request, mutating=True):
|
|
408
|
+
return denied
|
|
409
|
+
tenant = known(slug)
|
|
410
|
+
if tenant is None:
|
|
411
|
+
return refuse(404, "no such tenant")
|
|
412
|
+
spec = await body_of(request)
|
|
413
|
+
if spec is None:
|
|
414
|
+
return refuse(422, "body must be a JSON object")
|
|
415
|
+
status, out = await run_in_threadpool(mint, tenant, spec)
|
|
416
|
+
return JSONResponse(out, status_code=status, headers=NO_STORE)
|
|
417
|
+
|
|
418
|
+
@app.get(PREFIX + "/tenants/{slug}/tokens")
|
|
419
|
+
async def get_tenant_tokens(request: Request, slug: str) -> Response:
|
|
420
|
+
if denied := guard(request, mutating=False):
|
|
421
|
+
return denied
|
|
422
|
+
tenant = known(slug)
|
|
423
|
+
if tenant is None:
|
|
424
|
+
return refuse(404, "no such tenant")
|
|
425
|
+
|
|
426
|
+
def rows() -> list[dict[str, Any]]:
|
|
427
|
+
conn = db.connect(tenant.db_path)
|
|
428
|
+
try:
|
|
429
|
+
return [
|
|
430
|
+
{**t, "kind": "write" if t["write_sources"] else "read"}
|
|
431
|
+
for t in list_tokens(conn)
|
|
432
|
+
]
|
|
433
|
+
finally:
|
|
434
|
+
conn.close()
|
|
435
|
+
|
|
436
|
+
return JSONResponse(await run_in_threadpool(rows), headers=NO_STORE)
|
|
437
|
+
|
|
438
|
+
@app.delete(PREFIX + "/tenants/{slug}/tokens/{token_id}")
|
|
439
|
+
async def revoke_tenant_token(request: Request, slug: str, token_id: str) -> Response:
|
|
440
|
+
if denied := guard(request, mutating=True):
|
|
441
|
+
return denied
|
|
442
|
+
tenant = known(slug)
|
|
443
|
+
if tenant is None:
|
|
444
|
+
return refuse(404, "no such tenant")
|
|
445
|
+
|
|
446
|
+
def revoke() -> bool:
|
|
447
|
+
conn = db.connect(tenant.db_path)
|
|
448
|
+
try:
|
|
449
|
+
return revoke_token(conn, token_id, clock())
|
|
450
|
+
finally:
|
|
451
|
+
conn.close()
|
|
452
|
+
|
|
453
|
+
if await run_in_threadpool(revoke):
|
|
454
|
+
log.info("token revoked: tenant=%s id=%s", tenant.id, token_id)
|
|
455
|
+
await run_in_threadpool(
|
|
456
|
+
log_event, tenant, "token.revoke", f"Token {token_id} revoked", token=token_id
|
|
457
|
+
)
|
|
458
|
+
return Response(status_code=204, headers=NO_STORE)
|
|
459
|
+
|
|
460
|
+
|
|
461
|
+
def _live_tokens(conn: Any, now: str) -> int:
|
|
462
|
+
"""Count tokens that are neither revoked nor expired and last longer than a session."""
|
|
463
|
+
return conn.execute(
|
|
464
|
+
"SELECT count(*) FROM tokens WHERE revoked_at IS NULL"
|
|
465
|
+
" AND (expires_at IS NULL OR (expires_at > ? AND expires_at > ?))",
|
|
466
|
+
(now, timefmt.plus(now, SHORT_LIVED)),
|
|
467
|
+
).fetchone()[0]
|