feat: move some config components to middleware folder

* signing middleware
* retry middleware; Also update retry config interface by introducing RetryStrategy class

Author: AllanZhengYP

clients/node/client-rds-data-node/RDSDataClient.ts

@@ -1,14 +1,14 @@
 import { contentLengthPlugin } from "@aws-sdk/middleware-content-length";
 import * as __aws_sdk_middleware_header_default from "@aws-sdk/middleware-header-default";
-import * as __aws_sdk_retry_middleware from "@aws-sdk/retry-middleware";
-import { signingPlugin } from "@aws-sdk/signing-middleware";
+import { retryPlugin, RetryConfig } from "@aws-sdk/retry-middleware";
+import { signingPlugin, AwsAuthConfiguration } from "@aws-sdk/signing-middleware";
 import * as __aws_sdk_util_user_agent_node from "@aws-sdk/util-user-agent-node";
 import {
   RDSDataConfiguration,
   RDSDataResolvedConfiguration,
   RDSRuntimeConfiguration
 } from "./RDSDataConfiguration";
-import { AwsAuthConfiguration, RegionConfiguration, RetryConfig, EndpointsConfig, ProtocolConfig } from '@aws-sdk/config-resolver';
+import { RegionConfiguration, EndpointsConfig, ProtocolConfig } from '@aws-sdk/config-resolver';
 import { HttpOptions, MetadataBearer } from '@aws-sdk/types';
 import { SmithyClient } from "@aws-sdk/smithy-client";
 
@@ -31,20 +31,9 @@ export class RDSDataClient extends SmithyClient<HttpOptions, InputTypesUnion, Ou
     this.config = intermediaConfig_4;
     super.use(contentLengthPlugin(this.config));
     if (this.config.maxRetries > 0) {
-      this.middlewareStack.add(
-        __aws_sdk_retry_middleware.retryMiddleware(
-          this.config.maxRetries,
-          this.config.retryDecider,
-          this.config.delayDecider
-        ),
-        {
-          step: "finalizeRequest",
-          priority: Infinity,
-          tags: { RETRY: true }
-        }
-      );
+      super.use(retryPlugin(this.config))
     }
