Files
continuwuity/src/service/services.rs
T

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

266 lines
7.4 KiB
Rust
Raw Normal View History

2024-07-18 06:37:47 +00:00
use std::{
2025-08-22 20:15:54 +05:00
ops::Deref,
sync::{Arc, OnceLock},
2024-07-18 06:37:47 +00:00
};
2024-05-09 15:59:08 -07:00
2025-08-22 20:15:54 +05:00
use futures::{StreamExt, TryStreamExt};
2024-07-13 07:01:45 +00:00
use tokio::sync::Mutex;
2025-08-22 20:15:54 +05:00
use tuwunel_core::{Result, Server, debug, debug_info, err, info, trace};
2025-04-22 01:41:02 +00:00
use tuwunel_database::Database;
2024-05-09 15:59:08 -07:00
use crate::{
2025-08-25 19:12:27 +05:00
account_data, admin, appservice, client, config, deactivate, emergency, federation, globals,
key_backups,
2024-07-13 07:01:45 +00:00
manager::Manager,
2025-08-25 19:12:27 +05:00
media, membership, presence, pusher, resolver, rooms, sending, server_keys,
2025-08-22 20:15:54 +05:00
service::{Args, Service},
2025-04-13 07:12:54 +00:00
sync, transaction_ids, uiaa, users,
2024-05-09 15:59:08 -07:00
};
pub struct Services {
2024-07-04 03:26:19 +00:00
pub account_data: Arc<account_data::Service>,
2024-05-09 15:59:08 -07:00
pub admin: Arc<admin::Service>,
2024-07-18 06:37:47 +00:00
pub appservice: Arc<appservice::Service>,
2025-01-28 20:55:28 +00:00
pub config: Arc<config::Service>,
2024-07-18 06:37:47 +00:00
pub client: Arc<client::Service>,
pub emergency: Arc<emergency::Service>,
pub globals: Arc<globals::Service>,
2024-07-04 03:26:19 +00:00
pub key_backups: Arc<key_backups::Service>,
pub media: Arc<media::Service>,
2024-07-18 06:37:47 +00:00
pub presence: Arc<presence::Service>,
pub pusher: Arc<pusher::Service>,
pub resolver: Arc<resolver::Service>,
2025-08-22 20:15:54 +05:00
pub alias: Arc<rooms::alias::Service>,
pub auth_chain: Arc<rooms::auth_chain::Service>,
2025-08-22 20:21:05 +05:00
pub delete: Arc<rooms::delete::Service>,
2025-08-22 20:15:54 +05:00
pub directory: Arc<rooms::directory::Service>,
pub event_handler: Arc<rooms::event_handler::Service>,
pub lazy_loading: Arc<rooms::lazy_loading::Service>,
pub metadata: Arc<rooms::metadata::Service>,
pub pdu_metadata: Arc<rooms::pdu_metadata::Service>,
pub read_receipt: Arc<rooms::read_receipt::Service>,
pub search: Arc<rooms::search::Service>,
pub short: Arc<rooms::short::Service>,
pub spaces: Arc<rooms::spaces::Service>,
pub state: Arc<rooms::state::Service>,
pub state_accessor: Arc<rooms::state_accessor::Service>,
pub state_cache: Arc<rooms::state_cache::Service>,
pub state_compressor: Arc<rooms::state_compressor::Service>,
pub threads: Arc<rooms::threads::Service>,
pub timeline: Arc<rooms::timeline::Service>,
pub typing: Arc<rooms::typing::Service>,
pub user: Arc<rooms::user::Service>,
pub federation: Arc<federation::Service>,
2024-05-09 15:59:08 -07:00
pub sending: Arc<sending::Service>,
pub server_keys: Arc<server_keys::Service>,
2024-08-08 17:18:30 +00:00
pub sync: Arc<sync::Service>,
2024-07-18 06:37:47 +00:00
pub transaction_ids: Arc<transaction_ids::Service>,
pub uiaa: Arc<uiaa::Service>,
pub users: Arc<users::Service>,
2025-08-25 19:12:27 +05:00
pub membership: Arc<membership::Service>,
pub deactivate: Arc<deactivate::Service>,
2024-07-04 03:26:19 +00:00
2024-07-13 07:01:45 +00:00
manager: Mutex<Option<Arc<Manager>>>,
2024-05-09 15:59:08 -07:00
pub server: Arc<Server>,
2024-06-28 22:51:39 +00:00
pub db: Arc<Database>,
2024-05-09 15:59:08 -07:00
}
2025-08-22 20:15:54 +05:00
pub struct OnceServices {
lock: OnceLock<Arc<Services>>,
}
impl OnceServices {
pub fn get_services(&self) -> &Arc<Services> {
self.lock
.get()
.expect("services must be initialized")
}
}
impl Deref for OnceServices {
type Target = Arc<Services>;
fn deref(&self) -> &Self::Target { self.get_services() }
}
2024-05-09 15:59:08 -07:00
impl Services {
#[allow(clippy::cognitive_complexity)]
2024-07-27 07:17:07 +00:00
pub async fn build(server: Arc<Server>) -> Result<Arc<Self>> {
let db = Database::open(&server).await?;
2025-08-22 20:15:54 +05:00
let services = Arc::new(OnceServices { lock: OnceLock::new() });
2024-07-04 03:26:19 +00:00
macro_rules! build {
2025-08-22 20:15:54 +05:00
($tyname:ty) => {
<$tyname>::build(Args {
2024-07-18 06:37:47 +00:00
db: &db,
server: &server,
2025-08-22 20:15:54 +05:00
services: &services,
})?
};
2024-07-04 03:26:19 +00:00
}
2025-08-22 20:15:54 +05:00
let res = Arc::new(Self {
2024-07-18 06:37:47 +00:00
account_data: build!(account_data::Service),
admin: build!(admin::Service),
appservice: build!(appservice::Service),
2024-07-16 22:00:54 +00:00
resolver: build!(resolver::Service),
2024-07-16 22:29:42 +00:00
client: build!(client::Service),
2025-01-28 20:55:28 +00:00
config: build!(config::Service),
2024-07-18 06:37:47 +00:00
emergency: build!(emergency::Service),
globals: build!(globals::Service),
key_backups: build!(key_backups::Service),
media: build!(media::Service),
presence: build!(presence::Service),
pusher: build!(pusher::Service),
2025-08-22 20:15:54 +05:00
alias: build!(rooms::alias::Service),
auth_chain: build!(rooms::auth_chain::Service),
2025-08-22 20:21:05 +05:00
delete: build!(rooms::delete::Service),
2025-08-22 20:15:54 +05:00
directory: build!(rooms::directory::Service),
event_handler: build!(rooms::event_handler::Service),
lazy_loading: build!(rooms::lazy_loading::Service),
metadata: build!(rooms::metadata::Service),
pdu_metadata: build!(rooms::pdu_metadata::Service),
read_receipt: build!(rooms::read_receipt::Service),
search: build!(rooms::search::Service),
short: build!(rooms::short::Service),
spaces: build!(rooms::spaces::Service),
state: build!(rooms::state::Service),
state_accessor: build!(rooms::state_accessor::Service),
state_cache: build!(rooms::state_cache::Service),
state_compressor: build!(rooms::state_compressor::Service),
threads: build!(rooms::threads::Service),
timeline: build!(rooms::timeline::Service),
typing: build!(rooms::typing::Service),
user: build!(rooms::user::Service),
federation: build!(federation::Service),
2024-07-18 06:37:47 +00:00
sending: build!(sending::Service),
server_keys: build!(server_keys::Service),
2024-08-08 17:18:30 +00:00
sync: build!(sync::Service),
2024-07-04 03:26:19 +00:00
transaction_ids: build!(transaction_ids::Service),
uiaa: build!(uiaa::Service),
2024-07-18 06:37:47 +00:00
users: build!(users::Service),
2025-08-25 19:12:27 +05:00
membership: build!(membership::Service),
deactivate: build!(deactivate::Service),
2024-07-18 06:37:47 +00:00
manager: Mutex::new(None),
2024-05-09 15:59:08 -07:00
server,
db,
2025-08-22 20:15:54 +05:00
});
services
.lock
.set(res.clone())
.map_err(|_| err!("couldn't set services lock"))
.unwrap();
Ok(res)
2024-05-09 15:59:08 -07:00
}
2024-07-27 07:17:07 +00:00
pub async fn start(self: &Arc<Self>) -> Result<Arc<Self>> {
debug_info!("Starting services...");
2024-11-01 22:16:14 +00:00
super::migrations::migrations(self).await?;
2024-07-13 07:01:45 +00:00
self.manager
.lock()
.await
.insert(Manager::new(self))
.clone()
.start()
.await?;
debug_info!("Services startup complete.");
2025-07-08 12:27:29 +00:00
2024-07-27 07:17:07 +00:00
Ok(Arc::clone(self))
}
2024-07-27 07:17:07 +00:00
pub async fn stop(&self) {
info!("Shutting down services...");
2024-07-13 08:07:49 +00:00
2025-08-24 02:30:47 +05:00
self.interrupt().await;
2024-07-13 07:01:45 +00:00
if let Some(manager) = self.manager.lock().await.as_ref() {
manager.stop().await;
}
debug_info!("Services shutdown complete.");
}
2025-07-08 12:08:13 +00:00
pub async fn poll(&self) -> Result {
2024-07-13 07:01:45 +00:00
if let Some(manager) = self.manager.lock().await.as_ref() {
return manager.poll().await;
}
Ok(())
}
2025-08-22 20:21:05 +05:00
pub(crate) fn services(&self) -> [Arc<dyn Service>; 41] {
2025-08-22 20:15:54 +05:00
[
self.account_data.clone(),
self.admin.clone(),
self.appservice.clone(),
self.resolver.clone(),
self.client.clone(),
self.config.clone(),
self.emergency.clone(),
self.globals.clone(),
self.key_backups.clone(),
self.media.clone(),
self.presence.clone(),
self.pusher.clone(),
self.alias.clone(),
self.auth_chain.clone(),
2025-08-22 20:21:05 +05:00
self.delete.clone(),
2025-08-22 20:15:54 +05:00
self.directory.clone(),
self.event_handler.clone(),
self.lazy_loading.clone(),
self.metadata.clone(),
self.pdu_metadata.clone(),
self.read_receipt.clone(),
self.search.clone(),
self.short.clone(),
self.spaces.clone(),
self.state.clone(),
self.state_accessor.clone(),
self.state_cache.clone(),
self.state_compressor.clone(),
self.threads.clone(),
self.timeline.clone(),
self.typing.clone(),
self.user.clone(),
self.federation.clone(),
self.sending.clone(),
self.server_keys.clone(),
self.sync.clone(),
self.transaction_ids.clone(),
self.uiaa.clone(),
self.users.clone(),
2025-08-25 19:12:27 +05:00
self.membership.clone(),
self.deactivate.clone(),
2025-08-22 20:15:54 +05:00
]
}
pub async fn clear_cache(&self) {
2025-08-22 20:15:54 +05:00
futures::stream::iter(self.services())
2025-07-08 11:08:58 +00:00
.for_each(async |service| {
service.clear_cache().await;
})
.await;
}
2024-07-04 03:26:19 +00:00
pub async fn memory_usage(&self) -> Result<String> {
2025-08-22 20:15:54 +05:00
futures::stream::iter(self.services())
.map(Ok)
2025-07-08 11:08:58 +00:00
.try_fold(String::new(), async |mut out, service| {
service.memory_usage(&mut out).await?;
Ok(out)
})
2024-05-09 15:59:08 -07:00
.await
}
2025-08-24 02:30:47 +05:00
async fn interrupt(&self) {
2024-07-04 03:26:19 +00:00
debug!("Interrupting services...");
2025-08-22 20:15:54 +05:00
for service in self.services() {
let name = service.name();
trace!("Interrupting {name}");
2025-08-24 02:30:47 +05:00
service.interrupt().await;
2024-07-04 03:26:19 +00:00
}
2024-05-09 15:59:08 -07:00
}
}