@temporalio/core-bridge 1.1.0 → 1.4.0

package/sdk-core/core/src/core_tests/activity_tasks.rs

@@ -1,5 +1,5 @@
 use crate::{
-    advance_fut, job_assert,
+    advance_fut, job_assert, prost_dur,
     test_help::{
         build_fake_worker, build_mock_pollers, canned_histories, gen_assert_and_reply,
         mock_manual_poller, mock_poller, mock_poller_from_resps, mock_worker, poll_and_reply,
@@ -10,6 +10,7 @@ use crate::{
     ActivityHeartbeat, Worker, WorkerConfigBuilder,
 };
 use futures::FutureExt;
+use itertools::Itertools;
 use std::{
     cell::RefCell,
     collections::{hash_map::Entry, HashMap, VecDeque},
@@ -23,6 +24,7 @@ use std::{
 use temporal_client::WorkflowOptions;
 use temporal_sdk::{ActivityOptions, WfContext};
 use temporal_sdk_core_api::{errors::CompleteActivityError, Worker as WorkerTrait};
+use temporal_sdk_core_protos::temporal::api::command::v1::ScheduleActivityTaskCommandAttributes;
 use temporal_sdk_core_protos::{
     coresdk::{
         activity_result::{
@@ -149,14 +151,14 @@ async fn heartbeats_report_cancels_only_once() {
             PollActivityTaskQueueResponse {
                 task_token: vec![1],
                 activity_id: "act1".to_string(),
-                heartbeat_timeout: Some(Duration::from_millis(1).into()),
+                heartbeat_timeout: Some(prost_dur!(from_millis(1))),
                 ..Default::default()
             }
             .into(),
             PollActivityTaskQueueResponse {
                 task_token: vec![2],
                 activity_id: "act2".to_string(),
-                heartbeat_timeout: Some(Duration::from_millis(1).into()),
+                heartbeat_timeout: Some(prost_dur!(from_millis(1))),
                 ..Default::default()
             }
             .into(),
@@ -226,7 +228,7 @@ async fn activity_cancel_interrupts_poll() {
         async {
             Some(Ok(PollActivityTaskQueueResponse {
                 task_token: vec![1],
-                heartbeat_timeout: Some(Duration::from_secs(1).into()),
+                heartbeat_timeout: Some(prost_dur!(from_secs(1))),
                 ..Default::default()
             }))
         }
@@ -263,7 +265,7 @@ async fn activity_cancel_interrupts_poll() {
         act_poller: Some(Box::from(mock_poller)),
         ..Default::default()
     };
-    let core = mock_worker(MocksHolder::from_mock_worker(mock_client.into(), mw));
+    let core = mock_worker(MocksHolder::from_mock_worker(mock_client, mw));
     let last_finisher = AtomicUsize::new(0);
     // Perform first poll to get the activity registered
     let act = core.poll_activity_task().await.unwrap();
@@ -315,7 +317,7 @@ async fn activity_poll_timeout_retries() {
         act_poller: Some(Box::from(mock_act_poller)),
         ..Default::default()
     };
-    let core = mock_worker(MocksHolder::from_mock_worker(mock_client.into(), mw));
+    let core = mock_worker(MocksHolder::from_mock_worker(mock_client, mw));
     let r = core.poll_activity_task().await.unwrap();
     assert_matches!(r.task_token.as_slice(), b"hello!");
 }
@@ -333,7 +335,7 @@ async fn many_concurrent_heartbeat_cancels() {
                 async move {
                     Ok(PollActivityTaskQueueResponse {
                         task_token: i.to_be_bytes().to_vec(),
-                        heartbeat_timeout: Some(Duration::from_millis(200).into()),
+                        heartbeat_timeout: Some(prost_dur!(from_millis(200))),
                         ..Default::default()
                     })
                 }
@@ -506,7 +508,7 @@ async fn can_heartbeat_acts_during_shutdown() {
         [PollActivityTaskQueueResponse {
             task_token: vec![1],
             activity_id: "act1".to_string(),
-            heartbeat_timeout: Some(Duration::from_millis(1).into()),
+            heartbeat_timeout: Some(prost_dur!(from_millis(1))),
             ..Default::default()
         }
         .into()],
@@ -559,7 +561,7 @@ async fn complete_act_with_fail_flushes_heartbeat() {
         [PollActivityTaskQueueResponse {
             task_token: vec![1],
             activity_id: "act1".to_string(),
-            heartbeat_timeout: Some(Duration::from_secs(10).into()),
+            heartbeat_timeout: Some(prost_dur!(from_secs(10))),
             ..Default::default()
         }
         .into()],
@@ -616,31 +618,61 @@ async fn max_tq_acts_set_passed_to_poll_properly() {
 /// delivered via polling.
 #[tokio::test]
 async fn activity_tasks_from_completion_are_delivered() {
+    // Construct the history - one task with 5 activities, 4 on the same task queue, and 1 on a
+    // different queue, 3 activities will be executed eagerly as specified by the
+    // MAX_EAGER_ACTIVITY_RESERVATIONS_PER_WORKFLOW_TASK constant.
     let wfid = "fake_wf_id";
     let mut t = TestHistoryBuilder::default();
     t.add_by_type(EventType::WorkflowExecutionStarted);
     t.add_full_wf_task();
-    let schedid = t.add_activity_task_scheduled("act_id");
-    let startid = t.add_activity_task_started(schedid);
-    t.add_activity_task_completed(schedid, startid, b"hi".into());
+    let act_same_queue_scheduled_ids = (1..4)
+        .map(|i| t.add_activity_task_scheduled(format!("act_id_{}_same_queue", i)))
+        .collect_vec();
+    t.add_activity_task_scheduled("act_id_same_queue_not_eager");
+    t.add_activity_task_scheduled("act_id_different_queue");
+    for scheduled_event_id in act_same_queue_scheduled_ids {
+        let started_event_id = t.add_activity_task_started(scheduled_event_id);
+        t.add_activity_task_completed(scheduled_event_id, started_event_id, b"hi".into());
+    }
     t.add_full_wf_task();
     t.add_workflow_execution_completed();
 
+    let num_eager_requested = Arc::new(AtomicUsize::new(0));
+    // Clone it to move into the callback below
+    let num_eager_requested_clone = num_eager_requested.clone();
+
     let mut mock = mock_workflow_client();
     mock.expect_complete_workflow_task()
         .times(1)
-        .returning(move |_| {
+        .returning(move |req| {
+            // Store the number of eager activities requested to be checked below
+            let count = req
+                .commands
+                .into_iter()
+                .filter(|c| match c.attributes {
+                    Some(Attributes::ScheduleActivityTaskCommandAttributes(
+                        ScheduleActivityTaskCommandAttributes {
+                            request_eager_execution,
+                            ..
+                        },
+                    )) => request_eager_execution,
+                    _ => false,
+                })
+                .count();
+            num_eager_requested_clone.store(count, Ordering::Relaxed);
             Ok(RespondWorkflowTaskCompletedResponse {
                 workflow_task: None,
-                activity_tasks: vec![PollActivityTaskQueueResponse {
-                    task_token: vec![1],
-                    activity_id: "act1".to_string(),
-                    ..Default::default()
-                }],
+                activity_tasks: (1..4)
+                    .map(|i| PollActivityTaskQueueResponse {
+                        task_token: vec![i],
+                        activity_id: format!("act_id_{}_same_queue", i),
+                        ..Default::default()
+                    })
+                    .collect_vec(),
             })
         });
     mock.expect_complete_activity_task()
-        .times(1)
+        .times(3)
         .returning(|_, _| Ok(RespondActivityTaskCompletedResponse::default()));
     let mut mock = single_hist_mock_sg(wfid, t, [1], mock, true);
     let mut mock_poller = mock_manual_poller();
@@ -651,32 +683,65 @@ async fn activity_tasks_from_completion_are_delivered() {
     mock.worker_cfg(|wc| wc.max_cached_workflows = 2);
     let core = mock_worker(mock);
 
+    // Test start
     let wf_task = core.poll_workflow_activation().await.unwrap();
-    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
-        wf_task.run_id,
+    let mut cmds = (1..4)
+        .map(|seq| {
+            ScheduleActivity {
+                seq,
+                activity_id: format!("act_id_{}_same_queue", seq),
+                task_queue: TEST_Q.to_string(),
+                cancellation_type: ActivityCancellationType::TryCancel as i32,
+                ..Default::default()
+            }
+            .into()
+        })
+        .collect_vec();
+    cmds.push(
         ScheduleActivity {
-            seq: 1,
-            activity_id: "act_id".to_string(),
+            seq: 4,
+            activity_id: "act_id_same_queue_not_eager".to_string(),
+            task_queue: TEST_Q.to_string(),
             cancellation_type: ActivityCancellationType::TryCancel as i32,
             ..Default::default()
         }
         .into(),
+    );
+    cmds.push(
+        ScheduleActivity {
+            seq: 5,
+            activity_id: "act_id_different_queue".to_string(),
+            task_queue: "different_queue".to_string(),
+            cancellation_type: ActivityCancellationType::Abandon as i32,
+            ..Default::default()
+        }
+        .into(),
+    );
+
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
+        wf_task.run_id,
+        cmds,
     ))
     .await
     .unwrap();
 
-    // We should see the activity when we poll now
-    let act_task = core.poll_activity_task().await.unwrap();
-    assert_eq!(act_task.task_token, vec![1]);
+    // We should see the 3 eager activities when we poll now
+    for i in 1..4 {
+        let act_task = core.poll_activity_task().await.unwrap();
+        assert_eq!(act_task.task_token, vec![i]);
 
-    core.complete_activity_task(ActivityTaskCompletion {
-        task_token: act_task.task_token.clone(),
-        result: Some(ActivityExecutionResult::ok("hi".into())),
-    })
-    .await
-    .unwrap();
+        core.complete_activity_task(ActivityTaskCompletion {
+            task_token: act_task.task_token.clone(),
+            result: Some(ActivityExecutionResult::ok("hi".into())),
+        })
+        .await
+        .unwrap();
+    }
 
     core.shutdown().await;
+
+    // Verify only a single eager activity was scheduled (the one on our worker's task queue)
+    assert_eq!(num_eager_requested.load(Ordering::Relaxed), 3);
 }
 
 #[tokio::test]
@@ -818,7 +883,7 @@ async fn retryable_net_error_exhaustion_is_nonfatal() {
         [PollActivityTaskQueueResponse {
             task_token: vec![1],
             activity_id: "act1".to_string(),
-            heartbeat_timeout: Some(Duration::from_secs(10).into()),
+            heartbeat_timeout: Some(prost_dur!(from_secs(10))),
             ..Default::default()
         }
         .into()],

package/sdk-core/core/src/core_tests/child_workflows.rs

@@ -1,12 +1,20 @@
 use crate::{
     replay::DEFAULT_WORKFLOW_TYPE,
-    test_help::{canned_histories, mock_sdk, MockPollCfg, ResponseType},
+    test_help::{
+        canned_histories, mock_sdk, mock_worker, single_hist_mock_sg, MockPollCfg, ResponseType,
+    },
     worker::{client::mocks::mock_workflow_client, ManagedWFFunc},
 };
 use temporal_client::WorkflowOptions;
 use temporal_sdk::{ChildWorkflowOptions, Signal, WfContext, WorkflowFunction, WorkflowResult};
-use temporal_sdk_core_protos::coresdk::child_workflow::{
-    child_workflow_result, ChildWorkflowCancellationType,
+use temporal_sdk_core_api::Worker;
+use temporal_sdk_core_protos::coresdk::{
+    child_workflow::{child_workflow_result, ChildWorkflowCancellationType},
+    workflow_activation::{workflow_activation_job, WorkflowActivationJob},
+    workflow_commands::{
+        CancelChildWorkflowExecution, CompleteWorkflowExecution, StartChildWorkflowExecution,
+    },
+    workflow_completion::WorkflowActivationCompletion,
 };
 use tokio::join;
 
@@ -97,3 +105,117 @@ async fn cancel_child_workflow() {
     wfm.process_all_activations().await.unwrap();
     wfm.shutdown().await.unwrap();
 }
+
+#[rstest::rstest]
+#[case::abandon(ChildWorkflowCancellationType::Abandon)]
+#[case::try_cancel(ChildWorkflowCancellationType::TryCancel)]
+#[case::wait_cancel_completed(ChildWorkflowCancellationType::WaitCancellationCompleted)]
+#[tokio::test]
+async fn cancel_child_workflow_lang_thinks_not_started_but_is(
+    #[case] cancellation_type: ChildWorkflowCancellationType,
+) {
+    // Since signal handlers always run first, it's possible lang might try to cancel
+    // a child workflow it thinks isn't started, but we've told it is in the same activation.
+    // It would be annoying for lang to have to peek ahead at jobs to be consistent in that case.
+    let t = match cancellation_type {
+        ChildWorkflowCancellationType::Abandon => {
+            canned_histories::single_child_workflow_abandon_cancelled("child-id-1")
+        }
+        ChildWorkflowCancellationType::TryCancel => {
+            canned_histories::single_child_workflow_try_cancelled("child-id-1")
+        }
+        _ => canned_histories::single_child_workflow_cancelled("child-id-1"),
+    };
+    let mock = mock_workflow_client();
+    let mock = single_hist_mock_sg("fakeid", t, [ResponseType::AllHistory], mock, true);
+    let core = mock_worker(mock);
+    let act = core.poll_workflow_activation().await.unwrap();
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+        act.run_id,
+        StartChildWorkflowExecution {
+            seq: 1,
+            cancellation_type: cancellation_type as i32,
+            ..Default::default()
+        }
+        .into(),
+    ))
+    .await
+    .unwrap();
+    let act = core.poll_workflow_activation().await.unwrap();
+    assert_matches!(
+        act.jobs.as_slice(),
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::ResolveChildWorkflowExecutionStart(_)),
+        }]
+    );
+    // Issue the cancel command
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+        act.run_id,
+        CancelChildWorkflowExecution {
+            child_workflow_seq: 1,
+        }
+        .into(),
+    ))
+    .await
+    .unwrap();
+    let act = core.poll_workflow_activation().await.unwrap();
+    // Make sure that a resolve for the "request cancel external workflow" command does *not* appear
+    // since lang didn't actually issue one. The only job should be resolving the child workflow.
+    assert_matches!(
+        act.jobs.as_slice(),
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::ResolveChildWorkflowExecution(_)),
+        }]
+    );
+    // Request cancel external is technically fallible, but the only reasons relate to targeting
+    // a not-found workflow, which couldn't happen in this case.
+}
+
+#[tokio::test]
+async fn cancel_already_complete_child_ignored() {
+    let t = canned_histories::single_child_workflow("child-id-1");
+    let mock = mock_workflow_client();
+    let mock = single_hist_mock_sg("fakeid", t, [ResponseType::AllHistory], mock, true);
+    let core = mock_worker(mock);
+    let act = core.poll_workflow_activation().await.unwrap();
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+        act.run_id,
+        StartChildWorkflowExecution {
+            seq: 1,
+            ..Default::default()
+        }
+        .into(),
+    ))
+    .await
+    .unwrap();
+    let act = core.poll_workflow_activation().await.unwrap();
+    assert_matches!(
+        act.jobs.as_slice(),
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::ResolveChildWorkflowExecutionStart(_)),
+        }]
+    );
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(act.run_id))
+        .await
+        .unwrap();
+    let act = core.poll_workflow_activation().await.unwrap();
+    assert_matches!(
+        act.jobs.as_slice(),
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::ResolveChildWorkflowExecution(_)),
+        }]
+    );
+    // Try to cancel post-completion, it should be ignored. Also complete the wf.
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
+        act.run_id,
+        vec![
+            CancelChildWorkflowExecution {
+                child_workflow_seq: 1,
+            }
+            .into(),
+            CompleteWorkflowExecution { result: None }.into(),
+        ],
+    ))
+    .await
+    .unwrap();
+}

