carlin 1.19.11 → 1.19.13

package/dist/deploy/cicd/lambdas/githubWebhooksApiV1.handler.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.githubWebhooksApiV1Handler = exports.webhooks = void 0;
+const tslib_1 = require("tslib");
+const pipelines_1 = require("../pipelines");
+const aws_sdk_1 = require("aws-sdk");
+const webhooks_1 = require("@octokit/webhooks");
+const executeTasks_1 = require("./executeTasks");
+const getProcessEnvVariable_1 = require("./getProcessEnvVariable");
+const getTriggerPipelineObjectKey_1 = require("../getTriggerPipelineObjectKey");
+const shConditionalCommands_1 = require("./shConditionalCommands");
+const adm_zip_1 = tslib_1.__importDefault(require("adm-zip"));
+const s3 = new aws_sdk_1.S3();
+/**
+ * When this file is saved on S3, a CodePipeline pipeline is started.
+ */
+const putJobDetails = async ({ pipeline, details, }) => {
+    const prefix = (0, getProcessEnvVariable_1.getProcessEnvVariable)('TRIGGER_PIPELINES_OBJECT_KEY_PREFIX');
+    const zip = new adm_zip_1.default();
+    const content = JSON.stringify(details);
+    zip.addFile(pipeline, Buffer.from(content));
+    return s3
+        .putObject({
+        Body: zip.toBuffer(),
+        Bucket: (0, getProcessEnvVariable_1.getProcessEnvVariable)('BASE_STACK_BUCKET_NAME'),
+        Key: (0, getTriggerPipelineObjectKey_1.getTriggerPipelinesObjectKey)({ prefix, pipeline }),
+    })
+        .promise();
+};
+/**
+ * Put outside of the handler to be able to spy on it.
+ */
+exports.webhooks = new webhooks_1.Webhooks({ secret: '123' });
+const getPipelines = () => {
+    const pipelines = JSON.parse(process.env.PIPELINES_JSON || JSON.stringify([]));
+    return pipelines;
+};
+exports.webhooks.on('push', async (details) => {
+    if (!getPipelines().includes('tag')) {
+        return;
+    }
+    if (details.payload.ref.startsWith('refs/tags/')) {
+        await putJobDetails({ pipeline: 'tag', details });
+    }
+});
+exports.webhooks.on('push', async (details) => {
+    if (!getPipelines().includes('main')) {
+        return;
+    }
+    if (details.payload.ref === 'refs/heads/main') {
+        await putJobDetails({ pipeline: 'main', details });
+    }
+});
+exports.webhooks.on(['pull_request.opened', 'pull_request.reopened', 'pull_request.synchronize'], async ({ payload }) => {
+    if (!getPipelines().includes('pr')) {
+        return;
+    }
+    if (payload.pull_request.draft) {
+        return;
+    }
+    await (0, executeTasks_1.executeTasks)({
+        commands: [
+            (0, shConditionalCommands_1.shConditionalCommands)({
+                conditionalCommands: (0, pipelines_1.getPrCommands)({
+                    branch: payload.pull_request.head.ref,
+                }),
+            }),
+        ],
+        tags: [
+            { key: 'Pipeline', value: 'pr' },
+            { key: 'PullRequest', value: payload.number.toString() },
+            { key: 'PullRequestUrl', value: payload.pull_request.url },
+            { key: 'Action', value: payload.action },
+            { key: 'Branch', value: payload.pull_request.head.ref },
+        ],
+    });
+});
+exports.webhooks.on(['pull_request.closed'], async ({ payload }) => {
+    if (!getPipelines().includes('pr')) {
+        return;
+    }
+    /**
+     * https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-cpu-memory-error.html
+     */
+    await (0, executeTasks_1.executeTasks)({
+        cpu: '512',
+        memory: '2048',
+        commands: [
+            (0, shConditionalCommands_1.shConditionalCommands)({
+                conditionalCommands: (0, pipelines_1.getClosedPrCommands)({
+                    branch: payload.pull_request.head.ref,
+                }),
+            }),
+        ],
+        tags: [
+            { key: 'Pipeline', value: 'pr' },
+            { key: 'PullRequest', value: payload.number.toString() },
+            { key: 'PullRequestTitle', value: payload.pull_request.title },
+            { key: 'PullRequestUrl', value: payload.pull_request.url },
+            { key: 'Action', value: payload.action },
+            { key: 'Branch', value: payload.pull_request.head.ref },
+        ],
+    });
+});
+const githubWebhooksApiV1Handler = async (event, context) => {
+    try {
+        /**
+         * Ends function immediately after callback.
+         */
+        context.callbackWaitsForEmptyEventLoop = false;
+        const { body, headers } = event;
+        if (!body) {
+            throw new Error("event.body doesn't exist.");
+        }
+        const xGitHubDelivery = headers['X-GitHub-Delivery'];
+        const xGitHubEvent = headers['X-GitHub-Event'];
+        const xHubSignature = headers['X-Hub-Signature-256'] || headers['X-Hub-Signature'];
+        if (!xGitHubDelivery) {
+            throw new Error("X-GitHub-Delivery doesn't exist.");
+        }
+        if (!xGitHubEvent) {
+            throw new Error("X-GitHub-Event doesn't exist.");
+        }
+        if (!xHubSignature) {
+            throw new Error("X-Hub-Signature-256 or X-Hub-Signature doesn't exist.");
+        }
+        exports.webhooks.onError((onErrorEvent) => {
+            throw onErrorEvent;
+        });
+        /**
+         * Replace "receive" for "verifyAndReceive" when WebCrypto exist on Node.js
+         * API.
+         */
+        await exports.webhooks.receive({
+            id: xGitHubDelivery,
+            name: xGitHubEvent,
+            // signature: xHubSignature,
+            payload: JSON.parse(body),
+        });
+        return { statusCode: 200, body: JSON.stringify({ ok: true }) };
+    }
+    catch (error) {
+        return { statusCode: error.status || 500, body: error.message };
+    }
+};
+exports.githubWebhooksApiV1Handler = githubWebhooksApiV1Handler;

