Add shared store runtime wrapper

Add a crate-local runtime wrapper for store backends that need to keep their I/O isolated while shutting down safely from async contexts.

Co-Authored-By: HAL 9000

Author: tnull

src/runtime.rs

@@ -6,6 +6,8 @@
 // accordance with one or both of these licenses.
 
 use std::future::Future;
+use std::io;
+use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
@@ -223,6 +225,60 @@ enum RuntimeMode {
 	Handle(tokio::runtime::Handle),
 }
 
+pub(crate) struct StoreRuntime {
+	runtime: Option<tokio::runtime::Runtime>,
+}
+
+impl StoreRuntime {
+	pub(crate) fn new(
+		thread_name_prefix: &'static str, worker_threads: usize, runtime_name: &'static str,
+	) -> io::Result<Self> {
+		let runtime = tokio::runtime::Builder::new_multi_thread()
+			.enable_all()
+			.thread_name_fn(move || {
+				static ATOMIC_ID: AtomicUsize = AtomicUsize::new(0);
+				let id = ATOMIC_ID.fetch_add(1, Ordering::SeqCst);
+				format!("{}-{}", thread_name_prefix, id)
+			})
+			.worker_threads(worker_threads)
+			.max_blocking_threads(worker_threads)
+			.build()
+			.map_err(|e| {
+				io::Error::new(
+					io::ErrorKind::Other,
+					format!("Failed to build {runtime_name} runtime: {e}"),
+				)
+			})?;
+		Ok(Self { runtime: Some(runtime) })
+	}
+
+	pub(crate) fn handle(&self) -> &tokio::runtime::Handle {
+		self.runtime.as_ref().expect("store runtime must be available").handle()
+	}
+
+	pub(crate) fn spawn<F>(&self, future: F) -> JoinHandle<F::Output>
+	where
+		F: Future + Send + 'static,
+		F::Output: Send + 'static,
+	{
+		self.handle().spawn(future)
+	}
+
+	pub(crate) fn shutdown_background(mut self) {
+		if let Some(runtime) = self.runtime.take() {
+			runtime.shutdown_background();
+		}
+	}
+}
+
+impl Drop for StoreRuntime {
+	fn drop(&mut self) {
+		if let Some(runtime) = self.runtime.take() {
+			runtime.shutdown_background();
+		}
+	}
+}
+
 pub(crate) struct RuntimeSpawner {
 	runtime: Arc<Runtime>,
 }