feat: add vpc

Author: yugasun

src/baas/vpc/apis.js

@@ -0,0 +1,59 @@
+function HttpError(code, message) {
+  this.code = code || 0
+  this.message = message || ''
+}
+
+HttpError.prototype = Error.prototype
+
+function apiFactory(actions) {
+  const apis = {}
+  actions.forEach((action) => {
+    apis[action] = async (apig, inputs) => {
+      const data = {
+        Version: '2017-03-12',
+        Action: action,
+        RequestClient: 'ServerlessComponent',
+        ...inputs
+      }
+
+      if (apig.options.Token) {
+        data.Token = apig.options.Token
+      }
+      try {
+        const { Response } = await apig.request(
+          data,
+          // this is preset options for apigateway
+          {
+            debug: false,
+            ServiceType: 'vpc',
+            host: 'vpc.tencentcloudapi.com'
+          },
+          false
+        )
+        if (Response && Response.Error && Response.Error.Code) {
+          throw new HttpError(Response.Error.Code, Response.Error.Message)
+        }
+        return Response
+      } catch (e) {
+        throw new HttpError(500, e.message)
+      }
+    }
+  })
+
+  return apis
+}
+
+const ACTIONS = [
+  'CreateDefaultVpc',
+  'CreateVpc',
+  'DeleteVpc',
+  'DescribeVpcs',
+  'CreateSubnet',
+  'DeleteSubnet',
+  'DescribeSubnets',
+  'ModifyVpcAttribute',
+  'ModifySubnetAttribute'
+]
+const APIS = apiFactory(ACTIONS)
+
+module.exports = APIS

src/baas/vpc/index.js

@@ -0,0 +1,157 @@
+const { Capi } = require('@tencent-sdk/capi')
+const utils = require('./utils')
+
+class Vpc {
+  constructor(credentials = {}, region) {
+    this.region = region || 'ap-guangzhou'
+    this.credentials = credentials
+    this.capi = new Capi({
+      Region: region,
+      AppId: credentials.AppId,
+      SecretId: credentials.SecretId,
+      SecretKey: credentials.SecretKey,
+      Token: credentials.Token
+    })
+  }
+
+  async deploy(inputs) {
+    const {
+      zone,
+      vpcName,
+      subnetName,
+      cidrBlock,
+      enableMulticast,
+      dnsServers,
+      domainName,
+      tags,
+      subnetTags,
+      enableSubnetBroadcast
+    } = inputs
+
+    let { vpcId, subnetId } = inputs
+
+    const handleVpc = async (vId) => {
+      let existVpc = false
+      if (vId) {
+        const detail = await utils.getVpcDetail(this.capi, vId)
+        if (detail) {
+          existVpc = true
+        }
+      }
+      const params = {
+        VpcName: vpcName
+      }
+      if (enableMulticast) {
+        params.EnableMulticast = enableMulticast
+      }
+      if (dnsServers) {
+        params.DnsServers = dnsServers
+      }
+      if (domainName) {
+        params.DomainName = domainName
+      }
+      if (existVpc) {
+        console.log(`Updating vpc ${vId}...`)
+        params.VpcId = vId
+        await utils.modifyVpc(this.capi, params)
+        console.log(`Update vpc ${vId} success`)
+      } else {
+        if (!cidrBlock) {
+          throw new Error('cidrBlock is required')
+        }
+        params.CidrBlock = cidrBlock
+        if (tags) {
+          params.Tags = tags
+        }
+        console.log(`Creating vpc ${vpcName}...`)
+        const res = await utils.createVpc(this.capi, params)
+        console.log(`Create vpc ${vpcName} success.`)
+        vId = res.VpcId
+      }
+      return vId
+    }
+
+    // check subnetId
+    const handleSubnet = async (vId, sId) => {
+      let existSubnet = false
+      if (sId) {
+        const detail = await utils.getSubnetDetail(this.capi, sId)
+        if (detail) {
+          existSubnet = true
+        }
+      }
+      const params = {
+        SubnetName: subnetName
+      }
+      if (existSubnet) {
+        console.log(`Updating subnet ${sId}...`)
+        params.SubnetId = sId
+
+        if (enableSubnetBroadcast !== undefined) {
+          params.EnableBroadcast = enableSubnetBroadcast
+        }
+        await utils.modifySubnet(this.capi, params)
+        console.log(`Update subnet ${sId} success.`)
+      } else {
+        if (vId) {
+          console.log(`Creating subnet ${subnetName}...`)
+          params.Zone = zone
+          params.VpcId = vId
+          params.CidrBlock = cidrBlock
+          if (subnetTags) {
+            params.Tags = subnetTags
+          }
+
+          const res = await utils.createSubnet(this.capi, params)
+          console.log('handleSubnet', res)
+
+          sId = res.SubnetId
+
+          if (enableSubnetBroadcast === true) {
+            await utils.modifySubnet(this.capi, {
+              SubnetId: sId,
+              EnableBroadcast: enableSubnetBroadcast
+            })
+          }
+          console.log(`Create subnet ${subnetName} success.`)
+        }
+      }
+      return sId
+    }
+
+    if (vpcName) {
+      vpcId = await handleVpc(vpcId)
+    }
+
+    if (subnetName) {
+      subnetId = await handleSubnet(vpcId, subnetId)
+    }
+
+    return {
+      region: this.region,
+      zone,
+      vpcId,
+      vpcName,
+      subnetId,
+      subnetName
+    }
+  }
+
+  async remove(inputs) {
+    const { vpcId, subnetId } = inputs
+    if (subnetId) {
+      console.log(`Start removing subnet ${subnetId}`)
+      await utils.deleteSubnet(this.capi, subnetId)
+      console.log(`Removed subnet ${subnetId}`)
+    }
+    if (vpcId) {
+      console.log(`Start removing vpc ${vpcId}`)
+      await utils.deleteVpc(this.capi, vpcId)
+      console.log(`Removed vpc ${vpcId}`)
+    }
+
+    return {}
+  }
+}
+
+module.exports = Vpc

