fix(workflow): Propagate scope cancellation while waiting on ExternalWorkflowHandle cancellation (temporalio#633)

bergundy · web-flow · commit de44dba89ac7 · 2022-05-07T00:25:14.000Z
* fix(workflow)!: Propagate scope cancellation while waiting on ExternalWorkflowHandle cancellation

* Avoid breaking history compatibility

* Try to avoid some CI failures waiting for verdaccio startup

* Don't use markers unnecessarily and address CR comments
diff --git a/packages/test/src/test-workflows.ts b/packages/test/src/test-workflows.ts
@@ -1803,3 +1803,28 @@ test('waitOnUser', async (t) => {
     compareCompletion(t, completion, makeSuccess());
   }
 });
+
+test('scopeCancelledWhileWaitingOnExternalWorkflowCancellation', async (t) => {
+  const { workflowType } = t.context;
+  {
+    const completion = await activate(t, makeStartWorkflow(workflowType));
+    compareCompletion(
+      t,
+      completion,
+      makeSuccess([
+        {
+          requestCancelExternalWorkflowExecution: {
+            seq: 1,
+            workflowExecution: { namespace: 'default', workflowId: 'irrelevant' },
+          },
+        },
+        {
+          setPatchMarker: { deprecated: false, patchId: '__temporal_internal_connect_external_handle_cancel_to_scope' },
+        },
+        {
+          completeWorkflowExecution: { result: defaultPayloadConverter.toPayload(undefined) },
+        },
+      ])
+    );
+  }
+});
diff --git a/packages/test/src/workflows/index.ts b/packages/test/src/workflows/index.ts
@@ -61,6 +61,7 @@ export * from './random';
 export * from './reject-promise';
 export * from './run-activity-in-different-task-queue';
 export * from './set-timeout-after-microtasks';
+export * from './scope-cancelled-while-waiting-on-external-workflow-cancellation';
 export * from './shared-promise-scopes';
 export * from './shield-awaited-in-root-scope';
 export * from './shield-in-shield';
diff --git a/packages/test/src/workflows/scope-cancelled-while-waiting-on-external-workflow-cancellation.ts b/packages/test/src/workflows/scope-cancelled-while-waiting-on-external-workflow-cancellation.ts
@@ -0,0 +1,29 @@
+/**
+ * Tests that scope cancellation is propagated to the workflow while waiting on
+ * external workflow cancellation (`await ExternalWorkflowHandle.cancel()`).
+ *
+ * This test was added along with the behavior fix where waiting for external
+ * workflow cancellation was the only framework generated promise that was not
+ * connected to a a cancellation scope.
+ *
+ * @module
+ */
+import { CancelledFailure } from '@temporalio/common';
+import { CancellationScope, getExternalWorkflowHandle } from '@temporalio/workflow';
+
+export async function scopeCancelledWhileWaitingOnExternalWorkflowCancellation(): Promise<void> {
+  try {
+    await CancellationScope.cancellable(async () => {
+      const handle = getExternalWorkflowHandle('irrelevant');
+      const promise = handle.cancel();
+      CancellationScope.current().cancel();
+      await promise;
+      throw new Error('External cancellation was not cancelled');
+    });
+    throw new Error('Expected CancellationScope to throw CancelledFailure');
+  } catch (err) {
+    if (!(err instanceof CancelledFailure)) {
+      throw err;
+    }
+  }
+}
diff --git a/packages/workflow/src/workflow.ts b/packages/workflow/src/workflow.ts
@@ -532,6 +532,9 @@ export function proxyLocalActivities<A extends ActivityInterface>(options: Local
   ) as any;
 }
 
+// TODO: deprecate this patch after "enough" time has passed
+const EXTERNAL_WF_CANCEL_PATCH = '__temporal_internal_connect_external_handle_cancel_to_scope';
+
 /**
  * Returns a client-side handle that can be used to signal and cancel an existing Workflow execution.
  * It takes a Workflow ID and optional run ID.
@@ -545,6 +548,28 @@ export function getExternalWorkflowHandle(workflowId: string, runId?: string): E
         if (state.info === undefined) {
           throw new IllegalStateError('Uninitialized workflow');
         }
+
+        // Connect this cancel operation to the current cancellation scope.
+        // This is behavior was introduced after v0.22.0 and is incompatible
+        // with histories generated with previous SDK versions and thus requires
+        // patching.
+        //
+        // We try to delay patching as much as possible to avoid polluting
+        // histories unless strictly required.
+        const scope = CancellationScope.current();
+        if (scope.cancellable) {
+          scope.cancelRequested.catch((err) => {
+            if (patched(EXTERNAL_WF_CANCEL_PATCH)) {
+              reject(err);
+            }
+          });
+        }
+        if (scope.consideredCancelled) {
+          if (patched(EXTERNAL_WF_CANCEL_PATCH)) {
+            return;
+          }
+        }
+
         const seq = state.nextSeqs.cancelWorkflow++;
         state.pushCommand({
           requestCancelExternalWorkflowExecution: {
@@ -657,15 +682,9 @@ export async function startChild<T extends Workflow>(
     workflowId: optionsWithDefaults.workflowId,
     originalRunId,
     result(): Promise<WorkflowResultType<T>> {
-      if (completed === undefined) {
-        throw new IllegalStateError('Child Workflow was not started');
-      }
       return completed as any;
     },
     async signal<Args extends any[]>(def: SignalDefinition<Args> | string, ...args: Args): Promise<void> {
-      if (started === undefined) {
-        throw new IllegalStateError('Workflow execution not started');
-      }
       return composeInterceptors(
         state.interceptors.outbound,
         'signalWorkflow',
diff --git a/scripts/registry.js b/scripts/registry.js
@@ -53,6 +53,15 @@ class Registry {
           let contents;
           try {
             contents = await readFile(logPath, 'utf8');
+            // Sometimes (mostly in Windows) tail can miss updates.
+            // Use this workaround as a last resort to recover and avoid failing CI.
+            const found = contents
+              .split('\n')
+              .map(JSON.parse)
+              .find((parsed) => parsed.addr);
+            if (found) {
+              resolve();
+            }
           } catch (e) {
             contents = `Error ${e}`;
           }
