@temporalio/core-bridge 1.11.8 → 1.12.0

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

@@ -0,0 +1,240 @@
+use crate::integ_tests::activity_functions::echo;
+use std::time::Duration;
+use temporal_client::{NamespacedClient, WorkflowOptions, WorkflowService};
+use temporal_sdk::{ActivityOptions, WfContext};
+use temporal_sdk_core_api::worker::{
+    WorkerDeploymentOptions, WorkerDeploymentVersion, WorkerVersioningStrategy,
+};
+use temporal_sdk_core_protos::{
+    coresdk::{
+        AsJsonPayloadExt, workflow_commands::CompleteWorkflowExecution, workflow_completion,
+        workflow_completion::WorkflowActivationCompletion,
+    },
+    temporal::api::{
+        enums::v1::VersioningBehavior,
+        history::v1::history_event::Attributes,
+        workflowservice::v1::{
+            DescribeWorkerDeploymentRequest, SetWorkerDeploymentCurrentVersionRequest,
+        },
+    },
+};
+use temporal_sdk_core_test_utils::{CoreWfStarter, WorkerTestHelpers, eventually};
+use tokio::join;
+
+#[rstest::rstest]
+#[tokio::test]
+async fn sets_deployment_info_on_task_responses(#[values(true, false)] use_default: bool) {
+    let wf_type = "sets_deployment_info_on_task_responses";
+    let mut starter = CoreWfStarter::new(wf_type);
+    let deploy_name = format!("deployment-{}", starter.get_task_queue());
+    let version = WorkerDeploymentVersion {
+        deployment_name: deploy_name.clone(),
+        build_id: "1.0".to_string(),
+    };
+    starter
+        .worker_config
+        .versioning_strategy(WorkerVersioningStrategy::WorkerDeploymentBased(
+            WorkerDeploymentOptions {
+                version: version.clone(),
+                use_worker_versioning: true,
+                default_versioning_behavior: VersioningBehavior::AutoUpgrade.into(),
+            },
+        ))
+        .no_remote_activities(true);
+    let core = starter.get_worker().await;
+    let client = starter.get_client().await;
+
+    // A bit annoying. We have to start up polling here so that the deployment will exist before
+    // we can describe it and then set the current version.
+    let worker_task = async {
+        let res = core.poll_workflow_activation().await.unwrap();
+        assert_eq!(
+            version,
+            res.deployment_version_for_current_task.unwrap().into(),
+        );
+
+        let mut success_complete = workflow_completion::Success::from_variants(vec![
+            CompleteWorkflowExecution { result: None }.into(),
+        ]);
+        if !use_default {
+            success_complete.versioning_behavior = VersioningBehavior::Pinned.into();
+        }
+        core.complete_workflow_activation(WorkflowActivationCompletion {
+            run_id: res.run_id.clone(),
+            status: Some(success_complete.into()),
+        })
+        .await
+        .unwrap();
+    };
+
+    let ops_task = async {
+        let desc_resp = eventually(
+            async || {
+                client
+                    .get_client()
+                    .clone()
+                    .describe_worker_deployment(DescribeWorkerDeploymentRequest {
+                        namespace: client.namespace().to_string(),
+                        deployment_name: deploy_name.clone(),
+                    })
+                    .await
+            },
+            Duration::from_secs(5),
+        )
+        .await
+        .unwrap()
+        .into_inner();
+
+        #[allow(deprecated)]
+        client
+            .get_client()
+            .clone()
+            .set_worker_deployment_current_version(SetWorkerDeploymentCurrentVersionRequest {
+                namespace: client.namespace().to_owned(),
+                deployment_name: deploy_name.clone(),
+                version: format!("{deploy_name}.1.0"),
+                conflict_token: desc_resp.conflict_token,
+                ..Default::default()
+            })
+            .await
+            .unwrap();
+
+        starter.start_wf().await;
+    };
+
+    join!(worker_task, ops_task);
+    core.handle_eviction().await;
+    core.shutdown().await;
+
+    // Fetch history & verify task complete is properly stamped
+    let history = starter.get_history().await;
+    let wft_complete = history
+        .events
+        .into_iter()
+        .find_map(|e| {
+            if let Attributes::WorkflowTaskCompletedEventAttributes(a) = e.attributes.unwrap() {
+                Some(a)
+            } else {
+                None
+            }
+        })
+        .unwrap();
+    if use_default {
+        assert_eq!(
+            wft_complete.versioning_behavior,
+            VersioningBehavior::AutoUpgrade as i32
+        );
+    } else {
+        assert_eq!(
+            wft_complete.versioning_behavior,
+            VersioningBehavior::Pinned as i32
+        );
+    }
+    assert_eq!(wft_complete.worker_deployment_name, deploy_name);
+    #[allow(deprecated)] // odd looking hack since can't put attr macro on macro
+    {
+        assert_eq!(
+            wft_complete.worker_deployment_version,
+            format!("{deploy_name}.1.0")
+        );
+    }
+}
+
+#[tokio::test]
+async fn activity_has_deployment_stamp() {
+    let wf_name = "activity_has_deployment_stamp";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let deploy_name = format!("deployment-{}", starter.get_task_queue());
+    starter
+        .worker_config
+        .versioning_strategy(WorkerVersioningStrategy::WorkerDeploymentBased(
+            WorkerDeploymentOptions {
+                version: WorkerDeploymentVersion {
+                    deployment_name: deploy_name.clone(),
+                    build_id: "1.0".to_string(),
+                },
+                use_worker_versioning: true,
+                default_versioning_behavior: VersioningBehavior::AutoUpgrade.into(),
+            },
+        ));
+    let mut worker = starter.worker().await;
+    let client = starter.get_client().await;
+    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
+        ctx.activity(ActivityOptions {
+            activity_type: "echo_activity".to_string(),
+            start_to_close_timeout: Some(Duration::from_secs(5)),
+            input: "hi!".as_json_payload().expect("serializes fine"),
+            ..Default::default()
+        })
+        .await;
+        Ok(().into())
+    });
+    worker.register_activity("echo_activity", echo);
+    let submitter = worker.get_submitter_handle();
+    let shutdown_handle = worker.inner_mut().shutdown_handle();
+
+    let client_task = async {
+        let desc_resp = eventually(
+            async || {
+                client
+                    .get_client()
+                    .clone()
+                    .describe_worker_deployment(DescribeWorkerDeploymentRequest {
+                        namespace: client.namespace().to_string(),
+                        deployment_name: deploy_name.clone(),
+                    })
+                    .await
+            },
+            Duration::from_secs(50),
+        )
+        .await
+        .unwrap()
+        .into_inner();
+
+        #[allow(deprecated)]
+        client
+            .get_client()
+            .clone()
+            .set_worker_deployment_current_version(SetWorkerDeploymentCurrentVersionRequest {
+                namespace: client.namespace().to_owned(),
+                deployment_name: deploy_name.clone(),
+                version: format!("{deploy_name}.1.0"),
+                conflict_token: desc_resp.conflict_token,
+                ..Default::default()
+            })
+            .await
+            .unwrap();
+
+        submitter
+            .submit_wf(
+                starter.get_wf_id(),
+                wf_name.to_owned(),
+                vec![],
+                WorkflowOptions::default(),
+            )
+            .await
+            .unwrap();
+        starter.wait_for_default_wf_finish().await.unwrap();
+        shutdown_handle();
+    };
+    join!(
+        async {
+            worker.inner_mut().run().await.unwrap();
+        },
+        client_task
+    );
+    let hist = starter.get_history().await;
+    let _activity_completed = hist
+        .events
+        .into_iter()
+        .find_map(|e| {
+            if let Attributes::ActivityTaskCompletedEventAttributes(a) = e.attributes.unwrap() {
+                Some(a)
+            } else {
+                None
+            }
+        })
+        .unwrap();
+    // TODO: Can't actually verify this at the moment as the deployment options are not transferred
+    //   to the event.
+}

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

