Merge pull request #26 from pubky/chore/cleanup-unused

Chore/cleanup unused

pubky-homeserver/src/config.rs

@@ -1,7 +1,7 @@
 //! Configuration for the server
 
 use anyhow::{anyhow, Result};
-use pkarr::{mainline::dht::DhtSettings, Keypair};
+use pkarr::Keypair;
 // use serde::{Deserialize, Serialize};
 use std::{fmt::Debug, path::PathBuf, time::Duration};
 

pubky-homeserver/src/database.rs

@@ -2,18 +2,12 @@ use std::fs;
 
 use std::path::Path;
 
-use bytes::Bytes;
-use heed::{types::Str, Database, Env, EnvOpenOptions, RwTxn};
+use heed::{Env, EnvOpenOptions};
 
 mod migrations;
 pub mod tables;
 
-use pubky_common::crypto::Hasher;
-
-use tables::{entries::Entry, Tables, TABLES_COUNT};
-
-use pkarr::PublicKey;
-use tables::blobs::{BlobsTable, BLOBS_TABLE};
+use tables::{Tables, TABLES_COUNT};
 
 #[derive(Debug, Clone)]
 pub struct DB {
@@ -37,12 +31,11 @@ impl DB {
 
 #[cfg(test)]
 mod tests {
+    use bytes::Bytes;
     use pkarr::Keypair;
     use pubky_common::timestamp::Timestamp;
 
-    use crate::config::Config;
-
-    use super::{Bytes, DB};
+    use super::DB;
 
     #[tokio::test]
     async fn entries() {
@@ -61,13 +54,15 @@ mod tests {
         let cloned_keypair = keypair.clone();
 
         let done = tokio::task::spawn_blocking(move || {
-            cloned.put_entry(&cloned_keypair.public_key(), path, rx);
+            cloned
+                .put_entry(&cloned_keypair.public_key(), path, rx)
+                .unwrap();
         });
 
-        tx.send(vec![1, 2, 3, 4, 5].into());
+        tx.send(vec![1, 2, 3, 4, 5].into()).unwrap();
         drop(tx);
 
-        done.await;
+        done.await.unwrap();
 
         let blob = db.get_blob(&keypair.public_key(), path).unwrap().unwrap();
 

pubky-homeserver/src/database/migrations.rs

@@ -1,4 +1,4 @@
-use heed::{types::Str, Database, Env, RwTxn};
+use heed::Env;
 
 mod m0;
 
@@ -7,7 +7,7 @@ use super::tables::Tables;
 pub fn run(env: &Env) -> anyhow::Result<Tables> {
     let mut wtxn = env.write_txn()?;
 
-    m0::run(env, &mut wtxn);
+    m0::run(env, &mut wtxn)?;
 
     let tables = Tables::new(env, &mut wtxn)?;
 

pubky-homeserver/src/database/migrations/m0.rs

@@ -1,4 +1,4 @@
-use heed::{types::Str, Database, Env, RwTxn};
+use heed::{Env, RwTxn};
 
 use crate::database::tables::{blobs, entries, sessions, users};
 

pubky-homeserver/src/database/tables/blobs.rs

@@ -1,9 +1,4 @@
-use std::{borrow::Cow, time::SystemTime};
-
-use heed::{
-    types::{Bytes, Str},
-    BoxedError, BytesDecode, BytesEncode, Database,
-};
+use heed::{types::Bytes, Database};
 use pkarr::PublicKey;
 
 use crate::database::DB;
@@ -36,7 +31,7 @@ impl DB {
             None
         };
 
-        rtxn.commit();
+        rtxn.commit()?;
 
         Ok(result)
     }

pubky-homeserver/src/database/tables/entries.rs

@@ -1,12 +1,11 @@
 use pkarr::PublicKey;
 use postcard::{from_bytes, to_allocvec};
 use serde::{Deserialize, Serialize};
-use std::{borrow::Cow, fmt::Result, time::SystemTime};
 use tracing::{debug, instrument};
 
 use heed::{
     types::{Bytes, Str},
-    BoxedError, BytesDecode, BytesEncode, Database, RoTxn,
+    Database, RoTxn,
 };
 
 use pubky_common::{
@@ -53,7 +52,9 @@ impl DB {
 
         let key = format!("{public_key}/{path}");
 
-        self.tables.entries.put(&mut wtxn, &key, &entry.serialize());
+        self.tables
+            .entries
+            .put(&mut wtxn, &key, &entry.serialize())?;
 
         wtxn.commit()?;
 
@@ -126,11 +127,11 @@ impl DB {
             .unwrap_or(next_threshold(path, "", false, reverse, shallow));
 
         for _ in 0..limit {
-            if let Some((key, _)) = (if reverse {
+            if let Some((key, _)) = if reverse {
                 self.tables.entries.get_lower_than(txn, &threshold)?
             } else {
                 self.tables.entries.get_greater_than(txn, &threshold)?
-            }) {
+            } {
                 if !key.starts_with(path) {
                     break;
                 }
@@ -228,25 +229,12 @@ impl Entry {
         self
     }
 
-    pub fn set_content_type(&mut self, content_type: &str) -> &mut Self {
-        self.content_type = content_type.to_string();
-        self
-    }
-
     // === Getters ===
 
     pub fn content_hash(&self) -> &[u8; 32] {
         &self.content_hash
     }
 
-    pub fn content_length(&self) -> usize {
-        self.content_length
-    }
-
-    pub fn content_type(&self) -> &str {
-        &self.content_type
-    }
-
     // === Public Method ===
 
     pub fn serialize(&self) -> Vec<u8> {

pubky-homeserver/src/database/tables/sessions.rs

@@ -1,12 +1,9 @@
-use std::{borrow::Cow, time::SystemTime};
-
 use heed::{
     types::{Bytes, Str},
-    BoxedError, BytesDecode, BytesEncode, Database,
+    Database,
 };
 use pkarr::PublicKey;
 use pubky_common::session::Session;
-use serde::Deserialize;
 use tower_cookies::Cookies;
 
 use crate::database::DB;
@@ -21,9 +18,8 @@ impl DB {
         &mut self,
         cookies: Cookies,
         public_key: &PublicKey,
-        path: &str,
     ) -> anyhow::Result<Option<Session>> {
-        if let Some(bytes) = self.get_session_bytes(cookies, public_key, path)? {
+        if let Some(bytes) = self.get_session_bytes(cookies, public_key)? {
             return Ok(Some(Session::deserialize(&bytes)?));
         };
 
@@ -34,7 +30,6 @@ impl DB {
         &mut self,
         cookies: Cookies,
         public_key: &PublicKey,
-        path: &str,
     ) -> anyhow::Result<Option<Vec<u8>>> {
         if let Some(cookie) = cookies.get(&public_key.to_string()) {
             let rtxn = self.env.read_txn()?;

pubky-homeserver/src/database/tables/users.rs

@@ -1,14 +1,12 @@
-use std::{borrow::Cow, time::SystemTime};
+use std::borrow::Cow;
 
 use postcard::{from_bytes, to_allocvec};
-use pubky_common::timestamp::Timestamp;
 use serde::{Deserialize, Serialize};
 
-use heed::{types::Str, BoxedError, BytesDecode, BytesEncode, Database};
+use heed::{BoxedError, BytesDecode, BytesEncode, Database};
 use pkarr::PublicKey;
 
 extern crate alloc;
-use alloc::vec::Vec;
 
 /// PublicKey => User.
 pub type UsersTable = Database<PublicKeyCodec, User>;

pubky-homeserver/src/error.rs

@@ -6,7 +6,6 @@ use axum::{
     response::IntoResponse,
 };
 use pubky_common::auth::AuthnSignatureError;
-use tracing::debug;
 
 pub type Result<T, E = Error> = core::result::Result<T, E>;
 
@@ -70,6 +69,22 @@ impl From<PathRejection> for Error {
     }
 }
 
+// === Pubky specific errors ===
+
+impl From<AuthnSignatureError> for Error {
+    fn from(error: AuthnSignatureError) -> Self {
+        Self::new(StatusCode::BAD_REQUEST, Some(error))
+    }
+}
+
+impl From<pkarr::Error> for Error {
+    fn from(error: pkarr::Error) -> Self {
+        Self::new(StatusCode::BAD_REQUEST, Some(error))
+    }
+}
+
+// === INTERNAL_SERVER_ERROR ===
+
 impl From<std::io::Error> for Error {
     fn from(error: std::io::Error) -> Self {
         Self::new(StatusCode::INTERNAL_SERVER_ERROR, error.into())
@@ -100,16 +115,8 @@ impl From<axum::Error> for Error {
     }
 }
 
-// === Pubky specific errors ===
-
-impl From<AuthnSignatureError> for Error {
-    fn from(error: AuthnSignatureError) -> Self {
-        Self::new(StatusCode::BAD_REQUEST, Some(error))
-    }
-}
-
-impl From<pkarr::Error> for Error {
-    fn from(error: pkarr::Error) -> Self {
-        Self::new(StatusCode::BAD_REQUEST, Some(error))
+impl<T> From<flume::SendError<T>> for Error {
+    fn from(error: flume::SendError<T>) -> Self {
+        Self::new(StatusCode::INTERNAL_SERVER_ERROR, error.into())
     }
 }

pubky-homeserver/src/extractors.rs

@@ -52,10 +52,6 @@ impl EntryPath {
     pub fn as_str(&self) -> &str {
         self.0.as_str()
     }
-
-    pub fn as_bytes(&self) -> &[u8] {
-        self.0.as_bytes()
-    }
 }
 
 #[async_trait]

pubky-homeserver/src/lib.rs

@@ -1,5 +1,3 @@
-#![allow(unused)]
-
 pub mod config;
 mod database;
 mod error;

pubky-homeserver/src/routes.rs

@@ -1,16 +1,10 @@
-use std::sync::Arc;
-
 use axum::{
     extract::DefaultBodyLimit,
-    http::Method,
     routing::{delete, get, post, put},
     Router,
 };
 use tower_cookies::CookieManagerLayer;
-use tower_http::{
-    cors::{self, CorsLayer},
-    trace::TraceLayer,
-};
+use tower_http::{cors::CorsLayer, trace::TraceLayer};
 
 use crate::server::AppState;
 

pubky-homeserver/src/routes/auth.rs

@@ -1,21 +1,14 @@
 use axum::{
     debug_handler,
-    extract::{Request, State},
-    http::{uri::Scheme, HeaderMap, StatusCode, Uri},
+    extract::State,
+    http::{uri::Scheme, StatusCode, Uri},
     response::IntoResponse,
-    Router,
 };
 use axum_extra::{headers::UserAgent, TypedHeader};
 use bytes::Bytes;
-use heed::BytesEncode;
-use postcard::to_allocvec;
 use tower_cookies::{cookie::SameSite, Cookie, Cookies};
 
-use pubky_common::{
-    crypto::{random_bytes, random_hash},
-    session::Session,
-    timestamp::Timestamp,
-};
+use pubky_common::{crypto::random_bytes, session::Session, timestamp::Timestamp};
 
 use crate::{
     database::tables::{
@@ -43,7 +36,6 @@ pub async fn signup(
 
 pub async fn session(
     State(state): State<AppState>,
-    TypedHeader(user_agent): TypedHeader<UserAgent>,
     cookies: Cookies,
     pubky: Pubky,
 ) -> Result<impl IntoResponse> {

pubky-homeserver/src/routes/pkarr.rs

@@ -1,5 +1,3 @@
-use std::{collections::HashMap, sync::RwLock};
-
 use axum::{
     body::{Body, Bytes},
     extract::State,
@@ -10,8 +8,7 @@ use axum::{
 };
 use futures_util::stream::StreamExt;
 
-use pkarr::{PublicKey, SignedPacket};
-use tracing::debug;
+use pkarr::SignedPacket;
 
 use crate::{
     error::{Error, Result},
@@ -31,7 +28,7 @@ pub fn pkarr_router(state: AppState) -> Router {
 }
 
 pub async fn pkarr_put(
-    State(mut state): State<AppState>,
+    State(state): State<AppState>,
     pubky: Pubky,
     body: Body,
 ) -> Result<impl IntoResponse> {