ranvier-runtime 0.37.0

Async Execution Engine for Ranvier
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
112
113
114
115
116

use async_trait::async_trait;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::Duration;
use tokio::time::sleep;
use tracing::{info, warn};

// In a real scenario, this might use ranvier_core::cluster::DistributedLock or the local one in distributed.rs
use crate::distributed::{DistributedError, DistributedLock, LockOptions};

/// Interface for components participating in cluster leader election.
#[async_trait]
pub trait LeaderElection: Send + Sync {
    /// Attempt to become the leader or renew leadership if already the leader.
    async fn try_become_leader(&self) -> Result<bool, DistributedError>;

    /// Returns true if this node is currently the elected leader.
    fn is_leader(&self) -> bool;

    /// Step down from leadership explicitly.
    async fn step_down(&self) -> Result<(), DistributedError>;
}

/// A standard implementation of leader election using a distributed lock.
pub struct LockBasedElection<L: DistributedLock> {
    lock: Arc<L>,
    node_id: String,
    resource_key: String,
    is_leader: Arc<AtomicBool>,
    ttl_ms: u64,
}

impl<L: DistributedLock> LockBasedElection<L> {
    pub fn new(lock: Arc<L>, node_id: String, resource_key: String, ttl_ms: u64) -> Self {
        Self {
            lock,
            node_id,
            resource_key,
            is_leader: Arc::new(AtomicBool::new(false)),
            ttl_ms,
        }
    }
}

#[async_trait]
impl<L: DistributedLock> LeaderElection for LockBasedElection<L> {
    async fn try_become_leader(&self) -> Result<bool, DistributedError> {
        let opts = LockOptions {
            ttl_ms: self.ttl_ms,
            retry_count: 0,
            retry_delay_ms: 0,
        };

        match self.lock.acquire(&self.resource_key, opts).await {
            Ok(_guard) => {
                if !self.is_leader.load(Ordering::Relaxed) {
                    info!("Node {} became the cluster leader", self.node_id);
                    self.is_leader.store(true, Ordering::SeqCst);
                }
                // We don't save the guard here in this simple implementation,
                // but a production version would keep the guard to extend it later.
                Ok(true)
            }
            Err(DistributedError::LockError(_)) => {
                if self.is_leader.load(Ordering::Relaxed) {
                    warn!("Node {} lost leadership!", self.node_id);
                    self.is_leader.store(false, Ordering::SeqCst);
                }
                Ok(false)
            }
            Err(e) => Err(e),
        }
    }

    fn is_leader(&self) -> bool {
        self.is_leader.load(Ordering::Relaxed)
    }

    async fn step_down(&self) -> Result<(), DistributedError> {
        if self.is_leader.swap(false, Ordering::SeqCst) {
            info!("Node {} stepping down from leadership", self.node_id);
            // In a real implementation, we would release the guard here.
        }
        Ok(())
    }
}

/// Manages the background task that periodically attempts to renew leadership.
pub struct ClusterManager {
    // Hidden internal structures for background task handle
}

impl ClusterManager {
    /// Starts a background task that periodically polls the leader election
    pub fn start_election_loop<E: LeaderElection + 'static>(
        election: Arc<E>,
        interval: Duration,
    ) -> tokio::task::JoinHandle<()> {
        tokio::spawn(async move {
            loop {
                match election.try_become_leader().await {
                    Ok(true) => {
                        // Successfully became or renewed leader.
                    }
                    Ok(false) => {
                        // Not the leader.
                    }
                    Err(err) => {
                        warn!("Error in leader election: {}", err);
                    }
                }
                sleep(interval).await;
            }
        })
    }
}