NCloud Terraform 변환 코드 구현

apps/terraform/convertor/TerraformConvertor.ts

@@ -0,0 +1,158 @@
+import { NCloudModel } from '../interface/NCloudModel';
+import { NCloudProvider } from '../model/NCloudProvider';
+import { CloudCanvasNode } from '../interface/CloudCanvasNode';
+import { parseToNCloudModel } from '../util/resourceParser';
+
+export class TerraformConvertor {
+    private resources: NCloudModel[];
+    private provider: NCloudProvider;
+    private resourceNameMap: Map<string, string>;
+
+    constructor(provider: NCloudProvider) {
+        this.provider = provider;
+        this.resources = [];
+        this.resourceNameMap = new Map();
+    }
+
+    addResourceFromJson(jsonData: { nodes?: CloudCanvasNode[] }) {
+        jsonData.nodes?.forEach((node => {
+            try {
+                const resource = parseToNCloudModel(node);
+                this.addResource(resource);
+            } catch (error) {
+                console.warn(`Skipping unsupported node type: ${node.type}`);
+            }
+        }));
+    }
+
+    addResource(resource: NCloudModel) {
+        this.resources.push(resource);
+        this.resourceNameMap.set(resource.serviceType, resource.name);
+    }
+
+
+
+    private replaceReferences(properties: { [key: string]: any }): { [key: string]: any } {
+        const result = { ...properties };
+
+        for (const [key, value] of Object.entries(result)) {
+            if (typeof value === 'string') {
+                switch(value) {
+                    case 'VPC_ID_PLACEHOLDER':
+                        const vpcName = this.resourceNameMap.get('ncloud_vpc');
+                        result[key] = `ncloud_vpc.${vpcName}.id`;
+                        break;
+                    case 'VPC_ACL_PLACEHOLDER':
+                        const vpcAclName = this.resourceNameMap.get('ncloud_vpc');
+                        result[key] = `ncloud_vpc.${vpcAclName}.default_network_acl_no`;
+                        break;
+                    case 'SUBNET_ID_PLACEHOLDER':
+                        const subnetName = this.resourceNameMap.get('ncloud_subnet');
+                        result[key] = `ncloud_subnet.${subnetName}.id`;
+                        break;
+                    case 'ACG_ID_PLACEHOLDER':
+                        const acgName = this.resourceNameMap.get('ncloud_access_control_group');
+                        result[key] = `ncloud_access_control_group.${acgName}.id`;
+                        break;
+                    case 'LOGIN_KEY_NAME_PLACEHOLDER':
+                        const loginKeyName = this.resourceNameMap.get('ncloud_login_key');
+                        result[key] = `ncloud_login_key.${loginKeyName}.key_name`;
+                        break;
+                    case 'NIC_ID_PLACEHOLDER':
+                        const nicName = this.resourceNameMap.get('ncloud_network_interface');
+                        result[key] = `ncloud_network_interface.${nicName}.id`;
+                        break;
+                    case 'SERVER_ID_PLACEHOLDER':
+                        const serverName = this.resourceNameMap.get('ncloud_server');
+                        result[key] = `ncloud_server.${serverName}.id`;
+                        break;
+                }
+            } else if (Array.isArray(value)) {
+                result[key] = value.map(item => {
+                    if (typeof item === 'string') {
+                        const replacedValue = this.replaceReferences({ temp: item }).temp;
+                        return replacedValue;
+                    }
+                    return this.replaceReferences(item);
+                });
+            } else if (typeof value === 'object' && value !== null) {
+                result[key] = this.replaceReferences(value);
+            }
+        }
+
+        return result;
+    }
+
+    private formatValue(value: any): string {
+        if (Array.isArray(value)) {
+            return `[${value.map(item => this.formatValue(item)).join(', ')}]`;
+        }
+
+        if (typeof value === 'string') {
+            const ncloudRefPattern = /^ncloud_[a-zA-Z_]+\.[a-zA-Z_-]+\.[a-zA-Z_]+$/;
+            const varRefPattern = /^var\.[a-zA-Z_]+$/;
+
+            if (ncloudRefPattern.test(value) || varRefPattern.test(value)) {
+                return value;
+            }
+
+            return `"${value}"`;
+        }
+        return value;
+    }
+
+    private formatProperties(properties: { [key: string]: any }): string {
+        const maxKeyLength = Math.max(...Object.keys(properties).map(key => key.length));
+
+        return Object.entries(properties)
+            .map(([key, value]) => {
+                const padding = ' '.repeat(maxKeyLength - key.length);
+
+                if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                    return `  ${key} {
+${this.formatProperties(value)}
+ }`;
+                }
+
+                return `  ${key}${padding} = ${this.formatValue(value)}`;
+            })
+            .join('\n');
+    }
+    generate(): string {
+        const providerProperties = this.provider.getProperties();
+
+        const terraformBlock = `
+terraform {
+ required_providers {
+   ncloud = {
+     source = "${providerProperties.terraform.required_providers.ncloud.source}"
+   }
+ }
+ required_version = "${providerProperties.terraform.required_version}"
+}`;
+
+        const providerBlock = `
+provider "${this.provider.name}" {
+${this.formatProperties(providerProperties.provider)}
+}`;
+
+        const resourceBlocks = this.resources
+            .sort((a, b) => a.priority - b.priority)
+            .map(resource => {
+                const properties = this.replaceReferences(resource.getProperties());
+                return `
+resource "${resource.serviceType}" "${resource.name}" {
+${this.formatProperties(properties)}
+}`;
+            });
+
+        return [terraformBlock, providerBlock, ...resourceBlocks].join('\n');
+    }
+
+    async saveToFile(filePath: string): Promise<void> {
+        const fs = require('fs').promises;
+        const terraformCode = this.generate();
+        console.log(terraformCode);
+        await fs.writeFile(filePath, terraformCode);
+    }
+}

