All files / src/handlers RuleConfigScheduler.ts

100% Statements 59/59
100% Branches 6/6
100% Functions 15/15
100% Lines 56/56

Press n or j to go to the next uncovered block, b, p or k for the previous block.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137                                3x             3x           3x 3x 3x   3x           3x           3x 3x 3x   3x               6x   6x 6x   6x         6x 6x   9x         9x 9x 9x     6x 9x 9x 9x     6x 9x   8x 8x   8x 6x 6x   6x 9x 1x 1x 6x 6x 6x 11x   6x 6x   6x 1x         5x 5x       6x 6x 11x 11x 9x   2x     6x   6x 9x 11x        
/* 
  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  
  Licensed under the Apache License, Version 2.0 (the "License").
  You may not use this file except in compliance with the License.
  You may obtain a copy of the License at
  
      http://www.apache.org/licenses/LICENSE-2.0
  
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
*/
 
import {
    InvocationType,
    InvokeCommand,
    InvokeCommandInput,
    LambdaClient,
} from '@aws-sdk/client-lambda';
import * as lambda from 'aws-lambda';
import {
    BasicHttpResponse as ServerlessResponse,
    FlowRuleBundle,
    Logger,
    LoggerFactory,
} from 'shared_types';
import { AppConfiguration } from 'src/common/configuration/AppConfiguration';
import { inject, injectable } from 'tsyringe';
import { TextDecoder, TextEncoder } from 'util';
import { AsyncRequestHandler } from '../common/AsyncRequestHandler';
import { DDBdataSourceService } from '../service/DDBdataSourceService';
export type ConfigurationEvaluationTriggerEvent = {
    ruleBundleId: string;
};
 
@injectable()
export class RuleConfigScheduler
    implements AsyncRequestHandler<lambda.ScheduledEvent, ServerlessResponse> {
    private readonly logger: Logger;
 
    constructor(
        @inject('LoggerFactory') loggerFactory: LoggerFactory,
        @inject('DDBdataSourceService') private dataSourceService: DDBdataSourceService,
        @inject('AppConfiguration') private appConfiguration: AppConfiguration,
        @inject('LambdaClient') private lambdaClient: LambdaClient
    ) {
        this.logger = loggerFactory.getLogger('RuleConfigHandler');
    }
 
    async handle(
        event: lambda.ScheduledEvent,
        // eslint-disable-next-line @typescript-eslint/no-unused-vars
        _context: lambda.Context
    ): Promise<ServerlessResponse> {
        this.logger.info('lambda event', event);
 
        const ruleGroups = await this.dataSourceService.getRuleBundles();
        const triggerEvents = this.generateTriggerEvents(ruleGroups);
 
        const result = {} as ScheduleResult;
        type ScheduleResult = {
            succeeded: string[];
            failed: string[];
        };
        this.logger.info('triggerEvents', triggerEvents);
        const responses = await Promise.all(
            triggerEvents.map(async (triggerEvent) => {
                const input: InvokeCommandInput = {
                    FunctionName: this.appConfiguration.autoConfigFunctionName,
                    InvocationType: InvocationType.RequestResponse,
                    Payload: new TextEncoder().encode(JSON.stringify(triggerEvent)),
                };
                this.logger.info('request evaluating', triggerEvent);
                const invokeCmd = new InvokeCommand(input);
                return this.lambdaClient.send(invokeCmd);
            })
        );
        const allResponses = responses.map((r) => {
            const responseJson = JSON.parse(new TextDecoder().decode(r.Payload));
            this.logger.info('got response from remote  ', responseJson);
            return responseJson;
        });
 
        const allSuccessfulInvocations = allResponses
            .filter((rp) => rp.statusCode === 200)
            .map((rp) => {
                const jsonbody = JSON.parse(rp.body);
                return jsonbody.ruleBundleIds;
            })
            .flatMap((i) => i);
        this.logger.debug('successed invocation info', allSuccessfulInvocations);
        result.succeeded = allSuccessfulInvocations;
 
        const failed = allResponses
            .filter((rp) => rp.statusCode != 200)
            .map((rp) => JSON.parse(rp.body).ruleBundleIds)
            .flatMap((i) => i);
        result.failed = failed;
        this.logger.debug('processedResult info', result);
        const successfulInvocations = ruleGroups.filter((rg) =>
            result.succeeded.includes(rg.id)
        );
        this.logger.debug('recording info successedInvocations ', successfulInvocations);
        this.dataSourceService.updateRuleGroupTimeStamps(successfulInvocations);
 
        if (result.failed && result.failed.length > 0) {
            throw new Error(
                `Encounter error while evaluated rule bundles ${result.failed}`
            );
        }
 
        this.logger.info('invocation result', result);
        return ServerlessResponse.ofObject(200, result);
    }
 
    private generateTriggerEvents(ruleGroups: FlowRuleBundle[]) {
        const map = new Map<string, FlowRuleBundle[]>();
        ruleGroups.forEach((i) => {
            const ids = map.get(i.ruleGroupArn);
            if (!ids) {
                map.set(i.ruleGroupArn, [i]);
            } else {
                ids.push(i);
            }
        });
        this.logger.info('ruleGroups', ruleGroups);
 
        const allGroupIds = Array.from(map.values());
        return allGroupIds.map((rg) => ({
            ruleBundleIds: rg.map((x) => x.id),
        }));
    }
}