bucketwarden-server 0.1.0

BucketWarden storage server runtime.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use super::*;

pub const REPLICATION_STRATEGY_ASYNC_ACTIVE_PASSIVE: &str = "async-active-passive";
pub const REPLICATION_STRATEGY_SYNCHRONOUS: &str = "synchronous";
pub const REPLICATION_STRATEGY_QUORUM: &str = "quorum";
pub const REPLICATION_STRATEGY_ACTIVE_ACTIVE: &str = "active-active";

const REPLICATION_STRATEGY_CAPABILITIES: &[&str] = &[
    "native-support-state",
    "semantic-parity",
    "configuration-admin-surface",
    "security-governance-impact",
    "observability-evidence",
    "failure-mode-behavior",
    "validation-test-coverage",
    "product-specific-caveats",
];

const REPLICATION_STRATEGY_CAVEATS: &[&str] = &[
    "BucketWarden supports explicit asynchronous active-passive replication runs.",
    "Replication preserves version identity, delete markers, Object Lock state, encryption metadata, and audit-relevant state.",
    "Synchronous, quorum, and active-active strategies are tracked but fail closed outside the current runtime boundary.",
];

const REPLICATION_STRATEGY_FAILURE_MODES: &[&str] = &[
    "unsupported-strategy-rejected",
    "missing-destination-skipped",
    "encrypted-object-skipped-when-disabled",
    "replication-lag-visible-as-pending",
];

#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct ReplicationStrategySupportEntry {
    pub strategy: &'static str,
    pub native_support: bool,
    pub semantic_parity: &'static str,
    pub failure_mode: &'static str,
    pub caveat: &'static str,
}

#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct ReplicationStrategySupportReport {
    pub active_strategy: &'static str,
    pub supported_strategies: Vec<&'static str>,
    pub unsupported_strategies: Vec<&'static str>,
    pub capabilities: Vec<&'static str>,
    pub failure_modes: Vec<&'static str>,
    pub caveats: Vec<&'static str>,
    pub entries: Vec<ReplicationStrategySupportEntry>,
}

impl BucketWarden {
    pub fn replication_strategy_support_report(&self) -> ReplicationStrategySupportReport {
        ReplicationStrategySupportReport {
            active_strategy: REPLICATION_STRATEGY_ASYNC_ACTIVE_PASSIVE,
            supported_strategies: vec![REPLICATION_STRATEGY_ASYNC_ACTIVE_PASSIVE],
            unsupported_strategies: vec![
                REPLICATION_STRATEGY_SYNCHRONOUS,
                REPLICATION_STRATEGY_QUORUM,
                REPLICATION_STRATEGY_ACTIVE_ACTIVE,
            ],
            capabilities: REPLICATION_STRATEGY_CAPABILITIES.to_vec(),
            failure_modes: REPLICATION_STRATEGY_FAILURE_MODES.to_vec(),
            caveats: REPLICATION_STRATEGY_CAVEATS.to_vec(),
            entries: vec![
                ReplicationStrategySupportEntry {
                    strategy: REPLICATION_STRATEGY_ASYNC_ACTIVE_PASSIVE,
                    native_support: true,
                    semantic_parity: "Explicit operator-triggered active-passive replication over BucketWarden object versions.",
                    failure_mode: "Lag is visible as PENDING or MISSING_DESTINATION until an operator run completes.",
                    caveat: "Replication is deterministic runtime replay, not an AWS cross-region replication SLA.",
                },
                ReplicationStrategySupportEntry {
                    strategy: REPLICATION_STRATEGY_SYNCHRONOUS,
                    native_support: false,
                    semantic_parity: "No write-acknowledged synchronous replica commit semantics are claimed.",
                    failure_mode: "Synchronous strategy selection is rejected as unsupported.",
                    caveat: "Synchronous replication needs a consensus or two-phase commit boundary before support.",
                },
                ReplicationStrategySupportEntry {
                    strategy: REPLICATION_STRATEGY_QUORUM,
                    native_support: false,
                    semantic_parity: "No quorum write, read repair, or replica voting semantics are claimed.",
                    failure_mode: "Quorum strategy selection is rejected as unsupported.",
                    caveat: "Quorum replication requires distributed placement and failure-domain decisions.",
                },
                ReplicationStrategySupportEntry {
                    strategy: REPLICATION_STRATEGY_ACTIVE_ACTIVE,
                    native_support: false,
                    semantic_parity: "No multi-writer conflict resolution or split-brain semantics are claimed.",
                    failure_mode: "Active-active strategy selection is rejected as unsupported.",
                    caveat: "Active-active replication requires explicit conflict semantics before support.",
                },
            ],
        }
    }

    pub fn ensure_replication_strategy_supported(
        &self,
        strategy: &str,
    ) -> Result<(), RuntimeError> {
        let report = self.replication_strategy_support_report();
        if report.supported_strategies.contains(&strategy) {
            Ok(())
        } else {
            Err(RuntimeError::UnsupportedReplicationStrategy(
                strategy.to_string(),
            ))
        }
    }
}