temporalio 0.0.1 → 0.1.0

data/bridge/sdk-core/tests/integ_tests/workflow_tests/local_activities.rs

@@ -1,19 +1,28 @@
 use anyhow::anyhow;
 use futures::future::join_all;
-use std::time::Duration;
+use std::{
+    sync::atomic::{AtomicU8, Ordering},
+    time::Duration,
+};
 use temporal_client::WorkflowOptions;
 use temporal_sdk::{
     interceptors::WorkerInterceptor, ActContext, ActivityCancelledError, CancellableFuture,
     LocalActivityOptions, WfContext, WorkflowResult,
 };
+use temporal_sdk_core::replay::HistoryForReplay;
 use temporal_sdk_core_protos::{
     coresdk::{
-        workflow_commands::ActivityCancellationType,
+        workflow_commands::workflow_command::Variant, workflow_commands::ActivityCancellationType,
+        workflow_completion, workflow_completion::workflow_activation_completion,
         workflow_completion::WorkflowActivationCompletion, AsJsonPayloadExt,
     },
-    temporal::api::common::v1::RetryPolicy,
+    temporal::api::{common::v1::RetryPolicy, enums::v1::TimeoutType},
+    TestHistoryBuilder,
+};
+use temporal_sdk_core_test_utils::{
+    history_from_proto_binary, init_integ_telem, replay_sdk_worker, workflows::la_problem_workflow,
+    CoreWfStarter,
 };
