chore: change to byte slice

Signed-off-by: kjuulh <contact@kjuulh.io>

crates/churn-server/src/agent.rs

@@ -24,13 +24,6 @@ impl std::ops::Deref for AgentService {
     }
 }
 
-impl Default for AgentService {
-    fn default() -> Self {
-        Self(Arc::new(DefaultAgentService::default()))
-    }
-}
-
-#[derive(Default)]
 struct DefaultAgentService {
     agents: Db,
 }

crates/churn-server/src/db.rs

@@ -1,6 +1,6 @@
 use core::slice::SlicePattern;
 
-use std::path::{Path, PathBuf};
+use std::path::{Path};
 use std::sync::Arc;
 
 use async_trait::async_trait;
@@ -22,22 +22,10 @@ impl std::ops::Deref for Db {
     }
 }
 
-impl Default for Db {
-    fn default() -> Self {
-        Self(Arc::new(DefaultDb::default()))
-    }
-}
-
 struct DefaultDb {
     db: sled::Db,
 }
 
-impl Default for DefaultDb {
-    fn default() -> Self {
-        Self::new(&PathBuf::from("churn-server.sled"))
-    }
-}
-
 impl DefaultDb {
     pub fn new(path: &Path) -> Self {
         Self {

crates/churn-server/src/event.rs

@@ -26,13 +26,6 @@ impl std::ops::Deref for EventService {
     }
 }
 
-impl Default for EventService {
-    fn default() -> Self {
-        Self(Arc::new(DefaultEventService::default()))
-    }
-}
-
-#[derive(Default)]
 struct DefaultEventService {
     db: Db,
 }
@@ -84,6 +77,7 @@ impl EventServiceTrait for DefaultEventService {
 
         let events = events
             .iter()
+            .map(|x| x.as_slice())
             .flat_map(LogEvent::deserialize_capnp)
             .sorted_by_key(|i| i.timestamp)
             .collect();

crates/churn-server/src/lease.rs

@@ -2,11 +2,21 @@ use std::sync::Arc;
 
 use axum::async_trait;
 
-use tokio::sync::Mutex;
+use churn_capnp::CapnpPackExt;
+use churn_domain::Lease;
+
+
+use crate::db::Db;
 
 #[derive(Clone)]
 pub struct LeaseService(Arc<dyn LeaseServiceTrait + Send + Sync + 'static>);
 
+impl LeaseService {
+    pub fn new(db: Db) -> Self {
+        Self(Arc::new(DefaultLeaseService::new(db)))
+    }
+}
+
 impl std::ops::Deref for LeaseService {
     type Target = Arc<dyn LeaseServiceTrait + Send + Sync + 'static>;
 
@@ -15,15 +25,14 @@ impl std::ops::Deref for LeaseService {
     }
 }
 
-impl Default for LeaseService {
-    fn default() -> Self {
-        Self(Arc::new(DefaultLeaseService::default()))
-    }
+struct DefaultLeaseService {
+    db: Db,
 }
 
-#[derive(Default)]
-struct DefaultLeaseService {
-    leases: Arc<Mutex<Vec<String>>>,
+impl DefaultLeaseService {
+    pub fn new(db: Db) -> Self {
+        Self { db }
+    }
 }
 
 #[async_trait]
@@ -34,12 +43,17 @@ pub trait LeaseServiceTrait {
 #[async_trait]
 impl LeaseServiceTrait for DefaultLeaseService {
     async fn create_lease(&self) -> anyhow::Result<String> {
-        let mut leases = self.leases.lock().await;
+        let lease = uuid::Uuid::new_v4();
+        let id = uuid::Uuid::new_v4();
 
-        let lease = uuid::Uuid::new_v4().to_string();
+        self.db
+            .insert(
+                "lease",
+                &lease.to_string(),
+                &Lease { id, lease }.serialize_capnp(),
+            )
+            .await?;
 
-        leases.push(lease.clone());
-
-        Ok(lease)
+        Ok(lease.to_string())
     }
 }

crates/churn-server/src/main.rs

@@ -70,37 +70,34 @@ async fn main() -> anyhow::Result<()> {
 
     let cli = Command::parse();
 
-    match cli.command {
-        Some(Commands::Serve { host }) => {
-            tracing::info!("Starting churn server");
-            let db = match cli.global.database {
-                DatabaseType::Sled => Db::new_sled(&cli.global.sled_path),
-            };
+    if let Some(Commands::Serve { host }) = cli.command {
+        tracing::info!("Starting churn server");
+        let db = match cli.global.database {
+            DatabaseType::Sled => Db::new_sled(&cli.global.sled_path),
+        };
 
-            let app = Router::new()
-                .route("/ping", get(ping))
-                .route("/logs", get(logs))
-                .nest(
-                    "/agent",
-                    Router::new()
-                        .route("/enroll", post(enroll))
-                        .route("/ping", post(agent_ping))
-                        .route("/events", post(get_tasks))
-                        .route("/lease", post(agent_lease)),
-                )
-                .with_state(AppState {
-                    agent: AgentService::new(db.clone()),
-                    leases: LeaseService::default(),
-                    events: EventService::new(db.clone()),
-                });
+        let app = Router::new()
+            .route("/ping", get(ping))
+            .route("/logs", get(logs))
+            .nest(
+                "/agent",
+                Router::new()
+                    .route("/enroll", post(enroll))
+                    .route("/ping", post(agent_ping))
+                    .route("/events", post(get_tasks))
+                    .route("/lease", post(agent_lease)),
+            )
+            .with_state(AppState {
+                agent: AgentService::new(db.clone()),
+                leases: LeaseService::new(db.clone()),
+                events: EventService::new(db.clone()),
+            });
 
-            tracing::info!("churn server listening on {}", host);
-            axum::Server::bind(&host)
-                .serve(app.into_make_service())
-                .await
-                .unwrap();
-        }
-        None => {}
+        tracing::info!("churn server listening on {}", host);
+        axum::Server::bind(&host)
+            .serve(app.into_make_service())
+            .await
+            .unwrap();
     }
 
     Ok(())
@@ -231,10 +228,10 @@ async fn logs(
                 .await
                 .map_err(AppError::Internal)?;
 
-            return Ok(Json(ServerMonitorResp {
+            Ok(Json(ServerMonitorResp {
                 cursor: Some(cursor),
                 logs: Vec::new(),
-            }));
+            }))
         }
     }
 }