@temporalio/core-bridge 1.11.6 → 1.11.8

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

@@ -0,0 +1,104 @@
+use std::time::Duration;
+use temporal_client::{Priority, WorkflowClientTrait, WorkflowOptions};
+use temporal_sdk::{ActContext, ActivityOptions, ChildWorkflowOptions, WfContext};
+use temporal_sdk_core_protos::{
+    coresdk::AsJsonPayloadExt, temporal::api::history::v1::history_event::Attributes,
+};
+use temporal_sdk_core_test_utils::CoreWfStarter;
+
+#[tokio::test]
+async fn priority_values_sent_to_server() {
+    let mut starter = CoreWfStarter::new("priority-values-sent-to-server");
+    starter.workflow_options.priority = Some(Priority { priority_key: 1 });
+    let mut worker = starter.worker().await;
+    let child_type = "child-wf";
+
+    worker.register_wf(starter.get_task_queue(), move |ctx: WfContext| async move {
+        let child = ctx.child_workflow(ChildWorkflowOptions {
+            workflow_id: format!("{}-child", ctx.task_queue()),
+            workflow_type: child_type.to_owned(),
+            options: WorkflowOptions {
+                priority: Some(Priority { priority_key: 4 }),
+                ..Default::default()
+            },
+            ..Default::default()
+        });
+
+        let started = child
+            .start(&ctx)
+            .await
+            .into_started()
+            .expect("Child should start OK");
+        let activity = ctx.activity(ActivityOptions {
+            activity_type: "echo".to_owned(),
+            input: "hello".as_json_payload().unwrap(),
+            start_to_close_timeout: Some(Duration::from_secs(5)),
+            priority: Some(Priority { priority_key: 5 }),
+            ..Default::default()
+        });
+        started.result().await;
+        activity.await;
+        Ok(().into())
+    });
+    worker.register_wf(child_type.to_owned(), |_ctx: WfContext| async move {
+        Ok(().into())
+    });
+    worker.register_activity("echo", |_ctx: ActContext, echo_me: String| async move {
+        Ok(echo_me)
+    });
+
+    starter
+        .start_with_worker(starter.get_task_queue(), &mut worker)
+        .await;
+    worker.run_until_done().await.unwrap();
+
+    let client = starter.get_client().await;
+    let history = client
+        .get_workflow_execution_history(starter.get_task_queue().to_owned(), None, vec![])
+        .await
+        .unwrap()
+        .history
+        .unwrap();
+    let workflow_init_event = history
+        .events
+        .iter()
+        .find_map(|e| {
+            if let Attributes::WorkflowExecutionStartedEventAttributes(e) =
+                e.attributes.as_ref().unwrap()
+            {
+                Some(e)
+            } else {
+                None
+            }
+        })
+        .unwrap();
+    assert_eq!(workflow_init_event.priority.unwrap().priority_key, 1);
+    let child_init_event = history
+        .events
+        .iter()
+        .find_map(|e| {
+            if let Attributes::StartChildWorkflowExecutionInitiatedEventAttributes(e) =
+                e.attributes.as_ref().unwrap()
+            {
+                Some(e)
+            } else {
+                None
+            }
+        })
+        .unwrap();
+    assert_eq!(child_init_event.priority.unwrap().priority_key, 4);
+    let activity_sched_event = history
+        .events
+        .iter()
+        .find_map(|e| {
+            if let Attributes::ActivityTaskScheduledEventAttributes(e) =
+                e.attributes.as_ref().unwrap()
+            {
+                Some(e)
+            } else {
+                None
+            }
+        })
+        .unwrap();
+    assert_eq!(activity_sched_event.priority.unwrap().priority_key, 5);
+}

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

@@ -2,21 +2,21 @@ use crate::integ_tests::workflow_tests::patches::changes_wf;
 use assert_matches::assert_matches;
 use parking_lot::Mutex;
 use std::{collections::HashSet, sync::Arc, time::Duration};
-use temporal_sdk::{interceptors::WorkerInterceptor, WfContext, Worker, WorkflowFunction};
+use temporal_sdk::{WfContext, Worker, WorkflowFunction, interceptors::WorkerInterceptor};
 use temporal_sdk_core::replay::{HistoryFeeder, HistoryForReplay};
