@kumologica/sdk 3.0.0

package/src/app/lib/aws/kl-iam-api.js

@@ -0,0 +1,27 @@
+const AWS = require('aws-sdk');
+
+/*
+ * AWS JS API:
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SNS.html
+ */
+class KLIAM {
+  
+  constructor(log) {
+    this.log = log; 
+    this.iam = new AWS.IAM();
+  }
+  
+  /**
+   * 
+   */
+  async listRoles() {
+   
+    const response = await this.iam.listRoles({}).promise();
+    
+    return response.Roles.map(function(r) {
+      return {id: r.Arn, name: r.RoleName, arn: r.Arn};
+    });
+  }
+}
+
+module.exports = KLIAM;

package/src/app/lib/aws/kl-rekognition-api.js

@@ -0,0 +1,66 @@
+const AWS = require('aws-sdk');
+
+/*
+ * AWS JS API:
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SSM.html
+ */
+class KLRekognition {
+  
+  constructor(log) {
+    this.log = log; 
+   // this.ssm = new AWS.SSM();
+  }
+  
+  /**
+   * docs: https://docs.aws.amazon.com/rekognition/latest/dg/api-permissions-reference.html
+   * 
+   * @param {*} operation 
+   * @param {*} region 
+   * @param {*} accountId 
+   * @param {*} node 
+   */
+  mapResource(operation, region, accountId, node) {
+      switch (operation) {    
+        case 'CreateCollection': return `arn:aws:rekognition:${region}:${accountId}:collection/${node.CollectionId}`;
+        case 'DeleteCollection': return `arn:aws:rekognition:${region}:${accountId}:collection/${node.CollectionId}`;
+        case 'DeleteFaces': return `arn:aws:rekognition:${region}:${accountId}:collection/${node.CollectionId}`;  
+        case 'DescribeCollection': return `arn:aws:rekognition:${region}:${accountId}:collection/${node.CollectionId}`;
+        case 'IndexFaces': return `arn:aws:rekognition:${region}:${accountId}:collection/${node.CollectionId}`;
+        case 'ListCollections': return `arn:aws:rekognition:${region}:${accountId}:*`
+        case 'ListFaces': return `arn:aws:rekognition:${region}:${accountId}:collection/${node.CollectionId}`; 
+        case 'SearchFaces': return `arn:aws:rekognition:${region}:${accountId}:collection/${node.CollectionId}`; 
+        case 'SearchFacesByImage': return `arn:aws:rekognition:${region}:${accountId}:collection/${node.CollectionId}`;
+        case 'CreateStreamProcessor': return `arn:aws:rekognition:${region}:${accountId}:*`;
+        //case 'CreateStreamProcessor': return `arn:aws:rekognition:${region}:${accountId}:collection/collection-id`;
+        //`arn:aws:rekognition:${region}:${accountId}:streamprocessor/stream-processor-name`
+        
+        case 'DeleteStreamProcessor': return `arn:aws:rekognition:${region}:${accountId}:streamprocessor/${node.Name}`;
+        case 'ListStreamProcessors': return `arn:aws:rekognition:${region}:${accountId}:streamprocessor/${node.Name}`;   
+        case 'StartStreamProcessor': return `arn:aws:rekognition:${region}:${accountId}:streamprocessor/${node.Name}`; 
+        case 'StopStreamProcessor': return `arn:aws:rekognition:${region}:${accountId}:streamprocessor/${node.Name}`;
+        
+        case 'CompareFaces': return '*';
+        case 'DetectFaces': return '*';
+        case 'DetectLabels': return '*';
+        case 'DetectModerationLabels': return '*';
+        case 'DetectText': return '*';
+        case 'GetCelebrityInfo': return '*';
+        case 'RecognizeCelebrities': return '*';
+        case 'GetCelebrityRecognition': return '*';
+        case 'GetContentModeration': return '*';
+        case 'GetFaceDetection': return '*';
+        case 'GetLabelDetection': return '*';
+        case 'GetPersonTracking': return '*';
+        case 'StartCelebrityRecognition': return '*';
+        case 'StartContentModeration': return '*';
+        case 'StartFaceDetection': return '*';
+        case 'StartFaceSearch': return '*';
+        case 'StartLabelDetection': return '*';
+        case 'StartPersonTracking': return "*";
+        default: return "*";
+      }
+    }
+  
+}
+
+module.exports = KLRekognition;

