Wp/ updated delete file to use pk as filename

src/backend.rs

@@ -1,2 +1 @@
 pub mod fs;
-// pub mod task;

src/backend/fs.rs

@@ -1,7 +1,6 @@
 use std::{
     fs::{self, OpenOptions},
-    io::{self, Read, Seek, Write},
-    path::{Path, PathBuf},
+    io::{Read, Seek, Write},
     pin::Pin,
     sync::Arc,
 };
@@ -131,6 +130,7 @@ pub async fn write_catalog(
     segment_hashes: &[BaoHash],
 ) -> Result<()> {
     debug!("Write catalog");
+
     let contents: Vec<u8> = segment_hashes
         .iter()
         .flat_map(|bao_hash| bao_hash.to_bytes())
@@ -189,7 +189,7 @@ pub fn read_file(pk: &Secp256k1PubKey, blake3_hash: &Blake3Hash) -> Result<FileS
                     0,
                     &write_pk_str,
                     SEGMENT_DIR,
-                    &format!("{}.c{}", segment_hash, NODE_FORMAT),
+                    &format!("{segment_hash}.c{NODE_FORMAT}"),
                 )?;
 
                 let mut chunk_file = OpenOptions::new().read(true).open(chunk_path)?;
@@ -276,73 +276,56 @@ pub fn read_catalog(write_pk_str: &str, file_hash: &Blake3Hash) -> Result<Vec<Ba
     Ok(bao_hashes)
 }
 
