Struct aws_sdk_s3::client::Builder

pub struct Builder<C = (), M = (), R = Standard> { /* fields omitted */ }

A builder that provides more customization options when constructing a Client.

To start, call Builder::new. Then, chain the method calls to configure the Builder. When configured to your liking, call Builder::build. The individual methods have additional documentation.

Implementations

impl<C, M> Builder<C, M, Standard> where
    C: Default,
    M: Default, 

pub fn new() -> Builder<C, M, Standard>

Construct a new builder.

This will

You will likely want to , as it does not specify a connector or middleware. It uses the standard retry mechanism.

impl<M, R> Builder<(), M, R>

pub fn connector<C>(self, connector: C) -> Builder<C, M, R>

Specify the connector for the eventual client to use.

The connector dictates how requests are turned into responses. Normally, this would entail sending the request to some kind of remote server, but in certain settings it’s useful to be able to use a custom connector instead, such as to mock the network for tests.

If you just want to specify a function from request to response instead, use Builder::map_connector.

pub fn connector_fn<F, FF>(self, map: F) -> Builder<ServiceFn<F>, M, R> where
    F: Fn(Request<SdkBody>) -> FF + Send,
    FF: Future<Output = Result<Response<SdkBody>, ConnectorError>>,
    ServiceFn<F>: SmithyConnector, 

Use a function that directly maps each request to a response as a connector.

use aws_smithy_client::Builder;
use aws_smithy_http::body::SdkBody;
let client = Builder::new()
  .middleware(..)
  .connector_fn(|req: http::Request<SdkBody>| {
    async move {
      Ok(http::Response::new(SdkBody::empty()))
    }
  })
  .build();

impl<C, R> Builder<C, (), R>

pub fn middleware<M>(self, middleware: M) -> Builder<C, M, R>

Specify the middleware for the eventual client ot use.

The middleware adjusts requests before they are dispatched to the connector. It is responsible for filling in any request parameters that aren’t specified by the Smithy protocol definition, such as those used for routing (like the URL), authentication, and authorization.

The middleware takes the form of a tower::Layer that wraps the actual connection for each request. The tower::Service that the middleware produces must accept requests of the type aws_smithy_http::operation::Request and return responses of the type http::Response<SdkBody>, most likely by modifying the provided request in place, passing it to the inner service, and then ultimately returning the inner service’s response.

If your requests are already ready to be sent and need no adjustment, you can use tower::layer::util::Identity as your middleware.

pub fn middleware_fn<F>(self, map: F) -> Builder<C, MapRequestLayer<F>, R> where
    F: 'static + Fn(Request) -> Request + Clone + Send + Sync, 

Use a function-like middleware that directly maps each request.

use aws_smithy_client::Builder;
use aws_smithy_http::body::SdkBody;
let client = Builder::new()
  .https()
  .middleware_fn(|req: aws_smithy_http::operation::Request| {
    req
  })
  .build();

impl<C, M> Builder<C, M, Standard>

pub fn retry_policy<R>(self, retry_policy: R) -> Builder<C, M, R>

Specify the retry policy for the eventual client to use.

By default, the Smithy client uses a standard retry policy that works well in most settings. You can use this method to override that policy with a custom one. A new policy instance will be instantiated for each request using retry::NewRequestPolicy. Each policy instance must implement tower::retry::Policy.

If you just want to modify the policy configuration for the standard retry policy, use Builder::set_retry_config.

impl<C, M> Builder<C, M, Standard>

pub fn set_retry_config(&mut self, config: Config)

Set the standard retry policy’s configuration.

impl<C, M, R> Builder<C, M, R>

pub fn map_connector<F, C2>(self, map: F) -> Builder<C2, M, R> where
    F: FnOnce(C) -> C2, 

Use a connector that wraps the current connector.

pub fn map_middleware<F, M2>(self, map: F) -> Builder<C, M2, R> where
    F: FnOnce(M) -> M2, 

Use a middleware that wraps the current middleware.

pub fn build(self) -> Client<C, M, R>

Build a Smithy service Client.

impl<C, M, R> Builder<C, M, R> where
    C: SmithyConnector,
    M: 'static + SmithyMiddleware<DynConnector> + Send + Sync,
    R: NewRequestPolicy, 

pub fn build_dyn(self) -> Client<DynConnector, DynMiddleware<DynConnector>, R>

Build a type-erased Smithy service Client.

Note that if you’re using the standard retry mechanism, retry::Standard, DynClient<R> is equivalent to Client with no type arguments.

use aws_smithy_client::{Builder, Client};
struct MyClient {
    client: aws_smithy_client::Client,
}

let client = Builder::new()
    .https()
    .middleware(tower::layer::util::Identity::new())
    .build_dyn();
let client = MyClient { client };

impl<M, R> Builder<(), M, R>

pub fn rustls(
    self
) -> Builder<HyperAdapter<HttpsConnector<HttpConnector<GaiResolver>>>, M, R>

Connect to the service over HTTPS using Rustls.

pub fn https(
    self
) -> Builder<HyperAdapter<HttpsConnector<HttpConnector<GaiResolver>>>, M, R>

Connect to the service over HTTPS using Rustls.

This is exactly equivalent to Builder::rustls. If you instead wish to use native_tls, use Builder::native_tls.

Trait Implementations

impl<C, M, R> Clone for Builder<C, M, R> where
    C: Clone,
    M: Clone,
    R: Clone, 

pub fn clone(&self) -> Builder<C, M, R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C, M, R> Debug for Builder<C, M, R> where
    C: Debug,
    M: Debug,
    R: Debug, 

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

Formats the value using the given formatter.

impl<C, M, R> Default for Builder<C, M, R> where
    C: Default,
    M: Default,
    R: Default, 

pub fn default() -> Builder<C, M, R>

Returns the “default value” for a type.