feat: Added rdsEventSubscription

Author: Marco Franceschi

src/enums/serviceMap.ts

@@ -52,6 +52,7 @@ import NetworkAcl from '../services/nacl'
 import NetworkInterface from '../services/networkInterface'
 import RDSCluster from '../services/rdsCluster'
 import RDSDbInstance from '../services/rdsDbInstance'
+import RDSEventSubscription from '../services/rdsEventSubscription'
 import RedshiftCluster from '../services/redshift'
 import Route53HostedZone from '../services/route53HostedZone'
 import Route53Record from '../services/route53Record'
@@ -185,6 +186,7 @@ export default {
   [services.rdsCluster]: RDSCluster,
   [services.rdsClusterSnapshot]: RdsClusterSnapshot,
   [services.rdsDbInstance]: RDSDbInstance,
+  [services.rdsEventSubscription]: RDSEventSubscription,
   [services.redshiftCluster]: RedshiftCluster,
   [services.route53HostedZone]: Route53HostedZone,
   [services.route53Record]: Route53Record,

src/enums/services.ts

@@ -80,6 +80,7 @@ export default {
   rdsCluster: 'rdsCluster',
   rdsClusterSnapshot: 'rdsClusterSnapshot',
   rdsDbInstance: 'rdsDbInstance',
+  rdsEventSubscription: 'rdsEventSubscription',
   redshiftCluster: 'redshiftCluster',
   route53HostedZone: 'route53HostedZone',
   route53Record: 'route53Record',

src/properties/logger.ts

@@ -264,6 +264,7 @@ export default {
    */
   fetchingEbsSnapshotData:
     'Fetching EBS Snapshot data for this AWS account via the AWS SDK...',
+  fetchingEbsSnapshotData: 'Fetching EBS Snapshot data for this AWS account via the AWS SDK...',
   doneFetchingEbsSnapshotData: '✅ Done fetching EBS Snapshot Data ✅',
   fetchedEbsSnapshots: (num: number): string => `Fetched ${num} EBS Snapshots`,
   lookingForEbsSnapshot: 'Looking for EBS Snapshots...',
@@ -293,6 +294,8 @@ export default {
   fetchedRdsClusters: (num: number): string => `Fetched ${num} RDS Clusters`,
   fetchedRdsInstances: (num: number): string =>
     `Fetched ${num} RDS DB Instances`,
+  fetchedRdsEventSubscriptions: (num: number): string =>
+    `Fetched ${num} RDS DB Event Subscriptions`,
   noClusterFound: '❎ DB Instance is not part of a cluster ❎ ',
   foundCluster: 'Found the cluster the instance belongs to',
   addingRdsInstances: (num: number): string =>

src/services/rdsEventSubscription/data.ts

@@ -0,0 +1,97 @@
+import CloudGraph from '@cloudgraph/sdk'
+import RDS, {
+  EventSubscription,
+  EventSubscriptionsMessage,
+  DescribeEventSubscriptionsMessage
+} from 'aws-sdk/clients/rds'
+import { AWSError } from 'aws-sdk/lib/error'
+import groupBy from 'lodash/groupBy'
+import isEmpty from 'lodash/isEmpty'
+import { Config } from 'aws-sdk/lib/config'
+import { initTestEndpoint } from '../../utils'
+import AwsErrorLog from '../../utils/errorLog'
+import awsLoggerText from '../../properties/logger'
+
+
+const { logger } = CloudGraph
+const lt = { ...awsLoggerText }
+const serviceName = 'RDS Event Subscriptions'
+const errorLog = new AwsErrorLog(serviceName)
+const endpoint = initTestEndpoint(serviceName)
+
+const listDBEventSubscriptionsForRegion = async (rds: RDS): Promise<EventSubscription[]> =>
+  new Promise<EventSubscription[]>(resolve => {
+    const eventSubscriptions: EventSubscription[] = []
+    const descDBInstancesOpts: DescribeEventSubscriptionsMessage = {}
+    const listEventSubscriptions = (token?: string): void => {
+      if (token) {
+        descDBInstancesOpts.Marker = token
+      }
+      try {
+        rds.describeEventSubscriptions(
+          descDBInstancesOpts,
+          (err: AWSError, data: EventSubscriptionsMessage) => {
+            const { Marker, EventSubscriptionsList = [] } = data || {}
+            if (err) {
+              errorLog.generateAwsErrorLog({
+                functionName: 'rds:describeEventSubscriptions',
+                err,
+              })
+            }
+
+            eventSubscriptions.push(...EventSubscriptionsList)
+
+            if (Marker) {
+              listEventSubscriptions(Marker)
+            } else {
+              resolve(eventSubscriptions)
+            }
+          }
+        )
+      } catch (error) {
+        resolve([])
+      }
+    }
+    listEventSubscriptions()
+  })
+
+export interface RawAwsRdsEventSubscription extends EventSubscription {
+  region: string
+}
+
+export default async ({
+  regions,
+  config,
+}: {
+  regions: string
+  config: Config
+}): Promise<{ [property: string]: RawAwsRdsEventSubscription[] }> =>
+  new Promise(async resolve => {
+    const rdsData: RawAwsRdsEventSubscription[] = []
+    const regionPromises = []
+
+    // Get all the instances for the region
+    regions.split(',').map(region => {
+      const regionPromise = new Promise<void>(async resolveRegion => {
+        const rds = new RDS({ ...config, region, endpoint })
+        const subscriptions = await listDBEventSubscriptionsForRegion(rds)
+
+        if (!isEmpty(subscriptions)) {
+          rdsData.push(
+            ...subscriptions.map(subscription => ({
+              ...subscription,
+              region,
+            }))
+          )
+        }
+        resolveRegion()
+      })
+      regionPromises.push(regionPromise)
+    })
+
+    await Promise.all(regionPromises)
+    logger.debug(lt.fetchedRdsEventSubscriptions(rdsData.length))
+
+    errorLog.reset()
+    resolve(groupBy(rdsData, 'region'))
+  })

src/services/rdsEventSubscription/format.ts

@@ -0,0 +1,45 @@
+import { AwsRdsEventSubscription } from '../../types/generated'
+import { RawAwsRdsEventSubscription } from './data'
+
+/**
+ * RdsEventSubscription
+ */
+
+export default ({
+  account,
+  service: rawData,
+  region,
+}: {
+  account,
+  service: RawAwsRdsEventSubscription
+  region,
+}): AwsRdsEventSubscription => {
+  const {
+    EventSubscriptionArn: arn,
+    CustomerAwsId: customerAwsId,
+    CustSubscriptionId: custSubscriptionId,
+    SnsTopicArn: snsTopicArn,
+    Status: status,
+    SubscriptionCreationTime: subscriptionCreationTime,
+    SourceType: sourceType,
+    SourceIdsList: sourceIdsList = [],
+    EventCategoriesList: eventCategoriesList = [],
+    Enabled: enabled
+  } = rawData
+
+  return {
+    id: arn,
+    accountId: account,
+    arn,
+    region,
+    customerAwsId,
+    custSubscriptionId,
+    snsTopicArn,
+    status,
+    subscriptionCreationTime,
+    sourceType,
+    sourceIdsList,
+    eventCategoriesList,
+    enabled
+  }
+}

src/services/rdsEventSubscription/index.ts

@@ -0,0 +1,13 @@
+import { Service } from '@cloudgraph/sdk'
+import BaseService from '../base'
+import format from './format'
+import getData from './data'
+import mutation from './mutation'
+
+export default class RdsEventSubscription extends BaseService implements Service {
+  format = format.bind(this)
+
+  getData = getData.bind(this)
+
+  mutation = mutation
+}

src/services/rdsEventSubscription/mutation.ts

@@ -0,0 +1,5 @@
+export default `mutation($input: [AddawsRdsEventSubscriptionInput!]!) {
+  addawsRdsEventSubscription(input: $input, upsert: true) {
+    numUids
+  }
+}`;

src/services/rdsEventSubscription/schema.graphql

@@ -0,0 +1,12 @@
+type awsRdsEventSubscription implements awsBaseService @key(fields: "arn") {
+   customerAwsId: String @search(by: [hash, regexp])
+   custSubscriptionId: String @search(by: [hash, regexp])
+   snsTopicArn: String @search(by: [hash, regexp])
+   status: String @search(by: [hash, regexp])
+   subscriptionCreationTime: String @search(by: [hash, regexp])
+   sourceType: String @search(by: [hash, regexp])
+   sourceIdsList: [String] @search(by: [hash])
+   eventCategoriesList: [String] @search(by: [hash])
+   enabled: Boolean @search
+}
+

src/types/generated.ts

@@ -4067,6 +4067,18 @@ export type AwsRdsDbInstanceParameterGroup = {
   status?: Maybe<Scalars['String']>;
 };
 
+export type AwsRdsEventSubscription = AwsBaseService & {
+  custSubscriptionId?: Maybe<Scalars['String']>;
+  customerAwsId?: Maybe<Scalars['String']>;
+  enabled?: Maybe<Scalars['Boolean']>;
+  eventCategoriesList?: Maybe<Array<Maybe<Scalars['String']>>>;
+  snsTopicArn?: Maybe<Scalars['String']>;
+  sourceIdsList?: Maybe<Array<Maybe<Scalars['String']>>>;
+  sourceType?: Maybe<Scalars['String']>;
+  status?: Maybe<Scalars['String']>;
+  subscriptionCreationTime?: Maybe<Scalars['String']>;
+};
+
 export type AwsRecorderStatus = {
   lastStartTime?: Maybe<Scalars['String']>;
   lastStatus?: Maybe<Scalars['String']>;