-#[allow(unused_variables)]
-pub fn delete_file(pk: Secp256k1PubKey, file_bytes: &[u8]) -> Result<()> {
-    let pk_bytes = pk.to_bytes();
-    let (x_only_pk, _) = pk.into_inner().x_only_public_key();
+pub fn read_slice(
+    pk: &Secp256k1PubKey,
+    file_hash: &Blake3Hash,
+    slice_start: usize,
+    slice_len: usize,
+) -> Result<Vec<BaoHash>> {
+    trace!("Create a shared secret using ECDH");
+    let ss = node_shared_secret(&pk.into_inner())?.secret_bytes();
+    let write_pk = PublicKey::from_secret_key_global(&SecretKey::from_slice(&ss)?);
+    let write_pk_str = write_pk.to_string();
 
-    let file_hash = Blake3Hash(blake3::keyed_hash(&x_only_pk.serialize(), file_bytes));
-    trace!(">>>>>file_hash::   {}", file_hash);
+    let path = file_path(0, &write_pk_str, CATALOG_DIR, &file_hash.to_string())?;
 
-    for vol in &SYS_CFG.volumes {
-        let seg_file = &vol.path.join(SEGMENT_DIR).join(file_hash.to_string());
-        let seg_dir = &vol.path.join(SEGMENT_DIR);
-        remove_dir_contents(seg_dir, seg_file.to_path_buf()).unwrap();
-    }
+    trace!("Read catalog at {path:?}");
+    let mut catalog_file = OpenOptions::new().read(true).open(path)?;
 
-    for vol in &SYS_CFG.volumes {
-        let cat_path = &vol.path.join(CATALOG_DIR).join(file_hash.to_string());
-        let cat = &vol.path.join(CATALOG_DIR);
-        remove_dir_catalogs(cat.to_path_buf(), cat_path.to_path_buf()).unwrap();
-    }
-    Ok(())
-}
+    let mut bytes = vec![];
+    catalog_file.read_to_end(&mut bytes)?;
 
-#[allow(unused_variables)]
-fn remove_dir_contents<P: AsRef<Path>>(path: P, seg_file: PathBuf) -> io::Result<()> {
-    trace!(">>> remove_Segment_contents");
-    for entry in fs::read_dir(path)? {
-        trace!("Delete Segment File at {:?}", entry);
-        fs::remove_file(entry?.path())?;
-    }
-    Ok(())
+    trace!("Read catalog at {:?}", catalog_file);
+    trace!(" )))) Read catalog BYTES len()  {:?}", bytes.len());
+
+    // GET RANGE ex: &bytes[1..4]);
+    let slice_end = slice_start + slice_len;
+    trace!(" {:?}", &bytes[slice_start..slice_end]);
+
+    let bao_hashes = bytes
+        .chunks_exact(bao::HASH_SIZE)
+        .map(BaoHash::try_from)
+        .collect::<Result<Vec<BaoHash>>>()?;
+
+    Ok(bao_hashes)
 }
 
-#[allow(unused_variables)]
-fn remove_dir_catalogs(path: PathBuf, file: PathBuf) -> io::Result<()> {
-    for entry in fs::read_dir(path)? {
-        trace!("Delete CATALOG File at {:?}", entry);
-        fs::remove_file(entry?.path())?;
+pub async fn delete_file(pk: &Secp256k1PubKey) -> Result<()> {
+    let ss = node_shared_secret(&pk.into_inner())?.secret_bytes();
+    let write_pk = PublicKey::from_secret_key_global(&SecretKey::from_slice(&ss)?);
+    let write_pk_str = write_pk.to_string();
+    trace!("WRITE_PK_STR: {}", write_pk_str);
+
+    for vol in &SYS_CFG.volumes {
+        trace!("VOLUME PATH: {:?}", vol.path);
+
+        let pk_path = vol.path.join(&write_pk_str);
+        let is_removed = fs::remove_dir_all(pk_path).is_ok();
+        trace!(
+            "VOLUME_{:?} WRITE_PK_STR REMOVED {:?}: ",
+            vol.path,
+            is_removed
+        );
     }
     Ok(())
 }
-
-// fn remove_dir_segements<P: AsRef<Path>>(path: P, seg_file: PathBuf) -> io::Result<()> {
-//     trace!(">>> remove_Segment_contents");
-//     for entry in fs::read_dir(path)? {
-//         let entry = entry?;
-//         trace!("ENTRY Delete SEGMENT File at {:?}", entry);
-
-//         match &entry {
-//             seg_file => {
-//                 fs::remove_file(seg_file.path())?;
-//                 trace!("Delete Segment File at {:?}", seg_file);
-//             }
-//         }
-//     }
-//     Ok(())
-// }
-
-// fn remove_dir_catalogs(path: PathBuf, file: PathBuf) -> io::Result<()> {
-//     for entry in fs::read_dir(path)? {
-//         let entry = entry?;
-//         trace!("ENTRY Delete CATALOG File at {:?}", entry);
-//         match &entry {
-//             file => {
-//                 fs::remove_file(file.path())?;
-//                 trace!("FILE MATCH Delete CATALOG File at {:?}", file);
-//             }
-//         }
-//     }
-//     Ok(())
-// }

src/frontend/http.rs

@@ -3,7 +3,7 @@ use std::{net::SocketAddr, str::FromStr};
 use anyhow::Result;
 use axum::{
     body::StreamBody,
-    extract::{BodyStream, Path},
+    extract::{BodyStream, Path, Query},
     http::StatusCode,
     response::{IntoResponse, Response},
     routing::{delete, get, post},
@@ -16,11 +16,33 @@ use secp256k1::PublicKey;
 use tower_http::cors::CorsLayer;
 
 use crate::{
-    backend::fs::{delete_file, read_file, write_file, FileStream},
+    backend::fs::{delete_file, read_file, read_slice, write_file, FileStream},
     config::{node_shared_secret, SYS_CFG},
     prelude::*,
 };
 
+struct FileSlice {
+    //#[serde(default, deserialize_with = "empty_string_as_none")]
+    pk: String,
+    black3_hash: String,
+    index_start: usize,
+    range_end: usize,
+}
+
+/// Serde deserialization decorator to map empty Strings to None,
+// fn empty_string_as_none<'de, D, T>(de: D) -> Result<Option<T>, D::Error>
+// where
+//     D: Deserializer<'de>,
+//     T: FromStr,
+//     T::Err: fmt::Display,
+// {
+//     let opt = Option::<String>::deserialize(de)?;
+//     match opt.as_deref() {
+//         None | Some("") => Ok(None),
+//         Some(s) => FromStr::from_str(s).map_err(de::Error::custom).map(Some),
+//     }
+// }
+
 #[axum_macros::debug_handler]
 async fn post_file(
     Path(pk): Path<String>,
@@ -69,13 +91,32 @@ async fn get_file(
     Ok((StatusCode::OK, StreamBody::new(file_stream)))
 }
 
+// #[axum_macros::debug_handler]
+// //async fn get_slice(Query(my_params): Query<FileSlice>) -> Result<impl IntoResponse, AppError> {
+// async fn get_slice(Query(my_params): Query<FileSlice>) -> Result<impl IntoResponse, AppError> {
+//     // let pk = my_params.black3_hash;
+//     // let blake3_hash = my_params.black3_hash;
+//     // let start_index = my_params.index_start;
+//     // let range_end = my_params.range_end;
+//     // debug!("my_params :: blake {:?} ", my_params.black3_hash);
+//     // debug!("my_params :: start {:?} ", my_params.index_start);
+//     // debug!("my_params :: end {:?} ", my_params.range_end);
+//     let file_stream = read_slices(
+//         my_params.pk,
+//         my_params.black3_hash,
+//         my_params.index_start,
+//         my_params.range_end,
+//     )
+//     .await?;
+//     Ok((StatusCode::OK, StreamBody::new(file_stream)))
+// }
+
 #[axum_macros::debug_handler]
-async fn remove_file(
-    Path((pk, blake3_hash)): Path<(String, String)>,
-) -> Result<impl IntoResponse, AppError> {
+async fn remove_file(Path(pk): Path<String>) -> Result<impl IntoResponse, AppError> {
     let pk = Secp256k1PubKey::try_from(pk.as_str())?;
-    delete_file(pk, blake3_hash.as_bytes())?;
-    Ok((StatusCode::OK, blake3_hash))
+    let del = delete_file(&pk).await.is_ok();
+
+    Ok((StatusCode::OK, del.to_string()))
 }
 
 async fn key(Path(pk): Path<String>) -> Result<impl IntoResponse, AppError> {
@@ -89,9 +130,10 @@ async fn key(Path(pk): Path<String>) -> Result<impl IntoResponse, AppError> {
 
 pub async fn start() -> Result<()> {
     let app = Router::new()
-        .route("/remove/:pk/:blake3_hash", delete(remove_file))
+        .route("/remove/:blake3_hash", delete(remove_file))
         .route("/store/:pk", post(post_file))
         .route("/retrieve/:pk/:blake3_hash", get(get_file))
+        // .route("/slice/", get(get_slice))
         .route("/key/:pk", get(key))
         // .route("/catalog/:blake3_hash", get(get_catalog))
         // .route("/raw/:bao_hash", get(get_raw))

src/structs.rs

@@ -15,6 +15,16 @@ impl fmt::Display for Blake3Hash {
     }
 }
 
+impl TryFrom<&[u8]> for Blake3Hash {
+    type Error = Error;
+
+    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
+        let mut hash = [0_u8; 32];
+        hash.copy_from_slice(&value[0..32]);
+        Ok(Self(blake3::Hash::try_from(hash)?))
+    }
+}
+
 pub struct BaoHash(pub bao::Hash);
 
 impl BaoHash {