Merge pull request #512 from RocketChat/improvement/vm2-poc

[NEW] Add runtime provider management and support VM2

Author: AllanPazRibeiro

package-lock.json

@@ -91,7 +91,8 @@
     "lodash.clonedeep": "^4.5.0",
     "semver": "^5.7.1",
     "stack-trace": "0.0.10",
-    "uuid": "^3.4.0"
+    "uuid": "^3.4.0",
+    "vm2": "^3.9.11"
   },
   "nyc": {
     "include": [

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rocket.chat/apps-ts-definition",
-  "version": "1.33.0-alpha",
+  "version": "1.35.0-alpha",
   "description": "Contains the TypeScript definitions for the Rocket.Chat Applications.",
   "main": "index.js",
   "typings": "index",

src/definition/package.json

@@ -25,6 +25,7 @@ import { IMarketplaceInfo } from './marketplace';
 import { DisabledApp } from './misc/DisabledApp';
 import { defaultPermissions } from './permissions/AppPermissions';
 import { ProxiedApp } from './ProxiedApp';
+import { AppsEngineEmptyRuntime } from './runtime/AppsEngineEmptyRuntime';
 import { AppLogStorage, AppMetadataStorage, IAppStorageItem } from './storage';
 import { AppSourceStorage } from './storage/AppSourceStorage';
 
@@ -240,7 +241,7 @@ export class AppManager {
                 app.getLogger().error(e);
                 this.logStorage.storeEntries(app.getID(), app.getLogger());
 
-                const prl = new ProxiedApp(this, item, app, () => '');
+                const prl = new ProxiedApp(this, item, app, new AppsEngineEmptyRuntime(app));
                 this.apps.set(item.id, prl);
                 aff.setApp(prl);
             }

src/server/AppManager.ts

@@ -1,5 +1,3 @@
-import * as vm from 'vm';
-
 import { IAppAccessors, ILogger } from '../definition/accessors';
 import { App } from '../definition/App';
 import { AppStatus } from '../definition/AppStatus';
@@ -10,23 +8,27 @@ import { AppManager } from './AppManager';
 import { NotEnoughMethodArgumentsError } from './errors';
 import { AppConsole } from './logging';
 import { AppLicenseValidationResult } from './marketplace/license';
-import { Utilities } from './misc/Utilities';
+import { AppsEngineRuntime } from './runtime/AppsEngineRuntime';
 import { IAppStorageItem } from './storage';
 
-export const ROCKETCHAT_APP_EXECUTION_PREFIX = '$RocketChat_App$';
-
 export class ProxiedApp implements IApp {
     private previousStatus: AppStatus;
 
     private latestLicenseValidationResult: AppLicenseValidationResult;
 
-    constructor(private readonly manager: AppManager,
-                private storageItem: IAppStorageItem,
-                private readonly app: App,
-                private readonly customRequire: (mod: string) => {}) {
+    constructor(
+        private readonly manager: AppManager,
+        private storageItem: IAppStorageItem,
+        private readonly app: App,
+        private readonly runtime: AppsEngineRuntime,
+    ) {
         this.previousStatus = storageItem.status;
     }
 
+    public getRuntime(): AppsEngineRuntime {
+        return this.runtime;
+    }
+
     public getApp(): App {
         return this.app;
     }
@@ -51,12 +53,6 @@ export class ProxiedApp implements IApp {
         return typeof (this.app as any)[method] === 'function';
     }
 
-    public makeContext(data: object): vm.Context {
-        return Utilities.buildDefaultAppContext(Object.assign({}, {
-            require: this.customRequire,
-        }, data));
-    }
-
     public setupLogger(method: AppMethod): AppConsole {
         const logger = new AppConsole(method);
         // Set the logger to our new one
@@ -65,13 +61,6 @@ export class ProxiedApp implements IApp {
         return logger;
     }
 
-    public runInContext(codeToRun: string, context: vm.Context): any {
-        return vm.runInContext(codeToRun, context, {
-            timeout: 1000,
-            filename: `${ ROCKETCHAT_APP_EXECUTION_PREFIX }_${ this.getName() }.ts`,
-        });
-    }
-
     public async call(method: AppMethod, ...args: Array<any>): Promise<any> {
         if (typeof (this.app as any)[method] !== 'function') {
             throw new Error(`The App ${this.app.getName()} (${this.app.getID()}`
@@ -89,8 +78,10 @@ export class ProxiedApp implements IApp {
 
         let result;
         try {
-            // tslint:disable-next-line:max-line-length
-            result = await this.runInContext(`app.${method}.apply(app, args)`, this.makeContext({ app: this.app, args })) as Promise<any>;
+            result = await this.runtime.runInSandbox(
+                `module.exports = app.${method}.apply(app, args)`,
+                { app: this.app, args },
+            );
             logger.debug(`'${method}' was successfully called! The result is:`, result);
         } catch (e) {
             logger.error(e);

src/server/ProxiedApp.ts

@@ -1,14 +1,14 @@
 import * as path from 'path';
-import * as vm from 'vm';
 
 import { App } from '../../definition/App';
 import { AppMethod } from '../../definition/metadata';
 import { AppAccessors } from '../accessors';
 import { AppManager } from '../AppManager';
-import { MustContainFunctionError, MustExtendAppError } from '../errors';
+import { MustContainFunctionError } from '../errors';
 import { AppConsole } from '../logging';
-import { Utilities } from '../misc/Utilities';
 import { ProxiedApp } from '../ProxiedApp';
+import { getRuntime } from '../runtime';
+import { buildCustomRequire } from '../runtime/require';
 import { IAppStorageItem } from '../storage';
 import { IParseAppPackageResult } from './IParseAppPackageResult';
 
@@ -29,31 +29,30 @@ export class AppCompiler {
                 `Could not find the classFile (${ storage.info.classFile }) file.`);
         }
 
-        const exports = {};
-        const customRequire = Utilities.buildCustomRequire(files, storage.info.id);
-        const context = Utilities.buildDefaultAppContext({ require: customRequire, exports, process: {}, console });
+        const Runtime = getRuntime();
 
-        const script = new vm.Script(files[path.normalize(storage.info.classFile)]);
-        const result = script.runInContext(context);
+        const customRequire = buildCustomRequire(files, storage.info.id);
+        const result = Runtime.runCode(files[path.normalize(storage.info.classFile)], {
+            require: customRequire,
+        });
 
         if (typeof result !== 'function') {
             // tslint:disable-next-line:max-line-length
             throw new Error(`The App's main class for ${ storage.info.name } is not valid ("${ storage.info.classFile }").`);
         }
-
         const appAccessors = new AppAccessors(manager, storage.info.id);
         const logger = new AppConsole(AppMethod._CONSTRUCTOR);
-        const rl = vm.runInNewContext('new App(info, rcLogger, appAccessors);', Utilities.buildDefaultAppContext({
+        const rl = Runtime.runCode('exports.app = new App(info, rcLogger, appAccessors);', {
             rcLogger: logger,
             info: storage.info,
             App: result,
-            process: {},
             appAccessors,
-        }), { timeout: 1000, filename: `App_${ storage.info.nameSlug }.js` });
+        }, { timeout: 1000, filename: `App_${ storage.info.nameSlug }.js` });
 
-        if (!(rl instanceof App)) {
-            throw new MustExtendAppError();
-        }
+        // TODO: app is importing the Class App internally so it's not same object to compare. Need to find a way to make this test
+        // if (!(rl instanceof App)) {
+        //     throw new MustExtendAppError();
+        // }
 
         if (typeof rl.getName !== 'function') {
             throw new MustContainFunctionError(storage.info.classFile, 'getName');
@@ -79,7 +78,8 @@ export class AppCompiler {
             throw new MustContainFunctionError(storage.info.classFile, 'getRequiredApiVersion');
         }
 
-        const app = new ProxiedApp(manager, storage, rl as App, customRequire);
+        // TODO: Fix this type cast from to any to the right one
+        const app = new ProxiedApp(manager, storage, rl as App, new Runtime(rl as App, customRequire as any));
 
         manager.getLogStorage().storeEntries(app.getID(), logger);
 

src/server/compiler/AppCompiler.ts

@@ -44,8 +44,8 @@ const proxyHandlers = {
     querystring: defaultHandler,
 };
 
-export function requireNativeModule(module: AllowedInternalModules, appId: string) {
-    const requiredModule = require(module);
+export function requireNativeModule(module: AllowedInternalModules, appId: string, requirer: any) {
+    const requiredModule = requirer(module);
 
     return new Proxy(
         requiredModule,

src/server/compiler/modules/index.ts

@@ -75,24 +75,22 @@ export class AppApi {
             hash: this.hash,
         };
 
-        const runContext = this.app.makeContext({
-            endpoint: this.endpoint,
-            args: [
-                request,
-                endpoint,
-                accessors.getReader(this.app.getID()),
-                accessors.getModifier(this.app.getID()),
-                accessors.getHttp(this.app.getID()),
-                accessors.getPersistence(this.app.getID()),
-            ],
-        });
-
         const logger = this.app.setupLogger(AppMethod._API_EXECUTOR);
         logger.debug(`${ path }'s ${ method } is being executed...`, request);
 
-        const runCode = `endpoint.${ method }.apply(endpoint, args)`;
+        const runCode = `module.exports = endpoint.${ method }.apply(endpoint, args)`;
         try {
-            const result: IApiResponse = await this.app.runInContext(runCode, runContext);
+            const result: IApiResponse = await this.app.getRuntime().runInSandbox(runCode, {
+                endpoint: this.endpoint,
+                args: [
+                    request,
+                    endpoint,
+                    accessors.getReader(this.app.getID()),
+                    accessors.getModifier(this.app.getID()),
+                    accessors.getHttp(this.app.getID()),
+                    accessors.getPersistence(this.app.getID()),
+                ],
+            });
             logger.debug(`${ path }'s ${ method } was successfully executed.`);
             logStorage.storeEntries(this.app.getID(), logger);
             return result;

src/server/managers/AppApi.ts

@@ -1,7 +1,7 @@
 import { IPermission } from '../../definition/permissions/IPermission';
 import { getPermissionsByAppId } from '../AppManager';
 import { PermissionDeniedError } from '../errors/PermissionDeniedError';
-import { ROCKETCHAT_APP_EXECUTION_PREFIX } from '../ProxiedApp';
+import { APPS_ENGINE_RUNTIME_FILE_PREFIX } from '../runtime/AppsEngineRuntime';
 
 export class AppPermissionManager {
     /**
@@ -33,7 +33,7 @@ export class AppPermissionManager {
 
     private static getCallStack(): string {
         const stack = new Error().stack.toString().split('\n');
-        const appStackIndex = stack.findIndex((position) => position.includes(ROCKETCHAT_APP_EXECUTION_PREFIX));
+        const appStackIndex = stack.findIndex((position) => position.includes(APPS_ENGINE_RUNTIME_FILE_PREFIX));
 
         return stack.slice(4, appStackIndex).join('\n');
     }

src/server/managers/AppPermissionManager.ts

@@ -63,23 +63,21 @@ export class AppSchedulerManager {
                 return;
             }
 
-            const context = app.makeContext({
-                processor,
-                args: [
-                    jobContext,
-                    this.accessors.getReader(appId),
-                    this.accessors.getModifier(appId),
-                    this.accessors.getHttp(appId),
-                    this.accessors.getPersistence(appId),
-                ],
-            });
-
             const logger = app.setupLogger(AppMethod._JOB_PROCESSOR);
             logger.debug(`Job processor ${processor.id} is being executed...`);
 
             try {
-                const codeToRun = `processor.processor.apply(null, args)`;
-                await app.runInContext(codeToRun, context);
+                const codeToRun = `module.exports = processor.processor.apply(null, args)`;
+                await app.getRuntime().runInSandbox(codeToRun, {
+                    processor,
+                    args: [
+                        jobContext,
+                        this.accessors.getReader(appId),
+                        this.accessors.getModifier(appId),
+                        this.accessors.getHttp(appId),
+                        this.accessors.getPersistence(appId),
+                    ],
+                });
                 logger.debug(`Job processor ${processor.id} was sucessfully executed`);
             } catch (e) {
                 logger.error(e);