fix(cfs): support tag config

Author: yugasun

__tests__/cfs.test.js

@@ -7,6 +7,7 @@ describe('Cfs', () => {
     SecretId: process.env.TENCENT_SECRET_ID,
     SecretKey: process.env.TENCENT_SECRET_KEY,
   };
+
   const inputs = {
     fsName: 'cfs-test',
     region: 'ap-guangzhou',
@@ -16,6 +17,12 @@ describe('Cfs', () => {
       vpcId: process.env.CFS_VPC_ID,
       subnetId: process.env.CFS_SUBNET_ID,
     },
+    tags: [
+      {
+        key: 'slstest',
+        value: 'slstest',
+      },
+    ],
   };
   const cfs = new Cfs(credentials, process.env.REGION);
 
@@ -29,6 +36,7 @@ describe('Cfs', () => {
       protocol: 'NFS',
       storageType: 'SD',
       fileSystemId: expect.stringContaining('cfs-'),
+      tags: inputs.tags,
     });
     inputs.fileSystemId = res.fileSystemId;
   });

src/modules/cfs/index.js

@@ -1,5 +1,6 @@
 const { Capi } = require('@tencent-sdk/capi');
 const apis = require('./apis');
+const Tag = require('../tag/index');
 
 class CFS {
   constructor(credentials = {}, region) {
@@ -11,6 +12,8 @@ class CFS {
       SecretKey: credentials.SecretKey,
       Token: credentials.Token,
     });
+
+    this.tagClient = new Tag(this.credentials, this.region);
   }
 
   async deploy(inputs = {}) {
@@ -71,15 +74,30 @@ class CFS {
         }
       }
 
-      if (inputs.tags) {
-        cfsInputs.ResourceTags = inputs.tags;
-      }
       console.log(`Creating CFS ${inputs.fsName}`);
       const { FileSystemId } = await apis.createCfs(this.capi, cfsInputs);
       console.log(`Created CFS ${inputs.fsName}, id ${FileSystemId} successful`);
       outputs.fileSystemId = FileSystemId;
     }
 
+    if (inputs.tags) {
+      try {
+        const tags = await this.tagClient.deployResourceTags({
+          tags: inputs.tags.map((item) => ({ TagKey: item.key, TagValue: item.value })),
+          serviceType: 'cfs',
+          resourcePrefix: 'filesystem',
+          resourceId: outputs.fileSystemId,
+        });
+
+        outputs.tags = tags.map((item) => ({
+          key: item.TagKey,
+          value: item.TagValue,
+        }));
+      } catch (e) {
+        console.log(`Deploy cfs tags error: ${e.message}`);
+      }
+    }
+
     return outputs;
   }
 

src/modules/scf/index.js

@@ -313,62 +313,6 @@ class Scf {
     return triggerResult;
   }
 
