Struct LeaseLooper 

pub struct LeaseLooper<T, Fut, S>
where
    T: Fn(LeaseContext, S) -> Fut + Send + Sync + Clone + 'static,
    Fut: Future<Output = Result<(), Box<dyn Error + Send + Sync>>> + Send + 'static,
    S: Clone + Send + Sync + 'static,
{ /* private fields */ }

A lease-based looper that ensures only one worker can execute a task at a time across multiple processes/machines using PostgreSQL as the coordination mechanism.

The looper function receives shared state of type S, allowing you to pass application-specific data (similar to Axum’s state handling).

Example

use std::sync::Arc;
use tokio::sync::Mutex;
use pg_lease::{LeaseLooper, LeaseLooperOptions};

#[derive(Clone)]
struct AppState {
    counter: Arc<Mutex<i32>>,
    config: String,
}

let state = AppState {
    counter: Arc::new(Mutex::new(0)),
    config: "production".to_string(),
};

let looper_func = |state: AppState| async move {
    let mut counter = state.counter.lock().await;
    *counter += 1;
    println!("Counter: {}, Config: {}", *counter, state.config);
    Ok(())
};

let looper = LeaseLooper::new(
    "my-task".to_string(),
    looper_func,
    "worker-1".to_string(),
    pool,
    LeaseLooperOptions::default(),
    state,
);

Implementations

impl<T, Fut, S> LeaseLooper<T, Fut, S>

where T: Fn(LeaseContext, S) -> Fut + Send + Sync + Clone + 'static, Fut: Future<Output = Result<(), Box<dyn Error + Send + Sync>>> + Send + 'static, S: Clone + Send + Sync + 'static,

pub fn new( lease_name: String, looper_func: T, worker_id: String, pool: Pool<Postgres>, options: LeaseLooperOptions, state: S, ) -> Self

pub async fn start(&self) -> Result<(), Box<dyn Error + Send + Sync>>

Starts the lease looper, which will poll for a lease and execute the looper function when the lease is acquired.

pub async fn stop(&self) -> Result<(), Box<dyn Error + Send + Sync>>

Stops the lease looper, aborting all running tasks.