add terraformer implement

Author: lyu571

package.json

@@ -2,7 +2,7 @@
     "name": "vscode-tencentcloud-terraform",
     "displayName": "Tencent Cloud Terraform",
     "description": "VS Code extension for developing with Terraform on Tencent Cloud",
-    "version": "0.0.4",
+    "version": "0.0.5",
     "license": "MIT",
     "publisher": "Tencent-Cloud",
     "icon": "images/tc-tf-logo.png",
@@ -46,6 +46,8 @@
         "onCommand:tcTerraform.visualize",
         "onCommand:tcTerraform.test",
         "onCommand:tcTerraform.push",
+        "onCommand:tcTerraformer.import",
+        "onCommand:tcTerraformer.plan",
         "workspaceContains:**/*.tf",
         "onLanguage:terraform"
     ],
@@ -151,6 +153,16 @@
                 "command": "tcTerraform.push",
                 "title": "Push",
                 "category": "TencentCloud Terraform"
+            },
+            {
+                "command": "tcTerraformer.import",
+                "title": "Import",
+                "category": "TencentCloud Terraformer"
+            },
+            {
+                "command": "tcTerraformer.plan",
+                "title": "Plan",
+                "category": "TencentCloud Terraformer"
             }
         ],
         "configuration": {

src/cloudShell.ts

@@ -14,7 +14,7 @@ import * as TelemetryWrapper from "vscode-extension-telemetry-wrapper";
 import { BaseShell } from "./baseShell";
 // import { aciConfig, Constants, exportContainerCmd, exportTestScript } from "./constants";
 // import { azFileDelete, azFilePush, escapeFile, TerraformCommand, TestOption } from "./shared";
-import { TerraformCommand } from "./common";
+import { TerraformCommand } from "./commons/commands";
 import { terraformChannel } from "./terraformChannel";
 // import { getStorageAccountforCloudShell, IStorageAccount } from "./utils/cloudShellUtils";
 import * as settingUtils from "./utils/settingUtils";

src/common.ts

@@ -1,18 +1,43 @@
 import { commands, env, Uri } from "vscode";
 import { terraformShellManager } from "../terraformShellManager";
-import { TerraformCommand } from '../common';
+
+"use strict";
+
+export enum TerraformCommand {
+    Init = "terraform init",
+    Plan = "terraform plan",
+    Apply = "terraform apply",
+    Import = "terraform import",
+    Refresh = "terraform refresh",
+    Destroy = "terraform destroy",
+    Validate = "terraform validate",
+    Show = "terraform show",
+    State = "terraform state"
+}
+
+export enum TerraformerCommand {
+    Plan = "terraformer plan",
+    Import = "terraformer import"
+}
+
+export enum TcCliCommand {
+    Login = "tccli configure",
+    Service = "tccli service",
+}
+
 
 const openURL = "tcTerraform.openurl";
-const executeImport = TerraformCommand.Import;
+// const executeImport = TerraformCommand.Import;
+const executeImport = TerraformerCommand.Import;
 
 export function registerHelpCommands() {
-    commands.registerCommand(openURL, function (url: string) {
+    commands.registerCommand(cmds.openURL, function (url: string) {
         env.openExternal(Uri.parse(url));
     });
 }
 
 export function registerResourceCommands() {
-    commands.registerCommand(executeImport, function (param: any) {
+    commands.registerCommand(cmds.executeImport, function (param: any) {
         // terraformShellManager.getShell().runTerraformCmd(importObject);
         terraformShellManager.getIntegratedShell().import(param, param.fileName);
     });

src/commons/commands.ts

@@ -1,15 +1,17 @@
 // The module 'vscode' contains the VS Code extensibility API
 // Import the module and reference it with the alias vscode in your code below
 import * as vscode from 'vscode';
+import * as settingUtils from "./utils/settingUtils";
 import { init } from "vscode-nls-i18n";
-import { TerraformCommand } from './common';
+import { TerraformCommand } from "./commons/commands";
 import { terraformShellManager } from "./terraformShellManager";
-import * as settingUtils from './utils/settingUtils';
 import { DialogOption } from "./utils/uiUtils";
 import { TerraformCompletionProvider } from './autocomplete/TerraformCompletionProvider';
 import { TerraformDefinitionProvider } from './autocomplete/TerraformDefinitionProvider';
 import { registerCommon } from './commons';
 import { registerView } from './views';
+import { TerraformRunner } from './utils/terraformRunner';
+import { TerraformerRunner } from './utils/terraformerRunner';
 
 const TF_MODE: vscode.DocumentFilter = { language: 'terraform', scheme: 'file' };
 
@@ -18,8 +20,8 @@ const TF_MODE: vscode.DocumentFilter = { language: 'terraform', scheme: 'file' }
 export async function activate(context: vscode.ExtensionContext) {
     console.log('Congratulations, your extension "TencentCloud Terraform" is now active!');
 
-    await settingUtils.checkTerraformInstalled();
-    await settingUtils.checkTCCLIInstalled();
+    await TerraformRunner.getInstance().checkInstalled();
+    await TerraformerRunner.getInstance().checkInstalled();
 
     let disposableLogin = vscode.commands.registerCommand('tcTerraform.login', async () => {
         // to-do
@@ -96,6 +98,19 @@ export async function activate(context: vscode.ExtensionContext) {
 
     context.subscriptions.push(disposablePush);
 
+    // terraformer
+    let disposableTferImport = vscode.commands.registerCommand('tcTerraformer.import', async () => {
+        terraformShellManager.getShell().runTerraformCmd(TerraformCommand.Destroy);
+    });
+
+    context.subscriptions.push(disposableTferImport);
+
+    let disposableTferPlan = vscode.commands.registerCommand('tcTerraformer.plan', async () => {
+        terraformShellManager.getShell().runTerraformCmd(TerraformCommand.Destroy);
+    });
+
+    context.subscriptions.push(disposableTferPlan);
+
     // auto-complete
     console.log('activate the auto complete(snippets and lint) feature');
     context.subscriptions.push(vscode.languages.registerCompletionItemProvider(TF_MODE, new TerraformCompletionProvider(), '.'));

src/extension.ts

@@ -15,7 +15,7 @@ export class CvmService implements ITencentCloudAPI {
                 //'xxx': "yyy"
             },
             'import': {
-                'filename': 'cvm.tf'
+                'file': 'cvm.tf'
             }
         };
     }
@@ -25,7 +25,7 @@ export class CvmService implements ITencentCloudAPI {
             // find all instances   
         }).then(
             (result) => {
-                console.debug('[DEBUG]--------------------------------result:', result);
+                // console.debug('[DEBUG]--------------------------------result:', result);
                 if (result.TotalCount === 0) {
                     throw new Error('[Warn] DescribeInstances result.TotalCount is 0.');
                 }

src/import/cvm.ts

@@ -17,13 +17,14 @@ import { executeCommand } from "./utils/cpUtils";
 import { drawGraph } from "./utils/dotUtils";
 import { isDotInstalled } from "./utils/dotUtils";
 import { selectWorkspaceFolder } from "./utils/workspaceUtils";
-import { checkTerraformInstalled } from "./terraformUtils";
-import { TerraformCommand } from "./common";
+import { TerraformCommand } from "./commons/commands";
 import * as helper from "./utils/helper";
 import { command } from "./commons/tencent/commands";
 import { promisify } from "util";
 import { ChildProcess } from "child_process";
 import * as cp from "child_process";
+import { TerraformerRunner, CommandType, FlagType, FlagsMap } from "./utils/terraformerRunner";
+import { values } from "lodash";
 
 // import stripAnsi from 'strip-ansi';
 
@@ -66,72 +67,54 @@ export class IntegratedShell extends BaseShell {
     }
 
     public async import(params: any, file?: string): Promise<void> {
-        // const fileName = "cvm.tf";
-        await checkTerraformInstalled();
+
+        const runner = TerraformerRunner.getInstance();// terraform or terraformer
+
+        await runner.checkInstalled();
 
         const cwd: string = await selectWorkspaceFolder();
         if (!cwd) {
             TelemetryWrapper.sendError(Error("noWorkspaceSelected"));
             return;
         }
 
-        const fileName = (file === undefined) ? params.resource.type + '.tf' : file;
+        const cmd = CommandType.Import;
+        const flags: FlagsMap[] = [
+            {
+                flag: FlagType.Resources,
+                value: ["mysql", "vpc", "subnet", "security_group"].join(",")
+            },
+            {
+                flag: FlagType.Filter,
+                value: ["tencentcloud_mysql_instance", "cdb-fitq5t9h"].join("=")
+            },
+            {
+                flag: FlagType.Regions,
+                value: "ap-guangzhou"
+            },
+            {
+                flag: FlagType.Redirect,
+                value: "terraformer_default_result"
+            },
+        ];
 
-        const defaultContents = `resource "${params.resource.type}" "${params.resource.name}" {}`;
-        const resAddress = `${params.resource.type}.${params.resource.name}`;
+        console.debug("[DEBUG]#### Executing import command. cwd:[%s], cmd:[%s], flags:[%s]", cwd, cmd.toString, flags.toString);
+        const result = await runner.executeImport(cwd, "", cmd, flags);
+        console.debug("[DEBUG]#### Executed import command. result:[%s]", result);
 
-        const tfFile: string = path.join(cwd, fileName);
 
-        // reset file
-        await this.resetFileContent(tfFile, defaultContents);
-        // reset state
-        await this.resetTFState(resAddress);
 
-        const importArgs = ['import ', params.resource.type, '.', params.resource.name, ' ', params.resource.id].join('');
-        console.debug("[DEBUG]#### import cmd: args=[%s], defaultContents=[%s]", importArgs, defaultContents);
+        const content: string = await runner.executeShow(cwd);
 
-        const importRet: string = await executeCommand(
-            "terraform",
-            [importArgs],
-            {
-                shell: true,
-                cwd,
-            },
-        );
-
-        // await this.runTerraformCmd("terraform " + importArgs);
-
-        const content: string =
-            await executeCommand(
-                "terraform",
-                ["show"],
-                {
-                    shell: true,
-                    cwd,
-                }
-            );
 
-        console.debug("[DEBUG]#### import content:[%s]", content);
-        fse.writeFileSync(tfFile, content);
+        const tfFile: string = result;
 
         vscode.window.showInformationMessage(`The resource:[${params.resource.type}] has been imported successfully, generated tf file:[${tfFile}].`);
-        await commands.executeCommand("vscode.open", Uri.file(tfFile), ViewColumn.Active || ViewColumn.One);
-    }
 
-    private async resetFileContent(tfFile: string, defaultContents: string) {
-        if (!fse.existsSync(tfFile)) {
-            fse.writeFileSync(tfFile, defaultContents);
-        } else {
-            await fse.writeFile(tfFile, defaultContents);
-        }
+        await commands.executeCommand("vscode.open", Uri.file(tfFile), ViewColumn.Active || ViewColumn.One);
     }
 
-    private async resetTFState(resAddress: string) {
-        // const runFunc = () => this.runTerraformCmdWithoutTerminal(TerraformCommand.State, ['rm', '-lock=false', resAddress]);
-        // await helper.retryF(runFunc);
 
-        await this.runTerraformCmd(TerraformCommand.State, ['rm', '-lock=false', resAddress]);
-    }
 
     public async runTerraformCmdWithoutTerminal(tfCommand: string, args?: string[]) {
         const cmd = [tfCommand, ...(args || [])].join(' ');

src/integratedShell.ts

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Tencent Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+"use strict";
+
+export abstract class BaseRunner {
+
+    public tfExecutor: any;
+
+    constructor() {
+        this.init();
+    }
+
+    /**
+     * execute this command to prepare the terraform import.
+     * @param cwd 
+     * @returns 
+     */
+    public abstract preImport(cwd: string, args?: any, path?: string): Promise<any>;
+
+    /**
+     * execute this command to display/output the terraform state.
+     * @param cwd 
+     * @returns 
+     */
+    public abstract executeShow(cwd: string, args?: string): Promise<any>;
+
+    /**
+     * execute this command to import the existing resource from tencentcloud
+     * @param cwd 
+     * @param args 
+     * @returns 
+     */
+    public abstract executeImport(cwd: string, args?: string): Promise<any>;
+
+    /**
+     * execute this command to handle post of the terraform import.
+     * @param cwd 
+     * @returns 
+     */
+    public abstract postImport(cwd: string, args?: string): Promise<any>;
+
+    /**
+     * check binary whether ready or not
+     */
+    public abstract checkInstalled(): Promise<void>;
+
+    public abstract init(): void;
+}

src/terraformUtils.ts

@@ -24,12 +24,12 @@ export async function executeCommand(command: string, args: string[], options: c
 
         childProc.stderr.on("data", (raw: string | Buffer) => {
             const data = stripAnsi(raw.toString());
+            console.error("Error found in stderr.on: %s", data);
             terraformChannel.append(data);
         });
 
-        // childProc.on("error", reject);
         childProc.on("error", (err: any) => {
-            console.error(err);
+            console.error("Error found in childProc.on error: %s", err);
             // reject(err);
         });