Struct RetryConfig 

pub struct RetryConfig { /* private fields */ }

Retry policy for failed drive reads.

Track and sector-range reads are split into chunks, and this policy is applied independently to each chunk. If a chunk read fails, the next attempt starts at the same LBA. Retry delays use capped exponential backoff. When adaptive chunk reduction is enabled, retries request fewer sectors from that LBA, down to the configured minimum. Chunks that were already read successfully are not repeated.

The default values are suitable for most drives. Unless you have specific requirements, using RetryConfig::default is recommended.

The default policy uses:

• 4 attempts, including the initial read;
• a 20 ms initial backoff;
• a 300 ms maximum backoff;
• adaptive chunk reduction;
• a minimum chunk size of 1 sector.

Implementations

impl RetryConfig

pub fn with_max_attempts(self, attempts: u8) -> Self

Set the maximum attempts per chunk, including the initial read.

A value of zero is normalized to one attempt.

Examples found in repository

examples/custom_retry.rs (line 26)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let output_dir = common::fresh_output_dir("custom_retry")?;
    let reader = CdReader::open_default()?;
    let toc = reader.read_toc()?;

    let first_audio = toc
        .tracks
        .iter()
        .find(|t| t.is_audio)
        .ok_or("no audio tracks found")?;

    // More attempts, longer backoff, and sector reduction down to 1
    // for maximum resilience on scratched media.
    let retry = RetryConfig::default()
        .with_max_attempts(8)
        .with_initial_backoff(Duration::from_millis(50))
        .with_max_backoff(Duration::from_secs(1))
        .with_chunk_reduction(true)
        .with_min_sectors_per_read(1);
    let options = ReadOptions::default().with_retry(retry);

    println!(
        "Reading track {} with aggressive retry...",
        first_audio.number
    );
    let data = reader.read_track_with_options(&toc, first_audio.number, &options)?;

    let wav = create_wav(data);
    let output_path = output_dir.join(format!("track{:02}.wav", first_audio.number));
    std::fs::write(&output_path, wav)?;
    println!("Saved {}", output_path.display());

    Ok(())
}

pub fn with_initial_backoff(self, backoff: Duration) -> Self

Set the delay before the second attempt.

The first attempt is always immediate.

Examples found in repository

examples/custom_retry.rs (line 27)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let output_dir = common::fresh_output_dir("custom_retry")?;
    let reader = CdReader::open_default()?;
    let toc = reader.read_toc()?;

    let first_audio = toc
        .tracks
        .iter()
        .find(|t| t.is_audio)
        .ok_or("no audio tracks found")?;

    // More attempts, longer backoff, and sector reduction down to 1
    // for maximum resilience on scratched media.
    let retry = RetryConfig::default()
        .with_max_attempts(8)
        .with_initial_backoff(Duration::from_millis(50))
        .with_max_backoff(Duration::from_secs(1))
        .with_chunk_reduction(true)
        .with_min_sectors_per_read(1);
    let options = ReadOptions::default().with_retry(retry);

    println!(
        "Reading track {} with aggressive retry...",
        first_audio.number
    );
    let data = reader.read_track_with_options(&toc, first_audio.number, &options)?;

    let wav = create_wav(data);
    let output_path = output_dir.join(format!("track{:02}.wav", first_audio.number));
    std::fs::write(&output_path, wav)?;
    println!("Saved {}", output_path.display());

    Ok(())
}

pub fn with_max_backoff(self, backoff: Duration) -> Self

Set the upper bound for exponential backoff delays.

A duration of zero disables retry delays.

Examples found in repository

examples/custom_retry.rs (line 28)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let output_dir = common::fresh_output_dir("custom_retry")?;
    let reader = CdReader::open_default()?;
    let toc = reader.read_toc()?;

    let first_audio = toc
        .tracks
        .iter()
        .find(|t| t.is_audio)
        .ok_or("no audio tracks found")?;

    // More attempts, longer backoff, and sector reduction down to 1
    // for maximum resilience on scratched media.
    let retry = RetryConfig::default()
        .with_max_attempts(8)
        .with_initial_backoff(Duration::from_millis(50))
        .with_max_backoff(Duration::from_secs(1))
        .with_chunk_reduction(true)
        .with_min_sectors_per_read(1);
    let options = ReadOptions::default().with_retry(retry);

    println!(
        "Reading track {} with aggressive retry...",
        first_audio.number
    );
    let data = reader.read_track_with_options(&toc, first_audio.number, &options)?;

    let wav = create_wav(data);
    let output_path = output_dir.join(format!("track{:02}.wav", first_audio.number));
    std::fs::write(&output_path, wav)?;
    println!("Saved {}", output_path.display());

    Ok(())
}

pub fn with_chunk_reduction(self, enabled: bool) -> Self

Enable or disable requesting fewer sectors after a failed chunk read.

Examples found in repository

examples/custom_retry.rs (line 29)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let output_dir = common::fresh_output_dir("custom_retry")?;
    let reader = CdReader::open_default()?;
    let toc = reader.read_toc()?;

    let first_audio = toc
        .tracks
        .iter()
        .find(|t| t.is_audio)
        .ok_or("no audio tracks found")?;

    // More attempts, longer backoff, and sector reduction down to 1
    // for maximum resilience on scratched media.
    let retry = RetryConfig::default()
        .with_max_attempts(8)
        .with_initial_backoff(Duration::from_millis(50))
        .with_max_backoff(Duration::from_secs(1))
        .with_chunk_reduction(true)
        .with_min_sectors_per_read(1);
    let options = ReadOptions::default().with_retry(retry);

    println!(
        "Reading track {} with aggressive retry...",
        first_audio.number
    );
    let data = reader.read_track_with_options(&toc, first_audio.number, &options)?;

    let wav = create_wav(data);
    let output_path = output_dir.join(format!("track{:02}.wav", first_audio.number));
    std::fs::write(&output_path, wav)?;
    println!("Saved {}", output_path.display());

    Ok(())
}

pub fn with_min_sectors_per_read(self, sectors: u32) -> Self

Set the minimum sectors per command when adaptive reduction is enabled.

A value of zero is normalized to one sector.

Examples found in repository

examples/custom_retry.rs (line 30)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let output_dir = common::fresh_output_dir("custom_retry")?;
    let reader = CdReader::open_default()?;
    let toc = reader.read_toc()?;

    let first_audio = toc
        .tracks
        .iter()
        .find(|t| t.is_audio)
        .ok_or("no audio tracks found")?;

    // More attempts, longer backoff, and sector reduction down to 1
    // for maximum resilience on scratched media.
    let retry = RetryConfig::default()
        .with_max_attempts(8)
        .with_initial_backoff(Duration::from_millis(50))
        .with_max_backoff(Duration::from_secs(1))
        .with_chunk_reduction(true)
        .with_min_sectors_per_read(1);
    let options = ReadOptions::default().with_retry(retry);

    println!(
        "Reading track {} with aggressive retry...",
        first_audio.number
    );
    let data = reader.read_track_with_options(&toc, first_audio.number, &options)?;

    let wav = create_wav(data);
    let output_path = output_dir.join(format!("track{:02}.wav", first_audio.number));
    std::fs::write(&output_path, wav)?;
    println!("Saved {}", output_path.display());

    Ok(())
}

Trait Implementations

impl Clone for RetryConfig

fn clone(&self) -> RetryConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RetryConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RetryConfig

fn default() -> Self

Returns the “default value” for a type.