-use temporal_sdk_core_test_utils::CoreWfStarter;
 use tokio_util::sync::CancellationToken;
 
 pub async fn echo(_ctx: ActContext, e: String) -> anyhow::Result<String> {
@@ -41,15 +50,7 @@ async fn one_local_activity() {
     worker.register_wf(wf_name.to_owned(), one_local_activity_wf);
     worker.register_activity("echo_activity", echo);
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }
 
@@ -72,15 +73,7 @@ async fn local_act_concurrent_with_timer() {
     worker.register_wf(wf_name.to_owned(), local_act_concurrent_with_timer_wf);
     worker.register_activity("echo_activity", echo);
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }
 
@@ -104,15 +97,7 @@ async fn local_act_then_timer_then_wait_result() {
     worker.register_wf(wf_name.to_owned(), local_act_then_timer_then_wait);
     worker.register_activity("echo_activity", echo);
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }
 
@@ -120,7 +105,7 @@ async fn local_act_then_timer_then_wait_result() {
 async fn long_running_local_act_with_timer() {
     let wf_name = "long_running_local_act_with_timer";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.wft_timeout(Duration::from_secs(1));
+    starter.workflow_options.task_timeout = Some(Duration::from_secs(1));
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), local_act_then_timer_then_wait);
     worker.register_activity("echo_activity", |_ctx: ActContext, str: String| async {
@@ -128,15 +113,7 @@ async fn long_running_local_act_with_timer() {
         Ok(str)
     });
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }
 
@@ -145,7 +122,7 @@ pub async fn local_act_fanout_wf(ctx: WfContext) -> WorkflowResult<()> {
         .map(|i| {
             ctx.local_activity(LocalActivityOptions {
                 activity_type: "echo_activity".to_string(),
-                input: format!("Hi {}", i)
+                input: format!("Hi {i}")
                     .as_json_payload()
                     .expect("serializes fine"),
                 ..Default::default()
@@ -166,15 +143,7 @@ async fn local_act_fanout() {
     worker.register_wf(wf_name.to_owned(), local_act_fanout_wf);
     worker.register_activity("echo_activity", echo);
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }
 
@@ -229,7 +198,7 @@ async fn local_act_retry_timer_backoff() {
 #[case::abandon(ActivityCancellationType::Abandon)]
 #[tokio::test]
 async fn cancel_immediate(#[case] cancel_type: ActivityCancellationType) {
-    let wf_name = format!("cancel_immediate_{:?}", cancel_type);
+    let wf_name = format!("cancel_immediate_{cancel_type:?}");
     let mut starter = CoreWfStarter::new(&wf_name);
     let mut worker = starter.worker().await;
     worker.register_wf(&wf_name, move |ctx: WfContext| async move {
@@ -263,17 +232,10 @@ async fn cancel_immediate(#[case] cancel_type: ActivityCancellationType) {
         }
     });
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker
         .run_until_done_intercepted(Some(LACancellerInterceptor {
+            cancel_on_workflow_completed: false,
             token: manual_cancel,
         }))
         .await
@@ -282,12 +244,29 @@ async fn cancel_immediate(#[case] cancel_type: ActivityCancellationType) {
 
 struct LACancellerInterceptor {
     token: CancellationToken,
+    cancel_on_workflow_completed: bool,
 }
 #[async_trait::async_trait(?Send)]
 impl WorkerInterceptor for LACancellerInterceptor {
-    async fn on_workflow_activation_completion(&self, _: &WorkflowActivationCompletion) {}
+    async fn on_workflow_activation_completion(&self, completion: &WorkflowActivationCompletion) {
+        if !self.cancel_on_workflow_completed {
+            return;
+        }
+        if let Some(workflow_activation_completion::Status::Successful(
+            workflow_completion::Success { commands, .. },
+        )) = completion.status.as_ref()
+        {
+            if let Some(&Variant::CompleteWorkflowExecution(_)) =
+                commands.last().and_then(|v| v.variant.as_ref())
+            {
+                self.token.cancel();
+            }
+        }
+    }
     fn on_shutdown(&self, _: &temporal_sdk::Worker) {
-        self.token.cancel()
+        if !self.cancel_on_workflow_completed {
+            self.token.cancel()
+        }
     }
 }
 
@@ -305,12 +284,9 @@ async fn cancel_after_act_starts(
     )]
     cancel_type: ActivityCancellationType,
 ) {
-    let wf_name = format!(
-        "cancel_after_act_starts_timer_{:?}_{:?}",
-        cancel_on_backoff, cancel_type
-    );
+    let wf_name = format!("cancel_after_act_starts_{cancel_on_backoff:?}_{cancel_type:?}");
     let mut starter = CoreWfStarter::new(&wf_name);
-    starter.wft_timeout(Duration::from_secs(1));
+    starter.workflow_options.task_timeout = Some(Duration::from_secs(1));
     let mut worker = starter.worker().await;
     let bo_dur = cancel_on_backoff.unwrap_or_else(|| Duration::from_secs(1));
     worker.register_wf(&wf_name, move |ctx: WfContext| async move {
@@ -370,21 +346,17 @@ async fn cancel_after_act_starts(
         }
     });
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(&wf_name, &mut worker).await;
     worker
         .run_until_done_intercepted(Some(LACancellerInterceptor {
             token: manual_cancel,
+            // Only needed for this one case since the activity is not drained and prevents worker from shutting down.
+            cancel_on_workflow_completed: matches!(cancel_type, ActivityCancellationType::Abandon)
+                && cancel_on_backoff.is_none(),
         }))
         .await
         .unwrap();
+    starter.shutdown().await;
 }
 
 #[rstest::rstest]
@@ -403,6 +375,11 @@ async fn x_to_close_timeout(#[case] is_schedule: bool) {
     } else {
         (None, Some(Duration::from_secs(2)))
     };
+    let timeout_type = if is_schedule {
+        TimeoutType::ScheduleToClose
+    } else {
+        TimeoutType::StartToClose
+    };
 
     worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| async move {
         let res = ctx
@@ -422,7 +399,7 @@ async fn x_to_close_timeout(#[case] is_schedule: bool) {
                 ..Default::default()
             })
             .await;
-        assert!(res.timed_out());
+        assert_eq!(res.timed_out(), Some(timeout_type));
         Ok(().into())
     });
     worker.register_activity("echo", |ctx: ActContext, _: String| async move {
@@ -435,15 +412,7 @@ async fn x_to_close_timeout(#[case] is_schedule: bool) {
         Ok(())
     });
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }
 
@@ -467,43 +436,37 @@ async fn schedule_to_close_timeout_across_timer_backoff(#[case] cached: bool) {
                 activity_type: "echo".to_string(),
                 input: "hi".as_json_payload().expect("serializes fine"),
                 retry_policy: RetryPolicy {
-                    initial_interval: Some(prost_dur!(from_micros(15))),
+                    initial_interval: Some(prost_dur!(from_millis(15))),
                     backoff_coefficient: 1_000.,
-                    maximum_interval: Some(prost_dur!(from_millis(1500))),
+                    maximum_interval: Some(prost_dur!(from_millis(1000))),
                     maximum_attempts: 40,
                     non_retryable_error_types: vec![],
                 },
-                timer_backoff_threshold: Some(Duration::from_secs(1)),
-                schedule_to_close_timeout: Some(Duration::from_secs(3)),
+                timer_backoff_threshold: Some(Duration::from_millis(500)),
+                schedule_to_close_timeout: Some(Duration::from_secs(2)),
                 ..Default::default()
             })
             .await;
-        assert!(res.timed_out());
+        assert_eq!(res.timed_out(), Some(TimeoutType::ScheduleToClose));
         Ok(().into())
     });
-    worker.register_activity("echo", |_: ActContext, _: String| async {
+    let num_attempts: &'static _ = Box::leak(Box::new(AtomicU8::new(0)));
+    worker.register_activity("echo", move |_: ActContext, _: String| async {
+        num_attempts.fetch_add(1, Ordering::Relaxed);
         Result::<(), _>::Err(anyhow!("Oh no I failed!"))
     });
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
+    // 3 attempts b/c first backoff is very small, then the next 2 attempts take at least 2 seconds
+    // b/c of timer backoff.
+    assert_eq!(3, num_attempts.load(Ordering::Relaxed));
 }
 
 #[rstest::rstest]
 #[tokio::test]
 async fn eviction_wont_make_local_act_get_dropped(#[values(true, false)] short_wft_timeout: bool) {
-    let wf_name = format!(
-        "eviction_wont_make_local_act_get_dropped_{}",
-        short_wft_timeout
-    );
+    let wf_name = format!("eviction_wont_make_local_act_get_dropped_{short_wft_timeout}");
     let mut starter = CoreWfStarter::new(&wf_name);
     starter.max_cached_workflows(0);
     let mut worker = starter.worker().await;
@@ -569,15 +532,7 @@ async fn timer_backoff_concurrent_with_non_timer_backoff() {
         Result::<(), _>::Err(anyhow!("Oh no I failed!"))
     });
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }
 
@@ -608,7 +563,7 @@ async fn repro_nondeterminism_with_timer_bug() {
             _ = r1 => {
                 t1.cancel(&ctx);
             },
-        };
+        }
         ctx.timer(Duration::from_secs(1)).await;
         Ok(().into())
     });
