cleanup

Cargo.toml

···
 # unstable-features = "allow"
 # # Temporary Allows
 dead_code = "allow"
-unused_imports = "allow"
+# unused_imports = "allow"
 
 [lints.clippy]
 # Groups

src/account_manager/helpers/account.rs

···
 use thiserror::Error;
 
 use diesel::dsl::{LeftJoinOn, exists, not};
-use diesel::helper_types::{Eq, IntoBoxed};
+use diesel::helper_types::Eq;
 
 #[derive(Error, Debug)]
 pub enum AccountHelperError {
···
         })
         .await
         .expect("Failed to delete actor")?;
-    let did = did.to_owned();
+    let did_clone = did.to_owned();
     _ = db
         .get()
         .await?
         .interact(move |conn| {
             _ = delete(EmailTokenSchema::email_token)
-                .filter(EmailTokenSchema::did.eq(&did))
+                .filter(EmailTokenSchema::did.eq(&did_clone))
                 .execute(conn)?;
             _ = delete(RefreshTokenSchema::refresh_token)
-                .filter(RefreshTokenSchema::did.eq(&did))
+                .filter(RefreshTokenSchema::did.eq(&did_clone))
                 .execute(conn)?;
             _ = delete(AccountSchema::account)
-                .filter(AccountSchema::did.eq(&did))
+                .filter(AccountSchema::did.eq(&did_clone))
                 .execute(conn)?;
             delete(ActorSchema::actor)
-                .filter(ActorSchema::did.eq(&did))
+                .filter(ActorSchema::did.eq(&did_clone))
                 .execute(conn)
         })
         .await
         .expect("Failed to delete account")?;
+
+    let data_repo_file = format!("data/repo/{}.db", did.to_owned());
+    let data_blob_path = format!("data/blob/{}", did);
+    let data_blob_path = std::path::Path::new(&data_blob_path);
+    let data_repo_file = std::path::Path::new(&data_repo_file);
+    if data_repo_file.exists() {
+        std::fs::remove_file(data_repo_file)?;
+    };
+    if data_blob_path.exists() {
+        std::fs::remove_dir_all(data_blob_path)?;
+    };
     Ok(())
 }
 

src/account_manager/mod.rs

···
 //! blacksky-algorithms/rsky is licensed under the Apache License 2.0
 //!
 //! Modified for SQLite backend
-use crate::ActorPools;
 use crate::account_manager::helpers::account::{
     AccountStatus, ActorAccount, AvailabilityFlags, GetAccountAdminStatusOutput,
 };
···
 use crate::account_manager::helpers::invite::CodeDetail;
 use crate::account_manager::helpers::password::UpdateUserPasswordOpts;
 use crate::models::pds::EmailTokenPurpose;
+use crate::serve::ActorStorage;
 use anyhow::Result;
-use axum::extract::FromRef;
 use chrono::DateTime;
 use chrono::offset::Utc as UtcOffset;
 use cidv10::Cid;
-use deadpool_diesel::sqlite::Pool;
 use diesel::*;
 use futures::try_join;
 use helpers::{account, auth, email_token, invite, password, repo};
