From 359b050d1d7e2bf582fe7882b304ebaf793e4dc5 Mon Sep 17 00:00:00 2001
From: Roman <mister02.rv@gmail.com>
Date: Tue, 31 Dec 2019 00:04:22 +0200
Subject: [PATCH] sandbox exercises

---
 JavaScript/application.js |  54 ++++++++++++-----
 JavaScript/framework.js   | 119 +++++++++++++++++++++-----------------
 2 files changed, 107 insertions(+), 66 deletions(-)

diff --git a/JavaScript/application.js b/JavaScript/application.js
index 8f018b8..3c5e82b 100644
--- a/JavaScript/application.js
+++ b/JavaScript/application.js
@@ -1,19 +1,47 @@
 'use strict';
+// Tests requires
+let api;
 
-// File contains a small piece of the source to demonstrate main module
-// of a sample application to be executed in the sandboxed context by
-// another pice of code from `framework.js`. Read README.md for tasks.
+// Require some modules
+require('fs');
+require('vm');
 
-const fs = require('fs');
-const net = require('net');
-
-// Print from the global context of application module
-console.log('From application global context');
-console.dir({ fs, net }, { depth: 1 });
-console.dir({ global }, { depth: 1 });
-console.dir({ api }, { depth: 2 });
+// One call to util`s function
+const o = { a: 5, b: 6 };
+o.self = o;
+api.console.log(api.util.inspect(o));
 
+// Using setTimeout and setInterval
+// Exporting a function
 module.exports = () => {
-  // Print from the exported function context
-  console.log('From application exported function');
+  api.timers.setTimeout(() => {
+    // Print from the exported function context
+    api.console.log('setTimeout from application2 exported function');
+  }, 5000);
+
+  api.timers.setInterval(() => {
+    // Print from the exported function context
+    api.console.log('setInterval from application2 exported function');
+  }, 2000);
 };
+/*
+// Exporting an onject
+const obj = {
+  fn1: () => {},
+  arr: Array.of({ length: 5 }),
+  o: new Object({}),
+  str: new String('string').valueOf(),
+  //buffer: Buffer.alloc(10),
+  bool: new Boolean(false).valueOf(),
+};
+
+module.exports = obj;
+*/
+// List of everything from the global context (application
+// sandbox) with the data types specified
+const def = obj =>
+  Object.keys(obj).reduce(
+    (hash, key) => ((hash[key] = typeof obj[key]), hash),
+    {}
+  );
+api.console.log(def(global));
diff --git a/JavaScript/framework.js b/JavaScript/framework.js
index 6bdafde..aa2d289 100644
--- a/JavaScript/framework.js
+++ b/JavaScript/framework.js
@@ -1,69 +1,82 @@
 'use strict';
 
-// Example showing us how the framework creates an environment (sandbox) for
-// appication runtime, load an application code and passes a sandbox into app
-// as a global context and receives exported application interface
-
-const PARSING_TIMEOUT = 1000;
-const EXECUTION_TIMEOUT = 5000;
+// File contains a small piece of the source to demonstrate main module
+// of a sample application to be executed in the sandboxed context by
+// another pice of code from `framework.js`.
 
 // The framework can require core libraries
-const fs = require('fs');
-const vm = require('vm');
-const timers = require('timers');
-const events = require('events');
 
-// Create a hash and turn it into the sandboxed context which will be
-// the global context of an application
-const context = {
-  module: {}, console,
-  require: name => {
-    if (name === 'fs') {
-      console.log('Module fs is restricted');
-      return null;
-    }
-    return require(name);
-  }
-};
+// Tests require to initialize 'api', but with it, code is not running!
+let api;
+global.api = {};
+api.vm = require('vm');
+api.fs = require('fs');
+api.util = require('util');
 
-context.global = context;
-const sandbox = vm.createContext(context);
+// This is a wrapper for 'console.log' to add more info into console output
+//in the following format: `<applicationName> <time> <message>`
+const wrapC = (path, fn) => message => {
+  console.log(`application: ${path}`);
+  const time = 'Time: ' + new Date();
+  console.log(time);
+  fn(message);
+};
+// Function for
+const def = obj =>
+  Object.keys(obj).reduce(
+    (hash, key) => ((hash[key] = typeof obj[key]), hash),
+    {}
+  );
 
-// Prepare lambda context injection
-const api = { timers,  events };
+// Wrap 'require' function for logging to a file in the format: `<time> <module name>`
+const req = name => {
+  const message = 'ModuleName: ' + name + '\nTime:' + new Date();
+  console.log(message);
+  return require(name);
+};
+// Print application parameter count and source code
+const countArgs = f => console.log(f.length);
+const content = f => console.log(f.toString());
 
-// Read an application source code from the file
-const fileName = './application.js';
-fs.readFile(fileName, 'utf8', (err, src) => {
+const runSandboxed = path => {
+  // Create a hash and turn it into the sandboxed context which will be
+  // the global context of an application
+  const context = {
+    module: {},
+    require: req,
+    api: {
+      timers: { setTimeout, setInterval },
+      util: api.util,
+      console: { log: wrapC(path, console.log) },
+    },
+  };
+  context.global = context;
+  const sandbox = api.vm.createContext(context);
   // We need to handle errors here
 
-  // Wrap source to lambda, inject api
-  src = `api => { ${src} };`;
+  // Read an application source code from the file
+  api.fs.readFile(path, 'utf-8', (err, data) => {
+    if (err) return;
+    // Run an application in sandboxed context
+    const script = new api.vm.Script(data, path);
+    const f = script.runInNewContext(sandbox);
 
-  // Run an application in sandboxed context
-  let script;
-  try {
-    script = new vm.Script(src, { timeout: PARSING_TIMEOUT });
-  } catch (e) {
-    console.dir(e);
-    console.log('Parsing timeout');
-    process.exit(1);
-  }
-
-  try {
-    const f = script.runInNewContext(sandbox, { timeout: EXECUTION_TIMEOUT });
-    f(api);
+    if (process.argv[2] === path || path === 'application.js') f;
     const exported = sandbox.module.exports;
-    console.dir({ exported });
-  } catch (e) {
-    console.dir(e);
-    console.log('Execution timeout');
-    process.exit(1);
-  }
+    const type = typeof exported;
+    if (type === 'function') {
+      countArgs(exported);
+      content(exported);
+      exported();
+    } else if (type === 'object') {
+      console.log(def(exported));
+    }
+    // We can access a link to exported interface from sandbox.module.exports
+    // to execute, save to the cache, print to console, etc.
+  });
+};
 
-  // We can access a link to exported interface from sandbox.module.exports
-  // to execute, save to the cache, print to console, etc.
-});
+runSandboxed('application.js');
 
 process.on('uncaughtException', err => {
   console.log('Unhandled exception: ' + err);