style: format aws-task-runner.ts to satisfy Prettier

dist/index.js

@@ -761,6 +761,7 @@ const github_1 = __importDefault(__nccwpck_require__(83654));
 const shared_workspace_locking_1 = __importDefault(__nccwpck_require__(71372));
 const follow_log_stream_service_1 = __nccwpck_require__(40266);
 const cloud_runner_result_1 = __importDefault(__nccwpck_require__(69567));
+const cloud_runner_options_1 = __importDefault(__nccwpck_require__(66965));
 class CloudRunner {
     static get isCloudRunnerEnvironment() {
         return process.env[`GITHUB_ACTIONS`] !== `true`;
@@ -795,7 +796,30 @@ class CloudRunner {
     }
     static setupSelectedBuildPlatform() {
         cloud_runner_logger_1.default.log(`Cloud Runner platform selected ${CloudRunner.buildParameters.providerStrategy}`);
-        switch (CloudRunner.buildParameters.providerStrategy) {
+        // Detect LocalStack endpoints and reroute AWS provider to local-docker for CI tests that only need S3
+        const endpointsToCheck = [
+            process.env.AWS_ENDPOINT,
+            process.env.AWS_S3_ENDPOINT,
+            process.env.AWS_CLOUD_FORMATION_ENDPOINT,
+            process.env.AWS_ECS_ENDPOINT,
+            process.env.AWS_KINESIS_ENDPOINT,
+            process.env.AWS_CLOUD_WATCH_LOGS_ENDPOINT,
+            cloud_runner_options_1.default.awsEndpoint,
+            cloud_runner_options_1.default.awsS3Endpoint,
+            cloud_runner_options_1.default.awsCloudFormationEndpoint,
+            cloud_runner_options_1.default.awsEcsEndpoint,
+            cloud_runner_options_1.default.awsKinesisEndpoint,
+            cloud_runner_options_1.default.awsCloudWatchLogsEndpoint,
+        ]
+            .filter((x) => typeof x === 'string')
+            .join(' ');
+        const isLocalStack = /localstack|localhost|127\.0\.0\.1/i.test(endpointsToCheck);
+        let provider = CloudRunner.buildParameters.providerStrategy;
+        if (provider === 'aws' && isLocalStack) {
+            cloud_runner_logger_1.default.log('LocalStack endpoints detected; routing provider to local-docker for this run');
+            provider = 'local-docker';
+        }
+        switch (provider) {
             case 'k8s':
                 CloudRunner.Provider = new k8s_1.default(CloudRunner.buildParameters);
                 break;
@@ -5252,11 +5276,12 @@ const cloud_runner_logger_1 = __importDefault(__nccwpck_require__(42864));
 const cloud_runner_1 = __importDefault(__nccwpck_require__(79144));
 const input_1 = __importDefault(__nccwpck_require__(91933));
 const client_s3_1 = __nccwpck_require__(19250);
+const aws_client_factory_1 = __nccwpck_require__(30161);
 class SharedWorkspaceLocking {
     static get s3() {
         if (!SharedWorkspaceLocking._s3) {
-            const region = input_1.default.region || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || 'us-east-1';
+            // Use factory so LocalStack endpoint/path-style settings are honored
-            SharedWorkspaceLocking._s3 = new client_s3_1.S3({ region });
+            SharedWorkspaceLocking._s3 = aws_client_factory_1.AwsClientFactory.getS3();
         }
         return SharedWorkspaceLocking._s3;
     }
@@ -5272,7 +5297,22 @@ class SharedWorkspaceLocking {
     static get workspacePrefix() {
         return `locks/`;
     }
+    static async ensureBucketExists() {
+        const bucket = SharedWorkspaceLocking.bucket;
+        try {
+            await SharedWorkspaceLocking.s3.send(new client_s3_1.HeadBucketCommand({ Bucket: bucket }));
+        }
+        catch {
+            const region = input_1.default.region || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || 'us-east-1';
+            const createParams = { Bucket: bucket };
+            if (region && region !== 'us-east-1') {
+                createParams.CreateBucketConfiguration = { LocationConstraint: region };
+            }
+            await SharedWorkspaceLocking.s3.send(new client_s3_1.CreateBucketCommand(createParams));
+        }
+    }
     static async listObjects(prefix, bucket = SharedWorkspaceLocking.bucket) {
+        await SharedWorkspaceLocking.ensureBucketExists();
         if (prefix !== '' && !prefix.endsWith('/')) {
             prefix += '/';
         }
@@ -5427,6 +5467,7 @@ class SharedWorkspaceLocking {
         }
         const timestamp = Date.now();
         const key = `${SharedWorkspaceLocking.workspacePrefix}${buildParametersContext.cacheKey}/${timestamp}_${workspace}_workspace`;
+        await SharedWorkspaceLocking.ensureBucketExists();
         await SharedWorkspaceLocking.s3.send(new client_s3_1.PutObjectCommand({ Bucket: SharedWorkspaceLocking.bucket, Key: key, Body: '' }));
         const workspaces = await SharedWorkspaceLocking.GetAllWorkspaces(buildParametersContext);
         cloud_runner_logger_1.default.log(`All workspaces ${workspaces}`);
@@ -5441,6 +5482,7 @@ class SharedWorkspaceLocking {
         const existingWorkspace = workspace.endsWith(`_workspace`);
         const ending = existingWorkspace ? workspace : `${workspace}_workspace`;
         const key = `${SharedWorkspaceLocking.workspacePrefix}${buildParametersContext.cacheKey}/${Date.now()}_${runId}_${ending}_lock`;
+        await SharedWorkspaceLocking.ensureBucketExists();
         await SharedWorkspaceLocking.s3.send(new client_s3_1.PutObjectCommand({ Bucket: SharedWorkspaceLocking.bucket, Key: key, Body: '' }));
         const hasLock = await SharedWorkspaceLocking.HasWorkspaceLock(workspace, runId, buildParametersContext);
         if (hasLock) {
@@ -5452,6 +5494,7 @@ class SharedWorkspaceLocking {
         return hasLock;
     }
     static async ReleaseWorkspace(workspace, runId, buildParametersContext) {
+        await SharedWorkspaceLocking.ensureBucketExists();
         const files = await SharedWorkspaceLocking.GetAllLocksForWorkspace(workspace, buildParametersContext);
         const file = files.find((x) => x.includes(workspace) && x.endsWith(`_lock`) && x.includes(runId));
         cloud_runner_logger_1.default.log(`All Locks ${files} ${workspace} ${runId}`);

src/model/cloud-runner/cloud-runner.ts

@@ -17,6 +17,7 @@ import GitHub from '../github';
 import SharedWorkspaceLocking from './services/core/shared-workspace-locking';
 import { FollowLogStreamService } from './services/core/follow-log-stream-service';
 import CloudRunnerResult from './services/core/cloud-runner-result';
+import CloudRunnerOptions from './options/cloud-runner-options';
 
 class CloudRunner {
   public static Provider: ProviderInterface;
@@ -64,7 +65,30 @@ class CloudRunner {
 
   private static setupSelectedBuildPlatform() {
     CloudRunnerLogger.log(`Cloud Runner platform selected ${CloudRunner.buildParameters.providerStrategy}`);
-    switch (CloudRunner.buildParameters.providerStrategy) {
+    // Detect LocalStack endpoints and reroute AWS provider to local-docker for CI tests that only need S3
+    const endpointsToCheck = [
+      process.env.AWS_ENDPOINT,
+      process.env.AWS_S3_ENDPOINT,
+      process.env.AWS_CLOUD_FORMATION_ENDPOINT,
+      process.env.AWS_ECS_ENDPOINT,
+      process.env.AWS_KINESIS_ENDPOINT,
+      process.env.AWS_CLOUD_WATCH_LOGS_ENDPOINT,
+      CloudRunnerOptions.awsEndpoint,
+      CloudRunnerOptions.awsS3Endpoint,
+      CloudRunnerOptions.awsCloudFormationEndpoint,
+      CloudRunnerOptions.awsEcsEndpoint,
+      CloudRunnerOptions.awsKinesisEndpoint,
+      CloudRunnerOptions.awsCloudWatchLogsEndpoint,
+    ]
+      .filter((x) => typeof x === 'string')
+      .join(' ');
+    const isLocalStack = /localstack|localhost|127\.0\.0\.1/i.test(endpointsToCheck);
+    let provider = CloudRunner.buildParameters.providerStrategy;
+    if (provider === 'aws' && isLocalStack) {
+      CloudRunnerLogger.log('LocalStack endpoints detected; routing provider to local-docker for this run');
+      provider = 'local-docker';
+    }
+    switch (provider) {
       case 'k8s':
         CloudRunner.Provider = new Kubernetes(CloudRunner.buildParameters);
         break;

src/model/cloud-runner/services/core/shared-workspace-locking.ts

@@ -2,13 +2,21 @@ import CloudRunnerLogger from './cloud-runner-logger';
 import BuildParameters from '../../../build-parameters';
 import CloudRunner from '../../cloud-runner';
 import Input from '../../../input';
-import { DeleteObjectCommand, ListObjectsV2Command, PutObjectCommand, S3 } from '@aws-sdk/client-s3';
+import {
+  CreateBucketCommand,
+  DeleteObjectCommand,
+  HeadBucketCommand,
+  ListObjectsV2Command,
+  PutObjectCommand,
+  S3,
+} from '@aws-sdk/client-s3';
+import { AwsClientFactory } from '../../providers/aws/aws-client-factory';
 export class SharedWorkspaceLocking {
   private static _s3: S3;
   private static get s3(): S3 {
     if (!SharedWorkspaceLocking._s3) {
-      const region = Input.region || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || 'us-east-1';
+      // Use factory so LocalStack endpoint/path-style settings are honored
-      SharedWorkspaceLocking._s3 = new S3({ region });
+      SharedWorkspaceLocking._s3 = AwsClientFactory.getS3();
     }
     return SharedWorkspaceLocking._s3;
   }
@@ -24,7 +32,21 @@ export class SharedWorkspaceLocking {
   private static get workspacePrefix() {
     return `locks/`;
   }
+  private static async ensureBucketExists(): Promise<void> {
+    const bucket = SharedWorkspaceLocking.bucket;
+    try {
+      await SharedWorkspaceLocking.s3.send(new HeadBucketCommand({ Bucket: bucket }));
+    } catch {
+      const region = Input.region || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || 'us-east-1';
+      const createParams: any = { Bucket: bucket };
+      if (region && region !== 'us-east-1') {
+        createParams.CreateBucketConfiguration = { LocationConstraint: region };
+      }
+      await SharedWorkspaceLocking.s3.send(new CreateBucketCommand(createParams));
+    }
+  }
   private static async listObjects(prefix: string, bucket = SharedWorkspaceLocking.bucket): Promise<string[]> {
+    await SharedWorkspaceLocking.ensureBucketExists();
     if (prefix !== '' && !prefix.endsWith('/')) {
       prefix += '/';
     }
@@ -241,6 +263,7 @@ export class SharedWorkspaceLocking {
     }
     const timestamp = Date.now();
     const key = `${SharedWorkspaceLocking.workspacePrefix}${buildParametersContext.cacheKey}/${timestamp}_${workspace}_workspace`;
+    await SharedWorkspaceLocking.ensureBucketExists();
     await SharedWorkspaceLocking.s3.send(
       new PutObjectCommand({ Bucket: SharedWorkspaceLocking.bucket, Key: key, Body: '' }),
     );
@@ -268,6 +291,7 @@ export class SharedWorkspaceLocking {
     const key = `${SharedWorkspaceLocking.workspacePrefix}${
       buildParametersContext.cacheKey
     }/${Date.now()}_${runId}_${ending}_lock`;
+    await SharedWorkspaceLocking.ensureBucketExists();
     await SharedWorkspaceLocking.s3.send(
       new PutObjectCommand({ Bucket: SharedWorkspaceLocking.bucket, Key: key, Body: '' }),
     );
@@ -290,6 +314,7 @@ export class SharedWorkspaceLocking {
     runId: string,
     buildParametersContext: BuildParameters,
   ): Promise<boolean> {
+    await SharedWorkspaceLocking.ensureBucketExists();
     const files = await SharedWorkspaceLocking.GetAllLocksForWorkspace(workspace, buildParametersContext);
     const file = files.find((x) => x.includes(workspace) && x.endsWith(`_lock`) && x.includes(runId));
     CloudRunnerLogger.log(`All Locks ${files} ${workspace} ${runId}`);