Fixes

Signed-off-by: Valerian Saliou <valerian@valeriansaliou.name>

Author: valeriansaliou

config.cfg

@@ -6,7 +6,7 @@
 
 [server]
 
-log_level = "error"
+log_level = "debug"
 
 
 [channel]

src/executor/flushb.rs

@@ -6,25 +6,54 @@
 
 use crate::store::fst::StoreFSTActionBuilder;
 use crate::store::item::StoreItem;
-use crate::store::kv::StoreKVActionBuilder;
+use crate::store::kv::{StoreKVAcquireMode, StoreKVActionBuilder, StoreKVPool};
 
 pub struct ExecutorFlushB;
 
 impl ExecutorFlushB {
     pub fn execute<'a>(store: StoreItem<'a>) -> Result<u32, ()> {
-        // Important: do not acquire the store from there, as otherwise it will remain open \
-        //   even if dropped in the inner function, as this caller would still own a reference to \
-        //   it.
         if let StoreItem(collection, Some(bucket), None) = store {
-            match (
-                StoreKVActionBuilder::erase(collection, Some(bucket)),
-                StoreFSTActionBuilder::erase(collection, Some(bucket)),
-            ) {
-                (Ok(erase_count), Ok(_)) => Ok(erase_count),
-                _ => Err(()),
+            // Important: acquire database access read lock, and reference it in context. This \
+            //   prevents the database from being erased while using it in this block.
+            general_kv_access_lock_read!();
+
+            if let Ok(kv_store) = StoreKVPool::acquire(StoreKVAcquireMode::OpenOnly, collection) {
+                // Important: acquire bucket store write lock
+                executor_kv_lock_write!(kv_store);
+
+                if kv_store.is_some() == true {
+                    // Store exists, proceed erasure.
+                    debug!(
+                        "collection store exists, erasing: {} from {}",
+                        bucket.as_str(),
+                        collection.as_str()
+                    );
+
+                    let kv_action = StoreKVActionBuilder::access(bucket, kv_store);
+
+                    // Notice: we cannot use the provided KV bucket erasure helper there, as \
+                    //   erasing a bucket requires a database lock, which would incur a dead-lock, \
+                    //   thus we need to perform the erasure from there.
+                    if let Ok(erase_count) = kv_action.batch_erase_bucket() {
+                        if StoreFSTActionBuilder::erase(collection, Some(bucket)).is_ok() == true {
+                            debug!("done with bucket erasure");
+
+                            return Ok(erase_count);
+                        }
+                    }
+                } else {
+                    // Store does not exist, consider as already erased.
+                    debug!(
+                        "collection store does not exist, consider {} from {} already erased",
+                        bucket.as_str(),
+                        collection.as_str()
+                    );
+
+                    return Ok(0);
+                }
             }
-        } else {
-            Err(())
         }
+
+        Err(())
     }
 }

src/store/kv.rs

@@ -269,43 +269,11 @@ impl StoreGenericActionBuilder for StoreKVActionBuilder {
     }
 
     fn proceed_erase_bucket<'a>(
-        collection: StoreItemPart<'a>,
-        bucket: StoreItemPart<'a>,
+        _collection: StoreItemPart<'a>,
+        _bucket: StoreItemPart<'a>,
     ) -> Result<u32, ()> {
-        debug!(
-            "sub-erase on kv bucket: {} for collection: {}",
-            bucket.as_str(),
-            collection.as_str()
-        );
-
-        if let Ok(kv_store) = StoreKVPool::acquire(StoreKVAcquireMode::OpenOnly, collection) {
-            if kv_store.is_some() == true {
-                // Store exists, proceed erasure.
-                debug!(
-                    "kv collection store exists, erasing: {} from {}",
-                    bucket.as_str(),
-                    collection.as_str()
-                );
-
-                let kv_action = Self::access(bucket, kv_store);
-
-                if let Ok(erase_count) = kv_action.batch_erase_bucket() {
-                    debug!("done with kv bucket erasure");
-
-                    return Ok(erase_count);
-                }
-            } else {
-                // Store does not exist, consider as already erased.
-                debug!(
-                    "kv collection store does not exist, consider {} from {} already erased",
-                    bucket.as_str(),
-                    collection.as_str()
-                );
-
-                return Ok(0);
-            }
-        }
-
+        // This one is not implemented, as we need to acquire the collection; which would cause \
+        //   a party-killer dead-lock.
         Err(())
     }
 }