tonhowtf/omniget · error · anyhow::Error

Failed to replace file after 3 attempts

Error message

Failed to replace file after 3 attempts: {}

What it means

embed_metadata() renames the temp output over the original file, retrying up to 3 times with backoff. If a rename attempt fails with a hard error (not a transient sharing violation that the retry loop tolerates), the temp file is deleted and this error returns the underlying io::Error.

Solutions

  1. Close any program using the output file (media player, editor) and retry the embedding.
  2. Check the destination directory is writable by the app's user.
  3. Add the wrapped io::Error detail to logs to see if it's PermissionDenied vs cross-device.
  4. As a workaround, write the embedded-metadata file next to the original under a new name instead of replacing it.

Example fix

// before
Err(e) => {
    let _ = std::fs::remove_file(&temp_output);
    return Err(anyhow!("Failed to replace file after 3 attempts: {}", e));
}
// after
Err(e) => {
    let _ = std::fs::remove_file(&temp_output);
    return Err(anyhow!(
        "Failed to replace file after 3 attempts: {} (is another program using the output file?)",
        e
    ));
}
Defensive patterns

Strategy: retry

Validate before calling

// detect an open handle on Windows-style platforms before embedding
let can_write = std::fs::OpenOptions::new()
    .append(true)
    .open(file)
    .is_ok();
if !can_write {
    return Err("output file is locked by another process; close it and retry".into());
}

Try / catch

match embed_metadata(/* ... */).await {
    Err(e) if e.to_string().contains("Failed to replace file after 3 attempts") => {
        ui::notify_file_locked(file); // prompt user to close players/sync apps
        // optionally schedule a retry after a delay
    }
    other => other?,
}

Prevention

When it happens

Trigger: Calling embed_metadata when the destination file is locked by another process with incompatible sharing semantics, or the destination directory lacks write permission and the retry loop's Err branch is hit (as opposed to the Ok-but-failed path).

Common situations: Another app (player, antivirus, cloud sync) holding the output file open on Windows; read-only target directory; the temp file living on a different filesystem than the destination in exotic setups.

Understand the failure class

Background: "failed to write file", "Could not save figure", "Error saving remote file" — file write failed: causes and fixes across languages and libraries — this error's family across 38 libraries.

Related errors

AI-assisted analysis of tonhowtf/omniget@8600b91f42 (2026-09-12). Data as JSON: /api/errors/02d63b8ee386b89e. Report an issue: GitHub.

Appendix: source

Thrown at src-tauri/omniget-core/src/core/ffmpeg.rs:558

    let mut rename_ok = false;
    for attempt in 0..3 {
        match std::fs::rename(&temp_output, file) {
            Ok(()) => {
                rename_ok = true;
                break;
            }
            Err(e) if attempt < 2 => {
                tracing::warn!(
                    "Failed to replace file (attempt {}): {}, retrying...",
                    attempt + 1,
                    e
                );
                tokio::time::sleep(std::time::Duration::from_millis(500 * (attempt as u64 + 1)))
                    .await;
            }
            Err(e) => {
                let _ = std::fs::remove_file(&temp_output);
                return Err(anyhow!("Failed to replace file after 3 attempts: {}", e));
            }
        }
    }
    if !rename_ok {
        let _ = std::fs::remove_file(&temp_output);
        return Err(anyhow!("Failed to replace file"));
    }

    Ok(())
}

async fn download_thumbnail(
    client: &reqwest::Client,
    url: &str,
    dest_dir: &Path,
) -> anyhow::Result<std::path::PathBuf> {
    let response = client
        .get(url)

View on GitHub (pinned to 8600b91f42)