Added Linode package

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

packages/linode-plugin/compute/linode-computeInstance.js

@@ -0,0 +1,68 @@
+/*This is an auto generated class, please do not change.*/
+/**
+    * Class to create a ComputeInstanceLinodeClass object
+    * @category Linode
+    */
+class Linode_ComputeInstance {
+    /**
+     *
+     * @param {module} do Linode SDK
+     * @param {object} options SDK options
+     */
+    constructor(linodeSdk, linodeToken) {
+        this._linode = linodeSdk;
+        this._linodeToken = linodeToken;
+        this._linode.setToken(this._linodeToken);
+    }
+    /**
+        * Trigers the getLinodes function of ComputeInstanceLinodeClass
+        * @param {AnyKeyword} params - Data required for getLinodes
+    * @param {AnyKeyword} filter - Data required for getLinodes
+        * @returns {Promise<getLinodesResponse>}
+        */
+    list(params = undefined, filter = undefined) {
+        return new Promise((resolve, reject) => {
+            this._linode.getLinodes(params, filter)
+                .then(data => resolve(data))
+                .catch(err => reject(err));
+        });
+    }
+    /**
+        * Trigers the createLinode function of ComputeInstanceLinodeClass
+        * @param {CreateLinodeRequest} data - Data required for createLinode
+        * @returns {Promise<createLinodeResponse>}
+        */
+    create(data) {
+        return new Promise((resolve, reject) => {
+            this._linode.createLinode(data)
+                .then(data => resolve(data))
+                .catch(err => reject(err));
+        });
+    }
+    /**
+        * Trigers the updateLinode function of ComputeInstanceLinodeClass
+        * @param {NumberKeyword} linodeId - Data required for updateLinode
+    * @param {DeepPartial} values - Data required for updateLinode
+        * @returns {Promise<updateLinodeResponse>}
+        */
+    update(linodeId, values) {
+        return new Promise((resolve, reject) => {
+            this._linode.updateLinode(linodeId, values)
+                .then(data => resolve(data))
+                .catch(err => reject(err));
+        });
+    }
+    /**
+        * Trigers the deleteLinode function of ComputeInstanceLinodeClass
+        * @param {NumberKeyword} linodeId - Data required for deleteLinode
+        * @returns {Promise<deleteLinodeResponse>}
+        */
+    delete(linodeId) {
+        return new Promise((resolve, reject) => {
+            this._linode.deleteLinode(linodeId)
+                .then(data => resolve(data))
+                .catch(err => reject(err));
+        });
+    }
+}
+module.exports = Linode_ComputeInstance;

packages/linode-plugin/compute/linode-kubernetes.js