@@ -1,9 +1,10 @@
 use std::{
-    sync::atomic::{AtomicUsize, Ordering},
+    sync::atomic::{AtomicBool, AtomicUsize, Ordering},
     time::Duration,
 };
-use temporal_sdk::{ActivityOptions, WfContext, WorkflowResult};
-use temporal_sdk_core_test_utils::CoreWfStarter;
+use temporal_sdk::{ActContext, ActivityOptions, WfContext, WorkflowResult};
+use temporal_sdk_core_protos::coresdk::AsJsonPayloadExt;
+use temporal_sdk_core_test_utils::{CoreWfStarter, WorkflowHandleExt};
 
 static RUN_CT: AtomicUsize = AtomicUsize::new(1);
 
@@ -45,3 +46,40 @@ async fn test_determinism_error_then_recovers() {
     // 4 because we still add on the 3rd and final attempt
     assert_eq!(RUN_CT.load(Ordering::Relaxed), 4);
 }
+
+#[tokio::test]
+async fn task_fail_causes_replay_unset_too_soon() {
+    let wf_name = "task_fail_causes_replay_unset_too_soon";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+
+    static DID_FAIL: AtomicBool = AtomicBool::new(false);
+    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| async move {
+        if DID_FAIL.load(Ordering::Relaxed) {
+            assert!(ctx.is_replaying());
+        }
+        ctx.activity(ActivityOptions {
+            activity_type: "echo".to_string(),
+            input: "hi!".as_json_payload().expect("serializes fine"),
+            start_to_close_timeout: Some(Duration::from_secs(2)),
+            ..Default::default()
+        })
+        .await;
+        if !DID_FAIL.load(Ordering::Relaxed) {
+            DID_FAIL.store(true, Ordering::Relaxed);
+            panic!("Die on purpose");
+        }
+        Ok(().into())
+    });
+    worker.register_activity("echo", |_ctx: ActContext, echo_me: String| async move {
+        Ok(echo_me)
+    });
+
+    let handle = starter.start_with_worker(wf_name, &mut worker).await;
+
+    worker.run_until_done().await.unwrap();
+    handle
+        .fetch_history_and_replay(worker.inner_mut())
+        .await
+        .unwrap();
+}

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