-use temporal_sdk_core_api::errors::{PollActivityError, PollWfError};
+use temporal_sdk_core_api::errors::PollError;
 use temporal_sdk_core_protos::{
+    DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder,
     coresdk::{
         workflow_activation::remove_from_cache::EvictionReason,
         workflow_commands::{ScheduleActivity, StartTimer},
         workflow_completion::WorkflowActivationCompletion,
     },
     temporal::api::enums::v1::EventType,
-    TestHistoryBuilder, DEFAULT_WORKFLOW_TYPE,
 };
 use temporal_sdk_core_test_utils::{
-    canned_histories, history_from_proto_binary, init_core_replay_preloaded, replay_sdk_worker,
-    replay_sdk_worker_stream, WorkerTestHelpers,
+    WorkerTestHelpers, canned_histories, history_from_proto_binary, init_core_replay_preloaded,
+    replay_sdk_worker, replay_sdk_worker_stream,
 };
 use tokio::join;
 
@@ -39,21 +39,20 @@ async fn timer_workflow_replay() {
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task.run_id,
-        vec![StartTimer {
-            seq: 0,
-            start_to_fire_timeout: Some(prost_dur!(from_secs(1))),
-        }
-        .into()],
+        vec![
+            StartTimer {
+                seq: 0,
+                start_to_fire_timeout: Some(prost_dur!(from_secs(1))),
+            }
+            .into(),
+        ],
     ))
     .await
     .unwrap();
     let task = core.poll_workflow_activation().await.unwrap();
     // Verify that an in-progress poll is interrupted by completion finishing processing history
     let act_poll_fut = async {
-        assert_matches!(
-            core.poll_activity_task().await,
-            Err(PollActivityError::ShutDown)
-        );
+        assert_matches!(core.poll_activity_task().await, Err(PollError::ShutDown));
     };
     let poll_fut = async {
         let evict_task = core
@@ -66,7 +65,7 @@ async fn timer_workflow_replay() {
             .unwrap();
         assert_matches!(
             core.poll_workflow_activation().await,
-            Err(PollWfError::ShutDown)
+            Err(PollError::ShutDown)
         );
     };
     let complete_fut = async {
@@ -77,7 +76,7 @@ async fn timer_workflow_replay() {
     // Subsequent polls should still return shutdown
     assert_matches!(
         core.poll_workflow_activation().await,
-        Err(PollWfError::ShutDown)
+        Err(PollError::ShutDown)
     );
 
     core.shutdown().await;
@@ -97,13 +96,15 @@ async fn workflow_nondeterministic_replay() {
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task.run_id,
-        vec![ScheduleActivity {
-            seq: 0,
-            activity_id: "0".to_string(),
-            activity_type: "fake_act".to_string(),
-            ..Default::default()
-        }
-        .into()],
+        vec![
+            ScheduleActivity {
+                seq: 0,
+                activity_id: "0".to_string(),
+                activity_type: "fake_act".to_string(),
+                ..Default::default()
+            }
+            .into(),
+        ],
     ))
     .await
     .unwrap();
@@ -117,7 +118,7 @@ async fn workflow_nondeterministic_replay() {
     core.shutdown().await;
     assert_matches!(
         core.poll_workflow_activation().await,
-        Err(PollWfError::ShutDown)
+        Err(PollError::ShutDown)
     );
 }
 
@@ -264,13 +265,15 @@ async fn replay_ends_with_empty_wft() {
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task.run_id,
-        vec![ScheduleActivity {
-            seq: 1,
-            activity_id: "1".to_string(),
-            activity_type: "say_hello".to_string(),
-            ..Default::default()
-        }
-        .into()],
+        vec![
+            ScheduleActivity {
+                seq: 1,
+                activity_id: "1".to_string(),
+                activity_type: "say_hello".to_string(),
+                ..Default::default()
+            }
+            .into(),
+        ],
     ))
     .await
     .unwrap();

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

@@ -2,8 +2,8 @@ use crate::integ_tests::activity_functions::echo;
 use futures_util::StreamExt;
 use std::{
     sync::{
-        atomic::{AtomicBool, AtomicU64, Ordering},
         Arc,
+        atomic::{AtomicBool, AtomicU64, Ordering},
     },
     time::Duration,
 };

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

@@ -6,8 +6,8 @@ use temporal_sdk_core_protos::coresdk::{
     workflow_completion::WorkflowActivationCompletion,
 };
 use temporal_sdk_core_test_utils::{
-    drain_pollers_and_shutdown, init_core_and_create_wf, start_timer_cmd, CoreWfStarter,
-    WorkerTestHelpers,
+    CoreWfStarter, WorkerTestHelpers, drain_pollers_and_shutdown, init_core_and_create_wf,
+    start_timer_cmd,
 };
 
 pub(crate) async fn timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
@@ -35,16 +35,19 @@ async fn timer_workflow_manual() {
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task.run_id,
-        vec![StartTimer {
-            seq: 0,
-            start_to_fire_timeout: Some(prost_dur!(from_secs(1))),
-        }
-        .into()],
+        vec![
+            StartTimer {
+                seq: 0,
+                start_to_fire_timeout: Some(prost_dur!(from_secs(1))),
+            }
+            .into(),
+        ],
     ))
     .await
     .unwrap();
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_execution(&task.run_id).await;
+    core.handle_eviction().await;
     drain_pollers_and_shutdown(&core).await;
 }
 

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

