temporalio 0.0.1

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

@@ -0,0 +1,113 @@
+use std::{
+    sync::atomic::{AtomicBool, Ordering},
+    time::Duration,
+};
+use temporal_client::WorkflowOptions;
+use temporal_sdk::{WfContext, WorkflowResult};
+use temporal_sdk_core_test_utils::CoreWfStarter;
+
+const MY_PATCH_ID: &str = "integ_test_change_name";
+
+pub async fn changes_wf(ctx: WfContext) -> WorkflowResult<()> {
+    if ctx.patched(MY_PATCH_ID) {
+        ctx.timer(Duration::from_millis(100)).await;
+    } else {
+        ctx.timer(Duration::from_millis(200)).await;
+    }
+    ctx.timer(Duration::from_millis(200)).await;
+    if ctx.patched(MY_PATCH_ID) {
+        ctx.timer(Duration::from_millis(100)).await;
+    } else {
+        ctx.timer(Duration::from_millis(200)).await;
+    }
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn writes_change_markers() {
+    let wf_name = "writes_change_markers";
+    let mut starter = CoreWfStarter::new(wf_name);
+    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();
+    worker.run_until_done().await.unwrap();
+}
+
+/// This one simulates a run as if the worker had the "old" code, then it fails at the end as
+/// a cheapo way of being re-run, at which point it runs with change checks and the "new" code.
+static DID_DIE: AtomicBool = AtomicBool::new(false);
+pub async fn no_change_then_change_wf(ctx: WfContext) -> WorkflowResult<()> {
+    if DID_DIE.load(Ordering::Acquire) {
+        assert!(!ctx.patched(MY_PATCH_ID));
+    }
+    ctx.timer(Duration::from_millis(200)).await;
+    ctx.timer(Duration::from_millis(200)).await;
+    if DID_DIE.load(Ordering::Acquire) {
+        assert!(!ctx.patched(MY_PATCH_ID));
+    }
+    ctx.timer(Duration::from_millis(200)).await;
+
+    if !DID_DIE.load(Ordering::Acquire) {
+        DID_DIE.store(true, Ordering::Release);
+        ctx.force_task_fail(anyhow::anyhow!("i'm ded"));
+    }
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn can_add_change_markers() {
+    let wf_name = "can_add_change_markers";
+    let mut starter = CoreWfStarter::new(wf_name);
+    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();
+    worker.run_until_done().await.unwrap();
+}
+
+static DID_DIE_2: AtomicBool = AtomicBool::new(false);
+pub async fn replay_with_change_marker_wf(ctx: WfContext) -> WorkflowResult<()> {
+    assert!(ctx.patched(MY_PATCH_ID));
+    ctx.timer(Duration::from_millis(200)).await;
+    if !DID_DIE_2.load(Ordering::Acquire) {
+        DID_DIE_2.store(true, Ordering::Release);
+        ctx.force_task_fail(anyhow::anyhow!("i'm ded"));
+    }
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn replaying_with_patch_marker() {
+    let wf_name = "replaying_with_patch_marker";
+    let mut starter = CoreWfStarter::new(wf_name);
+    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();
+    worker.run_until_done().await.unwrap();
+}

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

@@ -0,0 +1,137 @@
+use assert_matches::assert_matches;
+use std::time::Duration;
+use temporal_sdk::{WfContext, Worker, WorkflowFunction};
+use temporal_sdk_core_api::errors::{PollActivityError, PollWfError};
+use temporal_sdk_core_protos::{
+    coresdk::{
+        workflow_activation::remove_from_cache::EvictionReason,
+        workflow_commands::{ScheduleActivity, StartTimer},
+        workflow_completion::WorkflowActivationCompletion,
+    },
+    DEFAULT_WORKFLOW_TYPE,
+};
+use temporal_sdk_core_test_utils::{
+    canned_histories, history_from_proto_binary, init_core_replay_preloaded, WorkerTestHelpers,
+};
+use tokio::join;
+
+#[tokio::test]
+async fn timer_workflow_replay() {
+    let (core, _) = init_core_replay_preloaded(
+        "timer_workflow_replay",
+        &history_from_proto_binary("histories/timer_workflow_history.bin")
+            .await
+            .unwrap(),
+    );
+    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()],
+    ))
+    .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)
+        );
+    };
+    let poll_fut = async {
+        assert_matches!(
+            core.poll_workflow_activation().await,
+            Err(PollWfError::ShutDown)
+        );
+    };
+    let complete_fut = async {
+        core.complete_execution(&task.run_id).await;
+    };
+    join!(act_poll_fut, poll_fut, complete_fut);
+
+    // Subsequent polls should still return shutdown
+    assert_matches!(
+        core.poll_workflow_activation().await,
+        Err(PollWfError::ShutDown)
+    );
+
+    core.shutdown().await;
+}
+
+#[tokio::test]
+async fn workflow_nondeterministic_replay() {
+    let (core, _) = init_core_replay_preloaded(
+        "timer_workflow_replay",
+        &history_from_proto_binary("histories/timer_workflow_history.bin")
+            .await
+            .unwrap(),
+    );
+    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()],
+    ))
+    .await
+    .unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
+    assert_eq!(task.eviction_reason(), Some(EvictionReason::Nondeterminism));
+    // Complete eviction
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
+        .await
+        .unwrap();
+    // Call shutdown explicitly because we saw a nondeterminism eviction
+    core.shutdown().await;
+    assert_matches!(
+        core.poll_workflow_activation().await,
+        Err(PollWfError::ShutDown)
+    );
+}
+
+#[tokio::test]
+async fn replay_using_wf_function() {
+    let num_timers = 10;
+    let t = canned_histories::long_sequential_timers(num_timers as usize);
+    let func = timers_wf(num_timers);
+    let (worker, _) =
+        init_core_replay_preloaded("replay_bench", &t.get_full_history_info().unwrap().into());
+    let mut worker = Worker::new_from_core(worker, "replay_bench".to_string());
+    worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
+    worker.run().await.unwrap();
+}
+
+#[tokio::test]
+async fn replay_ok_ending_with_terminated_or_timed_out() {
+    let mut t1 = canned_histories::single_timer("1");
+    t1.add_workflow_execution_terminated();
+    let mut t2 = canned_histories::single_timer("1");
+    t2.add_workflow_execution_timed_out();
+    for t in [t1, t2] {
+        let func = timers_wf(1);
+        let (worker, _) = init_core_replay_preloaded(
+            "replay_ok_terminate",
+            &t.get_full_history_info().unwrap().into(),
+        );
+        let mut worker = Worker::new_from_core(worker, "replay_ok_terminate".to_string());
+        worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
+        worker.run().await.unwrap();
+    }
+}
+
+fn timers_wf(num_timers: u32) -> WorkflowFunction {
+    WorkflowFunction::new(move |ctx: WfContext| async move {
+        for _ in 1..=num_timers {
+            ctx.timer(Duration::from_secs(1)).await;
+        }
+        Ok(().into())
+    })
+}

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

