@temporalio/core-bridge 1.15.0 → 1.16.1

package/sdk-core/crates/sdk-core/tests/integ_tests/pagination_tests.rs

@@ -1,10 +1,8 @@
 use crate::common::*;
-use futures_util::StreamExt;
 use std::sync::{
     Arc,
     atomic::{AtomicUsize, Ordering},
 };
-use temporalio_client::WorkflowOptions;
 use temporalio_common::protos::{
     DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder,
     temporal::api::{
@@ -14,9 +12,31 @@ use temporalio_common::protos::{
         workflowservice::v1::GetWorkflowExecutionHistoryResponse,
     },
 };
-use temporalio_sdk::WfContext;
+use temporalio_macros::{workflow, workflow_methods};
+use temporalio_sdk::{SyncWorkflowContext, WorkflowContext, WorkflowResult};
 use temporalio_sdk_core::test_help::{MockPollCfg, ResponseType, mock_worker_client};
 
+#[workflow]
+struct WeirdPaginationWf {
+    sig_ctr: Arc<AtomicUsize>,
+    signal_count: usize,
+}
+
+#[workflow_methods(factory_only)]
+impl WeirdPaginationWf {
+    #[run(name = DEFAULT_WORKFLOW_TYPE)]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        ctx.wait_condition(|s| s.signal_count >= 2).await;
+        Ok(())
+    }
+
+    #[signal(name = "hi")]
+    fn hi(&mut self, _ctx: &mut SyncWorkflowContext<Self>, _: ()) {
+        self.signal_count += 1;
+        self.sig_ctr.fetch_add(1, Ordering::AcqRel);
+    }
+}
+
 #[tokio::test]
 async fn weird_pagination_doesnt_drop_wft_events() {
     let wf_id = "fakeid";
@@ -97,7 +117,6 @@ async fn weird_pagination_doesnt_drop_wft_events() {
         })
         .times(1);
 