@@ -8,7 +8,9 @@ mod determinism;
 mod eager;
 mod local_activities;
 mod modify_wf_properties;
+mod nexus;
 mod patches;
+mod priority;
 mod replay;
 mod resets;
 mod signals;
@@ -18,32 +20,27 @@ mod upsert_search_attrs;
 
 use crate::integ_tests::{activity_functions::echo, metrics_tests};
 use assert_matches::assert_matches;
-use futures_channel::mpsc::UnboundedReceiver;
-use futures_util::{future, SinkExt, StreamExt};
 use std::{
     collections::{HashMap, HashSet},
-    sync::{
-        atomic::{AtomicUsize, Ordering},
-        Arc,
-    },
+    sync::atomic::{AtomicUsize, Ordering},
     time::Duration,
 };
-use temporal_client::{WorkflowClientTrait, WorkflowOptions};
-use temporal_sdk::{interceptors::WorkerInterceptor, ActivityOptions, WfContext, WorkflowResult};
-use temporal_sdk_core::{replay::HistoryForReplay, CoreRuntime};
-use temporal_sdk_core_api::{
-    errors::{PollWfError, WorkflowErrorType},
-    Worker,
+use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowExecutionResult, WorkflowOptions};
+use temporal_sdk::{
+    ActivityOptions, LocalActivityOptions, WfContext, WorkflowResult,
+    interceptors::WorkerInterceptor,
 };
+use temporal_sdk_core::{CoreRuntime, replay::HistoryForReplay};
+use temporal_sdk_core_api::errors::{PollError, WorkflowErrorType};
 use temporal_sdk_core_protos::{
     coresdk::{
+        ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion,
         activity_result::ActivityExecutionResult,
-        workflow_activation::{workflow_activation_job, WorkflowActivation, WorkflowActivationJob},
+        workflow_activation::{WorkflowActivationJob, workflow_activation_job},
         workflow_commands::{
             ActivityCancellationType, FailWorkflowExecution, QueryResult, QuerySuccess, StartTimer,
         },
         workflow_completion::WorkflowActivationCompletion,
-        ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion,
     },
     temporal::api::{
         enums::v1::EventType, failure::v1::Failure, history::v1::history_event,
@@ -51,68 +48,36 @@ use temporal_sdk_core_protos::{
     },
 };
 use temporal_sdk_core_test_utils::{
-    drain_pollers_and_shutdown, history_from_proto_binary, init_core_and_create_wf,
-    init_core_replay_preloaded, schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers,
+    CoreWfStarter, WorkerTestHelpers, drain_pollers_and_shutdown, history_from_proto_binary,
+    init_core_and_create_wf, init_core_replay_preloaded, schedule_activity_cmd,
 };
-use tokio::{join, time::sleep};
+use tokio::{join, sync::Notify, time::sleep};
 use uuid::Uuid;
-
 // TODO: We should get expected histories for these tests and confirm that the history at the end
 //  matches.
 
 #[tokio::test]
 async fn parallel_workflows_same_queue() {
-    let mut starter = CoreWfStarter::new("parallel_workflows_same_queue");
-    let core = starter.get_worker().await;
-    let num_workflows = 25usize;
-
-    let run_ids: Vec<_> = future::join_all(
-        (0..num_workflows).map(|i| starter.start_wf_with_id(format!("wf-id-{i}"))),
-    )
-    .await;
-
-    let mut send_chans = HashMap::new();
-    async fn wf_task(
-        worker: Arc<dyn Worker>,
-        mut task_chan: UnboundedReceiver<WorkflowActivation>,
-    ) {
-        let task = task_chan.next().await.unwrap();
-        assert_matches!(
-            task.jobs.as_slice(),
-            [WorkflowActivationJob {
-                variant: Some(workflow_activation_job::Variant::InitializeWorkflow(_)),
-            }]
-        );
-        worker
-            .complete_timer(&task.run_id, 1, Duration::from_secs(1))
-            .await;
-        let task = task_chan.next().await.unwrap();
-        worker.complete_execution(&task.run_id).await;
-    }
-
-    let handles: Vec<_> = run_ids
-        .iter()
-        .map(|run_id| {
-            let (tx, rx) = futures_channel::mpsc::unbounded();
-            send_chans.insert(run_id.clone(), tx);
-            tokio::spawn(wf_task(core.clone(), rx))
-        })
-        .collect();
-
-    for _ in 0..num_workflows * 2 {
-        let task = core.poll_workflow_activation().await.unwrap();
-        send_chans
-            .get(&task.run_id)
-            .unwrap()
-            .send(task)
-            .await
-            .unwrap();
-    }
+    let wf_name = "parallel_workflows_same_queue";
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter.worker_config.no_remote_activities(true);
+    let mut core = starter.worker().await;
 
-    for handle in handles {
-        handle.await.unwrap()
+    core.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
+        ctx.timer(Duration::from_secs(1)).await;
+        Ok(().into())
+    });
+    for i in 0..25 {
+        core.submit_wf(
+            format!("{}-{}", wf_name, i),
+            wf_name,
+            vec![],
+            starter.workflow_options.clone(),
+        )
+        .await
+        .unwrap();
     }
-    drain_pollers_and_shutdown(&core).await;
+    core.run_until_done().await.unwrap();
 }
 
 static RUN_CT: AtomicUsize = AtomicUsize::new(0);
