ci: add tests for Unity 6 and build profiles

add new `buildProfile` action param, which will be passed into
Unity as the `-activeBuildProfile ...` CLI param.

closes https://github.com/game-ci/unity-builder/issues/674

package.json

@@ -32,11 +32,6 @@
     "@actions/core": "^1.11.1",
     "@actions/exec": "^1.1.1",
     "@actions/github": "^6.0.0",
-    "@aws-sdk/client-cloudformation": "^3.777.0",
-    "@aws-sdk/client-cloudwatch-logs": "^3.777.0",
-    "@aws-sdk/client-ecs": "^3.778.0",
-    "@aws-sdk/client-kinesis": "^3.777.0",
-    "@aws-sdk/client-s3": "^3.779.0",
     "@kubernetes/client-node": "^0.16.3",
     "@octokit/core": "^5.1.0",
     "async-wait-until": "^2.0.12",

src/model/cloud-runner/providers/aws/aws-base-stack.ts

@@ -1,18 +1,6 @@
 import CloudRunnerLogger from '../../services/core/cloud-runner-logger';
 import * as core from '@actions/core';
-import {
+import * as SDK from 'aws-sdk';
-  CloudFormation,
-  CreateStackCommand,
-  CreateStackCommandInput,
-  DescribeStacksCommand,
-  DescribeStacksCommandInput,
-  ListStacksCommand,
-  Parameter,
-  UpdateStackCommand,
-  UpdateStackCommandInput,
-  waitUntilStackCreateComplete,
-  waitUntilStackUpdateComplete,
-} from '@aws-sdk/client-cloudformation';
 import { BaseStackFormation } from './cloud-formations/base-stack-formation';
 import crypto from 'node:crypto';
 
@@ -22,49 +10,51 @@ export class AWSBaseStack {
   }
   private baseStackName: string;
 
