impl crate::Service for Service

Signed-off-by: Jason Volk <jason@zemos.net>

src/service/rooms/alias/mod.rs

@@ -3,9 +3,8 @@ mod remote;
 
 use std::sync::Arc;
 
-use conduit::{Error, Result, Server};
+use conduit::{Error, Result};
 use data::Data;
-use database::Database;
 use ruma::{
 	api::{appservice, client::error::ErrorKind},
 	events::{
@@ -21,13 +20,17 @@ pub struct Service {
 	db: Data,
 }
 
-impl Service {
-	pub fn build(_server: &Arc<Server>, db: &Arc<Database>) -> Result<Self> {
-		Ok(Self {
-			db: Data::new(db),
-		})
+impl crate::Service for Service {
+	fn build(args: crate::Args<'_>) -> Result<Arc<Self>> {
+		Ok(Arc::new(Self {
+			db: Data::new(args.db),
+		}))
 	}
 
+	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
+}
+
+impl Service {
 	#[tracing::instrument(skip(self))]
 	pub fn set_alias(&self, alias: &RoomAliasId, room_id: &RoomId, user_id: &UserId) -> Result<()> {
 		if alias == services().globals.admin_alias && user_id != services().globals.server_user {

src/service/rooms/auth_chain/mod.rs

@@ -5,9 +5,8 @@ use std::{
 	sync::Arc,
 };
 
-use conduit::{debug, error, trace, warn, Error, Result, Server};
+use conduit::{debug, error, trace, warn, Error, Result};
 use data::Data;
-use database::Database;
 use ruma::{api::client::error::ErrorKind, EventId, RoomId};
 
 use crate::services;
@@ -16,13 +15,17 @@ pub struct Service {
 	db: Data,
 }
 
-impl Service {
-	pub fn build(server: &Arc<Server>, db: &Arc<Database>) -> Result<Self> {
-		Ok(Self {
-			db: Data::new(server, db),
-		})
+impl crate::Service for Service {
+	fn build(args: crate::Args<'_>) -> Result<Arc<Self>> {
+		Ok(Arc::new(Self {
+			db: Data::new(args.server, args.db),
+		}))
 	}
 
+	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
+}
+
+impl Service {
 	pub async fn event_ids_iter<'a>(
 		&self, room_id: &RoomId, starting_events_: Vec<Arc<EventId>>,
 	) -> Result<impl Iterator<Item = Arc<EventId>> + 'a> {

src/service/rooms/directory/mod.rs

@@ -2,9 +2,7 @@ mod data;
 
 use std::sync::Arc;
 
-use conduit::Server;
 use data::Data;
-use database::Database;
 use ruma::{OwnedRoomId, RoomId};
 
 use crate::Result;
@@ -13,13 +11,17 @@ pub struct Service {
 	db: Data,
 }
 
-impl Service {
-	pub fn build(_server: &Arc<Server>, db: &Arc<Database>) -> Result<Self> {
-		Ok(Self {
-			db: Data::new(db),
-		})
+impl crate::Service for Service {
+	fn build(args: crate::Args<'_>) -> Result<Arc<Self>> {
+		Ok(Arc::new(Self {
+			db: Data::new(args.db),
+		}))
 	}
 
+	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
+}
+
+impl Service {
 	#[tracing::instrument(skip(self))]
 	pub fn set_public(&self, room_id: &RoomId) -> Result<()> { self.db.set_public(room_id) }
 

src/service/rooms/event_handler/mod.rs

@@ -9,8 +9,7 @@ use std::{
 	time::{Duration, Instant},
 };
 
-use conduit::{debug_error, debug_info, Error, Result, Server};
-use database::Database;
+use conduit::{debug_error, debug_info, Error, Result};
 use futures_util::Future;
 pub use parse_incoming_pdu::parse_incoming_pdu;
 use ruma::{
@@ -45,9 +44,13 @@ type AsyncRecursiveCanonicalJsonVec<'a> =
 type AsyncRecursiveCanonicalJsonResult<'a> =
 	AsyncRecursiveType<'a, Result<(Arc<PduEvent>, BTreeMap<String, CanonicalJsonValue>)>>;
 
-impl Service {
-	pub fn build(_server: &Arc<Server>, _db: &Arc<Database>) -> Result<Self> { Ok(Self {}) }
+impl crate::Service for Service {
+	fn build(_args: crate::Args<'_>) -> Result<Arc<Self>> { Ok(Arc::new(Self {})) }
 
+	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
+}
+
+impl Service {
 	/// When receiving an event one needs to:
 	/// 0. Check the server is in the room
 	/// 1. Skip the PDU if we already know about it
@@ -180,7 +183,7 @@ impl Service {
 						.globals
 						.bad_event_ratelimiter
 						.write()
-						.await
+						.expect("locked")
 						.entry((*prev_id).to_owned())
 					{
 						hash_map::Entry::Vacant(e) => {
@@ -200,7 +203,7 @@ impl Service {
 			.globals
 			.roomid_federationhandletime
 			.write()
-			.await
+			.expect("locked")
 			.insert(room_id.to_owned(), (event_id.to_owned(), start_time));
 
 		let r = self
@@ -211,7 +214,7 @@ impl Service {
 			.globals
 			.roomid_federationhandletime
 			.write()
-			.await
+			.expect("locked")
 			.remove(&room_id.to_owned());
 
 		r
@@ -245,7 +248,7 @@ impl Service {
 			.globals
 			.bad_event_ratelimiter
 			.read()
-			.await
+			.expect("locked")
 			.get(prev_id)
 		{
 			// Exponential backoff
@@ -274,7 +277,7 @@ impl Service {
 				.globals
 				.roomid_federationhandletime
 				.write()
-				.await
+				.expect("locked")
 				.insert(room_id.to_owned(), ((*prev_id).to_owned(), start_time));
 
 			self.upgrade_outlier_to_timeline_pdu(pdu, json, create_event, origin, room_id, pub_key_map)
@@ -284,7 +287,7 @@ impl Service {
 				.globals
 				.roomid_federationhandletime
 				.write()
-				.await
+				.expect("locked")
 				.remove(&room_id.to_owned());
 
 			debug!(
@@ -1043,7 +1046,7 @@ impl Service {
 					.globals
 					.bad_event_ratelimiter
 					.write()
-					.await
+					.expect("locked")
 					.entry(id)
 				{
 					hash_map::Entry::Vacant(e) => {
@@ -1076,7 +1079,7 @@ impl Service {
 						.globals
 						.bad_event_ratelimiter
 						.read()
-						.await
+						.expect("locked")
 						.get(&*next_id)
 					{
 						// Exponential backoff
@@ -1184,7 +1187,7 @@ impl Service {
 						.globals
 						.bad_event_ratelimiter
 						.read()
-						.await
+						.expect("locked")
 						.get(&**next_id)
 					{
 						// Exponential backoff

src/service/rooms/lazy_loading/mod.rs

@@ -2,14 +2,12 @@ mod data;
 
 use std::{
 	collections::{HashMap, HashSet},
-	sync::Arc,
+	fmt::Write,
+	sync::{Arc, Mutex},
 };
 
-use conduit::Server;
 use data::Data;
-use database::Database;
 use ruma::{DeviceId, OwnedDeviceId, OwnedRoomId, OwnedUserId, RoomId, UserId};
-use tokio::sync::Mutex;
 
 use crate::{PduCount, Result};
 
@@ -20,14 +18,27 @@ pub struct Service {
 	pub lazy_load_waiting: Mutex<HashMap<(OwnedUserId, OwnedDeviceId, OwnedRoomId, PduCount), HashSet<OwnedUserId>>>,
 }
 
-impl Service {
-	pub fn build(_server: &Arc<Server>, db: &Arc<Database>) -> Result<Self> {
-		Ok(Self {
-			db: Data::new(db),
+impl crate::Service for Service {
+	fn build(args: crate::Args<'_>) -> Result<Arc<Self>> {
+		Ok(Arc::new(Self {
+			db: Data::new(args.db),
 			lazy_load_waiting: Mutex::new(HashMap::new()),
-		})
+		}))
 	}
 
+	fn memory_usage(&self, out: &mut dyn Write) -> Result<()> {
+		let lazy_load_waiting = self.lazy_load_waiting.lock().expect("locked").len();
+		writeln!(out, "lazy_load_waiting: {lazy_load_waiting}")?;
+
+		Ok(())
+	}
+
+	fn clear_cache(&self) { self.lazy_load_waiting.lock().expect("locked").clear(); }
+
+	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
+}
+
+impl Service {
 	#[tracing::instrument(skip(self))]
 	pub fn lazy_load_was_sent_before(
 		&self, user_id: &UserId, device_id: &DeviceId, room_id: &RoomId, ll_user: &UserId,
@@ -43,7 +54,7 @@ impl Service {
 	) {
 		self.lazy_load_waiting
 			.lock()
-			.await
+			.expect("locked")
 			.insert((user_id.to_owned(), device_id.to_owned(), room_id.to_owned(), count), lazy_load);
 	}
 
@@ -51,7 +62,7 @@ impl Service {
 	pub async fn lazy_load_confirm_delivery(
 		&self, user_id: &UserId, device_id: &DeviceId, room_id: &RoomId, since: PduCount,
 	) -> Result<()> {
-		if let Some(user_ids) = self.lazy_load_waiting.lock().await.remove(&(
+		if let Some(user_ids) = self.lazy_load_waiting.lock().expect("locked").remove(&(
 			user_id.to_owned(),
 			device_id.to_owned(),
 			room_id.to_owned(),

src/service/rooms/metadata/mod.rs

@@ -2,22 +2,25 @@ mod data;
 
 use std::sync::Arc;
 
-use conduit::{Result, Server};
+use conduit::Result;
 use data::Data;
-use database::Database;
 use ruma::{OwnedRoomId, RoomId};
 
 pub struct Service {
 	db: Data,
 }
 
-impl Service {
-	pub fn build(_server: &Arc<Server>, db: &Arc<Database>) -> Result<Self> {
-		Ok(Self {
-			db: Data::new(db),
-		})
+impl crate::Service for Service {
+	fn build(args: crate::Args<'_>) -> Result<Arc<Self>> {
+		Ok(Arc::new(Self {
+			db: Data::new(args.db),
+		}))
 	}
 
+	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
+}
+
+impl Service {
 	/// Checks if a room exists.
 	#[tracing::instrument(skip(self))]
 	pub fn exists(&self, room_id: &RoomId) -> Result<bool> { self.db.exists(room_id) }

src/service/rooms/mod.rs

@@ -19,25 +19,27 @@ pub mod timeline;
 pub mod typing;
 pub mod user;
 
+use std::sync::Arc;
+
 pub struct Service {
-	pub alias: alias::Service,
-	pub auth_chain: auth_chain::Service,
-	pub directory: directory::Service,
-	pub event_handler: event_handler::Service,
-	pub lazy_loading: lazy_loading::Service,
-	pub metadata: metadata::Service,
-	pub outlier: outlier::Service,
-	pub pdu_metadata: pdu_metadata::Service,
-	pub read_receipt: read_receipt::Service,
-	pub search: search::Service,
-	pub short: short::Service,
-	pub state: state::Service,
-	pub state_accessor: state_accessor::Service,
-	pub state_cache: state_cache::Service,
-	pub state_compressor: state_compressor::Service,
-	pub timeline: timeline::Service,
-	pub threads: threads::Service,
-	pub typing: typing::Service,
-	pub spaces: spaces::Service,
-	pub user: user::Service,
+	pub alias: Arc<alias::Service>,
+	pub auth_chain: Arc<auth_chain::Service>,
+	pub directory: Arc<directory::Service>,
+	pub event_handler: Arc<event_handler::Service>,
+	pub lazy_loading: Arc<lazy_loading::Service>,
+	pub metadata: Arc<metadata::Service>,
+	pub outlier: Arc<outlier::Service>,
+	pub pdu_metadata: Arc<pdu_metadata::Service>,
+	pub read_receipt: Arc<read_receipt::Service>,
+	pub search: Arc<search::Service>,
+	pub short: Arc<short::Service>,
+	pub state: Arc<state::Service>,
+	pub state_accessor: Arc<state_accessor::Service>,
+	pub state_cache: Arc<state_cache::Service>,
+	pub state_compressor: Arc<state_compressor::Service>,
+	pub timeline: Arc<timeline::Service>,
+	pub threads: Arc<threads::Service>,
+	pub typing: Arc<typing::Service>,
+	pub spaces: Arc<spaces::Service>,
+	pub user: Arc<user::Service>,
 }

src/service/rooms/outlier/mod.rs

@@ -2,9 +2,8 @@ mod data;
 
 use std::sync::Arc;
 
-use conduit::{Result, Server};
+use conduit::Result;
 use data::Data;
-use database::Database;
 use ruma::{CanonicalJsonObject, EventId};
 
 use crate::PduEvent;
@@ -13,13 +12,17 @@ pub struct Service {
 	db: Data,
 }
 
-impl Service {
-	pub fn build(_server: &Arc<Server>, db: &Arc<Database>) -> Result<Self> {
-		Ok(Self {
-			db: Data::new(db),
-		})
+impl crate::Service for Service {
+	fn build(args: crate::Args<'_>) -> Result<Arc<Self>> {
+		Ok(Arc::new(Self {
+			db: Data::new(args.db),
+		}))
 	}
 
+	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
+}
+
+impl Service {
 	/// Returns the pdu from the outlier tree.
 	pub fn get_outlier_pdu_json(&self, event_id: &EventId) -> Result<Option<CanonicalJsonObject>> {
 		self.db.get_outlier_pdu_json(event_id)

src/service/rooms/pdu_metadata/mod.rs

@@ -2,9 +2,8 @@ mod data;
 
 use std::sync::Arc;
 
-use conduit::{Result, Server};
+use conduit::Result;
 use data::Data;
-use database::Database;
 use ruma::{
 	api::{client::relations::get_relating_events, Direction},
 	events::{relation::RelationType, TimelineEventType},
@@ -28,13 +27,17 @@ struct ExtractRelatesToEventId {
 	relates_to: ExtractRelType,
 }
 
-impl Service {
-	pub fn build(_server: &Arc<Server>, db: &Arc<Database>) -> Result<Self> {
-		Ok(Self {
-			db: Data::new(db),
-		})
+impl crate::Service for Service {
+	fn build(args: crate::Args<'_>) -> Result<Arc<Self>> {
+		Ok(Arc::new(Self {
+			db: Data::new(args.db),
+		}))
 	}
 
+	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
+}
+
+impl Service {
 	#[tracing::instrument(skip(self, from, to))]
 	pub fn add_relation(&self, from: PduCount, to: PduCount) -> Result<()> {
 		match (from, to) {

src/service/rooms/read_receipt/mod.rs

@@ -2,9 +2,8 @@ mod data;
 
 use std::sync::Arc;
 
-use conduit::{Result, Server};
+use conduit::Result;
 use data::Data;
-use database::Database;
 use ruma::{events::receipt::ReceiptEvent, serde::Raw, OwnedUserId, RoomId, UserId};
 
 use crate::services;
@@ -13,13 +12,17 @@ pub struct Service {
 	db: Data,
 }
 
-impl Service {
-	pub fn build(_server: &Arc<Server>, db: &Arc<Database>) -> Result<Self> {
-		Ok(Self {
-			db: Data::new(db),
-		})
+impl crate::Service for Service {
+	fn build(args: crate::Args<'_>) -> Result<Arc<Self>> {
+		Ok(Arc::new(Self {
+			db: Data::new(args.db),
+		}))
 	}
 
+	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
+}
+
+impl Service {
 	/// Replaces the previous read receipt.
 	pub fn readreceipt_update(&self, user_id: &UserId, room_id: &RoomId, event: &ReceiptEvent) -> Result<()> {
 		self.db.readreceipt_update(user_id, room_id, event)?;

src/service/rooms/search/mod.rs

@@ -2,22 +2,25 @@ mod data;
 
 use std::sync::Arc;
 
-use conduit::{Result, Server};
+use conduit::Result;
 use data::Data;
-use database::Database;
 use ruma::RoomId;
 
 pub struct Service {
 	db: Data,
 }
 
-impl Service {
-	pub fn build(_server: &Arc<Server>, db: &Arc<Database>) -> Result<Self> {
-		Ok(Self {
-			db: Data::new(db),
-		})
+impl crate::Service for Service {
+	fn build(args: crate::Args<'_>) -> Result<Arc<Self>> {
+		Ok(Arc::new(Self {
+			db: Data::new(args.db),
+		}))
 	}
 
+	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
+}
+
+impl Service {
 	#[tracing::instrument(skip(self))]
 	pub fn index_pdu(&self, shortroomid: u64, pdu_id: &[u8], message_body: &str) -> Result<()> {
 		self.db.index_pdu(shortroomid, pdu_id, message_body)

src/service/rooms/short/mod.rs

@@ -2,22 +2,25 @@ mod data;
 
 use std::sync::Arc;
 
-use conduit::{Result, Server};
+use conduit::Result;
 use data::Data;
-use database::Database;
 use ruma::{events::StateEventType, EventId, RoomId};
 
 pub struct Service {
 	db: Data,
 }
 
-impl Service {
-	pub fn build(_server: &Arc<Server>, db: &Arc<Database>) -> Result<Self> {
-		Ok(Self {
-			db: Data::new(db),
-		})
+impl crate::Service for Service {
+	fn build(args: crate::Args<'_>) -> Result<Arc<Self>> {
+		Ok(Arc::new(Self {
+			db: Data::new(args.db),
+		}))
 	}
 
+	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
+}
+
+impl Service {
 	pub fn get_or_create_shorteventid(&self, event_id: &EventId) -> Result<u64> {
 		self.db.get_or_create_shorteventid(event_id)
 	}

src/service/rooms/spaces/mod.rs

@@ -7,8 +7,7 @@ use std::{
 	sync::Arc,
 };
 
-use conduit::{debug_info, Server};
-use database::Database;
+use conduit::debug_info;
 use lru_cache::LruCache;
 use ruma::{
 	api::{
@@ -159,17 +158,21 @@ impl From<CachedSpaceHierarchySummary> for SpaceHierarchyRoomsChunk {
 	}
 }
 
-impl Service {
-	pub fn build(server: &Arc<Server>, _db: &Arc<Database>) -> Result<Self> {
-		let config = &server.config;
-		Ok(Self {
+impl crate::Service for Service {
+	fn build(args: crate::Args<'_>) -> Result<Arc<Self>> {
+		let config = &args.server.config;
+		Ok(Arc::new(Self {
 			roomid_spacehierarchy_cache: Mutex::new(LruCache::new(
 				(f64::from(config.roomid_spacehierarchy_cache_capacity) * config.conduit_cache_capacity_modifier)
 					as usize,
 			)),
-		})
+		}))
 	}
 
+	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
+}
+
+impl Service {
 	/// Gets the response for the space hierarchy over federation request
 	///
 	/// Errors if the room does not exist, so a check if the room exists should

src/service/rooms/state/mod.rs

@@ -7,10 +7,9 @@ use std::{
 
 use conduit::{
 	utils::{calculate_hash, mutex_map},
-	warn, Error, Result, Server,
+	warn, Error, Result,
 };
 use data::Data;
-use database::Database;
 use ruma::{
 	api::client::error::ErrorKind,
 	events::{
@@ -29,13 +28,17 @@ pub struct Service {
 	db: Data,
 }
 
-impl Service {
-	pub fn build(_server: &Arc<Server>, db: &Arc<Database>) -> Result<Self> {
-		Ok(Self {
-			db: Data::new(db),
-		})
+impl crate::Service for Service {
+	fn build(args: crate::Args<'_>) -> Result<Arc<Self>> {
+		Ok(Arc::new(Self {
+			db: Data::new(args.db),
+		}))
 	}
 
+	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
+}
+
+impl Service {
 	/// Set the room to the given statehash and update caches.
 	pub async fn force_state(
 		&self,

src/service/rooms/state_accessor/mod.rs

@@ -2,12 +2,12 @@ mod data;
 
 use std::{
 	collections::HashMap,
+	fmt::Write,
 	sync::{Arc, Mutex as StdMutex, Mutex},
 };
 
-use conduit::{error, utils::mutex_map, warn, Error, Result, Server};
+use conduit::{error, utils::mutex_map, warn, Error, Result};
 use data::Data;
-use database::Database;
 use lru_cache::LruCache;
 use ruma::{
 	events::{
@@ -41,20 +41,39 @@ pub struct Service {
 	pub user_visibility_cache: Mutex<LruCache<(OwnedUserId, u64), bool>>,
 }
 
-impl Service {
-	pub fn build(server: &Arc<Server>, db: &Arc<Database>) -> Result<Self> {
-		let config = &server.config;
-		Ok(Self {
-			db: Data::new(db),
+impl crate::Service for Service {
+	fn build(args: crate::Args<'_>) -> Result<Arc<Self>> {
+		let config = &args.server.config;
+		Ok(Arc::new(Self {
+			db: Data::new(args.db),
 			server_visibility_cache: StdMutex::new(LruCache::new(
 				(f64::from(config.server_visibility_cache_capacity) * config.conduit_cache_capacity_modifier) as usize,
 			)),
 			user_visibility_cache: StdMutex::new(LruCache::new(
 				(f64::from(config.user_visibility_cache_capacity) * config.conduit_cache_capacity_modifier) as usize,
 			)),
-		})
+		}))
 	}
 
+	fn memory_usage(&self, out: &mut dyn Write) -> Result<()> {
+		let server_visibility_cache = self.server_visibility_cache.lock().expect("locked").len();
+		writeln!(out, "server_visibility_cache: {server_visibility_cache}")?;
+
+		let user_visibility_cache = self.user_visibility_cache.lock().expect("locked").len();
+		writeln!(out, "user_visibility_cache: {user_visibility_cache}")?;
+
+		Ok(())
+	}
+
+	fn clear_cache(&self) {
+		self.server_visibility_cache.lock().expect("locked").clear();
+		self.user_visibility_cache.lock().expect("locked").clear();
+	}
+
+	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
+}
+
+impl Service {
 	/// Builds a StateMap by iterating over all keys that start
 	/// with state_hash, this gives the full state for the given state_hash.
 	#[tracing::instrument(skip(self))]

src/service/rooms/state_cache/mod.rs

@@ -2,9 +2,8 @@ mod data;
 
 use std::sync::Arc;
 
-use conduit::{error, warn, Error, Result, Server};
+use conduit::{error, warn, Error, Result};
 use data::Data;
-use database::Database;
 use itertools::Itertools;
 use ruma::{
 	events::{
@@ -28,13 +27,17 @@ pub struct Service {
 	db: Data,
 }
 
-impl Service {
-	pub fn build(_server: &Arc<Server>, db: &Arc<Database>) -> Result<Self> {
-		Ok(Self {
-			db: Data::new(db),
-		})
+impl crate::Service for Service {
+	fn build(args: crate::Args<'_>) -> Result<Arc<Self>> {
+		Ok(Arc::new(Self {
+			db: Data::new(args.db),
+		}))
 	}
 
+	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
+}
+
+impl Service {
 	/// Update current membership data.
 	#[tracing::instrument(skip(self, last_state))]
 	#[allow(clippy::too_many_arguments)]

src/service/rooms/state_compressor/mod.rs

@@ -2,13 +2,13 @@ mod data;
 
 use std::{
 	collections::HashSet,
+	fmt::Write,
 	mem::size_of,
 	sync::{Arc, Mutex as StdMutex, Mutex},
 };
 
-use conduit::{utils, Result, Server};
+use conduit::{utils, Result};
 use data::Data;
-use database::Database;
 use lru_cache::LruCache;
 use ruma::{EventId, RoomId};
 
@@ -52,17 +52,30 @@ pub struct Service {
 	pub stateinfo_cache: StateInfoLruCache,
 }
 
-impl Service {
-	pub fn build(server: &Arc<Server>, db: &Arc<Database>) -> Result<Self> {
-		let config = &server.config;
-		Ok(Self {
-			db: Data::new(db),
+impl crate::Service for Service {
+	fn build(args: crate::Args<'_>) -> Result<Arc<Self>> {
+		let config = &args.server.config;
+		Ok(Arc::new(Self {
+			db: Data::new(args.db),
 			stateinfo_cache: StdMutex::new(LruCache::new(
 				(f64::from(config.stateinfo_cache_capacity) * config.conduit_cache_capacity_modifier) as usize,
 			)),
-		})
+		}))
 	}
 
+	fn memory_usage(&self, out: &mut dyn Write) -> Result<()> {
+		let stateinfo_cache = self.stateinfo_cache.lock().expect("locked").len();
+		writeln!(out, "stateinfo_cache: {stateinfo_cache}")?;
+
+		Ok(())
+	}
+
+	fn clear_cache(&self) { self.stateinfo_cache.lock().expect("locked").clear(); }
+
+	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
+}
+
+impl Service {
 	/// Returns a stack with info on shortstatehash, full state, added diff and
 	/// removed diff for the selected shortstatehash and each parent layer.
 	#[tracing::instrument(skip(self))]

src/service/rooms/threads/mod.rs

@@ -2,9 +2,8 @@ mod data;
 
 use std::{collections::BTreeMap, sync::Arc};
 
-use conduit::{Error, Result, Server};
+use conduit::{Error, Result};
 use data::Data;
-use database::Database;
 use ruma::{
 	api::client::{error::ErrorKind, threads::get_threads::v1::IncludeThreads},
 	events::relation::BundledThread,
@@ -18,13 +17,17 @@ pub struct Service {
 	db: Data,
 }
 
-impl Service {
-	pub fn build(_server: &Arc<Server>, db: &Arc<Database>) -> Result<Self> {
-		Ok(Self {
-			db: Data::new(db),
-		})
+impl crate::Service for Service {
+	fn build(args: crate::Args<'_>) -> Result<Arc<Self>> {
+		Ok(Arc::new(Self {
+			db: Data::new(args.db),
+		}))
 	}
 
+	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
+}
+
+impl Service {
 	pub fn threads_until<'a>(
 		&'a self, user_id: &'a UserId, room_id: &'a RoomId, until: u64, include: &'a IncludeThreads,
 	) -> Result<impl Iterator<Item = Result<(u64, PduEvent)>> + 'a> {

src/service/rooms/timeline/mod.rs

@@ -2,12 +2,12 @@ mod data;
 
 use std::{
 	collections::{BTreeMap, HashSet},
+	fmt::Write,
 	sync::Arc,
 };
 
-use conduit::{debug, error, info, utils, utils::mutex_map, warn, Error, Result, Server};
+use conduit::{debug, error, info, utils, utils::mutex_map, warn, Error, Result};
 use data::Data;
-use database::Database;
 use itertools::Itertools;
 use rand::prelude::SliceRandom;
 use ruma::{
@@ -68,13 +68,37 @@ pub struct Service {
 	db: Data,
 }
 
-impl Service {
-	pub fn build(_server: &Arc<Server>, db: &Arc<Database>) -> Result<Self> {
-		Ok(Self {
-			db: Data::new(db),
-		})
+impl crate::Service for Service {
+	fn build(args: crate::Args<'_>) -> Result<Arc<Self>> {
+		Ok(Arc::new(Self {
+			db: Data::new(args.db),
+		}))
 	}
 
+	fn memory_usage(&self, out: &mut dyn Write) -> Result<()> {
+		let lasttimelinecount_cache = self
+			.db
+			.lasttimelinecount_cache
+			.lock()
+			.expect("locked")
+			.len();
+		writeln!(out, "lasttimelinecount_cache: {lasttimelinecount_cache}")?;
+
+		Ok(())
+	}
+
+	fn clear_cache(&self) {
+		self.db
+			.lasttimelinecount_cache
+			.lock()
+			.expect("locked")
+			.clear();
+	}
+
+	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
+}
+
+impl Service {
 	#[tracing::instrument(skip(self))]
 	pub fn first_pdu_in_room(&self, room_id: &RoomId) -> Result<Option<Arc<PduEvent>>> {
 		self.all_pdus(user_id!("@doesntmatter:conduit.rs"), room_id)?
@@ -1238,19 +1262,6 @@ impl Service {
 		debug!("Prepended backfill pdu");
 		Ok(())
 	}
-
-	pub fn get_lasttimelinecount_cache_usage(&self) -> (usize, usize) {
-		let cache = self.db.lasttimelinecount_cache.lock().expect("locked");
-		(cache.len(), cache.capacity())
-	}
-
-	pub fn clear_lasttimelinecount_cache(&self) {
-		self.db
-			.lasttimelinecount_cache
-			.lock()
-			.expect("locked")
-			.clear();
-	}
 }
 
 #[cfg(test)]

src/service/rooms/typing/mod.rs

@@ -1,7 +1,6 @@
 use std::{collections::BTreeMap, sync::Arc};
 
-use conduit::{debug_info, trace, utils, Result, Server};
-use database::Database;
+use conduit::{debug_info, trace, utils, Result};
 use ruma::{
 	api::federation::transactions::edu::{Edu, TypingContent},
 	events::SyncEphemeralRoomEvent,
@@ -19,15 +18,19 @@ pub struct Service {
 	pub typing_update_sender: broadcast::Sender<OwnedRoomId>,
 }
 
-impl Service {
-	pub fn build(_server: &Arc<Server>, _db: &Arc<Database>) -> Result<Self> {
-		Ok(Self {
+impl crate::Service for Service {
+	fn build(_args: crate::Args<'_>) -> Result<Arc<Self>> {
+		Ok(Arc::new(Self {
 			typing: RwLock::new(BTreeMap::new()),
 			last_typing_update: RwLock::new(BTreeMap::new()),
 			typing_update_sender: broadcast::channel(100).0,
-		})
+		}))
 	}
 
+	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
+}
+
+impl Service {
 	/// Sets a user as typing until the timeout timestamp is reached or
 	/// roomtyping_remove is called.
 	pub async fn typing_add(&self, user_id: &UserId, room_id: &RoomId, timeout: u64) -> Result<()> {

src/service/rooms/user/mod.rs

@@ -2,22 +2,25 @@ mod data;
 
 use std::sync::Arc;
 
-use conduit::{Result, Server};
+use conduit::Result;
 use data::Data;
-use database::Database;
 use ruma::{OwnedRoomId, OwnedUserId, RoomId, UserId};
 
 pub struct Service {
 	db: Data,
 }
 
-impl Service {
-	pub fn build(_server: &Arc<Server>, db: &Arc<Database>) -> Result<Self> {
-		Ok(Self {
-			db: Data::new(db),
-		})
+impl crate::Service for Service {
+	fn build(args: crate::Args<'_>) -> Result<Arc<Self>> {
+		Ok(Arc::new(Self {
+			db: Data::new(args.db),
+		}))
 	}
 
+	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
+}
+
+impl Service {
 	pub fn reset_notification_counts(&self, user_id: &UserId, room_id: &RoomId) -> Result<()> {
 		self.db.reset_notification_counts(user_id, room_id)
 	}