package/src/app/lib/aws/kl-ssm-api.js

@@ -0,0 +1,24 @@
+const AWS = require('aws-sdk');
+
+/*
+ * AWS JS API:
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SSM.html
+ */
+class KLSSM {
+  
+  constructor(log) {
+    this.log = log; 
+    this.ssm = new AWS.SSM();
+  }
+  
+  async getParameter(name) {
+    var params = {
+        Name: name
+        //WithDecryption: true || false
+      };
+
+      return await this.ssm.getParameter(params).promise();
+  }
+}
+
+module.exports = KLSSM;

package/src/app/lib/azure/index.js

@@ -0,0 +1,80 @@
+const fs = require('fs-extra');
+const path = require('path');
+const util = require('util');
+const exec = util.promisify(require('child_process').exec);
+const chalk = require('chalk');
+
+class Azure {
+	constructor(terminal) {
+		this.term = terminal;
+		this.deploying = false;
+	}
+
+	log(text, calog = true, source = 'Kumologica') {
+		console.log(text);
+
+		var t = text;
+
+		if (calog) {
+			t = `${source}: ${chalk.hex('#F5DEB3')(text)}`;
+		}
+		//  t = `Kumohub:    ${chalk.hex('#F5DEB3')(text)}`;
+
+		if (this.term) {
+			this.term.emit('terminal-output', t);
+		}
+	}
+
+	async deploy(projectInfo, params) {
+		try {
+			const { build, exp, deploy } = require('@kumologica/builder');
+
+			params.provider = 'azure';
+			params["flow-file-name"] = projectInfo.projectFlowName;
+			params["project-directory"] = projectInfo.projectDir;
+			const zipFileName = await build('azure', params, this.log.bind(this));
+
+			params["zip-file-name"] = zipFileName;
+			
+			const templateFileName = exp("terraform", "azure", params, this.log.bind(this));
+
+			this.log("Deploying to Azure");
+			params["template-file-name"] = templateFileName;
+			deploy("azure", params, this.log.bind(this));
+
+		} catch (Error) {
+			this.log(chalk.redBright('Deployment failed'));
+			this.log(`  Reason: ${chalk.redBright(Error.message? Error.message: Error)}`);
+		}
+	}
+
+	async login(alias) {
+
+		this.log('Logging in to azure account with --service-principal details ...');
+
+		try {
+			const cmd = `az login --service-principal -u ${alias.client_id} -p ${alias.client_secret} --tenant ${alias.tenant_id}`;
+			const response = await exec(cmd, {});
+
+			if (process.env.KUMOLOGICA_LOGLEVEL === 'debug' && response) {
+				this.log('', false);
+				const lines = response.stdout.split('\n');
+				for (var i = 0; i < lines.length; i++) {
+					if (lines[i]) {
+						this.log(lines[i], false);
+					}
+				}
+				this.log('', false);
+			} else {
+				this.log(chalk.greenBright('Login successful'));
+			}
+		} catch (Error) {
+			this.log(chalk.redBright('Login failed'));
+			this.log(`  Reason: ${chalk.redBright(Error)}`);
+			throw Error;
+		}
+	}
+
+}
+
+module.exports = Azure;

package/src/app/lib/dependencies.js

@@ -0,0 +1,50 @@
+const path = require('path');
+const util = require('util');
+const exec = util.promisify(require('child_process').exec);
+const fs = require("fs"); 
+const os = require('os');
+
+// checking availability of npm, aws cli and aws profile.
+// the result is sent to the home screen to display
+async function checkDependencies() {
+
+    const npmCheckCmd = 'npm --version';
+    const awsCliCmd = 'aws --version';
+    const response = {
+        npm: {},
+        aws: {},
+        awsProfile: {}
+    };
+
+    try {
+        const res = await exec(npmCheckCmd, { });
+        response.npm.status = true;
+        response.npm.info = res.stdout || res.stderr;
+    } catch (Error) {
+        response.npm.status = false;
+        response.npm.info = Error.stdout || Error.stderr;
+    }
+
+    try {
+        const res = await exec(awsCliCmd, { });
+        response.aws.status = true;
+        response.aws.info = res.stdout || res.stderr;
+    } catch (Error) {
+        response.aws.status = false;
+        response.aws.info = Error.stdout || Error.stderr;
+    }
+
+    const homedir = os.homedir();
+    if (fs.existsSync(path.join(homedir, '.aws/credentials'))) {
+        response.awsProfile.status = true;
+        response.awsProfile.info = 'File: ' + path.join(homedir, '.aws/credentials')  + ' exists.';
+    } else {
+        response.awsProfile.status = false;
+        response.awsProfile.info = 'File: ' + path.join(homedir, '.aws/credentials') + ' doesn\'t exists';
+    }
+
+    return response;
+}
+
+
+module.exports = { checkDependencies };

