feat(appmesh): add route retry policies

packages/@aws-cdk/aws-appmesh/README.md

@@ -320,6 +320,40 @@ router.addRoute('route-http', {
 });
 ```
 
+Add an http2 route with retries:
+
+```ts
+router.addRoute('route-http2-retry', {
+ routeSpec: appmesh.RouteSpec.http2({
+ weightedTargets: [{ virtualNode: node }],
+ retryPolicy: {
+ httpRetryEvents: [appmesh.HttpRetryEvent.CLIENT_ERROR],
+ tcpRetryEvents: [appmesh.TcpRetryEvent.CONNECTION_ERROR],
+ maxRetries: 5,
+ perRetryTimeout: cdk.Duration.seconds(1),
+ },
+ }),
+});
+```
+
+Add a gRPC route with retries:
+
+```ts
+router.addRoute('route-grpc-retry', {
+ routeSpec: appmesh.RouteSpec.grpc({
+ weightedTargets: [{ virtualNode: node }],
+ match: { serviceName: 'servicename' },
+ retryPolicy: {
+ grpcRetryEvents: [appmesh.GrpcRetryEvent.DEADLINE_EXCEEDED],
+ httpRetryEvents: [appmesh.HttpRetryEvent.CLIENT_ERROR],
+ tcpRetryEvents: [appmesh.TcpRetryEvent.CONNECTION_ERROR],
+ maxRetries: 5,
+ perRetryTimeout: cdk.Duration.seconds(1),
+ },
+ }),
+});
+```
+
 The _RouteSpec_ class provides an easy interface for defining new protocol specific route specs.
 The `tcp()`, `http()` and `http2()` methods provide the spec necessary to define a protocol specific spec.
 

packages/@aws-cdk/aws-appmesh/lib/route-spec.ts

@@ -1,3 +1,4 @@
+import * as cdk from '@aws-cdk/core';
 import { CfnRoute } from './appmesh.generated';
 import { Protocol, HttpTimeout, GrpcTimeout, TcpTimeout } from './shared-interfaces';
 import { IVirtualNode } from './virtual-node';
@@ -68,6 +69,76 @@ export interface HttpRouteSpecOptions {
  * @default - None
  */
  readonly timeout?: HttpTimeout;
+
+ /**
+ * The retry policy
+ * @default - no retry policy
+ */
+ readonly retryPolicy?: HttpRetryPolicy;
+}
+
+/**
+ * HTTP retry policy
+ */
+export interface HttpRetryPolicy {
+ /**
+ * Specify HTTP events on which to retry
+ * @default - no retries for http events
+ */
+ readonly httpRetryEvents?: HttpRetryEvent[];
+
+ /**
+ * The maximum number of retry attempts
+ */
+ readonly maxRetries: number;
+
+ /**
+ * The timeout for each retry attempt
+ */
+ readonly perRetryTimeout: cdk.Duration;
+
+ /**
+ * TCP events on which to retry. The event occurs before any processing of a
+ * request has started and is encountered when the upstream is temporarily or
+ * permanently unavailable.
+ * @default - no retries for tcp events
+ */
+ readonly tcpRetryEvents?: TcpRetryEvent[];
+}
+
+/**
+ * HTTP events on which to retry.
+ */
+export enum HttpRetryEvent {
+ /**
+ * HTTP status codes 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, and 511
+ */
+ SERVER_ERROR = 'server-error',
+
+ /**
+ * HTTP status codes 502, 503, and 504
+ */
+ GATEWAY_ERROR = 'gateway-error',
+
+ /**
+ * HTTP status code 409
+ */
+ CLIENT_ERROR = 'client-error',
+
+ /**
+ * Retry on refused stream
+ */
+ STREAM_ERROR = 'stream-error',
+}
+
+/**
+ * TCP events on which you may retry
+ */
+export enum TcpRetryEvent {
+ /**
+ * A connection error
+ */
+ CONNECTION_ERROR = 'connection-error',
 }
 
 /**
@@ -107,6 +178,51 @@ export interface GrpcRouteSpecOptions {
  * List of targets that traffic is routed to when a request matches the route
  */
  readonly weightedTargets: WeightedTarget[];
+
+ /**
+ * The retry policy
+ * @default - no retry policy
+ */
+ readonly retryPolicy?: GrpcRetryPolicy;
+}
+
+/** gRPC retry policy */
+export interface GrpcRetryPolicy extends HttpRetryPolicy {
+ /**
+ * gRPC events on which to retry
+ * @default - no retries for gRPC events
+ */
+ readonly grpcRetryEvents?: GrpcRetryEvent[];
+}
+
+/**
+ * gRPC events
+ */
+export enum GrpcRetryEvent {
+ /**
+ * Request was cancelled
+ */
+ CANCELLED = 'cancelled',
+
+ /**
+ * The deadline was exceeded
+ */
+ DEADLINE_EXCEEDED = 'deadline-exceeded',
+
+ /**
+ * Internal error
+ */
+ INTERNAL = 'internal',
+
+ /**
+ * Resource was exhausted
+ */
+ RESOURCE_EXHAUSTED = 'resource-exhausted',
+
+ /**
+ * Unavailable
+ */
+ UNAVAILABILE = 'unavailable',
 }
 
 /**
@@ -203,19 +319,43 @@ class HttpRouteSpec extends RouteSpec {
  */
  public readonly weightedTargets: WeightedTarget[];
 
+ /**
+ * The retry policy
+ */
+ public readonly retryPolicy?: HttpRetryPolicy;
+
  constructor(props: HttpRouteSpecOptions, protocol: Protocol) {
  super();
  this.protocol = protocol;
  this.match = props.match;
  this.weightedTargets = props.weightedTargets;
  this.timeout = props.timeout;
+
+ if (props.retryPolicy) {
+ if (props.retryPolicy.httpRetryEvents && props.retryPolicy.httpRetryEvents.length === 0) {
+ throw new Error('Specify at least one value in `httpRetryEvents` or leave it undefined');
+ }
+
+ if (props.retryPolicy.tcpRetryEvents && props.retryPolicy.tcpRetryEvents.length === 0) {
+ throw new Error('Specify at least one value in `tcpRetryEvents` or leave it undefined');
+ }
+
+ const numHttpRetryEvents = (props.retryPolicy.httpRetryEvents ?? []).length;
+ const numTcpRetryEvents = (props.retryPolicy.tcpRetryEvents ?? []).length;
+ if (numHttpRetryEvents + numTcpRetryEvents === 0) {
+ throw new Error('You must specify one value for at least one of `httpRetryEvents` or `tcpRetryEvents`');
+ }
+
+ this.retryPolicy = props.retryPolicy;
+ }
  }
 
  public bind(_scope: Construct): RouteSpecConfig {
  const prefixPath = this.match ? this.match.prefixPath : '/';
  if (prefixPath[0] != '/') {
  throw new Error(`Prefix Path must start with \'/\', got: ${prefixPath}`);
  }