apps/terraform/enum/ResourcePriority.ts

@@ -0,0 +1,11 @@
+export enum ResourcePriority {
+    VPC = 1,
+    NETWORK_ACL = 2,
+    SUBNET = 3,
+    ACG = 4,
+    ACG_RULE = 5,
+    LOGIN_KEY = 6,
+    NETWORK_INTERFACE = 7,
+    SERVER = 8,
+    PUBLIC_IP = 9
+}

apps/terraform/interface/ACG.ts

@@ -0,0 +1,6 @@
+export interface ACG {
+    id: string;
+    name: string;
+    vpcNo: string;
+    description: string;
+}

apps/terraform/interface/ACGRule.ts

@@ -0,0 +1,6 @@
+export interface ACGRule {
+    protocol: string;
+    ipBlock: string;
+    portRange: string;
+    description: string;
+}

apps/terraform/interface/CloudCanvasNode.ts

@@ -0,0 +1,6 @@
+export interface CloudCanvasNode {
+    id: string;
+    type: string;
+    name: string;
+    properties: { [key: string]: any };
+}

apps/terraform/interface/NCloudModel.ts

@@ -0,0 +1,8 @@
+import { ResourcePriority } from '../enum/ResourcePriority';
+
+export interface NCloudModel {
+    name: string;
+    serviceType: string;
+    priority: ResourcePriority;
+    getProperties(): { [key: string]: any };
+}

apps/terraform/interface/NetworkACL.ts

@@ -0,0 +1,5 @@
+export interface NetworkACL {
+    id: string;
+    name: string;
+    vpcNo: string;
+}

apps/terraform/interface/NetworkInterface.ts

@@ -0,0 +1,6 @@
+export interface NetworkInterface {
+    id: string;
+    name: string;
+    subnetNo: string;
+    accessControlGroups: string[];
+}

apps/terraform/interface/Provider.ts

@@ -0,0 +1,6 @@
+export interface Provider {
+    accessKey: string;
+    secretKey: string;
+    region: string;
+    site: string;
+}