···
     pub async fn create_account(
         &self,
         opts: CreateAccountOpts,
-        actor_pools: &mut std::collections::HashMap<String, ActorPools>,
+        actor_pools: &mut std::collections::HashMap<String, ActorStorage>,
     ) -> Result<(String, String)> {
         let CreateAccountOpts {
             did,
···
         let did_path = did
             .strip_prefix("did:plc:")
             .ok_or_else(|| anyhow::anyhow!("Invalid DID"))?;
-        let path_repo = format!("sqlite://{}", did_path);
+        let repo_path = format!("sqlite://data/repo/{}.db", did_path);
         let actor_repo_pool =
-            crate::establish_pool(path_repo.as_str()).expect("Failed to establish pool");
-        let path_blob = path_repo.replace("repo", "blob");
-        let actor_blob_pool = crate::establish_pool(&path_blob).expect("Failed to establish pool");
-        let actor_pool = ActorPools {
+            crate::db::establish_pool(repo_path.as_str()).expect("Failed to establish pool");
+        let blob_path = std::path::Path::new("data/blob").to_path_buf();
+        let actor_pool = ActorStorage {
             repo: actor_repo_pool,
-            blob: actor_blob_pool,
+            blob: blob_path.clone(),
         };
-        actor_pools
-            .insert(did.clone(), actor_pool)
-            .expect("Failed to insert actor pools");
+        let blob_path = blob_path.join(did_path);
+        tokio::fs::create_dir_all(&blob_path)
+            .await
+            .map_err(|_| anyhow::anyhow!("Failed to create blob path"))?;
+        drop(
+            actor_pools
+                .insert(did.clone(), actor_pool)
+                .expect("Failed to insert actor pools"),
+        );
         let db = actor_pools
             .get(&did)
             .ok_or_else(|| anyhow::anyhow!("Actor not found"))?
···
         did: String,
         cid: Cid,
         rev: String,
-        actor_pools: &std::collections::HashMap<String, ActorPools>,
+        actor_pools: &std::collections::HashMap<String, ActorStorage>,
     ) -> Result<()> {
         let db = actor_pools
             .get(&did)
···
     pub async fn delete_account(
         &self,
         did: &str,
-        actor_pools: &std::collections::HashMap<String, ActorPools>,
+        actor_pools: &std::collections::HashMap<String, ActorStorage>,
     ) -> Result<()> {
         let db = actor_pools
             .get(did)

src/actor_endpoints.rs

···
 /// We shouldn't have to know about any bsky endpoints to store private user data.
 /// This will _very likely_ be changed in the future.
 use atrium_api::app::bsky::actor;
-use axum::{Json, routing::post};
+use axum::{
+    Json, Router,
+    extract::State,
+    routing::{get, post},
+};
 use constcat::concat;
 use diesel::prelude::*;
 
-use crate::actor_store::ActorStore;
+use crate::{actor_store::ActorStore, auth::AuthenticatedUser};
 
-use super::*;
+use super::serve::*;
 
 async fn put_preferences(
     user: AuthenticatedUser,
-    State(actor_pools): State<std::collections::HashMap<String, ActorPools>>,
+    State(actor_pools): State<std::collections::HashMap<String, ActorStorage>>,
     Json(input): Json<actor::put_preferences::Input>,
 ) -> Result<()> {
     let did = user.did();
-    let json_string =
-        serde_json::to_string(&input.preferences).context("failed to serialize preferences")?;
+    // let json_string =
+    //     serde_json::to_string(&input.preferences).context("failed to serialize preferences")?;
 
     // let conn = &mut actor_pools
     //     .get(&did)
···
     //         .context("failed to update user preferences")
     // });
     todo!("Use actor_store's preferences writer instead");
+    // let mut actor_store = ActorStore::from_actor_pools(&did, &actor_pools).await;
+    // let values = actor::defs::Preferences {
+    //     private_prefs: Some(json_string),
+    //     ..Default::default()
+    // };
+    // let namespace = actor::defs::PreferencesNamespace::Private;
+    // let scope = actor::defs::PreferencesScope::User;
+    // actor_store.pref.put_preferences(values, namespace, scope);
+
     Ok(())
 }
 
 async fn get_preferences(
     user: AuthenticatedUser,
-    State(actor_pools): State<std::collections::HashMap<String, ActorPools>>,
+    State(actor_pools): State<std::collections::HashMap<String, ActorStorage>>,
 ) -> Result<Json<actor::get_preferences::Output>> {
     let did = user.did();
     // let conn = &mut actor_pools

src/actor_store/blob.rs

···
 use rsky_repo::types::{PreparedBlobRef, PreparedWrite};
 use std::str::FromStr as _;
 
-use super::sql_blob::{BlobStoreSql, ByteStream};
+use super::blob_fs::{BlobStoreFs, ByteStream};
 
 pub struct GetBlobOutput {
     pub size: i32,
···
 /// Handles blob operations for an actor store
 pub struct BlobReader {
     /// SQL-based blob storage
-    pub blobstore: BlobStoreSql,
+    pub blobstore: BlobStoreFs,
     /// DID of the actor
     pub did: String,
     /// Database connection
···
 impl BlobReader {
     /// Create a new blob reader
     pub fn new(
-        blobstore: BlobStoreSql,
+        blobstore: BlobStoreFs,
         db: deadpool_diesel::Pool<
             deadpool_diesel::Manager<SqliteConnection>,
             deadpool_diesel::sqlite::Object,

src/actor_store/blob_fs.rs

···
         let first_level = if cid_str.len() >= 10 {
             &cid_str[0..10]
         } else {
-            &cid_str
+            "short"
         };
 
         let second_level = if cid_str.len() >= 20 {
             &cid_str[10..20]
         } else {
-            "default"
+            "short"
         };
 
         self.base_dir
···
             async_fs::create_dir_all(parent).await?;
         }
 
-        // Copy first, then delete source after success
-        _ = async_fs::copy(&mov.from, &mov.to).await?;
-        async_fs::remove_file(&mov.from).await?;
+        // Move the file
+        async_fs::rename(&mov.from, &mov.to).await?;
 
         debug!("Moved blob: {:?} -> {:?}", mov.from, mov.to);
         Ok(())

src/actor_store/mod.rs

···
 use tokio::sync::RwLock;
 
 use blob::BlobReader;
+use blob_fs::BlobStoreFs;
 use preference::PreferenceReader;
 use record::RecordReader;
-use sql_blob::BlobStoreSql;
 use sql_repo::SqlRepoReader;
 
-use crate::ActorPools;
+use crate::serve::ActorStorage;
 
 #[derive(Debug)]
 enum FormatCommitError {
···
 
 // Combination of RepoReader/Transactor, BlobReader/Transactor, SqlRepoReader/Transactor
 impl ActorStore {
-    /// Concrete reader of an individual repo (hence BlobStoreSql which takes `did` param)
+    /// Concrete reader of an individual repo (hence BlobStoreFs which takes `did` param)
     pub fn new(
         did: String,
-        blobstore: BlobStoreSql,
+        blobstore: BlobStoreFs,
         db: deadpool_diesel::Pool<
             deadpool_diesel::Manager<SqliteConnection>,
             deadpool_diesel::sqlite::Object,
···
     /// Create a new ActorStore taking ActorPools HashMap as input
     pub async fn from_actor_pools(
         did: &String,
-        hashmap_actor_pools: &std::collections::HashMap<String, ActorPools>,
+        hashmap_actor_pools: &std::collections::HashMap<String, ActorStorage>,
     ) -> Self {
         let actor_pool = hashmap_actor_pools
             .get(did)
             .expect("Actor pool not found")
             .clone();
-        let blobstore = BlobStoreSql::new(did.clone(), actor_pool.blob);
+        let blobstore = BlobStoreFs::new(did.clone(), actor_pool.blob);
         let conn = actor_pool
             .repo
             .clone()

src/apis/com/atproto/repo/apply_writes.rs

···
 //! Apply a batch transaction of repository creates, updates, and deletes. Requires auth, implemented by PDS.
-use crate::SharedSequencer;
+use crate::account_manager::AccountManager;
 use crate::account_manager::helpers::account::AvailabilityFlags;
-use crate::account_manager::{AccountManager, AccountManagerCreator, SharedAccountManager};
 use crate::{
-    ActorPools, AppState, SigningKey,
-    actor_store::{ActorStore, sql_blob::BlobStoreSql},
+    actor_store::ActorStore,
     auth::AuthenticatedUser,
-    config::AppConfig,
-    error::{ApiError, ErrorMessage},
+    error::ApiError,
+    serve::{ActorStorage, AppState},
 };
 use anyhow::{Result, bail};
-use axum::{
-    Json, Router,
-    body::Body,
-    extract::{Query, Request, State},
-    http::{self, StatusCode},
-    routing::{get, post},
-};
+use axum::{Json, extract::State};
 use cidv10::Cid;
-use deadpool_diesel::sqlite::Pool;
 use futures::stream::{self, StreamExt};
 use rsky_lexicon::com::atproto::repo::{ApplyWritesInput, ApplyWritesInputRefWrite};
-use rsky_pds::auth_verifier::AccessStandardIncludeChecks;
 use rsky_pds::repo::prepare::{
     PrepareCreateOpts, PrepareDeleteOpts, PrepareUpdateOpts, prepare_create, prepare_delete,
     prepare_update,
···
 use rsky_pds::sequencer::Sequencer;
 use rsky_repo::types::PreparedWrite;
 use std::str::FromStr;
-use std::sync::Arc;
 use tokio::sync::RwLock;
 
 async fn inner_apply_writes(
     body: ApplyWritesInput,
     user: AuthenticatedUser,
     sequencer: &RwLock<Sequencer>,
-    actor_pools: std::collections::HashMap<String, ActorPools>,
+    actor_pools: std::collections::HashMap<String, ActorStorage>,
     account_manager: &RwLock<AccountManager>,
 ) -> Result<()> {
     let tx: ApplyWritesInput = body;

src/apis/com/atproto/repo/mod.rs

···
 use axum::{Router, routing::post};
 use constcat::concat;
 
-use crate::AppState;
+use crate::serve::AppState;
 
 pub mod apply_writes;
 // pub mod create_record;

src/apis/mod.rs

···
 use axum::{Json, Router, routing::get};
 use serde_json::json;
 
-use crate::{AppState, Result};
+use crate::serve::{AppState, Result};
 
 /// Health check endpoint. Returns name and version of the service.
 pub(crate) async fn health() -> Result<Json<serde_json::Value>> {

src/auth.rs

···
 use diesel::prelude::*;
 use sha2::{Digest as _, Sha256};
 
-use crate::{AppState, Error, error::ErrorMessage};
+use crate::{
+    error::{Error, ErrorMessage},
+    serve::AppState,
+};
 
 /// Request extractor for authenticated users.
 /// If specified in an API endpoint, this guarantees the API can only be called

src/did.rs

···
 use serde::{Deserialize, Serialize};
 use url::Url;
 
-use crate::Client;
+use crate::serve::Client;
 
 /// URL whitelist for DID document resolution.
 const ALLOWED_URLS: &[&str] = &["bsky.app", "bsky.chat"];

src/error.rs

···
 
 impl ApiError {
     /// Get the appropriate HTTP status code for this error
-    fn status_code(&self) -> StatusCode {
+    const fn status_code(&self) -> StatusCode {
         match self {
             Self::RuntimeError => StatusCode::INTERNAL_SERVER_ERROR,
             Self::InvalidLogin
···
             Self::BadRequest(error, _) => error,
             Self::AuthRequiredError(_) => "AuthRequiredError",
         }
-        .to_string()
+        .to_owned()
     }
 
     /// Get the user-facing error message
···
             Self::BadRequest(_, msg) => msg,
             Self::AuthRequiredError(msg) => msg,
         }
-        .to_string()
+        .to_owned()
     }
 }
 
 impl From<Error> for ApiError {
     fn from(_value: Error) -> Self {
-        ApiError::RuntimeError
+        Self::RuntimeError
     }
 }
 
 impl From<handle::errors::Error> for ApiError {
     fn from(value: handle::errors::Error) -> Self {
         match value.kind {
-            ErrorKind::InvalidHandle => ApiError::InvalidHandle,
-            ErrorKind::HandleNotAvailable => ApiError::HandleNotAvailable,
-            ErrorKind::UnsupportedDomain => ApiError::UnsupportedDomain,
-            ErrorKind::InternalError => ApiError::RuntimeError,
+            ErrorKind::InvalidHandle => Self::InvalidHandle,
+            ErrorKind::HandleNotAvailable => Self::HandleNotAvailable,
+            ErrorKind::UnsupportedDomain => Self::UnsupportedDomain,
+            ErrorKind::InternalError => Self::RuntimeError,
         }
     }
 }
···
         let error_type = self.error_type();
         let message = self.message();
 
-        // Log the error for debugging
-        error!("API Error: {}: {}", error_type, message);
+        if cfg!(debug_assertions) {
+            error!("API Error: {}: {}", error_type, message);
+        }
 
         // Create the error message and serialize to JSON
         let error_message = ErrorMessage::new(error_type, message);
         let body = serde_json::to_string(&error_message).unwrap_or_else(|_| {
-            r#"{"error":"InternalServerError","message":"Error serializing response"}"#.to_string()
+            r#"{"error":"InternalServerError","message":"Error serializing response"}"#.to_owned()
         });
 
         // Build the response

src/firehose.rs

···
-//! The firehose module.
-use std::{collections::VecDeque, time::Duration};
-
-use anyhow::{Result, bail};
-use atrium_api::{
-    com::atproto::sync::{self},
-    types::string::{Datetime, Did, Tid},
-};
-use atrium_repo::Cid;
-use axum::extract::ws::{Message, WebSocket};
-use metrics::{counter, gauge};
-use rand::Rng as _;
-use serde::{Serialize, ser::SerializeMap as _};
-use tracing::{debug, error, info, warn};
-
-use crate::{
-    Client,
-    config::AppConfig,
-    metrics::{FIREHOSE_HISTORY, FIREHOSE_LISTENERS, FIREHOSE_MESSAGES, FIREHOSE_SEQUENCE},
-};
-
-enum FirehoseMessage {
-    Broadcast(sync::subscribe_repos::Message),
-    Connect(Box<(WebSocket, Option<i64>)>),
-}
-
-enum FrameHeader {
-    Error,
-    Message(String),
-}
-
-impl Serialize for FrameHeader {
-    #[expect(clippy::question_mark_used, reason = "returns a Result")]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let mut map = serializer.serialize_map(None)?;
-
-        match *self {
-            Self::Message(ref s) => {
-                map.serialize_key("op")?;
-                map.serialize_value(&1_i32)?;
-                map.serialize_key("t")?;
-                map.serialize_value(s.as_str())?;
-            }
-            Self::Error => {
-                map.serialize_key("op")?;
-                map.serialize_value(&-1_i32)?;
-            }
-        }
-
-        map.end()
-    }
-}
-
-/// A repository operation.
-pub(crate) enum RepoOp {
-    /// Create a new record.
-    Create {
-        /// The CID of the record.
-        cid: Cid,
-        /// The path of the record.
-        path: String,
-    },
-    /// Delete an existing record.
-    Delete {
-        /// The path of the record.
-        path: String,
-        /// The previous CID of the record.
-        prev: Cid,
-    },
-    /// Update an existing record.
-    Update {
-        /// The CID of the record.
-        cid: Cid,
-        /// The path of the record.
-        path: String,
-        /// The previous CID of the record.
-        prev: Cid,
-    },
-}
-
-impl From<RepoOp> for sync::subscribe_repos::RepoOp {
-    fn from(val: RepoOp) -> Self {
-        let (action, cid, prev, path) = match val {
-            RepoOp::Create { cid, path } => ("create", Some(cid), None, path),
-            RepoOp::Update { cid, path, prev } => ("update", Some(cid), Some(prev), path),
-            RepoOp::Delete { path, prev } => ("delete", None, Some(prev), path),
-        };
-
-        sync::subscribe_repos::RepoOpData {
-            action: action.to_owned(),
-            cid: cid.map(atrium_api::types::CidLink),
-            prev: prev.map(atrium_api::types::CidLink),
-            path,
-        }
-        .into()
-    }
-}
-
-/// A commit to the repository.
-pub(crate) struct Commit {
-    /// Blobs that were created in this commit.
-    pub blobs: Vec<Cid>,
-    /// The car file containing the commit blocks.
-    pub car: Vec<u8>,
-    /// The CID of the commit.
-    pub cid: Cid,
-    /// The DID of the repository changed.
-    pub did: Did,
-    /// The operations performed in this commit.
-    pub ops: Vec<RepoOp>,
-    /// The previous commit's CID (if applicable).
-    pub pcid: Option<Cid>,
-    /// The revision of the commit.
-    pub rev: String,
-}
-
-impl From<Commit> for sync::subscribe_repos::Commit {
-    fn from(val: Commit) -> Self {
-        sync::subscribe_repos::CommitData {
-            blobs: val
-                .blobs
-                .into_iter()
-                .map(atrium_api::types::CidLink)
-                .collect::<Vec<_>>(),
-            blocks: val.car,
-            commit: atrium_api::types::CidLink(val.cid),
-            ops: val.ops.into_iter().map(Into::into).collect::<Vec<_>>(),
-            prev_data: val.pcid.map(atrium_api::types::CidLink),
-            rebase: false,
-            repo: val.did,
-            rev: Tid::new(val.rev).expect("should be valid revision"),
-            seq: 0,
-            since: None,
-            time: Datetime::now(),
-            too_big: false,
-        }
-        .into()
-    }
-}
-
-/// A firehose producer. This is used to transmit messages to the firehose for broadcast.
-#[derive(Clone, Debug)]
-pub(crate) struct FirehoseProducer {
-    /// The channel to send messages to the firehose.
-    tx: tokio::sync::mpsc::Sender<FirehoseMessage>,
-}
-
-impl FirehoseProducer {
-    /// Broadcast an `#account` event.
-    pub(crate) async fn account(&self, account: impl Into<sync::subscribe_repos::Account>) {
-        drop(
-            self.tx
-                .send(FirehoseMessage::Broadcast(
-                    sync::subscribe_repos::Message::Account(Box::new(account.into())),
-                ))
-                .await,
-        );
-    }
-    /// Handle client connection.
-    pub(crate) async fn client_connection(&self, ws: WebSocket, cursor: Option<i64>) {
-        drop(
-            self.tx
-                .send(FirehoseMessage::Connect(Box::new((ws, cursor))))
-                .await,
-        );
-    }
-    /// Broadcast a `#commit` event.
-    pub(crate) async fn commit(&self, commit: impl Into<sync::subscribe_repos::Commit>) {
-        drop(
-            self.tx
-                .send(FirehoseMessage::Broadcast(
-                    sync::subscribe_repos::Message::Commit(Box::new(commit.into())),
-                ))
-                .await,
-        );
-    }
-    /// Broadcast an `#identity` event.
-    pub(crate) async fn identity(&self, identity: impl Into<sync::subscribe_repos::Identity>) {
-        drop(
-            self.tx
-                .send(FirehoseMessage::Broadcast(
-                    sync::subscribe_repos::Message::Identity(Box::new(identity.into())),
-                ))
-                .await,
-        );
-    }
-}
-
-#[expect(
-    clippy::as_conversions,
-    clippy::cast_possible_truncation,
-    clippy::cast_sign_loss,
-    clippy::cast_precision_loss,
-    clippy::arithmetic_side_effects
-)]
-/// Convert a `usize` to a `f64`.
-const fn convert_usize_f64(x: usize) -> Result<f64, &'static str> {
-    let result = x as f64;
-    if result as usize - x > 0 {
-        return Err("cannot convert");
-    }
-    Ok(result)
-}
-
-/// Serialize a message.
-fn serialize_message(seq: u64, mut msg: sync::subscribe_repos::Message) -> (&'static str, Vec<u8>) {
-    let mut dummy_seq = 0_i64;
-    #[expect(clippy::pattern_type_mismatch)]
-    let (ty, nseq) = match &mut msg {
-        sync::subscribe_repos::Message::Account(m) => ("#account", &mut m.seq),
-        sync::subscribe_repos::Message::Commit(m) => ("#commit", &mut m.seq),
-        sync::subscribe_repos::Message::Identity(m) => ("#identity", &mut m.seq),
-        sync::subscribe_repos::Message::Sync(m) => ("#sync", &mut m.seq),
-        sync::subscribe_repos::Message::Info(_m) => ("#info", &mut dummy_seq),
-    };
-    // Set the sequence number.
-    *nseq = i64::try_from(seq).expect("should find seq");
-
-    let hdr = FrameHeader::Message(ty.to_owned());
-
-    let mut frame = Vec::new();
-    serde_ipld_dagcbor::to_writer(&mut frame, &hdr).expect("should serialize header");
-    serde_ipld_dagcbor::to_writer(&mut frame, &msg).expect("should serialize message");
-
-    (ty, frame)
-}
-
-/// Broadcast a message out to all clients.
-async fn broadcast_message(clients: &mut Vec<WebSocket>, msg: Message) -> Result<()> {
-    counter!(FIREHOSE_MESSAGES).increment(1);
-
-    for i in (0..clients.len()).rev() {
-        let client = clients.get_mut(i).expect("should find client");
-        if let Err(e) = client.send(msg.clone()).await {
-            debug!("Firehose client disconnected: {e}");
-            drop(clients.remove(i));
-        }
-    }
-
-    gauge!(FIREHOSE_LISTENERS)
-        .set(convert_usize_f64(clients.len()).expect("should find clients length"));
-    Ok(())
-}
-
-/// Handle a new connection from a websocket client created by subscribeRepos.
-async fn handle_connect(
-    mut ws: WebSocket,
-    seq: u64,
-    history: &VecDeque<(u64, &str, sync::subscribe_repos::Message)>,
-    cursor: Option<i64>,
-) -> Result<WebSocket> {
-    if let Some(cursor) = cursor {
-        let mut frame = Vec::new();
-        let cursor = u64::try_from(cursor);
-        if cursor.is_err() {
-            tracing::warn!("cursor is not a valid u64");
-            return Ok(ws);
-        }
-        let cursor = cursor.expect("should be valid u64");
-        // Cursor specified; attempt to backfill the consumer.
-        if cursor > seq {
-            let hdr = FrameHeader::Error;
-            let msg = sync::subscribe_repos::Error::FutureCursor(Some(format!(
-                "cursor {cursor} is greater than the current sequence number {seq}"
-            )));
-            serde_ipld_dagcbor::to_writer(&mut frame, &hdr).expect("should serialize header");
-            serde_ipld_dagcbor::to_writer(&mut frame, &msg).expect("should serialize message");
-            // Drop the connection.
-            drop(ws.send(Message::binary(frame)).await);
-            bail!(
-                "connection dropped: cursor {cursor} is greater than the current sequence number {seq}"
-            );
-        }
-
-        for &(historical_seq, ty, ref msg) in history {
-            if cursor > historical_seq {
-                continue;
-            }
-            let hdr = FrameHeader::Message(ty.to_owned());
-            serde_ipld_dagcbor::to_writer(&mut frame, &hdr).expect("should serialize header");
-            serde_ipld_dagcbor::to_writer(&mut frame, msg).expect("should serialize message");
-            if let Err(e) = ws.send(Message::binary(frame.clone())).await {
-                debug!("Firehose client disconnected during backfill: {e}");
-                break;
-            }
-            // Clear out the frame to begin a new one.
-            frame.clear();
-        }
-    }
-
-    Ok(ws)
-}
-
-/// Reconnect to upstream relays.
-pub(crate) async fn reconnect_relays(client: &Client, config: &AppConfig) {
-    // Avoid connecting to upstream relays in test mode.
-    if config.test {
-        return;
-    }
-
-    info!("attempting to reconnect to upstream relays");
-    for relay in &config.firehose.relays {
-        let Some(host) = relay.host_str() else {
-            warn!("relay {} has no host specified", relay);
-            continue;
-        };
-
-        let r = client
-            .post(format!("https://{host}/xrpc/com.atproto.sync.requestCrawl"))
-            .json(&serde_json::json!({
-                "hostname": format!("https://{}", config.host_name)
-            }))
-            .send()
-            .await;
-
-        let r = match r {
-            Ok(r) => r,
-            Err(e) => {
-                error!("failed to hit upstream relay {host}: {e}");
-                continue;
-            }
-        };
-
-        let s = r.status();
-        if let Err(e) = r.error_for_status_ref() {
-            error!("failed to hit upstream relay {host}: {e}");
-        }
-
-        let b = r.json::<serde_json::Value>().await;
-        if let Ok(b) = b {
-            info!("relay {host}: {} {}", s, b);
-        } else {
-            info!("relay {host}: {}", s);
-        }
-    }
-}
-
-/// The main entrypoint for the firehose.
-///
-/// This will broadcast all updates in this PDS out to anyone who is listening.
-///
-/// Reference: <https://atproto.com/specs/sync>
-pub(crate) fn spawn(
-    client: Client,
-    config: AppConfig,
-) -> (tokio::task::JoinHandle<()>, FirehoseProducer) {
-    let (tx, mut rx) = tokio::sync::mpsc::channel(1000);
-    let handle = tokio::spawn(async move {
-        fn time_since_inception() -> u64 {
-            chrono::Utc::now()
-                .timestamp_micros()
-                .checked_sub(1_743_442_000_000_000)
-                .expect("should not wrap")
-                .unsigned_abs()
-        }
-        let mut clients: Vec<WebSocket> = Vec::new();
-        let mut history = VecDeque::with_capacity(1000);
-        let mut seq = time_since_inception();
-
-        loop {
-            if let Ok(msg) = tokio::time::timeout(Duration::from_secs(30), rx.recv()).await {
-                match msg {
-                    Some(FirehoseMessage::Broadcast(msg)) => {
-                        let (ty, by) = serialize_message(seq, msg.clone());
-
-                        history.push_back((seq, ty, msg));
-                        gauge!(FIREHOSE_HISTORY).set(
-                            convert_usize_f64(history.len()).expect("should find history length"),
-                        );
-
-                        info!(
-                            "Broadcasting message {} {} to {} clients",
-                            seq,
-                            ty,
-                            clients.len()
-                        );
-
-                        counter!(FIREHOSE_SEQUENCE).absolute(seq);
-                        let now = time_since_inception();
-                        if now > seq {
-                            seq = now;
-                        } else {
-                            seq = seq.checked_add(1).expect("should not wrap");
-                        }
-
-                        drop(broadcast_message(&mut clients, Message::binary(by)).await);
-                    }
-                    Some(FirehoseMessage::Connect(ws_cursor)) => {
-                        let (ws, cursor) = *ws_cursor;
-                        match handle_connect(ws, seq, &history, cursor).await {
-                            Ok(r) => {
-                                gauge!(FIREHOSE_LISTENERS).increment(1_i32);
-                                clients.push(r);
-                            }
-                            Err(e) => {
-                                error!("failed to connect new client: {e}");
-                            }
-                        }
-                    }
-                    // All producers have been destroyed.
-                    None => break,
-                }
-            } else {
-                if clients.is_empty() {
-                    reconnect_relays(&client, &config).await;
-                }
-
-                let contents = rand::thread_rng()
-                    .sample_iter(rand::distributions::Alphanumeric)
-                    .take(15)
-                    .map(char::from)
-                    .collect::<String>();
-
-                // Send a websocket ping message.
-                // Reference: https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API/Writing_WebSocket_servers#pings_and_pongs_the_heartbeat_of_websockets
-                let message = Message::Ping(axum::body::Bytes::from_owner(contents));
-                drop(broadcast_message(&mut clients, message).await);
-            }
-        }
-    });
-
-    (handle, FirehoseProducer { tx })
-}

src/lib.rs

···
 mod db;
 mod did;
 pub mod error;
-mod firehose;
 mod metrics;
-mod mmap;
 mod models;
 mod oauth;
-mod plc;
 mod schema;
+mod serve;
 mod service_proxy;
-#[cfg(test)]
-mod tests;
 
-use account_manager::{AccountManager, SharedAccountManager};
-use anyhow::{Context as _, anyhow};
-use atrium_api::types::string::Did;
-use atrium_crypto::keypair::{Export as _, Secp256k1Keypair};
-use auth::AuthenticatedUser;
-use axum::{
-    Router,
-    body::Body,
-    extract::{FromRef, Request, State},
-    http::{self, HeaderMap, Response, StatusCode, Uri},
-    response::IntoResponse,
-    routing::get,
-};
-use azure_core::credentials::TokenCredential;
-use clap::Parser;
-use clap_verbosity_flag::{InfoLevel, Verbosity, log::LevelFilter};
-use config::AppConfig;
-use db::establish_pool;
-use deadpool_diesel::sqlite::Pool;
-use diesel::prelude::*;
-use diesel_migrations::{EmbeddedMigrations, embed_migrations};
-pub use error::Error;
-use figment::{Figment, providers::Format as _};
-use firehose::FirehoseProducer;
-use http_cache_reqwest::{CacheMode, HttpCacheOptions, MokaManager};
-use rand::Rng as _;
-use rsky_pds::{crawlers::Crawlers, sequencer::Sequencer};
-use serde::{Deserialize, Serialize};
-use service_proxy::service_proxy;
-use std::{
-    net::{IpAddr, Ipv4Addr, SocketAddr},
-    path::PathBuf,
-    str::FromStr as _,
-    sync::Arc,
-};
-use tokio::{net::TcpListener, sync::RwLock};
-use tower_http::{cors::CorsLayer, trace::TraceLayer};
-use tracing::{info, warn};
-use uuid::Uuid;
-
-/// The application user agent. Concatenates the package name and version. e.g. `bluepds/0.0.0`.
-pub const APP_USER_AGENT: &str = concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"),);
-
-/// Embedded migrations
-pub const MIGRATIONS: EmbeddedMigrations = embed_migrations!("./migrations");
-
-/// The application-wide result type.
-pub type Result<T> = std::result::Result<T, Error>;
-/// The reqwest client type with middleware.
-pub type Client = reqwest_middleware::ClientWithMiddleware;
-
-/// The Shared Sequencer which requests crawls from upstream relays and emits events to the firehose.
-pub struct SharedSequencer {
-    /// The sequencer instance.
-    pub sequencer: RwLock<Sequencer>,
-}
-
-#[expect(
-    clippy::arbitrary_source_item_ordering,
-    reason = "serialized data might be structured"
-)]
-#[derive(Serialize, Deserialize, Debug, Clone)]
-/// The key data structure.
-struct KeyData {
-    /// Primary signing key for all repo operations.
-    skey: Vec<u8>,
-    /// Primary signing (rotation) key for all PLC operations.
-    rkey: Vec<u8>,
-}
-
-// FIXME: We should use P256Keypair instead. SecP256K1 is primarily used for cryptocurrencies,
-// and the implementations of this algorithm are much more limited as compared to P256.
-//
-// Reference: https://soatok.blog/2022/05/19/guidance-for-choosing-an-elliptic-curve-signature-algorithm-in-2022/
-#[derive(Clone)]
-/// The signing key for PLC/DID operations.
-pub struct SigningKey(Arc<Secp256k1Keypair>);
-#[derive(Clone)]
-/// The rotation key for PLC operations.
-pub struct RotationKey(Arc<Secp256k1Keypair>);
-
-impl std::ops::Deref for SigningKey {
-    type Target = Secp256k1Keypair;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl SigningKey {
-    /// Import from a private key.
-    pub fn import(key: &[u8]) -> Result<Self> {
-        let key = Secp256k1Keypair::import(key).context("failed to import signing key")?;
-        Ok(Self(Arc::new(key)))
-    }
-}
-
-impl std::ops::Deref for RotationKey {
-    type Target = Secp256k1Keypair;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-#[derive(Parser, Debug, Clone)]
-/// Command line arguments.
-pub struct Args {
-    /// Path to the configuration file
-    #[arg(short, long, default_value = "default.toml")]
-    pub config: PathBuf,
-    /// The verbosity level.
-    #[command(flatten)]
-    pub verbosity: Verbosity<InfoLevel>,
-}
-
-/// The actor pools for the database connections.
-pub struct ActorPools {
-    /// The database connection pool for the actor's repository.
-    pub repo: Pool,
-    /// The database connection pool for the actor's blobs.
-    pub blob: Pool,
-}
-
-impl Clone for ActorPools {
-    fn clone(&self) -> Self {
-        Self {
-            repo: self.repo.clone(),
-            blob: self.blob.clone(),
-        }
-    }
-}
-
-#[expect(clippy::arbitrary_source_item_ordering, reason = "arbitrary")]
-#[derive(Clone, FromRef)]
-pub struct AppState {
-    /// The application configuration.
-    pub config: AppConfig,
-    /// The main database connection pool. Used for common PDS data, like invite codes.
-    pub db: Pool,
-    /// Actor-specific database connection pools. Hashed by DID.
-    pub db_actors: std::collections::HashMap<String, ActorPools>,
-
-    /// The HTTP client with middleware.
-    pub client: Client,
-    /// The simple HTTP client.
-    pub simple_client: reqwest::Client,
-    /// The firehose producer.
-    pub sequencer: Arc<SharedSequencer>,
-    /// The account manager.
-    pub account_manager: Arc<SharedAccountManager>,
-
-    /// The signing key.
-    pub signing_key: SigningKey,
-    /// The rotation key.
-    pub rotation_key: RotationKey,
-}
+pub use serve::run;
 
 /// The index (/) route.
-async fn index() -> impl IntoResponse {
+async fn index() -> impl axum::response::IntoResponse {
     r"
          __                         __
         /\ \__                     /\ \__
···
   Protocol: https://atproto.com
     "
 }
-
-/// The main application entry point.
-#[expect(
-    clippy::cognitive_complexity,
-    clippy::too_many_lines,
-    unused_qualifications,
-    reason = "main function has high complexity"
-)]
-pub async fn run() -> anyhow::Result<()> {
-    let args = Args::parse();
-
-    // Set up trace logging to console and account for the user-provided verbosity flag.
-    if args.verbosity.log_level_filter() != LevelFilter::Off {
-        let lvl = match args.verbosity.log_level_filter() {
-            LevelFilter::Error => tracing::Level::ERROR,
-            LevelFilter::Warn => tracing::Level::WARN,
-            LevelFilter::Info | LevelFilter::Off => tracing::Level::INFO,
-            LevelFilter::Debug => tracing::Level::DEBUG,
-            LevelFilter::Trace => tracing::Level::TRACE,
-        };
-        tracing_subscriber::fmt().with_max_level(lvl).init();
-    }
-
-    if !args.config.exists() {
-        // Throw up a warning if the config file does not exist.
-        //
-        // This is not fatal because users can specify all configuration settings via
-        // the environment, but the most likely scenario here is that a user accidentally
-        // omitted the config file for some reason (e.g. forgot to mount it into Docker).
-        warn!(
-            "configuration file {} does not exist",
-            args.config.display()
-        );
-    }
-
-    // Read and parse the user-provided configuration.
-    let config: AppConfig = Figment::new()
-        .admerge(figment::providers::Toml::file(args.config))
-        .admerge(figment::providers::Env::prefixed("BLUEPDS_"))
-        .extract()
-        .context("failed to load configuration")?;
-
-    if config.test {
-        warn!("BluePDS starting up in TEST mode.");
-        warn!("This means the application will not federate with the rest of the network.");
-        warn!(
-            "If you want to turn this off, either set `test` to false in the config or define `BLUEPDS_TEST = false`"
-        );
-    }
-
-    // Initialize metrics reporting.
-    metrics::setup(config.metrics.as_ref()).context("failed to set up metrics exporter")?;
-
-    // Create a reqwest client that will be used for all outbound requests.
-    let simple_client = reqwest::Client::builder()
-        .user_agent(APP_USER_AGENT)
-        .build()
-        .context("failed to build requester client")?;
-    let client = reqwest_middleware::ClientBuilder::new(simple_client.clone())
-        .with(http_cache_reqwest::Cache(http_cache_reqwest::HttpCache {
-            mode: CacheMode::Default,
-            manager: MokaManager::default(),
-            options: HttpCacheOptions::default(),
-        }))
-        .build();
-
-    tokio::fs::create_dir_all(&config.key.parent().context("should have parent")?)
-        .await
-        .context("failed to create key directory")?;
-
-    // Check if crypto keys exist. If not, create new ones.
-    let (skey, rkey) = if let Ok(f) = std::fs::File::open(&config.key) {
-        let keys: KeyData = serde_ipld_dagcbor::from_reader(std::io::BufReader::new(f))
-            .context("failed to deserialize crypto keys")?;
-
-        let skey = Secp256k1Keypair::import(&keys.skey).context("failed to import signing key")?;
-        let rkey = Secp256k1Keypair::import(&keys.rkey).context("failed to import rotation key")?;
-
-        (SigningKey(Arc::new(skey)), RotationKey(Arc::new(rkey)))
-    } else {
-        info!("signing keys not found, generating new ones");
-
-        let skey = Secp256k1Keypair::create(&mut rand::thread_rng());
-        let rkey = Secp256k1Keypair::create(&mut rand::thread_rng());
-
-        let keys = KeyData {
-            skey: skey.export(),
-            rkey: rkey.export(),
-        };
-
-        let mut f = std::fs::File::create(&config.key).context("failed to create key file")?;
-        serde_ipld_dagcbor::to_writer(&mut f, &keys).context("failed to serialize crypto keys")?;
-
-        (SigningKey(Arc::new(skey)), RotationKey(Arc::new(rkey)))
-    };
-
-    tokio::fs::create_dir_all(&config.repo.path).await?;
-    tokio::fs::create_dir_all(&config.plc.path).await?;
-    tokio::fs::create_dir_all(&config.blob.path).await?;
-
-    // Create a database connection manager and pool for the main database.
-    let pool =
-        establish_pool(&config.db).context("failed to establish database connection pool")?;
-    // Create a dictionary of database connection pools for each actor.
-    let mut actor_pools = std::collections::HashMap::new();
-    // let mut actor_blob_pools = std::collections::HashMap::new();
-    // We'll determine actors by looking in the data/repo dir for .db files.
-    let mut actor_dbs = tokio::fs::read_dir(&config.repo.path)
-        .await
-        .context("failed to read repo directory")?;
-    while let Some(entry) = actor_dbs
-        .next_entry()
-        .await
-        .context("failed to read repo dir")?
-    {
-        let path = entry.path();
-        if path.extension().and_then(|s| s.to_str()) == Some("db") {
-            let did_path = path
-                .file_stem()
-                .and_then(|s| s.to_str())
-                .context("failed to get actor DID")?;
-            let did = Did::from_str(&format!("did:plc:{}", did_path))
-                .expect("should be able to parse actor DID");
-
-            // Create a new database connection manager and pool for the actor.
-            // The path for the SQLite connection needs to look like "sqlite://data/repo/<actor>.db"
-            let path_repo = format!("sqlite://{}", did_path);
-            let actor_repo_pool =
-                establish_pool(&path_repo).context("failed to create database connection pool")?;
-            // Create a new database connection manager and pool for the actor blobs.
-            // The path for the SQLite connection needs to look like "sqlite://data/blob/<actor>.db"
-            let path_blob = path_repo.replace("repo", "blob");
-            let actor_blob_pool =
-                establish_pool(&path_blob).context("failed to create database connection pool")?;
-            drop(actor_pools.insert(
-                did.to_string(),
-                ActorPools {
-                    repo: actor_repo_pool,
-                    blob: actor_blob_pool,
-                },
-            ));
-        }
-    }
-    // Apply pending migrations
-    // let conn = pool.get().await?;
-    // conn.run_pending_migrations(MIGRATIONS)
-    //     .expect("should be able to run migrations");
-
-    let hostname = config.host_name.clone();
-    let crawlers: Vec<String> = config
-        .firehose
-        .relays
-        .iter()
-        .map(|s| s.to_string())
-        .collect();
-    let sequencer = Arc::new(SharedSequencer {
-        sequencer: RwLock::new(Sequencer::new(
-            Crawlers::new(hostname, crawlers.clone()),
-            None,
-        )),
-    });
-    let account_manager = SharedAccountManager {
-        account_manager: RwLock::new(AccountManager::new(pool.clone())),
-    };
-
-    let addr = config
-        .listen_address
-        .unwrap_or(SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 8000));
-
-    let app = Router::new()
-        .route("/", get(index))
-        .merge(oauth::routes())
-        .nest(
-            "/xrpc",
-            apis::routes()
-                .merge(actor_endpoints::routes())
-                .fallback(service_proxy),
-        )
-        // .layer(RateLimitLayer::new(30, Duration::from_secs(30)))
-        .layer(CorsLayer::permissive())
-        .layer(TraceLayer::new_for_http())
-        .with_state(AppState {
-            config: config.clone(),
-            db: pool.clone(),
-            db_actors: actor_pools.clone(),
-            client: client.clone(),
-            simple_client,
-            sequencer: sequencer.clone(),
-            account_manager: Arc::new(account_manager),
-            signing_key: skey,
-            rotation_key: rkey,
-        });
-
-    info!("listening on {addr}");
-    info!("connect to: http://127.0.0.1:{}", addr.port());
-
-    // Determine whether or not this was the first startup (i.e. no accounts exist and no invite codes were created).
-    // If so, create an invite code and share it via the console.
-    let conn = pool.get().await.context("failed to get db connection")?;
-
-    #[derive(QueryableByName)]
-    struct TotalCount {
-        #[diesel(sql_type = diesel::sql_types::Integer)]
-        total_count: i32,
-    }
-
-    let result = conn.interact(move |conn| {
-        diesel::sql_query(
-            "SELECT (SELECT COUNT(*) FROM account) + (SELECT COUNT(*) FROM invite_code) AS total_count",
-        )
-        .get_result::<TotalCount>(conn)
-    })
-    .await
-    .expect("should be able to query database")?;
-
-    let c = result.total_count;
-
-    #[expect(clippy::print_stdout)]
-    if c == 0 {
-        let uuid = Uuid::new_v4().to_string();
-
-        use crate::models::pds as models;
-        use crate::schema::pds::invite_code::dsl as InviteCode;
-        let uuid_clone = uuid.clone();
-        drop(
-            conn.interact(move |conn| {
-                diesel::insert_into(InviteCode::invite_code)
-                    .values(models::InviteCode {
-                        code: uuid_clone,
-                        available_uses: 1,
-                        disabled: 0,
-                        for_account: "None".to_owned(),
-                        created_by: "None".to_owned(),
-                        created_at: "None".to_owned(),
-                    })
-                    .execute(conn)
-                    .context("failed to create new invite code")
-            })
-            .await
-            .expect("should be able to create invite code"),
-        );
-
-        // N.B: This is a sensitive message, so we're bypassing `tracing` here and
-        // logging it directly to console.
-        println!("=====================================");
-        println!("            FIRST STARTUP            ");
-        println!("=====================================");
-        println!("Use this code to create an account:");
-        println!("{uuid}");
-        println!("=====================================");
-    }
-
-    let listener = TcpListener::bind(&addr)
-        .await
-        .context("failed to bind address")?;
-
-    // Serve the app, and request crawling from upstream relays.
-    let serve = tokio::spawn(async move {
-        axum::serve(listener, app.into_make_service())
-            .await
-            .context("failed to serve app")
-    });
-
-    // Now that the app is live, request a crawl from upstream relays.
-    let mut background_sequencer = sequencer.sequencer.write().await.clone();
-    drop(tokio::spawn(
-        async move { background_sequencer.start().await },
-    ));
-
-    serve
-        .await
-        .map_err(Into::into)
-        .and_then(|r| r)
-        .context("failed to serve app")
-}

src/main.rs

···
 //! BluePDS binary entry point.
 
 use anyhow::Context as _;
-use clap::Parser;
 
 #[tokio::main(flavor = "multi_thread")]
 async fn main() -> anyhow::Result<()> {
-    // Parse command line arguments and call into the library's run function
     bluepds::run().await.context("failed to run application")
-}
+}

src/mmap.rs

···
-#![allow(clippy::arbitrary_source_item_ordering)]
-use std::io::{ErrorKind, Read as _, Seek as _, Write as _};
-
-#[cfg(unix)]
-use std::os::fd::AsRawFd as _;
-#[cfg(windows)]
-use std::os::windows::io::AsRawHandle;
-
-use memmap2::{MmapMut, MmapOptions};
-
-pub(crate) struct MappedFile {
-    /// The underlying file handle.
-    file: std::fs::File,
-    /// The length of the file.
-    len: u64,
-    /// The mapped memory region.
-    map: MmapMut,
-    /// Our current offset into the file.
-    off: u64,
-}
-
-impl MappedFile {
-    pub(crate) fn new(mut f: std::fs::File) -> std::io::Result<Self> {
-        let len = f.seek(std::io::SeekFrom::End(0))?;
-
-        #[cfg(windows)]
-        let raw = f.as_raw_handle();
-        #[cfg(unix)]
-        let raw = f.as_raw_fd();
-
-        #[expect(unsafe_code)]
-        Ok(Self {
-            // SAFETY:
-            // All file-backed memory map constructors are marked \
-            // unsafe because of the potential for Undefined Behavior (UB) \
-            // using the map if the underlying file is subsequently modified, in or out of process.
-            map: unsafe { MmapOptions::new().map_mut(raw)? },
-            file: f,
-            len,
-            off: 0,
-        })
-    }
-
-    /// Resize the memory-mapped file. This will reallocate the memory mapping.
-    #[expect(unsafe_code)]
-    fn resize(&mut self, len: u64) -> std::io::Result<()> {
-        // Resize the file.
-        self.file.set_len(len)?;
-
-        #[cfg(windows)]
-        let raw = self.file.as_raw_handle();
-        #[cfg(unix)]
-        let raw = self.file.as_raw_fd();
-
-        // SAFETY:
-        // All file-backed memory map constructors are marked \
-        // unsafe because of the potential for Undefined Behavior (UB) \
-        // using the map if the underlying file is subsequently modified, in or out of process.
-        self.map = unsafe { MmapOptions::new().map_mut(raw)? };
-        self.len = len;
-
-        Ok(())
-    }
-}
-
-impl std::io::Read for MappedFile {
-    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
-        if self.off == self.len {
-            // If we're at EOF, return an EOF error code. `Ok(0)` tends to trip up some implementations.
-            return Err(std::io::Error::new(ErrorKind::UnexpectedEof, "eof"));
-        }
-
-        // Calculate the number of bytes we're going to read.
-        let remaining_bytes = self.len.saturating_sub(self.off);
-        let buf_len = u64::try_from(buf.len()).unwrap_or(u64::MAX);
-        let len = usize::try_from(std::cmp::min(remaining_bytes, buf_len)).unwrap_or(usize::MAX);
-
-        let off = usize::try_from(self.off).map_err(|e| {
-            std::io::Error::new(
-                ErrorKind::InvalidInput,
-                format!("offset too large for this platform: {e}"),
-            )
-        })?;
-
-        if let (Some(dest), Some(src)) = (
-            buf.get_mut(..len),
-            self.map.get(off..off.saturating_add(len)),
-        ) {
-            dest.copy_from_slice(src);
-            self.off = self.off.saturating_add(u64::try_from(len).unwrap_or(0));
-            Ok(len)
-        } else {
-            Err(std::io::Error::new(
-                ErrorKind::InvalidInput,
-                "invalid buffer range",
-            ))
-        }
-    }
-}
-
-impl std::io::Write for MappedFile {
-    fn flush(&mut self) -> std::io::Result<()> {
-        // This is done by the system.
-        Ok(())
-    }
-    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-        // Determine if we need to resize the file.
-        let buf_len = u64::try_from(buf.len()).map_err(|e| {
-            std::io::Error::new(
-                ErrorKind::InvalidInput,
-                format!("buffer length too large for this platform: {e}"),
-            )
-        })?;
-
-        if self.off.saturating_add(buf_len) >= self.len {
-            self.resize(self.off.saturating_add(buf_len))?;
-        }
-
-        let off = usize::try_from(self.off).map_err(|e| {
-            std::io::Error::new(
-                ErrorKind::InvalidInput,
-                format!("offset too large for this platform: {e}"),
-            )
-        })?;
-        let len = buf.len();
-
-        if let Some(dest) = self.map.get_mut(off..off.saturating_add(len)) {
-            dest.copy_from_slice(buf);
-            self.off = self.off.saturating_add(buf_len);
-            Ok(len)
-        } else {
-            Err(std::io::Error::new(
-                ErrorKind::InvalidInput,
-                "invalid buffer range",
-            ))
-        }
-    }
-}
-
-impl std::io::Seek for MappedFile {
-    fn seek(&mut self, pos: std::io::SeekFrom) -> std::io::Result<u64> {
-        let off = match pos {
-            std::io::SeekFrom::Start(i) => i,
-            std::io::SeekFrom::End(i) => {
-                if i <= 0 {
-                    // If i is negative or zero, we're seeking backwards from the end
-                    // or exactly at the end
-                    self.len.saturating_sub(i.unsigned_abs())
-                } else {
-                    // If i is positive, we're seeking beyond the end, which is allowed
-                    // but requires extending the file
-                    self.len.saturating_add(i.unsigned_abs())
-                }
-            }
-            std::io::SeekFrom::Current(i) => {
-                if i >= 0 {
-                    self.off.saturating_add(i.unsigned_abs())
-                } else {
-                    self.off.saturating_sub(i.unsigned_abs())
-                }
-            }
-        };
-
-        // If the offset is beyond EOF, extend the file to the new size.
-        if off > self.len {
-            self.resize(off)?;
-        }
-
-        self.off = off;
-        Ok(off)
-    }
-}
-
-impl tokio::io::AsyncRead for MappedFile {
-    fn poll_read(
-        mut self: std::pin::Pin<&mut Self>,
-        _cx: &mut std::task::Context<'_>,
-        buf: &mut tokio::io::ReadBuf<'_>,
-    ) -> std::task::Poll<std::io::Result<()>> {
-        let wbuf = buf.initialize_unfilled();
-        let len = wbuf.len();
-
-        std::task::Poll::Ready(match self.read(wbuf) {
-            Ok(_) => {
-                buf.advance(len);
-                Ok(())
-            }
-            Err(e) => Err(e),
-        })
-    }
-}
-
-impl tokio::io::AsyncWrite for MappedFile {
-    fn poll_flush(
-        self: std::pin::Pin<&mut Self>,
-        _cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Result<(), std::io::Error>> {
-        std::task::Poll::Ready(Ok(()))
-    }
-
-    fn poll_shutdown(
-        self: std::pin::Pin<&mut Self>,
-        _cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Result<(), std::io::Error>> {
-        std::task::Poll::Ready(Ok(()))
-    }
-
-    fn poll_write(
-        mut self: std::pin::Pin<&mut Self>,
-        _cx: &mut std::task::Context<'_>,
-        buf: &[u8],
-    ) -> std::task::Poll<Result<usize, std::io::Error>> {
-        std::task::Poll::Ready(self.write(buf))
-    }
-}
-
-impl tokio::io::AsyncSeek for MappedFile {
-    fn poll_complete(
-        self: std::pin::Pin<&mut Self>,
-        _cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<std::io::Result<u64>> {
-        std::task::Poll::Ready(Ok(self.off))
-    }
-
-    fn start_seek(
-        mut self: std::pin::Pin<&mut Self>,
-        position: std::io::SeekFrom,
-    ) -> std::io::Result<()> {
-        self.seek(position).map(|_p| ())
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use rand::Rng as _;
-    use std::io::Write as _;
-
-    use super::*;
-
-    #[test]
-    fn basic_rw() {
-        let tmp = std::env::temp_dir().join(
-            rand::thread_rng()
-                .sample_iter(rand::distributions::Alphanumeric)
-                .take(10)
-                .map(char::from)
-                .collect::<String>(),
-        );
-
-        let mut m = MappedFile::new(
-            std::fs::File::options()
-                .create(true)
-                .truncate(true)
-                .read(true)
-                .write(true)
-                .open(&tmp)
-                .expect("Failed to open temporary file"),
-        )
-        .expect("Failed to create MappedFile");
-
-        m.write_all(b"abcd123").expect("Failed to write data");
-        let _: u64 = m
-            .seek(std::io::SeekFrom::Start(0))
-            .expect("Failed to seek to start");
-
-        let mut buf = [0_u8; 7];
-        m.read_exact(&mut buf).expect("Failed to read data");
-
-        assert_eq!(&buf, b"abcd123");
-
-        drop(m);
-        std::fs::remove_file(tmp).expect("Failed to remove temporary file");
-    }
-}

src/oauth.rs

···
 //! OAuth endpoints
 #![allow(unnameable_types, unused_qualifications)]
+use crate::config::AppConfig;
+use crate::error::Error;
 use crate::metrics::AUTH_FAILED;
-use crate::{AppConfig, AppState, Client, Error, Result, SigningKey};
+use crate::serve::{AppState, Client, Result, SigningKey};
 use anyhow::{Context as _, anyhow};
 use argon2::{Argon2, PasswordHash, PasswordVerifier as _};
 use atrium_crypto::keypair::Did as _;

src/plc.rs

···
-//! PLC operations.
-use std::collections::HashMap;
-
-use anyhow::{Context as _, bail};
-use base64::Engine as _;
-use serde::{Deserialize, Serialize};
-use tracing::debug;
-
-use crate::{Client, RotationKey};
-
-/// The URL of the public PLC directory.
-const PLC_DIRECTORY: &str = "https://plc.directory/";
-
-#[derive(Debug, Deserialize, Serialize, Clone)]
-#[serde(rename_all = "camelCase", tag = "type")]
-/// A PLC service.
-pub(crate) enum PlcService {
-    #[serde(rename = "AtprotoPersonalDataServer")]
-    /// A personal data server.
-    Pds {
-        /// The URL of the PDS.
-        endpoint: String,
-    },
-}
-
-#[expect(
-    clippy::arbitrary_source_item_ordering,
-    reason = "serialized data might be structured"
-)]
-#[derive(Debug, Deserialize, Serialize, Clone)]
-#[serde(rename_all = "camelCase")]
-pub(crate) struct PlcOperation {
-    #[serde(rename = "type")]
-    pub typ: String,
-    pub rotation_keys: Vec<String>,
-    pub verification_methods: HashMap<String, String>,
-    pub also_known_as: Vec<String>,
-    pub services: HashMap<String, PlcService>,
-    pub prev: Option<String>,
-}
-
-impl PlcOperation {
-    /// Sign an operation with the provided signature.
-    pub(crate) fn sign(self, sig: Vec<u8>) -> SignedPlcOperation {
-        SignedPlcOperation {
-            typ: self.typ,
-            rotation_keys: self.rotation_keys,
-            verification_methods: self.verification_methods,
-            also_known_as: self.also_known_as,
-            services: self.services,
-            prev: self.prev,
-            sig: base64::prelude::BASE64_URL_SAFE_NO_PAD.encode(sig),
-        }
-    }
-}
-
-#[expect(
-    clippy::arbitrary_source_item_ordering,
-    reason = "serialized data might be structured"
-)]
-#[derive(Debug, Deserialize, Serialize, Clone)]
-#[serde(rename_all = "camelCase")]
-/// A signed PLC operation.
-pub(crate) struct SignedPlcOperation {
-    #[serde(rename = "type")]
-    pub typ: String,
-    pub rotation_keys: Vec<String>,
-    pub verification_methods: HashMap<String, String>,
-    pub also_known_as: Vec<String>,
-    pub services: HashMap<String, PlcService>,
-    pub prev: Option<String>,
-    pub sig: String,
-}
-
-pub(crate) fn sign_op(rkey: &RotationKey, op: PlcOperation) -> anyhow::Result<SignedPlcOperation> {
-    let bytes = serde_ipld_dagcbor::to_vec(&op).context("failed to encode op")?;
-    let bytes = rkey.sign(&bytes).context("failed to sign op")?;
-
-    Ok(op.sign(bytes))
-}
-
-/// Submit a PLC operation to the public directory.
-pub(crate) async fn submit(
-    client: &Client,
-    did: &str,
-    op: &SignedPlcOperation,
-) -> anyhow::Result<()> {
-    debug!(
-        "submitting {} {}",
-        did,
-        serde_json::to_string(&op).context("should serialize")?
-    );
-
-    let res = client
-        .post(format!("{PLC_DIRECTORY}{did}"))
-        .json(&op)
-        .send()
-        .await
-        .context("failed to send directory request")?;
-
-    if res.status().is_success() {
-        Ok(())
-    } else {
-        let e = res
-            .json::<serde_json::Value>()
-            .await
-            .context("failed to read error response")?;
-
-        bail!(
-            "error from PLC directory: {}",
-            serde_json::to_string(&e).context("should serialize")?
-        );
-    }
-}

src/serve.rs

···
+use super::account_manager::{AccountManager, SharedAccountManager};
+use super::config::AppConfig;
+use super::db::establish_pool;
+pub use super::error::Error;
+use super::service_proxy::service_proxy;
+use anyhow::Context as _;
+use atrium_api::types::string::Did;
+use atrium_crypto::keypair::{Export as _, Secp256k1Keypair};
+use axum::{Router, extract::FromRef, routing::get};
+use clap::Parser;
+use clap_verbosity_flag::{InfoLevel, Verbosity, log::LevelFilter};
+use deadpool_diesel::sqlite::Pool;
+use diesel::prelude::*;
+use diesel_migrations::{EmbeddedMigrations, embed_migrations};
+use figment::{Figment, providers::Format as _};
+use http_cache_reqwest::{CacheMode, HttpCacheOptions, MokaManager};
+use rsky_pds::{crawlers::Crawlers, sequencer::Sequencer};
+use serde::{Deserialize, Serialize};
+use std::{
+    net::{IpAddr, Ipv4Addr, SocketAddr},
+    path::PathBuf,
+    str::FromStr as _,
+    sync::Arc,
+};
+use tokio::{net::TcpListener, sync::RwLock};
+use tower_http::{cors::CorsLayer, trace::TraceLayer};
+use tracing::{info, warn};
+use uuid::Uuid;
+
+/// The application user agent. Concatenates the package name and version. e.g. `bluepds/0.0.0`.
+pub const APP_USER_AGENT: &str = concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"),);
+
+/// Embedded migrations
+pub const MIGRATIONS: EmbeddedMigrations = embed_migrations!("./migrations");
+
+/// The application-wide result type.
+pub type Result<T> = std::result::Result<T, Error>;
+/// The reqwest client type with middleware.
+pub type Client = reqwest_middleware::ClientWithMiddleware;
+
+/// The Shared Sequencer which requests crawls from upstream relays and emits events to the firehose.
+pub struct SharedSequencer {
+    /// The sequencer instance.
+    pub sequencer: RwLock<Sequencer>,
+}
+
+#[expect(
+    clippy::arbitrary_source_item_ordering,
+    reason = "serialized data might be structured"
+)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+/// The key data structure.
+struct KeyData {
+    /// Primary signing key for all repo operations.
+    skey: Vec<u8>,
+    /// Primary signing (rotation) key for all PLC operations.
+    rkey: Vec<u8>,
+}
+
+// FIXME: We should use P256Keypair instead. SecP256K1 is primarily used for cryptocurrencies,
+// and the implementations of this algorithm are much more limited as compared to P256.
+//
+// Reference: https://soatok.blog/2022/05/19/guidance-for-choosing-an-elliptic-curve-signature-algorithm-in-2022/
+#[derive(Clone)]
+/// The signing key for PLC/DID operations.
+pub struct SigningKey(Arc<Secp256k1Keypair>);
+#[derive(Clone)]
+/// The rotation key for PLC operations.
+pub struct RotationKey(Arc<Secp256k1Keypair>);
+
+impl std::ops::Deref for SigningKey {
+    type Target = Secp256k1Keypair;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl SigningKey {
+    /// Import from a private key.
+    pub fn import(key: &[u8]) -> Result<Self> {
+        let key = Secp256k1Keypair::import(key).context("failed to import signing key")?;
+        Ok(Self(Arc::new(key)))
+    }
+}
+
+impl std::ops::Deref for RotationKey {
+    type Target = Secp256k1Keypair;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[derive(Parser, Debug, Clone)]
+/// Command line arguments.
+pub struct Args {
+    /// Path to the configuration file
+    #[arg(short, long, default_value = "default.toml")]
+    pub config: PathBuf,
+    /// The verbosity level.
+    #[command(flatten)]
+    pub verbosity: Verbosity<InfoLevel>,
+}
+
+/// The actor pools for the database connections.
+pub struct ActorStorage {
+    /// The database connection pool for the actor's repository.
+    pub repo: Pool,
+    /// The file storage path for the actor's blobs.
+    pub blob: PathBuf,
+}
+
+impl Clone for ActorStorage {
+    fn clone(&self) -> Self {
+        Self {
+            repo: self.repo.clone(),
+            blob: self.blob.clone(),
+        }
+    }
+}
+
+#[expect(clippy::arbitrary_source_item_ordering, reason = "arbitrary")]
+#[derive(Clone, FromRef)]
+/// The application state, shared across all routes.
+pub struct AppState {
+    /// The application configuration.
+    pub(crate) config: AppConfig,
+    /// The main database connection pool. Used for common PDS data, like invite codes.
+    pub db: Pool,
+    /// Actor-specific database connection pools. Hashed by DID.
+    pub db_actors: std::collections::HashMap<String, ActorStorage>,
+
+    /// The HTTP client with middleware.
+    pub client: Client,
+    /// The simple HTTP client.
+    pub simple_client: reqwest::Client,
+    /// The firehose producer.
+    pub sequencer: Arc<SharedSequencer>,
+    /// The account manager.
+    pub account_manager: Arc<SharedAccountManager>,
+
+    /// The signing key.
+    pub signing_key: SigningKey,
+    /// The rotation key.
+    pub rotation_key: RotationKey,
+}
+
+/// The main application entry point.
+#[expect(
+    clippy::cognitive_complexity,
+    clippy::too_many_lines,
+    unused_qualifications,
+    reason = "main function has high complexity"
+)]
+pub async fn run() -> anyhow::Result<()> {
+    let args = Args::parse();
+
+    // Set up trace logging to console and account for the user-provided verbosity flag.
+    if args.verbosity.log_level_filter() != LevelFilter::Off {
+        let lvl = match args.verbosity.log_level_filter() {
+            LevelFilter::Error => tracing::Level::ERROR,
+            LevelFilter::Warn => tracing::Level::WARN,
+            LevelFilter::Info | LevelFilter::Off => tracing::Level::INFO,
+            LevelFilter::Debug => tracing::Level::DEBUG,
+            LevelFilter::Trace => tracing::Level::TRACE,
+        };
+        tracing_subscriber::fmt().with_max_level(lvl).init();
+    }
+
+    if !args.config.exists() {
+        // Throw up a warning if the config file does not exist.
+        //
+        // This is not fatal because users can specify all configuration settings via
+        // the environment, but the most likely scenario here is that a user accidentally
+        // omitted the config file for some reason (e.g. forgot to mount it into Docker).
+        warn!(
+            "configuration file {} does not exist",
+            args.config.display()
+        );
+    }
+
+    // Read and parse the user-provided configuration.
+    let config: AppConfig = Figment::new()
+        .admerge(figment::providers::Toml::file(args.config))
+        .admerge(figment::providers::Env::prefixed("BLUEPDS_"))
+        .extract()
+        .context("failed to load configuration")?;
+
+    if config.test {
+        warn!("BluePDS starting up in TEST mode.");
+        warn!("This means the application will not federate with the rest of the network.");
+        warn!(
+            "If you want to turn this off, either set `test` to false in the config or define `BLUEPDS_TEST = false`"
+        );
+    }
+
+    // Initialize metrics reporting.
+    super::metrics::setup(config.metrics.as_ref()).context("failed to set up metrics exporter")?;
+
+    // Create a reqwest client that will be used for all outbound requests.
+    let simple_client = reqwest::Client::builder()
+        .user_agent(APP_USER_AGENT)
+        .build()
+        .context("failed to build requester client")?;
+    let client = reqwest_middleware::ClientBuilder::new(simple_client.clone())
+        .with(http_cache_reqwest::Cache(http_cache_reqwest::HttpCache {
+            mode: CacheMode::Default,
+            manager: MokaManager::default(),
+            options: HttpCacheOptions::default(),
+        }))
+        .build();
+
+    tokio::fs::create_dir_all(&config.key.parent().context("should have parent")?)
+        .await
+        .context("failed to create key directory")?;
+
+    // Check if crypto keys exist. If not, create new ones.
+    let (skey, rkey) = if let Ok(f) = std::fs::File::open(&config.key) {
+        let keys: KeyData = serde_ipld_dagcbor::from_reader(std::io::BufReader::new(f))
+            .context("failed to deserialize crypto keys")?;
+
+        let skey = Secp256k1Keypair::import(&keys.skey).context("failed to import signing key")?;
+        let rkey = Secp256k1Keypair::import(&keys.rkey).context("failed to import rotation key")?;
+
+        (SigningKey(Arc::new(skey)), RotationKey(Arc::new(rkey)))
+    } else {
+        info!("signing keys not found, generating new ones");
+
+        let skey = Secp256k1Keypair::create(&mut rand::thread_rng());
+        let rkey = Secp256k1Keypair::create(&mut rand::thread_rng());
+
+        let keys = KeyData {
+            skey: skey.export(),
+            rkey: rkey.export(),
+        };
+
+        let mut f = std::fs::File::create(&config.key).context("failed to create key file")?;
+        serde_ipld_dagcbor::to_writer(&mut f, &keys).context("failed to serialize crypto keys")?;
+
+        (SigningKey(Arc::new(skey)), RotationKey(Arc::new(rkey)))
+    };
+
+    tokio::fs::create_dir_all(&config.repo.path).await?;
+    tokio::fs::create_dir_all(&config.plc.path).await?;
+    tokio::fs::create_dir_all(&config.blob.path).await?;
+
+    // Create a database connection manager and pool for the main database.
+    let pool =
+        establish_pool(&config.db).context("failed to establish database connection pool")?;
+
+    // Create a dictionary of database connection pools for each actor.
+    let mut actor_pools = std::collections::HashMap::new();
+    // We'll determine actors by looking in the data/repo dir for .db files.
+    let mut actor_dbs = tokio::fs::read_dir(&config.repo.path)
+        .await
+        .context("failed to read repo directory")?;
+    while let Some(entry) = actor_dbs
+        .next_entry()
+        .await
+        .context("failed to read repo dir")?
+    {
+        let path = entry.path();
+        if path.extension().and_then(|s| s.to_str()) == Some("db") {
+            let actor_repo_pool = establish_pool(&format!("sqlite://{}", path.display()))
+                .context("failed to create database connection pool")?;
+
+            let did = Did::from_str(&format!(
+                "did:plc:{}",
+                path.file_stem()
+                    .and_then(|s| s.to_str())
+                    .context("failed to get actor DID")?
+            ))
+            .expect("should be able to parse actor DID")
+            .to_string();
+            let blob_path = config.blob.path.to_path_buf();
+            let actor_storage = ActorStorage {
+                repo: actor_repo_pool,
+                blob: blob_path.clone(),
+            };
+            drop(actor_pools.insert(did, actor_storage));
+        }
+    }
+    // Apply pending migrations
+    // let conn = pool.get().await?;
+    // conn.run_pending_migrations(MIGRATIONS)
+    //     .expect("should be able to run migrations");
+
+    let hostname = config.host_name.clone();
+    let crawlers: Vec<String> = config
+        .firehose
+        .relays
+        .iter()
+        .map(|s| s.to_string())
+        .collect();
+    let sequencer = Arc::new(SharedSequencer {
+        sequencer: RwLock::new(Sequencer::new(
+            Crawlers::new(hostname, crawlers.clone()),
+            None,
+        )),
+    });
+    let account_manager = SharedAccountManager {
+        account_manager: RwLock::new(AccountManager::new(pool.clone())),
+    };
+
+    let addr = config
+        .listen_address
+        .unwrap_or(SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 8000));
+
+    let app = Router::new()
+        .route("/", get(super::index))
+        .merge(super::oauth::routes())
+        .nest(
+            "/xrpc",
+            super::apis::routes()
+                .merge(super::actor_endpoints::routes())
+                .fallback(service_proxy),
+        )
+        // .layer(RateLimitLayer::new(30, Duration::from_secs(30)))
+        .layer(CorsLayer::permissive())
+        .layer(TraceLayer::new_for_http())
+        .with_state(AppState {
+            config: config.clone(),
+            db: pool.clone(),
+            db_actors: actor_pools.clone(),
+            client: client.clone(),
+            simple_client,
+            sequencer: sequencer.clone(),
+            account_manager: Arc::new(account_manager),
+            signing_key: skey,
+            rotation_key: rkey,
+        });
+
+    info!("listening on {addr}");
+    info!("connect to: http://127.0.0.1:{}", addr.port());
+
+    // Determine whether or not this was the first startup (i.e. no accounts exist and no invite codes were created).
+    // If so, create an invite code and share it via the console.
+    let conn = pool.get().await.context("failed to get db connection")?;
+
+    #[derive(QueryableByName)]
+    struct TotalCount {
+        #[diesel(sql_type = diesel::sql_types::Integer)]
+        total_count: i32,
+    }
+
+    let result = conn.interact(move |conn| {
+        diesel::sql_query(
+            "SELECT (SELECT COUNT(*) FROM account) + (SELECT COUNT(*) FROM invite_code) AS total_count",
+        )
+        .get_result::<TotalCount>(conn)
+    })
+    .await
+    .expect("should be able to query database")?;
+
+    let c = result.total_count;
+
+    #[expect(clippy::print_stdout)]
+    if c == 0 {
+        let uuid = Uuid::new_v4().to_string();
+
+        use crate::models::pds as models;
+        use crate::schema::pds::invite_code::dsl as InviteCode;
+        let uuid_clone = uuid.clone();
+        drop(
+            conn.interact(move |conn| {
+                diesel::insert_into(InviteCode::invite_code)
+                    .values(models::InviteCode {
+                        code: uuid_clone,
+                        available_uses: 1,
+                        disabled: 0,
+                        for_account: "None".to_owned(),
+                        created_by: "None".to_owned(),
+                        created_at: "None".to_owned(),
+                    })
+                    .execute(conn)
+                    .context("failed to create new invite code")
+            })
+            .await
+            .expect("should be able to create invite code"),
+        );
+
+        // N.B: This is a sensitive message, so we're bypassing `tracing` here and
+        // logging it directly to console.
+        println!("=====================================");
+        println!("            FIRST STARTUP            ");
+        println!("=====================================");
+        println!("Use this code to create an account:");
+        println!("{uuid}");
+        println!("=====================================");
+    }
+
+    let listener = TcpListener::bind(&addr)
+        .await
+        .context("failed to bind address")?;
+
+    // Serve the app, and request crawling from upstream relays.
+    let serve = tokio::spawn(async move {
+        axum::serve(listener, app.into_make_service())
+            .await
+            .context("failed to serve app")
+    });
+
+    // Now that the app is live, request a crawl from upstream relays.
+    let mut background_sequencer = sequencer.sequencer.write().await.clone();
+    drop(tokio::spawn(
+        async move { background_sequencer.start().await },
+    ));
+
+    serve
+        .await
+        .map_err(Into::into)
+        .and_then(|r| r)
+        .context("failed to serve app")
+}

src/service_proxy.rs

···
 /// Reference: <https://atproto.com/specs/xrpc#service-proxying>
 use anyhow::{Context as _, anyhow};
 use atrium_api::types::string::Did;
-use atrium_crypto::keypair::{Export as _, Secp256k1Keypair};
 use axum::{
-    Router,
     body::Body,
-    extract::{FromRef, Request, State},
+    extract::{Request, State},
     http::{self, HeaderMap, Response, StatusCode, Uri},
-    response::IntoResponse,
-    routing::get,
 };
-use azure_core::credentials::TokenCredential;
-use clap::Parser;
-use clap_verbosity_flag::{InfoLevel, Verbosity, log::LevelFilter};
-use deadpool_diesel::sqlite::Pool;
-use diesel::prelude::*;
-use diesel_migrations::{EmbeddedMigrations, embed_migrations};
-use figment::{Figment, providers::Format as _};
-use http_cache_reqwest::{CacheMode, HttpCacheOptions, MokaManager};
 use rand::Rng as _;
-use serde::{Deserialize, Serialize};
-use std::{
-    net::{IpAddr, Ipv4Addr, SocketAddr},
-    path::PathBuf,
-    str::FromStr as _,
-    sync::Arc,
-};
-use tokio::net::TcpListener;
-use tower_http::{cors::CorsLayer, trace::TraceLayer};
-use tracing::{info, warn};
-use uuid::Uuid;
+use std::str::FromStr as _;
 
-use super::{Client, Error, Result};
-use crate::{AuthenticatedUser, SigningKey};
+use super::{
+    auth::AuthenticatedUser,
+    serve::{Client, Error, Result, SigningKey},
+};
 
 pub(super) async fn service_proxy(
     uri: Uri,

src/tests.rs

···
-//! Testing utilities for the PDS.
-#![expect(clippy::arbitrary_source_item_ordering)]
-use std::{
-    net::{IpAddr, Ipv4Addr, SocketAddr, TcpListener},
-    path::PathBuf,
-    time::{Duration, Instant},
-};
-
-use anyhow::Result;
-use atrium_api::{
-    com::atproto::server,
-    types::string::{AtIdentifier, Did, Handle, Nsid, RecordKey},
-};
-use figment::{Figment, providers::Format as _};
-use futures::future::join_all;
-use serde::{Deserialize, Serialize};
-use tokio::sync::OnceCell;
-use uuid::Uuid;
-
-use crate::config::AppConfig;
-
-/// Global test state, created once for all tests.
-pub(crate) static TEST_STATE: OnceCell<TestState> = OnceCell::const_new();
-
-/// A temporary test directory that will be cleaned up when the struct is dropped.
-struct TempDir {
-    /// The path to the directory.
-    path: PathBuf,
-}
-
-impl TempDir {
-    /// Create a new temporary directory.
-    fn new() -> Result<Self> {
-        let path = std::env::temp_dir().join(format!("bluepds-test-{}", Uuid::new_v4()));
-        std::fs::create_dir_all(&path)?;
-        Ok(Self { path })
-    }
-
-    /// Get the path to the directory.
-    fn path(&self) -> &PathBuf {
-        &self.path
-    }
-}
-
-impl Drop for TempDir {
-    fn drop(&mut self) {
-        drop(std::fs::remove_dir_all(&self.path));
-    }
-}
-
-/// Test state for the application.
-pub(crate) struct TestState {
-    /// The address the test server is listening on.
-    address: SocketAddr,
-    /// The HTTP client.
-    client: reqwest::Client,
-    /// The application configuration.
-    config: AppConfig,
-    /// The temporary directory for test data.
-    #[expect(dead_code)]
-    temp_dir: TempDir,
-}
-
-impl TestState {
-    /// Get a base URL for the test server.
-    pub(crate) fn base_url(&self) -> String {
-        format!("http://{}", self.address)
-    }
-
-    /// Create a test account.
-    pub(crate) async fn create_test_account(&self) -> Result<TestAccount> {
-        // Create the account
-        let handle = "test.handle";
-        let response = self
-            .client
-            .post(format!(
-                "http://{}/xrpc/com.atproto.server.createAccount",
-                self.address
-            ))
-            .json(&server::create_account::InputData {
-                did: None,
-                verification_code: None,
-                verification_phone: None,
-                email: Some(format!("{}@example.com", &handle)),
-                handle: Handle::new(handle.to_owned()).expect("should be able to create handle"),
-                password: Some("password123".to_owned()),
-                invite_code: None,
-                recovery_key: None,
-                plc_op: None,
-            })
-            .send()
-            .await?;
-
-        let account: server::create_account::Output = response.json().await?;
-
-        Ok(TestAccount {
-            handle: handle.to_owned(),
-            did: account.did.to_string(),
-            access_token: account.access_jwt.clone(),
-            refresh_token: account.refresh_jwt.clone(),
-        })
-    }
-
-    /// Create a new test state.
-    #[expect(clippy::unused_async)]
-    async fn new() -> Result<Self> {
-        // Configure the test app
-        #[derive(Serialize, Deserialize)]
-        struct TestConfigInput {
-            db: Option<String>,
-            host_name: Option<String>,
-            key: Option<PathBuf>,
-            listen_address: Option<SocketAddr>,
-            test: Option<bool>,
-        }
-        // Create a temporary directory for test data
-        let temp_dir = TempDir::new()?;
-
-        // Find a free port
-        let listener = TcpListener::bind(SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 0))?;
-        let address = listener.local_addr()?;
-        drop(listener);
-
-        let test_config = TestConfigInput {
-            db: Some(format!("sqlite://{}/test.db", temp_dir.path().display())),
-            host_name: Some(format!("localhost:{}", address.port())),
-            key: Some(temp_dir.path().join("test.key")),
-            listen_address: Some(address),
-            test: Some(true),
-        };
-
-        let config: AppConfig = Figment::new()
-            .admerge(figment::providers::Toml::file("default.toml"))
-            .admerge(figment::providers::Env::prefixed("BLUEPDS_"))
-            .merge(figment::providers::Serialized::defaults(test_config))
-            .merge(
-                figment::providers::Toml::string(
-                    r#"
-                [firehose]
-                relays = []
-
-                [repo]
-                path = "repo"
-
-                [plc]
-                path = "plc"
-
-                [blob]
-                path = "blob"
-                limit = 10485760   # 10 MB
-            "#,
-                )
-                .nested(),
-            )
-            .extract()?;
-
-        // Create directories
-        std::fs::create_dir_all(temp_dir.path().join("repo"))?;
-        std::fs::create_dir_all(temp_dir.path().join("plc"))?;
-        std::fs::create_dir_all(temp_dir.path().join("blob"))?;
-
-        // Create client
-        let client = reqwest::Client::builder()
-            .timeout(Duration::from_secs(30))
-            .build()?;
-
-        Ok(Self {
-            address,
-            client,
-            config,
-            temp_dir,
-        })
-    }
-
-    /// Start the application in a background task.
-    async fn start_app(&self) -> Result<()> {
-        // // Get a reference to the config that can be moved into the task
-        // let config = self.config.clone();
-        // let address = self.address;
-
-        // // Start the application in a background task
-        // let _handle = tokio::spawn(async move {
-        //     // Set up the application
-        //     use crate::*;
-
-        //     // Initialize metrics (noop in test mode)
-        //     drop(metrics::setup(None));
-
-        //     // Create client
-        //     let simple_client = reqwest::Client::builder()
-        //         .user_agent(APP_USER_AGENT)
-        //         .build()
-        //         .context("failed to build requester client")?;
-        //     let client = reqwest_middleware::ClientBuilder::new(simple_client.clone())
-        //         .with(http_cache_reqwest::Cache(http_cache_reqwest::HttpCache {
-        //             mode: CacheMode::Default,
-        //             manager: MokaManager::default(),
-        //             options: HttpCacheOptions::default(),
-        //         }))
-        //         .build();
-
-        //     // Create a test keypair
-        //     std::fs::create_dir_all(config.key.parent().context("should have parent")?)?;
-        //     let (skey, rkey) = {
-        //         let skey = Secp256k1Keypair::create(&mut rand::thread_rng());
-        //         let rkey = Secp256k1Keypair::create(&mut rand::thread_rng());
-
-        //         let keys = KeyData {
-        //             skey: skey.export(),
-        //             rkey: rkey.export(),
-        //         };
-
-        //         let mut f =
-        //             std::fs::File::create(&config.key).context("failed to create key file")?;
-        //         serde_ipld_dagcbor::to_writer(&mut f, &keys)
-        //             .context("failed to serialize crypto keys")?;
-
-        //         (SigningKey(Arc::new(skey)), RotationKey(Arc::new(rkey)))
-        //     };
-
-        //     // Set up database
-        //     let opts = SqliteConnectOptions::from_str(&config.db)
-        //         .context("failed to parse database options")?
-        //         .create_if_missing(true);
-        //     let db = SqliteDbConn::connect_with(opts).await?;
-
-        //     sqlx::migrate!()
-        //         .run(&db)
-        //         .await
-        //         .context("failed to apply migrations")?;
-
-        //     // Create firehose
-        //     let (_fh, fhp) = firehose::spawn(client.clone(), config.clone());
-
-        //     // Create the application state
-        //     let app_state = AppState {
-        //         cred: azure_identity::DefaultAzureCredential::new()?,
-        //         config: config.clone(),
-        //         db: db.clone(),
-        //         client: client.clone(),
-        //         simple_client,
-        //         firehose: fhp,
-        //         signing_key: skey,
-        //         rotation_key: rkey,
-        //     };
-
-        //     // Create the router
-        //     let app = Router::new()
-        //         .route("/", get(index))
-        //         .merge(oauth::routes())
-        //         .nest(
-        //             "/xrpc",
-        //             endpoints::routes()
-        //                 .merge(actor_endpoints::routes())
-        //                 .fallback(service_proxy),
-        //         )
-        //         .layer(CorsLayer::permissive())
-        //         .layer(TraceLayer::new_for_http())
-        //         .with_state(app_state);
-
-        //     // Listen for connections
-        //     let listener = TcpListener::bind(&address)
-        //         .await
-        //         .context("failed to bind address")?;
-
-        //     axum::serve(listener, app.into_make_service())
-        //         .await
-        //         .context("failed to serve app")
-        // });
-
-        // // Give the server a moment to start
-        // tokio::time::sleep(Duration::from_millis(500)).await;
-
-        Ok(())
-    }
-}
-
-/// A test account that can be used for testing.
-pub(crate) struct TestAccount {
-    /// The access token for the account.
-    pub(crate) access_token: String,
-    /// The account DID.
-    pub(crate) did: String,
-    /// The account handle.
-    pub(crate) handle: String,
-    /// The refresh token for the account.
-    #[expect(dead_code)]
-    pub(crate) refresh_token: String,
-}
-
-/// Initialize the test state.
-pub(crate) async fn init_test_state() -> Result<&'static TestState> {
-    async fn init_test_state() -> std::result::Result<TestState, anyhow::Error> {
-        let state = TestState::new().await?;
-        state.start_app().await?;
-        Ok(state)
-    }
-    TEST_STATE.get_or_try_init(init_test_state).await
-}
-
-/// Create a record benchmark that creates records and measures the time it takes.
-#[expect(
-    clippy::arithmetic_side_effects,
-    clippy::integer_division,
-    clippy::integer_division_remainder_used,
-    clippy::use_debug,
-    clippy::print_stdout
-)]
-pub(crate) async fn create_record_benchmark(count: usize, concurrent: usize) -> Result<Duration> {
-    // Initialize the test state
-    let state = init_test_state().await?;
-
-    // Create a test account
-    let account = state.create_test_account().await?;
-
-    // Create the client with authorization
-    let client = reqwest::Client::builder()
-        .timeout(Duration::from_secs(30))
-        .build()?;
-
-    let start = Instant::now();
-
-    // Split the work into batches
-    let mut handles = Vec::new();
-    for batch_idx in 0..concurrent {
-        let batch_size = count / concurrent;
-        let client = client.clone();
-        let base_url = state.base_url();
-        let account_did = account.did.clone();
-        let account_handle = account.handle.clone();
-        let access_token = account.access_token.clone();
-
-        let handle = tokio::spawn(async move {
-            let mut results = Vec::new();
-
-            for i in 0..batch_size {
-                let request_start = Instant::now();
-                let record_idx = batch_idx * batch_size + i;
-
-                let result = client
-                    .post(format!("{base_url}/xrpc/com.atproto.repo.createRecord"))
-                    .header("Authorization", format!("Bearer {access_token}"))
-                    .json(&atrium_api::com::atproto::repo::create_record::InputData {
-                        repo: AtIdentifier::Did(Did::new(account_did.clone()).expect("valid DID")),
-                        collection: Nsid::new("app.bsky.feed.post".to_owned()).expect("valid NSID"),
-                        rkey: Some(
-                            RecordKey::new(format!("test-{record_idx}")).expect("valid record key"),
-                        ),
-                        validate: None,
-                        record: serde_json::from_str(
-                            &serde_json::json!({
-                                "$type": "app.bsky.feed.post",
-                                "text": format!("Test post {record_idx} from {account_handle}"),
-                                "createdAt": chrono::Utc::now().to_rfc3339(),
-                            })
-                            .to_string(),
-                        )
-                        .expect("valid JSON record"),
-                        swap_commit: None,
-                    })
-                    .send()
-                    .await;
-
-                // Fetch the record we just created
-                let get_response = client
-                    .get(format!(
-                        "{base_url}/xrpc/com.atproto.sync.getRecord?did={account_did}&collection=app.bsky.feed.post&rkey={record_idx}"
-                    ))
-                    .header("Authorization", format!("Bearer {access_token}"))
-                    .send()
-                    .await;
-                if get_response.is_err() {
-                    println!("Failed to fetch record {record_idx}: {get_response:?}");
-                    results.push(get_response);
-                    continue;
-                }
-
-                let request_duration = request_start.elapsed();
-                if record_idx % 10 == 0 {
-                    println!("Created record {record_idx} in {request_duration:?}");
-                }
-                results.push(result);
-            }
-
-            results
-        });
-
-        handles.push(handle);
-    }
-
-    // Wait for all batches to complete
-    let results = join_all(handles).await;
-
-    // Check for errors
-    for batch_result in results {
-        let batch_responses = batch_result?;
-        for response_result in batch_responses {
-            match response_result {
-                Ok(response) => {
-                    if !response.status().is_success() {
-                        return Err(anyhow::anyhow!(
-                            "Failed to create record: {}",
-                            response.status()
-                        ));
-                    }
-                }
-                Err(err) => {
-                    return Err(anyhow::anyhow!("Failed to create record: {}", err));
-                }
-            }
-        }
-    }
-
-    let duration = start.elapsed();
-    Ok(duration)
-}
-
-#[cfg(test)]
-#[expect(clippy::module_inception, clippy::use_debug, clippy::print_stdout)]
-mod tests {
-    use super::*;
-    use anyhow::anyhow;
-
-    #[tokio::test]
-    async fn test_create_account() -> Result<()> {
-        return Ok(());
-        #[expect(unreachable_code, reason = "Disabled")]
-        let state = init_test_state().await?;
-        let account = state.create_test_account().await?;
-
-        println!("Created test account: {}", account.handle);
-        if account.handle.is_empty() {
-            return Err(anyhow::anyhow!("Account handle is empty"));
-        }
-        if account.did.is_empty() {
-            return Err(anyhow::anyhow!("Account DID is empty"));
-        }
-        if account.access_token.is_empty() {
-            return Err(anyhow::anyhow!("Account access token is empty"));
-        }
-
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn test_create_record_benchmark() -> Result<()> {
-        return Ok(());
-        #[expect(unreachable_code, reason = "Disabled")]
-        let duration = create_record_benchmark(100, 1).await?;
-
-        println!("Created 100 records in {duration:?}");
-
-        if duration.as_secs() >= 10 {
-            return Err(anyhow!("Benchmark took too long"));
-        }
-
-        Ok(())
-    }
-}