src/baas/vpc/index.test.js

@@ -0,0 +1,25 @@
+const Vpc = require('./index')
+
+async function runTest() {
+  const credentials = {
+    SecretId: '',
+    SecretKey: ''
+  }
+  const inputs = {
+    region: 'ap-guangzhou',
+    zone: 'ap-guangzhou-2',
+    vpcName: 'serverless',
+    subnetName: 'serverless',
+    cidrBlock: '10.0.0.0/16'
+  }
+  const vpc = new Vpc(credentials, inputs.region)
+  const outputs = await vpc.deploy(inputs)
+
+  await vpc.remove(outputs)
+}
+
+runTest()
+
+process.on('unhandledRejection', (e) => {
+  console.log(e);
+})

src/baas/vpc/utils.js

@@ -0,0 +1,97 @@
+const {
+  DescribeVpcs,
+  DescribeSubnets,
+  CreateVpc,
+  DeleteVpc,
+  CreateSubnet,
+  DeleteSubnet,
+  ModifyVpcAttribute,
+  ModifySubnetAttribute
+} = require('./apis')
+
+const utils = {
+  /**
+   *
+   * @param {object} capi capi instance
+   * @param {string} vpcId
+   */
+  async getVpcDetail(capi, vpcId) {
+    // get instance detail
+    try {
+      const res = await DescribeVpcs(capi, {
+        VpcIds: [vpcId]
+      })
+      if (res.VpcSet) {
+        const {
+          VpcSet: [detail]
+        } = res
+        return detail
+      }
+      return null
+    } catch (e) {
+      console.log(e)
+      return null
+    }
+  },
+
+  /**
+   *
+   * @param {object} capi capi instance
+   * @param {string} vpcId
+   */
+  async getSubnetDetail(capi, subnetId) {
+    try {
+      const res = await DescribeSubnets(capi, {
+        SubnetIds: [subnetId]
+      })
+      if (res.SubnetSet) {
+        const {
+          SubnetSet: [detail]
+        } = res
+        return detail
+      }
+      return null
+    } catch (e) {
+      console.log(e)
+      return null
+    }
+  },
+
+  async createVpc(capi, inputs) {
+    const res = await CreateVpc(capi, inputs)
+    if (res.Vpc && res.Vpc.VpcId) {
+      const { Vpc } = res
+      return Vpc
+    }
+  },
+
+  async modifyVpc(capi, inputs) {
+    await ModifyVpcAttribute(capi, inputs)
+  },
+
+  async deleteVpc(capi, vpcId) {
+    await DeleteVpc(capi, {
+      VpcId: vpcId
+    })
+  },
+
+  async createSubnet(capi, inputs) {
+    const res = await CreateSubnet(capi, inputs)
+    if (res.Subnet && res.Subnet.SubnetId) {
+      const { Subnet } = res
+      return Subnet
+    }
+  },
+
+  async modifySubnet(capi, inputs) {
+    await ModifySubnetAttribute(capi, inputs)
+  },
+
+  async deleteSubnet(capi, subnetId) {
+    await DeleteSubnet(capi, {
+      SubnetId: subnetId
+    })
+  }
+}
+
+module.exports = utils