feat: Added rdsGlobalClusters

Author: Marco Franceschi

src/enums/serviceMap.ts

@@ -51,6 +51,7 @@ import NATGateway from '../services/natGateway'
 import NetworkAcl from '../services/nacl'
 import NetworkInterface from '../services/networkInterface'
 import RDSCluster from '../services/rdsCluster'
+import RDSGlobalCluster from '../services/rdsGlobalCluster '
 import RDSDbInstance from '../services/rdsDbInstance'
 import RDSEventSubscription from '../services/rdsEventSubscription'
 import RdsDbProxies from '../services/rdsDbProxies'
@@ -185,6 +186,7 @@ export default {
   [services.vpcPeeringConnection]: VpcPeeringConnection,
   [services.sqs]: SQS,
   [services.rdsCluster]: RDSCluster,
+  [services.rdsGlobalCluster]: RDSGlobalCluster,
   [services.rdsClusterSnapshot]: RdsClusterSnapshot,
   [services.rdsDbInstance]: RDSDbInstance,
   [services.rdsEventSubscription]: RDSEventSubscription,

src/enums/services.ts

@@ -78,6 +78,7 @@ export default {
   networkInterface: 'networkInterface',
   organization: 'organization',
   rdsCluster: 'rdsCluster',
+  rdsGlobalCluster: 'rdsGlobalCluster',
   rdsClusterSnapshot: 'rdsClusterSnapshot',
   rdsDbInstance: 'rdsDbInstance',
   rdsEventSubscription: 'rdsEventSubscription',

src/properties/logger.ts

@@ -292,6 +292,7 @@ export default {
   lookingforRdsClusters: 'Looking for RDS Clusters...',
   creatingRdsInstance: (num: number): string => `Creating RDS Instance #${num}`,
   fetchedRdsClusters: (num: number): string => `Fetched ${num} RDS Clusters`,
+  fetchedRdsGlobalClusters: (num: number): string => `Fetched ${num} RDS Global Clusters`,
   fetchedRdsInstances: (num: number): string =>
     `Fetched ${num} RDS DB Instances`,
   fetchedRdsEventSubscriptions: (num: number): string =>

src/services/rdsGlobalCluster /data.ts

@@ -0,0 +1,99 @@
+import CloudGraph from '@cloudgraph/sdk'
+import RDS, {
+  GlobalClustersMessage,
+  DescribeGlobalClustersMessage,
+  GlobalCluster,
+} 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 awsLoggerText from '../../properties/logger'
+import AwsErrorLog from '../../utils/errorLog'
+import { initTestEndpoint } from '../../utils'
+
+const lt = { ...awsLoggerText }
+const { logger } = CloudGraph
+const serviceName = 'RDS DB cluster'
+const errorLog = new AwsErrorLog(serviceName)
+const endpoint = initTestEndpoint(serviceName)
+
+const listGlobalClustersForRegion = async (rds: RDS): Promise<GlobalCluster[]> =>
+  new Promise<GlobalCluster[]>(resolve => {
+    const clusterList: GlobalCluster[] = []
+    const descClustersOpts: DescribeGlobalClustersMessage = {}
+    const listAllClusters = (token?: string): void => {
+      if (token) {
+        descClustersOpts.Marker = token
+      }
+      try {
+        rds.describeGlobalClusters(
+          descClustersOpts,
+          (err: AWSError, data: GlobalClustersMessage) => {
+            const { Marker, GlobalClusters = [] } = data || {}
+            if (err) {
+              errorLog.generateAwsErrorLog({
+                functionName: 'rds:describeGlobalClusters',
+                err,
+              })
+            }
+
+            clusterList.push(...GlobalClusters)
+
+            if (Marker) {
+              listAllClusters(Marker)
+            } else {
+              resolve(clusterList)
+            }
+          }
+        )
+      } catch (error) {
+        resolve([])
+      }
+    }
+    listAllClusters()
+  })
+
+
+export interface RawAwsRdsGlobalCluster extends GlobalCluster {
+  region: string
+}
+
+export default async ({
+  regions,
+  config,
+}: {
+  regions: string
+  config: Config
+}): Promise<{ [property: string]: RawAwsRdsGlobalCluster[] }> =>
+  new Promise(async resolve => {
+    const rdsData: RawAwsRdsGlobalCluster[] = []
+    const regionPromises = []
+    const tagsPromises = []
+
+    // Get all the global clusters for the region
+    regions.split(',').map(region => {
+      const regionPromise = new Promise<void>(async resolveRegion => {
+        const rds = new RDS({ ...config, region, endpoint })
+        const clusters = await listGlobalClustersForRegion(rds)
+
+        if (!isEmpty(clusters)) {
+          rdsData.push(
+            ...(await Promise.all(
+              clusters.map(async cluster => ({
+                ...cluster,
+                region,
+              }))
+            ))
+          )
+        }
+        resolveRegion()
+      })
+      regionPromises.push(regionPromise)
+    })
+
+    await Promise.all(regionPromises)
+    logger.debug(lt.fetchedRdsGlobalClusters(rdsData.length))
+    errorLog.reset()
+    resolve(groupBy(rdsData, 'region'))
+  })

src/services/rdsGlobalCluster /format.ts

@@ -0,0 +1,64 @@
+import { RawAwsRdsGlobalCluster } from './data'
+import { AwsRdsGlobalCluster } from '../../types/generated'
+import { generateUniqueId } from '@cloudgraph/sdk'
+
+export default ({
+  service,
+  account,
+  region,
+}: {
+  service: RawAwsRdsGlobalCluster
+  account: string
+  region: string
+}): AwsRdsGlobalCluster => {
+  const {
+    GlobalClusterIdentifier: globalClusterIdentifier,
+    GlobalClusterResourceId: globalClusterResourceId,
+    GlobalClusterArn: arn,
+    Status: status,
+    Engine: engine,
+    EngineVersion: engineVersion,
+    DatabaseName: databaseName,
+    StorageEncrypted: storageEncrypted,
+    DeletionProtection: deletionProtection,
+    GlobalClusterMembers = [],
+    FailoverState = {},
+  } = service
+
+
+  const failoverState = {
+    status: FailoverState.Status,
+    fromDbClusterArn: FailoverState.FromDbClusterArn,
+    toDbClusterArn: FailoverState.ToDbClusterArn,
+  }
+
+  const globalClusterMembers = GlobalClusterMembers.map(gc => ({
+    id: generateUniqueId({
+      arn,
+      ...gc,
+    }),
+    dBClusterArn: gc.DBClusterArn,
+    isWriter: gc.IsWriter,
+    globalWriteForwardingStatus: gc.GlobalWriteForwardingStatus,
+    readers: gc.Readers ?? [],
+  }))
+
+
+  return {
+    id: arn,
+    accountId: account,
+    arn,
+    region,
+    globalClusterIdentifier,
+    globalClusterResourceId,
+    status,
+    engine,
+    engineVersion,
+    databaseName,
+    storageEncrypted,
+    deletionProtection,
+    globalClusterMembers,
+    failoverState,
+
+  }
+}

src/services/rdsGlobalCluster /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 RDSGlobalCluster extends BaseService implements Service {
+  format = format.bind(this)
+
+  getData = getData.bind(this)
+
+  mutation = mutation
+}

src/services/rdsGlobalCluster /mutation.ts

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

src/services/rdsGlobalCluster /schema.graphql

@@ -0,0 +1,33 @@
+type awsRdsGlobalClusterFailoverState {
+    status: String @search(by: [hash, regexp])
+    fromDbClusterArn: String @search(by: [hash, regexp])
+    toDbClusterArn: String @search(by: [hash, regexp])
+}
+
+type awsRdsGlobalClusterMembers
+  @generate(
+    query: { get: false, query: true, aggregate: false }
+    mutation: { add: false, delete: false }
+    subscription: false
+  ) {
+  id: String! @id
+  dBClusterArn: String @search(by: [hash, regexp])
+  readers: [String] @search(by: [hash])
+  isWriter: Boolean @search
+  globalWriteForwardingStatus: String @search(by: [hash, regexp])
+}
+
+
+type awsRdsGlobalCluster implements awsBaseService @key(fields: "arn") {
+    globalClusterIdentifier: String @search(by: [hash, regexp])
+    globalClusterResourceId: String @search(by: [hash, regexp])
+    globalClusterArn: String @search(by: [hash, regexp])
+    status: String @search(by: [hash, regexp])
+    engine: String @search(by: [hash, regexp])
+    engineVersion: String @search(by: [hash, regexp])
+    databaseName: String @search(by: [hash, regexp])
+    storageEncrypted: Boolean @search
+    deletionProtection: Boolean @search
+    globalClusterMembers: [awsRdsGlobalClusterMembers]
+    failoverState: awsRdsGlobalClusterFailoverState
+}

src/types/generated.ts

@@ -4152,6 +4152,34 @@ export type AwsRdsEventSubscription = AwsBaseService & {
   subscriptionCreationTime?: Maybe<Scalars['String']>;
 };
 
+export type AwsRdsGlobalCluster = AwsBaseService & {
+  databaseName?: Maybe<Scalars['String']>;
+  deletionProtection?: Maybe<Scalars['Boolean']>;
+  engine?: Maybe<Scalars['String']>;
+  engineVersion?: Maybe<Scalars['String']>;
+  failoverState?: Maybe<AwsRdsGlobalClusterFailoverState>;
+  globalClusterArn?: Maybe<Scalars['String']>;
+  globalClusterIdentifier?: Maybe<Scalars['String']>;
+  globalClusterMembers?: Maybe<Array<Maybe<AwsRdsGlobalClusterMembers>>>;
+  globalClusterResourceId?: Maybe<Scalars['String']>;
+  status?: Maybe<Scalars['String']>;
+  storageEncrypted?: Maybe<Scalars['Boolean']>;
+};
+
+export type AwsRdsGlobalClusterFailoverState = {
+  fromDbClusterArn?: Maybe<Scalars['String']>;
+  status?: Maybe<Scalars['String']>;
+  toDbClusterArn?: Maybe<Scalars['String']>;
+};
+
+export type AwsRdsGlobalClusterMembers = {
+  dBClusterArn?: Maybe<Scalars['String']>;
+  globalWriteForwardingStatus?: Maybe<Scalars['String']>;
+  id: Scalars['String'];
+  isWriter?: Maybe<Scalars['Boolean']>;
+  readers?: Maybe<Array<Maybe<Scalars['String']>>>;
+};
+
 export type AwsRecorderStatus = {
   lastStartTime?: Maybe<Scalars['String']>;
   lastStatus?: Maybe<Scalars['String']>;