Implement signals

bergundy · bergundy · commit 6738d41c2398 · 2021-04-27T15:41:00.000+03:00
diff --git a/packages/test-workflows/src/signals.ts b/packages/test-workflows/src/signals.ts
@@ -15,12 +15,23 @@ const signals = {
 };
 
 async function main(): Promise<void> {
-  await Promise.race([
-    new Promise((_resolve, reject) => {
-      interrupt = reject;
-    }),
-    sleep(100000),
-  ]);
+  try {
+    await Promise.race([
+      new Promise<never>((_resolve, reject) => {
+        interrupt = reject;
+      }),
+      (async (): Promise<never> => {
+        await sleep(100000);
+        throw new Error('Sleep completed unexpectedly');
+      })(),
+    ]);
+  } catch (err) {
+    if (err.message !== 'just because') {
+      throw new Error('Unexpected error');
+    }
+  }
+  // Don't complete to allow Workflow to be interrupted by fail() signal
+  await sleep(100000);
 }
 
 export const workflow: Interruptable = { main, signals };
diff --git a/packages/test/src/test-integration.ts b/packages/test/src/test-integration.ts
@@ -108,14 +108,14 @@ if (RUN_INTEGRATION_TESTS) {
     t.is(res, undefined);
   });
 
-  // Queries not yet properly implemented
-  test.skip('signals', async (t) => {
+  test('signals', async (t) => {
     const client = new Connection();
     const workflow = client.workflow<Interruptable>('signals', { taskQueue: 'test' });
     const promise = workflow.start();
     await workflow.started;
     await workflow.signal.interrupt('just because');
-    t.throwsAsync(promise, { message: /just because/, instanceOf: WorkflowExecutionFailedError });
+    await workflow.signal.fail();
+    await t.throwsAsync(promise, { message: /Signal failed/, instanceOf: WorkflowExecutionFailedError });
   });
 
   test('http', async (t) => {
diff --git a/packages/test/src/test-workflows.ts b/packages/test/src/test-workflows.ts
@@ -133,7 +133,7 @@ function makeSignalWorkflow(
   args: any[],
   timestamp: number = Date.now()
 ): coresdk.workflow_activation.IWFActivation {
-  return makeActivation(timestamp, { signalWorkflow: { signalName, input: args } });
+  return makeActivation(timestamp, { signalWorkflow: { signalName, input: defaultDataConverter.toPayloads(...args) } });
 }
 
 function makeCompleteWorkflowExecution(result?: coresdk.common.IPayload): coresdk.workflow_commands.IWorkflowCommand {
@@ -528,8 +528,7 @@ test('simple-query', async (t) => {
   }
 });
 
-// Signals have not yet been implemented
-test.skip('signals', async (t) => {
+test('signals', async (t) => {
   const { script } = t.context;
   {
     const req = await activate(t, makeStartWorkflow(script));
@@ -540,12 +539,30 @@ test.skip('signals', async (t) => {
     );
   }
   {
-    const req = await activate(t, makeSignalWorkflow('fail', []));
-    compareCompletion(t, req, makeSuccess([])); // TODO
+    const req = await activate(t, makeSignalWorkflow('interrupt', ['just because']));
+    compareCompletion(
+      t,
+      req,
+      makeSuccess([makeStartTimerCommand({ timerId: '1', startToFireTimeout: msToTs(100000) })])
+    );
   }
   {
-    const req = await activate(t, makeSignalWorkflow('interrupt', ['just because']));
-    compareCompletion(t, req, makeSuccess([])); // TODO
+    const req = cleanWorkflowFailureStackTrace(await activate(t, makeSignalWorkflow('fail', [])));
+    compareCompletion(
+      t,
+      req,
+      makeSuccess([
+        makeFailWorkflowExecution(
+          'Signal failed',
+          dedent`
+          Error: Signal failed
+              at fail
+              at Activator.signalWorkflow
+              at activate`,
+          'Error'
+        ),
+      ])
+    );
   }
 });
 
diff --git a/packages/workflow/src/internals.ts b/packages/workflow/src/internals.ts
@@ -213,8 +213,32 @@ export class Activator implements WorkflowTaskHandler {
     }
   }
 
-  public signalWorkflow(_activation: iface.coresdk.workflow_activation.ISignalWorkflow): void {
-    throw new Error('Not implemented');
+  public signalWorkflow(activation: iface.coresdk.workflow_activation.ISignalWorkflow): void {
+    if (state.workflow === undefined) {
+      throw new Error('state.workflow is not defined');
+    }
+    const { signals } = state.workflow;
+    if (signals === undefined) {
+      throw new Error('Workflow did not define any signals');
+    }
+
+    if (!activation.signalName) {
+      throw new Error('Missing activation signalName');
+    }
+
+    const fn = signals[activation.signalName];
+    if (fn === undefined) {
+      throw new Error(`Workflow did not register a signal named ${activation.signalName}`);
+    }
+    try {
+      // TODO: support custom converter
+      const retOrPromise = fn(...arrayFromPayloads(defaultDataConverter, activation.input));
+      if (retOrPromise instanceof Promise) {
+        retOrPromise.catch(failWorkflow);
+      }
+    } catch (err) {
+      failWorkflow(err);
+    }
   }
 
   public updateRandomSeed(activation: iface.coresdk.workflow_activation.IUpdateRandomSeed): void {