apps/terraform/interface/PublicIp.ts

@@ -0,0 +1,5 @@
+export interface PublicIp {
+    id: string;
+    publicIp: string;
+    serverInstanceNo: string;
+}

apps/terraform/interface/Server.ts

@@ -0,0 +1,9 @@
+export interface Server {
+    id: string;
+    name: string;
+    subnetNo: string;
+    serverImageProductCode: string;
+    serverProductCode: string;
+    loginKeyName: string;
+    networkInterfaceNo: string;
+}

apps/terraform/interface/Subnet.ts

@@ -0,0 +1,10 @@
+export interface Subnet {
+    id: string;
+    name: string;
+    vpcNo: string;
+    subnet: string;
+    zone: string;
+    networkAclNo: string;
+    subnetType: string;
+    usageType: string;
+}

apps/terraform/interface/VPC.ts

@@ -0,0 +1,10 @@
+export interface VPC {
+    id: string;
+    name: string;
+    region: string;
+    ipv4CidrBlock: string;
+    defaultNetworkAclNo: string;
+    defaultAccessControlGroupNo: string;
+    defaultPublicRouteTableNo: string;
+    defaultPrivateRouteTableNo: string;
+}

apps/terraform/main.ts

@@ -0,0 +1,104 @@
+import { CloudCanvasNode } from './interface/CloudCanvasNode';
+import { NCloudProvider } from './model/NCloudProvider';
+import { TerraformConvertor } from './convertor/TerraformConvertor';
+
+const sampleNodes: CloudCanvasNode[] = [
+    {
+        id: "vpc1",
+        type: "VPC",
+        name: "my-vpc",
+        properties: {
+            cidrBlock: "172.16.0.0/16"
+        }
+    },
+    {
+        id: "nacl1",
+        type: "NetworkACL",
+        name: "my-nacl",
+        properties: {
+        }
+    },
+    {
+        id: "subnet1",
+        type: "Subnet",
+        name: "my-subnet",
+        properties: {
+            subnet: "172.16.10.0/24",
+            zone: "KR-2",
+            subnetType: "PUBLIC",
+            usageType: "GEN"
+        }
+    },
+    {
+        id: "acg1",
+        type: "ACG",
+        name: "my-acg",
+        properties: {
+            description: "My ACG"
+        }
+    },
+    {
+        id: "acgrule1",
+        type: "ACGRule",
+        name: "",
+        properties: {
+            protocol: "TCP",
+            ipBlock: "0.0.0.0/0",
+            portRange: "80",
+            description: "HTTP"
+        }
+    },
+    {
+        id: "loginkey1",
+        type: "LoginKey",
+        name: "my-key",
+        properties: {
+        }
+    },
+    {
+        id: "nic1",
+        type: "NetworkInterface",
+        name: "my-nic",
+        properties: {}
+    },
+    {
+        id: "server1",
+        type: "Server",
+        name: "my-server",
+        properties: {
+            serverImageProductCode: "SW.VSVR.OS.LNX64.CNTOS.0708.B050",
+            serverProductCode: "SVR.VSVR.HICPU.C002.M004.NET.HDD.B050.G002"
+        }
+    },
+    {
+        id: "publicip1",
+        type: "PublicIP",
+        name: "my-public-ip",
+        properties: {}
+    }
+];
+
+async function main() {
+    try {
+        const provider = new NCloudProvider({
+            accessKey: "var.access_key",
+            secretKey: "var.secret_key",
+            region: "var.region",
+            site: "public"
+        });
+
+        const convertor = new TerraformConvertor(provider);
+
+        convertor.addResourceFromJson({ nodes: sampleNodes });
+        await convertor.saveToFile('main.tf');
+        console.log('\nGenerated Terraform code:');
+        console.log('----------------------------------------');
+        console.log(convertor.generate());
+        console.log('----------------------------------------');
+
+    } catch (error) {
+        console.error('Error generating Terraform configuration:', error);
+    }
+}
+
+main().catch(console.error);