+
  const httpConfig: CfnRoute.HttpRouteProperty = {
  action: {
  weightedTargets: renderWeightedTargets(this.weightedTargets),
@@ -224,6 +364,7 @@ class HttpRouteSpec extends RouteSpec {
  prefix: prefixPath,
  },
  timeout: renderTimeout(this.timeout),
+ retryPolicy: this.retryPolicy ? renderHttpRetryPolicy(this.retryPolicy) : undefined,
  };
  return {
  httpRouteSpec: this.protocol === Protocol.HTTP ? httpConfig : undefined,
@@ -266,11 +407,40 @@ class GrpcRouteSpec extends RouteSpec {
  public readonly match: GrpcRouteMatch;
  public readonly timeout?: GrpcTimeout;
 
+ /**
+ * The retry policy.
+ */
+ public readonly retryPolicy?: GrpcRetryPolicy;
+
  constructor(props: GrpcRouteSpecOptions) {
  super();
  this.weightedTargets = props.weightedTargets;
  this.match = props.match;
  this.timeout = props.timeout;
+
+ if (props.retryPolicy) {
+ if (props.retryPolicy.grpcRetryEvents && props.retryPolicy.grpcRetryEvents.length === 0) {
+ throw new Error('Specify at least one value in `grpcRetryEvents` or leave it undefined');
+ }
+
+ if (props.retryPolicy.httpRetryEvents && props.retryPolicy.httpRetryEvents.length === 0) {
+ throw new Error('Specify at least one value in `httpRetryEvents` or leave it undefined');
+ }
+
+ if (props.retryPolicy.tcpRetryEvents && props.retryPolicy.tcpRetryEvents.length === 0) {
+ throw new Error('Specify at least one value in `tcpRetryEvents` or leave it undefined');
+ }
+
+ const numGrpcRetryEvents = (props.retryPolicy.grpcRetryEvents ?? []).length;
+ const numHttpRetryEvents = (props.retryPolicy.httpRetryEvents ?? []).length;
+ const numTcpRetryEvents = (props.retryPolicy.tcpRetryEvents ?? []).length;
+
+ if (numGrpcRetryEvents + numHttpRetryEvents + numTcpRetryEvents === 0) {
+ throw new Error('You must specify one value for at least one of `grpcRetryEvents`, `httpRetryEvents`, `tcpRetryEvents`');
+ }
+
+ this.retryPolicy = props.retryPolicy;
+ }
  }
 
  public bind(_scope: Construct): RouteSpecConfig {
@@ -283,6 +453,7 @@ class GrpcRouteSpec extends RouteSpec {
  serviceName: this.match.serviceName,
  },
  timeout: renderTimeout(this.timeout),
+ retryPolicy: this.retryPolicy ? renderGrpcRetryPolicy(this.retryPolicy) : undefined,
  },
  };
  }
@@ -323,3 +494,22 @@ function renderTimeout(timeout?: HttpTimeout): CfnRoute.HttpTimeoutProperty | un
  }
  : undefined;
 }
+
+function renderHttpRetryPolicy(retryPolicy: HttpRetryPolicy): CfnRoute.HttpRetryPolicyProperty {
+ return {
+ maxRetries: retryPolicy.maxRetries,
+ perRetryTimeout: {
+ unit: 'ms',
+ value: retryPolicy.perRetryTimeout.toMilliseconds(),
+ },
+ httpRetryEvents: retryPolicy.httpRetryEvents,
+ tcpRetryEvents: retryPolicy.tcpRetryEvents,
+ };
+}
+
+function renderGrpcRetryPolicy(retryPolicy: GrpcRetryPolicy): CfnRoute.GrpcRetryPolicyProperty {
+ return {
+ ...renderHttpRetryPolicy(retryPolicy),
+ grpcRetryEvents: retryPolicy.grpcRetryEvents,
+ };
+}