@@ -180,14 +145,14 @@ async fn shutdown_aborts_actively_blocked_poll() {
     });
     assert_matches!(
         core.poll_workflow_activation().await.unwrap_err(),
-        PollWfError::ShutDown
+        PollError::ShutDown
     );
     handle.await.unwrap();
     // Ensure double-shutdown doesn't explode
     core.shutdown().await;
     assert_matches!(
         core.poll_workflow_activation().await.unwrap_err(),
-        PollWfError::ShutDown
+        PollError::ShutDown
     );
 }
 
@@ -230,26 +195,19 @@ async fn fail_wf_task(#[values(true, false)] replay: bool) {
 
     // The server will want to retry the task. This time we finish the workflow -- but we need
     // to poll a couple of times as there will be more than one required workflow activation.
-    let task = core.poll_workflow_activation().await.unwrap();
-    // The first poll response will tell us to evict
-    assert_matches!(
-        task.jobs.as_slice(),
-        [WorkflowActivationJob {
-            variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
-        }]
-    );
-    core.complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
-        .await
-        .unwrap();
+    // The first poll response will tell us to evict.
+    core.handle_eviction().await;
 
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task.run_id,
-        vec![StartTimer {
-            seq: 0,
-            start_to_fire_timeout: Some(prost_dur!(from_millis(200))),
-        }
-        .into()],
+        vec![
+            StartTimer {
+                seq: 0,
+                start_to_fire_timeout: Some(prost_dur!(from_millis(200))),
+            }
+            .into(),
+        ],
     ))
     .await
     .unwrap();
@@ -269,10 +227,12 @@ async fn fail_workflow_execution() {
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task.run_id,
-        vec![FailWorkflowExecution {
-            failure: Some(Failure::application_failure("I'm ded".to_string(), false)),
-        }
-        .into()],
+        vec![
+            FailWorkflowExecution {
+                failure: Some(Failure::application_failure("I'm ded".to_string(), false)),
+            }
+            .into(),
+        ],
     ))
     .await
     .unwrap();
@@ -369,11 +329,13 @@ async fn signal_workflow_signal_not_handled_on_workflow_completion() {
         // Task is completed with a timer
         core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
             res.run_id,
-            vec![StartTimer {
-                seq: 0,
-                start_to_fire_timeout: Some(prost_dur!(from_millis(10))),
-            }
-            .into()],
+            vec![
+                StartTimer {
+                    seq: 0,
+                    start_to_fire_timeout: Some(prost_dur!(from_millis(10))),
+                }
+                .into(),
+            ],
         ))
         .await
         .unwrap();
@@ -408,18 +370,8 @@ async fn signal_workflow_signal_not_handled_on_workflow_completion() {
             // Send completion - not having seen a poll response with a signal in it yet (unhandled
             // command error will be logged as a warning and an eviction will be issued)
             core.complete_execution(&run_id).await;
-
             // We should be told to evict
-            let res = core.poll_workflow_activation().await.unwrap();
-            assert_matches!(
-                res.jobs.as_slice(),
-                [WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
-                }]
-            );
-            core.complete_workflow_activation(WorkflowActivationCompletion::empty(res.run_id))
-                .await
-                .unwrap();
+            core.handle_eviction().await;
             // Loop to the top to handle wf from the beginning
             continue;
         }
