Compare commits
4
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
e68f7407f3 | ||
|
|
1b768d558d | ||
|
|
ad436f786c | ||
|
|
16c40864bb |
@@ -134,7 +134,8 @@ jobs:
|
||||
docker images "$IMAGE_PREFIX-$svc" --format '{{.Repository}}:{{.Tag}}' | xargs -r docker rmi >/dev/null 2>&1 || true
|
||||
done
|
||||
docker image prune -f >/dev/null
|
||||
docker builder prune -af --filter until=72h >/dev/null || true
|
||||
# A size cap, not an age: a busy day builds tens of gigabytes.
|
||||
docker builder prune -af --max-used-space 10GB >/dev/null || true
|
||||
|
||||
deploy:
|
||||
needs: build
|
||||
|
||||
Generated
+2
@@ -1862,7 +1862,9 @@ name = "service-kit"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"http",
|
||||
"tokio",
|
||||
"tower-http",
|
||||
"tracing",
|
||||
"tracing-appender",
|
||||
"tracing-subscriber",
|
||||
|
||||
@@ -12,3 +12,5 @@ tokio.workspace = true
|
||||
tracing.workspace = true
|
||||
tracing-subscriber.workspace = true
|
||||
tracing-appender.workspace = true
|
||||
tower-http.workspace = true
|
||||
http = "1"
|
||||
|
||||
+218
-26
@@ -3,9 +3,10 @@
|
||||
//! Environment:
|
||||
//! * `BIND_ADDR` listen address (each service has its own default)
|
||||
//! * `LOG_FORMAT` `text` (default) or `json`; `RUST_LOG` sets the level
|
||||
//! * `LOG_DIR` also write the log there, as JSON, one file a day
|
||||
//! (`<LOG_NAME>.YYYY-MM-DD.log`), keeping `LOG_KEEP_DAYS` (default 30) files
|
||||
//! * `LOG_NAME` the file name prefix (default: the service's name)
|
||||
//! * `LOG_DIR` also write the log there, as JSON, one file a UTC day
|
||||
//! (`<LOG_NAME>/<LOG_NAME>.YYYY-MM-DD.log`), keeping `LOG_KEEP_DAYS`
|
||||
//! (default 30) files of at most `LOG_MAX_DAY_MB` (default 50) each
|
||||
//! * `LOG_NAME` the folder and file name (default: the service's name)
|
||||
|
||||
use std::net::SocketAddr;
|
||||
use std::time::Duration;
|
||||
@@ -14,41 +15,201 @@ use anyhow::Context;
|
||||
|
||||
/// Days of log files kept in `LOG_DIR` by default.
|
||||
const LOG_KEEP_DAYS: usize = 30;
|
||||
/// At most this many megabytes of log a day per service by default.
|
||||
const LOG_MAX_DAY_MB: u64 = 50;
|
||||
|
||||
/// Initializes `tracing` from `RUST_LOG` and `LOG_FORMAT`, and the log files
|
||||
/// in `LOG_DIR` (named after `LOG_NAME`, else `name`), so the log outlives the
|
||||
/// container.
|
||||
pub fn init_logging(name: &str) {
|
||||
/// Keeps the background log writer alive: hold it until `main` returns, so
|
||||
/// the last lines reach the file.
|
||||
#[must_use = "the log files stop being written when this is dropped"]
|
||||
pub struct LogGuard(#[allow(dead_code)] Option<tracing_appender::non_blocking::WorkerGuard>);
|
||||
|
||||
/// Logging for a one-off command: the console only, never the log files.
|
||||
pub fn init_console_logging() {
|
||||
use tracing_subscriber::layer::SubscriberExt;
|
||||
use tracing_subscriber::util::SubscriberInitExt;
|
||||
use tracing_subscriber::{EnvFilter, Layer, fmt};
|
||||
tracing_subscriber::registry().with(env_filter()).with(console_layer()).init();
|
||||
}
|
||||
|
||||
let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info,tower_http=info"));
|
||||
let json = std::env::var("LOG_FORMAT").is_ok_and(|f| f.eq_ignore_ascii_case("json"));
|
||||
let stdout = if json { fmt::layer().json().boxed() } else { fmt::layer().boxed() };
|
||||
let mut problem = None;
|
||||
fn env_filter() -> tracing_subscriber::EnvFilter {
|
||||
tracing_subscriber::EnvFilter::try_from_default_env()
|
||||
.unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info,tower_http=info"))
|
||||
}
|
||||
|
||||
fn console_layer<S>() -> Box<dyn tracing_subscriber::Layer<S> + Send + Sync>
|
||||
where
|
||||
S: tracing::Subscriber + for<'a> tracing_subscriber::registry::LookupSpan<'a>,
|
||||
{
|
||||
use tracing_subscriber::{Layer, fmt};
|
||||
if std::env::var("LOG_FORMAT").is_ok_and(|f| f.eq_ignore_ascii_case("json")) {
|
||||
fmt::layer().json().boxed()
|
||||
} else {
|
||||
fmt::layer().boxed()
|
||||
}
|
||||
}
|
||||
|
||||
/// A whole number from the environment; a value that is not one is reported.
|
||||
fn env_number<T: std::str::FromStr>(name: &str, default: T, problems: &mut Vec<String>) -> T {
|
||||
match std::env::var(name) {
|
||||
Ok(raw) if !raw.trim().is_empty() => raw.trim().parse().unwrap_or_else(|_| {
|
||||
problems.push(format!("{name}={raw} is not a whole number; using the default"));
|
||||
default
|
||||
}),
|
||||
_ => default,
|
||||
}
|
||||
}
|
||||
|
||||
/// Initializes `tracing` from `RUST_LOG` and `LOG_FORMAT`, and the log files
|
||||
/// in `LOG_DIR`, so the log outlives the container: each service writes its
|
||||
/// own folder `LOG_DIR/<name>/` (`<name>` = `LOG_NAME`, else `name`), one
|
||||
/// file a UTC day, keeping `LOG_KEEP_DAYS` files (at least 2), at most
|
||||
/// `LOG_MAX_DAY_MB` megabytes a day.
|
||||
pub fn init_logging(name: &str) -> LogGuard {
|
||||
use tracing_subscriber::layer::SubscriberExt;
|
||||
use tracing_subscriber::util::SubscriberInitExt;
|
||||
use tracing_subscriber::{Layer, fmt};
|
||||
|
||||
let mut problems = Vec::new();
|
||||
let mut guard = None;
|
||||
let file = std::env::var("LOG_DIR").ok().filter(|d| !d.trim().is_empty()).and_then(|dir| {
|
||||
let prefix =
|
||||
std::env::var("LOG_NAME").ok().filter(|n| !n.trim().is_empty()).unwrap_or_else(|| name.to_string());
|
||||
let keep = std::env::var("LOG_KEEP_DAYS").ok().and_then(|d| d.parse().ok()).unwrap_or(LOG_KEEP_DAYS);
|
||||
let appender = tracing_appender::rolling::Builder::new()
|
||||
.rotation(tracing_appender::rolling::Rotation::DAILY)
|
||||
.filename_prefix(prefix)
|
||||
.filename_suffix("log")
|
||||
.max_log_files(keep.max(1))
|
||||
.build(&dir);
|
||||
let name = std::env::var("LOG_NAME").ok().filter(|n| !n.trim().is_empty()).unwrap_or_else(|| name.to_string());
|
||||
let keep: usize = env_number("LOG_KEEP_DAYS", LOG_KEEP_DAYS, &mut problems);
|
||||
if keep < 2 {
|
||||
problems.push(format!("LOG_KEEP_DAYS={keep} would delete today's file on a restart; keeping 2 days"));
|
||||
}
|
||||
let max_mb: u64 = env_number("LOG_MAX_DAY_MB", LOG_MAX_DAY_MB, &mut problems);
|
||||
// Its own folder: the old-file cleanup takes every file whose name
|
||||
// starts with the prefix ("worker" would take "worker-ai" files too).
|
||||
let folder = std::path::Path::new(&dir).join(&name);
|
||||
let appender = std::fs::create_dir_all(&folder).map_err(|e| e.to_string()).and_then(|()| {
|
||||
tracing_appender::rolling::Builder::new()
|
||||
.rotation(tracing_appender::rolling::Rotation::DAILY)
|
||||
.filename_prefix(&name)
|
||||
.filename_suffix("log")
|
||||
.max_log_files(keep.max(2))
|
||||
.build(&folder)
|
||||
.map_err(|e| e.to_string())
|
||||
});
|
||||
match appender {
|
||||
Ok(appender) => Some(fmt::layer().json().with_ansi(false).with_writer(appender).boxed()),
|
||||
Ok(appender) => {
|
||||
let (writer, g) = tracing_appender::non_blocking(DailyCap::new(appender, max_mb.max(1) * 1024 * 1024));
|
||||
guard = Some(g);
|
||||
Some(fmt::layer().json().with_ansi(false).with_writer(writer).boxed())
|
||||
}
|
||||
Err(e) => {
|
||||
problem = Some(format!("cannot write the log files in {dir}: {e}"));
|
||||
problems
|
||||
.push(format!("cannot write the log files in {}: {e}; logging to stdout only", folder.display()));
|
||||
None
|
||||
}
|
||||
}
|
||||
});
|
||||
tracing_subscriber::registry().with(filter).with(stdout).with(file).init();
|
||||
if let Some(problem) = problem {
|
||||
tracing::warn!("{problem}; logging to stdout only");
|
||||
tracing_subscriber::registry().with(env_filter()).with(console_layer()).with(file).init();
|
||||
for problem in problems {
|
||||
tracing::warn!("{problem}");
|
||||
}
|
||||
LogGuard(guard)
|
||||
}
|
||||
|
||||
/// A daily size limit in front of the log file: past `limit` bytes in a UTC
|
||||
/// day the rest of that day's lines are dropped (after one note saying so),
|
||||
/// so a log storm cannot fill the disk.
|
||||
struct DailyCap<W> {
|
||||
inner: W,
|
||||
limit: u64,
|
||||
day: u64,
|
||||
written: u64,
|
||||
}
|
||||
|
||||
impl<W> DailyCap<W> {
|
||||
fn new(inner: W, limit: u64) -> Self {
|
||||
Self { inner, limit, day: utc_day(), written: 0 }
|
||||
}
|
||||
}
|
||||
|
||||
fn utc_day() -> u64 {
|
||||
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map_or(0, |d| d.as_secs() / 86_400)
|
||||
}
|
||||
|
||||
impl<W: std::io::Write> std::io::Write for DailyCap<W> {
|
||||
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
|
||||
let today = utc_day();
|
||||
if today != self.day {
|
||||
self.day = today;
|
||||
self.written = 0;
|
||||
}
|
||||
if self.written >= self.limit {
|
||||
return Ok(buf.len());
|
||||
}
|
||||
self.written += buf.len() as u64;
|
||||
if self.written >= self.limit {
|
||||
let note = format!(
|
||||
"{{\"level\":\"WARN\",\"fields\":{{\"message\":\"daily log limit of {} MB reached; the rest of today is only on stdout\"}}}}\n",
|
||||
self.limit / 1024 / 1024
|
||||
);
|
||||
self.inner.write_all(buf)?;
|
||||
self.inner.write_all(note.as_bytes())?;
|
||||
return Ok(buf.len());
|
||||
}
|
||||
self.inner.write(buf)
|
||||
}
|
||||
|
||||
fn flush(&mut self) -> std::io::Result<()> {
|
||||
self.inner.flush()
|
||||
}
|
||||
}
|
||||
|
||||
/// The request log of an HTTP service (`TraceLayer::make_span_with` and
|
||||
/// `on_response`): the Docker health check stays out of it unless it fails,
|
||||
/// and e-mail addresses and tokens in the path are masked (the log is kept).
|
||||
#[derive(Debug, Clone, Copy, Default)]
|
||||
pub struct RequestLog;
|
||||
|
||||
impl<B> tower_http::trace::MakeSpan<B> for RequestLog {
|
||||
fn make_span(&mut self, request: &http::Request<B>) -> tracing::Span {
|
||||
let path = request.uri().path();
|
||||
if path == "/healthz" {
|
||||
return tracing::Span::none();
|
||||
}
|
||||
tracing::info_span!("request", method = %request.method(), path = %masked_path(path))
|
||||
}
|
||||
}
|
||||
|
||||
impl<B> tower_http::trace::OnResponse<B> for RequestLog {
|
||||
fn on_response(self, response: &http::Response<B>, latency: Duration, span: &tracing::Span) {
|
||||
// A health check (no span) that went well is not logged.
|
||||
if span.is_none() && response.status().is_success() {
|
||||
return;
|
||||
}
|
||||
let ms = latency.as_millis() as u64;
|
||||
let status = response.status().as_u16();
|
||||
if span.is_none() {
|
||||
tracing::warn!(path = "/healthz", status, latency_ms = ms, "health check failed");
|
||||
} else {
|
||||
tracing::info!(status, latency_ms = ms, "finished processing request");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The path with secrets masked: a segment holding an e-mail address, and a
|
||||
/// long one that is not a UUID (share slugs, invitation tokens). Queries are
|
||||
/// never logged.
|
||||
pub fn masked_path(path: &str) -> String {
|
||||
let uuid = |s: &str| {
|
||||
s.len() == 36
|
||||
&& s.char_indices()
|
||||
.all(|(i, c)| if [8, 13, 18, 23].contains(&i) { c == '-' } else { c.is_ascii_hexdigit() })
|
||||
};
|
||||
path.split('/')
|
||||
.map(|segment| {
|
||||
if segment.contains('@') || segment.contains("%40") {
|
||||
":email"
|
||||
} else if segment.len() >= 12 && !uuid(segment) {
|
||||
":token"
|
||||
} else {
|
||||
segment
|
||||
}
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.join("/")
|
||||
}
|
||||
|
||||
/// Listen address from `BIND_ADDR`, or `default`.
|
||||
@@ -92,3 +253,34 @@ pub async fn shutdown_signal() {
|
||||
}
|
||||
tracing::info!("shutting down");
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::io::Write;
|
||||
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn secrets_in_paths_are_masked() {
|
||||
assert_eq!(masked_path("/v1/admin/waitlist/anna%40example.com"), "/v1/admin/waitlist/:email");
|
||||
assert_eq!(masked_path("/v1/public/shares/Ab3dEf6hIj9kLm2n/visit"), "/v1/public/shares/:token/visit");
|
||||
assert_eq!(masked_path("/v1/public/invites/k3jh4k5j6h7k8j9h0k1j2h3k"), "/v1/public/invites/:token");
|
||||
let id = "01a1f960-96cb-765f-899a-4d76b45b236e";
|
||||
assert_eq!(masked_path(&format!("/v1/tarot/readings/{id}")), format!("/v1/tarot/readings/{id}"));
|
||||
assert_eq!(masked_path("/v1/admin/prompts/forecast/hu"), "/v1/admin/prompts/forecast/hu");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_daily_cap_drops_the_rest_of_the_day() {
|
||||
let mut cap = DailyCap::new(Vec::new(), 10);
|
||||
cap.write_all(b"12345\n").unwrap();
|
||||
cap.write_all(b"67890\n").unwrap();
|
||||
cap.write_all(b"dropped\n").unwrap();
|
||||
let text = String::from_utf8(cap.inner.clone()).unwrap();
|
||||
assert!(text.starts_with("12345\n67890\n") && text.contains("daily log limit") && !text.contains("dropped"));
|
||||
// A new day starts again.
|
||||
cap.day -= 1;
|
||||
cap.write_all(b"next\n").unwrap();
|
||||
assert!(String::from_utf8(cap.inner).unwrap().ends_with("next\n"));
|
||||
}
|
||||
}
|
||||
|
||||
+2
-1
@@ -83,7 +83,8 @@ A Google OAuth kliensnél a `https://sorsfonalak.hu` címet fel kell venni az en
|
||||
## Üzemeltetés
|
||||
|
||||
- Naplók élőben: `docker compose logs -f backend worker worker-ai` (ez a konténer újraindításáig/cseréjéig él).
|
||||
- Naplók utólag: a backend és a két worker JSON-sorokat ír a `logs` volume-ba is, naponta új fájlba (`backend.2026-11-20.log`, `worker…`, `worker-ai…`), 30 napig megőrizve (`LOG_DIR`, `LOG_KEEP_DAYS`, `LOG_NAME`). A fájlok helye a szerveren: `docker volume inspect -f '{{.Mountpoint}}' sorsfonalak_logs`, például `grep -h '"level":"ERROR"' /var/lib/docker/volumes/sorsfonalak_logs/_data/backend.*.log | tail`. A Docker 30 másodpercenkénti `/healthz` ellenőrzése nem kerül a naplóba.
|
||||
- Naplók utólag: a backend és a két worker JSON-sorokat ír a `logs` volume-ba is, szolgáltatásonként külön mappába, UTC-nap szerint új fájlba (`backend/backend.2026-11-20.log`, `worker/…`, `worker-ai/…`; a nap magyar idő szerint hajnali 1-2 órakor fordul). 30 napig maradnak meg, naponta legfeljebb 50 MB (`LOG_KEEP_DAYS`, `LOG_MAX_DAY_MB`, `LOG_DIR`, `LOG_NAME`); a kérések útvonalában az e-mail-címek és a tokenek maszkolva vannak. A fájlok helye: `docker volume inspect -f '{{.Mountpoint}}' sorsfonalak_logs`, például `grep -h '"level":"ERROR"' /var/lib/docker/volumes/sorsfonalak_logs/_data/backend/*.log | tail`. A Docker 30 másodpercenkénti `/healthz` ellenőrzése csak akkor kerül a naplóba, ha hibás.
|
||||
- Deploy és futó feladatok: leállításkor a worker nem vesz fel újat, a futókat befejezi (`SHUTDOWN_DRAIN_SECS`: `worker` 40 s, `worker-ai` 270 s, `stop_grace_period` 1, illetve 5 perc); ami addig nem készül el, visszakerül a sorba, a próbálkozás nem számít. Ha éppen elemzés készül, a deploy ennyivel tovább tarthat.
|
||||
- A worker két konténerben fut, ugyanabból az image-ből: a `worker` küldi az e-maileket és takarít (`WORKER_TASKS=email,cleanup`, ide kerülnek a további háttérfeladatok is), a `worker-ai` írja az elemzéseket és a válaszokat (`WORKER_TASKS=analyses`, gyors és lassú sáv). A sávok mérete a szerver `.env` fájljában állítható (`QUICK_CONCURRENCY`, `ANALYSIS_CONCURRENCY`).
|
||||
- Visszaállás korábbi verzióra: `.env`-ben `TAG=<régebbi hash>`, utána `docker compose up -d`
|
||||
- Mentés: naponta egy `pg_dump` a `/opt/sorsfonalak/backups` mappába, 14 napig megmarad. A mentéseket érdemes a szerverről is elvinni (DigitalOcean backup, vagy `rsync` otthonra).
|
||||
|
||||
@@ -81,6 +81,8 @@ services:
|
||||
HOROSCOPE_API_URL: http://horoscope-api:8080
|
||||
PUBLIC_BASE_URL: https://${DOMAIN}
|
||||
GOOGLE_CLIENT_IDS: ${GOOGLE_CLIENT_IDS:-}
|
||||
# Sign in with Apple: the Services ID (e.g. hu.sorsfonalak.web); empty: off.
|
||||
APPLE_CLIENT_IDS: ${APPLE_CLIENT_IDS:-}
|
||||
BOOTSTRAP_ADMIN_EMAILS: ${BOOTSTRAP_ADMIN_EMAILS:-}
|
||||
ANALYSIS_MODEL: ${ANALYSIS_MODEL:-}
|
||||
SUMMARY_MODEL: ${SUMMARY_MODEL:-}
|
||||
@@ -131,9 +133,11 @@ services:
|
||||
# SMTP_URL or the SES credentials come from .env.secrets (docs/levelkuldes.md);
|
||||
# listing them here with an empty default would override that file.
|
||||
SES_REGION: ${SES_REGION:-eu-central-1}
|
||||
MAIL_FROM: ${MAIL_FROM:-Sorsfonalak <hello@sorsfonalak.hu>}
|
||||
MAIL_FROM: ${MAIL_FROM:-Sorsfonalak <noreply@sorsfonalak.hu>}
|
||||
PUBLIC_BASE_URL: https://${DOMAIN}
|
||||
LOG_DIR: /logs
|
||||
# On a deploy the e-mails and invoices being sent finish first.
|
||||
SHUTDOWN_DRAIN_SECS: 40
|
||||
env_file:
|
||||
- path: .env.secrets
|
||||
required: false
|
||||
@@ -143,6 +147,7 @@ services:
|
||||
read_only: true
|
||||
volumes:
|
||||
- logs:/logs
|
||||
stop_grace_period: 1m
|
||||
logging: *logging
|
||||
restart: unless-stopped
|
||||
|
||||
@@ -158,6 +163,9 @@ services:
|
||||
PUBLIC_BASE_URL: https://${DOMAIN}
|
||||
LOG_DIR: /logs
|
||||
LOG_NAME: worker-ai
|
||||
# On a deploy the analyses being written finish first (a detailed one
|
||||
# takes a few minutes); what is not done by then goes back to the queue.
|
||||
SHUTDOWN_DRAIN_SECS: 270
|
||||
env_file:
|
||||
- path: .env.secrets
|
||||
required: false
|
||||
@@ -167,6 +175,7 @@ services:
|
||||
read_only: true
|
||||
volumes:
|
||||
- logs:/logs
|
||||
stop_grace_period: 5m
|
||||
logging: *logging
|
||||
restart: unless-stopped
|
||||
|
||||
|
||||
@@ -46,6 +46,7 @@ services:
|
||||
# Plain HTTP in development; leave the default (true) in production.
|
||||
COOKIE_SECURE: ${COOKIE_SECURE:-false}
|
||||
GOOGLE_CLIENT_IDS: ${GOOGLE_CLIENT_IDS:-}
|
||||
APPLE_CLIENT_IDS: ${APPLE_CLIENT_IDS:-}
|
||||
BOOTSTRAP_ADMIN_EMAILS: ${BOOTSTRAP_ADMIN_EMAILS:-}
|
||||
# Paid detailed analyses (empty: anthropic/claude-opus-5.5).
|
||||
ANALYSIS_MODEL: ${ANALYSIS_MODEL:-}
|
||||
|
||||
+1
-1
@@ -68,7 +68,7 @@ A droplet saját tűzfala (`sorsfonalak-fw`, DigitalOcean → Networking → Fir
|
||||
|
||||
## 6. Indítás
|
||||
|
||||
- A `.env` fájlban opcionális: `MAIL_FROM=Sorsfonalak <hello@sorsfonalak.hu>` (ez az alapérték is).
|
||||
- A `.env` fájlban opcionális: `MAIL_FROM=Sorsfonalak <noreply@sorsfonalak.hu>` (élesben ez van beállítva, és ez a deploy compose alapértéke is). Az Apple „Email Communication” beállításában ugyanez a cím van regisztrálva: ha változik, ott is át kell írni, különben az Apple-továbbítócímekre nem érkeznek meg a levelek.
|
||||
- Utána: `docker compose up -d worker`. A naplóban ennek kell megjelennie: `e-mail delivery enabled`, `via=Amazon SES eu-central-1:2587, credentials from …`.
|
||||
- Az eddig várakozó levelek ekkor kimennek. Ha ezt nem szeretnéd, előtte töröld őket: `DELETE FROM email_outbox WHERE sent_at IS NULL;`.
|
||||
- Hibaüzenetek a naplóban:
|
||||
|
||||
@@ -18,6 +18,7 @@ Felhasználók, belépés, mentett születési képletek, szinasztriák és megh
|
||||
| `FREE_PERSON_SLOTS` | `0` | ennyi személyt vehet fel csomag nélkül egy felhasználó |
|
||||
| `SIGNUP_MODE` | `invite` | `invite`: új fiók csak meghívóval jön létre (403 `not_invited`); `open`: bárki regisztrálhat |
|
||||
| `GOOGLE_CLIENT_IDS` | – | Google OAuth kliens-azonosító(k); üresen a Google-belépés ki van kapcsolva |
|
||||
| `APPLE_CLIENT_IDS` | – | Sign in with Apple: a Services ID(k) vesszővel elválasztva (pl. `hu.sorsfonalak.web`), az ID token `aud` mezője ezek egyike kell legyen; üresen az Apple-belépés ki van kapcsolva |
|
||||
| `BOOTSTRAP_ADMIN_EMAILS` | – | ezek a címek regisztrációkor vagy belépéskor admin szerepet kapnak (így lesz meg az első admin) |
|
||||
| `SUPPORTED_LOCALES` | `hu,en` | felület- és elemzésnyelvek; az első az alapértelmezett |
|
||||
| `ANALYSIS_MODEL` | `anthropic/claude-opus-5.5` | az elemzések, előrejelzések és válaszok alapmodellje, és a tartalék, ha a választott modell hibára fut |
|
||||
|
||||
@@ -75,6 +75,12 @@ pub struct Config {
|
||||
pub google_client_ids: Vec<String>,
|
||||
/// `GOOGLE_JWKS_URL` (default Google's certificate endpoint).
|
||||
pub google_jwks_url: String,
|
||||
/// `APPLE_CLIENT_IDS`: comma-separated Services IDs (e.g.
|
||||
/// `hu.sorsfonalak.web`) accepted as the ID token audience; empty
|
||||
/// disables Sign in with Apple.
|
||||
pub apple_client_ids: Vec<String>,
|
||||
/// `APPLE_JWKS_URL` (default Apple's key endpoint).
|
||||
pub apple_jwks_url: String,
|
||||
/// `BOOTSTRAP_ADMIN_EMAILS`: these users get the admin role when they
|
||||
/// register or log in (to create the first administrator).
|
||||
pub bootstrap_admin_emails: Vec<String>,
|
||||
@@ -197,6 +203,8 @@ impl Config {
|
||||
google_client_ids: list("GOOGLE_CLIENT_IDS"),
|
||||
google_jwks_url: var("GOOGLE_JWKS_URL")
|
||||
.unwrap_or_else(|| "https://www.googleapis.com/oauth2/v3/certs".into()),
|
||||
apple_client_ids: list("APPLE_CLIENT_IDS"),
|
||||
apple_jwks_url: var("APPLE_JWKS_URL").unwrap_or_else(|| "https://appleid.apple.com/auth/keys".into()),
|
||||
bootstrap_admin_emails: list("BOOTSTRAP_ADMIN_EMAILS").into_iter().map(|e| e.to_lowercase()).collect(),
|
||||
supported_locales,
|
||||
analysis_model: var("ANALYSIS_MODEL").unwrap_or_else(|| "anthropic/claude-opus-5.5".into()),
|
||||
@@ -240,6 +248,8 @@ impl Config {
|
||||
user_invites: true,
|
||||
referral_rewards: true,
|
||||
google_client_ids: vec!["test-client.apps.googleusercontent.com".into()],
|
||||
apple_client_ids: vec!["hu.sorsfonalak.test".into()],
|
||||
apple_jwks_url: google_jwks_url.clone(),
|
||||
google_jwks_url,
|
||||
bootstrap_admin_emails: vec!["admin@example.com".into()],
|
||||
supported_locales: vec!["hu".into(), "en".into()],
|
||||
|
||||
@@ -1,107 +0,0 @@
|
||||
//! Google Sign-In: verification of Google ID tokens.
|
||||
//!
|
||||
//! The frontend obtains an ID token with Google Identity Services (button or
|
||||
//! One Tap) and posts it to `POST /v1/auth/google`. The token is a JWT signed
|
||||
//! by Google; it is verified here against Google's published keys (JWKS,
|
||||
//! cached), the configured client ids (audience) and the issuer.
|
||||
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use jsonwebtoken::{Algorithm, DecodingKey, Validation, decode, decode_header};
|
||||
use serde::Deserialize;
|
||||
use tokio::sync::RwLock;
|
||||
|
||||
use crate::error::ApiError;
|
||||
|
||||
const ISSUERS: [&str; 2] = ["accounts.google.com", "https://accounts.google.com"];
|
||||
const JWKS_MAX_AGE: Duration = Duration::from_secs(3600);
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
pub struct GoogleClaims {
|
||||
/// Stable Google account id.
|
||||
pub sub: String,
|
||||
pub email: Option<String>,
|
||||
#[serde(default)]
|
||||
pub email_verified: bool,
|
||||
pub name: Option<String>,
|
||||
pub locale: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Deserialize)]
|
||||
struct Jwk {
|
||||
kid: String,
|
||||
n: String,
|
||||
e: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct JwkSet {
|
||||
keys: Vec<Jwk>,
|
||||
}
|
||||
|
||||
pub struct GoogleVerifier {
|
||||
client_ids: Vec<String>,
|
||||
jwks_url: String,
|
||||
http: reqwest::Client,
|
||||
cache: RwLock<Option<(Instant, Vec<Jwk>)>>,
|
||||
}
|
||||
|
||||
impl GoogleVerifier {
|
||||
pub fn new(client_ids: Vec<String>, jwks_url: String) -> Self {
|
||||
let http = reqwest::Client::builder().timeout(Duration::from_secs(10)).build().expect("static configuration");
|
||||
Self { client_ids, jwks_url, http, cache: RwLock::new(None) }
|
||||
}
|
||||
|
||||
pub fn enabled(&self) -> bool {
|
||||
!self.client_ids.is_empty()
|
||||
}
|
||||
|
||||
async fn fetch_keys(&self) -> Result<Vec<Jwk>, ApiError> {
|
||||
let set: JwkSet = self
|
||||
.http
|
||||
.get(&self.jwks_url)
|
||||
.send()
|
||||
.await
|
||||
.and_then(|r| r.error_for_status())
|
||||
.map_err(|e| ApiError::Internal(format!("fetching Google keys: {e}")))?
|
||||
.json()
|
||||
.await
|
||||
.map_err(|e| ApiError::Internal(format!("parsing Google keys: {e}")))?;
|
||||
Ok(set.keys)
|
||||
}
|
||||
|
||||
/// The key with `kid`; the key set is refetched when it is stale or the
|
||||
/// key is unknown (Google rotates its keys).
|
||||
async fn key(&self, kid: &str) -> Result<Jwk, ApiError> {
|
||||
if let Some((fetched, keys)) = self.cache.read().await.as_ref()
|
||||
&& fetched.elapsed() < JWKS_MAX_AGE
|
||||
&& let Some(k) = keys.iter().find(|k| k.kid == kid)
|
||||
{
|
||||
return Ok(k.clone());
|
||||
}
|
||||
let keys = self.fetch_keys().await?;
|
||||
let found = keys.iter().find(|k| k.kid == kid).cloned();
|
||||
*self.cache.write().await = Some((Instant::now(), keys));
|
||||
found.ok_or_else(|| ApiError::InvalidCredentials("the Google token is signed with an unknown key".into()))
|
||||
}
|
||||
|
||||
pub async fn verify(&self, id_token: &str) -> Result<GoogleClaims, ApiError> {
|
||||
if !self.enabled() {
|
||||
return Err(ApiError::Forbidden("Google login is not configured".into()));
|
||||
}
|
||||
let invalid =
|
||||
|e: jsonwebtoken::errors::Error| ApiError::InvalidCredentials(format!("invalid Google token: {e}"));
|
||||
let header = decode_header(id_token).map_err(invalid)?;
|
||||
if header.alg != Algorithm::RS256 {
|
||||
return Err(ApiError::InvalidCredentials("invalid Google token: unexpected algorithm".into()));
|
||||
}
|
||||
let kid = header.kid.ok_or_else(|| ApiError::InvalidCredentials("invalid Google token: no key id".into()))?;
|
||||
let jwk = self.key(&kid).await?;
|
||||
let key = DecodingKey::from_rsa_components(&jwk.n, &jwk.e).map_err(invalid)?;
|
||||
let mut validation = Validation::new(Algorithm::RS256);
|
||||
validation.set_audience(&self.client_ids);
|
||||
validation.set_issuer(&ISSUERS);
|
||||
validation.set_required_spec_claims(&["exp", "iss", "aud", "sub"]);
|
||||
Ok(decode::<GoogleClaims>(id_token, &key, &validation).map_err(invalid)?.claims)
|
||||
}
|
||||
}
|
||||
@@ -12,9 +12,9 @@ mod birth_changes;
|
||||
mod config;
|
||||
mod credits;
|
||||
mod error;
|
||||
mod google;
|
||||
mod invoices;
|
||||
mod models;
|
||||
mod oidc;
|
||||
mod packages;
|
||||
mod persons;
|
||||
mod routes;
|
||||
@@ -32,7 +32,7 @@ use sqlx::PgPool;
|
||||
|
||||
use crate::auth::LoginLimiter;
|
||||
use crate::config::Config;
|
||||
use crate::google::GoogleVerifier;
|
||||
use crate::oidc::IdTokenVerifier;
|
||||
|
||||
const DEFAULT_BIND_ADDR: &str = "0.0.0.0:8081";
|
||||
|
||||
@@ -40,7 +40,8 @@ pub struct AppState {
|
||||
pub db: PgPool,
|
||||
pub config: Config,
|
||||
pub horoscope: HoroscopeClient,
|
||||
pub google: GoogleVerifier,
|
||||
pub google: IdTokenVerifier,
|
||||
pub apple: IdTokenVerifier,
|
||||
pub login_limiter: LoginLimiter,
|
||||
pub models: models::Catalog,
|
||||
pub stripe: stripe::Client,
|
||||
@@ -50,7 +51,8 @@ impl AppState {
|
||||
pub fn new(db: PgPool, config: Config) -> Self {
|
||||
Self {
|
||||
horoscope: HoroscopeClient::new(&config.horoscope_api_url),
|
||||
google: GoogleVerifier::new(config.google_client_ids.clone(), config.google_jwks_url.clone()),
|
||||
google: IdTokenVerifier::google(config.google_client_ids.clone(), config.google_jwks_url.clone()),
|
||||
apple: IdTokenVerifier::apple(config.apple_client_ids.clone(), config.apple_jwks_url.clone()),
|
||||
login_limiter: LoginLimiter::new(10, Duration::from_secs(15 * 60)),
|
||||
models: models::Catalog::new(&config.openrouter_models_url),
|
||||
stripe: stripe::Client::default(),
|
||||
@@ -66,12 +68,13 @@ async fn main() -> anyhow::Result<()> {
|
||||
if std::env::args().nth(1).as_deref() == Some("healthcheck") {
|
||||
return service_kit::healthcheck(addr);
|
||||
}
|
||||
service_kit::init_logging("backend");
|
||||
let _log = service_kit::init_logging("backend");
|
||||
let config = Config::from_env()?;
|
||||
let pool = db::connect(&config.database_url).await.context("connecting to the database")?;
|
||||
db::migrate(&pool).await.context("running database migrations")?;
|
||||
tracing::info!(
|
||||
google_login = !config.google_client_ids.is_empty(),
|
||||
apple_login = !config.apple_client_ids.is_empty(),
|
||||
horoscope_api = %config.horoscope_api_url,
|
||||
"database ready"
|
||||
);
|
||||
|
||||
@@ -0,0 +1,139 @@
|
||||
//! Sign-in with Google and Apple: verification of their ID tokens.
|
||||
//!
|
||||
//! The frontend obtains an ID token (Google Identity Services, or Sign in with
|
||||
//! Apple JS) and posts it to `POST /v1/auth/google` / `/v1/auth/apple`. The
|
||||
//! token is a JWT signed by the provider; it is verified here against the
|
||||
//! provider's published keys (JWKS, cached), the configured client ids
|
||||
//! (audience: Google client ids, Apple Services IDs) and the issuer.
|
||||
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use jsonwebtoken::{Algorithm, DecodingKey, Validation, decode, decode_header};
|
||||
use serde::Deserialize;
|
||||
use tokio::sync::RwLock;
|
||||
|
||||
use crate::error::ApiError;
|
||||
|
||||
const GOOGLE_ISSUERS: &[&str] = &["accounts.google.com", "https://accounts.google.com"];
|
||||
const APPLE_ISSUERS: &[&str] = &["https://appleid.apple.com"];
|
||||
const JWKS_MAX_AGE: Duration = Duration::from_secs(3600);
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
pub struct IdClaims {
|
||||
/// Stable account id at the provider.
|
||||
pub sub: String,
|
||||
pub email: Option<String>,
|
||||
/// Apple sends it as a string ("true").
|
||||
#[serde(default, deserialize_with = "flexible_bool")]
|
||||
pub email_verified: bool,
|
||||
/// Google only; Apple gives the name to the frontend, at the first sign-in.
|
||||
pub name: Option<String>,
|
||||
pub locale: Option<String>,
|
||||
}
|
||||
|
||||
fn flexible_bool<'de, D: serde::Deserializer<'de>>(d: D) -> Result<bool, D::Error> {
|
||||
Ok(match serde_json::Value::deserialize(d)? {
|
||||
serde_json::Value::Bool(b) => b,
|
||||
serde_json::Value::String(s) => s == "true",
|
||||
_ => false,
|
||||
})
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Deserialize)]
|
||||
struct Jwk {
|
||||
kid: String,
|
||||
n: String,
|
||||
e: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct JwkSet {
|
||||
keys: Vec<Jwk>,
|
||||
}
|
||||
|
||||
pub struct IdTokenVerifier {
|
||||
/// "Google" or "Apple", for messages.
|
||||
provider: &'static str,
|
||||
issuers: &'static [&'static str],
|
||||
client_ids: Vec<String>,
|
||||
jwks_url: String,
|
||||
http: reqwest::Client,
|
||||
cache: RwLock<Option<(Instant, Vec<Jwk>)>>,
|
||||
}
|
||||
|
||||
impl IdTokenVerifier {
|
||||
fn new(
|
||||
provider: &'static str,
|
||||
issuers: &'static [&'static str],
|
||||
client_ids: Vec<String>,
|
||||
jwks_url: String,
|
||||
) -> Self {
|
||||
let http = reqwest::Client::builder().timeout(Duration::from_secs(10)).build().expect("static configuration");
|
||||
Self { provider, issuers, client_ids, jwks_url, http, cache: RwLock::new(None) }
|
||||
}
|
||||
|
||||
pub fn google(client_ids: Vec<String>, jwks_url: String) -> Self {
|
||||
Self::new("Google", GOOGLE_ISSUERS, client_ids, jwks_url)
|
||||
}
|
||||
|
||||
pub fn apple(client_ids: Vec<String>, jwks_url: String) -> Self {
|
||||
Self::new("Apple", APPLE_ISSUERS, client_ids, jwks_url)
|
||||
}
|
||||
|
||||
pub fn enabled(&self) -> bool {
|
||||
!self.client_ids.is_empty()
|
||||
}
|
||||
|
||||
async fn fetch_keys(&self) -> Result<Vec<Jwk>, ApiError> {
|
||||
let set: JwkSet = self
|
||||
.http
|
||||
.get(&self.jwks_url)
|
||||
.send()
|
||||
.await
|
||||
.and_then(|r| r.error_for_status())
|
||||
.map_err(|e| ApiError::Internal(format!("fetching {} keys: {e}", self.provider)))?
|
||||
.json()
|
||||
.await
|
||||
.map_err(|e| ApiError::Internal(format!("parsing {} keys: {e}", self.provider)))?;
|
||||
Ok(set.keys)
|
||||
}
|
||||
|
||||
/// The key with `kid`; the key set is refetched when it is stale or the
|
||||
/// key is unknown (the providers rotate their keys).
|
||||
async fn key(&self, kid: &str) -> Result<Jwk, ApiError> {
|
||||
if let Some((fetched, keys)) = self.cache.read().await.as_ref()
|
||||
&& fetched.elapsed() < JWKS_MAX_AGE
|
||||
&& let Some(k) = keys.iter().find(|k| k.kid == kid)
|
||||
{
|
||||
return Ok(k.clone());
|
||||
}
|
||||
let keys = self.fetch_keys().await?;
|
||||
let found = keys.iter().find(|k| k.kid == kid).cloned();
|
||||
*self.cache.write().await = Some((Instant::now(), keys));
|
||||
found.ok_or_else(|| {
|
||||
ApiError::InvalidCredentials(format!("the {} token is signed with an unknown key", self.provider))
|
||||
})
|
||||
}
|
||||
|
||||
pub async fn verify(&self, id_token: &str) -> Result<IdClaims, ApiError> {
|
||||
let provider = self.provider;
|
||||
if !self.enabled() {
|
||||
return Err(ApiError::Forbidden(format!("{provider} login is not configured")));
|
||||
}
|
||||
let invalid =
|
||||
|e: jsonwebtoken::errors::Error| ApiError::InvalidCredentials(format!("invalid {provider} token: {e}"));
|
||||
let header = decode_header(id_token).map_err(invalid)?;
|
||||
if header.alg != Algorithm::RS256 {
|
||||
return Err(ApiError::InvalidCredentials(format!("invalid {provider} token: unexpected algorithm")));
|
||||
}
|
||||
let kid =
|
||||
header.kid.ok_or_else(|| ApiError::InvalidCredentials(format!("invalid {provider} token: no key id")))?;
|
||||
let jwk = self.key(&kid).await?;
|
||||
let key = DecodingKey::from_rsa_components(&jwk.n, &jwk.e).map_err(invalid)?;
|
||||
let mut validation = Validation::new(Algorithm::RS256);
|
||||
validation.set_audience(&self.client_ids);
|
||||
validation.set_issuer(self.issuers);
|
||||
validation.set_required_spec_claims(&["exp", "iss", "aud", "sub"]);
|
||||
Ok(decode::<IdClaims>(id_token, &key, &validation).map_err(invalid)?.claims)
|
||||
}
|
||||
}
|
||||
@@ -307,20 +307,78 @@ pub async fn google(
|
||||
WithRejection(Json(req), _): Body<GoogleRequest>,
|
||||
) -> ApiResult<impl IntoResponse> {
|
||||
let claims = state.google.verify(&req.id_token).await?;
|
||||
let signup = Signup {
|
||||
name: claims.name.clone(),
|
||||
locale: claims.locale.clone(),
|
||||
invite_token: req.invite_token,
|
||||
referral: req.referral,
|
||||
};
|
||||
social_login(&state, headers, jar, "google", claims, signup).await
|
||||
}
|
||||
|
||||
// --- Apple ------------------------------------------------------------------------------
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct AppleRequest {
|
||||
/// ID token (JWT) from Sign in with Apple JS.
|
||||
id_token: String,
|
||||
/// The name Apple gives the page at the first sign-in only (it is not in
|
||||
/// the token): used when the account is created.
|
||||
name: Option<String>,
|
||||
invite_token: Option<String>,
|
||||
referral: Option<String>,
|
||||
}
|
||||
|
||||
/// Logs in with Apple, like [`google`]. The address may be an Apple relay
|
||||
/// (`…@privaterelay.appleid.com`), which forwards our e-mails.
|
||||
pub async fn apple(
|
||||
State(state): St,
|
||||
headers: HeaderMap,
|
||||
jar: CookieJar,
|
||||
WithRejection(Json(req), _): Body<AppleRequest>,
|
||||
) -> ApiResult<impl IntoResponse> {
|
||||
let claims = state.apple.verify(&req.id_token).await?;
|
||||
let signup = Signup { name: req.name, locale: None, invite_token: req.invite_token, referral: req.referral };
|
||||
social_login(&state, headers, jar, "apple", claims, signup).await
|
||||
}
|
||||
|
||||
/// What a new account starts with.
|
||||
struct Signup {
|
||||
name: Option<String>,
|
||||
locale: Option<String>,
|
||||
invite_token: Option<String>,
|
||||
referral: Option<String>,
|
||||
}
|
||||
|
||||
/// Logs in with a verified provider identity: the linked user, else the user
|
||||
/// with the same (provider-verified) e-mail address, else a new user.
|
||||
async fn social_login(
|
||||
state: &AppState,
|
||||
headers: HeaderMap,
|
||||
jar: CookieJar,
|
||||
provider: &'static str,
|
||||
claims: crate::oidc::IdClaims,
|
||||
signup: Signup,
|
||||
) -> ApiResult<impl IntoResponse + use<>> {
|
||||
let email = match (claims.email.as_deref(), claims.email_verified) {
|
||||
(Some(e), true) => normalize_email(e)?,
|
||||
_ => return Err(ApiError::InvalidCredentials("the Google account has no verified e-mail address".into())),
|
||||
_ => {
|
||||
return Err(ApiError::InvalidCredentials(format!("the {provider} account has no verified e-mail address")));
|
||||
}
|
||||
};
|
||||
|
||||
let mut tx = state.db.begin().await?;
|
||||
let linked: Option<(Uuid,)> =
|
||||
sqlx::query_as("SELECT user_id FROM auth_identities WHERE provider = 'google' AND subject = $1")
|
||||
sqlx::query_as("SELECT user_id FROM auth_identities WHERE provider = $1 AND subject = $2")
|
||||
.bind(provider)
|
||||
.bind(&claims.sub)
|
||||
.fetch_optional(&mut *tx)
|
||||
.await?;
|
||||
let (user_id, created) = match linked {
|
||||
Some((id,)) => {
|
||||
sqlx::query("UPDATE auth_identities SET last_used_at = now() WHERE provider = 'google' AND subject = $1")
|
||||
sqlx::query("UPDATE auth_identities SET last_used_at = now() WHERE provider = $1 AND subject = $2")
|
||||
.bind(provider)
|
||||
.bind(&claims.sub)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
@@ -331,7 +389,7 @@ pub async fn google(
|
||||
sqlx::query_as("SELECT id FROM users WHERE email = $1").bind(&email).fetch_optional(&mut *tx).await?;
|
||||
let (id, created) = match existing {
|
||||
Some((id,)) => {
|
||||
// Google has verified the address, so it counts as verified here too.
|
||||
// The provider has verified the address, so it counts as verified here too.
|
||||
sqlx::query(
|
||||
"UPDATE users SET email_verified_at = COALESCE(email_verified_at, now()) WHERE id = $1",
|
||||
)
|
||||
@@ -341,9 +399,9 @@ pub async fn google(
|
||||
(id, false)
|
||||
}
|
||||
None => {
|
||||
super::invitations::admit(&state, &mut tx, &email, req.invite_token.as_deref()).await?;
|
||||
super::invitations::admit(state, &mut tx, &email, signup.invite_token.as_deref()).await?;
|
||||
let id = Uuid::now_v7();
|
||||
let locale = claims
|
||||
let locale = signup
|
||||
.locale
|
||||
.as_deref()
|
||||
.and_then(|l| l.split(['-', '_']).next())
|
||||
@@ -355,7 +413,7 @@ pub async fn google(
|
||||
)
|
||||
.bind(id)
|
||||
.bind(&email)
|
||||
.bind(clean_name(claims.name.clone()))
|
||||
.bind(clean_name(signup.name))
|
||||
.bind(locale)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
@@ -363,21 +421,27 @@ pub async fn google(
|
||||
&mut tx,
|
||||
id,
|
||||
&email,
|
||||
req.invite_token.as_deref(),
|
||||
signup.invite_token.as_deref(),
|
||||
state.config.free_person_slots,
|
||||
)
|
||||
.await?;
|
||||
super::shares::record_referral(&mut tx, state.config.referral_rewards, id, req.referral.as_deref())
|
||||
.await?;
|
||||
super::shares::record_referral(
|
||||
&mut tx,
|
||||
state.config.referral_rewards,
|
||||
id,
|
||||
signup.referral.as_deref(),
|
||||
)
|
||||
.await?;
|
||||
(id, true)
|
||||
}
|
||||
};
|
||||
sqlx::query(
|
||||
"INSERT INTO auth_identities (id, user_id, provider, subject, email, last_used_at) \
|
||||
VALUES ($1, $2, 'google', $3, $4, now())",
|
||||
VALUES ($1, $2, $3, $4, $5, now())",
|
||||
)
|
||||
.bind(Uuid::now_v7())
|
||||
.bind(id)
|
||||
.bind(provider)
|
||||
.bind(&claims.sub)
|
||||
.bind(&email)
|
||||
.execute(&mut *tx)
|
||||
@@ -386,11 +450,11 @@ pub async fn google(
|
||||
}
|
||||
};
|
||||
let mut user = load_user(&mut tx, user_id).await?;
|
||||
apply_bootstrap_admin(&state, &mut tx, &mut user).await?;
|
||||
apply_bootstrap_admin(state, &mut tx, &mut user).await?;
|
||||
tx.commit().await?;
|
||||
|
||||
let session = create_session(&state.db, &state.config, user.id, user_agent(&headers)).await?;
|
||||
Ok(login_response(&state, jar, &user, session, created))
|
||||
Ok(login_response(state, jar, &user, session, created))
|
||||
}
|
||||
|
||||
// --- logout -------------------------------------------------------------------------------
|
||||
|
||||
@@ -36,8 +36,7 @@ use axum::{Json, Router};
|
||||
use axum_extra::extract::WithRejection;
|
||||
use serde_json::{Value, json};
|
||||
use tower_http::cors::{AllowOrigin, CorsLayer};
|
||||
use tower_http::trace::{DefaultMakeSpan, DefaultOnResponse, TraceLayer};
|
||||
use tracing::Level;
|
||||
use tower_http::trace::TraceLayer;
|
||||
use uuid::Uuid;
|
||||
|
||||
use crate::AppState;
|
||||
@@ -60,12 +59,14 @@ where
|
||||
|
||||
pub fn router(state: Arc<AppState>) -> Router {
|
||||
Router::new()
|
||||
.route("/healthz", get(health))
|
||||
.route("/v1/config", get(public_config))
|
||||
.route("/v1/packages", get(payments::catalog))
|
||||
// login
|
||||
.route("/v1/auth/register", post(auth::register))
|
||||
.route("/v1/auth/login", post(auth::login))
|
||||
.route("/v1/auth/google", post(auth::google))
|
||||
.route("/v1/auth/apple", post(auth::apple))
|
||||
.route("/v1/auth/logout", post(auth::logout))
|
||||
.route("/v1/auth/logout-all", post(auth::logout_all))
|
||||
.route("/v1/auth/verify-email", post(auth::verify_email))
|
||||
@@ -140,13 +141,8 @@ pub fn router(state: Arc<AppState>) -> Router {
|
||||
.route("/v1/admin/analyses/{id}/regenerate", post(analyses::regenerate))
|
||||
.route("/v1/admin/questions/{id}/regenerate", post(questions::regenerate))
|
||||
.layer(cors(&state.config.cors_allowed_origins))
|
||||
.layer(
|
||||
TraceLayer::new_for_http()
|
||||
.make_span_with(DefaultMakeSpan::new().level(Level::INFO))
|
||||
.on_response(DefaultOnResponse::new().level(Level::INFO)),
|
||||
)
|
||||
// After the layers: the Docker health check (every 30 s) stays out of the log.
|
||||
.route("/healthz", get(health))
|
||||
// The request log: masked paths, health checks only when they fail.
|
||||
.layer(TraceLayer::new_for_http().make_span_with(service_kit::RequestLog).on_response(service_kit::RequestLog))
|
||||
.with_state(state)
|
||||
}
|
||||
|
||||
@@ -169,6 +165,7 @@ async fn public_config(State(state): St) -> Json<Value> {
|
||||
let c = &state.config;
|
||||
Json(json!({
|
||||
"google_login": { "enabled": state.google.enabled(), "client_id": c.google_client_ids.first() },
|
||||
"apple_login": { "enabled": state.apple.enabled(), "client_id": c.apple_client_ids.first() },
|
||||
"locales": c.supported_locales,
|
||||
"password_login": c.password_login,
|
||||
"mock_payments": payments::method(c) == Some("mock"),
|
||||
|
||||
@@ -195,6 +195,18 @@ fn google_token(sub: &str, email: &str, audience: &str) -> String {
|
||||
jsonwebtoken::encode(&header, &claims, &jsonwebtoken::EncodingKey::from_rsa_pem(GOOGLE_KEY_PEM).unwrap()).unwrap()
|
||||
}
|
||||
|
||||
fn apple_token(sub: &str, email: &str, audience: &str) -> String {
|
||||
let now = time::OffsetDateTime::now_utc().unix_timestamp();
|
||||
// Apple sends email_verified as a string and no name.
|
||||
let claims = json!({
|
||||
"iss": "https://appleid.apple.com", "aud": audience, "sub": sub, "email": email,
|
||||
"email_verified": "true", "is_private_email": "true", "iat": now, "exp": now + 600
|
||||
});
|
||||
let mut header = jsonwebtoken::Header::new(jsonwebtoken::Algorithm::RS256);
|
||||
header.kid = Some("test-key".into());
|
||||
jsonwebtoken::encode(&header, &claims, &jsonwebtoken::EncodingKey::from_rsa_pem(GOOGLE_KEY_PEM).unwrap()).unwrap()
|
||||
}
|
||||
|
||||
// --- test client -------------------------------------------------------------------------------
|
||||
|
||||
struct TestApp {
|
||||
@@ -851,7 +863,7 @@ async fn export_and_delete_account(pool: PgPool) {
|
||||
/// config and catalog, shared links, invitation pages, the waitlist and
|
||||
/// unsubscribing. Every other route (charts, calculations, analyses) needs a
|
||||
/// logged-in user, so other apps cannot use them.
|
||||
const PUBLIC_ROUTES: [&str; 16] = [
|
||||
const PUBLIC_ROUTES: [&str; 17] = [
|
||||
"/healthz",
|
||||
// Stripe calls it; the signature proves it.
|
||||
"/v1/payments/stripe/webhook",
|
||||
@@ -860,6 +872,7 @@ const PUBLIC_ROUTES: [&str; 16] = [
|
||||
"/v1/auth/register",
|
||||
"/v1/auth/login",
|
||||
"/v1/auth/google",
|
||||
"/v1/auth/apple",
|
||||
"/v1/auth/verify-email",
|
||||
"/v1/auth/password-reset",
|
||||
"/v1/auth/password-reset/confirm",
|
||||
@@ -2673,3 +2686,59 @@ async fn tarot_readings_draw_on_the_server_and_use_tarot_units(pool: PgPool) {
|
||||
assert_eq!(r.status, StatusCode::NO_CONTENT, "{}", r.body);
|
||||
assert_eq!(count().await, 0);
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn apple_login_creates_links_and_rejects(pool: PgPool) {
|
||||
let app = TestApp::new(pool).await;
|
||||
let r = app.get("/v1/config", None).await;
|
||||
assert_eq!(r.body["apple_login"], json!({"enabled": true, "client_id": "hu.sorsfonalak.test"}));
|
||||
let relay = "x7k2p9@privaterelay.appleid.com";
|
||||
// The name comes from the page (Apple gives it at the first sign-in only).
|
||||
let r = app
|
||||
.post(
|
||||
"/v1/auth/apple",
|
||||
None,
|
||||
json!({"id_token": apple_token("a-1", relay, "hu.sorsfonalak.test"), "name": "Kovács Anna"}),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(r.status, StatusCode::CREATED, "{}", r.body);
|
||||
assert_eq!((&r.body["created"], &r.body["user"]["display_name"]), (&json!(true), &json!("Kovács Anna")));
|
||||
assert_eq!(r.body["user"]["email"], relay);
|
||||
let r =
|
||||
app.post("/v1/auth/apple", None, json!({"id_token": apple_token("a-1", relay, "hu.sorsfonalak.test")})).await;
|
||||
assert_eq!((r.status, &r.body["created"]), (StatusCode::OK, &json!(false)));
|
||||
assert_eq!(r.body["user"]["display_name"], "Kovács Anna");
|
||||
|
||||
// the same address as a Google account: both log into one user
|
||||
let google = app
|
||||
.post("/v1/auth/google", None, json!({"id_token": google_token("g-9", "bela@example.com", GOOGLE_CLIENT)}))
|
||||
.await;
|
||||
let token = google.body["session"]["token"].as_str().unwrap().to_string();
|
||||
let r = app
|
||||
.post(
|
||||
"/v1/auth/apple",
|
||||
None,
|
||||
json!({"id_token": apple_token("a-2", "bela@example.com", "hu.sorsfonalak.test")}),
|
||||
)
|
||||
.await;
|
||||
assert_eq!((r.status, &r.body["created"]), (StatusCode::OK, &json!(false)));
|
||||
assert_eq!(app.get("/v1/me", Some(&token)).await.body["providers"], json!(["google", "apple"]));
|
||||
|
||||
// a Google token is no Apple token, nor one for another Services ID
|
||||
let r = app
|
||||
.post("/v1/auth/apple", None, json!({"id_token": google_token("g-1", "gabor@gmail.com", GOOGLE_CLIENT)}))
|
||||
.await;
|
||||
assert_eq!(r.status, StatusCode::UNAUTHORIZED);
|
||||
let r = app.post("/v1/auth/apple", None, json!({"id_token": apple_token("a-3", relay, "other.service")})).await;
|
||||
assert_eq!(r.status, StatusCode::UNAUTHORIZED);
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn apple_login_can_be_off(pool: PgPool) {
|
||||
let app = TestApp::with_config(pool, |c| c.apple_client_ids.clear()).await;
|
||||
assert_eq!(app.get("/v1/config", None).await.body["apple_login"]["enabled"], false);
|
||||
let r = app
|
||||
.post("/v1/auth/apple", None, json!({"id_token": apple_token("a-1", "a@b.hu", "hu.sorsfonalak.test")}))
|
||||
.await;
|
||||
assert_eq!(r.status, StatusCode::FORBIDDEN);
|
||||
}
|
||||
|
||||
@@ -57,7 +57,10 @@ export default async function PrivacyPage() {
|
||||
</thead>
|
||||
<tbody>
|
||||
<tr>
|
||||
<td>Google-fiókod neve, e-mail-címe és azonosítója (belépéskor a Google adja át)</td>
|
||||
<td>
|
||||
Google- vagy Apple-fiókod neve, e-mail-címe és azonosítója (belépéskor a Google, illetve az Apple adja
|
||||
át)
|
||||
</td>
|
||||
<td>Fiókod létrehozása, belépés, kapcsolattartás</td>
|
||||
<td>Szerződés teljesítése (GDPR 6. cikk (1) b)</td>
|
||||
</tr>
|
||||
@@ -168,6 +171,13 @@ export default async function PrivacyPage() {
|
||||
</a>{" "}
|
||||
szabályzatnak, beleértve a „Limited Use” (korlátozott felhasználás) követelményeit.
|
||||
</p>
|
||||
<p>
|
||||
<strong>Belépés Apple-fiókkal:</strong> ha az „Apple-bejelentkezést” választod, az Apple a fiókod egyedi
|
||||
azonosítóját és az e-mail-címedet adja át, az első belépéskor a nevedet is. Ha az e-mail-címedet elrejted,
|
||||
egy Apple-továbbítócímet kapunk (<code>…@privaterelay.appleid.com</code>): az erre küldött leveleinket az Apple
|
||||
továbbítja hozzád. Ezeket ugyanarra és ugyanúgy használjuk, mint a Google-adatokat. A hozzáférést az Apple ID
|
||||
beállításaidban vonhatod vissza (Bejelentkezés és biztonság › Bejelentkezés az Apple-lel).
|
||||
</p>
|
||||
</section>
|
||||
|
||||
<section>
|
||||
|
||||
@@ -0,0 +1,152 @@
|
||||
"use client";
|
||||
|
||||
import Script from "next/script";
|
||||
import { useRouter } from "next/navigation";
|
||||
import { useState } from "react";
|
||||
|
||||
import { Waitlist } from "@/components/Waitlist";
|
||||
import { ApiError, api, errorText } from "@/lib/api";
|
||||
|
||||
/** The part of Sign in with Apple JS (appleid.auth.js) we use. */
|
||||
interface AppleSignInResponse {
|
||||
authorization: { id_token: string; code: string; state?: string };
|
||||
/** Only at the first sign-in of this Apple ID on the site. */
|
||||
user?: { email?: string; name?: { firstName?: string; lastName?: string } };
|
||||
}
|
||||
|
||||
declare global {
|
||||
interface Window {
|
||||
AppleID?: {
|
||||
auth: {
|
||||
init(options: { clientId: string; scope: string; redirectURI: string; state?: string; usePopup: boolean }): void;
|
||||
signIn(): Promise<AppleSignInResponse>;
|
||||
};
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
/** Apple's logo (Sign in with Apple guidelines: the logo left of the label). */
|
||||
function AppleMark() {
|
||||
return (
|
||||
<svg width="18" height="20" viewBox="0 0 17 20" aria-hidden="true" fill="currentColor">
|
||||
<path d="M13.77 10.62c-.02-2.2 1.8-3.26 1.88-3.31-1.03-1.5-2.62-1.7-3.18-1.73-1.35-.14-2.64.8-3.33.8-.69 0-1.74-.78-2.86-.76-1.47.02-2.83.86-3.59 2.17-1.53 2.65-.39 6.57 1.1 8.72.73 1.05 1.6 2.23 2.73 2.19 1.1-.04 1.51-.71 2.84-.71 1.32 0 1.7.71 2.86.69 1.18-.02 1.93-1.07 2.65-2.12.84-1.22 1.18-2.4 1.2-2.46-.03-.01-2.29-.88-2.3-3.48zM11.6 4.17c.6-.73 1.01-1.75.9-2.76-.87.04-1.92.58-2.54 1.31-.56.65-1.05 1.69-.92 2.68.97.08 1.96-.49 2.56-1.23z" />
|
||||
</svg>
|
||||
);
|
||||
}
|
||||
|
||||
/** The e-mail address inside Apple's ID token (only for the waitlist form; the backend verifies the token). */
|
||||
function tokenEmail(idToken: string): string {
|
||||
try {
|
||||
const part = idToken.split(".")[1].replace(/-/g, "+").replace(/_/g, "/");
|
||||
const bytes = Uint8Array.from(atob(part), (c) => c.charCodeAt(0));
|
||||
const email = JSON.parse(new TextDecoder().decode(bytes)).email;
|
||||
return typeof email === "string" ? email : "";
|
||||
} catch {
|
||||
return "";
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* "Continue with Apple": Apple's sign-in opens in a popup and returns an ID
|
||||
* token, which the backend verifies. Apple gives the name only at the first
|
||||
* sign-in, so it is sent along then (Hungarian order: family name first).
|
||||
*/
|
||||
export function AppleLogin({
|
||||
clientId,
|
||||
target,
|
||||
inviteToken = null,
|
||||
}: {
|
||||
clientId: string;
|
||||
target: string;
|
||||
inviteToken?: string | null;
|
||||
}) {
|
||||
const router = useRouter();
|
||||
const [ready, setReady] = useState(false);
|
||||
const [busy, setBusy] = useState(false);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
const [uninvited, setUninvited] = useState<string | null>(null);
|
||||
|
||||
function loaded() {
|
||||
window.AppleID?.auth.init({
|
||||
clientId,
|
||||
scope: "name email",
|
||||
redirectURI: `${window.location.origin}/belepes`,
|
||||
usePopup: true,
|
||||
});
|
||||
setReady(true);
|
||||
}
|
||||
|
||||
async function signIn() {
|
||||
const apple = window.AppleID;
|
||||
if (!apple) return;
|
||||
setError(null);
|
||||
setUninvited(null);
|
||||
let response: AppleSignInResponse;
|
||||
try {
|
||||
response = await apple.auth.signIn();
|
||||
} catch (e) {
|
||||
// Closing the popup is not an error worth showing.
|
||||
const code = (e as { error?: string } | null)?.error;
|
||||
if (code !== "popup_closed_by_user" && code !== "user_cancelled_authorize") {
|
||||
setError("Az Apple-belépés nem sikerült. Próbáld újra.");
|
||||
}
|
||||
return;
|
||||
}
|
||||
setBusy(true);
|
||||
const name = [response.user?.name?.lastName, response.user?.name?.firstName].filter(Boolean).join(" ") || null;
|
||||
try {
|
||||
let referral: string | null = null;
|
||||
try {
|
||||
referral = localStorage.getItem("sf_ref");
|
||||
} catch {
|
||||
// storage blocked
|
||||
}
|
||||
await api("/auth/apple", {
|
||||
body: { id_token: response.authorization.id_token, name, invite_token: inviteToken, referral },
|
||||
});
|
||||
try {
|
||||
localStorage.removeItem("sf_ref");
|
||||
} catch {
|
||||
// storage blocked
|
||||
}
|
||||
router.replace(target);
|
||||
router.refresh();
|
||||
} catch (e) {
|
||||
if (e instanceof ApiError && e.code === "not_invited") setUninvited(tokenEmail(response.authorization.id_token));
|
||||
else setError(errorText(e));
|
||||
setBusy(false);
|
||||
}
|
||||
}
|
||||
|
||||
return (
|
||||
<div className="field">
|
||||
<Script
|
||||
src="https://appleid.cdn-apple.com/appleauth/static/jsapi/appleid/1/hu_HU/appleid.auth.js"
|
||||
strategy="afterInteractive"
|
||||
onReady={loaded}
|
||||
onError={() => setError("Nem sikerült betölteni az Apple-belépést. Ellenőrizd a hálózatot vagy a reklámblokkolót.")}
|
||||
/>
|
||||
<button type="button" className="btn-social btn-apple" onClick={signIn} disabled={!ready || busy}>
|
||||
<span className="btn-social-icon">
|
||||
<AppleMark />
|
||||
</span>
|
||||
{busy ? "Belépés…" : "Folytatás Apple-fiókkal"}
|
||||
</button>
|
||||
{error && (
|
||||
<p className="msg msg-error" role="alert">
|
||||
{error}
|
||||
</p>
|
||||
)}
|
||||
{uninvited !== null && (
|
||||
<>
|
||||
<p className="msg msg-error" role="alert">
|
||||
{inviteToken
|
||||
? "Ez a meghívó már nem érvényes, és ehhez az Apple-fiókhoz sem tartozik másik."
|
||||
: "A Sorsfonalak jelenleg meghívásos, és ehhez az Apple-fiókhoz nem tartozik meghívó. Ha kaptál meghívót, nyisd meg a levélben kapott linket, vagy lépj be azzal a fiókkal, amelynek a címére a meghívó szólt."}
|
||||
</p>
|
||||
<Waitlist email={uninvited.endsWith("@privaterelay.appleid.com") ? "" : uninvited} />
|
||||
</>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -8,6 +8,7 @@ import { BACKEND_URL, getMe } from "@/lib/server";
|
||||
import { formatDate } from "@/lib/astro";
|
||||
import type { InvitationLanding, PublicConfig } from "@/lib/types";
|
||||
|
||||
import { AppleLogin } from "./AppleLogin";
|
||||
import { GoogleLogin } from "./GoogleLogin";
|
||||
|
||||
export const metadata: Metadata = { title: "Belépés" };
|
||||
@@ -43,7 +44,7 @@ const CLOSED: Record<string, string> = {
|
||||
};
|
||||
|
||||
/** The invitation the visitor came with: who sent it and what they wrote. */
|
||||
function InvitationCard({ invitation }: { invitation: InvitationLanding | null }) {
|
||||
function InvitationCard({ invitation, apple }: { invitation: InvitationLanding | null; apple: boolean }) {
|
||||
if (!invitation) {
|
||||
return (
|
||||
<p className="msg msg-error" role="alert">
|
||||
@@ -66,7 +67,7 @@ function InvitationCard({ invitation }: { invitation: InvitationLanding | null }
|
||||
</p>
|
||||
{invitation.message && <blockquote className="invite-quote">{invitation.message}</blockquote>}
|
||||
<p className="hint" style={{ margin: 0 }}>
|
||||
Bármelyik Google-fiókoddal elfogadhatod. Érvényes: {formatDate(invitation.expires_at).replace(/\.$/, "")}-ig.
|
||||
Bármelyik {apple ? "Google- vagy Apple-fiókoddal" : "Google-fiókoddal"} elfogadhatod. Érvényes: {formatDate(invitation.expires_at).replace(/\.$/, "")}-ig.
|
||||
</p>
|
||||
</div>
|
||||
);
|
||||
@@ -83,6 +84,8 @@ export default async function LoginPage({ searchParams }: { searchParams: Promis
|
||||
inviteToken ? loadInvitation(inviteToken) : Promise.resolve(null),
|
||||
]);
|
||||
const clientId = config?.google_login.enabled ? config.google_login.client_id : null;
|
||||
const appleId = config?.apple_login?.enabled ? config.apple_login.client_id : null;
|
||||
const pendingInvite = invitation?.status === "pending" ? inviteToken : null;
|
||||
const inviteOnly = config?.signup_mode === "invite";
|
||||
|
||||
return (
|
||||
@@ -107,17 +110,16 @@ export default async function LoginPage({ searchParams }: { searchParams: Promis
|
||||
<h1 style={{ fontSize: 44 }}>{rawToken ? "Meghívó" : "Belépés"}</h1>
|
||||
<p className="muted">{rawToken ? "Lépj be, és már kezdheted is." : "Üdv újra! Lépj be a fiókodba."}</p>
|
||||
</div>
|
||||
{rawToken && <InvitationCard invitation={inviteToken ? invitation : null} />}
|
||||
{rawToken && <InvitationCard invitation={inviteToken ? invitation : null} apple={appleId !== null} />}
|
||||
{config === null ? (
|
||||
<p className="msg msg-error" role="alert">
|
||||
A szerver most nem érhető el. Próbáld újra egy kicsit később.
|
||||
</p>
|
||||
) : clientId ? (
|
||||
<GoogleLogin
|
||||
clientId={clientId}
|
||||
target={target}
|
||||
inviteToken={invitation?.status === "pending" ? inviteToken : null}
|
||||
/>
|
||||
<div className="field" style={{ gap: 12 }}>
|
||||
<GoogleLogin clientId={clientId} target={target} inviteToken={pendingInvite} />
|
||||
{appleId && <AppleLogin clientId={appleId} target={target} inviteToken={pendingInvite} />}
|
||||
</div>
|
||||
) : (
|
||||
<p className="msg msg-error" role="alert">
|
||||
A Google-belépés még nincs beállítva (a backend <code>GOOGLE_CLIENT_IDS</code> változója üres).
|
||||
|
||||
@@ -210,6 +210,11 @@ td.num { font-variant-numeric: tabular-nums; white-space: nowrap; }
|
||||
.social-login:hover .btn-social { border-color: #5a6790; background: rgba(255, 255, 255, 0.03); }
|
||||
.social-login:focus-within .btn-social { outline: 2px solid var(--gold); outline-offset: 2px; }
|
||||
.social-login[data-ready="false"] .btn-social { opacity: 0.6; }
|
||||
/* Sign in with Apple: Apple's white button style. */
|
||||
.btn-apple { background: #fff; border-color: #fff; color: #000; cursor: pointer; }
|
||||
.btn-apple:hover:not(:disabled) { background: #e8e8ed; border-color: #e8e8ed; }
|
||||
.btn-apple:focus-visible { outline: 2px solid var(--gold); outline-offset: 2px; }
|
||||
.btn-apple:disabled { opacity: 0.6; cursor: default; }
|
||||
.gsi-overlay {
|
||||
position: absolute; inset: 0; display: flex; align-items: center; justify-content: center;
|
||||
opacity: 0.001; overflow: hidden; cursor: pointer;
|
||||
|
||||
@@ -12,7 +12,7 @@ export const metadata: Metadata = {
|
||||
|
||||
const DATA: [string, string, string][] = [
|
||||
[
|
||||
"Your Google account's name, e-mail address and ID (passed on by Google when you sign in)",
|
||||
"Your Google or Apple account's name, e-mail address and ID (passed on by Google or Apple when you sign in)",
|
||||
"Creating your account, signing you in, contacting you",
|
||||
"Performance of a contract (GDPR Art. 6(1)(b))",
|
||||
],
|
||||
@@ -168,6 +168,13 @@ export default async function PrivacyPolicyPage() {
|
||||
</a>
|
||||
, including the Limited Use requirements.
|
||||
</p>
|
||||
<p>
|
||||
<strong>Signing in with Apple:</strong> if you choose “Sign in with Apple”, Apple passes us your account's
|
||||
unique ID and your e-mail address, and your name the first time. If you hide your address, we get an Apple
|
||||
relay address (<code>…@privaterelay.appleid.com</code>) and Apple forwards our e-mails to you. We use these
|
||||
for the same purposes and in the same way as the Google data. You can revoke access in your Apple ID settings
|
||||
(Sign-In and Security › Sign in with Apple).
|
||||
</p>
|
||||
</section>
|
||||
|
||||
<section>
|
||||
|
||||
@@ -94,6 +94,8 @@ export interface Question {
|
||||
|
||||
export interface PublicConfig {
|
||||
google_login: { enabled: boolean; client_id: string | null };
|
||||
/** Sign in with Apple; `client_id` is the Services ID. */
|
||||
apple_login?: { enabled: boolean; client_id: string | null };
|
||||
locales: string[];
|
||||
password_login: boolean;
|
||||
password_min_length: number;
|
||||
|
||||
@@ -54,7 +54,7 @@ async fn main() -> anyhow::Result<()> {
|
||||
if std::env::args().nth(1).as_deref() == Some("healthcheck") {
|
||||
return service_kit::healthcheck(addr);
|
||||
}
|
||||
service_kit::init_logging("horoscope-api");
|
||||
let _log = service_kit::init_logging("horoscope-api");
|
||||
let state = Arc::new(tokio::task::spawn_blocking(load_state).await??);
|
||||
let app = routes::router(state);
|
||||
let listener = tokio::net::TcpListener::bind(addr).await.with_context(|| format!("binding {addr}"))?;
|
||||
|
||||
@@ -9,8 +9,7 @@ use axum::{Json, Router};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::{Value, json};
|
||||
use tower_http::cors::{AllowOrigin, Any, CorsLayer};
|
||||
use tower_http::trace::{DefaultMakeSpan, DefaultOnResponse, TraceLayer};
|
||||
use tracing::Level;
|
||||
use tower_http::trace::TraceLayer;
|
||||
|
||||
use crate::AppState;
|
||||
use crate::error::ApiError;
|
||||
@@ -22,6 +21,7 @@ type AppResult<T> = Result<Json<T>, ApiError>;
|
||||
|
||||
pub fn router(state: Arc<AppState>) -> Router {
|
||||
Router::new()
|
||||
.route("/healthz", get(health))
|
||||
.route("/v1/info", get(info))
|
||||
.route("/v1/countries", get(countries))
|
||||
.route("/v1/places", get(places))
|
||||
@@ -30,13 +30,8 @@ pub fn router(state: Arc<AppState>) -> Router {
|
||||
.route("/v1/synastry", post(synastry_chart))
|
||||
.route("/v1/forecast", post(forecast_year))
|
||||
.layer(cors())
|
||||
.layer(
|
||||
TraceLayer::new_for_http()
|
||||
.make_span_with(DefaultMakeSpan::new().level(Level::INFO))
|
||||
.on_response(DefaultOnResponse::new().level(Level::INFO)),
|
||||
)
|
||||
// After the layers: the Docker health check (every 30 s) stays out of the log.
|
||||
.route("/healthz", get(health))
|
||||
// The request log: masked paths, health checks only when they fail.
|
||||
.layer(TraceLayer::new_for_http().make_span_with(service_kit::RequestLog).on_response(service_kit::RequestLog))
|
||||
.with_state(state)
|
||||
}
|
||||
|
||||
|
||||
@@ -611,7 +611,7 @@ impl Analyzer {
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn run(analyzer: Arc<Analyzer>, poll: Duration, stop: watch::Receiver<bool>) {
|
||||
pub async fn run(analyzer: Arc<Analyzer>, poll: Duration, drain: Duration, stop: watch::Receiver<bool>) {
|
||||
let quick = Arc::new(Semaphore::new(analyzer.lanes.quick));
|
||||
let slow = Arc::new(Semaphore::new(analyzer.lanes.slow));
|
||||
let mut tasks = tokio::task::JoinSet::new();
|
||||
@@ -662,8 +662,12 @@ pub async fn run(analyzer: Arc<Analyzer>, poll: Duration, stop: watch::Receiver<
|
||||
() = crate::stopped(stop.clone()) => break,
|
||||
}
|
||||
}
|
||||
// Give running analyses a moment, then hand the rest back to the queue.
|
||||
let _ = tokio::time::timeout(Duration::from_secs(10), async { while tasks.join_next().await.is_some() {} }).await;
|
||||
// Let running analyses finish within the drain time, then hand the rest
|
||||
// back to the queue (without counting the attempt).
|
||||
if !tasks.is_empty() {
|
||||
tracing::info!(running = tasks.len(), drain_secs = drain.as_secs(), "waiting for running analyses");
|
||||
}
|
||||
let _ = tokio::time::timeout(drain, async { while tasks.join_next().await.is_some() {} }).await;
|
||||
tasks.abort_all();
|
||||
analyzer.release_running().await;
|
||||
}
|
||||
|
||||
@@ -52,6 +52,11 @@ pub struct Config {
|
||||
pub mail_from: Mailbox,
|
||||
/// Fallback polling interval; new e-mails are picked up at once via LISTEN/NOTIFY.
|
||||
pub poll_interval: Duration,
|
||||
/// On a stop (a deploy): how long running work may still finish, taking
|
||||
/// nothing new (`SHUTDOWN_DRAIN_SECS`, default 20); analyses not done by
|
||||
/// then go back to the queue. Keep it below the container's stop grace
|
||||
/// period (`stop_grace_period` in compose, Docker's default is 10 s).
|
||||
pub shutdown_drain: Duration,
|
||||
/// After this many failed attempts an e-mail is marked as failed.
|
||||
pub max_email_attempts: i32,
|
||||
/// Unset: analyses stay pending.
|
||||
@@ -107,6 +112,7 @@ impl Config {
|
||||
smtp_about,
|
||||
mail_from: mail_from.parse().with_context(|| format!("invalid MAIL_FROM '{mail_from}'"))?,
|
||||
poll_interval: Duration::from_secs(parsed("POLL_INTERVAL_SECS", 30)?),
|
||||
shutdown_drain: Duration::from_secs(parsed("SHUTDOWN_DRAIN_SECS", 20)?),
|
||||
max_email_attempts: parsed("MAX_EMAIL_ATTEMPTS", 8)?,
|
||||
// The lower-case name is accepted too (as written in some secrets files).
|
||||
openrouter_api_key: var("OPENROUTER_API_KEY").or_else(|| var("openrouter_api_key")),
|
||||
|
||||
@@ -84,12 +84,12 @@ async fn main() -> anyhow::Result<()> {
|
||||
match std::env::args().nth(1).as_deref() {
|
||||
Some("healthcheck") => return service_kit::healthcheck(addr),
|
||||
Some("compare-models") => {
|
||||
service_kit::init_logging("worker");
|
||||
service_kit::init_console_logging();
|
||||
return compare::main(std::env::args().skip(2).collect()).await;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
service_kit::init_logging("worker");
|
||||
let _log = service_kit::init_logging("worker");
|
||||
let config = Config::from_env()?;
|
||||
let pool = db::connect(&config.database_url).await.context("connecting to the database")?;
|
||||
db::migrate(&pool).await.context("running database migrations")?;
|
||||
@@ -125,7 +125,12 @@ async fn main() -> anyhow::Result<()> {
|
||||
} else {
|
||||
let analyzer = analysis::Analyzer::new(pool.clone(), llm, config.max_analysis_attempts, lanes);
|
||||
tracing::info!(quick = lanes.quick, slow = lanes.slow, "analyses enabled");
|
||||
jobs.spawn(analysis::run(Arc::new(analyzer), config.poll_interval, stop.clone()));
|
||||
jobs.spawn(analysis::run(
|
||||
Arc::new(analyzer),
|
||||
config.poll_interval,
|
||||
config.shutdown_drain,
|
||||
stop.clone(),
|
||||
));
|
||||
}
|
||||
}
|
||||
None => tracing::warn!("OPENROUTER_API_KEY is not set: analyses stay pending"),
|
||||
@@ -158,10 +163,16 @@ async fn main() -> anyhow::Result<()> {
|
||||
() = service_kit::shutdown_signal() => {}
|
||||
}
|
||||
let _ = stop_tx.send(true);
|
||||
// Let jobs finish the batch they are working on.
|
||||
let finished = tokio::time::timeout(Duration::from_secs(30), async { while jobs.join_next().await.is_some() {} });
|
||||
// Nothing new is taken; running work finishes (analyses hand back what is
|
||||
// not done within the drain time, a few seconds before this gives up).
|
||||
tracing::info!(drain_secs = config.shutdown_drain.as_secs(), "stopping: letting running work finish");
|
||||
let finished = tokio::time::timeout(config.shutdown_drain + Duration::from_secs(5), async {
|
||||
while jobs.join_next().await.is_some() {}
|
||||
});
|
||||
if finished.await.is_err() {
|
||||
tracing::warn!("jobs did not stop in time");
|
||||
} else {
|
||||
tracing::info!("all work finished");
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -928,6 +928,49 @@ mod analyses {
|
||||
assert!(!user.contains("Szeged") && !user.contains("Pécs"));
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn a_stop_lets_running_analyses_finish(db: PgPool) {
|
||||
let s = setup(&db).await;
|
||||
let id = request_analysis(&db, &s).await;
|
||||
// A model that takes a while to answer.
|
||||
let body = reply(&content(Kind::Natal)).1;
|
||||
let app = axum::Router::new().route(
|
||||
"/chat/completions",
|
||||
axum::routing::post(move || {
|
||||
let body = body.clone();
|
||||
async move {
|
||||
tokio::time::sleep(std::time::Duration::from_millis(1500)).await;
|
||||
Json(body)
|
||||
}
|
||||
}),
|
||||
);
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let url = format!("http://{}", listener.local_addr().unwrap());
|
||||
tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
|
||||
let a = std::sync::Arc::new(analyzer(&db, &url));
|
||||
let (stop_tx, stop) = tokio::sync::watch::channel(false);
|
||||
let drain = std::time::Duration::from_secs(10);
|
||||
let run = tokio::spawn(crate::analysis::run(a, std::time::Duration::from_secs(30), drain, stop));
|
||||
let status = || async {
|
||||
sqlx::query_scalar::<_, String>("SELECT status FROM analyses WHERE id = $1")
|
||||
.bind(id)
|
||||
.fetch_one(&db)
|
||||
.await
|
||||
.unwrap()
|
||||
};
|
||||
for _ in 0..60 {
|
||||
if status().await == "running" {
|
||||
break;
|
||||
}
|
||||
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
|
||||
}
|
||||
assert_eq!(status().await, "running");
|
||||
// A deploy stops the worker while the model is still writing.
|
||||
stop_tx.send(true).unwrap();
|
||||
run.await.unwrap();
|
||||
assert_eq!(status().await, "done");
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn tarot_readings_are_written_in_the_quick_lane_and_refunded_on_failure(db: PgPool) {
|
||||
let s = setup(&db).await;
|
||||
|
||||
Reference in New Issue
Block a user