-    let wf_type = DEFAULT_WORKFLOW_TYPE;
     let mh = MockPollCfg::from_resp_batches(wf_id, t, [ResponseType::Raw(wft_resp)], mock_client);
     let mut worker = mock_sdk_cfg(mh, |cfg| {
         cfg.max_cached_workflows = 2;
@@ -106,32 +125,36 @@ async fn weird_pagination_doesnt_drop_wft_events() {
 
     let sig_ctr = Arc::new(AtomicUsize::new(0));
     let sig_ctr_clone = sig_ctr.clone();
-    worker.register_wf(wf_type.to_owned(), move |ctx: WfContext| {
-        let sig_ctr_clone = sig_ctr_clone.clone();
-        async move {
-            let mut sigchan = ctx.make_signal_channel("hi");
-            while sigchan.next().await.is_some() {
-                if sig_ctr_clone.fetch_add(1, Ordering::AcqRel) == 1 {
-                    break;
-                }
-            }
-            Ok(().into())
-        }
+    worker.register_workflow_with_factory(move || WeirdPaginationWf {
+        sig_ctr: sig_ctr_clone.clone(),
+        signal_count: 0,
     });
 
-    worker
-        .submit_wf(
-            wf_id.to_owned(),
-            wf_type.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
     worker.run_until_done().await.unwrap();
     assert_eq!(sig_ctr.load(Ordering::Acquire), 2);
 }
 
+#[workflow]
+struct ExtremePaginationWf {
+    sig_ctr: Arc<AtomicUsize>,
+    signal_count: usize,
+}
+
+#[workflow_methods(factory_only)]
+impl ExtremePaginationWf {
+    #[run(name = DEFAULT_WORKFLOW_TYPE)]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        ctx.wait_condition(|s| s.signal_count >= 6).await;
+        Ok(())
+    }
+
+    #[signal(name = "hi")]
+    fn hi(&mut self, _ctx: &mut SyncWorkflowContext<Self>, _: ()) {
+        self.signal_count += 1;
+        self.sig_ctr.fetch_add(1, Ordering::AcqRel);
+    }
+}
+
 #[tokio::test]
 async fn extreme_pagination_doesnt_drop_wft_events_worker() {
     let wf_id = "fakeid";
@@ -237,7 +260,6 @@ async fn extreme_pagination_doesnt_drop_wft_events_worker() {
     wft_resp.previous_started_event_id = 3;
     wft_resp.started_event_id = 15;
 
-    let wf_type = DEFAULT_WORKFLOW_TYPE;
     let mh = MockPollCfg::from_resp_batches(wf_id, t, [ResponseType::Raw(wft_resp)], mock_client);
     let mut worker = mock_sdk_cfg(mh, |cfg| {
         cfg.max_cached_workflows = 2;
@@ -246,28 +268,11 @@ async fn extreme_pagination_doesnt_drop_wft_events_worker() {
 
     let sig_ctr = Arc::new(AtomicUsize::new(0));
     let sig_ctr_clone = sig_ctr.clone();
-    worker.register_wf(wf_type.to_owned(), move |ctx: WfContext| {
-        let sig_ctr_clone = sig_ctr_clone.clone();
-        async move {
-            let mut sigchan = ctx.make_signal_channel("hi");
-            while sigchan.next().await.is_some() {
-                if sig_ctr_clone.fetch_add(1, Ordering::AcqRel) == 5 {
-                    break;
-                }
-            }
-            Ok(().into())
-        }
+    worker.register_workflow_with_factory(move || ExtremePaginationWf {
+        sig_ctr: sig_ctr_clone.clone(),
+        signal_count: 0,
     });
 
-    worker
-        .submit_wf(
-            wf_id.to_owned(),
-            wf_type.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
     worker.run_until_done().await.unwrap();
     assert_eq!(sig_ctr.load(Ordering::Acquire), 6);
 }

package/sdk-core/crates/sdk-core/tests/integ_tests/polling_tests.rs

@@ -1,9 +1,7 @@
-use crate::{
-    common::{
-        CoreWfStarter, INTEG_CLIENT_NAME, INTEG_CLIENT_VERSION, get_integ_server_options,
-        init_core_and_create_wf, init_integ_telem, integ_dev_server_config, integ_worker_config,
-    },
-    integ_tests::activity_functions::echo,
+use crate::common::{
+    CoreWfStarter, INTEG_CLIENT_NAME, INTEG_CLIENT_VERSION, activity_functions::StdActivities,
+    get_integ_client, init_core_and_create_wf, init_integ_telem, integ_dev_server_config,
+    integ_worker_config,
 };
 use assert_matches::assert_matches;
 use futures_util::{FutureExt, StreamExt, future::join_all};
@@ -15,12 +13,16 @@ use std::{
     },
     time::Duration,
 };
-use temporalio_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions};
+use temporalio_client::{
+    Client, Connection, ConnectionOptions, NamespacedClient, UntypedWorkflow,
+    WorkflowExecutionInfo, WorkflowStartOptions,
+};
 use temporalio_common::{
-    Worker, prost_dur,
+    data_converters::RawValue,
+    prost_dur,
     protos::{
         coresdk::{
-            AsJsonPayloadExt, IntoCompletion,
+            IntoCompletion,
             activity_task::activity_task as act_task,
             workflow_activation::{FireTimer, WorkflowActivationJob, workflow_activation_job},
             workflow_commands::{ActivityCancellationType, RequestCancelActivity, StartTimer},
@@ -29,15 +31,14 @@ use temporalio_common::{
         temporal::api::enums::v1::EventType,
         test_utils::schedule_activity_cmd,
     },
-    telemetry::{Logger, TelemetryOptions},
-    worker::PollerBehavior,
+    telemetry::{CoreLogStreamConsumer, Logger, TelemetryOptions},
 };
-use temporalio_sdk::{ActivityOptions, WfContext};
+use temporalio_macros::{workflow, workflow_methods};
+use temporalio_sdk::{ActivityOptions, WorkflowContext, WorkflowResult};
 use temporalio_sdk_core::{
-    ClientOptions, CoreRuntime, RuntimeOptions,
+    CoreRuntime, PollerBehavior, RuntimeOptions, TunerHolder,
     ephemeral_server::{TemporalDevServerConfig, default_cached_download},
     init_worker,
-    telemetry::CoreLogStreamConsumer,
     test_help::{NAMESPACE, WorkerTestHelpers, drain_pollers_and_shutdown},
 };
 use tokio::{sync::Notify, time::timeout};
@@ -145,87 +146,99 @@ async fn switching_worker_client_changes_poll() {
     let result = std::panic::AssertUnwindSafe(async {
         // Connect clients to both servers
         info!("Connecting clients");
-        let client1 = ClientOptions::builder()
-            .identity("integ_tester".to_owned())
-            .client_name("temporal-core".to_owned())
-            .client_version("0.1.0".to_owned())
-            .target_url(Url::parse(&format!("http://{}", server1.target)).unwrap())
-            .build()
-            .connect("default", None)
-            .await
-            .unwrap();
-        let client2 = ClientOptions::builder()
-            .identity("integ_tester".to_owned())
-            .client_name("temporal-core".to_owned())
-            .client_version("0.1.0".to_owned())
-            .target_url(Url::parse(&format!("http://{}", server2.target)).unwrap())
-            .build()
-            .connect("default", None)
-            .await
-            .unwrap();
+        let opts1 =
+            ConnectionOptions::new(Url::parse(&format!("http://{}", server1.target)).unwrap())
+                .identity("integ_tester".to_owned())
+                .client_name("temporal-core".to_owned())
+                .client_version("0.1.0".to_owned())
+                .build();
+        let connection1 = Connection::connect(opts1).await.unwrap();
+        let client_opts1 = temporalio_client::ClientOptions::new("default").build();
+        let client1 = Client::new(connection1, client_opts1).unwrap();
+
+        let opts2 =
+            ConnectionOptions::new(Url::parse(&format!("http://{}", server2.target)).unwrap())
+                .identity("integ_tester".to_owned())
+                .client_name("temporal-core".to_owned())
+                .client_version("0.1.0".to_owned())
+                .build();
+        let connection2 = Connection::connect(opts2).await.unwrap();
+        let client_opts2 = temporalio_client::ClientOptions::new("default").build();
+        let client2 = Client::new(connection2, client_opts2).unwrap();
 
         // Start a workflow on both servers
         info!("Starting workflows");
         let wf1 = client1
             .start_workflow(
-                vec![],
-                "my-task-queue".to_owned(),
-                "my-workflow-1".to_owned(),
-                "my-workflow-type".to_owned(),
-                None,
-                WorkflowOptions::default(),
+                UntypedWorkflow::new("my-workflow-type"),
+                RawValue::default(),
+                WorkflowStartOptions::new("my-task-queue".to_owned(), "my-workflow-1".to_owned())
+                    .build(),
             )
             .await
             .unwrap();
+        let wf1_run_id = wf1.run_id().unwrap().to_string();
         let wf2 = client2
             .start_workflow(
-                vec![],
-                "my-task-queue".to_owned(),
-                "my-workflow-2".to_owned(),
-                "my-workflow-type".to_owned(),
-                None,
-                WorkflowOptions::default(),
+                UntypedWorkflow::new("my-workflow-type"),
+                RawValue::default(),
+                WorkflowStartOptions::new("my-task-queue".to_owned(), "my-workflow-2".to_owned())
+                    .build(),
             )
             .await
             .unwrap();
+        let wf2_run_id = wf2.run_id().unwrap().to_string();
 
         // Create a worker only on the first server
         let mut config = integ_worker_config("my-task-queue");
         // We want a cache so we don't get extra remove-job activations
         config.max_cached_workflows = 100_usize;
-        let worker = init_worker(init_integ_telem().unwrap(), config, client1.clone()).unwrap();
+        let worker = init_worker(
+            init_integ_telem().unwrap(),
+            config,
+            client1.connection().clone(),
+        )
+        .unwrap();
 
         // Poll for first task, confirm it's first wf, complete, and wait for complete
         info!("Doing initial poll");
         let act1 = worker.poll_workflow_activation().await.unwrap();
-        assert_eq!(wf1.run_id, act1.run_id);
+        assert_eq!(wf1_run_id, act1.run_id);
         worker.complete_execution(&act1.run_id).await;
         worker.handle_eviction().await;
         info!("Waiting on first workflow complete");
-        client1
-            .get_untyped_workflow_handle("my-workflow-1", wf1.run_id)
-            .get_workflow_result(Default::default())
-            .await
-            .unwrap();
+        WorkflowExecutionInfo {
+            namespace: client1.namespace(),
+            workflow_id: "my-workflow-1".into(),
+            run_id: Some(wf1_run_id.clone()),
+            first_execution_run_id: None,
+        }
+        .bind_untyped(client1.clone())
+        .get_result(Default::default())
+        .await
+        .unwrap();
 
         // Swap client, poll for next task, confirm it's second wf, and respond w/ empty
         info!("Replacing client and polling again");
-        worker
-            .replace_client(client2.get_client().inner().clone())
-            .unwrap();
+        worker.replace_client(client2.connection().clone()).unwrap();
         let act2 = worker.poll_workflow_activation().await.unwrap();
-        assert_eq!(wf2.run_id, act2.run_id);
+        assert_eq!(wf2_run_id, act2.run_id);
         worker.complete_execution(&act2.run_id).await;
         worker.handle_eviction().await;
         info!("Waiting on second workflow complete");
-        client2
-            .get_untyped_workflow_handle("my-workflow-2", wf2.run_id)
-            .get_workflow_result(Default::default())
-            .await
-            .unwrap();
+        WorkflowExecutionInfo {
+            namespace: client2.namespace(),
+            workflow_id: "my-workflow-2".into(),
+            run_id: Some(wf2_run_id),
+            first_execution_run_id: None,
+        }
+        .bind_untyped(client2.clone())
+        .get_result(Default::default())
+        .await
+        .unwrap();
 
         // Shutdown workers and servers
-        drain_pollers_and_shutdown(&(Arc::new(worker) as Arc<dyn Worker>)).await;
+        drain_pollers_and_shutdown(&worker).await;
     })
     .catch_unwind()
     .await;
@@ -239,54 +252,65 @@ async fn switching_worker_client_changes_poll() {
     }
 }
 
+#[workflow]
+#[derive(Default)]
+struct OnlyOneWorkflowSlotAndTwoPollers;
+
+#[workflow_methods]
+impl OnlyOneWorkflowSlotAndTwoPollers {
+    #[run(name = "only_one_workflow_slot_and_two_pollers")]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        for _ in 0..3 {
+            let _ = ctx
+                .start_activity(
+                    StdActivities::echo,
+                    "hi!".to_string(),
+                    ActivityOptions {
+                        start_to_close_timeout: Some(Duration::from_secs(5)),
+                        ..Default::default()
+                    },
+                )
+                .await;
+        }
+        Ok(())
+    }
+}
+
 #[rstest::rstest]
 #[tokio::test]
 async fn small_workflow_slots_and_pollers(#[values(false, true)] use_autoscaling: bool) {
     let wf_name = "only_one_workflow_slot_and_two_pollers";
     let mut starter = CoreWfStarter::new(wf_name);
     if use_autoscaling {
-        starter.worker_config.workflow_task_poller_behavior = PollerBehavior::Autoscaling {
+        starter.sdk_config.workflow_task_poller_behavior = PollerBehavior::Autoscaling {
             minimum: 1,
             maximum: 5,
             initial: 1,
         };
     } else {
-        starter.worker_config.workflow_task_poller_behavior = PollerBehavior::SimpleMaximum(2);
+        starter.sdk_config.workflow_task_poller_behavior = PollerBehavior::SimpleMaximum(2);
     }
-    starter.worker_config.max_outstanding_workflow_tasks = Some(2_usize);
-    starter.worker_config.max_outstanding_local_activities = Some(1_usize);
-    starter.worker_config.activity_task_poller_behavior = PollerBehavior::SimpleMaximum(1);
-    starter.worker_config.max_outstanding_activities = Some(1_usize);
+    starter.sdk_config.activity_task_poller_behavior = PollerBehavior::SimpleMaximum(1);
+    starter.sdk_config.tuner = Arc::new(TunerHolder::fixed_size(2, 1, 1, 1));
+    starter.sdk_config.register_activities(StdActivities);
     let mut worker = starter.worker().await;
-    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
-        for _ in 0..3 {
-            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);
+
+    worker.register_workflow::<OnlyOneWorkflowSlotAndTwoPollers>();
+    let task_queue = starter.get_task_queue().to_owned();
     worker
-        .submit_wf(
-            starter.get_task_queue(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
+        .submit_workflow(
+            OnlyOneWorkflowSlotAndTwoPollers::run,
+            (),
+            WorkflowStartOptions::new(task_queue.clone(), task_queue.clone()).build(),
         )
         .await
         .unwrap();
     let wf2id = format!("{}-2", starter.get_task_queue());
     worker
-        .submit_wf(
-            wf2id.clone(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
+        .submit_workflow(
+            OnlyOneWorkflowSlotAndTwoPollers::run,
+            (),
+            WorkflowStartOptions::new(task_queue.clone(), wf2id.clone()).build(),
         )
         .await
         .unwrap();
@@ -299,16 +323,15 @@ async fn small_workflow_slots_and_pollers(#[values(false, true)] use_autoscaling
         .iter()
         .any(|e| e.event_type() == EventType::WorkflowTaskTimedOut);
     assert!(!any_task_timeouts);
-    let history = starter
+    let events = starter
         .get_client()
         .await
-        .get_workflow_execution_history(wf2id, None, vec![])
+        .get_workflow_handle::<UntypedWorkflow>(&wf2id)
+        .fetch_history(Default::default())
         .await
         .unwrap()
-        .history
-        .unwrap();
-    let any_task_timeouts = history
-        .events
+        .into_events();
+    let any_task_timeouts = events
         .iter()
         .any(|e| e.event_type() == EventType::WorkflowTaskTimedOut);
     assert!(!any_task_timeouts);
@@ -378,42 +401,40 @@ async fn replace_client_works_after_polling_failure() {
                 "http://{}",
                 initial_server.lock().unwrap().as_ref().unwrap().target
             );
-            let client_for_initial_server = ClientOptions::builder()
+            let opts = ConnectionOptions::new(Url::parse(&initial_server_target).unwrap())
                 .identity("client_for_initial_server".to_string())
-                .target_url(Url::parse(&initial_server_target).unwrap())
                 .client_name(INTEG_CLIENT_NAME.to_string())
                 .client_version(INTEG_CLIENT_VERSION.to_string())
-                .build()
-                .connect(NAMESPACE, rt.telemetry().get_temporal_metric_meter())
-                .await
-                .unwrap();
+                .build();
+            let connection = Connection::connect(opts).await.unwrap();
+            let client_opts = temporalio_client::ClientOptions::new(NAMESPACE).build();
+            let client_for_initial_server = Client::new(connection, client_opts).unwrap();
 
             let wf_name = "replace_client_works_after_polling_failure";
             let task_queue = format!("{wf_name}_tq");
 
             let mut config = integ_worker_config(&task_queue);
             config.max_cached_workflows = 100_usize;
-            let worker =
-                Arc::new(init_worker(&rt, config, client_for_initial_server.clone()).unwrap());
+            let worker = Arc::new(
+                init_worker(&rt, config, client_for_initial_server.connection().clone()).unwrap(),
+            );
 
             // Polling the initial server the first time is successful.
             let wf_1 = client_for_initial_server
                 .start_workflow(
-                    vec![],
-                    task_queue.clone(),
-                    wf_name.into(),
-                    wf_name.into(),
-                    None,
-                    WorkflowOptions::default(),
+                    UntypedWorkflow::new(wf_name),
+                    RawValue::default(),
+                    WorkflowStartOptions::new(task_queue.clone(), wf_name.to_string()).build(),
                 )
                 .await
                 .unwrap();
+            let wf_1_run_id = wf_1.run_id().unwrap().to_string();
             let act_1 =
                 tokio::time::timeout(Duration::from_secs(60), worker.poll_workflow_activation())
                     .await
                     .unwrap()
                     .unwrap();
-            assert_eq!(act_1.run_id, wf_1.run_id);
+            assert_eq!(act_1.run_id, wf_1_run_id);
 
             // Initial server is shut down.
             let mut server = initial_server.lock().unwrap().take().unwrap();
@@ -436,34 +457,34 @@ async fn replace_client_works_after_polling_failure() {
                 .unwrap();
 
             // Start a new WF on main integration server.
-            let client_for_integ_server = get_integ_server_options()
-                .connect(NAMESPACE, rt.telemetry().get_temporal_metric_meter())
-                .await
-                .unwrap();
+            let client_for_integ_server = get_integ_client(
+                NAMESPACE.to_string(),
+                rt.telemetry().get_temporal_metric_meter(),
+            )
+            .await;
             let wf_2 = client_for_integ_server
                 .start_workflow(
-                    vec![],
-                    task_queue,
-                    wf_name.into(),
-                    wf_name.into(),
-                    None,
-                    WorkflowOptions {
-                        execution_timeout: Some(Duration::from_secs(60)),
-                        ..Default::default()
-                    },
+                    UntypedWorkflow::new(wf_name),
+                    RawValue::default(),
+                    WorkflowStartOptions::new(task_queue, wf_name)
+                        .execution_timeout(Duration::from_secs(60))
+                        .build(),
                 )
                 .await
                 .unwrap();
+            let wf_2_run_id = wf_2.run_id().unwrap().to_string();
 
             // Switch worker over to the main integration server.
             // The polling started on the initial server should complete with a task from the new server.
-            worker.replace_client(client_for_integ_server).unwrap();
+            worker
+                .replace_client(client_for_integ_server.connection().clone())
+                .unwrap();
             let act_2 = tokio::time::timeout(Duration::from_secs(60), poll_join_handle)
                 .await
                 .unwrap()
                 .unwrap()
                 .unwrap();
-            assert_eq!(act_2.run_id, wf_2.run_id);
+            assert_eq!(act_2.run_id, wf_2_run_id);
         })
     }
     .catch_unwind()