code cleanup

Author: npalm

lambdas/functions/webhook/src/ConfigLoader.ts

@@ -125,10 +125,11 @@ export class ConfigWebhookEventBridge extends BaseConfig {
 export class ConfigDispatcher extends BaseConfig {
   repositoryAllowList: string[] = [];
   matcherConfig: RunnerMatcherConfig[] = [];
-  workflowJobEventSecondaryQueue: string = ''; // Deprecated, not loaded
+  workflowJobEventSecondaryQueue: string = ''; // Deprecated
 
   async loadConfig(): Promise<void> {
     this.loadEnvVar(process.env.REPOSITORY_ALLOW_LIST, 'repositoryAllowList', []);
+    this.loadEnvVar(process.env.SQS_WORKFLOW_JOB_QUEUE, 'workflowJobEventSecondaryQueue', '');
     await this.loadParameter(process.env.PARAMETER_RUNNER_MATCHER_CONFIG_PATH, 'matcherConfig');
 
     validateRunnerMatcherConfig(this);

lambdas/functions/webhook/src/eventbridge/index.test.ts

@@ -14,7 +14,7 @@ beforeEach(() => {
   nock.disableNetConnect();
 });
 
-describe('Test publish', () => {
+describe('Test EventBridge adapter', () => {
   test('Test publish without errors', async () => {
     // Arrange
     const output: PutEventsCommandOutput = {

lambdas/functions/webhook/src/lambda.test.ts

@@ -4,7 +4,7 @@ import { mocked } from 'jest-mock';
 import { WorkflowJobEvent } from '@octokit/webhooks-types';
 
 import { dispatchToRunners, eventBridgeWebhook, directWebhook } from './lambda';
-import { handle, publishOnEventBridge } from './webhook';
+import { publishForRunners, publishOnEventBridge } from './webhook';
 import ValidationError from './ValidationError';
 import { getParameter } from '@aws-github-runner/aws-ssm-util';
 import { dispatch } from './runners/dispatch';
@@ -91,7 +91,7 @@ describe('Test webhook lambda wrapper.', () => {
 
   describe('Test webhook lambda wrapper.', () => {
     it('Happy flow, resolve.', async () => {
-      const mock = mocked(handle);
+      const mock = mocked(publishForRunners);
       mock.mockImplementation(() => {
         return new Promise((resolve) => {
           resolve({ body: 'test', statusCode: 200 });
@@ -103,15 +103,15 @@ describe('Test webhook lambda wrapper.', () => {
     });
 
     it('An expected error, resolve.', async () => {
-      const mock = mocked(handle);
+      const mock = mocked(publishForRunners);
       mock.mockRejectedValue(new ValidationError(400, 'some error'));
 
       const result = await directWebhook(event, context);
       expect(result).toMatchObject({ body: 'some error', statusCode: 400 });
     });
 
     it('Errors are not thrown.', async () => {
-      const mock = mocked(handle);
+      const mock = mocked(publishForRunners);
       const logSpy = jest.spyOn(logger, 'error');
       mock.mockRejectedValue(new Error('some error'));
       const result = await directWebhook(event, context);

lambdas/functions/webhook/src/lambda.ts

@@ -2,7 +2,7 @@ import middy from '@middy/core';
 import { logger, setContext, captureLambdaHandler, tracer } from '@aws-github-runner/aws-powertools-util';
 import { APIGatewayEvent, Context } from 'aws-lambda';
 
-import { handle, publishOnEventBridge } from './webhook';
+import { publishForRunners, publishOnEventBridge } from './webhook';
 import { IncomingHttpHeaders } from 'http';
 import ValidationError from './ValidationError';
 import { EventWrapper } from './types';
@@ -24,7 +24,7 @@ export async function directWebhook(event: APIGatewayEvent, context: Context): P
   let result: Response;
   try {
     const config: ConfigWebhook = await ConfigWebhook.load();
-    result = await handle(headersToLowerCase(event.headers), event.body as string, config);
+    result = await publishForRunners(headersToLowerCase(event.headers), event.body as string, config);
   } catch (e) {
     logger.error(`Failed to handle webhook event`, { error: e });
     if (e instanceof ValidationError) {

lambdas/functions/webhook/src/local.ts

@@ -1,7 +1,7 @@
 import bodyParser from 'body-parser';
 import express from 'express';
 
-import { handle } from './webhook';
+import { publishForRunners } from './webhook';
 import { ConfigWebhook } from './ConfigLoader';
 
 const app = express();
@@ -10,7 +10,7 @@ app.use(bodyParser.json());
 
 app.post('/event_handler', async (req, res) => {
   const config: ConfigWebhook = await ConfigWebhook.load();
-  handle(req.headers, JSON.stringify(req.body), config)
+  publishForRunners(req.headers, JSON.stringify(req.body), config)
     .then((c) => res.status(c.statusCode).end())
     .catch((e) => {
       console.log(e);

lambdas/functions/webhook/src/webhook/index.test.ts

@@ -5,7 +5,7 @@ import nock from 'nock';
 
 import workFlowJobEvent from '../../test/resources/github_workflowjob_event.json';
 
-import { checkBodySize, handle, publishOnEventBridge } from '.';
+import { checkBodySize, publishForRunners, publishOnEventBridge } from '.';
 import { dispatch } from '../runners/dispatch';
 import { IncomingHttpHeaders } from 'http';
 import { ConfigWebhook, ConfigWebhookEventBridge } from '../ConfigLoader';
@@ -43,7 +43,7 @@ describe('handle GitHub webhook events', () => {
     });
 
     it('should return 500 if no signature available', async () => {
-      await expect(handle({}, '', config)).rejects.toMatchObject({
+      await expect(publishForRunners({}, '', config)).rejects.toMatchObject({
         statusCode: 500,
       });
     });
@@ -57,7 +57,7 @@ describe('handle GitHub webhook events', () => {
       const event = JSON.stringify(workFlowJobEvent);
 
       // act and assert
-      const result = handle(
+      const result = publishForRunners(
         {
           'X-Hub-Signature-256': await webhooks.sign(event),
           'X-GitHub-Event': 'workflow_job',
@@ -76,7 +76,7 @@ describe('handle GitHub webhook events', () => {
       const other = JSON.stringify({ ...workFlowJobEvent, action: 'mutated' });
 
       await expect(
-        handle({ 'X-Hub-Signature-256': await webhooks.sign(other), 'X-GitHub-Event': 'workflow_job' }, event, config),
+        publishForRunners({ 'X-Hub-Signature-256': await webhooks.sign(other), 'X-GitHub-Event': 'workflow_job' }, event, config),
       ).rejects.toMatchObject({
         statusCode: 401,
       });
@@ -86,7 +86,7 @@ describe('handle GitHub webhook events', () => {
       const event = JSON.stringify(workFlowJobEvent);
 
       await expect(
-        handle({ 'X-Hub-Signature-256': await webhooks.sign(event), 'X-GitHub-Event': 'invalid' }, event, config),
+        publishForRunners({ 'X-Hub-Signature-256': await webhooks.sign(event), 'X-GitHub-Event': 'invalid' }, event, config),
       ).rejects.toMatchObject({
         statusCode: 202,
       });
@@ -100,7 +100,7 @@ describe('handle GitHub webhook events', () => {
       });
 
       await expect(
-        handle({ 'X-Hub-Signature-256': await webhooks.sign(event), 'X-GitHub-Event': 'workflow_job' }, event, config),
+        publishForRunners({ 'X-Hub-Signature-256': await webhooks.sign(event), 'X-GitHub-Event': 'workflow_job' }, event, config),
       ).resolves.toMatchObject({
         statusCode: 201,
       });

lambdas/functions/webhook/src/webhook/index.ts

@@ -10,7 +10,7 @@ import { publish } from '../eventbridge';
 import { ConfigWebhook, ConfigWebhookEventBridge } from '../ConfigLoader';
 const logger = createChildLogger('handler');
 
-export async function handle(headers: IncomingHttpHeaders, body: string, config: ConfigWebhook): Promise<Response> {
+export async function publishForRunners(headers: IncomingHttpHeaders, body: string, config: ConfigWebhook): Promise<Response> {
   init(headers);
 
   await verifySignature(headers, body, config.webhookSecret);