1 files changed, 136 insertions, 0 deletions
diff --git a/rola-cli/src/bucket_mgr/bind/chains.rs b/rola-cli/src/bucket_mgr/bind/chains.rs
new file mode 100644
index 0000000..881e5ba
--- /dev/null
+++ b/rola-cli/src/bucket_mgr/bind/chains.rs
@@ -0,0 +1,136 @@
+use crate::{
+    Next,
+    bucket_mgr::{
+        EntryBucketBind, ErrorBucketBindIndexNotFound, ErrorBucketBindIndexNotProvided,
+        ResultAllBucketBind, ResultBucketOperated,
+        ResultEnumBucketOperation::{self, Set},
+        ResultOneBucketBind, StateBucketBindListAll, StateBucketBindListSpecified,
+        StateBucketBindRemove, StateBucketBindSet,
+    },
+    error::{ErrorRequireOverwrite, ErrorSpace},
+    res::{bucket::ResBucketWithoutProtocol, overwrite::ResOverwrite},
+};
+use mingling::{LazyRes, macros::chain};
+use rorolala::bucket::{self};
+use shared_functions::info;
+
+// Chains
+
+#[chain]
+pub fn handle_bucket_bind(args: EntryBucketBind) -> Next {
+    match args.index {
+        Some(op_idx) => {
+            if let Some(url) = args.set {
+                // bind idx --set url
+                return StateBucketBindSet::new((op_idx, url)).to_chain();
+            } else if args.remove {
+                // bind idx --remove
+                return StateBucketBindRemove::new(op_idx).to_chain();
+            } else {
+                // bind idx
+                return StateBucketBindListSpecified::new(op_idx).to_chain();
+            }
+        }
+        None => {
+            if !args.remove && args.set.is_none() {
+                // bind
+                return StateBucketBindListAll::new(()).to_chain();
+            } else {
+                // index not provided
+                // bind --set url
+                // or
+                // bind --remove
+                return ErrorBucketBindIndexNotProvided::default().to_render();
+            }
+        }
+    }
+}
+
+#[chain]
+pub fn handle_state_bucket_bind_set(
+    set: StateBucketBindSet,
+    bucket: &mut LazyRes<ResBucketWithoutProtocol>,
+    overwrite: &ResOverwrite,
+) -> Next {
+    let (index, url) = set.inner;
+    let bucket_space_ref = &bucket.get_ref().space;
+
+    let exist = match bucket::bind::check_bucket_bind_exists(bucket_space_ref, index) {
+        Ok(exists) => exists,
+        Err(e) => return ErrorSpace::from(e).to_chain(),
+    };
+
+    // When the bind already exists but overwrite is not specified
+    // Dispatch to ErrorRequireOverwrite
+    if exist && !overwrite.overwrite {
+        return ErrorRequireOverwrite::default().to_render();
+    }
+
+    if let Err(space_error) =
+        bucket::bind::write_bucket_bind(bucket_space_ref, index, url.clone().as_str())
+    {
+        ErrorSpace::from(space_error).to_chain();
+    }
+
+    ResultBucketOperated {
+        operation: Set,
+        index,
+        url: Some(url),
+    }
+    .to_render()
+}
+
+#[chain]
+pub fn handle_state_bucket_bind_remove(
+    remove: StateBucketBindRemove,
+    bucket: &mut LazyRes<ResBucketWithoutProtocol>,
+) -> Next {
+    let index = remove.inner;
+    let bucket_space_ref = &bucket.get_ref().space;
+
+    if let Err(space_error) = bucket::bind::remove_bucket_bind(bucket_space_ref, index) {
+        return ErrorSpace::from(space_error).to_chain();
+    }
+
+    ResultBucketOperated {
+        operation: ResultEnumBucketOperation::Remove,
+        index,
+        url: None,
+    }
+    .to_render()
+}
+
+#[chain]
+pub fn handle_state_bucket_bind_list_specified(
+    index: StateBucketBindListSpecified,
+    bucket: &mut LazyRes<ResBucketWithoutProtocol>,
+) -> Next {
+    let index = index.inner;
+    let bucket_space_ref = &bucket.get_ref().space;
+    let bind_info = match bucket::bind::read_bucket_bind(bucket_space_ref, index) {
+        Err(e) => return ErrorSpace::from(e).to_chain(),
+        Ok(None) => return ErrorBucketBindIndexNotFound::new(index).to_render(),
+        Ok(Some(r)) => r,
+    };
+
+    ResultOneBucketBind {
+        index: bind_info.get_index(),
+        url: bind_info.get_url().to_string(),
+    }
+    .to_render()
+}
+
+#[chain]
+pub fn handle_state_bucket_bind_list_all(
+    _p: StateBucketBindListAll,
+    bucket: &mut LazyRes<ResBucketWithoutProtocol>,
+) -> Next {
+    let bucket_space_ref = &bucket.get_ref().space;
+    info!("Reading all bucket binds from space");
+    let bind_list = match bucket::bind::read_bucket_binds(bucket_space_ref) {
+        Err(e) => return ErrorSpace::from(e).to_chain(),
+        Ok(r) => r,
+    };
+    info!("Read {} bucket binds", bind_list.len());
+    ResultAllBucketBind { bind_list }.to_render()
+}