@temporalio/core-bridge 0.16.4 → 0.18.0

package/sdk-core/{src → core/src}/core_tests/replay_flag.rs

@@ -1,14 +1,11 @@
-use crate::{
-    prototype_rust_sdk::{WfContext, WorkflowFunction},
-    test_help::canned_histories,
-    workflow::managed_wf::ManagedWFFunc,
-};
+use crate::{test_help::canned_histories, workflow::managed_wf::ManagedWFFunc};
 use rstest::{fixture, rstest};
 use std::time::Duration;
+use temporal_sdk::{WfContext, WorkflowFunction};
 use temporal_sdk_core_protos::temporal::api::enums::v1::CommandType;
 
 fn timers_wf(num_timers: u32) -> WorkflowFunction {
-    WorkflowFunction::new(move |mut command_sink: WfContext| async move {
+    WorkflowFunction::new(move |command_sink: WfContext| async move {
         for _ in 1..=num_timers {
             command_sink.timer(Duration::from_secs(1)).await;
         }
@@ -30,20 +27,19 @@ fn fire_happy_hist(num_timers: u32) -> ManagedWFFunc {
 #[tokio::test]
 async fn replay_flag_is_correct(#[case] mut wfm: ManagedWFFunc, #[case] num_timers: usize) {
     // Verify replay flag is correct by constructing a workflow manager that already has a complete
-    // history fed into it. The first (few, depending on test a params) activation(s) will be under
-    // replay while the last should not
+    // history fed into it. It should always be replaying, because history is complete.
 
     for _ in 1..=num_timers {
         let act = wfm.get_next_activation().await.unwrap();
         assert!(act.is_replaying);
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 1);
         assert_eq!(commands[0].command_type, CommandType::StartTimer as i32);
     }
 
     let act = wfm.get_next_activation().await.unwrap();
-    assert!(!act.is_replaying);
-    let commands = wfm.get_server_commands().await.commands;
+    assert!(act.is_replaying);
+    let commands = wfm.get_server_commands().commands;
     assert_eq!(commands.len(), 1);
     assert_eq!(
         commands[0].command_type,
@@ -62,7 +58,7 @@ async fn replay_flag_is_correct_partial_history() {
 
     let act = wfm.get_next_activation().await.unwrap();
     assert!(!act.is_replaying);
-    let commands = wfm.get_server_commands().await.commands;
+    let commands = wfm.get_server_commands().commands;
     assert_eq!(commands.len(), 1);
     assert_eq!(commands[0].command_type, CommandType::StartTimer as i32);
     wfm.shutdown().await.unwrap();

package/sdk-core/{src → core/src}/core_tests/workers.rs

@@ -1,27 +1,29 @@
 use crate::{
-    pollers::{MockManualGateway, MockServerGatewayApis},
     test_help::{
-        build_fake_core, build_multihist_mock_sg, canned_histories, hist_to_poll_resp, mock_core,
-        mock_core_with_opts_no_workers, mock_manual_poller, register_mock_workers,
-        single_hist_mock_sg, FakeWfResponses, MockWorker, MocksHolder, ResponseType, TEST_Q,
+        build_fake_core, build_mock_pollers, build_multihist_mock_sg, canned_histories,
+        hist_to_poll_resp, mock_core, mock_core_with_opts_no_workers, mock_manual_poller,
+        register_mock_workers, single_hist_mock_sg, FakeWfResponses, MockPollCfg, MockWorker,
+        MocksHolder, ResponseType, TEST_Q,
     },
-    Core, CoreInitOptionsBuilder, CoreSDK, PollWfError, WorkerConfigBuilder,
+    Core, CoreInitOptionsBuilder, CoreSDK, PollActivityError, PollWfError, WorkerConfigBuilder,
 };
 use futures::FutureExt;
 use rstest::{fixture, rstest};
-use std::time::Duration;
+use std::{cell::RefCell, time::Duration};
+use temporal_client::mocks::{mock_gateway, mock_manual_gateway};
 use temporal_sdk_core_protos::{
     coresdk::{
-        workflow_activation::wf_activation_job,
+        workflow_activation::workflow_activation_job,
         workflow_commands::{
             workflow_command, ActivityCancellationType, CompleteWorkflowExecution,
             RequestCancelActivity, ScheduleActivity, StartTimer,
         },
-        workflow_completion::WfActivationCompletion,
+        workflow_completion::WorkflowActivationCompletion,
     },
     temporal::api::workflowservice::v1::RespondWorkflowTaskCompletedResponse,
 };
-use tokio::sync::watch;
+use temporal_sdk_core_test_utils::start_timer_cmd;
+use tokio::sync::{watch, Barrier};
 
 #[tokio::test]
 async fn multi_workers() {
@@ -45,9 +47,9 @@ async fn multi_workers() {
         let res = core.poll_workflow_activation(&tq).await.unwrap();
         assert_matches!(
             res.jobs[0].variant,
-            Some(wf_activation_job::Variant::StartWorkflow(_))
+            Some(workflow_activation_job::Variant::StartWorkflow(_))
         );
-        core.complete_workflow_activation(WfActivationCompletion::empty(tq, res.run_id))
+        core.complete_workflow_activation(WorkflowActivationCompletion::empty(tq, res.run_id))
             .await
             .unwrap();
     }
@@ -90,7 +92,6 @@ async fn worker_double_register_is_err() {
                 .build()
                 .unwrap(),
         )
-        .await
         .is_err());
 }
 
@@ -116,7 +117,7 @@ async fn pending_activities_only_returned_for_their_queue() {
 
     // Create a pending activation by cancelling a try-cancel activity
     let res = core.poll_workflow_activation("q-1").await.unwrap();
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         "q-1",
         res.run_id,
         vec![ScheduleActivity {
@@ -130,7 +131,7 @@ async fn pending_activities_only_returned_for_their_queue() {
     .await
     .unwrap();
     let res = core.poll_workflow_activation("q-1").await.unwrap();
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         "q-1",
         res.run_id,
         vec![RequestCancelActivity { seq: act_id }.into()],
@@ -141,14 +142,14 @@ async fn pending_activities_only_returned_for_their_queue() {
     let res = core.poll_workflow_activation("q-2").await.unwrap();
     assert_matches!(
         res.jobs[0].variant,
-        Some(wf_activation_job::Variant::StartWorkflow(_))
+        Some(workflow_activation_job::Variant::StartWorkflow(_))
     );
 }
 
 #[tokio::test]
 async fn nonexistent_worker_poll_returns_not_registered() {
     let core =
-        mock_core_with_opts_no_workers(MockManualGateway::new(), CoreInitOptionsBuilder::default());
+        mock_core_with_opts_no_workers(mock_manual_gateway(), CoreInitOptionsBuilder::default());
     assert_matches!(
         core.poll_workflow_activation(TEST_Q).await.unwrap_err(),
         PollWfError::NoWorkerForQueue(_)
@@ -165,7 +166,7 @@ async fn after_shutdown_of_worker_get_shutdown_err() {
 
     tokio::join!(core.shutdown_worker(TEST_Q), async {
         // Need to complete task for shutdown to finish
-        core.complete_workflow_activation(WfActivationCompletion::from_cmd(
+        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
             TEST_Q,
             run_id.clone(),
             workflow_command::Variant::StartTimer(StartTimer {
@@ -179,11 +180,14 @@ async fn after_shutdown_of_worker_get_shutdown_err() {
         let res = core.poll_workflow_activation(TEST_Q).await.unwrap();
         assert_matches!(
             res.jobs[0].variant,
-            Some(wf_activation_job::Variant::RemoveFromCache(_))
+            Some(workflow_activation_job::Variant::RemoveFromCache(_))
         );
-        core.complete_workflow_activation(WfActivationCompletion::empty(TEST_Q, run_id.clone()))
-            .await
-            .unwrap();
+        core.complete_workflow_activation(WorkflowActivationCompletion::empty(
+            TEST_Q,
+            run_id.clone(),
+        ))
+        .await
+        .unwrap();
         assert_matches!(
             core.poll_workflow_activation(TEST_Q).await.unwrap_err(),
             PollWfError::ShutDown
@@ -197,17 +201,17 @@ async fn after_shutdown_of_worker_can_be_reregistered() {
     let mut core = build_fake_core("fake_wf_id", t.clone(), &[1]);
     let res = core.poll_workflow_activation(TEST_Q).await.unwrap();
     assert_eq!(res.jobs.len(), 1);
-    core.complete_workflow_activation(WfActivationCompletion::empty(TEST_Q, res.run_id))
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(TEST_Q, res.run_id))
         .await
         .unwrap();
     core.shutdown_worker(TEST_Q).await;
     // Need to recreate mock to re-register worker
-    let mocks = single_hist_mock_sg("fake_wf_id", t, &[1], MockServerGatewayApis::new(), true);
+    let mocks = single_hist_mock_sg("fake_wf_id", t, &[1], mock_gateway(), true);
     let pollers = mocks.take_pollers().into_values();
     register_mock_workers(&mut core, pollers);
     // Worker is replaced and the different mock returns a new wft
     let res = core.poll_workflow_activation(TEST_Q).await.unwrap();
-    core.complete_workflow_activation(WfActivationCompletion::empty(TEST_Q, res.run_id))
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(TEST_Q, res.run_id))
         .await
         .unwrap();
     core.shutdown().await;
@@ -220,14 +224,10 @@ async fn shutdown_worker_can_complete_pending_activation() {
     let res = core.poll_workflow_activation(TEST_Q).await.unwrap();
     assert_eq!(res.jobs.len(), 1);
     // Complete the timer, will queue PA
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         TEST_Q,
         res.run_id,
-        vec![StartTimer {
-            seq: 1,
-            ..Default::default()
-        }
-        .into()],
+        vec![start_timer_cmd(1, Duration::from_secs(1))],
     ))
     .await
     .unwrap();
@@ -236,7 +236,7 @@ async fn shutdown_worker_can_complete_pending_activation() {
         let res = core.poll_workflow_activation(TEST_Q).await.unwrap();
         // The timer fires
         assert_eq!(res.jobs.len(), 1);
-        core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
             TEST_Q,
             res.run_id,
             vec![CompleteWorkflowExecution::default().into()],
@@ -281,7 +281,7 @@ fn worker_shutdown() -> (CoreSDK, watch::Sender<bool>) {
         });
         mock_pollers.push(MockWorker::new(&tq, Box::from(mock_poller)));
     }
-    let mut mock_gateway = MockServerGatewayApis::new();
+    let mut mock_gateway = mock_gateway();
     mock_gateway
         .expect_complete_workflow_task()
         .returning(|_| Ok(RespondWorkflowTaskCompletedResponse::default()));
@@ -324,7 +324,7 @@ async fn worker_shutdown_during_multiple_poll_doesnt_deadlock(
     };
     let poll2fut = async {
         let res = core.poll_workflow_activation("q2").await.unwrap();
-        core.complete_workflow_activation(WfActivationCompletion::empty("q2", res.run_id))
+        core.complete_workflow_activation(WorkflowActivationCompletion::empty("q2", res.run_id))
             .await
             .unwrap();
     };
@@ -336,3 +336,90 @@ async fn worker_shutdown_during_multiple_poll_doesnt_deadlock(
     tokio::join!(pollfut, poll2fut, shutdownfut);
     core.shutdown().await;
 }
+
+#[rstest]
+#[tokio::test]
+async fn can_shutdown_local_act_only_worker_when_act_polling(
+    #[values(true, false)] whole_core_shutdown: bool,
+) {
+    let t = canned_histories::single_timer("1");
+    let mock = mock_gateway();
+    let mh = MockPollCfg::from_resp_batches("fakeid", t, [1], mock);
+    let mut mock = build_mock_pollers(mh);
+    mock.worker_cfg(TEST_Q, |w| {
+        w.no_remote_activities = true;
+    });
+    let core = mock_core(mock);
+    let barrier = Barrier::new(2);
+
+    tokio::join!(
+        async {
+            barrier.wait().await;
+            if whole_core_shutdown {
+                core.shutdown().await;
+            } else {
+                core.shutdown_worker(TEST_Q).await;
+            }
+        },
+        async {
+            let res = core.poll_workflow_activation(TEST_Q).await.unwrap();
+            // Complete so there's no outstanding WFT and shutdown can finish
+            core.complete_workflow_activation(WorkflowActivationCompletion::empty(
+                TEST_Q, res.run_id,
+            ))
+            .await
+            .unwrap();
+            barrier.wait().await;
+            assert_matches!(
+                core.poll_activity_task(TEST_Q).await.unwrap_err(),
+                PollActivityError::ShutDown
+            );
+        }
+    );
+}
+
+#[tokio::test]
+async fn complete_with_task_not_found_during_shutdwn() {
+    let t = canned_histories::single_timer("1");
+    let mut mock = mock_gateway();
+    mock.expect_complete_workflow_task()
+        .times(1)
+        .returning(|_| Err(tonic::Status::not_found("Workflow task not found.")));
+    let mh = MockPollCfg::from_resp_batches("fakeid", t, [1], mock);
+    let core = mock_core(build_mock_pollers(mh));
+
+    let res = core.poll_workflow_activation(TEST_Q).await.unwrap();
+    assert_eq!(res.jobs.len(), 1);
+
+    let complete_order = RefCell::new(vec![]);
+    // Initiate shutdown before completing the activation
+    let shutdown_fut = async {
+        core.shutdown().await;
+        complete_order.borrow_mut().push(3);
+    };
+    let poll_fut = async {
+        // This should *not* return shutdown, but instead should do nothing until the complete
+        // goes through, at which point it will return the eviction.
+        let res = core.poll_workflow_activation(TEST_Q).await.unwrap();
+        assert_matches!(
+            res.jobs[0].variant,
+            Some(workflow_activation_job::Variant::RemoveFromCache(_))
+        );
+        core.complete_workflow_activation(WorkflowActivationCompletion::empty(TEST_Q, res.run_id))
+            .await
+            .unwrap();
+        complete_order.borrow_mut().push(2);
+    };
+    let complete_fut = async {
+        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
+            TEST_Q,
+            res.run_id,
+            vec![start_timer_cmd(1, Duration::from_secs(1))],
+        ))
+        .await
+        .unwrap();
+        complete_order.borrow_mut().push(1);
+    };
+    tokio::join!(shutdown_fut, poll_fut, complete_fut);
+    assert_eq!(&complete_order.into_inner(), &[1, 2, 3])
+}

package/sdk-core/{src → core/src}/core_tests/workflow_cancels.rs

@@ -6,12 +6,14 @@ use crate::{
     workflow::WorkflowCachingPolicy::NonSticky,
 };
 use rstest::rstest;
+use std::time::Duration;
 use temporal_sdk_core_protos::coresdk::{
-    workflow_activation::{wf_activation_job, WfActivationJob},
+    workflow_activation::{workflow_activation_job, WorkflowActivationJob},
     workflow_commands::{
-        CancelWorkflowExecution, CompleteWorkflowExecution, FailWorkflowExecution, StartTimer,
+        CancelWorkflowExecution, CompleteWorkflowExecution, FailWorkflowExecution,
     },
 };
+use temporal_sdk_core_test_utils::start_timer_cmd;
 
 enum CompletionType {
     Complete,
@@ -56,17 +58,13 @@ async fn timer_then_cancel_req(
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::StartWorkflow(_)),
-                vec![StartTimer {
-                    seq: timer_seq,
-                    ..Default::default()
-                }
-                .into()],
+                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
+                vec![start_timer_cmd(timer_seq, Duration::from_secs(1))],
             ),
             gen_assert_and_reply(
                 &job_assert!(
-                    wf_activation_job::Variant::FireTimer(_),
-                    wf_activation_job::Variant::CancelWorkflow(_)
+                    workflow_activation_job::Variant::FireTimer(_),
+                    workflow_activation_job::Variant::CancelWorkflow(_)
                 ),
                 vec![final_cmd],
             ),
@@ -86,26 +84,18 @@ async fn timer_then_cancel_req_then_timer_then_cancelled() {
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::StartWorkflow(_)),
-                vec![StartTimer {
-                    seq: 1,
-                    ..Default::default()
-                }
-                .into()],
+                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
+                vec![start_timer_cmd(1, Duration::from_secs(1))],
             ),
             gen_assert_and_reply(
                 &job_assert!(
-                    wf_activation_job::Variant::FireTimer(_),
-                    wf_activation_job::Variant::CancelWorkflow(_)
+                    workflow_activation_job::Variant::FireTimer(_),
+                    workflow_activation_job::Variant::CancelWorkflow(_)
                 ),
-                vec![StartTimer {
-                    seq: 2,
-                    ..Default::default()
-                }
-                .into()],
+                vec![start_timer_cmd(2, Duration::from_secs(1))],
             ),
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::FireTimer(_)),
+                &job_assert!(workflow_activation_job::Variant::FireTimer(_)),
                 vec![CancelWorkflowExecution::default().into()],
             ),
         ],
@@ -124,8 +114,8 @@ async fn immediate_cancel() {
         NonSticky,
         &[gen_assert_and_reply(
             &job_assert!(
-                wf_activation_job::Variant::StartWorkflow(_),
-                wf_activation_job::Variant::CancelWorkflow(_)
+                workflow_activation_job::Variant::StartWorkflow(_),
+                workflow_activation_job::Variant::CancelWorkflow(_)
             ),
             vec![CancelWorkflowExecution {}.into()],
         )],