@@ -632,3 +587,83 @@ async fn repro_nondeterminism_with_timer_bug() {
         .await
         .unwrap();
 }
+
+#[rstest::rstest]
+#[tokio::test]
+async fn weird_la_nondeterminism_repro(#[values(true, false)] fix_hist: bool) {
+    init_integ_telem();
+    let mut hist = history_from_proto_binary(
+        "histories/evict_while_la_running_no_interference-85_history.bin",
+    )
+    .await
+    .unwrap();
+    if fix_hist {
+        // Replace broken ending with accurate ending
+        hist.events.truncate(20);
+        let mut thb = TestHistoryBuilder::from_history(hist.events);
+        thb.add_workflow_task_completed();
+        thb.add_workflow_execution_completed();
+        hist = thb.get_full_history_info().unwrap().into();
+    }
+
+    let mut worker = replay_sdk_worker([HistoryForReplay::new(hist, "fake".to_owned())]);
+    worker.register_wf(
+        "evict_while_la_running_no_interference",
+        la_problem_workflow,
+    );
+    worker.register_activity("delay", |_: ActContext, _: String| async {
+        tokio::time::sleep(Duration::from_secs(15)).await;
+        Ok(())
+    });
+    worker.run().await.unwrap();
+}
+
+#[tokio::test]
+async fn second_weird_la_nondeterminism_repro() {
+    init_integ_telem();
+    let mut hist = history_from_proto_binary(
+        "histories/evict_while_la_running_no_interference-23_history.bin",
+    )
+    .await
+    .unwrap();
+    // Chop off uninteresting ending
+    hist.events.truncate(24);
+    let mut thb = TestHistoryBuilder::from_history(hist.events);
+    thb.add_workflow_execution_completed();
+    hist = thb.get_full_history_info().unwrap().into();
+
+    let mut worker = replay_sdk_worker([HistoryForReplay::new(hist, "fake".to_owned())]);
+    worker.register_wf(
+        "evict_while_la_running_no_interference",
+        la_problem_workflow,
+    );
+    worker.register_activity("delay", |_: ActContext, _: String| async {
+        tokio::time::sleep(Duration::from_secs(15)).await;
+        Ok(())
+    });
+    worker.run().await.unwrap();
+}
+
+#[tokio::test]
+async fn third_weird_la_nondeterminism_repro() {
+    init_integ_telem();
+    let mut hist = history_from_proto_binary(
+        "histories/evict_while_la_running_no_interference-16_history.bin",
+    )
+    .await
+    .unwrap();
+    let mut thb = TestHistoryBuilder::from_history(hist.events);
+    thb.add_workflow_task_scheduled_and_started();
+    hist = thb.get_full_history_info().unwrap().into();
+
+    let mut worker = replay_sdk_worker([HistoryForReplay::new(hist, "fake".to_owned())]);
+    worker.register_wf(
+        "evict_while_la_running_no_interference",
+        la_problem_workflow,
+    );
+    worker.register_activity("delay", |_: ActContext, _: String| async {
+        tokio::time::sleep(Duration::from_secs(15)).await;
+        Ok(())
+    });
+    worker.run().await.unwrap();
+}