@@ -515,16 +467,7 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
         .await
         .unwrap();
     // Now poll again, it will be an eviction b/c non-sticky mode.
-    let wf_task = core.poll_workflow_activation().await.unwrap();
-    assert_matches!(
-        wf_task.jobs.as_slice(),
-        [WorkflowActivationJob {
-            variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
-        }]
-    );
-    core.complete_workflow_activation(WorkflowActivationCompletion::empty(wf_task.run_id))
-        .await
-        .unwrap();
+    core.handle_eviction().await;
     // Start from the beginning
     poll_sched_act().await;
     let wf_task = core.poll_workflow_activation().await.unwrap();
@@ -753,7 +696,7 @@ async fn build_id_correct_in_wf_info() {
 async fn nondeterminism_errors_fail_workflow_when_configured_to(
     #[values(true, false)] whole_worker: bool,
 ) {
-    let (telemopts, addr, _aborter) = metrics_tests::prom_metrics(false, false);
+    let (telemopts, addr, _aborter) = metrics_tests::prom_metrics(None);
     let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
     let wf_name = "nondeterminism_errors_fail_workflow_when_configured_to";
     let mut starter = CoreWfStarter::new_with_runtime(wf_name, rt);
@@ -836,3 +779,96 @@ async fn nondeterminism_errors_fail_workflow_when_configured_to(
     );
     assert!(body.contains(&match_this));
 }
+
+#[tokio::test]
+async fn history_out_of_order_on_restart() {
+    let wf_name = "history_out_of_order_on_restart";
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter
+        .worker_config
+        .workflow_failure_errors([WorkflowErrorType::Nondeterminism]);
+    let mut worker = starter.worker().await;
+    let mut starter2 = starter.clone_no_worker();
+    let mut worker2 = starter2.worker().await;
+
+    static HIT_SLEEP: Notify = Notify::const_new();
+
+    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
+        ctx.local_activity(LocalActivityOptions {
+            activity_type: "echo".to_owned(),
+            input: "hi".as_json_payload().unwrap(),
+            start_to_close_timeout: Some(Duration::from_secs(5)),
+            ..Default::default()
+        })
+        .await;
+        ctx.activity(ActivityOptions {
+            activity_type: "echo".to_owned(),
+            input: "hi".as_json_payload().unwrap(),
+            start_to_close_timeout: Some(Duration::from_secs(5)),
+            ..Default::default()
+        })
+        .await;
+        // Interrupt this sleep on first go
+        HIT_SLEEP.notify_one();
+        ctx.timer(Duration::from_secs(5)).await;
+        Ok(().into())
+    });
+    worker.register_activity("echo", echo);
+
+    worker2.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
+        ctx.local_activity(LocalActivityOptions {
+            activity_type: "echo".to_owned(),
+            input: "hi".as_json_payload().unwrap(),
+            start_to_close_timeout: Some(Duration::from_secs(5)),
+            ..Default::default()
+        })
+        .await;
+        // Timer is added after restarting workflow
+        ctx.timer(Duration::from_secs(1)).await;
+        ctx.activity(ActivityOptions {
+            activity_type: "echo".to_owned(),
+            input: "hi".as_json_payload().unwrap(),
+            start_to_close_timeout: Some(Duration::from_secs(5)),
+            ..Default::default()
+        })
+        .await;
+        ctx.timer(Duration::from_secs(2)).await;
+        Ok(().into())
+    });
+    worker2.register_activity("echo", echo);
+    worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions {
+                execution_timeout: Some(Duration::from_secs(20)),
+                ..Default::default()
+            },
+        )
+        .await
+        .unwrap();
+
+    let w1 = async {
+        worker.run_until_done().await.unwrap();
+    };
+    let w2 = async {
+        // wait to hit sleep
+        HIT_SLEEP.notified().await;
+        starter.shutdown().await;
+        // start new worker
+        worker2.expect_workflow_completion(wf_name, None);
+        worker2.run_until_done().await.unwrap();
+    };
+    join!(w1, w2);
+    // The workflow should fail with the nondeterminism error
+    let handle = starter
+        .get_client()
+        .await
+        .get_untyped_workflow_handle(wf_name, "");
+    let res = handle
+        .get_workflow_result(Default::default())
+        .await
+        .unwrap();
+    assert_matches!(res, WorkflowExecutionResult::Failed(_));
+}