package/src/app/lib/kumohub/index.js

@@ -0,0 +1,201 @@
+const fs = require('fs-extra');
+const path = require('path');
+const util = require('util');
+const request = require('request');
+const requestAsync = util.promisify(request);
+ 
+/**
+ * Class managing login and deployment to kumohub.
+ */
+class Kumohub {
+  constructor(terminal) {
+    this.term = terminal;
+    this.deploying = false;
+  }
+
+  log(text, calog = true, source = 'Kumologica') {
+    console.log(text);
+
+    var t = text;
+
+    if (calog) {
+      t = `${source}: ${text}`;
+    }
+  
+    if (this.term) {
+      this.term.emit('terminal-output', t);
+    }
+  }
+  sanitizeLambdaName(name) {
+    return name
+      .replace('.json', '')
+      .trim()
+      .replace(/^@/, '')
+      .replace(/[^a-zA-Z0-9-]/g, '-')
+      .substr(0, 140);
+  }
+
+  isDeploying() {
+    return this.deploying;
+  }
+
+  getLoginUrl(account) {
+    return `https://admin.${account}.kumohub.io/prod/security/login`;
+  }
+  getRefreshUrl(account) {
+    return `https://admin.${account}.kumohub.io/prod/security/tokenrefresh`;
+  }
+  getServiceUrl(tenantAccount, account, stage, service) {
+    return `https://admin.${tenantAccount}.kumohub.io/prod/services-service/${account}/${stage}/${service}`;
+  }
+
+  isValidToken() {
+    // token valid for at least 5 min
+    return this.tokens && this.loginTime && 
+    (this.loginTime + this.tokens.AuthenticationResult.ExpiresIn * 1000 > Date.now() + 5 * 60 * 1000); 
+  }
+
+  isCurrentProfile(username, password, subscription) {
+    return this.username && this.password && this.subscription &&
+           this.username == username &&
+           this.password == password &&
+           this.subscription == subscription;
+  }
+
+  isLoggedIn(username, password, subscription) {
+     
+    return (this.isCurrentProfile(username, password, subscription) 
+      && this.tokens
+      && this.isValidToken());
+  }
+
+  async getWorkspaces(account) {
+    const url = `https://admin.${account}.kumohub.io/prod/workspace-service/workspaces`;
+
+    const { statusCode, body } = await requestAsync({
+        uri: url,
+        method: 'GET',
+        json: true,
+        headers: {
+            Authorization: `Bearer ${this.tokens.AuthenticationResult.IdToken}`
+          }
+    });
+
+    return body;
+  }
+
+  async login(username, password, subscription) {
+
+    // first check its the same user then tokens present and finally dont neeed refresh
+    if (this.isCurrentProfile(username, password, subscription) && this.tokens) {
+
+      if (this.isValidToken()) {
+        console.log('token still valid');
+        return this.tokens;
+      } else {
+        console.log('refreshing tokens');
+        return this.refreshToken(subscription);
+      }
+    }
+
+    try {
+      const url = this.getLoginUrl(subscription);
+
+      const { statusCode, body } = await requestAsync({
+        uri: url,
+        method: 'POST',
+        json: true,
+        body: {
+          username: username,
+          password: password
+      }
+      });
+
+      if (statusCode === 200) {
+        this.log(`Successfully logged in to ${subscription}.kumohub.io`);
+        
+        this.username = username;
+        this.password = password;
+        this.subscription = subscription;
+        this.tokens = body;
+        this.loginTime = Date.now();
+
+        return body;
+      
+      } else {
+        throw new Error(`Received an error from Kumohub: ${statusCode} ${JSON.stringify(body)}`);
+      }
+    } catch (err) {
+      if (err && err.errno && err.errno == "ENOTFOUND" && err.hostname) {
+        throw new Error(`Unable to connect to ${err.hostname}, please check your network or your profile's subscription name is correct.`);
+      }
+      throw new Error(`Unexpected error: ${JSON.stringify(err)}`);
+    }
+  }
+
+  async logout () {
+    this.username = null;
+    this.password = null;
+    this.subscription = null;
+    this.tokens = null;
+    this.loginTime =null;
+  }
+  
+  async getService(subscription, account, stage, service) {
+    try {
+      const url = this.getServiceUrl(subscription, account, stage, service);
+
+      const { statusCode, body } = await requestAsync({
+        uri: url,
+        method: 'GET',
+        headers: {'Authorization': `Bearer ${this.tokens.AuthenticationResult.IdToken}`},
+        json: true
+      });
+
+      if (statusCode === 200) {
+        return body;
+      } else {
+        throw new Error(`Received an error from Kumohub: ${statusCode} ${JSON.stringify(body)}`);
+      }
+    } catch (err) {
+      if (err && err.errno && err.errno == "ENOTFOUND" && err.hostname) {
+        throw new Error(`Unable to connect to ${err.hostname}, please check your network or profile subscription name is correct.`);
+      }
+      throw new Error(`Unexpected error: ${JSON.stringify(err)}`);
+    }
+  }
+
+  async refreshToken(subscription) {
+    try {
+      const url = this.getRefreshUrl(subscription);
+
+      const { statusCode, body } = await requestAsync({
+        uri: url,
+        method: 'POST',
+        json: true,
+        body: {
+          refreshToken: this.tokens.AuthenticationResult.RefreshToken
+      }
+      });
+
+      if (statusCode === 200) {
+        this.tokens.AuthenticationResult.AccessToken = body.AuthenticationResult.AccessToken;
+        this.tokens.AuthenticationResult.IdToken = body.AuthenticationResult.IdToken;
+        this.tokens.AuthenticationResult.TokenType = body.AuthenticationResult.TokenType;
+        this.tokens.AuthenticationResult.ExpiresIn = body.AuthenticationResult.ExpiresIn;
+        this.subscription = subscription;
+        this.loginTime = Date.now();
+        return this.tokens;
+      } else {
+        throw new Error(`Received an error from Kumohub: ${statusCode} ${JSON.stringify(body)}`);
+      }
+    } catch (err) {
+      if (err && err.errno && err.errno == "ENOTFOUND" && err.hostname) {
+        throw new Error(`Unable to connect to ${err.hostname}, please check your network or profile subscription name is correct.`);
+      }
+      throw new Error(`Unexpected error: ${JSON.stringify(err)}`);
+    }
+  }
+}
+
+module.exports = Kumohub;

