fn fetch_with_retries()

in tough/src/http.rs [248:299]

• 44 lines of code
• 3 McCabe index (conditional complexity)

fn fetch_with_retries(
    r: &mut RetryState,
    cs: &HttpTransportBuilder,
    url: &Url,
) -> Result<RetryRead, HttpError> {
    trace!("beginning fetch for '{}'", url);
    // create a reqwest client
    let client = ClientBuilder::new()
        .timeout(cs.timeout)
        .connect_timeout(cs.connect_timeout)
        .build()
        .context(HttpClientSnafu)?;

    // retry loop
    loop {
        // build the request
        let request = build_request(&client, r.next_byte, url)?;

        // send the GET request, then categories the outcome by converting to an HttpResult.
        let http_result: HttpResult = client.execute(request).into();

        match http_result {
            HttpResult::Ok(response) => {
                trace!("{:?} - returning from successful fetch", r);
                return Ok(RetryRead {
                    retry_state: *r,
                    settings: *cs,
                    response,
                    url: url.clone(),
                });
            }
            HttpResult::Fatal(err) => {
                trace!("{:?} - returning fatal error from fetch: {}", r, err);
                return Err(err).context(FetchFatalSnafu);
            }
            HttpResult::FileNotFound(err) => {
                trace!("{:?} - returning file not found from fetch: {}", r, err);
                return Err(err).context(FetchFileNotFoundSnafu);
            }
            HttpResult::Retryable(err) => {
                trace!("{:?} - retryable error: {}", r, err);
                if r.current_try >= cs.tries - 1 {
                    debug!("{:?} - returning failure, no more retries: {}", r, err);
                    return Err(err).context(FetchNoMoreRetriesSnafu { tries: cs.tries });
                }
            }
        }

        r.increment(cs);
        std::thread::sleep(r.wait);
    }
}