mars-shard · lifecycle

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum LifecycleEvent {
    /// A shard is being split into two new shards.
    Split {
        source_shard: String,
        new_shard_a: String,
        new_shard_b: String,
    },
    /// Two shards are being merged into one.
    Merge {
        shard_a: String,
        shard_b: String,
        target_shard: String,
    },
    /// A shard is being migrated between clusters.
    Migrate {
        shard: String,
        from_cluster: String,
        to_cluster: String,
    },
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum OperationState {
    /// Operation has been created but not started.
    Initiated,
    /// Operation is actively executing.
    InProgress,
    /// Operation is finalizing (writing metadata, updating topology).
    Completing,
    /// Operation completed successfully.
    Complete,
    /// Operation failed with a reason.
    Failed(String),
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LifecycleOperation {
/// Unique operation ID.

pub id: String,
/// The lifecycle event being executed.

pub event: LifecycleEvent,
/// Current state of the operation.

pub state: OperationState,
/// When the operation was initiated.

pub started_at: chrono::DateTime<chrono::Utc>,
/// When the operation completed (if it has).

#[serde(skip_serializing_if = "Option::is_none")]
pub completed_at: Option<chrono::DateTime<chrono::Utc>>
}

pub struct LifecycleManager {

}

pub fn new(split_threshold: f64, merge_threshold: f64) -> Self;

pub fn check_split_needed(&self, shard: &ShardInfo) -> bool;

pub fn check_merge_needed(&self, shard: &ShardInfo) -> bool;

pub fn initiate_split(&mut self, shard_id: &str) -> Result<LifecycleOperation, ShardError>;

pub fn initiate_merge(
        &mut self,
        shard_a: &str,
        shard_b: &str,
    ) -> Result<LifecycleOperation, ShardError>;

pub fn initiate_migrate(
        &mut self,
        shard_id: &str,
        from_cluster: &str,
        to_cluster: &str,
    ) -> Result<LifecycleOperation, ShardError>;

pub fn advance(&mut self, op_id: &str, new_state: OperationState) -> Result<(), ShardError>;

pub fn pending_operations(&self) -> Vec<&LifecycleOperation>;

pub fn all_operations(&self) -> &[LifecycleOperation];

pub fn split_threshold(&self) -> f64;

pub fn merge_threshold(&self) -> f64;