Struct WriteHandle 

pub struct WriteHandle { /* private fields */ }

One destination file, open for concurrent positional writes.

Implementations

impl WriteHandle

pub fn open_cloned( final_path: &Path, size: u64, preallocate: bool, ) -> Result<Self>

Open the partial file, seeding it from an existing copy where the filesystem can do that for free.

Delta sync reuses most blocks of an unchanged file, and the receiver would otherwise copy every one of them out of the old file and into the new one — gigabytes of local I/O to reproduce bytes that are already on the disk. A copy-on-write clone shares the extents instead, so the seeding is O(1) and only the chunks that genuinely differ are written. Where the filesystem cannot clone, this falls back to the ordinary path and the per-chunk copies happen as before.

pub fn open(final_path: &Path, size: u64, preallocate: bool) -> Result<Self>

Open (or reopen) the partial file for final_path, sized to size.

pub fn size(&self) -> u64

pub fn part_path(&self) -> &Path

pub fn created_new(&self) -> bool

Whether this session created the partial file, and can therefore assume unwritten regions read as zeros.

pub fn write_zeros_at(&self, offset: u64, len: usize) -> Result<()>

Write len zero bytes at offset without allocating a buffer that big.

pub fn write_at(&self, offset: u64, buf: &[u8]) -> Result<()>

Write buf at offset. Safe to call concurrently from many threads.

pub fn read_at(&self, offset: u64, buf: &mut [u8]) -> Result<usize>

pub fn matches_at(&self, offset: u64, want: &[u8]) -> Result<bool>

Is want already what the file holds at offset?

Used to avoid rewriting bytes a copy-on-write clone already shares: writing them would break the sharing and cost the very I/O the clone was there to avoid.

pub fn sync(&self) -> Result<()>

Flush to stable storage. Called once per file, not per chunk — an fsync per chunk would dominate the cost of the transfer.

pub fn commit( &self, mode: u32, mtime: i64, preserve_metadata: bool, ) -> Result<()>

Rename the partial file into place and apply metadata.

Takes &self rather than self because several workers may still hold a clone of the Arc around this handle when the last chunk lands. Renaming a file that is still open is safe on unix, and on Windows too: Rust’s OpenOptions opens with FILE_SHARE_DELETE. Callers guarantee this runs once per file.

pub fn discard(&self)

Delete the partial file. Used when a transfer aborts unrecoverably.