-  // deploy tags
-  async deployTags(funcInfo, inputs) {
-    console.log(`Adding tags for function ${inputs.name} in ${this.region}`);
-    const inputKeys = [];
-    const inputTags = Object.entries(inputs.tags).map(([key, value]) => {
-      inputKeys.push(key);
-      return {
-        Key: key,
-        Value: value,
-      };
-    });
-    const funcTags = funcInfo.Tags;
-    const funcTagKeys = funcTags.map((item) => item.Key);
-
-    const detachTags = [];
-    const attachTags = [];
-
-    for (let i = 0; i < funcTags.length; i++) {
-      const funcTag = funcTags[i];
-      if (inputKeys.indexOf(funcTag.Key) === -1) {
-        detachTags.push({
-          TagKey: funcTag.Key,
-        });
-      } else {
-        const inputTagVal = inputs.tags[funcTag.Key];
-        const funcTagVal = funcTags[i].Value;
-        if (inputTagVal !== funcTagVal) {
-          attachTags.push({
-            TagKey: funcTag.Key,
-            TagValue: inputTagVal,
-          });
-        }
-      }
-    }
-
-    for (let i = 0; i < inputTags.length; i++) {
-      const inputTag = inputTags[i];
-      if (funcTagKeys.indexOf(inputTag.Key) === -1) {
-        attachTags.push({
-          TagKey: inputTag.Key,
-          TagValue: inputTag.Value,
-        });
-      }
-    }
-
-    await this.tagClient.deploy({
-      resourceIds: [`${funcInfo.Namespace}/function/${funcInfo.FunctionName}`],
-      resourcePrefix: 'namespace',
-      serviceType: 'scf',
-      detachTags,
-      attachTags,
-    });
-
-    return attachTags;
-  }
-
   // delete function
   async deleteFunction(namespace, functionName) {
     namespace = namespace || CONFIGS.defaultNamespace;
@@ -676,7 +620,13 @@ class Scf {
 
     // create/update tags
     if (inputs.tags) {
-      const deployedTags = await this.deployTags(funcInfo, inputs);
+      const deployedTags = await this.tagClient.deployResourceTags({
+        tags: Object.entries(inputs.tags).map(([TagKey, TagValue]) => ({ TagKey, TagValue })),
+        resourceId: `${funcInfo.Namespace}/function/${funcInfo.FunctionName}`,
+        serviceType: 'scf',
+        resourcePrefix: 'namespace',
+      });
+
       outputs.Tags = deployedTags.map((item) => ({
         Key: item.TagKey,
         Value: item.TagValue,

src/modules/tag/apis.js

@@ -8,6 +8,7 @@ const ACTIONS = [
   'CreateTag',
   'DeleteTag',
   'DescribeTags',
+  'DescribeResourceTagsByResourceIds',
 ];
 
 const APIS = ApiFactory({

src/modules/tag/index.js

@@ -19,6 +19,31 @@ class Tag {
     return result;
   }
 
+  async getResourceTags({ resourceId, serviceType, resourcePrefix, offset = 0, limit = 100 }) {
+    const { Tags, TotalCount } = await this.request({
+      Action: 'DescribeResourceTagsByResourceIds',
+      Limit: limit,
+      Offset: offset,
+      ServiceType: serviceType,
+      ResourceRegion: this.region,
+      ResourcePrefix: resourcePrefix,
+      ResourceIds: [resourceId],
+    });
+    if (TotalCount > limit) {
+      return Tags.concat(
+        await this.getResourceTags({
+          resourceId,
+          serviceType,
+          resourcePrefix,
+          offset: offset + limit,
+          limit,
+        }),
+      );
+    }
+
+    return Tags;
+  }
+
   async getTagList(offset = 0, limit = 100) {
     const { Tags, TotalCount } = await this.request({
       Action: 'DescribeTags',
@@ -41,14 +66,13 @@ class Tag {
   }
 
   async getScfResourceTags(inputs) {
-    const data = {
-      Action: 'DescribeResourceTags',
-      ResourcePrefix: 'namespace',
-      ResourceId: `${inputs.namespace || 'default'}/function/${inputs.functionName}`,
-    };
+    const tags = await this.getResourceTags({
+      resourceId: `${inputs.namespace || 'default'}/function/${inputs.functionName}`,
+      serviceType: 'scf',
+      resourcePrefix: 'namespace',
+    });
 
-    const { Rows } = await this.request(data);
-    return Rows;
+    return tags;
   }
 
   async attachTags({ serviceType, resourcePrefix, resourceIds, tags }) {
@@ -145,6 +169,62 @@ class Tag {
 
     return true;
   }
+
+  async deployResourceTags({ tags, resourceId, serviceType, resourcePrefix }) {
+    console.log(`Adding tags for ${resourceId} in ${this.region}`);
+    const inputKeys = [];
+    tags.forEach(({ TagKey }) => {
+      inputKeys.push(TagKey);
+    });
+
+    const oldTags = await this.getResourceTags({
+      resourceId: resourceId,
+      serviceType: serviceType,
+      resourcePrefix: resourcePrefix,
+    });
+
+    const oldTagKeys = [];
+    oldTags.forEach(({ TagKey }) => {
+      oldTagKeys.push(TagKey);
+    });
+
+    const detachTags = [];
+    const attachTags = [];
+    const leftTags = [];
+
+    oldTags.forEach((item) => {
+      if (inputKeys.indexOf(item.TagKey) === -1) {
+        detachTags.push({
+          TagKey: item.TagKey,
+        });
+      } else {
+        const [inputTag] = tags.filter((t) => t.TagKey === item.TagKey);
+        const oldTagVal = item.TagValue;
+
+        if (inputTag.TagValue !== oldTagVal) {
+          attachTags.push(inputTag);
+        } else {
+          leftTags.push(item);
+        }
+      }
+    });
+
+    tags.forEach((item) => {
+      if (oldTagKeys.indexOf(item.TagKey) === -1) {
+        attachTags.push(item);
+      }
+    });
+
+    await this.deploy({
+      resourceIds: [resourceId],
+      resourcePrefix: resourcePrefix,
+      serviceType: serviceType,
+      detachTags,
+      attachTags,
+    });
+
+    return leftTags.concat(attachTags);
+  }
 }
 
 module.exports = Tag;