Update dist

Author: GitHub Actions

dist/index.js

@@ -60899,7 +60899,7 @@ function buildUserDataScript(githubRegistrationToken, label) {
   }
 }
 
-async function startEc2Instance(label, githubRegistrationToken) {
+async function startEc2Instances(label, count, githubRegistrationToken) {
   const ec2 = new AWS.EC2();
 
   // User data scripts are run as the root user.
@@ -60909,8 +60909,8 @@ async function startEc2Instance(label, githubRegistrationToken) {
   const params = {
     ImageId: config.input.ec2ImageId,
     InstanceType: config.input.ec2InstanceType,
-    MinCount: 1,
-    MaxCount: 1,
+    MinCount: count,
+    MaxCount: count,
     UserData: Buffer.from(userData.join('\n')).toString('base64'),
     SubnetId: config.input.subnetId,
     SecurityGroupIds: [config.input.securityGroupId],
@@ -60921,53 +60921,53 @@ async function startEc2Instance(label, githubRegistrationToken) {
 
   try {
     const result = await ec2.runInstances(params).promise();
-    const ec2InstanceId = result.Instances[0].InstanceId;
-    core.info(`AWS EC2 instance ${ec2InstanceId} is started`);
-    return ec2InstanceId;
+    const ec2InstanceIds = result.Instances.map(i => i.InstanceId);
+    core.info(`AWS EC2 instances ${JSON.stringify(ec2InstanceIds)} are started`);
+    return ec2InstanceIds;
   } catch (error) {
     core.error('AWS EC2 instance starting error');
     throw error;
   }
 }
 
-async function terminateEc2Instance() {
+async function terminateEc2Instances() {
   const ec2 = new AWS.EC2();
 
   const params = {
-    InstanceIds: [config.input.ec2InstanceId],
+    InstanceIds: config.input.ec2InstanceIds,
   };
 
   try {
     await ec2.terminateInstances(params).promise();
-    core.info(`AWS EC2 instance ${config.input.ec2InstanceId} is terminated`);
+    core.info(`AWS EC2 instances ${JSON.stringify(config.input.ec2InstanceIds)} are terminated`);
     return;
   } catch (error) {
-    core.error(`AWS EC2 instance ${config.input.ec2InstanceId} termination error`);
+    core.error(`AWS EC2 instances ${JSON.stringify(config.input.ec2InstanceIds)} termination error`);
     throw error;
   }
 }
 
-async function waitForInstanceRunning(ec2InstanceId) {
+async function waitForInstancesRunning(ec2InstanceIds) {
   const ec2 = new AWS.EC2();
 
   const params = {
-    InstanceIds: [ec2InstanceId],
+    InstanceIds: ec2InstanceIds,
   };
 
   try {
     await ec2.waitFor('instanceRunning', params).promise();
-    core.info(`AWS EC2 instance ${ec2InstanceId} is up and running`);
+    core.info(`AWS EC2 instances ${JSON.stringify(ec2InstanceIds)} are up and running`);
     return;
   } catch (error) {
-    core.error(`AWS EC2 instance ${ec2InstanceId} initialization error`);
+    core.error(`AWS EC2 instances ${JSON.stringify(ec2InstanceIds)} initialization error`);
     throw error;
   }
 }
 
 module.exports = {
-  startEc2Instance,
-  terminateEc2Instance,
-  waitForInstanceRunning,
+  startEc2Instances,
+  terminateEc2Instances,
+  waitForInstancesRunning,
 };
 
 
@@ -60986,10 +60986,11 @@ class Config {
       githubToken: core.getInput('github-token'),
       ec2ImageId: core.getInput('ec2-image-id'),
       ec2InstanceType: core.getInput('ec2-instance-type'),
+      ec2InstanceCount: core.getInput('ec2-instance-count'),
       subnetId: core.getInput('subnet-id'),
       securityGroupId: core.getInput('security-group-id'),
       label: core.getInput('label'),
-      ec2InstanceId: core.getInput('ec2-instance-id'),
+      ec2InstanceIds: core.getInput('ec2-instance-id'),
       iamRoleName: core.getInput('iam-role-name'),
       keyPairName: core.getInput('key-pair-name'),
       runnerHomeDir: core.getInput('runner-home-dir')
@@ -61025,10 +61026,29 @@ class Config {
       if (!this.input.ec2ImageId || !this.input.ec2InstanceType || !this.input.subnetId || !this.input.securityGroupId || !this.input.keyPairName) {
         throw new Error(`Not all the required inputs are provided for the 'start' mode`);
       }
+
+      if (this.input.ec2InstanceCount === undefined) {
+        this.input.ec2InstanceCount = 1;
+      }
+      const parsedEc2InstanceCount = parseInt(this.input.ec2InstanceCount);
+      if (isNaN(parsedEc2InstanceCount)) {
+        throw new Error(`The 'ec2-instance-count' input has illegal value '${this.input.ec2InstanceCount}'`);
+      } else if (parsedEc2InstanceCount < 1) {
+        throw new Error(`The 'ec2-instance-count' input must be greater than zero`);
+      }
+      this.input.ec2InstanceCount = parsedEc2InstanceCount;
     } else if (this.input.mode === 'stop') {
-      if (!this.input.label || !this.input.ec2InstanceId) {
+      if (!this.input.label || !this.input.ec2InstanceIds) {
         throw new Error(`Not all the required inputs are provided for the 'stop' mode`);
       }
+
+      try {
+        const parsedEc2InstanceIds = JSON.parse(this.input.ec2InstanceIds);
+        this.input.ec2InstanceIds = parsedEc2InstanceIds;
+      } catch (error) {
+        core.info(`Got error ${error} when parsing '${this.input.ec2InstanceIds}' as JSON, assuming that it is a raw string containing a single EC2 instance ID`);
+        this.input.ec2InstanceIds = [this.input.ec2InstanceIds];
+      }
     } else {
       throw new Error('Wrong mode. Allowed values: start, stop.');
     }
@@ -61059,15 +61079,15 @@ const config = __webpack_require__(34570);
 
 // use the unique label to find the runner
 // as we don't have the runner's id, it's not possible to get it in any other way
-async function getRunner(label) {
+async function getRunners(label) {
   const octokit = github.getOctokit(config.input.githubToken);
 
   try {
     const runners = await octokit.paginate('GET /repos/{owner}/{repo}/actions/runners', config.githubContext);
-    const foundRunners = _.filter(runners, { labels: [{ name: label }] });
-    return foundRunners.length > 0 ? foundRunners[0] : null;
+    return _.filter(runners, { labels: [{ name: label }] });
   } catch (error) {
-    return null;
+    core.error(`Error fetching current runners: ${error}`)
+    return [];
   }
 }
 
@@ -61085,48 +61105,48 @@ async function getRegistrationToken() {
   }
 }
 
-async function removeRunner() {
-  const runner = await getRunner(config.input.label);
+async function removeRunners() {
+  const runners = await getRunners(config.input.label);
   const octokit = github.getOctokit(config.input.githubToken);
 
   // skip the runner removal process if the runner is not found
-  if (!runner) {
-    core.info(`GitHub self-hosted runner with label ${config.input.label} is not found, so the removal is skipped`);
+  if (!runners || runners.length === 0) {
+    core.info(`GitHub self-hosted runners with label ${config.input.label} are not found, so the removal is skipped`);
     return;
   }
 
   try {
-    await octokit.request('DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}', _.merge(config.githubContext, { runner_id: runner.id }));
-    core.info(`GitHub self-hosted runner ${runner.name} is removed`);
+    await Promise.all(runners.map(r => octokit.request('DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}', _.merge(config.githubContext, { runner_id: r.id }))));
+    core.info(`GitHub self-hosted runners ${runners.map(r => r.name)} are removed`);
     return;
   } catch (error) {
-    core.error('GitHub self-hosted runner removal error');
+    core.error('GitHub self-hosted runners removal error');
     throw error;
   }
 }
 
-async function waitForRunnerRegistered(label) {
+async function waitForRunnersRegistered(label, expectedRunnerCount) {
   const timeoutMinutes = 5;
   const retryIntervalSeconds = 10;
   const quietPeriodSeconds = 30;
   let waitSeconds = 0;
 
-  core.info(`Waiting ${quietPeriodSeconds}s for the AWS EC2 instance to be registered in GitHub as a new self-hosted runner`);
+  core.info(`Waiting ${quietPeriodSeconds}s for the AWS EC2 instances to be registered in GitHub as the new self-hosted runners`);
   await new Promise(r => setTimeout(r, quietPeriodSeconds * 1000));
-  core.info(`Checking every ${retryIntervalSeconds}s if the GitHub self-hosted runner is registered`);
+  core.info(`Checking every ${retryIntervalSeconds}s if the GitHub self-hosted runners are registered`);
 
   return new Promise((resolve, reject) => {
     const interval = setInterval(async () => {
-      const runner = await getRunner(label);
+      const runners = await getRunners(label);
 
       if (waitSeconds > timeoutMinutes * 60) {
-        core.error('GitHub self-hosted runner registration error');
+        core.error('GitHub self-hosted runners registration error');
         clearInterval(interval);
-        reject(`A timeout of ${timeoutMinutes} minutes is exceeded. Your AWS EC2 instance was not able to register itself in GitHub as a new self-hosted runner.`);
+        reject(`A timeout of ${timeoutMinutes} minutes is exceeded. Your AWS EC2 instances were not able to register themselves in GitHub as the new self-hosted runners.`);
       }
 
-      if (runner && runner.status === 'online') {
-        core.info(`GitHub self-hosted runner ${runner.name} is registered and ready to use`);
+      if (runners && runners.length == expectedRunnerCount && runners.every(r => r.status === 'online')) {
+        core.info(`GitHub self-hosted runners ${JSON.stringify(runners.map(r => r.name))} are registered and ready to use`);
         clearInterval(interval);
         resolve();
       } else {
@@ -61139,8 +61159,8 @@ async function waitForRunnerRegistered(label) {
 
 module.exports = {
   getRegistrationToken,
-  removeRunner,
-  waitForRunnerRegistered,
+  removeRunners,
+  waitForRunnersRegistered,
 };
 
 
@@ -61154,23 +61174,23 @@ const gh = __webpack_require__(56989);
 const config = __webpack_require__(34570);
 const core = __webpack_require__(42186);
 
-function setOutput(label, ec2InstanceId) {
+function setOutput(label, ec2InstanceIds) {
   core.setOutput('label', label);
-  core.setOutput('ec2-instance-id', ec2InstanceId);
+  core.setOutput('ec2-instance-id', JSON.stringify(ec2InstanceIds));
 }
 
 async function start() {
   const label = config.generateUniqueLabel();
   const githubRegistrationToken = await gh.getRegistrationToken();
-  const ec2InstanceId = await aws.startEc2Instance(label, githubRegistrationToken);
-  setOutput(label, ec2InstanceId);
-  await aws.waitForInstanceRunning(ec2InstanceId);
-  await gh.waitForRunnerRegistered(label);
+  const ec2InstanceIds = await aws.startEc2Instances(label, config.input.ec2InstanceCount, githubRegistrationToken);
+  setOutput(label, ec2InstanceIds);
+  await aws.waitForInstancesRunning(ec2InstanceIds);
+  await gh.waitForRunnersRegistered(label, config.input.ec2InstanceCount);
 }
 
 async function stop() {
-  await aws.terminateEc2Instance();
-  await gh.removeRunner();
+  await aws.terminateEc2Instances();
+  await gh.removeRunners();
 }
 
 (async function () {