fix(tag): update deploy tag flow

Author: yugasun

__tests__/scf.test.js

@@ -90,7 +90,7 @@ describe('Scf', () => {
     publish: true,
     traffic: 0.8,
     tags: {
-      mytest: 'abc',
+      test: 'test',
     },
     environment: {
       variables: {
@@ -279,7 +279,12 @@ describe('Scf', () => {
       CodeResult: 'success',
       CodeError: '',
       ErrNo: 0,
-      Tags: expect.any(Array),
+      Tags: [
+        {
+          Key: 'test',
+          Value: 'test',
+        },
+      ],
       AccessInfo: { Host: '', Vip: '' },
       Type: 'Event',
       CfsConfig: {

__tests__/tag.test.js

@@ -6,20 +6,52 @@ describe('Tag', () => {
     SecretKey: process.env.TENCENT_SECRET_KEY,
   };
   const functionName = 'serverless-unit-test';
-  const inputs = {
-    resource: `qcs::scf:${process.env.REGION}:uin/${process.env.TENCENT_UIN}:namespace/default/function/${functionName}`,
-    replaceTags: { tagKey: 'tagValue' },
-    deleteTags: { abcdd: 'def' },
+  const tagItem = { TagKey: 'slstest', TagValue: 'slstest' };
+  const commonInputs = {
+    resourceIds: [`default/function/${functionName}`],
+    resourcePrefix: 'namespace',
+    serviceType: 'scf',
   };
   const tag = new Tag(credentials, process.env.REGION);
 
-  test('should success modify tags', async () => {
-    const res = await tag.deploy(inputs);
-    const [curTag] = await tag.getScfResourceTags({
+  test('attach tags', async () => {
+    delete commonInputs.addTags;
+    commonInputs.attachTags = [tagItem];
+
+    const res = await tag.deploy(commonInputs);
+    const tagList = await tag.getScfResourceTags({
+      functionName: functionName,
+    });
+    const [exist] = tagList.filter(
+      (item) => item.TagKey === tagItem.TagKey && item.TagValue === tagItem.TagValue,
+    );
+    expect(res).toBe(true);
+    expect(exist).toBeDefined();
+  });
+
+  test('detach tags', async () => {
+    delete commonInputs.addTags;
+    delete commonInputs.attachTags;
+    commonInputs.detachTags = [tagItem];
+
+    const res = await tag.deploy(commonInputs);
+    const tagList = await tag.getScfResourceTags({
       functionName: functionName,
     });
+    const [exist] = tagList.filter(
+      (item) => item.TagKey === tagItem.TagKey && item.TagValue === tagItem.TagValue,
+    );
     expect(res).toBe(true);
-    expect(curTag.TagKey).toBe('tagKey');
-    expect(curTag.TagValue).toBe('tagValue');
+    expect(exist).toBeUndefined();
+  });
+
+  test('delete tags', async () => {
+    const res = await tag.deleteTags([tagItem]);
+
+    expect(res).toBe(true);
+
+    const exist = await tag.isTagExist(tagItem);
+
+    expect(exist).toBe(false);
   });
 });

src/modules/scf/index.js

@@ -316,17 +316,57 @@ class Scf {
   // deploy tags
   async deployTags(funcInfo, inputs) {
     console.log(`Adding tags for function ${inputs.name} in ${this.region}`);
-    const deleteTags = {};
-    for (let i = 0; i < funcInfo.Tags.length; i++) {
-      if (!inputs.tags.hasOwnProperty(funcInfo.Tags[i].Key)) {
-        deleteTags[funcInfo.Tags[i].Key] = funcInfo.Tags[i].Value;
+    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({
-      resource: `qcs::scf:${this.region}::lam/${funcInfo.FunctionId}`,
-      replaceTags: inputs.tags,
-      deleteTags: deleteTags,
+      resourceIds: [`${funcInfo.Namespace}/function/${funcInfo.FunctionName}`],
+      resourcePrefix: 'namespace',
+      serviceType: 'scf',
+      detachTags,
+      attachTags,
     });
+
+    return attachTags;
   }
 
   // delete function
@@ -636,7 +676,11 @@ class Scf {
 
     // create/update tags
     if (inputs.tags) {
-      await this.deployTags(funcInfo, inputs);
+      const deployedTags = await this.deployTags(funcInfo, inputs);
+      outputs.Tags = deployedTags.map((item) => ({
+        Key: item.TagKey,
+        Value: item.TagValue,
+      }));
     }
 
     // create/update/delete triggers

src/modules/tag/apis.js

@@ -1,6 +1,14 @@
 const { ApiFactory } = require('../../utils/api');
 
-const ACTIONS = ['ModifyResourceTags', 'DescribeResourceTags'];
+const ACTIONS = [
+  'ModifyResourceTags',
+  'DescribeResourceTags',
+  'AttachResourcesTag',
+  'DetachResourcesTag',
+  'CreateTag',
+  'DeleteTag',
+  'DescribeTags',
+];
 
 const APIS = ApiFactory({
   // debug: true,

src/modules/tag/index.js

@@ -19,6 +19,27 @@ class Tag {
     return result;
   }
 
+  async getTagList(offset = 0, limit = 100) {
+    const { Tags, TotalCount } = await this.request({
+      Action: 'DescribeTags',
+      Limit: limit,
+      Offset: offset,
+    });
+    if (TotalCount > limit) {
+      return Tags.concat(await this.getTagList(offset + limit, limit));
+    }
+
+    return Tags;
+  }
+
+  async isTagExist(tag) {
+    const tagList = await this.getTagList();
+    const [exist] = tagList.filter(
+      (item) => item.TagKey === tag.TagKey && item.TagValue === tag.TagValue,
+    );
+    return !!exist;
+  }
+
   async getScfResourceTags(inputs) {
     const data = {
       Action: 'DescribeResourceTags',
@@ -30,33 +51,97 @@ class Tag {
     return Rows;
   }
 
-  async deploy(inputs = {}) {
-    const tagsInputs = {
-      Action: 'ModifyResourceTags',
-      Resource: inputs.resource,
+  async attachTags({ serviceType, resourcePrefix, resourceIds, tags }) {
+    const commonInputs = {
+      Action: 'AttachResourcesTag',
+      ResourceIds: resourceIds,
+      ServiceType: serviceType,
+      ResourceRegion: this.region,
+      ResourcePrefix: resourcePrefix,
     };
+    // if tag not exsit, create it
 
-    const { replaceTags = {}, deleteTags = {} } = inputs;
+    for (let i = 0; i < tags.length; i++) {
+      const currentTag = tags[i];
+      const tagExist = await this.isTagExist(currentTag);
+      if (!tagExist) {
+        await this.createTag(currentTag);
+      }
+      const tagInputs = {
+        ...commonInputs,
+        ...currentTag,
+      };
+      await this.request(tagInputs);
+    }
+  }
 
-    if (Object.keys(replaceTags).length > 0) {
-      tagsInputs.ReplaceTags = Object.entries(replaceTags).map(([key, val]) => ({
-        TagKey: key,
-        TagValue: val,
-      }));
+  async detachTags({ serviceType, resourcePrefix, resourceIds, tags }) {
+    const commonInputs = {
+      Action: 'DetachResourcesTag',
+      ResourceIds: resourceIds,
+      ServiceType: serviceType,
+      ResourceRegion: this.region,
+      ResourcePrefix: resourcePrefix,
+    };
+    for (let i = 0; i < tags.length; i++) {
+      const tagInputs = {
+        ...commonInputs,
+        ...tags[i],
+      };
+      delete tagInputs.TagValue;
+      await this.request(tagInputs);
     }
-    if (Object.keys(deleteTags).length > 0) {
-      tagsInputs.DeleteTags = Object.keys(deleteTags).map((key) => ({
-        TagKey: key,
-      }));
+  }
+
+  async createTag(tag) {
+    console.log(`Creating tag key: ${tag.TagKey}, value: ${tag.TagValue}`);
+    await this.request({
+      Action: 'CreateTag',
+      ...tag,
+    });
+
+    return tag;
+  }
+
+  async deleteTag(tag) {
+    console.log(`Deleting tag key: ${tag.TagKey}, value: ${tag.TagValue}`);
+    await this.request({
+      Action: 'DeleteTag',
+      ...tag,
+    });
+
+    return true;
+  }
+
+  async deleteTags(tags) {
+    for (let i = 0; i < tags.length; i++) {
+      await this.deleteTag(tags[i]);
     }
 
+    return true;
+  }
+
+  async deploy(inputs = {}) {
+    const { detachTags = [], attachTags = [], serviceType, resourceIds, resourcePrefix } = inputs;
+
     console.log(`Updating tags`);
     try {
-      await this.request(tagsInputs);
+      await this.detachTags({
+        tags: detachTags,
+        serviceType,
+        resourceIds,
+        resourcePrefix,
+      });
+      await this.attachTags({
+        tags: attachTags,
+        serviceType,
+        resourceIds,
+        resourcePrefix,
+      });
     } catch (e) {
       console.log(e);
     }
-    console.log(`Update tags success.`);
+    console.log(`Update tags success`);
 
     return true;
   }