Struct BackupWorker 

pub struct BackupWorker { /* private fields */ }

The backup worker. BackupWorker::spawn runs it as a task; tests drive it a step at a time with run_once.

Implementations

impl BackupWorker

pub fn new( config: BackupConfig, store: Arc<dyn ObjectStore>, source: Arc<dyn WalSource>, store_dir: PathBuf, ) -> Result<Self, BackupError>

A worker for the store in store_dir, uploading to store under the prefix config.s3_url names.

pub fn spawn( config: BackupConfig, store: Arc<dyn ObjectStore>, source: Arc<dyn WalSource>, store_dir: PathBuf, snapshot_rx: Receiver<BackupTrigger>, ) -> Result<BackupHandle, BackupError>

Start the worker as a Tokio task. It takes the bucket lease, then runs one step at once — reading the bucket’s previous state and uploading a base restore point — then one every wal_interval_ms, and one immediately on each trigger. While another instance holds the lease it uploads nothing and is unhealthy (see the module docs).

Errors

Only a malformed config.s3_url.

pub fn start(self, snapshot_rx: Receiver<BackupTrigger>) -> BackupHandle

Run this worker as a Tokio task, beside a supervisor that evaluates health every wal_interval_ms and reports the worker’s end — a shutdown, or a panic — as unhealthy with the reason.

pub fn counters(&self) -> BackupCounters

The counters this worker updates (the same ones its BackupHandle carries).

pub fn instance_id(&self) -> &str

The instance id this worker takes the bucket lease under, the same for every attempt.

pub fn adopt_lease(&mut self, lease: Arc<BucketLease>)

Hold lease, taken for this prefix by someone else in this process (a restore on boot), instead of taking one: the worker renews it at once and from then on, and its instance id becomes the lease’s. Call before start, inside a Tokio runtime.

pub async fn step(&mut self) -> Duration

One step, with its outcome recorded in the counters. Returns how long to wait before the next one: the WAL interval after a success or a deferral, the back-off after a failure.

pub async fn flush(&mut self)

Ship pending WAL bytes and write a final manifest, retrying a failure twice. Used on shutdown, under the shutdown grace.

pub async fn run_once(&mut self) -> Result<(), BackupError>

One step: read the bucket’s previous state if not done yet; upload a new restore point when the snapshot or WAL file on disk, or the engine’s WAL generation, changed; ship the WAL bytes fsynced since the last step; write a manifest when one is due.