feat(workflow): Reuse a single v8 context (#951)

* Reusable v8 context

* Skip test-isolation in non reusable context mode

* Fix tests

* One less serialization

* Fix SDK version for reuseV8Context

* Run in worker thread

* No serialization of activations and completions

* Self review

* Fix unhandled rejection handling

* Address review comments

Author: bergundy

.github/workflows/ci.yml

@@ -15,8 +15,14 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
+        reuse-v8-context: [false]
         node: [14, 16]
         os: [ubuntu-latest, macos-latest, windows-latest]
+        include:
+          - os: ubuntu-latest
+            node: 16
+            reuse-v8-context: true
+
     runs-on: ${{ matrix.os }}
     steps:
       - name: Print build information
@@ -66,6 +72,7 @@ jobs:
         env:
           # TODO: Run integration tests on MacOS / Windows probably using temporalite
           RUN_INTEGRATION_TESTS: ${{ startsWith(matrix.os, 'ubuntu') }}
+          REUSE_V8_CONTEXT: ${{ matrix.reuse-v8-context }}
 
       - uses: actions/upload-artifact@v3
         if: ${{ failure() }}
@@ -303,3 +310,11 @@ jobs:
     with:
       test-type: ci-stress
       test-timeout-minutes: 20
+      reuse-v8-context: false
+
+  stress-tests-reuse-context:
+    uses: ./.github/workflows/stress.yml
+    with:
+      test-type: ci-stress
+      test-timeout-minutes: 20
+      reuse-v8-context: true

.github/workflows/stress.yml

@@ -9,18 +9,22 @@ on:
       test-timeout-minutes:
         required: true
         type: number
+      reuse-v8-context:
+        required: true
+        type: boolean
 
 env:
   TEMPORAL_TESTING_LOG_DIR: /tmp/worker-logs
   TEMPORAL_TESTING_MEM_LOG_DIR: /tmp/worker-mem-logs
   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+  REUSE_V8_CONTEXT: ${{ inputs.reuse-v8-context }}
 
 jobs:
   stress-test:
-    runs-on: ubuntu-latest-4-cores
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - name: Print build info
-        run: 'echo test-type: ${{ inputs.test-type }}, test-timeout-minutes: ${{ inputs.test-timeout-minutes }}'
+        run: 'echo test-type: ${{ inputs.test-type }}, test-timeout-minutes: ${{ inputs.test-timeout-minutes }}, reuse-v8-context: $REUSE_V8_CONTEXT'
       - uses: actions/checkout@v2
         with:
           submodules: recursive

docs/activation-in-debug-mode.mermaid

@@ -0,0 +1,29 @@
+%% Activation diagram for Worker with `debugMode` option on
+sequenceDiagram
+    participant Server
+    participant Core as Rust Core
+    participant MT as Node Main Thread
+    participant VM as Workflow VM Sandbox
+
+    MT->>+Core: Poll Workflow Activation
+    opt No pending work
+        Core->>+Server: Poll Workflow Task
+        Server-->>-Core: Respond with Workflow Task
+    end
+    Core->>-MT: Respond with Activation
+    MT->>MT: Decode Payloads
+    loop patches, signals, completions, queries as jobs
+        MT->>VM: Activate(jobs)
+        VM->>VM: Run Microtasks
+        MT->>VM: Try Unblock Conditions
+    end
+    MT->>VM: Collect Commands
+    MT->>MT: Encode Payloads
+    MT->>+VM: Collect Sink Calls
+    VM-->>-MT: Respond with Sink Calls
+    MT->>MT: Run Sink Functions
+    MT->>Core: Complete Activation
+    opt Completed Workflow Task   
+        Core->>Server: Complete Workflow Task
+    end
+

docs/activation.mermaid

@@ -1,3 +1,4 @@
+%% Activation diagram for Worker with `reuseV8Context` option off
 sequenceDiagram
     participant Server
     participant Core as Rust Core

docs/arch-debug-mode.svg

@@ -1,8 +1,10 @@
 import path from 'path';
 import StackUtils from 'stack-utils';
-import ava from 'ava';
+import ava, { TestFn } from 'ava';
 import { inWorkflowContext } from '@temporalio/workflow';
 import { Payload, PayloadCodec } from '@temporalio/common';
+import { Worker as RealWorker, WorkerOptions } from '@temporalio/worker';
+import * as worker from '@temporalio/worker';
 
 export function u8(s: string): Uint8Array {
   // TextEncoder requires lib "dom"
@@ -18,6 +20,7 @@ export function isSet(env: string | undefined): boolean {
 }
 
 export const RUN_INTEGRATION_TESTS = inWorkflowContext() || isSet(process.env.RUN_INTEGRATION_TESTS);
+export const REUSE_V8_CONTEXT = inWorkflowContext() || isSet(process.env.REUSE_V8_CONTEXT);
 
 export async function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -48,10 +51,22 @@ export function cleanStackTrace(ostack: string): string {
   return normalizedStack ? `${firstLine}\n${normalizedStack}` : firstLine;
 }
 
+function noopTest() {
+  // eslint: this function body is empty and it's okay.
+}
+
+noopTest.serial = () => undefined;
+noopTest.macro = () => undefined;
+noopTest.before = () => undefined;
+noopTest.after = () => undefined;
+(noopTest.after as any).always = () => undefined;
+noopTest.beforeEach = () => undefined;
+noopTest.afterEach = () => undefined;
+
 /**
- * (Incomplete) helper to allow mixing workflow and non-workflow code in the same test file.
+ * (Mostly complete) helper to allow mixing workflow and non-workflow code in the same test file.
  */
-export const test = inWorkflowContext() ? () => undefined : ava;
+export const test: TestFn<unknown> = inWorkflowContext() ? (noopTest as any) : ava;
 
 export const bundlerOptions = {
   // This is a bit ugly but it does the trick, when a test that includes workflow code tries to import a forbidden
@@ -65,6 +80,7 @@ export const bundlerOptions = {
     'crypto',
     'module',
     'path',
+    'stack-utils',
   ],
 };
 
@@ -86,3 +102,16 @@ export class ByteSkewerPayloadCodec implements PayloadCodec {
     }));
   }
 }
+
+// Hack around Worker not being available in workflow context
+if (inWorkflowContext()) {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  worker.Worker = class {}; // eslint-disable-line import/namespace
+}
+
+export class Worker extends worker.Worker {
+  static async create(options: WorkerOptions): Promise<worker.Worker> {
+    return RealWorker.create({ ...options, reuseV8Context: REUSE_V8_CONTEXT });
+  }
+}