Fix panic when failing to create `Duration` for exponential backoff from a large float (#3621)

# references = ["smithy-rs#920"]

# references = ["smithy-rs#920"]

# meta = { "breaking" = false, "tada" = false, "bug" = false, "target" = "client | server | all"}

# meta = { "breaking" = false, "tada" = false, "bug" = false, "target" = "client | server | all"}

# author = "rcoh"

# author = "rcoh"

[[aws-sdk-rust]]

message = "Fix panics that occurred when `Duration` for exponential backoff could not be created from too big a float."

references = ["aws-sdk-rust#1133"]

meta = { "breaking" = false, "tada" = false, "bug" = true }

author = "ysaito1001"

[[smithy-rs]]

message = "Fix panics that occurred when `Duration` for exponential backoff could not be created from too big a float."

references = ["aws-sdk-rust#1133"]

meta = { "breaking" = false, "tada" = false, "bug" = true, "target" = "client" }

author = "ysaito1001"

[package]

[package]

name = "aws-smithy-runtime"

name = "aws-smithy-runtime"

version = "1.5.0"

version = "1.5.1"

authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>", "Zelda Hessler <zhessler@amazon.com>"]

authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>", "Zelda Hessler <zhessler@amazon.com>"]

description = "The new smithy runtime crate"

description = "The new smithy runtime crate"

edition = "2021"

edition = "2021"

                    } else {

                    } else {

                        fastrand::f64()

                        fastrand::f64()

                    };

                    };

                    let backoff = calculate_exponential_backoff(

                    Ok(calculate_exponential_backoff(

                        // Generate a random base multiplier to create jitter

                        // Generate a random base multiplier to create jitter

                        base,

                        base,

                        // Get the backoff time multiplier in seconds (with fractional seconds)

                        // Get the backoff time multiplier in seconds (with fractional seconds)

                        // `self.local.attempts` tracks number of requests made including the initial request

                        // `self.local.attempts` tracks number of requests made including the initial request

                        // The initial attempt shouldn't count towards backoff calculations, so we subtract it

                        // The initial attempt shouldn't count towards backoff calculations, so we subtract it

                        request_attempts - 1,

                        request_attempts - 1,

                    );

                        // Maximum backoff duration as a fallback to prevent overflow when calculating a power

                    Ok(Duration::from_secs_f64(backoff).min(retry_cfg.max_backoff()))

                        retry_cfg.max_backoff(),

                    ))

                }

                }

            }

            }

            RetryAction::RetryForbidden | RetryAction::NoActionIndicated => {

            RetryAction::RetryForbidden | RetryAction::NoActionIndicated => {

    None

    None

}

}

fn calculate_exponential_backoff(base: f64, initial_backoff: f64, retry_attempts: u32) -> f64 {

fn calculate_exponential_backoff(

    2_u32

    base: f64,

    initial_backoff: f64,

    retry_attempts: u32,

    max_backoff: Duration,

) -> Duration {

    let result = match 2_u32

        .checked_pow(retry_attempts)

        .checked_pow(retry_attempts)

        .map(|backoff| (backoff as f64) * base * initial_backoff)

        .map(|power| (power as f64) * initial_backoff)

        .unwrap_or(f64::MAX)

    {

        Some(backoff) => match Duration::try_from_secs_f64(backoff) {

            Ok(result) => result.min(max_backoff),

            Err(e) => {

                tracing::warn!("falling back to {max_backoff:?} as `Duration` could not be created for exponential backoff: {e}");

                max_backoff

            }

        },

        None => max_backoff,

    };

    // Apply jitter to `result`, and note that it can be applied to `max_backoff`.

    // Won't panic because `base` is either in range 0..1 or a constant 1 in testing (if configured).

    result.mul_f64(base)

}

}