package/dist/deploy/cicd/lambdas/imageUpdaterSchedule.handler.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.imageUpdaterScheduleHandler = void 0;
+const config_1 = require("../config");
+const executeTasks_1 = require("./executeTasks");
+const shConditionalCommands_1 = require("./shConditionalCommands");
+/**
+ * Update CI/CD resources with the newest carlin and repository image.
+ */
+const imageUpdaterScheduleHandler = async () => {
+    const cicdConfig = process.env.CICD_CONFIG;
+    if (!cicdConfig) {
+        return;
+    }
+    const command = (0, shConditionalCommands_1.shConditionalCommands)({
+        conditionalCommands: [
+            /**
+             * -e  Exit immediately if a command exits with a non-zero status.
+             */
+            'set -e',
+            'git status',
+            'git fetch',
+            'git pull origin main',
+            'git rev-parse HEAD',
+            'yarn global add carlin',
+            `cd ${config_1.CICD_FOLDER_NAME}`,
+            'echo $CICD_CONFIG > carlin.json',
+            'cat carlin.json',
+            `carlin deploy cicd -c carlin.json`,
+        ],
+    });
+    await (0, executeTasks_1.executeTasks)({
+        commands: [command],
+        cpu: '512',
+        memory: '2048',
+        taskEnvironment: [
+            {
+                name: 'CICD_CONFIG',
+                value: cicdConfig,
+            },
+        ],
+    });
+};
+exports.imageUpdaterScheduleHandler = imageUpdaterScheduleHandler;

package/dist/deploy/cicd/lambdas/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pipelinesHandler = exports.imageUpdaterScheduleHandler = exports.githubWebhooksApiV1Handler = exports.ecsTaskReportHandler = exports.cicdApiV1Handler = void 0;
+var cicdApiV1_handler_1 = require("./cicdApiV1.handler");
+Object.defineProperty(exports, "cicdApiV1Handler", { enumerable: true, get: function () { return cicdApiV1_handler_1.cicdApiV1Handler; } });
+var ecsTaskReport_handler_1 = require("./ecsTaskReport.handler");
+Object.defineProperty(exports, "ecsTaskReportHandler", { enumerable: true, get: function () { return ecsTaskReport_handler_1.ecsTaskReportHandler; } });
+var githubWebhooksApiV1_handler_1 = require("./githubWebhooksApiV1.handler");
+Object.defineProperty(exports, "githubWebhooksApiV1Handler", { enumerable: true, get: function () { return githubWebhooksApiV1_handler_1.githubWebhooksApiV1Handler; } });
+var imageUpdaterSchedule_handler_1 = require("./imageUpdaterSchedule.handler");
+Object.defineProperty(exports, "imageUpdaterScheduleHandler", { enumerable: true, get: function () { return imageUpdaterSchedule_handler_1.imageUpdaterScheduleHandler; } });
+var pipelines_handler_1 = require("./pipelines.handler");
+Object.defineProperty(exports, "pipelinesHandler", { enumerable: true, get: function () { return pipelines_handler_1.pipelinesHandler; } });