-    super.use(signingPlugin(this.config.signer));
+    super.use(signingPlugin(this.config));
     this.middlewareStack.add(
       __aws_sdk_middleware_header_default.headerDefault({
         "User-Agent": this.config.defaultUserAgent

clients/node/client-rds-data-node/RDSDataConfiguration.ts

@@ -9,8 +9,10 @@ import { RestJsonProtocol } from "@aws-sdk/protocol-rest-json";
 import { fromUtf8, toUtf8 } from '@aws-sdk/util-utf8-node';
 import { fromBase64, toBase64 } from '@aws-sdk/util-base64-node';
 import { defaultUserAgent } from '@aws-sdk/util-user-agent-node';
+import { AwsAuthConfiguration, AwsAuthConfigurationInput } from '@aws-sdk/signing-middleware';
+import { RetryConfig, RetryConfigInput } from '@aws-sdk/retry-middleware';
 import { name, version } from './package.json';
-import { AwsAuthConfiguration, RegionConfiguration, RetryConfig, EndpointsConfig, ProtocolConfig, AWSClientRuntimeConfiguration } from '@aws-sdk/config-resolver';
+import { RegionConfiguration, EndpointsConfig, ProtocolConfig, AWSClientRuntimeConfiguration } from '@aws-sdk/config-resolver';
 
 export type AWSClientRuntimeResolvedConfiguration = Required<AWSClientRuntimeConfiguration>;
 
@@ -33,9 +35,9 @@ export const RDSRuntimeConfiguration: AWSClientRuntimeResolvedConfiguration = {
 }
 
 export type RDSDataConfiguration = AWSClientRuntimeConfiguration &
-  AwsAuthConfiguration.Input &
+  AwsAuthConfigurationInput &
   RegionConfiguration.Input &
-  RetryConfig.Input &
+  RetryConfigInput &
   EndpointsConfig.Input &
   ProtocolConfig.Input
 

packages/config-resolver/src/components.ts

@@ -1,18 +1,14 @@
 import {
   Credentials,
   Provider,
-  RequestSigner,
   HashConstructor,
-  RetryDecider,
-  DelayDecider,
   UrlParser,
   Protocol,
   HttpOptions,
   StreamCollector,
   Decoder,
   Encoder
 } from "@aws-sdk/types";
-import { SignatureV4 } from "@aws-sdk/signature-v4";
 import {
   HttpEndpoint,
   HttpHandler,
@@ -123,56 +119,6 @@ export function normalizeEndpoint(
   return endpoint!;
 }
 
-export namespace AwsAuthConfiguration {
-  export interface Input {
-    /**
-     * The credentials used to sign requests.
-     */
-    credentials?: Credentials | Provider<Credentials>;
-
-    /**
-     * The signer to use when signing requests.
-     */
-    signer?: RequestSigner;
-
-    /**
-     * Whether to escape request path when signing the request
-     */
-    signingEscapePath?: boolean;
-  }
-  interface PreviouslyResolved {
-    credentialDefaultProvider: (input: any) => Provider<Credentials>;
-    region: string | Provider<string>;
-    signingName: string;
-    sha256: HashConstructor;
-  }
-  export type Resolved = {
-    credentials: Provider<Credentials>;
-    signer: RequestSigner;
-    signingEscapePath: boolean;
-  };
-  export function resolve<T>(
-    input: T & Input & PreviouslyResolved
-  ): T & Resolved {
-    let credentials =
-      input.credentials || input.credentialDefaultProvider(input as any);
-    const normalizedCreds = normalizeProvider(credentials);
-    const signingEscapePath = input.signingEscapePath || false;
-    return {
-      ...input,
-      signingEscapePath,
-      credentials: normalizedCreds,
-      signer: new SignatureV4({
-        credentials: normalizedCreds,
-        region: input.region,
-        service: input.signingName,
-        sha256: input.sha256,
-        uriEscapePath: signingEscapePath
-      })
-    };
-  }
-}
-
 export namespace RegionConfiguration {
   export interface Input {
     /**
@@ -197,25 +143,6 @@ export namespace RegionConfiguration {
   }
 }
 
-export namespace RetryConfig {
-  export interface Input {
-    maxRetries?: number;
-    retryDecider?: RetryDecider;
-    delayDecider?: DelayDecider;
-  }
-  export interface Resolved {
-    maxRetries: number;
-    retryDecider?: RetryDecider;
-    delayDecider?: DelayDecider;
-  }
-  export function resolve<T>(input: T & Input): T & Resolved {
-    return {
-      ...input,
-      maxRetries: input.maxRetries === undefined ? 3 : input.maxRetries
-    };
-  }
-}
-
 export namespace EndpointsConfig {
   export interface Input {
     /**

packages/retry-middleware/package.json

@@ -20,6 +20,7 @@
   },
   "devDependencies": {
     "@types/jest": "^24.0.12",
+    "@aws-sdk/protocol-http": "^0.1.0-preview.1",
     "jest": "^24.7.1",
     "typescript": "~3.4.0"
   }

packages/retry-middleware/src/configurations.ts

@@ -0,0 +1,25 @@
+import { RetryStrategy } from "@aws-sdk/types";
+import { ExponentialBackOffStrategy } from "./defaultStrategy";
+
+export namespace RetryConfig {
+  export interface Input {
+    maxRetries?: number;
+    retryStrategy?: RetryStrategy;
+  }
+  export interface Resolved {
+    maxRetries: number;
+    retryStrategy: RetryStrategy;
+  }
+  export function resolve<T>(input: T & Input): T & Resolved {
+    const maxRetries = input.maxRetries === undefined ? 3 : input.maxRetries;
+    return {
+      ...input,
+      maxRetries,
+      retryStrategy:
+        input.retryStrategy || new ExponentialBackOffStrategy(maxRetries)
+    };
+  }
+}
+
+//export separately for showing comment block in Intellisense
+export type RetryConfigInput = RetryConfig.Input;

packages/retry-middleware/src/defaultStrategy.ts

@@ -0,0 +1,23 @@
+import {
+  DEFAULT_RETRY_DELAY_BASE,
+  THROTTLING_RETRY_DELAY_BASE
+} from "./constants";
+import { defaultDelayDecider } from "./delayDecider";
+import { defaultRetryDecider } from "./retryDecider";
+import { isThrottlingError } from "@aws-sdk/service-error-classification";
+import { RetryStrategy, SdkError } from "@aws-sdk/types";
+
+export class ExponentialBackOffStrategy implements RetryStrategy {
+  constructor(public readonly maxRetries: number) {}
+  shouldRetry(error: SdkError, retryAttempted: number) {
+    return retryAttempted < this.maxRetries && defaultRetryDecider(error);
+  }
+  computeDelayBeforeNextRetry(error: SdkError, retryAttempted: number): number {
+    return defaultDelayDecider(
+      isThrottlingError(error)
+        ? THROTTLING_RETRY_DELAY_BASE
+        : DEFAULT_RETRY_DELAY_BASE,
+      retryAttempted
+    );
+  }
+}

packages/retry-middleware/src/index.ts

@@ -1,3 +1,3 @@
-export * from "./delayDecider";
-export * from "./retryDecider";
 export * from "./retryMiddleware";
+export * from "./defaultStrategy";
+export * from "./configurations";

packages/retry-middleware/src/retryDecider.spec.ts

@@ -1,49 +1,37 @@
 import { defaultRetryDecider } from "./retryDecider";
 
 describe("defaultRetryDecider", () => {
-  const decider = defaultRetryDecider();
-
   it("should return false when the provided error is falsy", () => {
-    expect(decider(null as any)).toBe(false);
+    expect(defaultRetryDecider(null as any)).toBe(false);
   });
 
   it("should return true if the error was tagged as a connection error", () => {
     const err: Error & { connectionError?: boolean } = new Error();
     err.connectionError = true;
-    expect(decider(err)).toBe(true);
+    expect(defaultRetryDecider(err)).toBe(true);
   });
 
   for (const httpStatusCode of [429, 500, 502, 503, 504, 509]) {
     it(`should return true if the error represents a service response with an HTTP status code of ${httpStatusCode}`, () => {
       const err: any = new Error();
       err.$metadata = { httpStatusCode };
-      expect(decider(err)).toBe(true);
+      expect(defaultRetryDecider(err)).toBe(true);
     });
   }
 
   it('should return true if the response represents a "still processing" error', () => {
     const err = new Error();
     err.name = "PriorRequestNotComplete";
-    expect(decider(err)).toBe(true);
+    expect(defaultRetryDecider(err)).toBe(true);
   });
 
   it("should return true if the response represents a throttling error", () => {
     const err = new Error();
     err.name = "TooManyRequestsException";
-    expect(decider(err)).toBe(true);
+    expect(defaultRetryDecider(err)).toBe(true);
   });
 
   it("should return false for other errors", () => {
-    expect(decider(new Error())).toBe(false);
-  });
-
-  describe("clock skew retries enabled", () => {
-    const decider = defaultRetryDecider(true);
-
-    it("should return true if the response represents a clock skew error", () => {
-      const err = new Error();
-      err.name = "RequestTimeTooSkewed";
-      expect(decider(err)).toBe(true);
-    });
+    expect(defaultRetryDecider(new Error())).toBe(false);
   });
 });

packages/retry-middleware/src/retryDecider.ts

@@ -4,35 +4,31 @@ import {
   isStillProcessingError,
   isThrottlingError
 } from "@aws-sdk/service-error-classification";
-import { MetadataBearer, SdkError, RetryDecider } from "@aws-sdk/types";
+import { MetadataBearer, SdkError } from "@aws-sdk/types";
 
-export function defaultRetryDecider(
-  retryClockSkewErrors = false
-): RetryDecider {
-  return (error: SdkError) => {
-    if (!error) {
-      return false;
-    }
+export const defaultRetryDecider = (error: SdkError) => {
+  if (!error) {
+    return false;
+  }
 
-    if (error.connectionError) {
-      return true;
-    }
+  if (error.connectionError) {
+    return true;
+  }
 
-    if (
-      hasMetadata(error) &&
-      error.$metadata.httpStatusCode &&
-      RETRYABLE_STATUS_CODES.has(error.$metadata.httpStatusCode)
-    ) {
-      return true;
-    }
+  if (
+    hasMetadata(error) &&
+    error.$metadata.httpStatusCode &&
+    RETRYABLE_STATUS_CODES.has(error.$metadata.httpStatusCode)
+  ) {
+    return true;
+  }
 
-    return (
-      isStillProcessingError(error) ||
-      isThrottlingError(error) ||
-      (retryClockSkewErrors && isClockSkewError(error))
-    );
-  };
-}
+  return (
+    isStillProcessingError(error) ||
+    isThrottlingError(error) ||
+    isClockSkewError(error)
+  );
+};
 
 function hasMetadata(error: any): error is MetadataBearer {
   return error && error.$metadata;