package/sdk-core/core/src/core_tests/local_activities.rs

@@ -1,4 +1,5 @@
 use crate::{
+    prost_dur,
     replay::{default_wes_attribs, TestHistoryBuilder, DEFAULT_WORKFLOW_TYPE},
     test_help::{
         hist_to_poll_resp, mock_sdk, mock_sdk_cfg, mock_worker, single_hist_mock_sg, MockPollCfg,
@@ -162,7 +163,7 @@ async fn local_act_heartbeat(#[case] shutdown_middle: bool) {
     let mut t = TestHistoryBuilder::default();
     let wft_timeout = Duration::from_millis(200);
     let mut wes_short_wft_timeout = default_wes_attribs();
-    wes_short_wft_timeout.workflow_task_timeout = Some(wft_timeout.into());
+    wes_short_wft_timeout.workflow_task_timeout = Some(wft_timeout.try_into().unwrap());
     t.add(
         EventType::WorkflowExecutionStarted,
         wes_short_wft_timeout.into(),
@@ -247,7 +248,7 @@ async fn local_act_fail_and_retry(#[case] eventually_pass: bool) {
                     activity_type: "echo".to_string(),
                     input: "hi".as_json_payload().expect("serializes fine"),
                     retry_policy: RetryPolicy {
-                        initial_interval: Some(Duration::from_millis(50).into()),
+                        initial_interval: Some(prost_dur!(from_millis(50))),
                         backoff_coefficient: 1.2,
                         maximum_interval: None,
                         maximum_attempts: 5,
@@ -328,10 +329,10 @@ async fn local_act_retry_long_backoff_uses_timer() {
                     activity_type: "echo".to_string(),
                     input: "hi".as_json_payload().expect("serializes fine"),
                     retry_policy: RetryPolicy {
-                        initial_interval: Some(Duration::from_millis(65).into()),
+                        initial_interval: Some(prost_dur!(from_millis(65))),
                         // This will make the second backoff 65 seconds, plenty to use timer
                         backoff_coefficient: 1_000.,
-                        maximum_interval: Some(Duration::from_secs(600).into()),
+                        maximum_interval: Some(prost_dur!(from_secs(600))),
                         maximum_attempts: 3,
                         non_retryable_error_types: vec![],
                     },
@@ -399,11 +400,10 @@ async fn local_act_null_result() {
 
 #[tokio::test]
 async fn query_during_wft_heartbeat_doesnt_accidentally_fail_to_continue_heartbeat() {
-    crate::telemetry::test_telem_console();
     let wfid = "fake_wf_id";
     let mut t = TestHistoryBuilder::default();
     let mut wes_short_wft_timeout = default_wes_attribs();
-    wes_short_wft_timeout.workflow_task_timeout = Some(Duration::from_millis(200).into());
+    wes_short_wft_timeout.workflow_task_timeout = Some(prost_dur!(from_millis(200)));
     t.add(
         EventType::WorkflowExecutionStarted,
         wes_short_wft_timeout.into(),

package/sdk-core/core/src/core_tests/workers.rs

@@ -1,4 +1,5 @@
 use crate::{
+    prost_dur,
     test_help::{
         build_fake_worker, build_mock_pollers, canned_histories, mock_manual_poller, mock_worker,
         MockPollCfg, MockWorkerInputs, MocksHolder, ResponseType,
@@ -35,7 +36,7 @@ async fn after_shutdown_of_worker_get_shutdown_err() {
                 run_id.clone(),
                 workflow_command::Variant::StartTimer(StartTimer {
                     seq: 1,
-                    start_to_fire_timeout: Some(Duration::from_secs(1).into()),
+                    start_to_fire_timeout: Some(prost_dur!(from_secs(1))),
                 }),
             ))
             .await
@@ -104,7 +105,7 @@ async fn worker_shutdown_during_poll_doesnt_deadlock() {
     mock_client
         .expect_complete_workflow_task()
         .returning(|_| Ok(RespondWorkflowTaskCompletedResponse::default()));
-    let worker = mock_worker(MocksHolder::from_mock_worker(mock_client.into(), mw));
+    let worker = mock_worker(MocksHolder::from_mock_worker(mock_client, mw));
     let pollfut = worker.poll_workflow_activation();
     let shutdownfut = async {
         worker.shutdown().await;

package/sdk-core/core/src/core_tests/workflow_tasks.rs

@@ -15,7 +15,7 @@ use crate::{
 use futures::{stream, FutureExt};
 use rstest::{fixture, rstest};
 use std::{
-    collections::VecDeque,
+    collections::{HashMap, VecDeque},
     sync::{
         atomic::{AtomicU64, Ordering},
         Arc,
@@ -33,11 +33,15 @@ use temporal_sdk_core_protos::{
         },
         workflow_commands::{
             ActivityCancellationType, CancelTimer, CompleteWorkflowExecution,
-            FailWorkflowExecution, RequestCancelActivity, ScheduleActivity,
+            ContinueAsNewWorkflowExecution, FailWorkflowExecution, RequestCancelActivity,
+            ScheduleActivity,
         },
         workflow_completion::WorkflowActivationCompletion,
     },
+    default_wes_attribs,
     temporal::api::{
+        command::v1::command::Attributes,
+        common::v1::{Payload, RetryPolicy},
         enums::v1::{EventType, WorkflowTaskFailedCause},
         failure::v1::Failure,
         history::v1::{history_event, TimerFiredEventAttributes},
@@ -2000,3 +2004,67 @@ async fn no_race_acquiring_permits() {
     };
     join!(poll_1_f, poll_2_f, other_f);
 }
+
+#[tokio::test]
+async fn continue_as_new_preserves_some_values() {
+    let wfid = "fake_wf_id";
+    let memo = HashMap::<String, Payload>::from([("enchi".to_string(), b"cat".into())]).into();
+    let search = HashMap::<String, Payload>::from([("noisy".to_string(), b"kitty".into())]).into();
+    let retry_policy = RetryPolicy {
+        backoff_coefficient: 13.37,
+        ..Default::default()
+    };
+    let mut wes_attrs = default_wes_attribs();
+    wes_attrs.memo = Some(memo);
+    wes_attrs.search_attributes = Some(search);
+    wes_attrs.retry_policy = Some(retry_policy);
+    let mut mock_client = mock_workflow_client();
+    let hist = {
+        let mut t = TestHistoryBuilder::default();
+        t.add(
+            EventType::WorkflowExecutionStarted,
+            wes_attrs.clone().into(),
+        );
+        t.add_full_wf_task();
+        t
+    };
+    mock_client
+        .expect_poll_workflow_task()
+        .returning(move |_, _| {
+            Ok(hist_to_poll_resp(
+                &hist,
+                wfid.to_owned(),
+                ResponseType::AllHistory,
+                TEST_Q.to_string(),
+            )
+            .resp)
+        });
+    mock_client
+        .expect_complete_workflow_task()
+        .returning(move |mut c| {
+            let can_cmd = c.commands.pop().unwrap().attributes.unwrap();
+            if let Attributes::ContinueAsNewWorkflowExecutionCommandAttributes(a) = can_cmd {
+                assert_eq!(a.workflow_type.unwrap().name, "meow");
+                assert_eq!(a.memo, wes_attrs.memo);
+                assert_eq!(a.search_attributes, wes_attrs.search_attributes);
+                assert_eq!(a.retry_policy, wes_attrs.retry_policy);
+            } else {
+                panic!("Wrong attributes type");
+            }
+            Ok(Default::default())
+        });
+
+    let worker = Worker::new_test(test_worker_cfg().build().unwrap(), mock_client);
+    let r = worker.poll_workflow_activation().await.unwrap();
+    worker
+        .complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+            r.run_id,
+            ContinueAsNewWorkflowExecution {
+                workflow_type: "meow".to_string(),
+                ..Default::default()
+            }
+            .into(),
+        ))
+        .await
+        .unwrap();
+}