package/dist/deploy/cicd/lambdas/pipelines.handler.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pipelinesHandler = exports.getJobDetails = exports.getJobDetailsFilename = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const aws_sdk_1 = require("aws-sdk");
+const pipelines_1 = require("../pipelines");
+const executeTasks_1 = require("./executeTasks");
+const putApprovalResultManualTask_1 = require("./putApprovalResultManualTask");
+const shConditionalCommands_1 = require("./shConditionalCommands");
+const adm_zip_1 = tslib_1.__importDefault(require("adm-zip"));
+const codepipeline = new aws_sdk_1.CodePipeline();
+const getUserParameters = (event) => {
+    const [pipeline, stage] = event['CodePipeline.job'].data.actionConfiguration.configuration.UserParameters.split('&');
+    return { pipeline: pipeline, stage };
+};
+const getJobDetailsFilename = (jobId) => `/tmp/${jobId}.zip`;
+exports.getJobDetailsFilename = getJobDetailsFilename;
+const getJobDetails = async (event) => {
+    const jobId = event['CodePipeline.job'].id;
+    const s3 = new aws_sdk_1.S3({
+        credentials: event['CodePipeline.job'].data.artifactCredentials,
+    });
+    const { bucketName, objectKey } = event['CodePipeline.job'].data.inputArtifacts[0].location.s3Location;
+    const { Body } = await s3
+        .getObject({ Bucket: bucketName, Key: objectKey })
+        .promise();
+    if (!Body) {
+        throw new Error('Cannot retrieve the job description (there is no input artifact).');
+    }
+    const filename = (0, exports.getJobDetailsFilename)(jobId);
+    await fs.promises.writeFile(filename, Body, {});
+    const zip = new adm_zip_1.default(filename);
+    const file = zip.readAsText(getUserParameters(event).pipeline);
+    try {
+        return JSON.parse(file);
+    }
+    catch {
+        throw new Error(`Job details is not a valid json. ${file}`);
+    }
+};
+exports.getJobDetails = getJobDetails;
+const pipelinesHandler = async (event) => {
+    var _a, _b;
+    const jobId = event['CodePipeline.job'].id;
+    let pipelineName;
+    try {
+        const { pipeline } = getUserParameters(event);
+        const gitHubJobDetails = await (0, exports.getJobDetails)(event);
+        const { jobDetails } = await codepipeline
+            .getJobDetails({ jobId })
+            .promise();
+        pipelineName = (_b = (_a = jobDetails === null || jobDetails === void 0 ? void 0 : jobDetails.data) === null || _a === void 0 ? void 0 : _a.pipelineContext) === null || _b === void 0 ? void 0 : _b.pipelineName;
+        const executeTasksInput = (() => {
+            const tags = [
+                {
+                    key: 'Pipeline',
+                    value: pipeline,
+                },
+                {
+                    key: 'AfterCommit',
+                    value: gitHubJobDetails.payload.after,
+                },
+            ];
+            const taskEnvironment = [];
+            if (pipelineName) {
+                tags.push({
+                    key: 'PipelineName',
+                    value: pipelineName,
+                });
+                taskEnvironment.push({
+                    name: 'PIPELINE_NAME',
+                    value: pipelineName,
+                });
+            }
+            if (pipeline === 'main') {
+                return {
+                    commands: [
+                        (0, shConditionalCommands_1.shConditionalCommands)({
+                            conditionalCommands: (0, pipelines_1.getMainCommands)(),
+                        }),
+                    ],
+                    tags,
+                    taskEnvironment,
+                };
+            }
+            if (pipeline === 'tag') {
+                const tag = gitHubJobDetails.payload.ref.split('/')[2];
+                return {
+                    commands: [
+                        (0, shConditionalCommands_1.shConditionalCommands)({
+                            conditionalCommands: (0, pipelines_1.getTagCommands)({ tag }),
+                        }),
+                    ],
+                    tags: [
+                        ...tags,
+                        {
+                            key: 'Tag',
+                            value: tag,
+                        },
+                    ],
+                    taskEnvironment,
+                };
+            }
+            return undefined;
+        })();
+        if (!executeTasksInput) {
+            throw new Error('executeTasksInputUndefined');
+        }
+        await (0, executeTasks_1.executeTasks)(executeTasksInput);
+        await codepipeline.putJobSuccessResult({ jobId }).promise();
+    }
+    catch (error) {
+        if (pipelineName) {
+            await (0, putApprovalResultManualTask_1.putApprovalResultManualTask)({
+                pipelineName,
+                /**
+                 * https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_ApprovalResult.html
+                 */
+                result: { status: 'Rejected', summary: error.message.slice(0, 511) },
+            });
+        }
+        await codepipeline
+            .putJobFailureResult({
+            jobId,
+            failureDetails: {
+                type: 'JobFailed',
+                message: error.message.slice(0, 4999),
+            },
+        })
+            .promise();
+    }
+};
+exports.pipelinesHandler = pipelinesHandler;