@@ -1,29 +1,38 @@
 use crate::integ_tests::activity_functions::echo;
 use anyhow::anyhow;
 use futures_util::future::join_all;
+use rstest::Context;
 use std::{
-    sync::atomic::{AtomicU8, Ordering},
+    sync::{
+        Arc,
+        atomic::{AtomicBool, AtomicU8, AtomicUsize, Ordering},
+    },
     time::Duration,
 };
-use temporal_client::{WfClientExt, WorkflowOptions};
+use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions};
 use temporal_sdk::{
-    ActContext, ActivityError, ActivityOptions, CancellableFuture, LocalActivityOptions, WfContext,
-    WorkflowResult, interceptors::WorkerInterceptor,
+    ActContext, ActivityError, ActivityOptions, CancellableFuture, LocalActivityOptions,
+    UpdateContext, WfContext, WorkflowResult,
+    interceptors::{FailOnNondeterminismInterceptor, WorkerInterceptor},
 };
 use temporal_sdk_core::replay::HistoryForReplay;
 use temporal_sdk_core_protos::{
     TestHistoryBuilder,
     coresdk::{
-        AsJsonPayloadExt,
+        AsJsonPayloadExt, IntoPayloadsExt,
         workflow_commands::{ActivityCancellationType, workflow_command::Variant},
         workflow_completion,
         workflow_completion::{WorkflowActivationCompletion, workflow_activation_completion},
     },
-    temporal::api::{common::v1::RetryPolicy, enums::v1::TimeoutType},
+    temporal::api::{
+        common::v1::RetryPolicy,
+        enums::v1::{TimeoutType, UpdateWorkflowExecutionLifecycleStage},
+        update::v1::WaitPolicy,
+    },
 };
 use temporal_sdk_core_test_utils::{
-    CoreWfStarter, WorkflowHandleExt, history_from_proto_binary, replay_sdk_worker,
-    workflows::la_problem_workflow,
+    CoreWfStarter, WorkflowHandleExt, history_from_proto_binary, init_core_replay_preloaded,
+    replay_sdk_worker, workflows::la_problem_workflow,
 };
 use tokio_util::sync::CancellationToken;
 
@@ -748,3 +757,154 @@ async fn la_resolve_same_time_as_other_cancel() {
         .await
         .unwrap();
 }