fn get_seconds_since_unix_epoch(runtime_components: &RuntimeComponents) -> f64 {

fn get_seconds_since_unix_epoch(runtime_components: &RuntimeComponents) -> f64 {

        assert_eq!(ShouldAttempt::No, actual);

        assert_eq!(ShouldAttempt::No, actual);

    }

    }

    #[test]

    fn should_not_panic_when_exponential_backoff_duration_could_not_be_created() {

        let (ctx, rc, cfg) = set_up_cfg_and_context(

            ErrorKind::TransientError,

            // Greater than 32 when subtracted by 1 in `calculate_backoff`, causing overflow in `calculate_exponential_backoff`

            33,

            RetryConfig::standard()

                .with_use_static_exponential_base(true)

                .with_max_attempts(100), // Any value greater than 33 will do

        );

        let strategy = StandardRetryStrategy::new();

        let actual = strategy

            .should_attempt_retry(&ctx, &rc, &cfg)

            .expect("method is infallible for this use");

        assert_eq!(ShouldAttempt::YesAfterDelay(MAX_BACKOFF), actual);

    }

    #[derive(Debug)]

    #[derive(Debug)]

    struct ServerError;

    struct ServerError;

    impl fmt::Display for ServerError {

    impl fmt::Display for ServerError {

        assert_eq!(token_bucket.available_permits(), 480);

        assert_eq!(token_bucket.available_permits(), 480);

    }

    }

    const MAX_BACKOFF: Duration = Duration::from_secs(20);

    #[test]

    #[test]

    fn calculate_exponential_backoff_where_initial_backoff_is_one() {

    fn calculate_exponential_backoff_where_initial_backoff_is_one() {

        let initial_backoff = 1.0;

        let initial_backoff = 1.0;

        for (attempt, expected_backoff) in [initial_backoff, 2.0, 4.0].into_iter().enumerate() {

        for (attempt, expected_backoff) in [initial_backoff, 2.0, 4.0].into_iter().enumerate() {

            let actual_backoff =

            let actual_backoff =

                calculate_exponential_backoff(1.0, initial_backoff, attempt as u32);

                calculate_exponential_backoff(1.0, initial_backoff, attempt as u32, MAX_BACKOFF);

            assert_eq!(expected_backoff, actual_backoff);

            assert_eq!(Duration::from_secs_f64(expected_backoff), actual_backoff);

        }

        }

    }

    }

        for (attempt, expected_backoff) in [initial_backoff, 6.0, 12.0].into_iter().enumerate() {

        for (attempt, expected_backoff) in [initial_backoff, 6.0, 12.0].into_iter().enumerate() {

            let actual_backoff =

            let actual_backoff =

                calculate_exponential_backoff(1.0, initial_backoff, attempt as u32);

                calculate_exponential_backoff(1.0, initial_backoff, attempt as u32, MAX_BACKOFF);

            assert_eq!(expected_backoff, actual_backoff);

            assert_eq!(Duration::from_secs_f64(expected_backoff), actual_backoff);

        }

        }

    }

    }

        for (attempt, expected_backoff) in [initial_backoff, 0.06, 0.12].into_iter().enumerate() {

        for (attempt, expected_backoff) in [initial_backoff, 0.06, 0.12].into_iter().enumerate() {

            let actual_backoff =

            let actual_backoff =

                calculate_exponential_backoff(1.0, initial_backoff, attempt as u32);

                calculate_exponential_backoff(1.0, initial_backoff, attempt as u32, MAX_BACKOFF);

            assert_eq!(expected_backoff, actual_backoff);

            assert_eq!(Duration::from_secs_f64(expected_backoff), actual_backoff);

        }

        }

    }

    }

    #[test]

    #[test]

    fn calculate_backoff_overflow() {

    fn calculate_backoff_overflow_should_gracefully_fallback_to_max_backoff() {

        // avoid overflow for a silly large amount of retry attempts

        // avoid overflow for a silly large amount of retry attempts

        assert_eq!(

        assert_eq!(

            calculate_exponential_backoff(1_f64, 10_f64, 100000),

            MAX_BACKOFF,

            f64::MAX

            calculate_exponential_backoff(1_f64, 10_f64, 100000, MAX_BACKOFF),

        );

        );

    }

    }

}

}

[dependencies]

[dependencies]

anyhow = "1.0.75"

anyhow = "1.0.75"

camino = "1.1.6"

camino = "1.1.6"

clap = { version = "4.4.11", features = ["derive"] }

clap = { version = "4.4.11", features = ["derive", "env"] }

crates-index = "2.3.0"

crates-index = "2.3.0"

indicatif = "0.17.7"

indicatif = "0.17.7"

reqwest = { version = "0.11.22", features = ["blocking"] }

reqwest = { version = "0.11.22", features = ["blocking"] }

    let previous_release_tag =

    let previous_release_tag =

        previous_release_tag(&repo, &release_tags, args.previous_release_tag.as_deref())?;

        previous_release_tag(&repo, &release_tags, args.previous_release_tag.as_deref())?;

    if release_tags.first() != Some(&previous_release_tag) {

    if release_tags.first() != Some(&previous_release_tag) {

        tracing::warn!("there are newer releases since '{previous_release_tag}'");

        tracing::warn!("there are newer releases since '{previous_release_tag}'. \

            Consider specifying a more recent release tag using the `--previous-release-tag` command-line argument or \

            the `SMITHY_RS_RUNTIME_VERSIONER_AUDIT_PREVIOUS_RELEASE_TAG` environment variable if audit fails.");

    }

    }

    let next_crates = discover_runtime_crates(&repo.root).context("next")?;

    let next_crates = discover_runtime_crates(&repo.root).context("next")?;