@@ -0,0 +1,93 @@
+use futures::StreamExt;
+use std::{sync::Arc, time::Duration};
+use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions, WorkflowService};
+use temporal_sdk::WfContext;
+use temporal_sdk_core_protos::temporal::api::{
+    common::v1::WorkflowExecution, workflowservice::v1::ResetWorkflowExecutionRequest,
+};
+use temporal_sdk_core_test_utils::{CoreWfStarter, NAMESPACE};
+use tokio::sync::Notify;
+
+const POST_RESET_SIG: &str = "post-reset";
+
+#[tokio::test]
+async fn reset_workflow() {
+    let wf_name = "reset_me_wf";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+    worker.fetch_results = false;
+    let notify = Arc::new(Notify::new());
+
+    let wf_notify = notify.clone();
+    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| {
+        let notify = wf_notify.clone();
+        async move {
+            // Make a couple workflow tasks
+            ctx.timer(Duration::from_secs(1)).await;
+            ctx.timer(Duration::from_secs(1)).await;
+            // Tell outer scope to send the reset
+            notify.notify_one();
+            let _ = ctx
+                .make_signal_channel(POST_RESET_SIG)
+                .next()
+                .await
+                .unwrap();
+            Ok(().into())
+        }
+    });
+
+    let run_id = worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+
+    let mut client = starter.get_client().await;
+    let client = Arc::make_mut(&mut client);
+    let resetter_fut = async {
+        notify.notified().await;
+        // Do the reset
+        client
+            .reset_workflow_execution(ResetWorkflowExecutionRequest {
+                namespace: NAMESPACE.to_owned(),
+                workflow_execution: Some(WorkflowExecution {
+                    workflow_id: wf_name.to_owned(),
+                    run_id: run_id.clone(),
+                }),
+                // End of first WFT
+                workflow_task_finish_event_id: 4,
+                request_id: "test-req-id".to_owned(),
+                ..Default::default()
+            })
+            .await
+            .unwrap();
+
+        // Unblock the workflow by sending the signal. Run ID will have changed after reset so
+        // we use empty run id
+        WorkflowClientTrait::signal_workflow_execution(
+            client,
+            wf_name.to_owned(),
+            "".to_owned(),
+            POST_RESET_SIG.to_owned(),
+            None,
+            None,
+        )
+        .await
+        .unwrap();
+
+        // Wait for the now-reset workflow to finish
+        client
+            .get_untyped_workflow_handle(wf_name.to_owned(), "")
+            .get_workflow_result(Default::default())
+            .await
+            .unwrap();
+        starter.shutdown().await;
+    };
+    let run_fut = worker.run_until_done();
+    let (_, rr) = tokio::join!(resetter_fut, run_fut);
+    rr.unwrap();
+}

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

