@csermet/multiprovider
Version:
cloud-graph provider plugin for AWS used to fetch AWS cloud data.
236 lines (235 loc) • 9.76 kB
JavaScript
"use strict";
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 services_1 = __importDefault(require("../../enums/services"));
const generateArns_1 = require("../../utils/generateArns");
const utils_1 = require("./utils");
const regions_1 = require("../../enums/regions");
/**
* EC2
*/
exports.default = ({ service: instance, data, region, account, }) => {
const connections = [];
const { InstanceId: id, SecurityGroups: instanceSecurityGroups = [], NetworkInterfaces: instanceNetworkInterfaces = [], SubnetId: subnetId, Tags: tags, IamInstanceProfile: iamInstanceProfile, IamRolesArn: rolesArn, } = instance;
/**
* Find Security Groups VPC Security Groups
* related to this EC2 instance
*/
const securityGroups = data.find(({ name }) => name === services_1.default.sg);
const sgIds = instanceSecurityGroups.map(({ GroupId }) => GroupId);
if (securityGroups?.data?.[region]) {
const sgsInRegion = securityGroups.data[region].filter(({ GroupId }) => sgIds.includes(GroupId));
if (!isEmpty_1.default(sgsInRegion)) {
for (const sg of sgsInRegion) {
connections.push({
id: sg.GroupId,
resourceType: services_1.default.sg,
relation: 'child',
field: 'securityGroups',
});
}
}
}
/**
* Find EBS volumes
* related to this EC2 instance
*/
const ebsVolumes = data.find(({ name }) => name === services_1.default.ebs);
if (ebsVolumes?.data?.[region]) {
const volumesInRegion = ebsVolumes.data[region].filter(({ Attachments: attachments }) => attachments.find(({ InstanceId }) => InstanceId === id));
if (!isEmpty_1.default(volumesInRegion)) {
for (const v of volumesInRegion) {
connections.push({
id: v.VolumeId,
resourceType: services_1.default.ebs,
relation: 'child',
field: 'ebs',
});
}
}
}
/**
* Find Elastic IPs
* related to this EC2 instance
*/
const eips = data.find(({ name }) => name === services_1.default.eip);
if (eips?.data?.[region]) {
const eipsInRegion = eips.data[region].filter(({ InstanceId }) => InstanceId === id);
if (!isEmpty_1.default(eipsInRegion)) {
for (const eip of eipsInRegion) {
connections.push({
id: eip.AllocationId,
resourceType: services_1.default.eip,
relation: 'child',
field: 'eip',
});
}
}
}
/**
* Find Network interfaces
* related to this EC2 instance
*/
const networkInterfaces = data.find(({ name }) => name === services_1.default.networkInterface);
const networkInterfacesIds = instanceNetworkInterfaces.map(({ NetworkInterfaceId }) => NetworkInterfaceId);
if (networkInterfaces?.data?.[region] ||
instanceNetworkInterfaces.length > 0) {
// Check for matching network interfaces in existing data
const networkInterfacesInRegion = (networkInterfaces?.data[region] || []).filter(({ NetworkInterfaceId }) => networkInterfacesIds.includes(NetworkInterfaceId));
const attachedNetworkInterfaces = networkInterfacesInRegion.length > 0
? networkInterfacesInRegion
: instanceNetworkInterfaces;
if (!isEmpty_1.default(attachedNetworkInterfaces)) {
for (const networkInterface of instanceNetworkInterfaces) {
connections.push({
id: networkInterface.NetworkInterfaceId,
resourceType: services_1.default.networkInterface,
relation: 'child',
field: 'networkInterfaces',
});
}
}
}
/**
* Find Subnets
* related to this EC2
*/
const subnets = data.find(({ name }) => name === services_1.default.subnet);
if (subnets?.data?.[region]) {
const subnetsInRegion = subnets.data[region].filter(({ SubnetId }) => subnetId === SubnetId);
if (!isEmpty_1.default(subnetsInRegion)) {
for (const subnet of subnetsInRegion) {
connections.push({
id: subnet.SubnetId,
resourceType: services_1.default.subnet,
relation: 'child',
field: 'subnets',
});
}
}
}
/**
* Find EKS cluster
* related to this EC2
*/
const eksClusterName = utils_1.getEksClusterName(tags);
const eksClusters = data.find(({ name }) => name === services_1.default.eksCluster);
if (eksClusters?.data?.[region]) {
const eksClustersInRegion = eksClusters.data[region].filter(({ name }) => name === eksClusterName);
if (!isEmpty_1.default(eksClustersInRegion)) {
for (const eksCluster of eksClustersInRegion) {
connections.push({
id: eksCluster.arn,
resourceType: services_1.default.eksCluster,
relation: 'child',
field: 'eksCluster',
});
}
}
}
/**
* Find ECS Container
* related to this EC2
*/
const ecsContainers = data.find(({ name }) => name === services_1.default.ecsContainer);
if (ecsContainers?.data?.[region]) {
const containersInRegion = ecsContainers.data[region].filter(({ ec2InstanceId }) => ec2InstanceId === id);
if (!isEmpty_1.default(containersInRegion)) {
for (const container of containersInRegion) {
connections.push({
id: container.containerInstanceArn,
resourceType: services_1.default.ecsContainer,
relation: 'child',
field: 'ecsContainer',
});
}
}
}
/**
* Find SSM managed instances
* related to this EC2 instance
*/
const instances = data.find(({ name }) => name === services_1.default.systemsManagerInstance);
if (instances?.data?.[region]) {
const dataInRegion = instances.data[region].filter(({ InstanceId }) => InstanceId === id);
if (!isEmpty_1.default(dataInRegion)) {
for (const ssmInstance of dataInRegion) {
const arn = generateArns_1.ssmManagedInstanceArn({
region,
account,
name: ssmInstance.InstanceId,
});
connections.push({
id: arn,
resourceType: services_1.default.systemsManagerInstance,
relation: 'child',
field: 'systemsManagerInstance',
});
}
}
}
/**
* Find Elastic Beanstalk
* related to this EC2 instance
*/
const elasticBeanstalkEnvId = utils_1.getElasticBeanstalkEnvId(tags);
const elasticBeanstalkEnvs = data.find(({ name }) => name === services_1.default.elasticBeanstalkEnv);
if (elasticBeanstalkEnvs?.data?.[region]) {
const elasticBeanstalkEnvsInRegion = elasticBeanstalkEnvs.data[region].filter(({ EnvironmentId }) => elasticBeanstalkEnvId === EnvironmentId);
if (!isEmpty_1.default(elasticBeanstalkEnvsInRegion)) {
for (const elasticBeanstalkEnv of elasticBeanstalkEnvsInRegion) {
connections.push({
id: elasticBeanstalkEnv.EnvironmentId,
resourceType: services_1.default.elasticBeanstalkEnv,
relation: 'child',
field: 'elasticBeanstalkEnv',
});
}
}
}
/**
* Find IAM Instance Profiles
* related to this EC2 instance
*/
const iamInstanceProfiles = data.find(({ name }) => name === services_1.default.iamInstanceProfile);
if (iamInstanceProfiles?.data?.[regions_1.globalRegionName]) {
const dataAtRegion = iamInstanceProfiles.data[regions_1.globalRegionName].filter(instanceProfile => instanceProfile.Arn === iamInstanceProfile?.Arn);
if (!isEmpty_1.default(dataAtRegion)) {
for (const iamInstance of dataAtRegion) {
const { InstanceProfileId: instanceProfileId } = iamInstance;
connections.push({
id: instanceProfileId,
resourceType: services_1.default.iamInstanceProfile,
relation: 'child',
field: 'iamInstanceProfile',
});
}
}
}
/**
* Find IAM Roles
* related to this EC2 instance
*/
const roles = data.find(({ name }) => name === services_1.default.iamRole);
if (roles?.data?.[regions_1.globalRegionName]) {
const dataAtRegion = roles.data[regions_1.globalRegionName].filter(({ Arn }) => rolesArn?.includes(Arn));
if (!isEmpty_1.default(dataAtRegion)) {
for (const iamRole of dataAtRegion) {
const { Arn: arn } = iamRole;
connections.push({
id: arn,
resourceType: services_1.default.iamRole,
relation: 'child',
field: 'iamRole',
});
}
}
}
const ec2Result = {
[id]: connections,
};
return ec2Result;
};