add versioning_sys

ecstore/src/bucket/versioning/mod.rs

@@ -1,14 +1,20 @@
-use crate::error::Result;
+use crate::error::{Error, Result};
 use rmp_serde::Serializer as rmpSerializer;
 use serde::{Deserialize, Serialize};
 
+#[derive(Debug, thiserror::Error)]
+pub enum VersioningErr {
+    #[error("too many excluded prefixes")]
+    TooManyExcludedPrefixes,
+    #[error("excluded prefixes extension supported only when versioning is enabled")]
+    ExcludedPrefixNotSupported,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Deserialize, Serialize)]
 pub enum State {
     #[default]
-    Enabled,
     Suspended,
-    // 如果未来可能会使用到Disabled状态，可以在这里添加
-    // Disabled,
+    Enabled,
 }
 
 // 实现Display trait用于打印
@@ -20,8 +26,6 @@ impl std::fmt::Display for State {
             match *self {
                 State::Enabled => "Enabled",
                 State::Suspended => "Suspended",
-                // 如果未来可能会使用到Disabled状态，可以在这里添加
-                // State::Disabled => "Disabled",
             }
         )
     }
@@ -52,4 +56,83 @@ impl Versioning {
         let t: Versioning = rmp_serde::from_slice(buf)?;
         Ok(t)
     }
+
+    pub fn validate(&self) -> Result<()> {
+        match self.status {
+            State::Suspended => {
+                if self.excluded_prefixes.len() > 0 {
+                    return Err(Error::new(VersioningErr::ExcludedPrefixNotSupported));
+                }
+            }
+            State::Enabled => {
+                if self.excluded_prefixes.len() > 10 {
+                    return Err(Error::new(VersioningErr::TooManyExcludedPrefixes));
+                }
+            }
+            _ => return Err(Error::msg(format!("unsupported versioning status {}", self.status))),
+        }
+
+        Ok(())
+    }
+
+    pub fn enabled(&self) -> bool {
+        self.status == State::Enabled
+    }
+
+    pub fn versioned(&self, prefix: &str) -> bool {
+        self.prefix_enabled(prefix) || self.prefix_suspended(prefix)
+    }
+
+    pub fn prefix_enabled(&self, prefix: &str) -> bool {
+        if self.status != State::Enabled {
+            return false;
+        }
+
+        if prefix.is_empty() {
+            return true;
+        }
+        if self.exclude_folders && prefix.ends_with("/") {
+            return false;
+        }
+
+        for sprefix in self.excluded_prefixes.iter() {
+            let full_prefix = format!("{}*", sprefix.prefix);
+            if utils::wildcard::match_simple(full_prefix, prefix) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    pub fn suspended(&self) -> bool {
+        self.status == State::Suspended
+    }
+
+    pub fn prefix_suspended(&self, prefix: &str) -> bool {
+        if self.status == State::Suspended {
+            return true;
+        }
+
+        if self.status == State::Enabled {
+            if prefix.is_empty() {
+                return false;
+            }
+
+            if self.exclude_folders && prefix.starts_with("/") {
+                return true;
+            }
+
+            for sprefix in self.excluded_prefixes.iter() {
+                let full_prefix = format!("{}*", sprefix.prefix);
+                if utils::wildcard::match_simple(full_prefix, prefix) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    pub fn prefixes_excluded(&self) -> bool {
+        self.excluded_prefixes.len() > 0 || self.exclude_folders
+    }
 }