Initialised Linode

Signed-off-by: Partik SIngh <partik.sbumrah.cse21@itbhu.ac.in>

generator/dummyClasses/linode.js

@@ -0,0 +1,24 @@
+class ClassName {
+    /**
+     *
+     * @param {module} do Linode SDK
+     * @param {object} options SDK options
+     */
+    constructor(linodeSdk, linodeToken) {
+     this._linode = linodeSdk;
+     this._linodeToken = linodeToken;
+    }
+
+    function() {
+    this._linode.setToken(this._linodeToken)
+      return new Promise((resolve, reject) => {
+        this._linode
+          .SDKFunctionName()
+          .then(data => resolve(data))
+          .catch(err => reject(err));
+      });
+    }
+  }
+
+  module.exports = ClassName;
+

generator/generators/linode/generator.ts

@@ -0,0 +1,123 @@
+import * as fs from "fs";
+import { createSourceFile, ScriptTarget, SyntaxKind } from "typescript";
+
+import { getAST } from "../../parsers/do/parser";
+import { transform } from "../../transformers/do/transformer";
+import { getDir,printFile } from "../lib/helper";
+
+interface FunctionData {
+  functionName: string;
+  SDKFunctionName: string;
+  params: param[];
+}
+
+interface param {
+  name: string;
+  type: string;
+  typeName: string;
+}
+
+interface ClassData {
+  className: string;
+  functions: FunctionData[];
+  serviceName: string;
+}
+
+const dummyFile = process.cwd() + "/dummyClasses/linode.js";
+
+const dummyAst = createSourceFile(
+  dummyFile,
+  fs.readFileSync(dummyFile).toString(),
+  ScriptTarget.Latest,
+  true
+);
+
+export function extractSDKData(sdkClassAst, serviceClass) {
+  let methods: FunctionData[] = [];
+  const functions = [];
+
+  Object.keys(serviceClass).map((key, index) => {
+    functions.push(serviceClass[key].split(" ")[1]);
+  });
+
+  sdkClassAst.members.map(method => {
+    if (method.name && functions.includes(method.name.text)) {
+      let name;
+      Object.keys(serviceClass).map((key, index) => {
+        if (serviceClass[key].split(" ")[1] === method.name.text) {
+          name = key;
+        }
+      });
+
+      const parameters = [];
+      method.parameters.map(param => {
+        if (param.name.text !== "callback") {
+          const parameter = {
+            name: param.name.text,
+            optional: param.questionToken ? true : false,
+            type: SyntaxKind[param.type.kind],
+            typeName: null
+          };
+
+          if (parameter.type === "TypeReference" && param.type.typeName) {
+            parameter.typeName = param.type.typeName.text;
+          }
+
+          parameters.push(parameter);
+        }
+      });
+
+      methods.push({
+        functionName: name.toString(),
+        SDKFunctionName: method.name.text.toString(),
+        params: parameters
+      });
+    }
+  });
+
+  const classData: ClassData = {
+    className: sdkClassAst.name.text,
+    functions: methods,
+    serviceName: null
+  };
+
+  return classData;
+}
+
+export function generateLinodeClass(serviceClass, serviceName) {
+  const sdkFile = serviceClass[Object.keys(serviceClass)[0]].split(" ")[0];
+  getAST(sdkFile).then(async result => {
+    const sdkClassAst = result;
+    try {
+      const classData: ClassData = extractSDKData(sdkClassAst, serviceClass);
+      classData.serviceName = serviceName;
+      const output = await transform(dummyAst, classData);
+      let filePath;
+      const dir = getDir(serviceName);
+      if (!fs.existsSync(process.cwd() + "/generatedClasses/Linode/" + dir)) {
+        fs.mkdirSync(process.cwd() + "/generatedClasses/Linode/" + dir);
+      }
+      if (/^[A-Z]*$/.test(serviceName)) {
+        filePath =
+          process.cwd() +
+          "/generatedClasses/Linode/" +
+          dir +
+          "/do-" +
+          serviceName +
+          ".js";
+      } else {
+        filePath =
+          process.cwd() +
+          "/generatedClasses/Linode/" +
+          dir +
+          "/do-" +
+          serviceName.charAt(0).toLowerCase() +
+          serviceName.slice(1) +
+          ".js";
+      }
+      printFile(filePath, output);
+    } catch (e) {
+      console.error(e);
+    }
+  });
+}

generator/node-cloud.yml

@@ -23,6 +23,11 @@ ComputeInstance:
     destroy: droplets.d.ts deleteById
     start: droplets.d.ts requestAction
     stop: droplets.d.ts requestAction
+  Linode:
+    create: linodes types.ts createLinode
+    list: linodes types.ts getLinodes
+    destroy: linodes types.ts deleteLinode
+    update: linodes types.ts updateLinode
 
 StorageBucket:
   AWS:
@@ -43,6 +48,12 @@ StorageBucket:
     list: storage storage.d.ts getBuckets
     upload: storage bucket.d.ts upload
     makePublic: storage file.d.ts makePublic
+  Linode:
+    create: object-storage types.ts createBucket
+    delete: object-storage types.ts deleteBucket
+    list: object-storage types.ts getBuckets
+
+
 
 PaaS:
   AWS:
@@ -118,6 +129,13 @@ Kubernetes:
     deleteNodegroup: kubernetes.d.ts deleteNodePool
     describeNodeGroup: kubernetes.d.ts getNodePoolById
     listNodegroups: kubernetes.d.ts getNodePools
+  Linode:
+    create: kubernetes types.ts createKubernetesCluster
+    delete: kubernetes types.ts deleteKubernetesCluster
+    getNodePool: kubernetes types.ts getNodePool
+    createNodePool: kubernetes types.ts createNodePool
+    updateNodePool: kubernetes types.ts updateNodePool
+    deleteNodePool: kubernetes types.ts deleteNodePool
 
 Monitoring:
   GCP:
@@ -260,6 +278,11 @@ LoadBalancer:
     delete: load-balancers.d.ts delete
     list: load-balancers.d.ts getAll
     update: load-balancers.d.ts update
+  Linode:
+    create: nodebalancers types.ts createNodeBalancer
+    delete: nodebalancers types.ts deleteNodeBalancer
+    list: nodebalancers types.ts getNodeBalancers
+
 
 IAM:
   AWS:

generator/parsers/linode/parser.ts

@@ -0,0 +1,41 @@
+import * as fs from "fs";
+import * as path from "path";
+import { createSourceFile, ScriptTarget, SyntaxKind } from "typescript";
+
+export function getAST(sdkFileName) {
+  return new Promise(async (resolve, reject) => {
+    try {
+      const file = path.join(
+        __dirname,
+        "../../../node_modules/linode/dist/modules/" +
+          sdkFileName.toLowerCase()
+      );
+      const ast = createSourceFile(
+        file,
+        fs.readFileSync(file).toString(),
+        ScriptTarget.Latest,
+        true
+      );
+
+      let cloned = null;
+
+      await ast.forEachChild(child => {
+        if (SyntaxKind[child.kind] === "ClassDeclaration") {
+          cloned = Object.assign({}, child);
+        }
+      });
+
+      if (!cloned) {
+        reject(new Error("Class not found!"));
+      } else {
+        resolve(cloned);
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        reject(new Error("File not found!"));
+      } else {
+        reject(error);
+      }
+    }
+  });
+}