Enable Endpoints 2.0 (#2074)

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

# author = "rcoh"

[[aws-sdk-rust]]

message = """Integrate Endpoints 2.0 into the Rust SDK. Endpoints 2.0 enables features like S3 virtual addressing & S3

object lambda. As part of this change, there are several breaking changes although efforts have been made to deprecate

where possible to smooth the upgrade path.

1. `aws_smithy_http::endpoint::Endpoint` and the `endpoint_resolver` methods have been deprecated. In general, these usages

   should be replaced with usages of `endpoint_url` instead. `endpoint_url` accepts a string so an `aws_smithy_http::Endpoint`

   does not need to be constructed. This structure and methods will be removed in a future release.

2. The `endpoint_resolver` method on `<service>::config::Builder` now accepts a service specific endpoint resolver instead

   of an implementation of `ResolveAwsEndpoint`. Most users will be able to replace these usages with a usage of `endpoint_url`.

3. `ResolveAwsEndpoint` has been deprecated and will be removed in a future version of the SDK.

4. The SDK does not support "pseudo regions" anymore. Specifically, regions like `iam-fips` will no longer resolve to a FIPS endpoint.

"""

references = ["smithy-rs#1784", "smithy-rs#2074"]

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

author = "rcoh"

[[aws-sdk-rust]]

message = """Add additional configuration parameters to `aws_sdk_s3::Config`.

The launch of endpoints 2.0 includes more configuration options for S3. The default behavior for endpoint resolution has

been changed. Before, all requests hit the path-style endpoint. Going forward, all requests that can be routed to the

virtually hosted bucket will be routed there automatically.

- `force_path_style`: Requests will now default to the virtually-hosted endpoint `<bucketname>.s3.<region>.amazonaws.com`

- `use_arn_region`: Enables this client to use an ARN’s region when constructing an endpoint instead of the client’s configured region.

- `accelerate`: Enables this client to use S3 Transfer Acceleration endpoints.

Note: the AWS SDK for Rust does not currently support Multi Region Access Points (MRAP).

"""

references = ["smithy-rs#1784", "smithy-rs#2074"]

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

author = "rcoh"

[[smithy-rs]]

message = "In 0.52, `@length`-constrained collection shapes whose members are not constrained made the server code generator crash. This has been fixed."

references = ["smithy-rs#2103"]

use std::net::IpAddr;

use aws_smithy_client::erase::boxclone::BoxCloneService;

use aws_smithy_http::endpoint::Endpoint;

use aws_smithy_http::endpoint::apply_endpoint;

use aws_smithy_types::error::display::DisplayErrorContext;

use aws_types::credentials;

use aws_types::credentials::{future, CredentialsError, ProvideCredentials};

                });

            }

        };

        let endpoint =

            Endpoint::immutable_uri(Uri::from_static(BASE_HOST)).expect("BASE_HOST is valid");

        endpoint

            .set_endpoint(&mut relative_uri, None)

        let endpoint = Uri::from_static(BASE_HOST);

        apply_endpoint(&mut relative_uri, &endpoint, None)

            .expect("appending relative URLs to the ECS endpoint should always succeed");

        Ok(relative_uri)

    }

use aws_smithy_client::{erase::DynConnector, SdkSuccess};

use aws_smithy_client::{retry, SdkError};

use aws_smithy_http::body::SdkBody;

use aws_smithy_http::endpoint::Endpoint;

use aws_smithy_http::endpoint::apply_endpoint;

use aws_smithy_http::operation;

use aws_smithy_http::operation::{Metadata, Operation};

use aws_smithy_http::response::ParseStrictResponse;

#[derive(Debug)]

struct ClientInner {

    endpoint: Endpoint,

    endpoint: Uri,

