@cumulus/ingest/sqs.js

Ingest utilities

'use strict';
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.deleteArchivedMessageFromS3 = exports.archiveSqsMessageToS3 = exports.getS3KeyForArchivedMessage = exports.getS3PrefixForArchivedMessage = void 0;
const logger_1 = __importDefault(require("@cumulus/logger"));
const SQS_1 = require("@cumulus/aws-client/SQS");
const common_1 = require("@cumulus/common");
const S3_1 = require("@cumulus/aws-client/S3");
const logger = new logger_1.default({ sender: '@cumulus/ingest/sqs' });
function getS3PrefixForArchivedMessage(stackName, queueName) {
    const prefix = `${stackName}/archived-incoming-messages/${queueName}/`;
    return prefix;
}
exports.getS3PrefixForArchivedMessage = getS3PrefixForArchivedMessage;
function getS3KeyForArchivedMessage(stackName, messageId, queueName) {
    const key = `${getS3PrefixForArchivedMessage(stackName, queueName)}${messageId}`;
    return key;
}
exports.getS3KeyForArchivedMessage = getS3KeyForArchivedMessage;
/**
 * Archives incoming SQS Message into S3
 *
 * @param {string} queueUrl - Queue URL
 * @param {Object} message - SQS message
 * @returns {undefined}
 */
async function archiveSqsMessageToS3(queueUrl, message) {
    const bucket = common_1.envUtils.getRequiredEnvVar('system_bucket', process.env);
    const stackName = common_1.envUtils.getRequiredEnvVar('stackName', process.env);
    if (!message.MessageId) {
        const error = new Error(`MessageId on message ${JSON.stringify(message)} required but not found.`);
        logger.error(error);
        throw error;
    }
    const queueName = (0, SQS_1.getQueueNameFromUrl)(queueUrl);
    if (!queueName) {
        throw new Error(`Unable to determine queueName from ${queueUrl}`);
    }
    const key = getS3KeyForArchivedMessage(stackName, message.MessageId, queueName);
    const body = message.Body;
    logger.info(`Archiving message ${message.MessageId} from queue ${queueUrl}`);
    try {
        await (0, S3_1.s3PutObject)({
            Bucket: bucket,
            Key: key,
            Body: body,
        });
        logger.debug(`Archived ${message.MessageId} from queue with key ${key}`);
    }
    catch (error) {
        logger.error(`Could not write to bucket. ${error}`);
        throw error;
    }
}
exports.archiveSqsMessageToS3 = archiveSqsMessageToS3;
/**
 * Deletes archived SQS Message from S3
 *
 * @param {string} messageId - SQS message ID
 * @param {string} queueUrl  - SQS queue URL
 * @returns {undefined}
 */
async function deleteArchivedMessageFromS3(messageId, queueUrl) {
    const bucket = common_1.envUtils.getRequiredEnvVar('system_bucket', process.env);
    const stackName = common_1.envUtils.getRequiredEnvVar('stackName', process.env);
    const queueName = (0, SQS_1.getQueueNameFromUrl)(queueUrl);
    if (!queueName) {
        throw new Error(`Unable to determine queueName from ${queueUrl}`);
    }
    const key = getS3KeyForArchivedMessage(stackName, messageId, queueName);
    try {
        await (0, S3_1.deleteS3Object)(bucket, key);
        logger.info(`Deleted archived message ${messageId} from S3 at ${bucket}/${key}`);
    }
    catch (error) {
        logger.error(`Could not delete message from bucket. ${error}`);
        throw error;
    }
}
exports.deleteArchivedMessageFromS3 = deleteArchivedMessageFromS3;
//# sourceMappingURL=sqs.js.map