Smart Resume for File Transfers in Rust — Never Start Over

CREATE TABLE transfer_state (
    id INTEGER PRIMARY KEY,
    file_path TEXT NOT NULL,
    total_bytes INTEGER NOT NULL,
    transferred_bytes INTEGER DEFAULT 0,
    file_hash TEXT,
    status TEXT DEFAULT 'in_progress',
    started_at INTEGER,
    updated_at INTEGER
);

pub async fn transfer_with_resume(
    source: &Path,
    dest: &Path,
    db: &Connection,
) -> Result<(), AppError> {
    let file_hash = compute_hash(source)?;

    // Check for existing partial transfer
    let existing = db.query_row(
        "SELECT transferred_bytes FROM transfer_state
         WHERE file_path = ? AND file_hash = ? AND status = 'in_progress'",
        params![source.to_str().unwrap(), &file_hash],
        |r| r.get::<_, i64>(0),
    ).ok();

    let start_offset = existing.unwrap_or(0) as u64;

    // Open source file, seek to offset
    let mut reader = File::open(source)?;
    reader.seek(SeekFrom::Start(start_offset))?;

    // Open dest file for append if resuming
    let mut writer = if start_offset > 0 {
        OpenOptions::new().append(true).open(dest)?
    } else {
        File::create(dest)?
    };

    // Transfer in chunks, updating DB periodically
    let mut transferred = start_offset;
    let mut buf = vec![0u8; 65536];

    loop {
        let n = reader.read(&mut buf)?;
        if n == 0 { break; }

        writer.write_all(&buf[..n])?;
        transferred += n as u64;

        // Update progress every 1MB
        if transferred % (1024 * 1024) == 0 {
            db.execute(
                "UPDATE transfer_state SET transferred_bytes = ?, updated_at = ? WHERE file_path = ?",
                params![transferred as i64, unix_now(), source.to_str().unwrap()],
            )?;
        }
    }

    // Mark complete
    db.execute(
        "UPDATE transfer_state SET status = 'complete' WHERE file_path = ?",
        params![source.to_str().unwrap()],
    )?;

    Ok(())
}

if compute_hash(dest)? != expected_hash {
    // Hash mismatch — delete and retry from scratch
    std::fs::remove_file(dest)?;
    return Err(AppError::Transfer("Hash mismatch after resume".into()));
}