support distribute lock

Signed-off-by: junxiang Mu <1948535941@qq.com>

common/common/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "common"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+lazy_static.workspace = true
+tokio.workspace = true
+tracing-error.workspace = true

common/common/src/error.rs

@@ -0,0 +1,82 @@
+use tracing_error::{SpanTrace, SpanTraceStatus};
+
+pub type StdError = Box<dyn std::error::Error + Send + Sync + 'static>;
+
+pub type Result<T = (), E = Error> = std::result::Result<T, E>;
+
+#[derive(Debug)]
+pub struct Error {
+    inner: Box<dyn std::error::Error + Send + Sync + 'static>,
+    span_trace: SpanTrace,
+}
+
+impl Error {
+    /// Create a new error from a `std::error::Error`.
+    #[must_use]
+    #[track_caller]
+    pub fn new<T: std::error::Error + Send + Sync + 'static>(source: T) -> Self {
+        Self::from_std_error(source.into())
+    }
+
+    /// Create a new error from a `std::error::Error`.
+    #[must_use]
+    #[track_caller]
+    pub fn from_std_error(inner: StdError) -> Self {
+        Self {
+            inner,
+            span_trace: SpanTrace::capture(),
+        }
+    }
+
+    /// Create a new error from a string.
+    #[must_use]
+    #[track_caller]
+    pub fn from_string(s: impl Into<String>) -> Self {
+        Self::msg(s)
+    }
+
+    /// Create a new error from a string.
+    #[must_use]
+    #[track_caller]
+    pub fn msg(s: impl Into<String>) -> Self {
+        Self::from_std_error(s.into().into())
+    }
+
+    /// Returns `true` if the inner type is the same as `T`.
+    #[inline]
+    pub fn is<T: std::error::Error + 'static>(&self) -> bool {
+        self.inner.is::<T>()
+    }
+
+    /// Returns some reference to the inner value if it is of type `T`, or
+    /// `None` if it isn't.
+    #[inline]
+    pub fn downcast_ref<T: std::error::Error + 'static>(&self) -> Option<&T> {
+        self.inner.downcast_ref()
+    }
+
+    /// Returns some mutable reference to the inner value if it is of type `T`, or
+    /// `None` if it isn't.
+    #[inline]
+    pub fn downcast_mut<T: std::error::Error + 'static>(&mut self) -> Option<&mut T> {
+        self.inner.downcast_mut()
+    }
+}
+
+impl<T: std::error::Error + Send + Sync + 'static> From<T> for Error {
+    fn from(e: T) -> Self {
+        Self::new(e)
+    }
+}
+
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.inner)?;
+
+        if self.span_trace.status() != SpanTraceStatus::EMPTY {
+            write!(f, "\nspan_trace:\n{}", self.span_trace)?;
+        }
+
+        Ok(())
+    }
+}

common/common/src/globals.rs

@@ -0,0 +1,8 @@
+use lazy_static::lazy_static;
+use tokio::sync::RwLock;
+
+lazy_static! {
+    pub static ref GLOBAL_Local_Node_Name: RwLock<String> = RwLock::new("".to_string());
+    pub static ref GLOBAL_Rustfs_Host: RwLock<String> = RwLock::new("".to_string());
+    pub static ref GLOBAL_Rustfs_Port: RwLock<String> = RwLock::new("9000".to_string());
+}

common/common/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod error;
+pub mod globals;