package/src/app/lib/runtime-loader/index.js

@@ -0,0 +1,42 @@
+const ENVVAR_KUMOLOGICA_RUNTIME = 'KUMOLOGICA_RUNTIME'
+
+class KREManager {
+    constructor() {
+        let runtimeLocationPath = this.readKumologicaRuntime();
+        // this.loadRuntime(runtimeLocationPath)
+        this.runtime = require('@kumologica/runtime');
+    }
+
+    // loadRuntime(runtimeLocationPath){
+    //     if (runtimeLocationPath){
+    //         console.log(`Environment variable: "KUMOLOGICA_RUNTIME" set to: ${runtimeLocationPath}`)
+    //         try{
+    //             this.runtime = require(runtimeLocationPath);
+    //         }catch(err){
+    //             throw new Error(`KUMOLOGICA_RUNTIME does not point to a valid runtime: ${runtimeLocationPath}`)
+    //         }
+            
+    //     } else {
+    //         console.log(`Environment variable: "KUMOLOGICA_RUNTIME" not set. Embedded runtime to be used.`)
+    //         this.runtime = require('@kumologica/runtime');
+    //     }
+    // }
+
+    getRuntime(){
+        return this.runtime;
+    }
+
+    readKumologicaRuntime() {
+        if (ENVVAR_KUMOLOGICA_RUNTIME in process.env) {
+          let value = process.env[ENVVAR_KUMOLOGICA_RUNTIME].toLowerCase();
+          return value;
+        }
+        return undefined;
+      }
+}
+
+let kreManager = new KREManager();
+
+module.exports = { 
+    ...kreManager.getRuntime(), // runtime
+}