UNPKG

@temporalio/worker

Version:
240 lines (233 loc) 10.8 kB
"use strict"; var __importDefault = (this && this.__importDefault) || function (mod) { return (mod && mod.__esModule) ? mod : { "default": mod }; }; Object.defineProperty(exports, "__esModule", { value: true }); exports.ReusableVMWorkflow = exports.ReusableVMWorkflowCreator = void 0; const node_vm_1 = __importDefault(require("node:vm")); const common_1 = require("@temporalio/common"); const core_bridge_1 = require("@temporalio/core-bridge"); const vm_shared_1 = require("./vm-shared"); const callIntoVmScript = new node_vm_1.default.Script(`__TEMPORAL_CALL_INTO_SCOPE()`); /** * A WorkflowCreator that creates VMWorkflows in the current isolate */ class ReusableVMWorkflowCreator { workflowBundle; isolateExecutionTimeoutMs; registeredActivityNames; /** * TODO(bergundy): Get rid of this static state somehow */ static unhandledRejectionHandlerHasBeenSet = false; static workflowByRunId = new Map(); /** * Optional context - this attribute is deleted upon on {@link destroy} * * Use the {@link context} getter instead */ _context; pristineObj; constructor(script, workflowBundle, isolateExecutionTimeoutMs, /** Known activity names registered on the executing worker */ registeredActivityNames) { this.workflowBundle = workflowBundle; this.isolateExecutionTimeoutMs = isolateExecutionTimeoutMs; this.registeredActivityNames = registeredActivityNames; if (!ReusableVMWorkflowCreator.unhandledRejectionHandlerHasBeenSet) { (0, vm_shared_1.setUnhandledRejectionHandler)((runId) => ReusableVMWorkflowCreator.workflowByRunId.get(runId)); ReusableVMWorkflowCreator.unhandledRejectionHandlerHasBeenSet = true; } this._context = node_vm_1.default.createContext({}, { microtaskMode: 'afterEvaluate' }); node_vm_1.default.runInContext(`{ const __TEMPORAL_CALL_INTO_SCOPE = () => { const [holder, fn, args] = globalThis.__TEMPORAL_ARGS__; delete globalThis.__TEMPORAL_ARGS__; if (globalThis.__TEMPORAL_BAG_HOLDER__ !== holder) { if (globalThis.__TEMPORAL_BAG_HOLDER__ !== undefined) { globalThis.__TEMPORAL_BAG_HOLDER__.bag = Object.getOwnPropertyDescriptors(globalThis); } // Start with all properties, and remove the ones that we see; the rest will be deleted const toBeDeleted = new Set(Reflect.ownKeys(globalThis)); for (const prop of Reflect.ownKeys(holder.bag)) { if (holder.bag[prop].value !== globalThis[prop]) { Object.defineProperty(globalThis, prop, holder.bag[prop]); } toBeDeleted.delete(prop); } // Delete extra properties, left from the former context for (const prop of toBeDeleted) { delete globalThis[prop]; } globalThis.__TEMPORAL_BAG_HOLDER__ = holder; } return __TEMPORAL__.api[fn](...args); } Object.defineProperty(globalThis, '__TEMPORAL_CALL_INTO_SCOPE', { value: __TEMPORAL_CALL_INTO_SCOPE, writable: false, enumerable: false, configurable: false }); }`, this._context, { timeout: isolateExecutionTimeoutMs, displayErrors: true }); this.injectGlobals(this._context); const sharedModules = new Map(); const __webpack_module_cache__ = new Proxy({}, { get: (_, p) => { // Try the shared modules first const sharedModule = sharedModules.get(p); if (sharedModule) { return sharedModule; } const moduleCache = this.context.__TEMPORAL_ACTIVATOR__?.moduleCache; return moduleCache?.get(p); }, set: (_, p, val) => { const moduleCache = this.context.__TEMPORAL_ACTIVATOR__?.moduleCache; if (moduleCache != null) { moduleCache.set(p, val); } else { // Workflow has not yet been loaded, share the module sharedModules.set(p, val); } return true; }, }); Object.defineProperty(this._context, '__webpack_module_cache__', { value: __webpack_module_cache__, writable: false, enumerable: false, configurable: false, }); script.runInContext(this.context); // The V8 context is really composed of two distinct objects: the 'this._context' object on the outside, and another // internal object to which we only have access from the inside, which defines the built-in global properties. // Node makes some attempt at keeping the two in sync, but it's not perfect. To avoid various inconsistencies, // we capture the global variables from the inside of the V8 context. this.pristineObj = node_vm_1.default.runInContext(`Object.getOwnPropertyDescriptors(globalThis)`, this.context); for (const k of [ ...Object.getOwnPropertyNames(this.pristineObj), ...Object.getOwnPropertySymbols(this.pristineObj), ]) { if (k !== 'globalThis') { const v = this.pristineObj[k]; v.value = deepFreeze(v.value); } } for (const v of sharedModules.values()) deepFreeze(v); } get context() { const { _context } = this; if (_context == null) { throw new common_1.IllegalStateError('Tried to use v8 context after Workflow creator was destroyed'); } return _context; } /** * Inject global objects as well as console.[log|...] into a vm context. * * Overridable for test purposes. */ injectGlobals(context) { (0, vm_shared_1.injectGlobals)(context); } /** * Create a workflow with given options */ async createWorkflow(options) { const context = this.context; const holder = { bag: this.pristineObj }; const { isolateExecutionTimeoutMs } = this; const workflowModule = new Proxy({}, { get(_, fn) { return (...args) => { // By the time we get out of this call, all microtasks will have been executed context.__TEMPORAL_ARGS__ = [holder, fn, args]; return callIntoVmScript.runInContext(context, { timeout: isolateExecutionTimeoutMs, displayErrors: true, }); }; }, }); workflowModule.initRuntime({ ...options, sourceMap: this.workflowBundle.sourceMap, getTimeOfDay: core_bridge_1.native.getTimeOfDay, registeredActivityNames: this.registeredActivityNames, }); const activator = context['__TEMPORAL_ACTIVATOR__']; const newVM = new ReusableVMWorkflow(options.info.runId, context, activator, workflowModule); ReusableVMWorkflowCreator.workflowByRunId.set(options.info.runId, newVM); return newVM; } /** * Create a new instance, pre-compile scripts from given code. * * This method is generic to support subclassing. */ static async create(workflowBundle, isolateExecutionTimeoutMs, registeredActivityNames) { vm_shared_1.globalHandlers.install(); // Call is idempotent await vm_shared_1.globalHandlers.addWorkflowBundle(workflowBundle); const script = new node_vm_1.default.Script(workflowBundle.code, { filename: workflowBundle.filename }); return new this(script, workflowBundle, isolateExecutionTimeoutMs, registeredActivityNames); } /** * Cleanup the pre-compiled script */ async destroy() { vm_shared_1.globalHandlers.removeWorkflowBundle(this.workflowBundle); delete this._context; } } exports.ReusableVMWorkflowCreator = ReusableVMWorkflowCreator; /** * A Workflow implementation using Node.js' built-in `vm` module */ class ReusableVMWorkflow extends vm_shared_1.BaseVMWorkflow { async dispose() { ReusableVMWorkflowCreator.workflowByRunId.delete(this.runId); } } exports.ReusableVMWorkflow = ReusableVMWorkflow; /** * Call `Object.freeze()` recursively on an object. * * Note that there are limits to this approach, as traversing using getOwnPropertyXxx doesn't allow * reaching variables defined in internal scopes. That notably means that Map and Set classes, * are not frozen. Similarly, private properties and variables defined in closures are unreachable * and will therefore not be frozen. It is simply impossible to cover all potential cases. * * We also do not attempt to visit the prototype chain, as this would make it much harder to load * polyfills, and it is extremely unlikely anyway that one would modify the prototype of a built-in * object in a way that would have undesirable consequences (i.e. a polyfill function may actually * leak to another workflow context, but it wouldn't carry anything Workflow specific). * * This implementation is based on https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze. * Some implementatino decisions (e.g. freezing functions, not freezing prototypes, not handling Maps * and Sets, etc) are specific to the Reusable VM Workflow Sandbox use case, and may not be appropriate * for other use cases. For that reason, it is preferable to keep this function private to this module, * rather than exposing it as a reusable utility in the common package. */ function deepFreeze(object, visited = new WeakSet()) { if (object == null || visited.has(object) || (typeof object !== 'object' && typeof object !== 'function')) return object; visited.add(object); if (Object.isFrozen(object)) return object; if (typeof object === 'object') { // Retrieve the property names defined on object const propNames = [...Object.getOwnPropertyNames(object), ...Object.getOwnPropertySymbols(object)]; // Freeze properties before freezing self for (const name of propNames) { const value = object[name]; if (value && (typeof value === 'object' || typeof value === 'function')) { try { deepFreeze(value, visited); } catch (_err) { // This is okay, for various reasons, some objects can't be frozen, e.g. Uint8Array. } } } } return Object.freeze(object); } //# sourceMappingURL=reusable-vm.js.map