-  async setupBaseStack(CF: CloudFormation) {
+  async setupBaseStack(CF: SDK.CloudFormation) {
     const baseStackName = this.baseStackName;
 
     const baseStack = BaseStackFormation.formation;
 
     // Cloud Formation Input
-    const describeStackInput: DescribeStacksCommandInput = {
+    const describeStackInput: SDK.CloudFormation.DescribeStacksInput = {
       StackName: baseStackName,
     };
-    const parametersWithoutHash: Parameter[] = [{ ParameterKey: 'EnvironmentName', ParameterValue: baseStackName }];
+    const parametersWithoutHash: SDK.CloudFormation.Parameter[] = [
+      { ParameterKey: 'EnvironmentName', ParameterValue: baseStackName },
+    ];
     const parametersHash = crypto
       .createHash('md5')
       .update(baseStack + JSON.stringify(parametersWithoutHash))
       .digest('hex');
-    const parameters: Parameter[] = [
+    const parameters: SDK.CloudFormation.Parameter[] = [
       ...parametersWithoutHash,
       ...[{ ParameterKey: 'Version', ParameterValue: parametersHash }],
     ];
-    const updateInput: UpdateStackCommandInput = {
+    const updateInput: SDK.CloudFormation.UpdateStackInput = {
       StackName: baseStackName,
       TemplateBody: baseStack,
       Parameters: parameters,
       Capabilities: ['CAPABILITY_IAM'],
     };
-    const createStackInput: CreateStackCommandInput = {
+    const createStackInput: SDK.CloudFormation.CreateStackInput = {
       StackName: baseStackName,
       TemplateBody: baseStack,
       Parameters: parameters,
       Capabilities: ['CAPABILITY_IAM'],
     };
 
-    const stacks = await CF.send(
+    const stacks = await CF.listStacks({
-      new ListStacksCommand({ StackStatusFilter: ['UPDATE_COMPLETE', 'CREATE_COMPLETE', 'ROLLBACK_COMPLETE'] }),
+      StackStatusFilter: ['UPDATE_COMPLETE', 'CREATE_COMPLETE', 'ROLLBACK_COMPLETE'],
-    );
+    }).promise();
     const stackNames = stacks.StackSummaries?.map((x) => x.StackName) || [];
     const stackExists: Boolean = stackNames.includes(baseStackName) || false;
     const describeStack = async () => {
-      return await CF.send(new DescribeStacksCommand(describeStackInput));
+      return await CF.describeStacks(describeStackInput).promise();
     };
     try {
       if (!stackExists) {
         CloudRunnerLogger.log(`${baseStackName} stack does not exist (${JSON.stringify(stackNames)})`);
-        await CF.send(new CreateStackCommand(createStackInput));
+        await CF.createStack(createStackInput).promise();
         CloudRunnerLogger.log(`created stack (version: ${parametersHash})`);
       }
       const CFState = await describeStack();
@@ -75,13 +65,7 @@ export class AWSBaseStack {
       const stackVersion = stack.Parameters?.find((x) => x.ParameterKey === 'Version')?.ParameterValue;
 
       if (stack.StackStatus === 'CREATE_IN_PROGRESS') {
-        await waitUntilStackCreateComplete(
+        await CF.waitFor('stackCreateComplete', describeStackInput).promise();
-          {
-            client: CF,
-            maxWaitTime: 200,
-          },
-          describeStackInput,
-        );
       }
 
       if (stackExists) {
@@ -89,7 +73,7 @@ export class AWSBaseStack {
         if (parametersHash !== stackVersion) {
           CloudRunnerLogger.log(`Attempting update of base stack`);
           try {
-            await CF.send(new UpdateStackCommand(updateInput));
+            await CF.updateStack(updateInput).promise();
           } catch (error: any) {
             if (error['message'].includes('No updates are to be performed')) {
               CloudRunnerLogger.log(`No updates are to be performed`);
@@ -109,13 +93,7 @@ export class AWSBaseStack {
           );
         }
         if (stack.StackStatus === 'UPDATE_IN_PROGRESS') {
-          await waitUntilStackUpdateComplete(
+          await CF.waitFor('stackUpdateComplete', describeStackInput).promise();
-            {
-              client: CF,
-              maxWaitTime: 200,
-            },
-            describeStackInput,
-          );
         }
       }
       CloudRunnerLogger.log('base stack is now ready');

src/model/cloud-runner/providers/aws/aws-error.ts

@@ -1,15 +1,15 @@
 import CloudRunnerLogger from '../../services/core/cloud-runner-logger';
-import { CloudFormation, DescribeStackEventsCommand } from '@aws-sdk/client-cloudformation';
+import * as SDK from 'aws-sdk';
 import * as core from '@actions/core';
 import CloudRunner from '../../cloud-runner';
 
 export class AWSError {
-  static async handleStackCreationFailure(error: any, CF: CloudFormation, taskDefStackName: string) {
+  static async handleStackCreationFailure(error: any, CF: SDK.CloudFormation, taskDefStackName: string) {
     CloudRunnerLogger.log('aws error: ');
     core.error(JSON.stringify(error, undefined, 4));
     if (CloudRunner.buildParameters.cloudRunnerDebug) {
       CloudRunnerLogger.log('Getting events and resources for task stack');
-      const events = (await CF.send(new DescribeStackEventsCommand({ StackName: taskDefStackName }))).StackEvents;
+      const events = (await CF.describeStackEvents({ StackName: taskDefStackName }).promise()).StackEvents;
       CloudRunnerLogger.log(JSON.stringify(events, undefined, 4));
     }
   }

src/model/cloud-runner/providers/aws/aws-job-stack.ts

@@ -1,12 +1,4 @@
-import {
+import * as SDK from 'aws-sdk';
-  CloudFormation,
-  CreateStackCommand,
-  CreateStackCommandInput,
-  DescribeStackResourcesCommand,
-  DescribeStacksCommand,
-  ListStacksCommand,
-  waitUntilStackCreateComplete,
-} from '@aws-sdk/client-cloudformation';
 import CloudRunnerAWSTaskDef from './cloud-runner-aws-task-def';
 import CloudRunnerSecret from '../../options/cloud-runner-secret';
 import { AWSCloudFormationTemplates } from './aws-cloud-formation-templates';
@@ -24,7 +16,7 @@ export class AWSJobStack {
   }
 
   public async setupCloudFormations(
-    CF: CloudFormation,
+    CF: SDK.CloudFormation,
     buildGuid: string,
     image: string,
     entrypoint: string[],
@@ -127,7 +119,7 @@ export class AWSJobStack {
     let previousStackExists = true;
     while (previousStackExists) {
       previousStackExists = false;
-      const stacks = await CF.send(new ListStacksCommand({}));
+      const stacks = await CF.listStacks().promise();
       if (!stacks.StackSummaries) {
         throw new Error('Faild to get stacks');
       }
@@ -140,7 +132,7 @@ export class AWSJobStack {
         }
       }
     }
-    const createStackInput: CreateStackCommandInput = {
+    const createStackInput: SDK.CloudFormation.CreateStackInput = {
       StackName: taskDefStackName,
       TemplateBody: taskDefCloudFormation,
       Capabilities: ['CAPABILITY_IAM'],
@@ -148,15 +140,9 @@ export class AWSJobStack {
     };
     try {
       CloudRunnerLogger.log(`Creating job aws formation ${taskDefStackName}`);
-      await CF.send(new CreateStackCommand(createStackInput));
+      await CF.createStack(createStackInput).promise();
-      await waitUntilStackCreateComplete(
+      await CF.waitFor('stackCreateComplete', { StackName: taskDefStackName }).promise();
-        {
+      const describeStack = await CF.describeStacks({ StackName: taskDefStackName }).promise();
-          client: CF,
-          maxWaitTime: 200,
-        },
-        { StackName: taskDefStackName },
-      );
-      const describeStack = await CF.send(new DescribeStacksCommand({ StackName: taskDefStackName }));
       for (const parameter of parameters) {
         if (!describeStack.Stacks?.[0].Parameters?.some((x) => x.ParameterKey === parameter.ParameterKey)) {
           throw new Error(`Parameter ${parameter.ParameterKey} not found in stack`);
@@ -167,7 +153,7 @@ export class AWSJobStack {
       throw error;
     }
 
-    const createCleanupStackInput: CreateStackCommandInput = {
+    const createCleanupStackInput: SDK.CloudFormation.CreateStackInput = {
       StackName: `${taskDefStackName}-cleanup`,
       TemplateBody: CleanupCronFormation.formation,
       Capabilities: ['CAPABILITY_IAM'],
@@ -197,7 +183,7 @@ export class AWSJobStack {
     if (CloudRunnerOptions.useCleanupCron) {
       try {
         CloudRunnerLogger.log(`Creating job cleanup formation`);
-        await CF.send(new CreateStackCommand(createCleanupStackInput));
+        await CF.createStack(createCleanupStackInput).promise();
 
         // await CF.waitFor('stackCreateComplete', { StackName: createCleanupStackInput.StackName }).promise();
       } catch (error) {
@@ -207,15 +193,12 @@ export class AWSJobStack {
     }
 
     const taskDefResources = (
-      await CF.send(
+      await CF.describeStackResources({
-        new DescribeStackResourcesCommand({
+        StackName: taskDefStackName,
-          StackName: taskDefStackName,
+      }).promise()
-        }),
-      )
     ).StackResources;
 
-    const baseResources = (await CF.send(new DescribeStackResourcesCommand({ StackName: this.baseStackName })))
+    const baseResources = (await CF.describeStackResources({ StackName: this.baseStackName }).promise()).StackResources;
-      .StackResources;
 
     return {
       taskDefStackName,

src/model/cloud-runner/providers/aws/aws-task-runner.ts

@@ -1,19 +1,4 @@
-import {
+import * as AWS from 'aws-sdk';
-  DescribeTasksCommand,
-  ECS,
-  RunTaskCommand,
-  RunTaskCommandInput,
-  Task,
-  waitUntilTasksRunning,
-} from '@aws-sdk/client-ecs';
-import {
-  DescribeStreamCommand,
-  DescribeStreamCommandOutput,
-  GetRecordsCommand,
-  GetRecordsCommandOutput,
-  GetShardIteratorCommand,
-  Kinesis,
-} from '@aws-sdk/client-kinesis';
 import CloudRunnerEnvironmentVariable from '../../options/cloud-runner-environment-variable';
 import * as core from '@actions/core';
 import CloudRunnerAWSTaskDef from './cloud-runner-aws-task-def';
@@ -27,8 +12,8 @@ import CloudRunnerOptions from '../../options/cloud-runner-options';
 import GitHub from '../../../github';
 
 class AWSTaskRunner {
-  public static ECS: ECS;
+  public static ECS: AWS.ECS;
-  public static Kinesis: Kinesis;
+  public static Kinesis: AWS.Kinesis;
   private static readonly encodedUnderscore = `$252F`;
   static async runTask(
     taskDef: CloudRunnerAWSTaskDef,
@@ -75,7 +60,7 @@ class AWSTaskRunner {
       throw new Error(`Container Overrides length must be at most 8192`);
     }
 
-    const task = await AWSTaskRunner.ECS.send(new RunTaskCommand(runParameters as RunTaskCommandInput));
+    const task = await AWSTaskRunner.ECS.runTask(runParameters).promise();
     const taskArn = task.tasks?.[0].taskArn || '';
     CloudRunnerLogger.log('Cloud runner job is starting');
     await AWSTaskRunner.waitUntilTaskRunning(taskArn, cluster);
@@ -123,13 +108,7 @@ class AWSTaskRunner {
 
   private static async waitUntilTaskRunning(taskArn: string, cluster: string) {
     try {
-      await waitUntilTasksRunning(
+      await AWSTaskRunner.ECS.waitFor('tasksRunning', { tasks: [taskArn], cluster }).promise();
-        {
-          client: AWSTaskRunner.ECS,
-          maxWaitTime: 120,
-        },
-        { tasks: [taskArn], cluster },
-      );
     } catch (error_) {
       const error = error_ as Error;
       await new Promise((resolve) => setTimeout(resolve, 3000));
@@ -145,7 +124,10 @@ class AWSTaskRunner {
   }
 
   static async describeTasks(clusterName: string, taskArn: string) {
-    const tasks = await AWSTaskRunner.ECS.send(new DescribeTasksCommand({ cluster: clusterName, tasks: [taskArn] }));
+    const tasks = await AWSTaskRunner.ECS.describeTasks({
+      cluster: clusterName,
+      tasks: [taskArn],
+    }).promise();
     if (tasks.tasks?.[0]) {
       return tasks.tasks?.[0];
     } else {
@@ -187,7 +169,9 @@ class AWSTaskRunner {
     output: string,
     shouldCleanup: boolean,
   ) {
-    const records = await AWSTaskRunner.Kinesis.send(new GetRecordsCommand({ ShardIterator: iterator }));
+    const records = await AWSTaskRunner.Kinesis.getRecords({
+      ShardIterator: iterator,
+    }).promise();
     iterator = records.NextShardIterator || '';
     ({ shouldReadLogs, output, shouldCleanup } = AWSTaskRunner.logRecords(
       records,
@@ -200,7 +184,7 @@ class AWSTaskRunner {
     return { iterator, shouldReadLogs, output, shouldCleanup };
   }
 
-  private static checkStreamingShouldContinue(taskData: Task, timestamp: number, shouldReadLogs: boolean) {
+  private static checkStreamingShouldContinue(taskData: AWS.ECS.Task, timestamp: number, shouldReadLogs: boolean) {
     if (taskData?.lastStatus === 'UNKNOWN') {
       CloudRunnerLogger.log('## Cloud runner job unknwon');
     }
@@ -220,17 +204,15 @@ class AWSTaskRunner {
   }
 
   private static logRecords(
-    records: GetRecordsCommandOutput,
+    records: AWS.Kinesis.GetRecordsOutput,
     iterator: string,
     shouldReadLogs: boolean,
     output: string,
     shouldCleanup: boolean,
   ) {
-    if ((records.Records ?? []).length > 0 && iterator) {
+    if (records.Records.length > 0 && iterator) {
-      for (const record of records.Records ?? []) {
+      for (const record of records.Records) {
-        const json = JSON.parse(
+        const json = JSON.parse(zlib.gunzipSync(Buffer.from(record.Data as string, 'base64')).toString('utf8'));
-          zlib.gunzipSync(Buffer.from(record.Data as unknown as string, 'base64')).toString('utf8'),
-        );
         if (json.messageType === 'DATA_MESSAGE') {
           for (const logEvent of json.logEvents) {
             ({ shouldReadLogs, shouldCleanup, output } = FollowLogStreamService.handleIteration(
@@ -248,19 +230,19 @@ class AWSTaskRunner {
   }
 
   private static async getLogStream(kinesisStreamName: string) {
-    return await AWSTaskRunner.Kinesis.send(new DescribeStreamCommand({ StreamName: kinesisStreamName }));
+    return await AWSTaskRunner.Kinesis.describeStream({
+      StreamName: kinesisStreamName,
+    }).promise();
   }
 
-  private static async getLogIterator(stream: DescribeStreamCommandOutput) {
+  private static async getLogIterator(stream: AWS.Kinesis.DescribeStreamOutput) {
     return (
       (
-        await AWSTaskRunner.Kinesis.send(
+        await AWSTaskRunner.Kinesis.getShardIterator({
-          new GetShardIteratorCommand({
+          ShardIteratorType: 'TRIM_HORIZON',
-            ShardIteratorType: 'TRIM_HORIZON',
+          StreamName: stream.StreamDescription.StreamName,
-            StreamName: stream.StreamDescription?.StreamName ?? '',
+          ShardId: stream.StreamDescription.Shards[0].ShardId,
-            ShardId: stream.StreamDescription?.Shards?.[0]?.ShardId || '',
+        }).promise()
-          }),
-        )
       ).ShardIterator || ''
     );
   }

src/model/cloud-runner/providers/aws/cloud-runner-aws-task-def.ts

@@ -1,9 +1,9 @@
-import { StackResource } from '@aws-sdk/client-cloudformation';
+import * as AWS from 'aws-sdk';
 
 class CloudRunnerAWSTaskDef {
   public taskDefStackName!: string;
   public taskDefCloudFormation!: string;
-  public taskDefResources: StackResource[] | undefined;
+  public taskDefResources: AWS.CloudFormation.StackResources | undefined;
-  public baseResources: StackResource[] | undefined;
+  public baseResources: AWS.CloudFormation.StackResources | undefined;
 }
 export default CloudRunnerAWSTaskDef;

src/model/cloud-runner/providers/aws/index.ts

@@ -1,6 +1,4 @@
-import { CloudFormation, DeleteStackCommand, waitUntilStackDeleteComplete } from '@aws-sdk/client-cloudformation';
+import * as SDK from 'aws-sdk';
-import { ECS as ECSClient } from '@aws-sdk/client-ecs';
-import { Kinesis } from '@aws-sdk/client-kinesis';
 import CloudRunnerSecret from '../../options/cloud-runner-secret';
 import CloudRunnerEnvironmentVariable from '../../options/cloud-runner-environment-variable';
 import CloudRunnerAWSTaskDef from './cloud-runner-aws-task-def';
@@ -77,7 +75,7 @@ class AWSBuildEnvironment implements ProviderInterface {
     defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
   ) {
     process.env.AWS_REGION = Input.region;
-    const CF = new CloudFormation({ region: Input.region });
+    const CF = new SDK.CloudFormation();
     await new AwsBaseStack(this.baseStackName).setupBaseStack(CF);
   }
 
@@ -91,10 +89,10 @@ class AWSBuildEnvironment implements ProviderInterface {
     secrets: CloudRunnerSecret[],
   ): Promise<string> {
     process.env.AWS_REGION = Input.region;
-    const ECS = new ECSClient({ region: Input.region });
+    const ECS = new SDK.ECS();
-    const CF = new CloudFormation({ region: Input.region });
+    const CF = new SDK.CloudFormation();
     AwsTaskRunner.ECS = ECS;
-    AwsTaskRunner.Kinesis = new Kinesis({ region: Input.region });
+    AwsTaskRunner.Kinesis = new SDK.Kinesis();
     CloudRunnerLogger.log(`AWS Region: ${CF.config.region}`);
     const entrypoint = ['/bin/sh'];
     const startTimeMs = Date.now();
@@ -131,31 +129,23 @@ class AWSBuildEnvironment implements ProviderInterface {
     }
   }
 
-  async cleanupResources(CF: CloudFormation, taskDef: CloudRunnerAWSTaskDef) {
+  async cleanupResources(CF: SDK.CloudFormation, taskDef: CloudRunnerAWSTaskDef) {
     CloudRunnerLogger.log('Cleanup starting');
-    await CF.send(new DeleteStackCommand({ StackName: taskDef.taskDefStackName }));
+    await CF.deleteStack({
+      StackName: taskDef.taskDefStackName,
+    }).promise();
     if (CloudRunnerOptions.useCleanupCron) {
-      await CF.send(new DeleteStackCommand({ StackName: `${taskDef.taskDefStackName}-cleanup` }));
+      await CF.deleteStack({
+        StackName: `${taskDef.taskDefStackName}-cleanup`,
+      }).promise();
     }
 
-    await waitUntilStackDeleteComplete(
+    await CF.waitFor('stackDeleteComplete', {
-      {
+      StackName: taskDef.taskDefStackName,
-        client: CF,
+    }).promise();
-        maxWaitTime: 200,
+    await CF.waitFor('stackDeleteComplete', {
-      },
+      StackName: `${taskDef.taskDefStackName}-cleanup`,
-      {
+    }).promise();
-        StackName: taskDef.taskDefStackName,
-      },
-    );
-    await waitUntilStackDeleteComplete(
-      {
-        client: CF,
-        maxWaitTime: 200,
-      },
-      {
-        StackName: `${taskDef.taskDefStackName}-cleanup`,
-      },
-    );
     CloudRunnerLogger.log(`Deleted Stack: ${taskDef.taskDefStackName}`);
     CloudRunnerLogger.log('Cleanup complete');
   }

src/model/cloud-runner/providers/aws/services/garbage-collection-service.ts

@@ -1,11 +1,4 @@
-import {
+import AWS from 'aws-sdk';
-  CloudFormation,
-  DeleteStackCommand,
-  DeleteStackCommandInput,
-  DescribeStackResourcesCommand,
-} from '@aws-sdk/client-cloudformation';
-import { CloudWatchLogs, DeleteLogGroupCommand } from '@aws-sdk/client-cloudwatch-logs';
-import { ECS, StopTaskCommand } from '@aws-sdk/client-ecs';
 import Input from '../../../../input';
 import CloudRunnerLogger from '../../../services/core/cloud-runner-logger';
 import { TaskService } from './task-service';
@@ -19,9 +12,9 @@ export class GarbageCollectionService {
 
   public static async cleanup(deleteResources = false, OneDayOlderOnly: boolean = false) {
     process.env.AWS_REGION = Input.region;
-    const CF = new CloudFormation({ region: Input.region });
+    const CF = new AWS.CloudFormation();
-    const ecs = new ECS({ region: Input.region });
+    const ecs = new AWS.ECS();
-    const cwl = new CloudWatchLogs({ region: Input.region });
+    const cwl = new AWS.CloudWatchLogs();
     const taskDefinitionsInUse = new Array();
     const tasks = await TaskService.getTasks();
 
@@ -30,14 +23,14 @@ export class GarbageCollectionService {
       taskDefinitionsInUse.push(taskElement.taskDefinitionArn);
       if (deleteResources && (!OneDayOlderOnly || GarbageCollectionService.isOlderThan1day(taskElement.createdAt!))) {
         CloudRunnerLogger.log(`Stopping task ${taskElement.containers?.[0].name}`);
-        await ecs.send(new StopTaskCommand({ task: taskElement.taskArn || '', cluster: element }));
+        await ecs.stopTask({ task: taskElement.taskArn || '', cluster: element }).promise();
       }
     }
 
     const jobStacks = await TaskService.getCloudFormationJobStacks();
     for (const element of jobStacks) {
       if (
-        (await CF.send(new DescribeStackResourcesCommand({ StackName: element.StackName }))).StackResources?.some(
+        (await CF.describeStackResources({ StackName: element.StackName }).promise()).StackResources?.some(
           (x) => x.ResourceType === 'AWS::ECS::TaskDefinition' && taskDefinitionsInUse.includes(x.PhysicalResourceId),
         )
       ) {
@@ -46,10 +39,7 @@ export class GarbageCollectionService {
         return;
       }
 
-      if (
+      if (deleteResources && (!OneDayOlderOnly || GarbageCollectionService.isOlderThan1day(element.CreationTime))) {
-        deleteResources &&
-        (!OneDayOlderOnly || (element.CreationTime && GarbageCollectionService.isOlderThan1day(element.CreationTime)))
-      ) {
         if (element.StackName === 'game-ci' || element.TemplateDescription === 'Game-CI base stack') {
           CloudRunnerLogger.log(`Skipping ${element.StackName} ignore list`);
 
@@ -57,8 +47,8 @@ export class GarbageCollectionService {
         }
 
         CloudRunnerLogger.log(`Deleting ${element.StackName}`);
-        const deleteStackInput: DeleteStackCommandInput = { StackName: element.StackName };
+        const deleteStackInput: AWS.CloudFormation.DeleteStackInput = { StackName: element.StackName };
-        await CF.send(new DeleteStackCommand(deleteStackInput));
+        await CF.deleteStack(deleteStackInput).promise();
       }
     }
     const logGroups = await TaskService.getLogGroups();
@@ -68,7 +58,7 @@ export class GarbageCollectionService {
         (!OneDayOlderOnly || GarbageCollectionService.isOlderThan1day(new Date(element.creationTime!)))
       ) {
         CloudRunnerLogger.log(`Deleting ${element.logGroupName}`);
-        await cwl.send(new DeleteLogGroupCommand({ logGroupName: element.logGroupName || '' }));
+        await cwl.deleteLogGroup({ logGroupName: element.logGroupName || '' }).promise();
       }
     }
 

src/model/cloud-runner/providers/aws/services/task-service.ts

@@ -1,31 +1,12 @@
-import {
+import AWS from 'aws-sdk';
-  CloudFormation,
-  DescribeStackResourcesCommand,
-  DescribeStacksCommand,
-  ListStacksCommand,
-  StackSummary,
-} from '@aws-sdk/client-cloudformation';
-import {
-  CloudWatchLogs,
-  DescribeLogGroupsCommand,
-  DescribeLogGroupsCommandInput,
-  LogGroup,
-} from '@aws-sdk/client-cloudwatch-logs';
-import {
-  DescribeTasksCommand,
-  DescribeTasksCommandInput,
-  ECS,
-  ListClustersCommand,
-  ListTasksCommand,
-  ListTasksCommandInput,
-  Task,
-} from '@aws-sdk/client-ecs';
-import { ListObjectsCommand, ListObjectsCommandInput, S3 } from '@aws-sdk/client-s3';
 import Input from '../../../../input';
 import CloudRunnerLogger from '../../../services/core/cloud-runner-logger';
 import { BaseStackFormation } from '../cloud-formations/base-stack-formation';
 import AwsTaskRunner from '../aws-task-runner';
+import { ListObjectsRequest } from 'aws-sdk/clients/s3';
 import CloudRunner from '../../../cloud-runner';
+import { StackSummaries } from 'aws-sdk/clients/cloudformation';
+import { LogGroups } from 'aws-sdk/clients/cloudwatchlogs';
 
 export class TaskService {
   static async watch() {
@@ -39,24 +20,20 @@ export class TaskService {
     return output;
   }
   public static async getCloudFormationJobStacks() {
-    const result: StackSummary[] = [];
+    const result: StackSummaries = [];
     CloudRunnerLogger.log(``);
     CloudRunnerLogger.log(`List Cloud Formation Stacks`);
     process.env.AWS_REGION = Input.region;
-    const CF = new CloudFormation({ region: Input.region });
+    const CF = new AWS.CloudFormation();
     const stacks =
-      (await CF.send(new ListStacksCommand({}))).StackSummaries?.filter(
+      (await CF.listStacks().promise()).StackSummaries?.filter(
         (_x) =>
           _x.StackStatus !== 'DELETE_COMPLETE' && _x.TemplateDescription !== BaseStackFormation.baseStackDecription,
       ) || [];
     CloudRunnerLogger.log(``);
     CloudRunnerLogger.log(`Cloud Formation Stacks ${stacks.length}`);
     for (const element of stacks) {
-      if (!element.CreationTime) {
+      const ageDate: Date = new Date(Date.now() - element.CreationTime.getTime());
-        CloudRunnerLogger.log(`${element.StackName} due to undefined CreationTime`);
-      }
-
-      const ageDate: Date = new Date(Date.now() - (element.CreationTime?.getTime() ?? 0));
 
       CloudRunnerLogger.log(
         `Task Stack ${element.StackName} - Age D${Math.floor(
@@ -66,18 +43,14 @@ export class TaskService {
       result.push(element);
     }
     const baseStacks =
-      (await CF.send(new ListStacksCommand({}))).StackSummaries?.filter(
+      (await CF.listStacks().promise()).StackSummaries?.filter(
         (_x) =>
           _x.StackStatus !== 'DELETE_COMPLETE' && _x.TemplateDescription === BaseStackFormation.baseStackDecription,
       ) || [];
     CloudRunnerLogger.log(``);
     CloudRunnerLogger.log(`Base Stacks ${baseStacks.length}`);
     for (const element of baseStacks) {
-      if (!element.CreationTime) {
+      const ageDate: Date = new Date(Date.now() - element.CreationTime.getTime());
-        CloudRunnerLogger.log(`${element.StackName} due to undefined CreationTime`);
-      }
-
-      const ageDate: Date = new Date(Date.now() - (element.CreationTime?.getTime() ?? 0));
 
       CloudRunnerLogger.log(
         `Task Stack ${element.StackName} - Age D${Math.floor(
@@ -91,22 +64,22 @@ export class TaskService {
     return result;
   }
   public static async getTasks() {
-    const result: { taskElement: Task; element: string }[] = [];
+    const result: { taskElement: AWS.ECS.Task; element: string }[] = [];
     CloudRunnerLogger.log(``);
     CloudRunnerLogger.log(`List Tasks`);
     process.env.AWS_REGION = Input.region;
-    const ecs = new ECS({ region: Input.region });
+    const ecs = new AWS.ECS();
-    const clusters = (await ecs.send(new ListClustersCommand({}))).clusterArns || [];
+    const clusters = (await ecs.listClusters().promise()).clusterArns || [];
     CloudRunnerLogger.log(`Task Clusters ${clusters.length}`);
     for (const element of clusters) {
-      const input: ListTasksCommandInput = {
+      const input: AWS.ECS.ListTasksRequest = {
         cluster: element,
       };
 
-      const list = (await ecs.send(new ListTasksCommand(input))).taskArns || [];
+      const list = (await ecs.listTasks(input).promise()).taskArns || [];
       if (list.length > 0) {
-        const describeInput: DescribeTasksCommandInput = { tasks: list, cluster: element };
+        const describeInput: AWS.ECS.DescribeTasksRequest = { tasks: list, cluster: element };
-        const describeList = (await ecs.send(new DescribeTasksCommand(describeInput))).tasks || [];
+        const describeList = (await ecs.describeTasks(describeInput).promise()).tasks || [];
         if (describeList.length === 0) {
           CloudRunnerLogger.log(`No Tasks`);
           continue;
@@ -132,48 +105,37 @@ export class TaskService {
   }
   public static async awsDescribeJob(job: string) {
     process.env.AWS_REGION = Input.region;
-    const CF = new CloudFormation({ region: Input.region });
+    const CF = new AWS.CloudFormation();
-    try {
+    const stack = (await CF.listStacks().promise()).StackSummaries?.find((_x) => _x.StackName === job) || undefined;
-      const stack =
+    const stackInfo = (await CF.describeStackResources({ StackName: job }).promise()) || undefined;
-        (await CF.send(new ListStacksCommand({}))).StackSummaries?.find((_x) => _x.StackName === job) || undefined;
+    const stackInfo2 = (await CF.describeStacks({ StackName: job }).promise()) || undefined;
-      const stackInfo = (await CF.send(new DescribeStackResourcesCommand({ StackName: job }))) || undefined;
+    if (stack === undefined) {
-      const stackInfo2 = (await CF.send(new DescribeStacksCommand({ StackName: job }))) || undefined;
+      throw new Error('stack not defined');
-      if (stack === undefined) {
+    }
-        throw new Error('stack not defined');
+    const ageDate: Date = new Date(Date.now() - stack.CreationTime.getTime());
-      }
+    const message = `
-      if (!stack.CreationTime) {
-        CloudRunnerLogger.log(`${stack.StackName} due to undefined CreationTime`);
-      }
-      const ageDate: Date = new Date(Date.now() - (stack.CreationTime?.getTime() ?? 0));
-      const message = `
     Task Stack ${stack.StackName}
     Age D${Math.floor(ageDate.getHours() / 24)} H${ageDate.getHours()} M${ageDate.getMinutes()}
     ${JSON.stringify(stack, undefined, 4)}
     ${JSON.stringify(stackInfo, undefined, 4)}
     ${JSON.stringify(stackInfo2, undefined, 4)}
     `;
-      CloudRunnerLogger.log(message);
+    CloudRunnerLogger.log(message);
 
-      return message;
+    return message;
-    } catch (error) {
-      CloudRunnerLogger.error(
-        `Failed to describe job ${job}: ${error instanceof Error ? error.message : String(error)}`,
-      );
-      throw error;
-    }
   }
   public static async getLogGroups() {
-    const result: Array<LogGroup> = [];
+    const result: LogGroups = [];
     process.env.AWS_REGION = Input.region;
-    const ecs = new CloudWatchLogs();
+    const ecs = new AWS.CloudWatchLogs();
-    let logStreamInput: DescribeLogGroupsCommandInput = {
+    let logStreamInput: AWS.CloudWatchLogs.DescribeLogGroupsRequest = {
       /* logGroupNamePrefix: 'game-ci' */
     };
-    let logGroupsDescribe = await ecs.send(new DescribeLogGroupsCommand(logStreamInput));
+    let logGroupsDescribe = await ecs.describeLogGroups(logStreamInput).promise();
     const logGroups = logGroupsDescribe.logGroups || [];
     while (logGroupsDescribe.nextToken) {
       logStreamInput = { /* logGroupNamePrefix: 'game-ci',*/ nextToken: logGroupsDescribe.nextToken };
-      logGroupsDescribe = await ecs.send(new DescribeLogGroupsCommand(logStreamInput));
+      logGroupsDescribe = await ecs.describeLogGroups(logStreamInput).promise();
       logGroups.push(...(logGroupsDescribe?.logGroups || []));
     }
 
@@ -197,12 +159,11 @@ export class TaskService {
   }
   public static async getLocks() {
     process.env.AWS_REGION = Input.region;
-    const s3 = new S3({ region: Input.region });
+    const s3 = new AWS.S3();
-    const listRequest: ListObjectsCommandInput = {
+    const listRequest: ListObjectsRequest = {
       Bucket: CloudRunner.buildParameters.awsStackName,
     };
-
+    const results = await s3.listObjects(listRequest).promise();
-    const results = await s3.send(new ListObjectsCommand(listRequest));
 
     return results.Contents || [];
   }