mirror of
https://github.com/rustfs/rustfs.git
synced 2026-08-12 16:16:55 +00:00
cxymds
4290f390dd
* fix(rpc): bind internode auth to exact targets * fix(heal): initialize the runtime atomically * fix(heal): aggregate status across cluster nodes --------- Co-authored-by: Zhengchao An <anzhengchao@gmail.com>
773 lines
23 KiB
Rust
773 lines
23 KiB
Rust
// 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.
|
|
|
|
use s3s::dto::{BucketLifecycleConfiguration, ExpirationStatus, LifecycleRule, ReplicationConfiguration, ReplicationRuleStatus};
|
|
use serde::{Deserialize, Serialize};
|
|
use std::{
|
|
fmt::{self, Display},
|
|
sync::OnceLock,
|
|
};
|
|
use tokio::sync::{broadcast, mpsc, oneshot};
|
|
use uuid::Uuid;
|
|
|
|
pub const HEAL_DELETE_DANGLING: bool = true;
|
|
pub const RUSTFS_RESERVED_BUCKET: &str = "rustfs";
|
|
pub const RUSTFS_RESERVED_BUCKET_PATH: &str = "/rustfs";
|
|
|
|
#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
|
|
pub enum HealItemType {
|
|
Metadata,
|
|
Bucket,
|
|
BucketMetadata,
|
|
Object,
|
|
}
|
|
|
|
impl HealItemType {
|
|
pub fn to_str(&self) -> &str {
|
|
match self {
|
|
HealItemType::Metadata => "metadata",
|
|
HealItemType::Bucket => "bucket",
|
|
HealItemType::BucketMetadata => "bucket-metadata",
|
|
HealItemType::Object => "object",
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Display for HealItemType {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
write!(f, "{}", self.to_str())
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
pub enum DriveState {
|
|
Ok,
|
|
Offline,
|
|
Corrupt,
|
|
Missing,
|
|
PermissionDenied,
|
|
Faulty,
|
|
RootMount,
|
|
Unknown(String),
|
|
Unformatted, // only returned by disk
|
|
}
|
|
|
|
impl DriveState {
|
|
pub fn to_str(&self) -> &str {
|
|
match self {
|
|
DriveState::Ok => "ok",
|
|
DriveState::Offline => "offline",
|
|
DriveState::Corrupt => "corrupt",
|
|
DriveState::Missing => "missing",
|
|
DriveState::PermissionDenied => "permission-denied",
|
|
DriveState::Faulty => "faulty",
|
|
DriveState::RootMount => "root-mount",
|
|
DriveState::Unknown(reason) => reason,
|
|
DriveState::Unformatted => "unformatted",
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Clone for DriveState {
|
|
fn clone(&self) -> Self {
|
|
match self {
|
|
DriveState::Unknown(reason) => DriveState::Unknown(reason.clone()),
|
|
DriveState::Ok => DriveState::Ok,
|
|
DriveState::Offline => DriveState::Offline,
|
|
DriveState::Corrupt => DriveState::Corrupt,
|
|
DriveState::Missing => DriveState::Missing,
|
|
DriveState::PermissionDenied => DriveState::PermissionDenied,
|
|
DriveState::Faulty => DriveState::Faulty,
|
|
DriveState::RootMount => DriveState::RootMount,
|
|
DriveState::Unformatted => DriveState::Unformatted,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Display for DriveState {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
write!(f, "{}", self.to_str())
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
|
#[repr(u8)]
|
|
pub enum HealScanMode {
|
|
Unknown = 0,
|
|
#[default]
|
|
Normal = 1,
|
|
Deep = 2,
|
|
}
|
|
|
|
impl HealScanMode {
|
|
pub const fn as_str(self) -> &'static str {
|
|
match self {
|
|
Self::Unknown => "unknown",
|
|
Self::Normal => "normal",
|
|
Self::Deep => "deep",
|
|
}
|
|
}
|
|
|
|
pub const fn from_u8(value: u8) -> Option<Self> {
|
|
match value {
|
|
0 => Some(Self::Unknown),
|
|
1 => Some(Self::Normal),
|
|
2 => Some(Self::Deep),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Serialize for HealScanMode {
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: serde::Serializer,
|
|
{
|
|
serializer.serialize_u8(*self as u8)
|
|
}
|
|
}
|
|
|
|
impl<'de> Deserialize<'de> for HealScanMode {
|
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
|
where
|
|
D: serde::Deserializer<'de>,
|
|
{
|
|
struct HealScanModeVisitor;
|
|
|
|
impl<'de> serde::de::Visitor<'de> for HealScanModeVisitor {
|
|
type Value = HealScanMode;
|
|
|
|
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
|
|
formatter.write_str("an integer between 0 and 2")
|
|
}
|
|
|
|
fn visit_u8<E>(self, value: u8) -> Result<Self::Value, E>
|
|
where
|
|
E: serde::de::Error,
|
|
{
|
|
HealScanMode::from_u8(value).ok_or_else(|| E::custom(format!("invalid HealScanMode value: {value}")))
|
|
}
|
|
|
|
fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
|
|
where
|
|
E: serde::de::Error,
|
|
{
|
|
if value > u8::MAX as u64 {
|
|
return Err(E::custom(format!("HealScanMode value too large: {value}")));
|
|
}
|
|
self.visit_u8(value as u8)
|
|
}
|
|
|
|
fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
|
|
where
|
|
E: serde::de::Error,
|
|
{
|
|
if value < 0 || value > u8::MAX as i64 {
|
|
return Err(E::custom(format!("invalid HealScanMode value: {value}")));
|
|
}
|
|
self.visit_u8(value as u8)
|
|
}
|
|
|
|
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
|
|
where
|
|
E: serde::de::Error,
|
|
{
|
|
// Try parsing as number string first (for URL-encoded values)
|
|
if let Ok(num) = value.parse::<u8>() {
|
|
return self.visit_u8(num);
|
|
}
|
|
// Try parsing as named string
|
|
match value {
|
|
"Unknown" | "unknown" => Ok(HealScanMode::Unknown),
|
|
"Normal" | "normal" => Ok(HealScanMode::Normal),
|
|
"Deep" | "deep" => Ok(HealScanMode::Deep),
|
|
_ => Err(E::custom(format!("invalid HealScanMode string: {value}"))),
|
|
}
|
|
}
|
|
}
|
|
|
|
deserializer.deserialize_any(HealScanModeVisitor)
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize)]
|
|
pub struct HealOpts {
|
|
pub recursive: bool,
|
|
#[serde(rename = "dryRun")]
|
|
pub dry_run: bool,
|
|
pub remove: bool,
|
|
pub recreate: bool,
|
|
#[serde(rename = "scanMode")]
|
|
pub scan_mode: HealScanMode,
|
|
#[serde(rename = "updateParity")]
|
|
pub update_parity: bool,
|
|
#[serde(rename = "nolock")]
|
|
pub no_lock: bool,
|
|
#[serde(rename = "pool", default)]
|
|
pub pool: Option<usize>,
|
|
#[serde(rename = "set", default)]
|
|
pub set: Option<usize>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum HealAdmissionDropReason {
|
|
QueueFull,
|
|
PolicyDropped,
|
|
}
|
|
|
|
impl HealAdmissionDropReason {
|
|
pub fn as_str(self) -> &'static str {
|
|
match self {
|
|
Self::QueueFull => "queue_full",
|
|
Self::PolicyDropped => "policy_dropped",
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum HealAdmissionResult {
|
|
Accepted,
|
|
Merged,
|
|
Full,
|
|
Dropped(HealAdmissionDropReason),
|
|
}
|
|
|
|
/// Admission decision together with the canonical task identifier.
|
|
///
|
|
/// A merged request must return the identifier of the task that already owns
|
|
/// the work instead of exposing the discarded request identifier as a new
|
|
/// client token.
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct HealAdmissionReceipt {
|
|
/// Admission decision for the submitted request.
|
|
pub result: HealAdmissionResult,
|
|
/// Canonical identifier of the accepted or merged task.
|
|
pub task_id: String,
|
|
}
|
|
|
|
impl HealAdmissionResult {
|
|
pub fn result_label(self) -> &'static str {
|
|
match self {
|
|
Self::Accepted => "accepted",
|
|
Self::Merged => "merged",
|
|
Self::Full => "full",
|
|
Self::Dropped(_) => "dropped",
|
|
}
|
|
}
|
|
|
|
pub fn reason_label(self) -> &'static str {
|
|
match self {
|
|
Self::Dropped(reason) => reason.as_str(),
|
|
_ => "none",
|
|
}
|
|
}
|
|
|
|
pub fn is_admitted(self) -> bool {
|
|
matches!(self, Self::Accepted | Self::Merged)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(rename_all = "snake_case")]
|
|
pub enum HealRequestSource {
|
|
#[default]
|
|
Internal,
|
|
Admin,
|
|
Scanner,
|
|
AutoHeal,
|
|
ReadRepair,
|
|
}
|
|
|
|
impl HealRequestSource {
|
|
pub const fn as_str(self) -> &'static str {
|
|
match self {
|
|
Self::Internal => "internal",
|
|
Self::Admin => "admin",
|
|
Self::Scanner => "scanner",
|
|
Self::AutoHeal => "auto_heal",
|
|
Self::ReadRepair => "read_repair",
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Heal channel command type
|
|
#[derive(Debug)]
|
|
pub enum HealChannelCommand {
|
|
/// Start a new heal task
|
|
Start {
|
|
request: HealChannelRequest,
|
|
response_tx: oneshot::Sender<Result<HealAdmissionResult, String>>,
|
|
},
|
|
/// Query heal task status
|
|
Query {
|
|
heal_path: String,
|
|
client_token: String,
|
|
response_tx: oneshot::Sender<Result<HealChannelResponse, String>>,
|
|
},
|
|
/// Cancel heal task
|
|
Cancel {
|
|
heal_path: String,
|
|
client_token: String,
|
|
response_tx: oneshot::Sender<Result<HealChannelResponse, String>>,
|
|
},
|
|
}
|
|
|
|
/// Heal request from admin to ahm
|
|
#[derive(Debug, Clone, Default)]
|
|
pub struct HealChannelRequest {
|
|
/// Unique request ID
|
|
pub id: String,
|
|
/// Disk ID for heal disk/erasure set task
|
|
pub disk: Option<String>,
|
|
/// Bucket name
|
|
pub bucket: String,
|
|
/// Object prefix (optional)
|
|
pub object_prefix: Option<String>,
|
|
/// Object version ID (optional)
|
|
pub object_version_id: Option<String>,
|
|
/// Force start heal
|
|
pub force_start: bool,
|
|
/// Priority
|
|
pub priority: HealChannelPriority,
|
|
/// Pool index (optional)
|
|
pub pool_index: Option<usize>,
|
|
/// Set index (optional)
|
|
pub set_index: Option<usize>,
|
|
/// Scan mode (optional)
|
|
pub scan_mode: Option<HealScanMode>,
|
|
/// Whether to remove corrupted data
|
|
pub remove_corrupted: Option<bool>,
|
|
/// Whether to recreate missing data
|
|
pub recreate_missing: Option<bool>,
|
|
/// Whether to update parity
|
|
pub update_parity: Option<bool>,
|
|
/// Whether to recursively process
|
|
pub recursive: Option<bool>,
|
|
/// Whether to dry run
|
|
pub dry_run: Option<bool>,
|
|
/// Timeout in seconds (optional)
|
|
pub timeout_seconds: Option<u64>,
|
|
/// Origin of the request for operational status and queue accounting
|
|
pub source: HealRequestSource,
|
|
}
|
|
|
|
/// Heal response from ahm to admin
|
|
#[derive(Debug, Clone)]
|
|
pub struct HealChannelResponse {
|
|
/// Request ID
|
|
pub request_id: String,
|
|
/// Success status
|
|
pub success: bool,
|
|
/// Response data (if successful)
|
|
pub data: Option<Vec<u8>>,
|
|
/// Error message (if failed)
|
|
pub error: Option<String>,
|
|
}
|
|
|
|
/// Heal priority
|
|
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
|
|
pub enum HealChannelPriority {
|
|
/// Low priority
|
|
Low,
|
|
/// Normal priority
|
|
#[default]
|
|
Normal,
|
|
/// High priority
|
|
High,
|
|
/// Critical priority
|
|
Critical,
|
|
}
|
|
|
|
/// Heal channel sender
|
|
pub type HealChannelSender = mpsc::UnboundedSender<HealChannelCommand>;
|
|
|
|
/// Heal channel receiver
|
|
pub type HealChannelReceiver = mpsc::UnboundedReceiver<HealChannelCommand>;
|
|
|
|
/// Canonical-receipt start command kept separate from the legacy public enum.
|
|
#[derive(Debug)]
|
|
pub struct HealReceiptCommand {
|
|
/// Heal request to admit.
|
|
pub request: HealChannelRequest,
|
|
/// Completion channel for the admission receipt.
|
|
pub response_tx: oneshot::Sender<Result<HealAdmissionReceipt, String>>,
|
|
}
|
|
|
|
/// Canonical-receipt command receiver.
|
|
pub type HealReceiptReceiver = mpsc::UnboundedReceiver<HealReceiptCommand>;
|
|
|
|
struct HealChannelSenders {
|
|
command: HealChannelSender,
|
|
receipt: mpsc::UnboundedSender<HealReceiptCommand>,
|
|
}
|
|
|
|
/// Global heal channel sender
|
|
static GLOBAL_HEAL_CHANNEL_SENDERS: OnceLock<HealChannelSenders> = OnceLock::new();
|
|
|
|
type HealResponseSender = broadcast::Sender<HealChannelResponse>;
|
|
|
|
/// Global heal response broadcaster
|
|
static GLOBAL_HEAL_RESPONSE_SENDER: OnceLock<HealResponseSender> = OnceLock::new();
|
|
|
|
/// Initialize global heal channel
|
|
pub fn init_heal_channel() -> Result<HealChannelReceiver, &'static str> {
|
|
let (receiver, receipt_receiver) = init_heal_channels()?;
|
|
drop(receipt_receiver);
|
|
Ok(receiver)
|
|
}
|
|
|
|
/// Initialize the legacy command and canonical-receipt channels atomically.
|
|
pub fn init_heal_channels() -> Result<(HealChannelReceiver, HealReceiptReceiver), &'static str> {
|
|
let (command, command_receiver) = mpsc::unbounded_channel();
|
|
let (receipt, receipt_receiver) = mpsc::unbounded_channel();
|
|
GLOBAL_HEAL_CHANNEL_SENDERS
|
|
.set(HealChannelSenders { command, receipt })
|
|
.map_err(|_| "Heal channel sender already initialized")?;
|
|
Ok((command_receiver, receipt_receiver))
|
|
}
|
|
|
|
/// Get global heal channel sender
|
|
pub fn get_heal_channel_sender() -> Option<&'static HealChannelSender> {
|
|
GLOBAL_HEAL_CHANNEL_SENDERS.get().map(|senders| &senders.command)
|
|
}
|
|
|
|
/// Send heal command through global channel
|
|
pub async fn send_heal_command(command: HealChannelCommand) -> Result<(), String> {
|
|
if let Some(sender) = get_heal_channel_sender() {
|
|
sender
|
|
.send(command)
|
|
.map_err(|e| format!("Failed to send heal command: {e}"))?;
|
|
Ok(())
|
|
} else {
|
|
Err("Heal channel not initialized".to_string())
|
|
}
|
|
}
|
|
|
|
fn heal_response_sender() -> &'static HealResponseSender {
|
|
GLOBAL_HEAL_RESPONSE_SENDER.get_or_init(|| {
|
|
let (tx, _rx) = broadcast::channel(1024);
|
|
tx
|
|
})
|
|
}
|
|
|
|
/// Publish a heal response to subscribers.
|
|
pub fn publish_heal_response(response: HealChannelResponse) -> Result<(), broadcast::error::SendError<HealChannelResponse>> {
|
|
let sender = heal_response_sender();
|
|
let _ = sender.send(response);
|
|
Ok(())
|
|
}
|
|
|
|
/// Subscribe to heal responses.
|
|
pub fn subscribe_heal_responses() -> broadcast::Receiver<HealChannelResponse> {
|
|
heal_response_sender().subscribe()
|
|
}
|
|
|
|
/// Send heal start request and wait for structured admission feedback.
|
|
pub async fn send_heal_request_with_receipt(request: HealChannelRequest) -> Result<HealAdmissionReceipt, String> {
|
|
let (response_tx, response_rx) = oneshot::channel();
|
|
let senders = GLOBAL_HEAL_CHANNEL_SENDERS
|
|
.get()
|
|
.ok_or_else(|| "Heal channel not initialized".to_string())?;
|
|
senders
|
|
.receipt
|
|
.send(HealReceiptCommand { request, response_tx })
|
|
.map_err(|err| format!("Failed to send heal receipt command: {err}"))?;
|
|
response_rx
|
|
.await
|
|
.map_err(|e| format!("Failed to receive heal admission response: {e}"))?
|
|
}
|
|
|
|
/// Send heal start request and wait for structured admission feedback.
|
|
pub async fn send_heal_request_with_admission(request: HealChannelRequest) -> Result<HealAdmissionResult, String> {
|
|
let (response_tx, response_rx) = oneshot::channel();
|
|
send_heal_command(HealChannelCommand::Start { request, response_tx }).await?;
|
|
response_rx
|
|
.await
|
|
.map_err(|e| format!("Failed to receive heal admission response: {e}"))?
|
|
}
|
|
|
|
/// Send heal start request
|
|
pub async fn send_heal_request(request: HealChannelRequest) -> Result<(), String> {
|
|
match send_heal_request_with_admission(request).await? {
|
|
HealAdmissionResult::Accepted | HealAdmissionResult::Merged => Ok(()),
|
|
HealAdmissionResult::Full => Err("Heal request queue is full".to_string()),
|
|
HealAdmissionResult::Dropped(reason) => Err(format!("Heal request dropped: {}", reason.as_str())),
|
|
}
|
|
}
|
|
|
|
async fn receive_heal_channel_response(
|
|
response_rx: oneshot::Receiver<Result<HealChannelResponse, String>>,
|
|
) -> Result<HealChannelResponse, String> {
|
|
response_rx
|
|
.await
|
|
.map_err(|e| format!("Failed to receive heal channel response: {e}"))?
|
|
}
|
|
|
|
/// Send heal query request
|
|
pub async fn query_heal_status(heal_path: String, client_token: String) -> Result<HealChannelResponse, String> {
|
|
let (response_tx, response_rx) = oneshot::channel();
|
|
send_heal_command(HealChannelCommand::Query {
|
|
heal_path,
|
|
client_token,
|
|
response_tx,
|
|
})
|
|
.await?;
|
|
receive_heal_channel_response(response_rx).await
|
|
}
|
|
|
|
/// Send heal cancel request
|
|
pub async fn cancel_heal_task(heal_path: String, client_token: String) -> Result<HealChannelResponse, String> {
|
|
let (response_tx, response_rx) = oneshot::channel();
|
|
send_heal_command(HealChannelCommand::Cancel {
|
|
heal_path,
|
|
client_token,
|
|
response_tx,
|
|
})
|
|
.await?;
|
|
receive_heal_channel_response(response_rx).await
|
|
}
|
|
|
|
/// Create a new heal request
|
|
pub fn create_heal_request(
|
|
bucket: String,
|
|
object_prefix: Option<String>,
|
|
force_start: bool,
|
|
priority: Option<HealChannelPriority>,
|
|
) -> HealChannelRequest {
|
|
HealChannelRequest {
|
|
id: Uuid::new_v4().to_string(),
|
|
bucket,
|
|
object_prefix,
|
|
object_version_id: None,
|
|
force_start,
|
|
priority: priority.unwrap_or_default(),
|
|
pool_index: None,
|
|
set_index: None,
|
|
scan_mode: None,
|
|
remove_corrupted: None,
|
|
recreate_missing: None,
|
|
update_parity: None,
|
|
recursive: None,
|
|
dry_run: None,
|
|
timeout_seconds: None,
|
|
source: HealRequestSource::Internal,
|
|
disk: None,
|
|
}
|
|
}
|
|
|
|
/// Create a new heal request with advanced options
|
|
pub fn create_heal_request_with_options(
|
|
bucket: String,
|
|
object_prefix: Option<String>,
|
|
force_start: bool,
|
|
priority: Option<HealChannelPriority>,
|
|
pool_index: Option<usize>,
|
|
set_index: Option<usize>,
|
|
) -> HealChannelRequest {
|
|
HealChannelRequest {
|
|
id: Uuid::new_v4().to_string(),
|
|
bucket,
|
|
object_prefix,
|
|
object_version_id: None,
|
|
force_start,
|
|
priority: priority.unwrap_or_default(),
|
|
pool_index,
|
|
set_index,
|
|
..Default::default()
|
|
}
|
|
}
|
|
|
|
/// Create a heal response
|
|
pub fn create_heal_response(
|
|
request_id: String,
|
|
success: bool,
|
|
data: Option<Vec<u8>>,
|
|
error: Option<String>,
|
|
) -> HealChannelResponse {
|
|
HealChannelResponse {
|
|
request_id,
|
|
success,
|
|
data,
|
|
error,
|
|
}
|
|
}
|
|
|
|
fn lc_get_prefix(rule: &LifecycleRule) -> String {
|
|
if let Some(p) = &rule.prefix {
|
|
return p.to_string();
|
|
} else if let Some(filter) = &rule.filter {
|
|
if let Some(p) = &filter.prefix {
|
|
return p.to_string();
|
|
} else if let Some(and) = &filter.and
|
|
&& let Some(p) = &and.prefix
|
|
{
|
|
return p.to_string();
|
|
}
|
|
}
|
|
|
|
"".into()
|
|
}
|
|
|
|
pub fn lc_has_active_rules(config: &BucketLifecycleConfiguration, prefix: &str) -> bool {
|
|
if config.rules.is_empty() {
|
|
return false;
|
|
}
|
|
|
|
for rule in config.rules.iter() {
|
|
if rule.status == ExpirationStatus::from_static(ExpirationStatus::DISABLED) {
|
|
continue;
|
|
}
|
|
let rule_prefix = lc_get_prefix(rule);
|
|
if !prefix.is_empty() && !rule_prefix.is_empty() && !prefix.starts_with(&rule_prefix) && !rule_prefix.starts_with(prefix)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if let Some(e) = &rule.noncurrent_version_expiration {
|
|
if e.noncurrent_days.is_some() {
|
|
return true;
|
|
}
|
|
if let Some(true) = e.newer_noncurrent_versions.map(|d| d > 0) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if rule.noncurrent_version_transitions.is_some() {
|
|
return true;
|
|
}
|
|
if let Some(true) = rule.expiration.as_ref().map(|e| e.date.is_some()) {
|
|
return true;
|
|
}
|
|
|
|
if let Some(true) = rule.expiration.as_ref().map(|e| e.days.is_some()) {
|
|
return true;
|
|
}
|
|
|
|
if let Some(Some(true)) = rule.expiration.as_ref().map(|e| e.expired_object_delete_marker) {
|
|
return true;
|
|
}
|
|
|
|
if let Some(true) = rule.transitions.as_ref().map(|t| !t.is_empty()) {
|
|
return true;
|
|
}
|
|
|
|
if rule.transitions.is_some() {
|
|
return true;
|
|
}
|
|
}
|
|
false
|
|
}
|
|
|
|
pub fn rep_has_active_rules(config: &ReplicationConfiguration, prefix: &str, recursive: bool) -> bool {
|
|
if config.rules.is_empty() {
|
|
return false;
|
|
}
|
|
|
|
for rule in config.rules.iter() {
|
|
if rule
|
|
.status
|
|
.eq(&ReplicationRuleStatus::from_static(ReplicationRuleStatus::DISABLED))
|
|
{
|
|
continue;
|
|
}
|
|
if !prefix.is_empty()
|
|
&& let Some(filter) = &rule.filter
|
|
&& let Some(r_prefix) = &filter.prefix
|
|
&& !r_prefix.is_empty()
|
|
{
|
|
// incoming prefix must be in rule prefix
|
|
if !recursive && !prefix.starts_with(r_prefix) {
|
|
continue;
|
|
}
|
|
// If recursive, we can skip this rule if it doesn't match the tested prefix or level below prefix
|
|
// does not match
|
|
if recursive && !r_prefix.starts_with(prefix) && !prefix.starts_with(r_prefix) {
|
|
continue;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
false
|
|
}
|
|
|
|
pub async fn send_heal_disk(set_disk_id: String, priority: Option<HealChannelPriority>) -> Result<(), String> {
|
|
let req = HealChannelRequest {
|
|
id: Uuid::new_v4().to_string(),
|
|
bucket: "".to_string(),
|
|
object_prefix: None,
|
|
disk: Some(set_disk_id),
|
|
object_version_id: None,
|
|
force_start: false,
|
|
priority: priority.unwrap_or(HealChannelPriority::Low),
|
|
pool_index: None,
|
|
set_index: None,
|
|
scan_mode: None,
|
|
remove_corrupted: None,
|
|
recreate_missing: None,
|
|
update_parity: None,
|
|
recursive: None,
|
|
dry_run: None,
|
|
timeout_seconds: None,
|
|
source: HealRequestSource::AutoHeal,
|
|
};
|
|
send_heal_request(req).await
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn heal_request_source_labels_are_stable() {
|
|
assert_eq!(HealRequestSource::Scanner.as_str(), "scanner");
|
|
assert_eq!(HealRequestSource::Admin.as_str(), "admin");
|
|
assert_eq!(HealRequestSource::AutoHeal.as_str(), "auto_heal");
|
|
assert_eq!(HealRequestSource::Internal.as_str(), "internal");
|
|
assert_eq!(HealRequestSource::ReadRepair.as_str(), "read_repair");
|
|
|
|
let request = HealChannelRequest::default();
|
|
assert_eq!(request.source, HealRequestSource::Internal);
|
|
}
|
|
|
|
#[test]
|
|
fn heal_admission_result_labels_are_stable() {
|
|
assert_eq!(HealAdmissionResult::Accepted.result_label(), "accepted");
|
|
assert_eq!(HealAdmissionResult::Merged.result_label(), "merged");
|
|
assert_eq!(HealAdmissionResult::Full.result_label(), "full");
|
|
assert_eq!(
|
|
HealAdmissionResult::Dropped(HealAdmissionDropReason::QueueFull).reason_label(),
|
|
"queue_full"
|
|
);
|
|
assert!(HealAdmissionResult::Merged.is_admitted());
|
|
assert!(!HealAdmissionResult::Full.is_admitted());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn heal_response_broadcast_reaches_subscriber() {
|
|
let mut receiver = subscribe_heal_responses();
|
|
let response = create_heal_response("req-1".to_string(), true, None, None);
|
|
|
|
publish_heal_response(response.clone()).expect("publish should succeed");
|
|
|
|
let received = receiver.recv().await.expect("should receive heal response");
|
|
assert_eq!(received.request_id, response.request_id);
|
|
assert!(received.success);
|
|
|
|
drop(receiver);
|
|
let response = create_heal_response("req-no-subscriber".to_string(), true, None, None);
|
|
|
|
publish_heal_response(response).expect("publish without subscribers should be ignored");
|
|
}
|
|
}
|