package/dist/deploy/cicd/lambdas/putApprovalResultManualTask.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.putApprovalResultManualTask = void 0;
+const aws_sdk_1 = require("aws-sdk");
+const config_1 = require("../config");
+const codepipeline = new aws_sdk_1.CodePipeline();
+const FIVE_SECONDS = 5 * 1000;
+const getApprovalActionToken = ({ actionName, stageName, pipelineName, }) => new Promise((resolve, reject) => {
+    setTimeout(() => {
+        codepipeline.getPipelineState({ name: pipelineName }, async (err, { stageStates = [] }) => {
+            var _a;
+            if (err) {
+                return reject(err);
+            }
+            const approvalStageState = stageStates.find((s) => s.stageName === stageName);
+            if (!approvalStageState) {
+                throw new Error('ApprovalStageStateIsUndefined');
+            }
+            const approvalActionState = (_a = approvalStageState.actionStates) === null || _a === void 0 ? void 0 : _a.find((a) => a.actionName === actionName);
+            if (!approvalActionState) {
+                throw new Error('ApprovalActionStateIsUndefined');
+            }
+            const { latestExecution } = approvalActionState;
+            if (latestExecution && latestExecution.status === 'InProgress') {
+                return resolve(latestExecution.token);
+            }
+            try {
+                return resolve(await getApprovalActionToken({
+                    actionName,
+                    stageName,
+                    pipelineName,
+                }));
+            }
+            catch (error) {
+                return reject(error);
+            }
+        });
+    }, FIVE_SECONDS);
+});
+const putApprovalResultManualTask = async ({ pipelineName, result, }) => {
+    const actionName = config_1.PIPELINE_ECS_TASK_EXECUTION_MANUAL_APPROVAL_ACTION_NAME;
+    const stageName = config_1.PIPELINE_ECS_TASK_EXECUTION_STAGE_NAME;
+    const token = await getApprovalActionToken({
+        actionName,
+        stageName,
+        pipelineName,
+    });
+    await codepipeline
+        .putApprovalResult({ pipelineName, stageName, actionName, result, token })
+        .promise();
+};
+exports.putApprovalResultManualTask = putApprovalResultManualTask;

