114 lines
3.5 KiB
Rust
114 lines
3.5 KiB
Rust
mod config;
|
|
mod factory;
|
|
|
|
use activitypub_base::{
|
|
followers_handler::{followers_handler, following_handler},
|
|
inbox::inbox_handler,
|
|
nodeinfo::{nodeinfo_handler, nodeinfo_well_known_handler},
|
|
outbox::outbox_handler,
|
|
webfinger::webfinger_handler,
|
|
};
|
|
use std::net::SocketAddr;
|
|
use std::sync::Arc;
|
|
use tower_http::cors::{AllowOrigin, CorsLayer};
|
|
use tracing_subscriber::EnvFilter;
|
|
|
|
#[tokio::main]
|
|
async fn main() {
|
|
let cfg = config::Config::from_env();
|
|
|
|
tracing_subscriber::fmt()
|
|
.with_env_filter(EnvFilter::from_default_env())
|
|
.init();
|
|
|
|
let infra = factory::build(&cfg).await;
|
|
|
|
// CORS
|
|
let cors = if cfg.cors_origins.trim() == "*" {
|
|
CorsLayer::permissive()
|
|
} else {
|
|
let origins: Vec<http::HeaderValue> = cfg
|
|
.cors_origins
|
|
.split(',')
|
|
.map(|o| o.trim())
|
|
.filter_map(|o| o.parse().ok())
|
|
.collect();
|
|
CorsLayer::new()
|
|
.allow_origin(AllowOrigin::list(origins))
|
|
.allow_methods(tower_http::cors::Any)
|
|
.allow_headers(tower_http::cors::Any)
|
|
};
|
|
|
|
let ap_router = axum::Router::new()
|
|
.route(
|
|
"/.well-known/webfinger",
|
|
axum::routing::get(webfinger_handler),
|
|
)
|
|
.route(
|
|
"/.well-known/nodeinfo",
|
|
axum::routing::get(nodeinfo_well_known_handler),
|
|
)
|
|
.route("/nodeinfo/2.0", axum::routing::get(nodeinfo_handler))
|
|
.route(
|
|
"/users/{username}/inbox",
|
|
axum::routing::post(inbox_handler),
|
|
)
|
|
.route(
|
|
"/users/{username}/outbox",
|
|
axum::routing::get(outbox_handler),
|
|
)
|
|
.route(
|
|
"/users/{username}/followers",
|
|
axum::routing::get(followers_handler),
|
|
)
|
|
.route(
|
|
"/users/{username}/following",
|
|
axum::routing::get(following_handler),
|
|
)
|
|
.layer(infra.ap_service.federation_config().middleware());
|
|
|
|
let base = presentation::routes::router()
|
|
.merge(ap_router)
|
|
.with_state(infra.state)
|
|
.layer(cors);
|
|
|
|
let addr = format!("{}:{}", cfg.host, cfg.port);
|
|
tracing::info!("Listening on {addr}");
|
|
let listener = tokio::net::TcpListener::bind(&addr).await.unwrap();
|
|
|
|
if let Some(rate_limit) = cfg.rate_limit {
|
|
use tower_governor::{governor::GovernorConfigBuilder, GovernorLayer}; // crate: tower_governor
|
|
|
|
// per_millisecond sets the token replenishment interval.
|
|
// rate_limit = max requests/minute => replenish every (60000 / rate_limit) ms.
|
|
let ms = (60_000u64).saturating_div(rate_limit as u64).max(1);
|
|
let governor_conf = Arc::new(
|
|
GovernorConfigBuilder::default()
|
|
.per_millisecond(ms)
|
|
.burst_size(rate_limit)
|
|
.use_headers()
|
|
.finish()
|
|
.expect("valid rate limit config"),
|
|
);
|
|
|
|
let limiter = governor_conf.limiter().clone();
|
|
tokio::spawn(async move {
|
|
let mut interval = tokio::time::interval(std::time::Duration::from_secs(60));
|
|
loop {
|
|
interval.tick().await;
|
|
limiter.retain_recent();
|
|
}
|
|
});
|
|
|
|
let app = base.layer(GovernorLayer::new(governor_conf));
|
|
axum::serve(
|
|
listener,
|
|
app.into_make_service_with_connect_info::<SocketAddr>(),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
} else {
|
|
axum::serve(listener, base).await.unwrap();
|
|
}
|
|
}
|