konokenj.cdk-api-mcp-server 0.25.0__py3-none-any.whl → 0.27.0__py3-none-any.whl

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.invoke.ts

@@ -1,119 +1,101 @@
-import { Code, Function } from 'aws-cdk-lib/aws-lambda';
-import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
-import * as cdk from 'aws-cdk-lib';
-import { LambdaInvoke } from 'aws-cdk-lib/aws-stepfunctions-tasks';
+import * as path from 'path';
 import { IntegTest, ExpectedResult } from '@aws-cdk/integ-tests-alpha';
-import { STANDARD_NODEJS_RUNTIME } from '../../../config';
+import * as cdk from 'aws-cdk-lib';
+import * as apigateway from 'aws-cdk-lib/aws-apigateway';
+import * as events from 'aws-cdk-lib/aws-events';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as lambda from 'aws-cdk-lib/aws-lambda-nodejs';
+import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+import { password, username } from './my-lambda-handler';
 
 /*
- * Creates a state machine with a task state to invoke a Lambda function
- * The state machine creates a couple of Lambdas that pass results forward
- * and into a Choice state that validates the output.
- *
- * Stack verification steps:
- * The generated State Machine can be executed from the CLI (or Step Functions console)
- * and runs with an execution status of `Succeeded`.
+ * Creates an API Gateway instance with a GET method and mock integration,
+ * secured with basic auth. It then creates a matching Connection and uses it
+ * in a state machine with a task state to invoke the endpoint.
  *
- * -- aws stepfunctions start-execution --state-machine-arn <state-machine-arn-from-output> provides execution arn
- * -- aws stepfunctions describe-execution --execution-arn <state-machine-arn-from-output> returns a status of `Succeeded`
+ * Stack verification steps :
+ * * aws stepfunctions start-execution --state-machine-arn <deployed state machine arn> : should return execution arn
+ * * aws stepfunctions describe-execution --execution-arn <execution-arn generated before> : should return status as SUCCEEDED
  */
 const app = new cdk.App({
   postCliContext: {
     '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
   },
 });
-const stack = new cdk.Stack(app, 'aws-stepfunctions-tasks-lambda-invoke-integ');
+const stack = new cdk.Stack(app, 'aws-stepfunctions-tasks-http-invoke-integ');
 