package/dist/deploy/cicd/lambdas/shConditionalCommands.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shConditionalCommands = exports.compileCommands = void 0;
+const compileCommands = (commands) => {
+    return commands.map((c) => c.replace(/;$/, '')).join(' && ');
+};
+exports.compileCommands = compileCommands;
+const approvedStatus = 'Approved';
+const rejectedStatus = 'Rejected';
+const defaultSuccessCommands = [
+    `carlin cicd-ecs-task-report --status=${approvedStatus}`,
+];
+const defaultFailureCommands = [
+    `carlin cicd-ecs-task-report --status=${rejectedStatus}`,
+];
+const defaultFinallyCommands = ['echo "Finally Command"'];
+const shConditionalCommands = ({ conditionalCommands, successCommands = defaultSuccessCommands, failureCommands = defaultFailureCommands, finallyCommands = defaultFinallyCommands, }) => {
+    const conditionalCommand = (0, exports.compileCommands)(conditionalCommands);
+    const successCommand = (0, exports.compileCommands)([
+        'echo "Success Command"',
+        ...successCommands,
+    ]);
+    const failureCommand = (0, exports.compileCommands)([
+        'echo "Failure Command"',
+        ...failureCommands,
+    ]);
+    const finallyCommand = (0, exports.compileCommands)(finallyCommands);
+    return `if ${conditionalCommand}; then ${successCommand}; else ${failureCommand}; fi; ${finallyCommand}`;
+};
+exports.shConditionalCommands = shConditionalCommands;

package/dist/deploy/cicd/pipelines.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTagCommands = exports.getMainCommands = exports.getClosedPrCommands = exports.getPrCommands = exports.getCommandFileDir = exports.pipelines = void 0;
+const config_1 = require("./config");
+exports.pipelines = ['pr', 'main', 'tag'];
+const getCommandFileDir = (pipeline) => `./${config_1.CICD_FOLDER_NAME}/commands/${pipeline}.sh`;
+exports.getCommandFileDir = getCommandFileDir;
+const getPrCommands = ({ branch }) => [
+    /**
+     * -e  Exit immediately if a command exits with a non-zero status.
+     */
+    'set -e',
+    'git status',
+    'git fetch',
+    /**
+     * Update to the most recent main branch to Lerna performs the diff properly.
+     */
+    'git pull origin main',
+    `git checkout ${branch} || (echo 'branch not found, probably deleted'; exit 0)`,
+    `git pull origin ${branch}`,
+    'git rev-parse HEAD',
+    'git status',
+    'yarn install --frozen-lockfile',
+    `sh -e ${(0, exports.getCommandFileDir)('pr')}`,
+];
+exports.getPrCommands = getPrCommands;
+const getClosedPrCommands = ({ branch }) => [
+    'git status',
+    'git fetch',
+    /**
+     * Get the most recent main because the PR was approved.
+     */
+    'git pull origin main',
+    'git rev-parse HEAD',
+    `export CARLIN_BRANCH=${branch}`,
+    /**
+     * Exit without error if `closed-pr` does not exist.
+     */
+    `[ ! -f "${(0, exports.getCommandFileDir)('closed-pr')}" ] && echo 'closed-pr command not found' || sh ${(0, exports.getCommandFileDir)('closed-pr')}`,
+];
+exports.getClosedPrCommands = getClosedPrCommands;
+const getMainCommands = () => [
+    /**
+     * -e  Exit immediately if a command exits with a non-zero status.
+     */
+    'set -e',
+    `export CARLIN_ENVIRONMENT=Staging`,
+    'git status',
+    'git fetch',
+    'git pull origin main',
+    'git rev-parse HEAD',
+    /**
+     * Reporting `MainTagFound` before exiting the process. This command blocks
+     * the process if tag was found. If we don't do this, the loop would never
+     * end because `main` command can create a tag, that would trigger this
+     * pipeline again.
+     */
+    'if git describe --exact-match; then echo "Tag found" && carlin cicd-ecs-task-report --status=MainTagFound && exit 0; fi',
+    'yarn install --frozen-lockfile',
+    `sh -e ${(0, exports.getCommandFileDir)('main')}`,
+];
+exports.getMainCommands = getMainCommands;
+const getTagCommands = ({ tag }) => [
+    /**
+     * -e  Exit immediately if a command exits with a non-zero status.
+     */
+    'set -e',
+    `export CARLIN_ENVIRONMENT=Production`,
+    'git status',
+    'git fetch --tags',
+    `git checkout tags/${tag} -b ${tag}-branch`,
+    'git rev-parse HEAD',
+    'yarn install --frozen-lockfile',
+    `sh -e ${(0, exports.getCommandFileDir)('tag')}`,
+];
+exports.getTagCommands = getTagCommands;

package/dist/deploy/cicd/readSSHKey.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSSHKey = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+/**
+ * Created to allow mocking.
+ */
+const readSSHKey = (dir) => fs.readFileSync(dir, 'utf-8');
+exports.readSSHKey = readSSHKey;