use std::collections::{HashMap, VecDeque};
use std::io::Read;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::time::Instant;
use crate::delta::{Delta, DeltaError, Signature, compute_delta_from_signatures, compute_delta_limited, compute_delta_rollsum, sign_source};
use crate::protocol::{
BatchFile, BatchItem, FileMeta, Frame, LinkSpec, SignatureEntry, SkippedFile,
stream,
};
use crate::sync::executor::{ExecutorOptions, ProgressFn};
use crate::sync::filter::FilterSet;
use crate::sync::planner::{Planner, PlannerConfig, SyncAction, SyncPlan, SyncTask};
use crate::sync::stats::{ItemizeAction, ItemizeEntry};
use crate::sync::scanner::Manifest;
use crate::sync::stats::SyncStats;
use crate::sync::strategy::{FileClass, TransferStrategy, classify_file_size, determine_strategy};
use crate::sync::wire::{
file_id, file_meta_from_entry, file_source, from_peer, manifest_from_file_meta, wire_rel,
};
use crate::sync::bandwidth::BandwidthLimiter;
use crate::{Error, Result};
use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt};
const DELTA_LITERAL_CHUNK_LIMIT: u64 = 256 * 1024 * 1024;
const BATCH_BYTES_BUDGET: u64 = 128 * 1024 * 1024;
const SIGNATURE_GROUP: usize = 32;
const CHUNK_SIZE: usize = 1024 * 1024;
const CHUNK_BATCH_BYTES: usize = 8 * 1024 * 1024;
const BATCH_READ_WINDOW: usize = 32;
pub(crate) struct Sender {
limiter: Option<Arc<BandwidthLimiter>>,
progress: Option<ProgressFn>,
compute_jobs: usize,
verify_hash: bool,
rollsum: bool,
itemize: bool,
}
impl Sender {
pub(crate) fn new(
bwlimit_bytes: Option<u64>,
progress: Option<ProgressFn>,
compute_jobs: usize,
verify_hash: bool,
rollsum: bool,
itemize: bool,
) -> Self {
Self {
limiter: bwlimit_bytes.map(|b| Arc::new(BandwidthLimiter::new(b))),
progress,
compute_jobs: compute_jobs.max(1),
verify_hash,
rollsum,
itemize,
}
}
pub(crate) async fn send<W: AsyncWrite + Unpin, R: AsyncRead + Unpin>(
&self,
ctrl_send: &mut W,
ctrl_recv: &mut R,
source_manifest: &Manifest,
source_root: &Path,
options: &ExecutorOptions,
) -> Result<SyncStats> {
let start = Instant::now();
let file_list: Vec<FileMeta> = source_manifest
.files
.iter()
.map(file_meta_from_entry)
.collect();
stream::send_frame(
ctrl_send,
&Frame::IndexRequest {
file_list,
path: options.remote_path.clone(),
verify: options.remove_source_files || options.verify,
},
)
.await?;
let frame = from_peer(stream::receive_frame(ctrl_recv).await?)?;
let dest_manifest = match frame {
Frame::IndexResponse { file_list } => manifest_from_file_meta(&file_list),
other => {
return Err(Error::Other(format!("Expected IndexResponse, got {other:?}")));
}
};
let planner = Planner::new(PlannerConfig {
checksum: options.checksum,
delete: options.delete,
delete_scope: (!options.delete_scope.is_empty()).then(|| options.delete_scope.clone()),
update_only: options.update_only,
ignore_existing: options.ignore_existing,
existing: options.existing,
ignore_times: options.ignore_times,
size_only: !options.preserve_times,
preserve_perms: options.preserve_perms,
preserve_times: options.preserve_times,
});
let plan = planner.plan(source_manifest, &dest_manifest);
tracing::info!(
"plan: {} create, {} update, {} delete, {} skip",
plan.creates.len(),
plan.updates.len(),
plan.deletes.len(),
plan.skips.len()
);
let mut changes = if self.itemize { plan.itemize() } else { Vec::new() };
let (bytes, files, transferred, send_skipped) = self
.apply_plan(ctrl_send, ctrl_recv, &plan, source_root, options)
.await?;
if !plan.deletes.is_empty() {
let filter = FilterSet {
includes: options.include.clone(),
excludes: options.exclude.clone(),
};
let skipped_set: std::collections::HashSet<&str> =
source_manifest.skipped.iter().map(String::as_str).collect();
let mut file_deletes: Vec<String> = Vec::new();
let mut dir_deletes: Vec<String> = Vec::new();
for task in &plan.deletes {
let rel = wire_rel(&task.relative_path);
let policy_skipped = is_under_skipped(&rel, &skipped_set);
if !filter.passes(&rel) || policy_skipped {
continue;
}
if task.is_dir {
dir_deletes.push(rel);
} else {
file_deletes.push(rel);
}
}
dir_deletes.sort_by(|a, b| b.cmp(a));
if !file_deletes.is_empty() || !dir_deletes.is_empty() {
if self.itemize {
changes.extend(recorded_deletes(&file_deletes, &dir_deletes));
}
let paths: Vec<String> = file_deletes.into_iter().chain(dir_deletes).collect();
stream::send_frame(ctrl_send, &Frame::DeleteRequest { paths }).await?;
}
}
let meta_paths: Vec<String> = plan
.meta
.iter()
.map(|task| wire_rel(&task.relative_path))
.collect();
if !meta_paths.is_empty() {
stream::send_frame(ctrl_send, &Frame::ApplyMeta { paths: meta_paths }).await?;
}
let meta_count = plan.meta.len() as u64;
stream::send_frame(ctrl_send, &Frame::Done {
files: files + meta_count,
bytes,
})
.await?;
let (recv_skipped, recv_hashes) = match from_peer(stream::receive_frame(ctrl_recv).await?)? {
Frame::Ack {
skipped, hashes, ..
} => (skipped, hashes),
other => return Err(Error::Other(format!("Expected Ack, got {other:?}"))),
};
let mut skipped = send_skipped;
skipped.extend(recv_skipped.clone());
if options.remove_source_files || options.verify {
let ack_hashes: HashMap<&str, [u8; 32]> =
recv_hashes.iter().map(|(rel, h)| (rel.as_str(), *h)).collect();
for (rel, source_hash) in &transferred {
if recv_skipped.iter().any(|s| s.path == *rel) {
continue;
}
let Some(dest_hash) = ack_hashes.get(rel.as_str()).copied() else {
tracing::warn!("no verification hash from receiver for {rel}");
skipped.push(SkippedFile::new(rel.clone(), "no verification hash from receiver".to_string()));
continue;
};
if *source_hash != dest_hash {
tracing::warn!(
"hash mismatch for {rel}: destination does not match source"
);
skipped.push(SkippedFile::new(rel.clone(), "hash mismatch: destination does not match source".to_string()));
continue;
}
if !options.remove_source_files {
tracing::info!("verified source {rel} (--verify)");
continue;
}
let entry = source_manifest.files.iter().find(|f| {
f.relative_path == *rel
});
if entry.is_some_and(|f| f.dereferenced) {
tracing::info!("external-origin source {rel}; not removed");
continue;
}
let full = source_root.join(rel);
match tokio::fs::metadata(&full).await {
Ok(src_meta) => {
let expected = source_manifest.files.iter().find(|f| {
f.relative_path == *rel
});
let scan_mtime = expected.map(|f| crate::sync::wire::mtime_to_wire(f.mtime_sec));
let stable = match (expected, scan_mtime) {
(Some(entry), Some(scan_mtime)) => {
src_meta.len() == entry.size
&& crate::platform::fs::mtime_secs(&src_meta) == scan_mtime
&& crate::platform::fs::mtime_nsecs(&src_meta) == entry.mtime_nsec
}
_ => true,
};
if !stable {
tracing::warn!("source changed since scan: {rel}; not removed");
skipped.push(SkippedFile::new(rel.clone(), "source changed since scan; not removed".to_string()));
continue;
}
}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => continue,
Err(e) => {
tracing::warn!("failed to stat source {rel}: {e}");
skipped.push(SkippedFile::new(rel.clone(), e.to_string()));
continue;
}
}
match tokio::fs::remove_file(&full).await {
Ok(()) => {
tracing::info!("verified and removed source {rel} (--remove-source-files)");
}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
Err(e) => {
tracing::warn!("failed to remove source {rel}: {e}");
skipped.push(SkippedFile::new(rel.clone(), e.to_string()));
}
}
}
}
#[expect(clippy::cast_possible_truncation)]
let files_sent = (files + meta_count) as usize;
Ok(SyncStats {
files_sent,
files_received: 0,
bytes_transferred: bytes,
duration: start.elapsed(),
changes,
skipped,
})
}
async fn request_needed_signatures<W: AsyncWrite + Unpin, R: AsyncRead + Unpin>(
&self,
ctrl_send: &mut W,
ctrl_recv: &mut R,
plan: &SyncPlan,
source_root: &Path,
files_total: u64,
) -> Result<(
HashMap<String, Arc<Signature>>,
HashMap<String, std::sync::mpsc::Receiver<Result<SourceSig>>>,
)> {
let mut need_sig: Vec<String> = Vec::new();
let mut prefetch: HashMap<String, std::sync::mpsc::Receiver<Result<SourceSig>>> =
HashMap::new();
for task in plan.tasks() {
if task.link_to.is_some() {
continue;
}
let dest_exists = task.action == SyncAction::Update;
if determine_strategy(task.source_size, dest_exists) == TransferStrategy::Delta {
let rel = wire_rel(&task.relative_path);
need_sig.push(rel.clone());
if !self.rollsum && task.source_size >= BIG_DELTA_PREFETCH_MIN {
let (tx, rx) = std::sync::mpsc::channel();
let full = task_source(source_root, task);
let display = rel.clone();
let progress = self.progress.clone();
let verify_hash = self.verify_hash;
tokio::task::spawn_blocking(move || {
let _ = tx.send(sign_source_task(
&full,
display,
progress,
verify_hash,
files_total,
));
});
prefetch.insert(rel, rx);
}
}
}
let sigs = self.request_signatures(ctrl_send, ctrl_recv, &need_sig).await?;
Ok((sigs, prefetch))
}
async fn send_make_dirs<W: AsyncWrite + Unpin>(
&self,
ctrl_send: &mut W,
plan: &SyncPlan,
) -> Result<u64> {
let mut dir_paths: Vec<String> = Vec::new();
for task in plan.tasks() {
if task.is_dir {
dir_paths.push(wire_rel(&task.relative_path));
}
}
if dir_paths.is_empty() {
return Ok(0);
}
let dir_count = dir_paths.len() as u64;
stream::send_frame(ctrl_send, &Frame::MakeDir { paths: dir_paths }).await?;
Ok(dir_count)
}
async fn send_links<W: AsyncWrite + Unpin>(
&self,
ctrl_send: &mut W,
links: Vec<LinkSpec>,
hardlinks: Vec<crate::protocol::HardlinkSpec>,
specials: Vec<crate::protocol::SpecialSpec>,
) -> Result<()> {
if !links.is_empty() || !hardlinks.is_empty() || !specials.is_empty() {
stream::send_frame(
ctrl_send,
&Frame::CreateLinks {
links,
hardlinks,
specials,
},
)
.await?;
}
Ok(())
}
async fn drain_batch_read(
&self,
batch_reads: &mut VecDeque<BatchRead>,
batch: &mut Vec<BatchItem>,
batch_bytes: &mut u64,
skipped: &mut Vec<SkippedFile>,
batch_seq: &mut u64,
) -> Result<()> {
let Some(read) = batch_reads.pop_front() else {
return Ok(());
};
let rel = read.rel;
match read.handle.await {
Ok(Ok(data)) => {
if data.len() as u64 != read.expected_size {
source_changed(&rel, skipped);
return Ok(());
}
let checksum = if self.verify_hash {
Some(*blake3::hash(&data).as_bytes())
} else {
None
};
let len = data.len() as u64;
batch.push(BatchItem {
file_id: *batch_seq,
file_path: rel,
data,
checksum,
});
*batch_bytes += len;
*batch_seq += 1;
}
Ok(Err(e)) => {
tracing::warn!("skipping {rel}: {e}");
skipped.push(SkippedFile::new(rel, e.to_string()));
}
Err(e) => return Err(Error::Other(format!("Read task panicked: {e}"))),
}
Ok(())
}
async fn apply_plan<W: AsyncWrite + Unpin, R: AsyncRead + Unpin>(
&self,
ctrl_send: &mut W,
ctrl_recv: &mut R,
plan: &SyncPlan,
source_root: &Path,
options: &ExecutorOptions,
) -> Result<(u64, u64, Vec<(String, [u8; 32])>, Vec<SkippedFile>)> {
let files_total = plan
.tasks()
.filter(|t| {
!t.is_dir && t.link_target.is_none() && t.link_to.is_none() && t.special.is_none()
})
.count() as u64;
let mut bytes_transferred: u64 = 0;
let mut files_sent: u64 = 0;
let mut skipped: Vec<SkippedFile> = Vec::new();
let mut transferred: Vec<(String, [u8; 32])> = Vec::new();
let mut batch: Vec<BatchItem> = Vec::new();
let mut batch_bytes: u64 = 0;
let mut batch_seq: u64 = 0;
let mut batch_reads: VecDeque<BatchRead> = VecDeque::new();
let mut links: Vec<LinkSpec> = Vec::new();
let mut hardlinks: Vec<crate::protocol::HardlinkSpec> = Vec::new();
let mut specials: Vec<crate::protocol::SpecialSpec> = Vec::new();
let (mut sig_map, mut prefetch_map) = self
.request_needed_signatures(ctrl_send, ctrl_recv, plan, source_root, files_total)
.await?;
let mut pending: VecDeque<DeltaJob> = VecDeque::new();
let (mut basis_senders, mut basis_receivers) = {
let mut refs: HashMap<String, Vec<std::sync::mpsc::Sender<Signature>>> =
HashMap::new();
let mut deps: HashMap<String, (String, std::sync::mpsc::Receiver<Signature>)> =
HashMap::new();
let mut by_stem: HashMap<StemKey, Vec<StemEntry>> = HashMap::new();
let mut extends: HashMap<StemKey, Vec<StemEntry>> = HashMap::new();
for task in plan.tasks() {
if task.is_dir
|| task.link_target.is_some()
|| task.link_to.is_some()
|| task.special.is_some()
{
continue;
}
let rel = wire_rel(&task.relative_path);
let size = task.source_size;
let dest_exists = task.action == SyncAction::Update;
if determine_strategy(size, dest_exists) == TransferStrategy::Copy
&& size >= CROSS_BASIS_MIN
&& let Some((ref_rel, ref_size)) =
indexed_candidate(&by_stem, &extends, &rel, size)
{
let (tx, rx) = std::sync::mpsc::channel();
refs.entry(ref_rel.clone()).or_default().push(tx);
tracing::debug!(
"cross-file basis: {ref_rel} ({ref_size} B) -> {rel} ({size} B)"
);
deps.insert(rel.clone(), (ref_rel, rx));
}
register_basis_entry(&mut by_stem, &mut extends, &rel, size);
}
(refs, deps)
};
files_sent += self.send_make_dirs(ctrl_send, plan).await?;
for task in plan.tasks() {
if task.is_dir {
continue; }
if let Some(target) = &task.link_target {
links.push(LinkSpec {
path: wire_rel(&task.relative_path),
target: target.clone(),
kind: task.link_kind,
});
continue;
}
if let Some(target) = &task.link_to {
hardlinks.push(crate::protocol::HardlinkSpec {
path: wire_rel(&task.relative_path),
target: target.clone(),
});
continue;
}
if let Some((kind, rdev)) = task.special {
if options.archive {
specials.push(crate::protocol::SpecialSpec {
path: wire_rel(&task.relative_path),
kind,
rdev,
});
}
continue;
}
let full = task_source(source_root, task);
let dest_exists = task.action == SyncAction::Update;
let strategy = determine_strategy(task.source_size, dest_exists);
let rel_display = wire_rel(&task.relative_path);
let ref_txs = basis_senders.remove(&rel_display).unwrap_or_default();
let cross_basis = basis_receivers.remove(&rel_display);
let is_batchable = strategy == TransferStrategy::Copy
&& classify_file_size(task.source_size) == FileClass::Small
&& ref_txs.is_empty()
&& cross_basis.is_none();
if is_batchable {
if batch_reads.len() >= BATCH_READ_WINDOW {
self.drain_batch_read(
&mut batch_reads,
&mut batch,
&mut batch_bytes,
&mut skipped,
&mut batch_seq,
)
.await?;
}
batch_reads.push_back(BatchRead {
rel: rel_display,
expected_size: task.source_size,
handle: tokio::spawn(async move {
tokio::fs::read(&full).await.map_err(Error::Io)
}),
});
if batch_bytes >= BATCH_BYTES_BUDGET {
self.flush_batch(
ctrl_send,
&mut batch,
&mut batch_reads,
&mut batch_bytes,
&mut bytes_transferred,
&mut files_sent,
&mut transferred,
&mut skipped,
options,
&mut batch_seq,
files_total,
)
.await?;
}
continue;
}
let fid = file_id(&rel_display);
let outcome = if let Some((basis_rel, basis_rx)) = cross_basis {
if pending.len() >= self.compute_jobs {
self.drain_delta(
ctrl_send,
&mut pending,
&mut bytes_transferred,
&mut files_sent,
&mut transferred,
&mut skipped,
files_total,
)
.await?;
}
let display = rel_display.clone();
let progress = self.progress.clone();
let full_compute = full.clone();
let verify_hash = self.verify_hash;
if !ref_txs.is_empty() {
spawn_ref_signature_job(&full_compute, ref_txs);
}
pending.push_back(DeltaJob {
rel: rel_display,
full: full.clone(),
fid,
expected_size: task.source_size,
basis_txs: Vec::new(),
handle: tokio::task::spawn_blocking(move || {
compute_cross_delta_job(
&full_compute,
basis_rx,
basis_rel,
display,
progress.as_ref(),
verify_hash,
files_total,
)
}),
});
Ok(SendOutcome::Deferred)
} else if strategy == TransferStrategy::Delta
|| (strategy == TransferStrategy::Copy
&& classify_file_size(task.source_size) != FileClass::Large)
{
if pending.len() >= self.compute_jobs {
self.drain_delta(
ctrl_send,
&mut pending,
&mut bytes_transferred,
&mut files_sent,
&mut transferred,
&mut skipped,
files_total,
)
.await?;
}
let is_delta = strategy == TransferStrategy::Delta;
let sig = sig_map.remove(&rel_display);
let display = rel_display.clone();
let progress = self.progress.clone();
let full_job = full.clone();
let full_compute = full.clone();
let verify_hash = self.verify_hash;
let rollsum = self.rollsum;
let source_sig_rx = if rollsum {
None
} else if let Some(rx) = prefetch_map.remove(&rel_display) {
Some(rx)
} else {
let (tx, rx) = std::sync::mpsc::channel();
let sign_full = full_compute.clone();
let sign_display = display.clone();
let sign_progress = progress.clone();
tokio::task::spawn_blocking(move || {
let _ = tx.send(sign_source_task(
&sign_full,
sign_display,
sign_progress,
verify_hash,
files_total,
));
});
Some(rx)
};
let ref_txs_for_job = if is_delta {
ref_txs
} else {
if !ref_txs.is_empty() {
spawn_ref_signature_job(&full_compute, ref_txs);
}
Vec::new()
};
pending.push_back(DeltaJob {
rel: rel_display,
full: full_job,
fid,
expected_size: task.source_size,
basis_txs: ref_txs_for_job,
handle: tokio::task::spawn_blocking(move || {
if is_delta {
compute_delta_job(
&full_compute,
sig,
source_sig_rx,
display,
progress.as_ref(),
verify_hash,
rollsum,
files_total,
)
} else {
read_whole_delta(
&full_compute,
&display,
progress.as_ref(),
verify_hash,
files_total,
)
}
}),
});
Ok(SendOutcome::Deferred)
} else {
if !ref_txs.is_empty() {
spawn_ref_signature_job(&full, ref_txs);
}
self.send_chunked(ctrl_send, fid, &rel_display, &full, task.source_size, files_total)
.await
.map(SendOutcome::Sent)
};
match outcome {
Ok(SendOutcome::Sent((sent, hash))) => {
bytes_transferred += sent;
files_sent += 1;
if sent != task.source_size {
source_changed(&wire_rel(&task.relative_path), &mut skipped);
continue;
}
transferred.push((wire_rel(&task.relative_path), hash));
}
Ok(SendOutcome::Deferred) => {}
Err(Error::Io(e)) => {
skip_file(&full, &wire_rel(&task.relative_path), &e, &mut skipped);
}
Err(Error::Delta(e)) => {
skip_file(&full, &wire_rel(&task.relative_path), &e, &mut skipped);
}
Err(e) => return Err(e),
}
}
while !pending.is_empty() {
self.drain_delta(
ctrl_send,
&mut pending,
&mut bytes_transferred,
&mut files_sent,
&mut transferred,
&mut skipped,
files_total,
)
.await?;
}
self.flush_batch(
ctrl_send,
&mut batch,
&mut batch_reads,
&mut batch_bytes,
&mut bytes_transferred,
&mut files_sent,
&mut transferred,
&mut skipped,
options,
&mut batch_seq,
files_total,
)
.await?;
self.send_links(ctrl_send, links, hardlinks, specials).await?;
Ok((bytes_transferred, files_sent, transferred, skipped))
}
async fn request_signatures<W: AsyncWrite + Unpin, R: AsyncRead + Unpin>(
&self,
ctrl_send: &mut W,
ctrl_recv: &mut R,
paths: &[String],
) -> Result<HashMap<String, Arc<Signature>>> {
if paths.is_empty() {
return Ok(HashMap::new());
}
let mut out = HashMap::with_capacity(paths.len());
for group in paths.chunks(SIGNATURE_GROUP) {
stream::send_frame(
ctrl_send,
&Frame::SignatureRequest {
paths: group.to_vec(),
},
)
.await?;
let frame = from_peer(stream::receive_frame(ctrl_recv).await?)?;
match frame {
Frame::SignatureResponse { signatures } => {
out.extend(signatures.into_iter().map(|s: SignatureEntry| {
(s.file_path, Arc::new(s.signature))
}));
}
other => Err(Error::Other(format!(
"Expected SignatureResponse, got {other:?}"
)))?,
}
}
Ok(out)
}
#[expect(clippy::too_many_arguments)]
async fn flush_batch<W: AsyncWrite + Unpin>(
&self,
ctrl_send: &mut W,
batch: &mut Vec<BatchItem>,
batch_reads: &mut VecDeque<BatchRead>,
batch_bytes: &mut u64,
bytes_transferred: &mut u64,
files_sent: &mut u64,
transferred: &mut Vec<(String, [u8; 32])>,
skipped: &mut Vec<SkippedFile>,
options: &ExecutorOptions,
batch_seq: &mut u64,
files_total: u64,
) -> Result<()> {
while !batch_reads.is_empty() {
self.drain_batch_read(batch_reads, batch, batch_bytes, skipped, batch_seq)
.await?;
}
if batch.is_empty() {
return Ok(());
}
if let Some(report) = &self.progress {
for item in batch.iter() {
let size = item.data.len() as u64;
report(&item.file_path, size, size, files_total);
}
}
transferred.extend(
batch
.iter()
.map(|b| (b.file_path.clone(), b.checksum.unwrap_or([0u8; 32]))),
);
let files = batch.len() as u64;
let bytes = std::mem::take(batch_bytes);
if let Some(limiter) = &self.limiter {
limiter.acquire(bytes).await;
}
let items = std::mem::take(batch);
if options.compress {
let recipes = items
.into_iter()
.map(|b| {
let mut delta = Delta::new(b.data.len() as u64, 0);
delta.checksum = b.checksum;
delta.push_literal_owned(b.data);
BatchFile {
file_id: b.file_id,
file_path: b.file_path,
delta,
}
})
.collect();
stream::send_frame_compressed(
ctrl_send,
&Frame::Batch { recipes },
true,
64 * 1024,
)
.await?;
} else {
stream::send_batch_raw(ctrl_send, &items).await?;
}
*bytes_transferred += bytes;
*files_sent += files;
Ok(())
}
async fn send_chunked<W: AsyncWrite + Unpin>(
&self,
ctrl: &mut W,
fid: u64,
display: &str,
full: &Path,
size: u64,
files_total: u64,
) -> Result<(u64, [u8; 32])> {
stream::send_frame(
ctrl,
&Frame::FileStart {
file_id: fid,
file_path: display.to_string(),
size,
},
)
.await?;
let mut file = std::fs::File::open(full).map_err(Error::Io)?;
let mut bufs = [vec![0u8; CHUNK_SIZE], vec![0u8; CHUNK_SIZE]];
let mut sent = 0u64;
let mut wire_buf = Vec::with_capacity(CHUNK_BATCH_BYTES + CHUNK_SIZE);
let mut hasher = self.verify_hash.then(blake3::Hasher::new);
let mut len = file.read(&mut bufs[0]).map_err(Error::Io)?;
if let Some(h) = &mut hasher {
h.update(&bufs[0][..len]);
}
let mut cur = 0usize;
while len > 0 {
let next = 1 - cur;
let mut file_slot = Some(file);
let mut hasher_slot = hasher;
let mut ahead = std::mem::take(&mut bufs[next]);
let read_task = tokio::task::spawn_blocking(move || {
let mut f = file_slot.take().expect("send_chunked file");
let mut h = hasher_slot.take();
let r = f.read(&mut ahead).map_err(Error::Io);
if let (Ok(read), Some(h)) = (&r, &mut h) {
h.update(&ahead[..*read]);
}
(r, h, f, ahead)
});
if let Some(limiter) = &self.limiter {
limiter.acquire(len as u64).await;
}
stream::chunk_frame_wire(fid, &bufs[cur][..len], &mut wire_buf)?;
if wire_buf.len() >= CHUNK_BATCH_BYTES {
ctrl.write_all(&wire_buf).await?;
wire_buf.clear();
}
sent += len as u64;
if let Some(report) = &self.progress {
report(display, sent, size, files_total);
}
let (read_result, hasher_back, file_back, buf_back) = read_task
.await
.map_err(|e| Error::Other(format!("Read task panicked: {e}")))?;
file = file_back;
hasher = hasher_back;
bufs[next] = buf_back;
len = read_result?;
cur = next;
}
if !wire_buf.is_empty() {
ctrl.write_all(&wire_buf).await?;
}
stream::send_frame(ctrl, &Frame::FileEnd { file_id: fid }).await?;
let checksum = hasher.map_or([0u8; 32], |h| *h.finalize().as_bytes());
Ok((sent, checksum))
}
#[expect(clippy::too_many_arguments, reason = "every running counter folds into this one point")]
async fn drain_delta<W: AsyncWrite + Unpin>(
&self,
ctrl_send: &mut W,
pending: &mut VecDeque<DeltaJob>,
bytes_transferred: &mut u64,
files_sent: &mut u64,
transferred: &mut Vec<(String, [u8; 32])>,
skipped: &mut Vec<SkippedFile>,
files_total: u64,
) -> Result<()> {
let Some(job) = pending.pop_front() else {
return Ok(());
};
let rel = job.rel;
let sent: Result<(u64, [u8; 32], Option<Signature>)> = match job.handle.await {
Ok(Ok(PreparedDelta::Delta(delta, source_signature, basis_path))) => {
let source_size = delta.source_size;
let checksum = delta.checksum.unwrap_or([0u8; 32]);
let literal_bytes = delta.bytes_literal();
let dissimilar = basis_path.is_some()
&& delta.bytes_matched() * 2 < delta.source_size;
if literal_bytes > DELTA_LITERAL_CHUNK_LIMIT || dissimilar {
self.send_chunked(
ctrl_send,
job.fid,
&rel,
&job.full,
job.expected_size,
files_total,
)
.await
.map(|(sent, hash)| (sent, hash, None))
} else {
if let Some(limiter) = &self.limiter {
limiter.acquire(literal_bytes).await;
}
stream::send_frame(
ctrl_send,
&Frame::DeltaRecipe {
file_id: job.fid,
file_path: rel.clone(),
delta,
source_signature: source_signature.clone(),
basis_path,
},
)
.await?;
Ok((source_size, checksum, source_signature))
}
}
Ok(Ok(PreparedDelta::ChunkedFallback)) => {
let size = tokio::fs::metadata(&job.full)
.await
.map_err(Error::Io)?
.len();
self.send_chunked(ctrl_send, job.fid, &rel, &job.full, size, files_total)
.await
.map(|(sent, hash)| (sent, hash, None))
}
Ok(Err(e)) => Err(e),
Err(e) => return Err(Error::Other(format!("Delta task panicked: {e}"))),
};
match sent {
Ok((sent, hash, source_signature)) => {
*bytes_transferred += sent;
*files_sent += 1;
if sent == job.expected_size {
if let Some(sig) = source_signature {
for tx in &job.basis_txs {
let _ = tx.send(sig.clone());
}
}
transferred.push((rel, hash));
} else {
source_changed(&rel, skipped);
}
}
Err(Error::Io(e)) => skip_file(Path::new(&rel), &rel, &e, skipped),
Err(Error::Delta(e)) => skip_file(Path::new(&rel), &rel, &e, skipped),
Err(e) => return Err(e),
}
Ok(())
}
}
fn skip_file(shown: &Path, rel: &str, e: &dyn std::fmt::Display, skipped: &mut Vec<SkippedFile>) {
tracing::warn!("skipping {}: {e}", shown.display());
skipped.push(SkippedFile::new(rel.to_string(), e.to_string()));
}
fn source_changed(rel: &str, skipped: &mut Vec<SkippedFile>) {
skipped.push(SkippedFile::new(
rel.to_string(),
"source changed during transfer; not removed".to_string(),
));
}
fn recorded_deletes(file_deletes: &[String], dir_deletes: &[String]) -> Vec<ItemizeEntry> {
file_deletes
.iter()
.map(|p| ItemizeEntry::new(ItemizeAction::Delete, p.clone(), 'f'))
.chain(
dir_deletes
.iter()
.rev()
.map(|p| ItemizeEntry::new(ItemizeAction::Delete, p.clone(), 'd')),
)
.collect()
}
fn is_under_skipped(rel: &str, skipped: &std::collections::HashSet<&str>) -> bool {
let mut cur = rel;
loop {
if skipped.contains(cur) {
return true;
}
match cur.rfind('/') {
Some(i) => cur = &cur[..i],
None => return false,
}
}
}
enum SendOutcome {
Sent((u64, [u8; 32])),
Deferred,
}
struct BatchRead {
rel: String,
expected_size: u64,
handle: tokio::task::JoinHandle<Result<Vec<u8>>>,
}
struct DeltaJob {
rel: String,
full: PathBuf,
fid: u64,
expected_size: u64,
basis_txs: Vec<std::sync::mpsc::Sender<Signature>>,
handle: tokio::task::JoinHandle<Result<PreparedDelta>>,
}
enum PreparedDelta {
Delta(Delta, Option<Signature>, Option<String>),
ChunkedFallback,
}
fn read_whole_delta(
full: &Path,
display: &str,
progress: Option<&ProgressFn>,
verify_hash: bool,
files_total: u64,
) -> Result<PreparedDelta> {
let mut file = std::fs::File::open(full).map_err(Error::Io)?;
let len = file.metadata().map_err(Error::Io)?.len();
let mut delta = Delta::new(len, 0);
let mut hasher = verify_hash.then(blake3::Hasher::new);
let mut buf = vec![0u8; 256 * 1024];
let mut read = 0u64;
loop {
let n = file.read(&mut buf).map_err(Error::Io)?;
if n == 0 {
break;
}
if let Some(h) = &mut hasher {
h.update(&buf[..n]);
}
delta.push_literal(&buf[..n]);
read += n as u64;
if let Some(report) = progress {
report(display, read, len, files_total);
}
}
delta.checksum = hasher.map(|h| *h.finalize().as_bytes());
Ok(PreparedDelta::Delta(delta, None, None))
}
fn sign_source_task(
full: &Path,
display: String,
progress: Option<ProgressFn>,
verify_hash: bool,
files_total: u64,
) -> Result<(Signature, Option<[u8; 32]>)> {
let file = std::fs::File::open(full).map_err(Error::Io)?;
let len = file.metadata().map_err(Error::Io)?.len();
let mut source: Box<dyn std::io::Read> = match progress {
Some(report) => Box::new(crate::sync::executor::ProgressStream::new(
file,
display,
len,
files_total,
report,
)),
None => Box::new(file),
};
sign_source(&mut source, verify_hash).map_err(Error::from)
}
type SourceSig = (Signature, Option<[u8; 32]>);
#[expect(clippy::too_many_arguments, reason = "job context: path, basis, prefetch channel, display, progress, flags")]
fn compute_delta_job(
full: &Path,
sig: Option<Arc<Signature>>,
source_sig_rx: Option<std::sync::mpsc::Receiver<Result<SourceSig>>>,
display: String,
progress: Option<&ProgressFn>,
verify_hash: bool,
rollsum: bool,
files_total: u64,
) -> Result<PreparedDelta> {
let Some(sig) = sig else {
return Ok(PreparedDelta::ChunkedFallback);
};
if sig.file_size == 0 || sig.chunks.is_empty() {
return Ok(PreparedDelta::ChunkedFallback);
}
if rollsum {
let file = std::fs::File::open(full).map_err(Error::Io)?;
let len = file.metadata().map_err(Error::Io)?.len();
let mut source: Box<dyn std::io::Read> = match progress {
Some(report) => Box::new(crate::sync::executor::ProgressStream::new(
file,
display,
len,
files_total,
Arc::clone(report),
)),
None => Box::new(file),
};
return match compute_delta_rollsum(
&mut source,
&sig,
DELTA_LITERAL_CHUNK_LIMIT,
verify_hash,
)
.map_err(Error::from)
{
Ok(delta) => Ok(PreparedDelta::Delta(delta, None, None)),
Err(Error::Delta(DeltaError::LiteralBudgetExceeded { .. })) => {
Ok(PreparedDelta::ChunkedFallback)
}
Err(e) => Err(e),
};
}
let (source_sig, checksum) = source_sig_rx
.ok_or_else(|| Error::Other("delta job without a source prefetch".to_string()))?
.recv()
.map_err(|_| Error::Other("source signature task failed".to_string()))??;
let mut file = std::fs::File::open(full).map_err(Error::Io)?;
match compute_delta_from_signatures(
&mut file,
&sig,
&source_sig,
DELTA_LITERAL_CHUNK_LIMIT,
)
.map_err(Error::from)
{
Ok(mut delta) => {
if verify_hash {
delta.checksum = checksum;
}
let source_signature = (!source_sig.chunks.is_empty()).then_some(source_sig);
Ok(PreparedDelta::Delta(delta, source_signature, None))
}
Err(Error::Delta(DeltaError::LiteralBudgetExceeded { .. })) => {
Ok(PreparedDelta::ChunkedFallback)
}
Err(e) => Err(e),
}
}
const BIG_DELTA_PREFETCH_MIN: u64 = 64 * 1024 * 1024;
const CROSS_BASIS_MIN: u64 = 1024 * 1024;
type StemKey = (String, Option<String>, String);
struct StemEntry {
size: u64,
rel: String,
}
fn stem_key(rel: &str) -> StemKey {
let path = Path::new(rel);
(
path.parent()
.map(|p| p.to_string_lossy().into_owned())
.unwrap_or_default(),
path.extension().map(|e| e.to_string_lossy().into_owned()),
path.file_stem()
.map(|s| s.to_string_lossy().into_owned())
.unwrap_or_default(),
)
}
fn register_basis_entry(
by_stem: &mut HashMap<StemKey, Vec<StemEntry>>,
extends: &mut HashMap<StemKey, Vec<StemEntry>>,
rel: &str,
size: u64,
) {
if size < CROSS_BASIS_MIN / 2 {
return;
}
let (parent, ext, stem) = stem_key(rel);
by_stem
.entry((parent.clone(), ext.clone(), stem.clone()))
.or_default()
.push(StemEntry { size, rel: rel.to_string() });
for i in 1..stem.len() {
if !stem.is_char_boundary(i) {
continue;
}
extends
.entry((parent.clone(), ext.clone(), stem[..i].to_string()))
.or_default()
.push(StemEntry { size, rel: rel.to_string() });
}
}
fn indexed_candidate(
by_stem: &HashMap<StemKey, Vec<StemEntry>>,
extends: &HashMap<StemKey, Vec<StemEntry>>,
rel: &str,
size: u64,
) -> Option<(String, u64)> {
let key = stem_key(rel);
let mut best: Option<(u64, String, u64)> = None; let mut consider = |ref_rel: &str, ref_size: u64| {
let (lo, hi) = (size.min(ref_size), size.max(ref_size));
let diff = ref_size.abs_diff(size);
if hi <= lo.saturating_mul(2) && best.as_ref().is_none_or(|(d, ..)| diff < *d) {
best = Some((diff, ref_rel.to_string(), ref_size));
}
};
for i in 1..key.2.len() {
if !key.2.is_char_boundary(i) {
continue;
}
if let Some(entries) = by_stem.get(&(key.0.clone(), key.1.clone(), key.2[..i].to_string()))
{
for e in entries {
consider(&e.rel, e.size);
}
}
}
if let Some(entries) = extends.get(&key) {
for e in entries {
consider(&e.rel, e.size);
}
}
best.map(|(_, ref_rel, ref_size)| (ref_rel, ref_size))
}
fn spawn_ref_signature_job(full: &Path, txs: Vec<std::sync::mpsc::Sender<Signature>>) {
let full = full.to_path_buf();
tokio::task::spawn_blocking(move || {
let Ok(mut file) = std::fs::File::open(&full) else {
return;
};
let Ok(sig) = crate::delta::Signature::generate(&mut file) else {
return;
};
for tx in &txs {
let _ = tx.send(sig.clone());
}
});
}
#[expect(clippy::needless_pass_by_value)] fn compute_cross_delta_job(
full: &Path,
basis_rx: std::sync::mpsc::Receiver<Signature>,
basis_rel: String,
display_path: String,
progress: Option<&ProgressFn>,
verify_hash: bool,
files_total: u64,
) -> Result<PreparedDelta> {
let Ok(ref_sig) = basis_rx.recv() else {
tracing::warn!("cross-file basis lost for {display_path} (basis {basis_rel}); streaming the file");
return Ok(PreparedDelta::ChunkedFallback);
};
let file = std::fs::File::open(full).map_err(Error::Io)?;
let len = file.metadata().map_err(Error::Io)?.len();
let mut source: Box<dyn std::io::Read> = match progress {
Some(report) => Box::new(crate::sync::executor::ProgressStream::new(
file,
display_path,
len,
files_total,
Arc::clone(report),
)),
None => Box::new(file),
};
let mut source_sig = Vec::new();
match compute_delta_limited(
&mut source,
&ref_sig,
DELTA_LITERAL_CHUNK_LIMIT,
verify_hash,
Some(&mut source_sig),
)
.map_err(Error::from)
{
Ok(delta) => {
let source_signature = (!source_sig.is_empty()).then_some(Signature {
file_size: delta.source_size,
chunks: source_sig,
});
Ok(PreparedDelta::Delta(delta, source_signature, Some(basis_rel)))
}
Err(Error::Delta(DeltaError::LiteralBudgetExceeded { .. })) => {
Ok(PreparedDelta::ChunkedFallback)
}
Err(e) => Err(e),
}
}
fn task_source(source_root: &Path, task: &SyncTask) -> PathBuf {
file_source(source_root, task.source_path.as_deref(), &task.relative_path)
}
#[cfg(test)]
mod tests {
use super::*;
fn index(prior: &[(&str, u64)]) -> (HashMap<StemKey, Vec<StemEntry>>, HashMap<StemKey, Vec<StemEntry>>) {
let mut by_stem: HashMap<StemKey, Vec<StemEntry>> = HashMap::new();
let mut extends: HashMap<StemKey, Vec<StemEntry>> = HashMap::new();
for (rel, size) in prior {
register_basis_entry(&mut by_stem, &mut extends, rel, *size);
}
(by_stem, extends)
}
#[test]
fn cross_basis_matches_sibling_files() {
let prior = [
("a/1.iso", 1_000_000),
("a/2.bin", 1_000_000),
("b/1.iso", 1_000_000),
];
let (by_stem, extends) = index(&prior);
assert_eq!(
indexed_candidate(&by_stem, &extends, "a/1.1.iso", 1_100_000),
Some(("a/1.iso".to_string(), 1_000_000))
);
assert_eq!(indexed_candidate(&by_stem, &extends, "c/1.1.iso", 1_100_000), None);
assert_eq!(indexed_candidate(&by_stem, &extends, "a/1.1.bin", 1_100_000), None);
assert_eq!(indexed_candidate(&by_stem, &extends, "a/1.1.iso", 3_000_000), None);
assert_eq!(indexed_candidate(&by_stem, &extends, "a/1.iso", 1_000_000), None);
let prior2 = [("a/1.iso", 1_000_000), ("a/1.0.iso", 1_200_000)];
let (by_stem, extends) = index(&prior2);
assert_eq!(
indexed_candidate(&by_stem, &extends, "a/1.1.iso", 1_100_000),
Some(("a/1.iso".to_string(), 1_000_000))
);
}
#[test]
fn cross_basis_inverted_dotted_stem() {
let (by_stem, extends) = index(&[("a/1.1.iso", 1_200_000)]);
assert_eq!(
indexed_candidate(&by_stem, &extends, "a/1.iso", 1_000_000),
Some(("a/1.1.iso".to_string(), 1_200_000))
);
let (by_stem, extends) = index(&[("a/2.bin", 1_200_000)]);
assert_eq!(indexed_candidate(&by_stem, &extends, "a/1.iso", 1_000_000), None);
}
#[test]
fn basis_entries_below_half_min_are_not_registered() {
let mut by_stem: HashMap<StemKey, Vec<StemEntry>> = HashMap::new();
let mut extends: HashMap<StemKey, Vec<StemEntry>> = HashMap::new();
register_basis_entry(&mut by_stem, &mut extends, "a/x.bin", CROSS_BASIS_MIN / 2 - 1);
assert!(by_stem.is_empty() && extends.is_empty());
register_basis_entry(&mut by_stem, &mut extends, "a/x.bin", CROSS_BASIS_MIN / 2);
assert_eq!(by_stem.len(), 1);
}
#[test]
fn delete_protection_covers_skipped_subtrees() {
let skipped: std::collections::HashSet<&str> =
["extdir", "a/b", "x/y/z"].into_iter().collect();
assert!(is_under_skipped("extdir", &skipped));
assert!(is_under_skipped("extdir/f", &skipped));
assert!(is_under_skipped("a/b", &skipped));
assert!(is_under_skipped("a/b/c/d", &skipped));
assert!(!is_under_skipped("extdir2", &skipped));
assert!(!is_under_skipped("a/bc", &skipped));
assert!(!is_under_skipped("x/y", &skipped));
assert!(!is_under_skipped("unrelated", &skipped));
assert!(!is_under_skipped("", &skipped));
}
}