Struct aws_sdk_databrew::middleware::DefaultMiddleware

#[non_exhaustive]
pub struct DefaultMiddleware;

AWS Middleware Stack

This implements the middleware stack for this service. It will:

1. Load credentials asynchronously into the property bag
2. Sign the request with SigV4
3. Resolve an Endpoint for the request
4. Add a user agent to the request

Implementations

impl DefaultMiddleware

pub fn new() -> Self

Create a new DefaultMiddleware stack

Note: DefaultMiddleware holds no state.

Examples found in repository

src/client.rs (line 5555)

    pub fn from_conf(conf: crate::Config) -> Self {
        let retry_config = conf
            .retry_config()
            .cloned()
            .unwrap_or_else(aws_smithy_types::retry::RetryConfig::disabled);
        let timeout_config = conf
            .timeout_config()
            .cloned()
            .unwrap_or_else(aws_smithy_types::timeout::TimeoutConfig::disabled);
        let sleep_impl = conf.sleep_impl();
        if (retry_config.has_retry() || timeout_config.has_timeouts()) && sleep_impl.is_none() {
            panic!("An async sleep implementation is required for retries or timeouts to work. \
                                    Set the `sleep_impl` on the Config passed into this function to fix this panic.");
        }

        let connector = conf.http_connector().and_then(|c| {
            let timeout_config = conf
                .timeout_config()
                .cloned()
                .unwrap_or_else(aws_smithy_types::timeout::TimeoutConfig::disabled);
            let connector_settings =
                aws_smithy_client::http_connector::ConnectorSettings::from_timeout_config(
                    &timeout_config,
                );
            c.connector(&connector_settings, conf.sleep_impl())
        });

        let builder = aws_smithy_client::Builder::new();

        let builder = match connector {
            // Use provided connector
            Some(c) => builder.connector(c),
            None => {
                #[cfg(any(feature = "rustls", feature = "native-tls"))]
                {
                    // Use default connector based on enabled features
                    builder.dyn_https_connector(
                        aws_smithy_client::http_connector::ConnectorSettings::from_timeout_config(
                            &timeout_config,
                        ),
                    )
                }
                #[cfg(not(any(feature = "rustls", feature = "native-tls")))]
                {
                    panic!("No HTTP connector was available. Enable the `rustls` or `native-tls` crate feature or set a connector to fix this.");
                }
            }
        };
        let mut builder = builder
            .middleware(aws_smithy_client::erase::DynMiddleware::new(
                crate::middleware::DefaultMiddleware::new(),
            ))
            .retry_config(retry_config.into())
            .operation_timeout_config(timeout_config.into());
        builder.set_sleep_impl(sleep_impl);
        let client = builder.build();

        Self {
            handle: std::sync::Arc::new(Handle { client, conf }),
        }
    }

Trait Implementations

impl Clone for DefaultMiddleware

fn clone(&self) -> DefaultMiddleware

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DefaultMiddleware

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

Formats the value using the given formatter.

impl Default for DefaultMiddleware

fn default() -> DefaultMiddleware

Returns the “default value” for a type.

impl<S> Layer<S> for DefaultMiddleware

type Service = <Stack<MapRequestLayer<RecursionDetectionStage>, Stack<MapRequestLayer<SigV4SigningStage>, Stack<AsyncMapRequestLayer<CredentialsStage>, Stack<MapRequestLayer<UserAgentStage>, Stack<MapRequestLayer<AwsAuthStage>, Stack<MapRequestLayer<SmithyEndpointStage>, Identity>>>>>> as Layer<S>>::Service

The wrapped service

fn layer(&self, inner: S) -> Self::Service

Wrap the given service with the middleware, returning a new service that has been decorated with the middleware.