A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
// SPDX-License-Identifier: AGPL-3.0-or-later
use crate::{
byte_budget::ByteBudget,
config::Config,
constants,
http_client::{self, HTTPClientOptions},
image_transform::AnimationLimits,
media_limits::MediaLimits,
metrics,
nsfw::NSFWClient,
response_body_limit::RESPONSE_BODY_TRANSPORT_CHUNK_BYTES_MAX,
server::{
attachment_signature::WouldDenyLog,
external::{ExternalHintCache, new_external_hint_cache},
transform::TransformRuntime,
},
storage::Store,
};
use std::{num::NonZeroU64, sync::Arc};
pub(in crate::server) struct AppState {
pub(in crate::server) cfg: Config,
pub(in crate::server) metrics: Arc<metrics::Metrics>,
pub(in crate::server) store: Store,
pub(in crate::server) media: MediaRuntime,
pub(in crate::server) signature_log: WouldDenyLog,
}
pub(in crate::server) struct MediaRuntime {
nsfw: NSFWClient,
external_client: http_client::HttpClient,
external_buffer_bytes: ByteBudget,
stored_buffer_bytes: ByteBudget,
external_hints: ExternalHintCache,
transforms: TransformRuntime,
}
impl AppState {
pub(in crate::server) fn try_new(cfg: Config) -> anyhow::Result<Self> {
let metrics = Arc::new(metrics::Metrics::new());
let socket_io_timeout =
NonZeroU64::new(cfg.socket_io_timeout_ms).unwrap_or(NonZeroU64::MIN);
let store = Store::try_new(cfg.clone(), metrics.storage(), metrics.http_client())?;
let external_client = http_client::build(
HTTPClientOptions::external(socket_io_timeout),
metrics.http_client(),
)?;
let nsfw = NSFWClient::new(
&cfg.media.nsfw_service_endpoint,
cfg.media.nsfw_threshold,
metrics.nsfw(),
)?;
let media = MediaRuntime::new(&cfg, &metrics, nsfw, external_client)?;
Ok(Self {
cfg,
metrics,
store,
media,
signature_log: WouldDenyLog::new(),
})
}
#[cfg(test)]
pub(in crate::server) fn for_tests(cfg: Config) -> Self {
let metrics = Arc::new(metrics::Metrics::new());
let store = Store::new(cfg.clone(), metrics.storage(), metrics.http_client());
let external_client = http_client::build_default(metrics.http_client());
let media = MediaRuntime::new(&cfg, &metrics, NSFWClient::disabled(), external_client)
.expect("test media runtime limits are valid");
Self {
cfg,
metrics,
store,
media,
signature_log: WouldDenyLog::new(),
}
}
}
impl MediaRuntime {
fn new(
cfg: &Config,
metrics: &Arc<metrics::Metrics>,
nsfw: NSFWClient,
external_client: http_client::HttpClient,
) -> anyhow::Result<Self> {
Ok(Self {
nsfw,
external_client,
external_buffer_bytes: ByteBudget::new(buffered_input_budget_bytes(cfg)),
stored_buffer_bytes: ByteBudget::new(buffered_input_budget_bytes(cfg)),
external_hints: new_external_hint_cache(cfg),
transforms: TransformRuntime::new(cfg, metrics)?,
})
}
pub(in crate::server) fn limits(&self) -> MediaLimits {
self.transforms.limits()
}
pub(in crate::server) fn animation(&self) -> AnimationLimits {
self.transforms.animation()
}
pub(in crate::server) fn nsfw(&self) -> &NSFWClient {
&self.nsfw
}
pub(in crate::server) fn external_client(&self) -> &http_client::HttpClient {
&self.external_client
}
pub(in crate::server) fn external_buffer_bytes(&self) -> &ByteBudget {
&self.external_buffer_bytes
}
pub(in crate::server) fn stored_buffer_bytes(&self) -> &ByteBudget {
&self.stored_buffer_bytes
}
pub(in crate::server) fn external_hints(&self) -> &ExternalHintCache {
&self.external_hints
}
pub(in crate::server) fn transforms(&self) -> &TransformRuntime {
&self.transforms
}
}
fn buffered_input_budget_bytes(cfg: &Config) -> usize {
let concurrent_inputs = cfg
.media
.max_native_transforms
.saturating_add(cfg.media.worker_queue_capacity)
.max(1);
constants::MAX_MEDIA_PROXY_BYTES
.saturating_mul(concurrent_inputs)
.saturating_add(RESPONSE_BODY_TRANSPORT_CHUNK_BYTES_MAX)
}