@@ -0,0 +1,95 @@
+/*This is an auto generated class, please do not change.*/
+/**
+    * Class to create a KubernetesLinodeClass object
+    * @category Linode
+    */
+class Linode_Kubernetes {
+    /**
+     *
+     * @param {module} do Linode SDK
+     * @param {object} options SDK options
+     */
+    constructor(linodeSdk, linodeToken) {
+        this._linode = linodeSdk;
+        this._linodeToken = linodeToken;
+        this._linode.setToken(this._linodeToken);
+    }
+    /**
+        * Trigers the createKubernetesCluster function of KubernetesLinodeClass
+        * @param {CreateKubeClusterPayload} data - Data required for createKubernetesCluster
+        * @returns {Promise<createKubernetesClusterResponse>}
+        */
+    create(data) {
+        return new Promise((resolve, reject) => {
+            this._linode.createKubernetesCluster(data)
+                .then(data => resolve(data))
+                .catch(err => reject(err));
+        });
+    }
+    /**
+        * Trigers the deleteKubernetesCluster function of KubernetesLinodeClass
+        * @param {NumberKeyword} clusterID - Data required for deleteKubernetesCluster
+        * @returns {Promise<deleteKubernetesClusterResponse>}
+        */
+    delete(clusterID) {
+        return new Promise((resolve, reject) => {
+            this._linode.deleteKubernetesCluster(clusterID)
+                .then(data => resolve(data))
+                .catch(err => reject(err));
+        });
+    }
+    /**
+        * Trigers the getNodePool function of KubernetesLinodeClass
+        * @param {NumberKeyword} clusterID - Data required for getNodePool
+    * @param {NumberKeyword} nodePoolID - Data required for getNodePool
+        * @returns {Promise<getNodePoolResponse>}
+        */
+    getNodePool(clusterID, nodePoolID) {
+        return new Promise((resolve, reject) => {
+            this._linode.getNodePool(clusterID, nodePoolID)
+                .then(data => resolve(data))
+                .catch(err => reject(err));
+        });
+    }
+    /**
+        * Trigers the createNodePool function of KubernetesLinodeClass
+        * @param {NumberKeyword} clusterID - Data required for createNodePool
+    * @param {CreateNodePoolData} data - Data required for createNodePool
+        * @returns {Promise<createNodePoolResponse>}
+        */
+    createNodePool(clusterID, data) {
+        return new Promise((resolve, reject) => {
+            this._linode.createNodePool(clusterID, data)
+                .then(data => resolve(data))
+                .catch(err => reject(err));
+        });
+    }
+    /**
+        * Trigers the updateNodePool function of KubernetesLinodeClass
+        * @param {NumberKeyword} clusterID - Data required for updateNodePool
+    * @param {NumberKeyword} nodePoolID - Data required for updateNodePool
+    * @param {Partial} data - Data required for updateNodePool
+        * @returns {Promise<updateNodePoolResponse>}
+        */
+    updateNodePool(clusterID, nodePoolID, data) {
+        return new Promise((resolve, reject) => {
+            this._linode.updateNodePool(clusterID, nodePoolID, data)
+                .then(data => resolve(data))
+                .catch(err => reject(err));
+        });
+    }
+    /**
+        * Trigers the deleteNodePool function of KubernetesLinodeClass
+        * @param {NumberKeyword} clusterID - Data required for deleteNodePool
+    * @param {NumberKeyword} nodePoolID - Data required for deleteNodePool
+        * @returns {Promise<deleteNodePoolResponse>}
+        */
+    deleteNodePool(clusterID, nodePoolID) {
+        return new Promise((resolve, reject) => {
+            this._linode.deleteNodePool(clusterID, nodePoolID)
+                .then(data => resolve(data))
+                .catch(err => reject(err));
+        });
+    }
+}
+module.exports = Linode_Kubernetes;

packages/linode-plugin/database/linode-noSql.js

