@temporalio/core-bridge 1.0.0-rc.0 → 1.0.0-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporalio/core-bridge",
-  "version": "1.0.0-rc.0",
+  "version": "1.0.0-rc.1",
   "description": "Temporal.io SDK Core<>Node bridge",
   "main": "index.js",
   "types": "index.d.ts",
@@ -19,10 +19,10 @@
   "author": "Roey Berman <roey@temporal.io>",
   "license": "MIT",
   "dependencies": {
-    "@opentelemetry/api": "^1.0.3",
-    "@temporalio/internal-non-workflow-common": "^1.0.0-rc.0",
-    "arg": "^5.0.1",
-    "cargo-cp-artifact": "^0.1.4",
+    "@opentelemetry/api": "^1.1.0",
+    "@temporalio/internal-non-workflow-common": "^1.0.0-rc.1",
+    "arg": "^5.0.2",
+    "cargo-cp-artifact": "^0.1.6",
     "which": "^2.0.2"
   },
   "bugs": {
@@ -43,5 +43,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "c25e91309b980f2118df4048d760306982019871"
+  "gitHead": "723de0fbc7a04e68084ec99453578e7027eb3803"
 }

package/sdk-core/core/src/worker/workflow/machines/workflow_machines.rs

@@ -711,6 +711,17 @@ impl WorkflowMachines {
     /// to the server. While doing so, [TemporalStateMachine::handle_command] is called on the
     /// machine associated with the command.
     fn prepare_commands(&mut self) -> Result<()> {
+        // It's possible we might prepare commands more than once before completing a WFT. (Because
+        // of local activities, of course). Some commands might have since been cancelled that we
+        // already prepared. Rip them out of the outgoing command list if so.
+        self.commands.retain(|c| {
+            !self
+                .all_machines
+                .get(c.machine)
+                .expect("Machine must exist")
+                .was_cancelled_before_sent_to_server()
+        });
+
         while let Some(c) = self.current_wf_task_commands.pop_front() {
             if !self
                 .machine(c.machine)

package/sdk-core/sdk/src/workflow_future.rs

@@ -122,11 +122,10 @@ impl WorkflowFuture {
             UnblockEvent::CancelExternal(seq, _) => CommandID::CancelExternal(seq),
         };
         let unblocker = self.command_status.remove(&cmd_id);
-        unblocker
+        let _ = unblocker
             .ok_or_else(|| anyhow!("Command {:?} not found to unblock!", cmd_id))?
             .unblocker
-            .send(event)
-            .expect("Receive half of unblock channel must exist");
+            .send(event);
         Ok(())
     }
 

package/sdk-core/tests/integ_tests/workflow_tests/local_activities.rs

@@ -580,3 +580,55 @@ async fn timer_backoff_concurrent_with_non_timer_backoff() {
         .unwrap();
     worker.run_until_done().await.unwrap();
 }
+
+#[tokio::test]
+async fn repro_nondeterminism_with_timer_bug() {
+    let wf_name = "repro_nondeterminism_with_timer_bug";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+
+    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
+        let t1 = ctx.timer(Duration::from_secs(30));
+        let r1 = ctx.local_activity(LocalActivityOptions {
+            activity_type: "delay".to_string(),
+            input: "hi".as_json_payload().expect("serializes fine"),
+            retry_policy: RetryPolicy {
+                initial_interval: Some(Duration::from_micros(15).into()),
+                backoff_coefficient: 1_000.,
+                maximum_interval: Some(Duration::from_millis(1500).into()),
+                maximum_attempts: 4,
+                non_retryable_error_types: vec![],
+            },
+            timer_backoff_threshold: Some(Duration::from_secs(1)),
+            ..Default::default()
+        });
+        tokio::pin!(t1);
+        tokio::select! {
+            _ = &mut t1 => {},
+            _ = r1 => {
+                t1.cancel(&ctx);
+            },
+        };
+        ctx.timer(Duration::from_secs(1)).await;
+        Ok(().into())
+    });
+    worker.register_activity("delay", |_: ActContext, _: String| async {
+        tokio::time::sleep(Duration::from_secs(2)).await;
+        Ok(())
+    });
+
+    let run_id = worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+    starter
+        .fetch_history_and_replay(wf_name, run_id, worker.inner_mut())
+        .await
+        .unwrap();
+}