+
+#[rstest::rstest]
+#[case(200, 0)]
+#[case(200, 2000)]
+#[case(2000, 0)]
+#[case(2000, 2000)]
+#[tokio::test]
+async fn long_local_activity_with_update(
+    #[context] ctx: Context,
+    #[case] update_interval_ms: u64,
+    #[case] update_inner_timer: u64,
+) {
+    let wf_name = format!("{}-{}", ctx.name, ctx.case.unwrap());
+    let mut starter = CoreWfStarter::new(&wf_name);
+    starter.workflow_options.task_timeout = Some(Duration::from_secs(1));
+    let mut worker = starter.worker().await;
+    let client = starter.get_client().await;
+
+    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| async move {
+        let update_counter = Arc::new(AtomicUsize::new(1));
+        let uc = update_counter.clone();
+        ctx.update_handler(
+            "update",
+            |_: &_, _: ()| Ok(()),
+            move |u: UpdateContext, _: ()| {
+                let uc = uc.clone();
+                async move {
+                    if update_inner_timer != 0 {
+                        u.wf_ctx
+                            .timer(Duration::from_millis(update_inner_timer))
+                            .await;
+                    }
+                    uc.fetch_add(1, Ordering::Relaxed);
+                    Ok(())
+                }
+            },
+        );
+        ctx.local_activity(LocalActivityOptions {
+            activity_type: "delay".to_string(),
+            input: "hi".as_json_payload().expect("serializes fine"),
+            ..Default::default()
+        })
+        .await;
+        update_counter.load(Ordering::Relaxed);
+        Ok(().into())
+    });
+    worker.register_activity("delay", |_: ActContext, _: String| async {
+        tokio::time::sleep(Duration::from_secs(6)).await;
+        Ok(())
+    });
+
+    let handle = starter
+        .start_with_worker(wf_name.clone(), &mut worker)
+        .await;
+
+    let wf_id = starter.get_task_queue().to_string();
+    let update = async {
+        loop {
+            tokio::time::sleep(Duration::from_millis(update_interval_ms)).await;
+            let _ = client
+                .update_workflow_execution(
+                    wf_id.clone(),
+                    "".to_string(),
+                    "update".to_string(),
+                    WaitPolicy {
+                        lifecycle_stage: UpdateWorkflowExecutionLifecycleStage::Completed as i32,
+                    },
+                    [().as_json_payload().unwrap()].into_payloads(),
+                )
+                .await;
+        }
+    };
+    let runner = async {
+        worker.run_until_done().await.unwrap();
+    };
+    tokio::select!(_ = update => {}, _ = runner => {});
+    let res = handle
+        .get_workflow_result(Default::default())
+        .await
+        .unwrap()
+        .unwrap_success();
+    let replay_res = handle
+        .fetch_history_and_replay(worker.inner_mut())
+        .await
+        .unwrap();
+    assert_eq!(res[0], replay_res.unwrap());
+
+    // Load histories from pre-fix version and ensure compat
+    let replay_worker = init_core_replay_preloaded(
+        starter.get_task_queue(),
+        [HistoryForReplay::new(
+            history_from_proto_binary(&format!("histories/{wf_name}_history.bin"))
+                .await
+                .unwrap(),
+            "fake".to_owned(),
+        )],
+    );
+    let inner_worker = worker.inner_mut();
+    inner_worker.with_new_core_worker(replay_worker);
+    inner_worker.set_worker_interceptor(FailOnNondeterminismInterceptor {});
+    inner_worker.run().await.unwrap();
+}
+
+#[tokio::test]
+async fn local_activity_with_heartbeat_only_causes_one_wakeup() {
+    let wf_name = "local_activity_with_heartbeat_only_causes_one_wakeup";
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter.workflow_options.task_timeout = Some(Duration::from_secs(1));
+    let mut worker = starter.worker().await;
+
+    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| async move {
+        let mut wakeup_counter = 1;
+        let la_resolved = AtomicBool::new(false);
+        tokio::join!(
+            async {
+                ctx.local_activity(LocalActivityOptions {
+                    activity_type: "delay".to_string(),
+                    input: "hi".as_json_payload().expect("serializes fine"),
+                    ..Default::default()
+                })
+                .await;
+                la_resolved.store(true, Ordering::Relaxed);
+            },
+            async {
+                ctx.wait_condition(|| {
+                    wakeup_counter += 1;
+                    la_resolved.load(Ordering::Relaxed)
+                })
+                .await;
+            }
+        );
+        Ok(().into())
+    });
+    worker.register_activity("delay", |_: ActContext, _: String| async {
+        tokio::time::sleep(Duration::from_secs(6)).await;
+        Ok(())
+    });
+
+    let handle = starter.start_with_worker(wf_name, &mut worker).await;
+    worker.run_until_done().await.unwrap();
+    let res = handle
+        .get_workflow_result(Default::default())
+        .await
+        .unwrap()
+        .unwrap_success();
+    let replay_res = handle
+        .fetch_history_and_replay(worker.inner_mut())
+        .await
+        .unwrap();
+    assert_eq!(res[0], replay_res.unwrap());
+}