@@ -0,0 +1,97 @@
+/*This is an auto generated class, please do not change.*/
+/**
+    * Class to create a NoSqlLinodeClass object
+    * @category Linode
+    */
+class Linode_NoSql {
+    /**
+     *
+     * @param {module} do Linode SDK
+     * @param {object} options SDK options
+     */
+    constructor(linodeSdk, linodeToken) {
+        this._linode = linodeSdk;
+        this._linodeToken = linodeToken;
+        this._linode.setToken(this._linodeToken);
+    }
+    /**
+        * Trigers the getDatabases function of NoSqlLinodeClass
+        * @param {AnyKeyword} params - Data required for getDatabases
+    * @param {AnyKeyword} filters - Data required for getDatabases
+        * @returns {Promise<getDatabasesResponse>}
+        */
+    getDatabases(params = undefined, filters = undefined) {
+        return new Promise((resolve, reject) => {
+            this._linode.getDatabases(params, filters)
+                .then(data => resolve(data))
+                .catch(err => reject(err));
+        });
+    }
+    /**
+        * Trigers the getDatabaseEngines function of NoSqlLinodeClass
+        * @param {AnyKeyword} params - Data required for getDatabaseEngines
+    * @param {AnyKeyword} filters - Data required for getDatabaseEngines
+        * @returns {Promise<getDatabaseEnginesResponse>}
+        */
+    getDatabaseEngines(params = undefined, filters = undefined) {
+        return new Promise((resolve, reject) => {
+            this._linode.getDatabaseEngines(params, filters)
+                .then(data => resolve(data))
+                .catch(err => reject(err));
+        });
+    }
+    /**
+        * Trigers the createDatabase function of NoSqlLinodeClass
+        * @param {UnionType} engine - Data required for createDatabase
+    * @param {CreateDatabasePayload} data - Data required for createDatabase
+        * @returns {Promise<createDatabaseResponse>}
+        */
+    createDatabase(engine, data) {
+        return new Promise((resolve, reject) => {
+            this._linode.createDatabase(engine, data)
+                .then(data => resolve(data))
+                .catch(err => reject(err));
+        });
+    }
+    /**
+        * Trigers the getEngineDatabase function of NoSqlLinodeClass
+        * @param {Engine} engine - Data required for getEngineDatabase
+    * @param {NumberKeyword} databaseID - Data required for getEngineDatabase
+        * @returns {Promise<getEngineDatabaseResponse>}
+        */
+    getEngineDatabase(engine, databaseID) {
+        return new Promise((resolve, reject) => {
+            this._linode.getEngineDatabase(engine, databaseID)
+                .then(data => resolve(data))
+                .catch(err => reject(err));
+        });
+    }
+    /**
+        * Trigers the updateDatabase function of NoSqlLinodeClass
+        * @param {Engine} engine - Data required for updateDatabase
+    * @param {NumberKeyword} databaseID - Data required for updateDatabase
+    * @param {UpdateDatabasePayload} data - Data required for updateDatabase
+        * @returns {Promise<updateDatabaseResponse>}
+        */
+    updateDatabase(engine, databaseID, data) {
+        return new Promise((resolve, reject) => {
+            this._linode.updateDatabase(engine, databaseID, data)
+                .then(data => resolve(data))
+                .catch(err => reject(err));
+        });
+    }
+    /**
+        * Trigers the deleteDatabase function of NoSqlLinodeClass
+        * @param {Engine} engine - Data required for deleteDatabase
+    * @param {NumberKeyword} databaseID - Data required for deleteDatabase
+        * @returns {Promise<deleteDatabaseResponse>}
+        */
+    deleteDatabase(engine, databaseID) {
+        return new Promise((resolve, reject) => {
+            this._linode.deleteDatabase(engine, databaseID)
+                .then(data => resolve(data))
+                .catch(err => reject(err));
+        });
+    }
+}
+module.exports = Linode_NoSql;

packages/linode-plugin/index.js

@@ -0,0 +1,7 @@
+const linodeSdk = require("@linode/api-v4");
+const lindoePlugin = require("./linode");
+
+const ncLinodePlugin = ()=>{
+    return new lindoePlugin(linodeSdk);
+}
+module.exports = ncLinodePlugin;

packages/linode-plugin/linode.js

@@ -0,0 +1,46 @@
+const computeInstance = require("./compute/linode-computeInstance");
+const kubernetes = require("./compute/linode-kubernetes");
+const noSql = require("./database/linode-noSql");
+const loadBalancer = require("./network/linode-loadBalancer");
+const linodeDns = require("./network/linode-DNS");
+const volume = require("./storage/linode-blockStorage");
+class Linode{
+    constructor(linodeSdk){
+        this._linodeSdk = linodeSdk;
+        if(!process.env.LINODE_TOKEN){
+            throw new Error("Provide Credentials")
+        }
+        this.token = process.env.LINODE_TOKEN;
+        return{
+            getSDK:()=>this._linodeSdk,
+            getToken:()=>this.token,
+            compute: this.computeInstance,
+            blockStorage: this.volume,
+            loadBalancer:this.loadBalancer,
+            dns:this.linodeDns,
+            noSql:this.noSql,
+            kubernetes:this.kubernetes,
+
+        };
+    }
+
+    computeInstance(){
+        return new computeInstance(this.getSDK(),this.getToken());
+    }
+    kubernetes(){
+        return new kubernetes(this.getSDK(),this.getToken());
+    }
+    noSql(){
+        return new noSql(this.getSDK(),this.getToken());
+    }
+    linodeDns(){
+        return new linodeDns(this.getSDK(),this.getToken());
+    }
+    loadBalancer(){
+        return new loadBalancer(this.getSDK(),this.getToken());
+    }
+    volume(){
+        return new volume(this.getSDK(),this.getToken());
+    }
+}
+module.exports = Linode;