-const submitJobLambda = new Function(stack, 'submitJobLambda', {
-  code: Code.fromInline(`exports.handler = async (event, context) => {
-        return {
-          statusCode: '200',
-          body: 'hello, world!',
-          ...event,
-        };
-      };`),
-  runtime: STANDARD_NODEJS_RUNTIME,
-  handler: 'index.handler',
+const authorizerHandler = new lambda.NodejsFunction(stack, 'AuthorizerHandler', {
+  entry: path.resolve(__dirname, 'my-lambda-handler', 'index.ts'),
+  handler: 'handler',
 });
 
-const submitJob = new LambdaInvoke(stack, 'Invoke Handler', {
-  lambdaFunction: submitJobLambda,
-  payload: sfn.TaskInput.fromObject({
-    execId: sfn.JsonPath.executionId,
-    execInput: sfn.JsonPath.executionInput,
-    execName: sfn.JsonPath.executionName,
-    execRoleArn: sfn.JsonPath.executionRoleArn,
-    execStartTime: sfn.JsonPath.executionStartTime,
-    stateEnteredTime: sfn.JsonPath.stateEnteredTime,
-    stateName: sfn.JsonPath.stateName,
-    stateRetryCount: sfn.JsonPath.stateRetryCount,
-    stateMachineId: sfn.JsonPath.stateMachineId,
-    stateMachineName: sfn.JsonPath.stateMachineName,
-  }),
-  outputPath: '$.Payload',
+const authorizer = new apigateway.TokenAuthorizer(stack, 'Authorizer', {
+  handler: authorizerHandler,
+  identitySource: 'method.request.header.Authorization',
+  resultsCacheTtl: cdk.Duration.seconds(0),
 });
 
-const checkJobStateLambda = new Function(stack, 'checkJobStateLambda', {
-  code: Code.fromInline(`exports.handler = async function(event, context) {
-        const expectedFields = [
-          'execId', 'execInput', 'execName', 'execRoleArn',
-          'execStartTime', 'stateEnteredTime', 'stateName',
-          'stateRetryCount', 'stateMachineId', 'stateMachineName',
-        ];
-        const fieldsAreSet = expectedFields.every(field => event[field] !== undefined);
-        return {
-          status: event.statusCode === '200' && fieldsAreSet ? 'SUCCEEDED' : 'FAILED'
-        };
-  };`),
-  runtime: STANDARD_NODEJS_RUNTIME,
-  handler: 'index.handler',
-});
+const api = new apigateway.RestApi(stack, 'IntegRestApi');
 
-const checkJobState = new LambdaInvoke(stack, 'Check the job state', {
-  lambdaFunction: checkJobStateLambda,
-  resultSelector: {
-    status: sfn.JsonPath.stringAt('$.Payload.status'),
+api.root.addResource('test').addMethod(
+  'GET',
+  new apigateway.MockIntegration({
+    integrationResponses: [
+      {
+        statusCode: '200',
+        responseTemplates: {
+          'application/json': JSON.stringify({ message: 'Hello, tester!' }),
+        },
+      },
+    ],
+    passthroughBehavior: apigateway.PassthroughBehavior.NEVER,
+    requestTemplates: {
+      'application/json': '{ "statusCode": 200 }',
+    },
+  }),
+  {
+    authorizer,
+    methodResponses: [
+      {
+        statusCode: '200',
+      },
+    ],
   },
-});
+);
 
-const isComplete = new sfn.Choice(stack, 'Job Complete?');
-const jobFailed = new sfn.Fail(stack, 'Job Failed', {
-  cause: 'Job Failed',
-  error: 'Received a status that was not 200',
+const connection = new events.Connection(stack, 'Connection', {
+  authorization: events.Authorization.basic(username, cdk.SecretValue.unsafePlainText(password)),
 });
-const finalStatus = new sfn.Pass(stack, 'Final step');
 
-const chain = sfn.Chain.start(submitJob)
-  .next(checkJobState)
-  .next(
-    isComplete
-      .when(sfn.Condition.stringEquals('$.status', 'FAILED'), jobFailed)
-      .when(sfn.Condition.stringEquals('$.status', 'SUCCEEDED'), finalStatus),
-  );
+const httpInvokeTask = new tasks.HttpInvoke(stack, 'Invoke HTTP Endpoint', {
+  apiRoot: api.urlForPath('/'),
+  apiEndpoint: sfn.TaskInput.fromText('/test'),
+  connection,
+  method: sfn.TaskInput.fromText('GET'),
+});
 
 const sm = new sfn.StateMachine(stack, 'StateMachine', {
-  definition: chain,
+  definition: httpInvokeTask,
   timeout: cdk.Duration.seconds(30),
 });
 
-new cdk.CfnOutput(stack, 'stateMachineArn', {
-  value: sm.stateMachineArn,
-});
-
-const integ = new IntegTest(app, 'IntegTest', {
+const testCase = new IntegTest(app, 'HttpInvokeTest', {
   testCases: [stack],
 });
-const res = integ.assertions.awsApiCall('StepFunctions', 'startExecution', {
+
+// Start an execution
+const start = testCase.assertions.awsApiCall('StepFunctions', 'startExecution', {
   stateMachineArn: sm.stateMachineArn,
 });
-const executionArn = res.getAttString('executionArn');
-integ.assertions.awsApiCall('StepFunctions', 'describeExecution', {
-  executionArn,
-}).expect(ExpectedResult.objectLike({
-  status: 'SUCCEEDED',
-})).waitForAssertions({
-  totalTimeout: cdk.Duration.seconds(10),
-  interval: cdk.Duration.seconds(3),
+
+// describe the results of the execution
+const describe = testCase.assertions.awsApiCall('StepFunctions', 'describeExecution', {
+  executionArn: start.getAttString('executionArn'),
 });
 
+// assert the results
+describe.expect(ExpectedResult.objectLike({
+  status: 'SUCCEEDED',
+}));
+
 app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.start-job-run.ts

@@ -1,122 +1,124 @@
-import * as ec2 from 'aws-cdk-lib/aws-ec2';
-import * as eks from 'aws-cdk-lib/aws-eks';
-import { AwsAuthMapping } from 'aws-cdk-lib/aws-eks';
+import * as databrew from 'aws-cdk-lib/aws-databrew';
 import * as iam from 'aws-cdk-lib/aws-iam';
+import * as s3 from 'aws-cdk-lib/aws-s3';
 import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
 import * as cdk from 'aws-cdk-lib';
-import { Aws } from 'aws-cdk-lib';
-import * as integ from '@aws-cdk/integ-tests-alpha';
-import { KubectlV31Layer } from '@aws-cdk/lambda-layer-kubectl-v31';
-import { EmrContainersStartJobRun, ReleaseLabel, VirtualClusterInput } from 'aws-cdk-lib/aws-stepfunctions-tasks';
-import { EC2_RESTRICT_DEFAULT_SECURITY_GROUP } from 'aws-cdk-lib/cx-api';
+import { GlueDataBrewStartJobRun } from 'aws-cdk-lib/aws-stepfunctions-tasks';
 
-/**
+/*
  * Stack verification steps:
- * Everything in the link below must be setup before running the state machine.
- * @see https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-enable-IAM.html
- * aws stepfunctions start-execution --state-machine-arn <deployed state machine arn> : should return execution arn
- * aws stepfunctions describe-execution --execution-arn <exection-arn generated before> : should return status as SUCCEEDED
+ * * aws stepfunctions start-execution --state-machine-arn <deployed state machine arn> : should return execution arn
+ * * aws stepfunctions describe-execution --execution-arn <exection-arn generated before> : should return status as SUCCEEDED
  */
 
-const app = new cdk.App({
-  postCliContext: {
-    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
-    '@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy': false,
-  },
-});
-const stack = new cdk.Stack(app, 'aws-stepfunctions-tasks-emr-containers-start-job-run');
-stack.node.setContext(EC2_RESTRICT_DEFAULT_SECURITY_GROUP, false);
+class GlueDataBrewJobStack extends cdk.Stack {
+  constructor(scope: cdk.App, id: string, props: cdk.StackProps = {}) {
+    super(scope, id, props);
 
-const eksCluster = new eks.Cluster(stack, 'integration-test-eks-cluster', {
-  version: eks.KubernetesVersion.V1_30,
-  defaultCapacity: 3,
-  defaultCapacityInstance: ec2.InstanceType.of(ec2.InstanceClass.M5, ec2.InstanceSize.XLARGE),
-  kubectlLayer: new KubectlV31Layer(stack, 'KubectlLayer'),
-});
+    const region = this.region;
 
-const virtualCluster = new cdk.CfnResource(stack, 'Virtual Cluster', {
-  type: 'AWS::EMRContainers::VirtualCluster',
-  properties: {
-    ContainerProvider: {
-      Id: eksCluster.clusterName,
-      Info: {
-        EksInfo: {
-          Namespace: 'default',
-        },
-      },
-      Type: 'EKS',
-    },
-    Name: 'Virtual-Cluster-Name',
-  },
-});
-
-const emrRole = eksCluster.addManifest('emrRole', {
-  apiVersion: 'rbac.authorization.k8s.io/v1',
-  kind: 'Role',
-  metadata: { name: 'emr-containers', namespace: 'default' },
-  rules: [
-    { apiGroups: [''], resources: ['namespaces'], verbs: ['get'] },
-    { apiGroups: [''], resources: ['serviceaccounts', 'services', 'configmaps', 'events', 'pods', 'pods/log'], verbs: ['get', 'list', 'watch', 'describe', 'create', 'edit', 'delete', 'deletecollection', 'annotate', 'patch', 'label'] },
-    { apiGroups: [''], resources: ['secrets'], verbs: ['create', 'patch', 'delete', 'watch'] },
-    { apiGroups: ['apps'], resources: ['statefulsets', 'deployments'], verbs: ['get', 'list', 'watch', 'describe', 'create', 'edit', 'delete', 'annotate', 'patch', 'label'] },
-    { apiGroups: ['batch'], resources: ['jobs'], verbs: ['get', 'list', 'watch', 'describe', 'create', 'edit', 'delete', 'annotate', 'patch', 'label'] },
-    { apiGroups: ['extensions'], resources: ['ingresses'], verbs: ['get', 'list', 'watch', 'describe', 'create', 'edit', 'delete', 'annotate', 'patch', 'label'] },
-    { apiGroups: ['rbac.authorization.k8s.io'], resources: ['roles', 'rolebindings'], verbs: ['get', 'list', 'watch', 'describe', 'create', 'edit', 'delete', 'deletecollection', 'annotate', 'patch', 'label'] },
-  ],
-});
+    const outputBucket = new s3.Bucket(this, 'JobOutputBucket', {
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+    });
 
-const emrRoleBind = eksCluster.addManifest('emrRoleBind', {
-  apiVersion: 'rbac.authorization.k8s.io/v1',
-  kind: 'RoleBinding',
-  metadata: { name: 'emr-containers', namespace: 'default' },
-  subjects: [{ kind: 'User', name: 'emr-containers', apiGroup: 'rbac.authorization.k8s.io' }],
-  roleRef: { kind: 'Role', name: 'emr-containers', apiGroup: 'rbac.authorization.k8s.io' },
-});
+    const role = new iam.Role(this, 'DataBrew Role', {
+      managedPolicies: [{
+        managedPolicyArn: 'arn:aws:iam::aws:policy/service-role/AWSGlueDataBrewServiceRole',
+      }],
+      path: '/',
+      assumedBy: new iam.ServicePrincipal('databrew.amazonaws.com'),
+      inlinePolicies: {
+        DataBrewPolicy: iam.PolicyDocument.fromJson({
+          Statement: [{
+            Effect: 'Allow',
+            Action: [
+              's3:GetObject',
+              's3:PutObject',
+              's3:DeleteObject',
+              's3:ListBucket',
+            ],
+            Resource: [
+              `arn:aws:s3:::databrew-public-datasets-${region}/*`,
+              `arn:aws:s3:::databrew-public-datasets-${region}`,
+              `${outputBucket.bucketArn}/*`,
+              `${outputBucket.bucketArn}`,
+            ],
+          }],
+        }),
+      },
+    });
 
-emrRoleBind.node.addDependency(emrRole);
+    const recipe = new databrew.CfnRecipe(this, 'DataBrew Recipe', {
+      name: 'recipe-1',
+      steps: [
+        {
+          action: {
+            operation: 'UPPER_CASE',
+            parameters: {
+              sourceColumn: 'description',
+            },
+          },
+        },
+        {
+          action: {
+            operation: 'DELETE',
+            parameters: {
+              sourceColumn: 'doc_id',
+            },
+          },
+        },
+      ],
+    });
 
-const emrServiceRole = iam.Role.fromRoleArn(stack, 'emrServiceRole', 'arn:aws:iam::'+Aws.ACCOUNT_ID+':role/AWSServiceRoleForAmazonEMRContainers');
-const authMapping: AwsAuthMapping = { groups: [], username: 'emr-containers' };
-eksCluster.awsAuth.addRoleMapping(emrServiceRole, authMapping);
+    const dataset = new databrew.CfnDataset(this, 'DataBrew Dataset', {
+      input: {
+        s3InputDefinition: {
+          bucket: `databrew-public-datasets-${region}`,
+          key: 'votes.csv',
+        },
+      },
+      name: 'dataset-1',
+    });
 
-virtualCluster.node.addDependency(emrRoleBind);
-virtualCluster.node.addDependency(eksCluster.awsAuth);
+    const project = new databrew.CfnProject(this, 'DataBrew Project', {
+      name: 'project-1',
+      roleArn: role.roleArn,
+      datasetName: dataset.name,
+      recipeName: recipe.name,
+    });
+    project.addDependency(dataset);
+    project.addDependency(recipe);
 
-const startJobRunJob = new EmrContainersStartJobRun(stack, 'Start a Job Run', {
-  virtualCluster: VirtualClusterInput.fromVirtualClusterId(virtualCluster.getAtt('Id').toString()),
-  releaseLabel: ReleaseLabel.EMR_6_2_0,
-  jobName: 'EMR-Containers-Job',
-  jobDriver: {
-    sparkSubmitJobDriver: {
-      entryPoint: sfn.TaskInput.fromText('local:///usr/lib/spark/examples/src/main/python/pi.py'),
-      entryPointArguments: sfn.TaskInput.fromObject(['2']),
-      sparkSubmitParameters: '--conf spark.driver.memory=512M --conf spark.kubernetes.driver.request.cores=0.2 --conf spark.kubernetes.executor.request.cores=0.2 --conf spark.sql.shuffle.partitions=60 --conf spark.dynamicAllocation.enabled=false',
-    },
-  },
-});
+    const job = new databrew.CfnJob(this, 'DataBrew Job', {
+      name: 'job-1',
+      type: 'RECIPE',
+      projectName: project.name,
+      roleArn: role.roleArn,
+      outputs: [{
+        location: {
+          bucket: outputBucket.bucketName,
+        },
+      }],
+    });
+    job.addDependency(project);
 
-const chain = sfn.Chain.start(startJobRunJob);
+    const startGlueDataBrewJob = new GlueDataBrewStartJobRun(this, 'Start DataBrew Job run', {
+      name: job.name,
+    });
 
-const sm = new sfn.StateMachine(stack, 'StateMachine', {
-  definition: chain,
-  timeout: cdk.Duration.seconds(1000),
-});
+    const chain = sfn.Chain.start(startGlueDataBrewJob);
 
-new cdk.CfnOutput(stack, 'stateMachineArn', {
-  value: sm.stateMachineArn,
-});
+    const sm = new sfn.StateMachine(this, 'StateMachine', {
+      definition: chain,
+      timeout: cdk.Duration.seconds(30),
+    });
 
-new integ.IntegTest(app, 'aws-stepfunctions-tasks-emr-containers-start-job-run-integ', {
-  testCases: [stack],
-  // Test includes assets that are updated weekly. If not disabled, the upgrade PR will fail.
-  diffAssets: false,
-  cdkCommandOptions: {
-    deploy: {
-      args: {
-        rollback: true,
-      },
-    },
-  },
-});
+    new cdk.CfnOutput(this, 'stateMachineArn', {
+      value: sm.stateMachineArn,
+    });
+  }
+}
 
+const app = new cdk.App();
+new GlueDataBrewJobStack(app, 'aws-stepfunctions-tasks-databrew-start-job-run-integ');
 app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-synthetics/README.md

@@ -298,6 +298,29 @@ new cloudwatch.Alarm(this, 'CanaryAlarm', {
 });
 ```
 
+### Performing safe canary updates
+
+You can configure a canary to first perform a dry run before applying any updates. The `dryRunAndUpdate` property can be used to safely update canaries by validating the changes before they're applied.
+This feature is supported for canary runtime versions `syn-nodejs-puppeteer-10.0+`, `syn-nodejs-playwright-2.0+`, and `syn-python-selenium-5.1+`.
+
+When `dryRunAndUpdate` is set to `true`, CDK will execute a dry run to validate the changes before applying them to the canary.
+If the dry run succeeds, the canary will be updated with the changes.
+If the dry run fails, the CloudFormation deployment will fail with the dry run's failure reason.
+
+```ts
+const canary = new synthetics.Canary(this, 'MyCanary', {
+  schedule: synthetics.Schedule.rate(Duration.minutes(5)),
+  test: synthetics.Test.custom({
+    code: synthetics.Code.fromAsset(path.join(__dirname, 'canary')),
+    handler: 'index.handler',
+  }),
+  runtime: synthetics.Runtime.SYNTHETICS_PYTHON_SELENIUM_5_1,
+  dryRunAndUpdate: true, // Enable dry run before updating
+});
+```
+
+For more information, see [Performing safe canary updates](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/performing-safe-canary-upgrades.html).
+
 ### Artifacts
 
 You can pass an S3 bucket to store artifacts from canary runs. If you do not,

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-synthetics/integ.canary-dryrun-update.ts

@@ -0,0 +1,32 @@
+import * as path from 'node:path';
+import { App, Duration, Size, Stack, StackProps } from 'aws-cdk-lib/core';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import { Construct } from 'constructs';
+import * as synthetics from 'aws-cdk-lib/aws-synthetics';
+
+class TestStack extends Stack {
+  public canary: synthetics.Canary;
+
+  constructor(scope: Construct, id: string, props?: StackProps) {
+    super(scope, id, props);
+
+    this.canary = new synthetics.Canary(this, 'DryRunCanary', {
+      canaryName: 'dryrun',
+      runtime: synthetics.Runtime.SYNTHETICS_PYTHON_SELENIUM_5_1,
+      test: synthetics.Test.custom({
+        handler: 'canary.handler',
+        code: synthetics.Code.fromAsset(path.join(__dirname, 'canaries')),
+      }),
+      memory: Size.mebibytes(2048),
+      timeout: Duration.minutes(4),
+      dryRunAndUpdate: true,
+    });
+  }
+}
+
+const app = new App();
+const testStack = new TestStack(app, 'SyntheticsCanaryDryRunAndUpdateStack');
+
+new IntegTest(app, 'SyntheticsCanaryDryRunAndUpdate', {
+  testCases: [testStack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-synthetics/integ.canary.ts

@@ -113,6 +113,7 @@ const selenium40 = createCanaryByRuntimes(Runtime.SYNTHETICS_PYTHON_SELENIUM_4_0
 const selenium41 = createCanaryByRuntimes(Runtime.SYNTHETICS_PYTHON_SELENIUM_4_1);
 const selenium50 = createCanaryByRuntimes(Runtime.SYNTHETICS_PYTHON_SELENIUM_5_0);
 const selenium51 = createCanaryByRuntimes(Runtime.SYNTHETICS_PYTHON_SELENIUM_5_1);
+const selenium60 = createCanaryByRuntimes(Runtime.SYNTHETICS_PYTHON_SELENIUM_6_0);
 
 const test = new IntegTest(app, 'IntegCanaryTest', {
   testCases: [stack],
@@ -140,6 +141,7 @@ const test = new IntegTest(app, 'IntegCanaryTest', {
   selenium41,
   selenium50,
   selenium51,
+  selenium60,
 ].forEach((canary) => test.assertions
   .awsApiCall('Synthetics', 'getCanaryRuns', {
     Name: canary.canaryName,

{konokenj_cdk_api_mcp_server-0.25.0.dist-info → konokenj_cdk_api_mcp_server-0.27.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: konokenj.cdk-api-mcp-server
-Version: 0.25.0
+Version: 0.27.0
 Summary: An MCP server provides AWS CDK API Reference
 Project-URL: Documentation, https://github.com/konokenj/cdk-api-mcp-server#readme
 Project-URL: Issues, https://github.com/konokenj/cdk-api-mcp-server/issues