Add some comments

Author: MasloMaslane

src/kvstorage/mod.rs

@@ -43,6 +43,9 @@ pub(crate) trait KVStorageTrait {
         hash: &str,
     ) -> Result<(), Box<dyn Error>> {
         let cnt = self.get_ref_count(bucket, hash).await?;
+        if cnt == 0 {
+            return Ok(());
+        }
         self.set_ref_count(bucket, hash, cnt - 1).await
     }
 
@@ -87,13 +90,20 @@ impl KVStorage {
         }
     }
 
+    /**
+     * Setup the KV storage.
+     */
     pub async fn setup(&mut self) -> Result<(), Box<dyn Error>> {
         match self {
             KVStorage::Postgres(storage) => storage.setup().await,
             KVStorage::SQLite(storage) => storage.setup().await,
         }
     }
 
+    /**
+     * Get the reference count for a hash.
+     * If the hash does not exist, return 0.
+     */
     pub async fn get_ref_count(&mut self, bucket: &str, hash: &str) -> Result<i32, Box<dyn Error>> {
         debug!("Getting ref count for bucket: {}, hash: {}", bucket, hash);
         match self {
@@ -102,6 +112,9 @@ impl KVStorage {
         }
     }
 
+    /**
+     * Set the reference count for a hash.
+     */
     pub async fn set_ref_count(
         &mut self,
         bucket: &str,
@@ -118,6 +131,9 @@ impl KVStorage {
         }
     }
 
+    /**
+     * Increment the reference count for a hash.
+     */
     pub async fn increment_ref_count(
         &mut self,
         bucket: &str,
@@ -130,6 +146,10 @@ impl KVStorage {
         }
     }
 
+    /**
+     * Decrement the reference count for a hash.
+     * If the reference count is already 0, do nothing.
+     */
     pub async fn decrement_ref_count(
         &mut self,
         bucket: &str,
@@ -142,6 +162,10 @@ impl KVStorage {
         }
     }
 
+    /**
+     * Get the modified time for a path.
+     * If the path does not exist, return 0.
+     */
     pub async fn get_modified(&mut self, bucket: &str, path: &str) -> Result<i64, Box<dyn Error>> {
         debug!("Getting modified time for bucket: {}, path: {}", bucket, path);
         match self {
@@ -150,6 +174,9 @@ impl KVStorage {
         }
     }
 
+    /**
+     * Set the modified time for a path.
+     */
     pub async fn set_modified(
         &mut self,
         bucket: &str,
@@ -166,6 +193,9 @@ impl KVStorage {
         }
     }
 
+    /**
+     * Delete the modified time for a path.
+     */
     pub async fn delete_modified(
         &mut self,
         bucket: &str,
@@ -178,6 +208,10 @@ impl KVStorage {
         }
     }
 
+    /**
+     * Get the reference file for a path.
+     * If the path does not exist, return an empty string.
+     */
     pub async fn get_ref_file(
         &mut self,
         bucket: &str,
@@ -190,6 +224,9 @@ impl KVStorage {
         }
     }
 
+    /**
+     * Set the reference file for a path.
+     */
     pub async fn set_ref_file(
         &mut self,
         bucket: &str,
@@ -206,6 +243,9 @@ impl KVStorage {
         }
     }
 
+    /**
+     * Delete the reference file for a path.
+     */
     pub async fn delete_ref_file(
         &mut self,
         bucket: &str,

src/locks/mod.rs

@@ -3,10 +3,16 @@ use tracing::{debug, info};
 
 pub mod memory;
 
+/**
+ * Get key for lock on file
+ */
 pub(crate) fn file_lock(bucket: &str, path: &str) -> String {
     format!("file:{}:{}", bucket, path)
 }
 
+/**
+ * Get key for lock on hash
+ */
 fn hash_lock(bucket: &str, hash: &str) -> String {
     format!("hash:{}:{}", bucket, hash)
 }
@@ -42,6 +48,9 @@ impl LocksStorage {
         }
     }
 
+    /**
+     * Acquire shared lock for key
+     */
     pub fn acquire_shared(&mut self, key: &str) {
         debug!("Acquiring shared lock for key: {}", key);
         match self {
@@ -51,6 +60,9 @@ impl LocksStorage {
         }
     }
 
+    /**
+     * Acquire exclusive lock for key
+     */
     pub fn acquire_exclusive(&mut self, key: &str) {
         debug!("Acquiring exclusive lock for key: {}", key);
         match self {
@@ -60,6 +72,9 @@ impl LocksStorage {
         }
     }
 
+    /**
+     * Release lock for key
+     */
     pub fn release(&mut self, key: &str) -> bool {
         debug!("Releasing lock for key: {}", key);
         match self {

src/main.rs

@@ -55,7 +55,7 @@ async fn main() {
         let app = Router::new()
             .route("/ft/version", get(ft_version))
             .route("/ft/files/{path}", put(ft_put_file))
-            .layer(
+            .layer( // Logging middleware
                 TraceLayer::new_for_http()
                     .make_span_with(DefaultMakeSpan::new().level(Level::INFO))
                     .on_response(DefaultOnResponse::new().level(Level::INFO)),

src/routes/ft/put_file.rs

@@ -15,6 +15,7 @@ pub async fn ft_put_file(
 ) -> impl IntoResponse {
     debug!("timestamp: {}", query.last_modified);
     let timestamp = utils::conv_rfc2822_to_unix_timestamp(&query.last_modified);
+
     if let Err(e) = timestamp {
         error!("Failed to parse last_modified: {}", e);
         return Response::builder()
@@ -37,6 +38,7 @@ pub async fn ft_put_file(
     }
     let current_modified = current_modified.unwrap();
 
+    // If the uploaded file is younger than the current one, return 200 OK
     if current_modified >= timestamp {
         state.locks.release(&*locks::file_lock(&state.bucket_name, &path));
         return Response::builder()