@@ -0,0 +1,167 @@
+use std::collections::HashMap;
+
+use futures::StreamExt;
+use temporal_client::{WorkflowClientTrait, WorkflowExecutionInfo, WorkflowOptions};
+use temporal_sdk::{
+    ChildWorkflowOptions, Signal, SignalWorkflowOptions, WfContext, WorkflowResult,
+};
+use temporal_sdk_core_protos::{coresdk::IntoPayloadsExt, temporal::api::common::v1::Payload};
+use temporal_sdk_core_test_utils::CoreWfStarter;
+use uuid::Uuid;
+
+const SIGNAME: &str = "signame";
+const RECEIVER_WFID: &str = "sends-signal-signal-receiver";
+
+async fn signal_sender(ctx: WfContext) -> WorkflowResult<()> {
+    let run_id = std::str::from_utf8(&ctx.get_args()[0].data)
+        .unwrap()
+        .to_owned();
+    let mut dat = SignalWorkflowOptions::new(RECEIVER_WFID, run_id, SIGNAME, [b"hi!"]);
+    dat.with_header("tupac", b"shakur");
+    let sigres = ctx.signal_workflow(dat).await;
+    if ctx.get_args().get(1).is_some() {
+        // We expect failure
+        assert!(sigres.is_err());
+    } else {
+        sigres.unwrap();
+    }
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn sends_signal_to_missing_wf() {
+    let wf_name = "sends_signal_to_missing_wf";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+    worker.register_wf(wf_name.to_owned(), signal_sender);
+
+    worker
+        .submit_wf(
+            wf_name,
+            wf_name,
+            vec![Uuid::new_v4().to_string().into(), [1].into()],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}
+
+async fn signal_receiver(ctx: WfContext) -> WorkflowResult<()> {
+    let res = ctx.make_signal_channel(SIGNAME).next().await.unwrap();
+    assert_eq!(&res.input, &[b"hi!".into()]);
+    assert_eq!(
+        *res.headers.get("tupac").expect("tupac header exists"),
+        b"shakur".into()
+    );
+    Ok(().into())
+}
+
+async fn signal_with_create_wf_receiver(ctx: WfContext) -> WorkflowResult<()> {
+    let res = ctx.make_signal_channel(SIGNAME).next().await.unwrap();
+    println!("HEADER: {:?}", res.headers);
+    assert_eq!(&res.input, &[b"tada".into()]);
+    assert_eq!(
+        *res.headers.get("tupac").expect("tupac header exists"),
+        b"shakur".into()
+    );
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn sends_signal_to_other_wf() {
+    let mut starter = CoreWfStarter::new("sends_signal_to_other_wf");
+    let mut worker = starter.worker().await;
+    worker.register_wf("sender", signal_sender);
+    worker.register_wf("receiver", signal_receiver);
+
+    let receiver_run_id = worker
+        .submit_wf(
+            RECEIVER_WFID,
+            "receiver",
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker
+        .submit_wf(
+            "sends-signal-sender",
+            "sender",
+            vec![receiver_run_id.into()],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}
+
+#[tokio::test]
+async fn sends_signal_with_create_wf() {
+    let mut starter = CoreWfStarter::new("sends_signal_with_create_wf");
+    let mut worker = starter.worker().await;
+    worker.register_wf("receiversignal", signal_with_create_wf_receiver);
+
+    let client = starter.get_client().await;
+    let mut header: HashMap<String, Payload> = HashMap::new();
+    header.insert("tupac".into(), "shakur".into());
+    let res = client
+        .signal_with_start_workflow_execution(
+            None,
+            worker.inner_mut().task_queue().to_owned(),
+            "sends_signal_with_create_wf".to_owned(),
+            "receiversignal".to_owned(),
+            None,
+            WorkflowOptions::default(),
+            SIGNAME.to_owned(),
+            vec![b"tada".into()].into_payloads(),
+            Some(header.into()),
+        )
+        .await
+        .expect("request succeeds.qed");
+
+    worker.started_workflows.lock().push(WorkflowExecutionInfo {
+        namespace: client.namespace().to_string(),
+        workflow_id: "sends_signal_with_create_wf".to_owned(),
+        run_id: Some(res.run_id.clone()),
+    });
+
+    worker.run_until_done().await.unwrap();
+}
+
+async fn signals_child(ctx: WfContext) -> WorkflowResult<()> {
+    let started_child = ctx
+        .child_workflow(ChildWorkflowOptions {
+            workflow_id: "my_precious_child".to_string(),
+            workflow_type: "child_receiver".to_string(),
+            ..Default::default()
+        })
+        .start(&ctx)
+        .await
+        .into_started()
+        .expect("Must start ok");
+    let mut sig = Signal::new(SIGNAME, [b"hi!"]);
+    sig.data.with_header("tupac", b"shakur");
+    started_child.signal(&ctx, sig).await.unwrap();
+    started_child.result().await.status.unwrap();
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn sends_signal_to_child() {
+    let mut starter = CoreWfStarter::new("sends_signal_to_child");
+    let mut worker = starter.worker().await;
+    worker.register_wf("child_signaler", signals_child);
+    worker.register_wf("child_receiver", signal_receiver);
+
+    worker
+        .submit_wf(
+            "sends-signal-to-child",
+            "child_signaler",
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}

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

@@ -0,0 +1,99 @@
+use crate::integ_tests::workflow_tests::timers::timer_wf;
+use std::{
+    sync::atomic::{AtomicBool, AtomicUsize, Ordering},
+    time::Duration,
+};
+use temporal_client::WorkflowOptions;
+use temporal_sdk::{WfContext, WorkflowResult};
+use temporal_sdk_core_test_utils::CoreWfStarter;
+use tokio::sync::Barrier;
+
+#[tokio::test]
+async fn timer_workflow_not_sticky() {
+    let wf_name = "timer_wf_not_sticky";
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter.max_cached_workflows(0);
+    let mut worker = starter.worker().await;
+    worker.register_wf(wf_name.to_owned(), timer_wf);
+
+    worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}
+
+static TIMED_OUT_ONCE: AtomicBool = AtomicBool::new(false);
+static RUN_CT: AtomicUsize = AtomicUsize::new(0);
+async fn timer_timeout_wf(ctx: WfContext) -> WorkflowResult<()> {
+    RUN_CT.fetch_add(1, Ordering::SeqCst);
+    let t = ctx.timer(Duration::from_secs(1));
+    if !TIMED_OUT_ONCE.load(Ordering::SeqCst) {
+        ctx.force_task_fail(anyhow::anyhow!("I AM SLAIN!"));
+        TIMED_OUT_ONCE.store(true, Ordering::SeqCst);
+    }
+    t.await;
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn timer_workflow_timeout_on_sticky() {
+    // This test intentionally times out a workflow task in order to make the next task be scheduled
+    // on a not-sticky queue
+    let wf_name = "timer_workflow_timeout_on_sticky";
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter.wft_timeout(Duration::from_secs(2));
+    let mut worker = starter.worker().await;
+    worker.register_wf(wf_name.to_owned(), timer_timeout_wf);
+
+    worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+    // If it didn't run twice it didn't time out
+    assert_eq!(RUN_CT.load(Ordering::SeqCst), 2);
+}
+
+#[tokio::test]
+async fn cache_miss_ok() {
+    let wf_name = "cache_miss_ok";
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter.max_wft(1);
+    let mut worker = starter.worker().await;
+
+    let barr: &'static Barrier = Box::leak(Box::new(Barrier::new(2)));
+    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| async move {
+        barr.wait().await;
+        ctx.timer(Duration::from_secs(1)).await;
+        Ok(().into())
+    });
+
+    let run_id = worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    let core = starter.get_worker().await;
+    let (r1, _) = tokio::join!(worker.run_until_done(), async move {
+        barr.wait().await;
+        core.request_workflow_eviction(&run_id);
+        // We need to signal the barrier again since the wf gets evicted and will hit it again
+        barr.wait().await;
+    });
+    r1.unwrap();
+}