fix(cynosdb): support enable/disable public access

Author: yugasun

__tests__/cynosdb.test.js

@@ -105,25 +105,36 @@ describe('Cynosdb', () => {
     ({ clusterId } = res);
   });
 
-  test('[SERVERLESS] remove', async () => {
-    await sleep(300);
-    const res = await client.remove({ clusterId });
-
-    const detail = await getClusterDetail(client.capi, clusterId);
-    expect(res).toEqual(true);
-    expect(detail.Status).toBe('isolated');
-  });
+  test('[SERVERLESS] should enable public access', async () => {
+    inputs.clusterId = clusterId;
+    inputs.enablePublicAccess = true;
 
-  test('[SERVERLESS] offline', async () => {
-    await sleep(300);
-    const res = await offlineCluster(client.capi, clusterId);
-    expect(res).toBeUndefined();
+    const res = await client.deploy(inputs);
+    expect(res).toEqual({
+      dbMode: 'SERVERLESS',
+      region: inputs.region,
+      zone: inputs.zone,
+      vpcConfig: inputs.vpcConfig,
+      instanceCount: 1,
+      // adminPassword: expect.stringMatching(pwdReg),
+      clusterId: expect.stringContaining('cynosdbmysql-'),
+      minCpu: 0.5,
+      maxCpu: 2,
+      connection: {
+        ip: expect.any(String),
+        port: 3306,
+        readList: expect.any(Array),
+      },
+      publicConnection: {
+        domain: expect.any(String),
+        ip: expect.any(String),
+        port: expect.any(Number),
+      },
+    });
   });
 
-  test('[SERVERLESS with minCpu and maxCpu] deploy', async () => {
-    inputs.dbMode = 'SERVERLESS';
-    inputs.minCpu = 2;
-    inputs.maxCpu = 4;
+  test('[SERVERLESS] should disable public access', async () => {
+    inputs.enablePublicAccess = false;
 
     const res = await client.deploy(inputs);
     expect(res).toEqual({
@@ -132,21 +143,20 @@ describe('Cynosdb', () => {
       zone: inputs.zone,
       vpcConfig: inputs.vpcConfig,
       instanceCount: 1,
-      adminPassword: expect.stringMatching(pwdReg),
+      // adminPassword: expect.stringMatching(pwdReg),
       clusterId: expect.stringContaining('cynosdbmysql-'),
-      minCpu: 2,
-      maxCpu: 4,
+      minCpu: 0.5,
+      maxCpu: 2,
       connection: {
         ip: expect.any(String),
         port: 3306,
         readList: expect.any(Array),
       },
     });
-
-    ({ clusterId } = res);
+    inputs.clusterId = undefined;
   });
 
-  test('[SERVERLESS with minCpu and maxCpu] remove', async () => {
+  test('[SERVERLESS] remove', async () => {
     await sleep(300);
     const res = await client.remove({ clusterId });
 
@@ -155,7 +165,7 @@ describe('Cynosdb', () => {
     expect(detail.Status).toBe('isolated');
   });
 
-  test('[SERVERLESS with minCpu and maxCpu] offline', async () => {
+  test('[SERVERLESS] offline', async () => {
     await sleep(300);
     const res = await offlineCluster(client.capi, clusterId);
     expect(res).toBeUndefined();

src/modules/cynosdb/apis.js

@@ -12,6 +12,9 @@ const ACTIONS = [
   'ResetAccountPassword',
   'DescribeClusters',
   'DescribeServerlessInstanceSpecs',
+  'OpenWan',
+  'CloseWan',
+  'DescribeClusterInstanceGrps',
 ];
 
 const APIS = ApiFactory({

src/modules/cynosdb/index.js

@@ -6,6 +6,8 @@ const {
   generatePwd,
   formatConnectOutput,
   resetPwd,
+  openPublicAccess,
+  closePublicAccess,
 } = require('./utils');
 const { ApiError } = require('../../utils/error');
 
@@ -46,6 +48,7 @@ class Cynosdb {
       maxCpu = 2,
       autoPause = 'yes',
       autoPauseDelay = 3600, // default 1h
+      enablePublicAccess,
     } = inputs;
 
     const outputs = {
@@ -57,6 +60,12 @@ class Cynosdb {
       dbMode,
     };
 
+    if (dbMode === 'SERVERLESS') {
+      outputs.minCpu = minCpu;
+      outputs.maxCpu = maxCpu;
+      outputs.instanceCount = 1;
+    }
+
     let isExisted = false;
     let clusterDetail = null;
     if (clusterId) {
@@ -104,20 +113,29 @@ class Cynosdb {
         dbInputs.MaxCpu = maxCpu;
         dbInputs.AutoPause = autoPause;
         dbInputs.AutoPauseDelay = autoPauseDelay;
-
-        outputs.minCpu = minCpu;
-        outputs.maxCpu = maxCpu;
-        outputs.instanceCount = 1;
       }
 
       clusterDetail = await createCluster(this.capi, dbInputs);
       outputs.clusterId = clusterDetail.ClusterId;
 
       outputs.adminPassword = dbInputs.AdminPassword;
+    } else {
+      console.log(`Cynosdb cluster ${outputs.clusterId} already exist`);
     }
 
     outputs.connection = formatConnectOutput(clusterDetail);
 
+    if (enablePublicAccess) {
+      const wanInfo = await openPublicAccess(this.capi, outputs.clusterId);
+      outputs.publicConnection = {
+        domain: wanInfo.WanDomain,
+        ip: wanInfo.WanIP,
+        port: wanInfo.WanPort,
+      };
+    } else if (enablePublicAccess === false) {
+      await closePublicAccess(this.capi, outputs.clusterId);
+    }
+
     return outputs;
   }
 

src/modules/cynosdb/utils.js

@@ -8,6 +8,9 @@ const {
   DescribeServerlessInstanceSpecs,
   OfflineCluster,
   DescribeInstances,
+  OpenWan,
+  CloseWan,
+  DescribeClusterInstanceGrps,
 } = require('./apis');
 const { ApiError } = require('../../utils/error');
 
@@ -238,6 +241,49 @@ async function resetPwd(capi, inputs) {
   return true;
 }
 
+async function getClusterGrpsInfo(capi, clusterId) {
+  const { InstanceGrpInfoList = [] } = await DescribeClusterInstanceGrps(capi, {
+    ClusterId: clusterId,
+  });
+  return InstanceGrpInfoList[0];
+}
+
+async function openPublicAccess(capi, clusterId) {
+  const gprInfo = await getClusterGrpsInfo(capi, clusterId);
+
+  console.log(`Start opening public access to cluster ${clusterId}`);
+  await OpenWan(capi, {
+    InstanceGrpId: gprInfo.InstanceGrpId,
+  });
+
+  const res = await waitResponse({
+    callback: async () => getClusterGrpsInfo(capi, clusterId),
+    targetProp: 'WanStatus',
+    targetResponse: 'open',
+    timeout: TIMEOUT,
+  });
+  console.log(`Open public access to cluster ${clusterId} success`);
+  return res;
+}
+
+async function closePublicAccess(capi, clusterId) {
+  const gprInfo = await getClusterGrpsInfo(capi, clusterId);
+
+  console.log(`Start closing public access to cluster ${clusterId}`);
+  await CloseWan(capi, {
+    InstanceGrpId: gprInfo.InstanceGrpId,
+  });
+
+  const res = await waitResponse({
+    callback: async () => getClusterGrpsInfo(capi, clusterId),
+    targetProp: 'WanStatus',
+    targetResponse: 'closed',
+    timeout: TIMEOUT,
+  });
+  console.log(`Close public access to cluster ${clusterId} success`);
+  return res;
+}
+
 module.exports = {
   TIMEOUT,
   PWD_CHARS,
@@ -252,4 +298,6 @@ module.exports = {
   offlineCluster,
   offlineInstance,
   getInstanceDetail,
+  openPublicAccess,
+  closePublicAccess,
 };