refactor: Restructure project layout and clean up dependencies (#30)

This commit introduces a significant reorganization of the project structure to improve maintainability and clarity.

Key changes include:
- Adjusted the directory layout for a more logical module organization.
- Removed unused crate dependencies, reducing the overall project size and potentially speeding up build times.
- Updated import paths and configuration files to reflect the structural changes.

crates/ecstore/src/tier/warm_backend.rs

@@ -0,0 +1,137 @@
+#![allow(unused_imports)]
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
+use crate::client::{
+    admin_handler_utils::AdminError,
+    transition_api::{ReadCloser, ReaderImpl},
+};
+use crate::error::is_err_bucket_not_found;
+use crate::tier::{
+    tier::ERR_TIER_TYPE_UNSUPPORTED,
+    tier_config::{TierConfig, TierType},
+    tier_handlers::{ERR_TIER_BUCKET_NOT_FOUND, ERR_TIER_PERM_ERR},
+    warm_backend_minio::WarmBackendMinIO,
+    warm_backend_rustfs::WarmBackendRustFS,
+    warm_backend_s3::WarmBackendS3,
+};
+use bytes::Bytes;
+use http::StatusCode;
+use std::collections::HashMap;
+use tracing::{info, warn};
+
+pub type WarmBackendImpl = Box<dyn WarmBackend + Send + Sync + 'static>;
+
+const PROBE_OBJECT: &str = "probeobject";
+
+#[derive(Default)]
+pub struct WarmBackendGetOpts {
+    pub start_offset: i64,
+    pub length: i64,
+}
+
+#[async_trait::async_trait]
+pub trait WarmBackend {
+    async fn put(&self, object: &str, r: ReaderImpl, length: i64) -> Result<String, std::io::Error>;
+    async fn put_with_meta(
+        &self,
+        object: &str,
+        r: ReaderImpl,
+        length: i64,
+        meta: HashMap<String, String>,
+    ) -> Result<String, std::io::Error>;
+    async fn get(&self, object: &str, rv: &str, opts: WarmBackendGetOpts) -> Result<ReadCloser, std::io::Error>;
+    async fn remove(&self, object: &str, rv: &str) -> Result<(), std::io::Error>;
+    async fn in_use(&self) -> Result<bool, std::io::Error>;
+}
+
+pub async fn check_warm_backend(w: Option<&WarmBackendImpl>) -> Result<(), AdminError> {
+    let w = w.expect("err");
+    let remote_version_id = w
+        .put(PROBE_OBJECT, ReaderImpl::Body(Bytes::from("RustFS".as_bytes().to_vec())), 5)
+        .await;
+    if let Err(err) = remote_version_id {
+        return Err(ERR_TIER_PERM_ERR.clone());
+    }
+
+    let r = w.get(PROBE_OBJECT, "", WarmBackendGetOpts::default()).await;
+    //xhttp.DrainBody(r);
+    if let Err(err) = r {
+        //if is_err_bucket_not_found(&err) {
+        //    return Err(ERR_TIER_BUCKET_NOT_FOUND);
+        //}
+        /*else if is_err_signature_does_not_match(err) {
+            return Err(ERR_TIER_MISSING_CREDENTIALS);
+        }*/
+        //else {
+        return Err(ERR_TIER_PERM_ERR.clone());
+        //}
+    }
+    if let Err(err) = w.remove(PROBE_OBJECT, &remote_version_id.expect("err")).await {
+        return Err(ERR_TIER_PERM_ERR.clone());
+    };
+    Ok(())
+}
+
+pub async fn new_warm_backend(tier: &TierConfig, probe: bool) -> Result<WarmBackendImpl, AdminError> {
+    let mut d: Option<WarmBackendImpl> = None;
+    match tier.tier_type {
+        TierType::S3 => {
+            let dd = WarmBackendS3::new(tier.s3.as_ref().expect("err"), &tier.name).await;
+            if let Err(err) = dd {
+                warn!("{}", err);
+                return Err(AdminError {
+                    code: "XRustFSAdminTierInvalidConfig".to_string(),
+                    message: format!("Unable to setup remote tier, check tier configuration: {}", err.to_string()),
+                    status_code: StatusCode::BAD_REQUEST,
+                });
+            }
+            d = Some(Box::new(dd.expect("err")));
+        }
+        TierType::RustFS => {
+            let dd = WarmBackendRustFS::new(tier.rustfs.as_ref().expect("err"), &tier.name).await;
+            if let Err(err) = dd {
+                warn!("{}", err);
+                return Err(AdminError {
+                    code: "XRustFSAdminTierInvalidConfig".to_string(),
+                    message: format!("Unable to setup remote tier, check tier configuration: {}", err.to_string()),
+                    status_code: StatusCode::BAD_REQUEST,
+                });
+            }
+            d = Some(Box::new(dd.expect("err")));
+        }
+        TierType::MinIO => {
+            let dd = WarmBackendMinIO::new(tier.minio.as_ref().expect("err"), &tier.name).await;
+            if let Err(err) = dd {
+                warn!("{}", err);
+                return Err(AdminError {
+                    code: "XRustFSAdminTierInvalidConfig".to_string(),
+                    message: format!("Unable to setup remote tier, check tier configuration: {}", err.to_string()),
+                    status_code: StatusCode::BAD_REQUEST,
+                });
+            }
+            d = Some(Box::new(dd.expect("err")));
+        }
+        _ => {
+            return Err(ERR_TIER_TYPE_UNSUPPORTED.clone());
+        }
+    }
+
+    Ok(d.expect("err"))
+}