use std::time::{Duration, Instant};
use crate::backoff::BackoffPolicy;
use crate::engine::{PassOutcome, PassReport, SyncEngine};
use crate::ledger::ConsentRequest;
use crate::traits::RecordMapper;
#[derive(Debug, Clone, PartialEq)]
pub struct SyncBudget {
pub max_passes: u32,
pub max_elapsed: Duration,
pub max_inline_delay_secs: f64,
}
impl Default for SyncBudget {
fn default() -> Self {
Self {
max_passes: 1,
max_elapsed: Duration::from_secs(60),
max_inline_delay_secs: 0.0,
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct SchedulePolicy {
pub backoff: BackoffPolicy,
pub idle_secs: f64,
pub min_secs: f64,
pub cancelled_secs: f64,
}
impl Default for SchedulePolicy {
fn default() -> Self {
Self {
backoff: BackoffPolicy::default(),
idle_secs: 900.0,
min_secs: 15.0,
cancelled_secs: 30.0,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum WorkOutcome {
Success,
Retry,
Failure,
}
#[derive(Debug, Clone, PartialEq)]
pub struct SyncReport {
pub passes: u32,
pub outcome: PassOutcome,
pub uploaded: usize,
pub downloaded: usize,
pub tombstones_applied: usize,
pub tombstones_written: usize,
pub quarantined: usize,
pub elapsed_ms: u64,
pub work: WorkOutcome,
pub next_delay_secs: Option<f64>,
pub consent_required: Option<ConsentRequest>,
}
pub fn sync_once<M: RecordMapper + 'static>(
engine: &mut SyncEngine<M>,
budget: &SyncBudget,
policy: &SchedulePolicy,
) -> SyncReport {
let started = Instant::now();
let mut passes = 0u32;
let mut total = PassReport {
outcome: PassOutcome::Synced,
uploaded: 0,
downloaded: 0,
tombstones_applied: 0,
tombstones_written: 0,
quarantined: 0,
blocked_reuploads: 0,
retry_after_secs: None,
};
let max_passes = budget.max_passes.max(1);
loop {
let rep = engine.run_pass();
passes += 1;
total.uploaded += rep.uploaded;
total.downloaded += rep.downloaded;
total.tombstones_applied += rep.tombstones_applied;
total.tombstones_written += rep.tombstones_written;
total.quarantined += rep.quarantined;
total.blocked_reuploads += rep.blocked_reuploads;
let progress =
rep.uploaded + rep.downloaded + rep.tombstones_applied + rep.tombstones_written;
total.outcome = rep.outcome;
total.retry_after_secs = rep.retry_after_secs;
if !should_continue(
&total.outcome,
total.retry_after_secs,
progress,
passes,
max_passes,
started.elapsed(),
budget,
) {
break;
}
}
let failures = engine.ledger().consecutive_failures;
let consent_required = match &total.outcome {
PassOutcome::ConsentRequired(req) => Some(req.clone()),
_ => None,
};
SyncReport {
passes,
work: work_outcome(&total.outcome),
next_delay_secs: next_delay(&total.outcome, total.retry_after_secs, failures, policy),
outcome: total.outcome,
uploaded: total.uploaded,
downloaded: total.downloaded,
tombstones_applied: total.tombstones_applied,
tombstones_written: total.tombstones_written,
quarantined: total.quarantined,
elapsed_ms: started.elapsed().as_millis() as u64,
consent_required,
}
}
pub fn should_continue(
outcome: &PassOutcome,
retry_after_secs: Option<f64>,
progress: usize,
passes_run: u32,
max_passes: u32,
elapsed: Duration,
budget: &SyncBudget,
) -> bool {
if passes_run >= max_passes || elapsed >= budget.max_elapsed {
return false;
}
if !matches!(outcome, PassOutcome::Pending(_)) || progress == 0 {
return false;
}
match retry_after_secs {
Some(s) => s.is_finite() && s <= budget.max_inline_delay_secs,
None => true,
}
}
pub fn work_outcome(outcome: &PassOutcome) -> WorkOutcome {
match outcome {
PassOutcome::Synced => WorkOutcome::Success,
PassOutcome::Pending(_)
| PassOutcome::Deferred { .. }
| PassOutcome::Unavailable(_)
| PassOutcome::Cancelled
| PassOutcome::Failed(_) => WorkOutcome::Retry,
PassOutcome::Disabled | PassOutcome::ConsentRequired(_) => WorkOutcome::Failure,
}
}
pub fn next_delay(
outcome: &PassOutcome,
retry_after_secs: Option<f64>,
failures: u32,
policy: &SchedulePolicy,
) -> Option<f64> {
let engine = retry_after_secs.filter(|s| s.is_finite() && *s > 0.0);
let secs = match outcome {
PassOutcome::Disabled | PassOutcome::ConsentRequired(_) => return None,
PassOutcome::Synced => policy.idle_secs,
PassOutcome::Pending(_) => engine.unwrap_or(policy.backoff.pending_floor_secs),
PassOutcome::Deferred { secs } => {
if secs.is_finite() && *secs > 0.0 {
*secs
} else {
policy.min_secs
}
}
PassOutcome::Cancelled => engine.unwrap_or(policy.cancelled_secs),
PassOutcome::Unavailable(_) | PassOutcome::Failed(_) => {
engine.unwrap_or_else(|| policy.backoff.delay_secs(failures.max(1), None))
}
};
Some(secs.max(policy.min_secs))
}