Switch to content block type

Author: nicolaschan

src/models/immutable.rs

@@ -0,0 +1,7 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct ContentBlock {
+    pub data: Vec<u8>,
+    pub references: Vec<blake3::Hash>,
+}

src/models/mod.rs

@@ -1,8 +1,10 @@
+mod immutable;
 mod name;
 mod namespace;
 mod peer;
 mod value;
 
+pub use immutable::ContentBlock;
 pub use name::Name;
 pub use namespace::NamespaceValues;
 pub use peer::Peers;

src/server/http.rs

@@ -19,7 +19,7 @@ use crate::{
         http::{HttpConnection, NamespaceResponse},
     },
     crypto::{Signed, encode::decode_verifying_key},
-    models::Peers,
+    models::{ContentBlock, Peers},
     server::{
         data_controller::DataController, immutable_controller::ImmutableController,
         sqlite_store::SqliteStore, task_controller::TaskController,
@@ -196,14 +196,14 @@ async fn get_immutable(
     let hash = blake3::Hash::from_hex(&hash).unwrap();
     let data = state.immutable_controller.get(&hash).await;
     match data {
-        Some(data) => (StatusCode::OK, Json(data)),
-        None => (StatusCode::NOT_FOUND, Json(Vec::new())),
+        Some(data) => (StatusCode::OK, Json(data)).into_response(),
+        None => (StatusCode::NOT_FOUND, "404 not found").into_response(),
     }
 }
 
 async fn post_immutable(
     State(state): State<AppState>,
-    Json(body): Json<Vec<u8>>,
+    Json(body): Json<ContentBlock>,
 ) -> impl IntoResponse {
     let hash = state.immutable_controller.set(&body).await;
     Json(hash)

src/server/immutable_controller.rs

@@ -2,6 +2,8 @@ use std::{path::PathBuf, sync::Arc};
 
 use tokio::sync::RwLock;
 
+use crate::models::ContentBlock;
+
 #[derive(Debug, Clone)]
 pub struct ImmutableController {
     basedir: PathBuf,
@@ -17,18 +19,20 @@ impl ImmutableController {
         }
     }
 
-    pub async fn get(&self, hash: &blake3::Hash) -> Option<Vec<u8>> {
+    pub async fn get(&self, hash: &blake3::Hash) -> Option<ContentBlock> {
         let _guard = self.filesystem_lock.read().await;
         let path = self.basedir.join(hash.to_string());
-        tokio::fs::read(&path).await.ok()
+        let encoded = tokio::fs::read(&path).await.ok()?;
+        bincode::deserialize(&encoded).ok()
     }
 
-    pub async fn set(&self, content: &Vec<u8>) -> blake3::Hash {
+    pub async fn set(&self, content: &ContentBlock) -> blake3::Hash {
         let _guard = self.filesystem_lock.write().await;
-        let hash = blake3::hash(content);
+        let encoded = bincode::serialize(content).unwrap();
+        let hash = blake3::hash(&encoded);
         let path = self.basedir.join(hash.to_string());
         if !path.exists() {
-            tokio::fs::write(&path, &content).await.unwrap();
+            tokio::fs::write(&path, &encoded).await.unwrap();
         }
         hash
     }