data/bridge/sdk-core/tests/integ_tests/workflow_tests/modify_wf_properties.rs

@@ -0,0 +1,54 @@
+use temporal_client::WorkflowClientTrait;
+use temporal_sdk::{WfContext, WorkflowResult};
+use temporal_sdk_core_protos::coresdk::{AsJsonPayloadExt, FromJsonPayloadExt};
+use temporal_sdk_core_test_utils::CoreWfStarter;
+use uuid::Uuid;
+
+static FIELD_A: &str = "cat_name";
+static FIELD_B: &str = "cute_level";
+
+async fn memo_upserter(ctx: WfContext) -> WorkflowResult<()> {
+    ctx.upsert_memo([
+        (FIELD_A.to_string(), "enchi".as_json_payload().unwrap()),
+        (FIELD_B.to_string(), 9001.as_json_payload().unwrap()),
+    ]);
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn sends_modify_wf_props() {
+    let wf_name = "can_upsert_memo";
+    let wf_id = Uuid::new_v4();
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
+    let mut worker = starter.worker().await;
+
+    worker.register_wf(wf_name, memo_upserter);
+    let run_id = worker
+        .submit_wf(wf_id.to_string(), wf_name, vec![], Default::default())
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+
+    let memo = starter
+        .get_client()
+        .await
+        .describe_workflow_execution(wf_id.to_string(), Some(run_id))
+        .await
+        .unwrap()
+        .workflow_execution_info
+        .unwrap()
+        .memo
+        .unwrap()
+        .fields;
+    let catname = memo.get(FIELD_A).unwrap();
+    let cuteness = memo.get(FIELD_B).unwrap();
+    for payload in [catname, cuteness] {
+        assert_eq!(
+            &b"json/plain".to_vec(),
+            payload.metadata.get("encoding").unwrap()
+        );
+    }
+    assert_eq!("enchi", String::from_json_payload(catname).unwrap());
+    assert_eq!(9001, usize::from_json_payload(cuteness).unwrap());
+}

data/bridge/sdk-core/tests/integ_tests/workflow_tests/patches.rs

@@ -2,7 +2,7 @@ use std::{
     sync::atomic::{AtomicBool, Ordering},
     time::Duration,
 };
-use temporal_client::WorkflowOptions;
+
 use temporal_sdk::{WfContext, WorkflowResult};
 use temporal_sdk_core_test_utils::CoreWfStarter;
 
@@ -27,18 +27,11 @@ pub async fn changes_wf(ctx: WfContext) -> WorkflowResult<()> {
 async fn writes_change_markers() {
     let wf_name = "writes_change_markers";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), changes_wf);
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }
 
@@ -67,18 +60,11 @@ pub async fn no_change_then_change_wf(ctx: WfContext) -> WorkflowResult<()> {
 async fn can_add_change_markers() {
     let wf_name = "can_add_change_markers";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), no_change_then_change_wf);
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }
 
@@ -97,17 +83,10 @@ pub async fn replay_with_change_marker_wf(ctx: WfContext) -> WorkflowResult<()>
 async fn replaying_with_patch_marker() {
     let wf_name = "replaying_with_patch_marker";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), replay_with_change_marker_wf);
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }