@csermet/multiprovider
Version:
cloud-graph provider plugin for AWS used to fetch AWS cloud data.
157 lines (156 loc) • 5.73 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const isEmpty_1 = __importDefault(require("lodash/isEmpty"));
const groupBy_1 = __importDefault(require("lodash/groupBy"));
const lambda_1 = __importDefault(require("aws-sdk/clients/lambda"));
const sdk_1 = __importDefault(require("@cloudgraph/sdk"));
const logger_1 = __importDefault(require("../../properties/logger"));
const utils_1 = require("../../utils");
const errorLog_1 = __importDefault(require("../../utils/errorLog"));
const lt = { ...logger_1.default };
const MAX_ITEMS = 50;
const { logger } = sdk_1.default;
const serviceName = 'Lambda';
const errorLog = new errorLog_1.default(serviceName);
const endpoint = utils_1.initTestEndpoint(serviceName);
const listFunctionsForRegion = async ({ lambda, resolveRegion, }) => new Promise(resolve => {
const functionsList = [];
const listFunctionsOpts = {};
const listAllFunctions = (token) => {
listFunctionsOpts.MaxItems = MAX_ITEMS;
if (token) {
listFunctionsOpts.Marker = token;
}
try {
lambda.listFunctions(listFunctionsOpts, (err, data) => {
const { NextMarker, Functions = [] } = data || {};
if (err) {
errorLog.generateAwsErrorLog({
functionName: 'lambda:listFunctions',
err,
});
}
/**
* No Lambdas for this region
*/
if (isEmpty_1.default(data)) {
return resolveRegion();
}
functionsList.push(...Functions);
if (NextMarker) {
logger.debug(lt.foundMoreLambdas(Functions.length));
listAllFunctions(NextMarker);
}
else {
resolve(functionsList);
}
});
}
catch (error) {
resolve([]);
}
};
listAllFunctions();
});
const getFunctionConcurrency = async (lambda, FunctionName) => new Promise(resolve => {
const getFunctionConcurrencyOpts = {
FunctionName,
};
try {
lambda.getFunctionConcurrency(getFunctionConcurrencyOpts, (err, data) => {
const { ReservedConcurrentExecutions: reservedConcurrentExecutions } = data || {};
if (err) {
errorLog.generateAwsErrorLog({
functionName: 'lambda:getFunctionConcurrency',
err,
});
}
resolve(reservedConcurrentExecutions || -1);
});
}
catch (error) {
resolve(null);
}
});
const getResourceTags = async (lambda, arn) => new Promise(resolve => {
try {
lambda.listTags({ Resource: arn }, (err, data) => {
if (err) {
errorLog.generateAwsErrorLog({
functionName: 'lambda:listTags',
err,
});
resolve({});
}
const { Tags = {} } = data || {};
resolve(Tags);
});
}
catch (error) {
resolve({});
}
});
const getLambdaPolicy = async (lambda, arn) => new Promise(resolve => {
try {
lambda.getPolicy({ FunctionName: arn }, (err, data) => {
if (err) {
errorLog.generateAwsErrorLog({
functionName: 'lambda:getPolicy',
err,
});
resolve({});
}
const { Policy = '', RevisionId = '' } = data || {};
resolve({ Policy, RevisionId });
});
}
catch (error) {
resolve({});
}
});
exports.default = async ({ regions, config, }) => new Promise(async (resolve) => {
const lambdaData = [];
const regionPromises = [];
const tagsPromises = [];
// get all Lambdas for all regions
regions.split(',').map(region => {
const lambda = new lambda_1.default({ ...config, region, endpoint });
const regionPromise = new Promise(async (resolveRegion) => {
const functionsList = await listFunctionsForRegion({
lambda,
resolveRegion,
});
if (!isEmpty_1.default(functionsList)) {
const promises = functionsList.map(async (fn) => ({
...fn,
reservedConcurrentExecutions: await getFunctionConcurrency(lambda, fn.FunctionName),
region,
}));
lambdaData.push(...(await Promise.all(promises)));
}
resolveRegion();
});
regionPromises.push(regionPromise);
});
await Promise.all(regionPromises);
logger.debug(lt.fetchedLambdas(lambdaData.length));
// get all tags and policy for each Lambda
lambdaData.map(({ FunctionArn: arn, region }, idx) => {
const lambda = new lambda_1.default({ ...config, region, endpoint });
const tagsAndPolicyPromise = new Promise(async (resolveData) => {
const envTags = await getResourceTags(lambda, arn);
lambdaData[idx].Tags = envTags;
const policy = await getLambdaPolicy(lambda, arn);
lambdaData[idx].PolicyData = policy;
resolveData();
});
tagsPromises.push(tagsAndPolicyPromise);
});
logger.debug(lt.gettingLambdaTags);
await Promise.all(tagsPromises);
errorLog.reset();
resolve(groupBy_1.default(lambdaData, 'region'));
});