    smithy_client: aws_smithy_client::Client<DynConnector, ImdsMiddleware>,

}

        let mut base_uri: Uri = path.parse().map_err(|_| {

            ImdsError::unexpected("IMDS path was not a valid URI. Hint: does it begin with `/`?")

        })?;

        self.inner

            .endpoint

            .set_endpoint(&mut base_uri, None)

            .map_err(ImdsError::unexpected)?;

        apply_endpoint(&mut base_uri, &self.inner.endpoint, None).map_err(ImdsError::unexpected)?;

        let request = http::Request::builder()

            .uri(base_uri)

            .body(SdkBody::empty())

            .endpoint

            .unwrap_or_else(|| EndpointSource::Env(config.env(), config.fs()));

        let endpoint = endpoint_source.endpoint(self.mode_override).await?;

        let endpoint = Endpoint::immutable_uri(endpoint)?;

        let retry_config = retry::Config::default()

            .with_max_attempts(self.max_attempts.unwrap_or(DEFAULT_ATTEMPTS));

        let token_loader = token::TokenMiddleware::new(

use aws_smithy_client::erase::DynConnector;

use aws_smithy_client::retry;

use aws_smithy_http::body::SdkBody;

use aws_smithy_http::endpoint::Endpoint;

use aws_smithy_http::endpoint::apply_endpoint;

use aws_smithy_http::middleware::AsyncMapRequest;

use aws_smithy_http::operation;

use aws_smithy_http::operation::Operation;

    token_parser: GetTokenResponseHandler,

    token: ExpiringCache<Token, ImdsError>,

    time_source: TimeSource,

    endpoint: Endpoint,

    endpoint: Uri,

    token_ttl: Duration,

}

    pub(super) fn new(

        connector: DynConnector,

        time_source: TimeSource,

        endpoint: Endpoint,

        endpoint: Uri,

        token_ttl: Duration,

        retry_config: retry::Config,

        timeout_config: TimeoutConfig,

    async fn get_token(&self) -> Result<(Token, SystemTime), ImdsError> {

        let mut uri = Uri::from_static("/latest/api/token");

        self.endpoint

            .set_endpoint(&mut uri, None)

            .map_err(ImdsError::unexpected)?;

        apply_endpoint(&mut uri, &self.endpoint, None).map_err(ImdsError::unexpected)?;

        let request = http::Request::builder()

            .header(

                X_AWS_EC2_METADATA_TOKEN_TTL_SECONDS,

        app_name: Option<AppName>,

        credentials_provider: Option<SharedCredentialsProvider>,

        endpoint_resolver: Option<Arc<dyn ResolveAwsEndpoint>>,

        endpoint_url: Option<String>,

        region: Option<Box<dyn ProvideRegion>>,

        retry_config: Option<RetryConfig>,

        sleep: Option<Arc<dyn AsyncSleep>>,

        /// Override the endpoint resolver used for **all** AWS Services

        ///

        /// This method is deprecated. Use [`Self::endpoint_url`] instead.

        ///

        /// This method will override the endpoint resolver used for **all** AWS services. This mainly

        /// exists to set a static endpoint for tools like `LocalStack`. For live traffic, AWS services

        /// require the service-specific endpoint resolver they load by default.

        ///     .await;

        /// # Ok(())

        /// # }

        #[deprecated(note = "use `.endpoint_url(...)` instead")]

        pub fn endpoint_resolver(

            mut self,

            endpoint_resolver: impl ResolveAwsEndpoint + 'static,

            self

        }

        /// Override the endpoint URL used for **all** AWS services.

        ///

        /// This method will override the endpoint URL used for **all** AWS services. This primarily

        /// exists to set a static endpoint for tools like `LocalStack`. When sending requests to

        /// production AWS services, this method should only be used for service-specific behavior.

        ///

        /// When this method is used, the [`Region`](aws_types::region::Region) is only used for

        /// signing; it is not used to route the request.

        ///

        /// # Examples

        ///

        /// Use a static endpoint for all services

        /// ```no_run

        /// # async fn create_config() {

        /// let sdk_config = aws_config::from_env()

        ///     .endpoint_url("http://localhost:1234")

        ///     .load()

        ///     .await;

        /// # }

        pub fn endpoint_url(mut self, endpoint_url: impl Into<String>) -> Self {

            self.endpoint_url = Some(endpoint_url.into());

            self

        }

        /// Set configuration for all sub-loaders (credentials, region etc.)

        ///

        /// Update the `ProviderConfig` used for all nested loaders. This can be used to override

            builder.set_endpoint_resolver(endpoint_resolver);

            builder.set_app_name(app_name);

            builder.set_sleep_impl(sleep_impl);

            builder.set_endpoint_url(self.endpoint_url);

            builder.build()

        }

    }