http-client/aws.smithy.kotlin.runtime.http.operation/SdkOperationExecution

SdkOperationExecution

class SdkOperationExecution<Request, Response>

Configure the execution of an operation from Request to Response.

An operation has several "phases" of its lifecycle that can be intercepted and customized. Technically any phase can act on the request or the response. The phases are named with their intended use; however, nothing prevents e.g. registering something in initialize that acts on the output type though.

Middleware Phases

Initialize ---> <Serialize> ---> Mutate
                                    |
                                    v
                                 <Retry>
                                    |
                                    v
                             +---------------------+
                             |    OnEachAttempt    |
                             |        |            |
                             |        v            |
                             |  <ResolveIdentity>  |
                             |        |            |
                             |        v            |
                             |  <ResolveEndpoint>  |
                             |        |            |
                             |        v            |
                             |    <Signing>        |
                             |        |            |
                             |        v            |
                             |   <Deserialize>     |
                             |        |            |
                             |        v            |
                             |     Receive         |
                             |        |            |
                             |        v            |
                             |    <HttpClient>     |
                             +---------------------+

In the above diagram the phase relationships and sequencing are shown. Requests start at initialize and proceed until the actual HTTP client engine call. The response then is returned up the call stack and traverses the phases in reverse.

Phases enclosed in brackets <> are implicit phases that are always present and cannot be intercepted directly (only one is allowed to exist). These are usually configured directly when the operation is built.

Default Behaviors

By default, every operation is:

Retried using the configured retryStrategy and retryPolicy.
Signed using the resolved authentication scheme

Constructors

SdkOperationExecution

constructor()

Properties

auth

var auth: OperationAuthConfig

The authentication config to use. Defaults to OperationAuthConfig.Anonymous which uses anonymous authentication (no auth).

endpointResolver

var endpointResolver: EndpointResolver?

The endpoint resolver for the operation

initialize

val initialize: <Error class: unknown class><OperationRequest<Request>, Response>

Request Middlewares: Prepare the input Request (e.g. set any default parameters if needed) before serialization

mutate

val mutate: <Error class: unknown class><SdkHttpRequest, Response>

Request Middlewares: Modify the outgoing HTTP request. This phase runs BEFORE the retry loop and is suitable for any middleware that only needs to run once and does not need to modify the outgoing request per/attempt.

onEachAttempt

val onEachAttempt: <Error class: unknown class><SdkHttpRequest, Response>

Request Middlewares: Modify the outgoing HTTP request. This phase is conceptually the same as mutate but it runs on every attempt. Each attempt will not see modifications made by previous attempts.

receive

val receive: <Error class: unknown class><SdkHttpRequest, <Error class: unknown class>>

Request Middlewares: First chance to intercept after signing (and last chance before the final request is sent).

retryPolicy

var retryPolicy: <Error class: unknown class><Response>

The retry policy to use. Defaults to StandardRetryPolicy.Default

retryStrategy

var retryStrategy: <Error class: unknown class>

The retry strategy to use. Defaults to StandardRetryStrategy