feat(appmesh): add listener timeout to Virtual Nodes

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

@@ -186,14 +186,20 @@ const node = new VirtualNode(this, 'node', {
       timeout: Duration.seconds(2), // min
       unhealthyThreshold: 2,
     },
+    timeout: {
+      http: {
+        idle: Duration.seconds(5),
+        perRequest: Duration.seconds(5),
+      }
+    }
   },
   accessLog: appmesh.AccessLog.fromFilePath('/dev/stdout'),
 });
 
 cdk.Tag.add(node, 'Environment', 'Dev');
 ```
 
-The listeners property can be left blank and added later with the `mesh.addListeners()` method. The `healthcheck` property is optional but if specifying a listener, the `portMappings` must contain at least one property.
+The listeners property can be left blank and added later with the `mesh.addListeners()` method. The `healthcheck` and `timeout` properties are optional but if specifying a listener, the `portMappings` must contain at least one property.
 
 ## Adding a Route
 

packages/@aws-cdk/aws-appmesh/lib/shared-interfaces.ts

@@ -81,6 +81,88 @@ export interface PortMapping {
   readonly protocol: Protocol;
 }
 
+/**
+ * Represents timeouts for different protocols.
+ */
+export interface HttpTimeout {
+  /**
+   * Represents an idle timeout. The amount of time that a connection may be idle.
+   *
+   * @default - none
+   */
+  readonly idle?: cdk.Duration;
+
+  /**
+   * Represents per request timeout.
+   *
+   * @default - 15 s
+   */
+  readonly perRequest?: cdk.Duration;
+}
+
+/**
+ * Represents timeouts for different protocols.
+ */
+export interface GrpcTimeout {
+  /**
+   * Represents an idle timeout. The amount of time that a connection may be idle.
+   *
+   * @default - none
+   */
+  readonly idle?: cdk.Duration;
+
+  /**
+   * Represents per request timeout.
+   *
+   * @default - 15 s
+   */
+
+  readonly perRequest?: cdk.Duration;
+}
+
+/**
+ * Represents timeouts for different protocols.
+ */
+export interface TcpTimeout {
+  /**
+   * Represents an idle timeout. The amount of time that a connection may be idle.
+   *
+   * @default - none
+   */
+  readonly idle?: cdk.Duration;
+}
+
+/**
+ * Represents timeouts for different protocols.
+ */
+export interface ListenerTimeout {
+  /**
+   * Represents GrpcTimeout type.
+   *
+   * @default - none
+   */
+  readonly grpc?: GrpcTimeout;
+  /**
+   * Represents HttpTimeout type.
+   *
+   * @default - none
+   */
+  readonly http?: HttpTimeout;
+  /**
+   * Represents HttpTimeout type.
+   *
+   * @default - none
+   */
+  readonly http2?: HttpTimeout;
+  /**
+   * Represents TCPTimeout type.
+   *
+   * @default - none
+   */
+  readonly tcp?: TcpTimeout;
+
+}
+
 /**
  * Represents the properties needed to define healthy and active listeners for nodes.
  */
@@ -98,6 +180,13 @@ export interface VirtualNodeListener {
    * @default - no healthcheck
    */
   readonly healthCheck?: HealthCheck;
+
+  /**
+   * Represents timeouts for different protocols.
+   *
+   * @default - none
+   */
+  readonly timeout?: ListenerTimeout;
 }
 
 /**

packages/@aws-cdk/aws-appmesh/lib/virtual-node.ts

@@ -3,7 +3,7 @@ import * as cdk from '@aws-cdk/core';
 import { Construct } from 'constructs';
 import { CfnVirtualNode } from './appmesh.generated';
 import { IMesh } from './mesh';
-import { AccessLog, HealthCheck, PortMapping, Protocol, VirtualNodeListener } from './shared-interfaces';
+import { AccessLog, HealthCheck, ListenerTimeout, PortMapping, Protocol, VirtualNodeListener } from './shared-interfaces';
 import { IVirtualService } from './virtual-service';
 
 /**
@@ -149,11 +149,107 @@ abstract class VirtualNodeBase extends cdk.Resource implements IVirtualNode {
       this.listeners.push({
         portMapping,
         healthCheck: renderHealthCheck(listener.healthCheck, portMapping),
+        timeout: renderListenerTimeout(listener.timeout),
       });
     }
   }
 }
 
+/**
+ * Utility method to extract time unit and value.
+ *
+ * @param time
+ */
+function getTimeUnitAndValue(time: cdk.Duration) {
+  let timeUnit = time.toHumanString().split(' ')[1];
+  if (timeUnit === 'seconds' || 'second') {
+    let timeValue: number = time.toSeconds();
+    return { value: timeValue, unit: 's' };
+  } else {
+    let timeValue: number = time.toMilliseconds();
+    return { value: timeValue, unit: 'ms' };
+  }
+}
+
+/**
+ * Method to create ListenerTimeoutProperty object based on available timeout protocol
+ *
+ * @param timeout
+ */
+function renderListenerTimeout(timeout: ListenerTimeout | undefined): CfnVirtualNode.ListenerTimeoutProperty | undefined {
+
+  if (timeout===undefined) {
+    return undefined;
+  }
+
+  let listenerTimeout:CfnVirtualNode.ListenerTimeoutProperty = {};
+
+  (Object.keys(timeout) as Array<keyof CfnVirtualNode.ListenerTimeoutProperty>)
+    .filter((key) => timeout[key]!==undefined).map((key) => {
+      if (key!=='tcp') {
+        let idle: unknown = timeout[key]?.idle;
+        let perRequest: unknown = timeout[key]?.perRequest;
+        if (idle===undefined && perRequest===undefined) {
+          listenerTimeout = {
+            [key]: {},
+          };
+        }
+        if (idle===undefined && perRequest!==undefined) {
+          listenerTimeout = {
+            [key]: {
+              perRequest: {
+                unit: getTimeUnitAndValue(perRequest as cdk.Duration).unit,
+                value: getTimeUnitAndValue(perRequest as cdk.Duration).value,
+              },
+            },
+          };
+        }
+        if (perRequest==undefined && idle!==undefined) {
+          listenerTimeout = {
+            [key]: {
+              idle: {
+                unit: getTimeUnitAndValue(idle as cdk.Duration).unit,
+                value: getTimeUnitAndValue(idle as cdk.Duration).value,
+              },
+            },
+          };
+        }
+        if (perRequest!==undefined && idle!==undefined) {
+          listenerTimeout = {
+            [key]: {
+              idle: {
+                unit: getTimeUnitAndValue(idle as cdk.Duration).unit,
+                value: getTimeUnitAndValue(idle as cdk.Duration).value,
+              },
+              perRequest: {
+                unit: getTimeUnitAndValue(perRequest as cdk.Duration).unit,
+                value: getTimeUnitAndValue(perRequest as cdk.Duration).value,
+              },
+            },
+          };
+        }
+      } else {
+        let idle: unknown = timeout[key]?.idle;
+        if (idle===undefined) {
+          listenerTimeout = {
+            [key]: {},
+          };
+        } else {
+          listenerTimeout = {
+            [key]: {
+              idle: {
+                unit: getTimeUnitAndValue(idle as cdk.Duration).unit,
+                value: getTimeUnitAndValue(idle as cdk.Duration).value,
+              },
+            },
+          };
+        }
+      }
+    });
+
+  return listenerTimeout;
+}
+
 /**
  * Minimum and maximum thresholds for HeathCheck numeric properties
  *

packages/@aws-cdk/aws-appmesh/package.json

@@ -125,6 +125,7 @@
       "resource-attribute:@aws-cdk/aws-appmesh.Route.routeUid",
       "resource-attribute:@aws-cdk/aws-appmesh.Route.routeVirtualRouterName",
       "resource-attribute:@aws-cdk/aws-appmesh.VirtualNode.virtualNodeMeshName",
+      "duration-prop-type:@aws-cdk/aws-appmesh.VirtualNodeListener.timeout",
       "resource-attribute:@aws-cdk/aws-appmesh.VirtualNode.virtualNodeMeshOwner",
       "resource-attribute:@aws-cdk/aws-appmesh.VirtualNode.virtualNodeResourceOwner",
       "resource-attribute:@aws-cdk/aws-appmesh.VirtualNode.virtualNodeUid",

packages/@aws-cdk/aws-appmesh/test/integ.mesh.expected.json

@@ -599,6 +599,63 @@
         }
       }
     },
+    "meshrouter2F830E97F": {
+      "Type": "AWS::AppMesh::VirtualRouter",
+      "Properties": {
+        "MeshName": {
+          "Fn::GetAtt": [
+            "meshACDFE68E",
+            "MeshName"
+          ]
+        },
+        "Spec": {
+          "Listeners": [
+            {
+              "PortMapping": {
+                "Port": 8080,
+                "Protocol": "http"
+              }
+            }
+          ]
+        },
+        "VirtualRouterName": "meshstackmeshrouter2BDE08990"
+      }
+    },
+    "meshrouter2route4030DB01D": {
+      "Type": "AWS::AppMesh::Route",
+      "Properties": {
+        "MeshName": {
+          "Fn::GetAtt": [
+            "meshACDFE68E",
+            "MeshName"
+          ]
+        },
+        "RouteName": "route-4",
+        "Spec": {
+          "TcpRoute": {
+            "Action": {
+              "WeightedTargets": [
+                {
+                  "VirtualNode": {
+                    "Fn::GetAtt": [
+                      "meshnode4AE87F692",
+                      "VirtualNodeName"
+                    ]
+                  },
+                  "Weight": 100
+                }
+              ]
+            }
+          }
+        },
+        "VirtualRouterName": {
+          "Fn::GetAtt": [
+            "meshrouter2F830E97F",
+            "VirtualRouterName"
+          ]
+        }
+      }
+    },
     "meshserviceE06ECED5": {
       "Type": "AWS::AppMesh::VirtualService",
       "Properties": {
@@ -623,6 +680,50 @@
         "VirtualServiceName": "service1.domain.local"
       }
     },
+    "meshnode4AE87F692": {
+      "Type": "AWS::AppMesh::VirtualNode",
+      "Properties": {
+        "MeshName": {
+          "Fn::GetAtt": [
+            "meshACDFE68E",
+            "MeshName"
+          ]
+        },
+        "Spec": {
+          "Listeners": [
+            {
+              "HealthCheck": {
+                "HealthyThreshold": 3,
+                "IntervalMillis": 5000,
+                "Path": "/check-path4",
+                "Port": 8080,
+                "Protocol": "http",
+                "TimeoutMillis": 2000,
+                "UnhealthyThreshold": 2
+              },
+              "PortMapping": {
+                "Port": 8080,
+                "Protocol": "http"
+              },
+              "Timeout": {
+                "HTTP": {
+                  "Idle": {
+                    "Unit": "s",
+                    "Value": 10
+                  }
+                }
+              }
+            }
+          ],
+          "ServiceDiscovery": {
+            "DNS": {
+              "Hostname": "node4.domain.local"
+            }
+          }
+        },
+        "VirtualNodeName": "meshstackmeshnode404B014E7"
+      }
+    },
     "meshnode726C787D": {
       "Type": "AWS::AppMesh::VirtualNode",
       "Properties": {