sandoxing with support for middleware info

Author: sevenbitbyte

src/index.js

@@ -2,10 +2,12 @@ const Comms = require('./comms')
 const Config = require('./config')
 const Party = require('./party')
 const Service = require('./service')
+const Sandbox = require('./sandbox')
 
 module.exports = {
   Comms,
   Config,
   ...Party,
-  ...Service
+  ...Service,
+  ...Sandbox
 }

src/sandbox/index.js

@@ -0,0 +1,5 @@
+module.exports = {
+  Sandbox: require('./sandbox'),
+  SandboxError: require('./sandbox-error'),
+  MiddlewareInfoSandbox: require('./middleware-info-sandbox')
+}

src/sandbox/middleware-info-sandbox.js

@@ -0,0 +1,53 @@
+//const debug = require('debug')('dataparty.MiddlewareInfoSandbox')
+const Sandbox = require('./sandbox')
+
+class MiddlewareInfoSandbox extends Sandbox {
+  constructor(code){
+    super(`  
+
+module.exports = async ()=>{
+
+  class ErrorError extends Error { 
+    constructor(msg){
+      super()
+      this.code = 'ErrorError'
+      this.message = 'You did not throw an error object, always throw an Error object! - [' + msg + ']'
+    }
+  }
+
+  try{
+    let Lib = ${code}
+
+    return {
+      Name: Lib.Name,
+      Type: Lib.Type,
+      Description: Lib.Description,
+      ConfigSchema: Lib.ConfigSchema
+    }
+  }
+  catch(err){
+
+    if(!err || !err.stack){
+      err = new ErrorError(err)
+    }
+
+    throw err
+  }
+
+}
+    `)
+
+    this.info = null
+  }
+
+  async run(){
+
+
+    this.info = await super.run()
+
+    return this.info
+  }
+
+}
+
+module.exports = MiddlewareInfoSandbox

src/sandbox/sandbox-error.js

@@ -0,0 +1,50 @@
+class SandboxError extends Error {
+  constructor(err, accessor){
+    super()
+    this.message = err.message
+
+
+    this.code = err.code || err.name || 'SandboxError'
+    this.name = this.code
+    this.stack = err.stack
+    this.locations = VMError.filterStackForModuleLines(err.stack, accessor)
+  }
+
+  static filterStackForModuleLines(stack, accessor){
+
+    let founds = []
+
+    if(!stack){
+      return founds
+    }
+  
+    const prefix = '(vm.js:'
+    stack.split('\n').map(line=>{
+      
+      let idx = line.indexOf(prefix)
+  
+      if(idx > -1){
+        const found = {
+          line: null,
+          col: null,
+          code: null
+        }
+  
+        let start = idx+prefix.length
+        let end = line.indexOf(')')
+  
+        const [l, c] = line.substr(start, end-start).split(':')
+  
+        found.col = c
+        found.line = l
+        found.code = accessor.code.split('\n')[found.line-1]
+
+        founds.push(found)
+      }
+    })
+    
+    return founds
+  }
+}
+
+module.exports = SandboxError

src/sandbox/sandbox.js

@@ -0,0 +1,41 @@
+const debug = require('debug')('dataparty.Sandbox')
+const {VM, NodeVM, VMScript} = require('vm2')
+
+const SandboxError = require('./sandbox-error')
+
+class Sandbox {
+  constructor(code){
+    debug('compiling code')
+    this.code = code
+    this.script = new VMScript(code)
+    debug('compiled')  
+  }
+
+  async run(context, sandbox){
+    debug('running')
+    try{
+      
+      let vm = new NodeVM({
+        sandbox,
+        require: {
+          external: {
+            modules: ['debug', '@dataparty/crypto', '@hapi/joi', '@hapi/hoek']
+          },
+          //builtin: ['*']
+        }
+      })
+
+      let fn = vm.run(this.script)
+      const retVal = await fn(context)
+      return retVal
+
+    } catch(err) {
+
+      debug('CodeVM.run - catch')
+      debug('',err)
+      throw new SandboxError(err,this)
+    }
+  }
+}
+
+module.exports = Sandbox

test/test-service-compile.js

@@ -2,7 +2,11 @@ const Path = require('path')
 const debug = require('debug')('test.service-compile')
 const Dataparty = require('../src')
 
-const {VM, NodeVM, VMScript} = require('vm2')
+//const {VM, NodeVM, VMScript} = require('vm2')
+
+process.on('uncaughtException', (err) => {
+  console.error('Asynchronous error caught.', err);
+})
 
 class ExampleService extends Dataparty.IService {
     constructor(opts){
@@ -13,72 +17,38 @@ class ExampleService extends Dataparty.IService {
 
 }
 
-class CodeAccessor {
-  constructor(code){
-    debug('code-accessor', code)
-    this.script = new VMScript(code)
-    debug('compiled')  
-  }
-
-  run(context, sandbox){
-    debug('run')
-
-
-    let vm = new NodeVM({
-      sandbox,
-      require: {
-        external: {
-          modules: ['debug', '@dataparty/crypto', '@hapi/joi', '@hapi/hoek']
-        },
-        //builtin: ['*']
-      }
-    })
-
-    debug('has run')
-    let fn = vm.run(this.script)
-    const retVal = fn(context)
-    debug('retVal', retVal)
-    debug('context', context)
-    return retVal
-  }
-
-}
-
-class MiddlewareInfoAccessor extends CodeAccessor {
-  constructor(code){
-    super(`
-      
-      let lib = ${code}
-     
-      module.exports = ()=>{
-
-      return {
-        Name: lib.Name,
-        Type: lib.Type,
-        Description: lib.Description,
-        ConfigSchema: lib.ConfigSchema
-      }
-    }
-    `)
-  }
-
-}
 
 async function main(){
 
-  console.log(Object.keys(Dataparty))
+  debug(Object.keys(Dataparty))
 
   const service = new ExampleService({ name: '@dataparty/example', version: '0.0.1' })
 
   const build = await service.compile(Path.join(__dirname,'../dataparty'), false)
 
   //debug(build.middleware.pre.decrypt)
 
-  let accessor = new MiddlewareInfoAccessor(build.middleware.pre.decrypt.code)
+  let decryptInfo = new Dataparty.MiddlewareInfoSandbox(build.middleware.pre.decrypt.code)
+
+  try{
+    await decryptInfo.run()
+  }
+  catch(err){
+    debug('supressing error')
+    debug('\tname\t',err.name)
+    debug('\tcode\t',err.code)
+
+    debug('\tmsg\t',err.message)
 
-  console.log(accessor.run('derp'))
+    debug('\tstack\t',err.stack)
+
+    debug('\tlocations\t',err.locations)
+  }
 
-  console.log(build)
+  debug('# Middleware #')
+  debug('\t Name=', decryptInfo.info.Name)
+  debug('\t Type="', decryptInfo.info.Type, '"')
+  debug('\t Desc="', decryptInfo.info.Description, '"')
 
   process.exit()
 }