@temporalio/core-bridge 1.15.0 → 1.16.1

package/sdk-core/crates/sdk-core/tests/main.rs

@@ -12,8 +12,9 @@ mod shared_tests;
 
 #[cfg(test)]
 mod integ_tests {
-    mod activity_functions;
+    mod async_activity_client_tests;
     mod client_tests;
+    mod data_converter_tests;
     mod ephemeral_server_tests;
     mod heartbeat_tests;
     mod metrics_tests;
@@ -25,6 +26,7 @@ mod integ_tests {
     mod worker_heartbeat_tests;
     mod worker_tests;
     mod worker_versioning_tests;
+    mod workflow_client_tests;
     mod workflow_tests;
 
     use crate::common::{
@@ -32,16 +34,19 @@ mod integ_tests {
         get_integ_telem_options, rand_6_chars,
     };
     use std::time::Duration;
-    use temporalio_client::{NamespacedClient, WorkflowService};
+    use temporalio_client::{
+        Connection, NamespacedClient,
+        grpc::{OperatorService, WorkflowService},
+    };
     use temporalio_common::{
         protos::temporal::api::{
             nexus::v1::{EndpointSpec, EndpointTarget, endpoint_target},
             operatorservice::v1::CreateNexusEndpointRequest,
             workflowservice::v1::ListNamespacesRequest,
         },
-        worker::{WorkerConfig, WorkerTaskTypes, WorkerVersioningStrategy},
+        worker::WorkerTaskTypes,
     };
-    use temporalio_sdk_core::{CoreRuntime, init_worker};
+    use temporalio_sdk_core::{CoreRuntime, WorkerConfig, WorkerVersioningStrategy, init_worker};
     use tonic::IntoRequest;
 
     // Create a worker like a bridge would (unwraps aside)
@@ -52,10 +57,7 @@ mod integ_tests {
         let runtime =
             CoreRuntime::new_assume_tokio(get_integ_runtime_options(get_integ_telem_options()))
                 .unwrap();
-        let mut retrying_client = opts
-            .connect_no_namespace(runtime.telemetry().get_temporal_metric_meter())
-            .await
-            .unwrap();
+        let mut connection = Connection::connect(opts).await.unwrap();
 
         let _worker = init_worker(
             &runtime,
@@ -68,13 +70,12 @@ mod integ_tests {
                 })
                 .build()
                 .unwrap(),
-            // clone the client if you intend to use it later. Strip off the retry wrapper since
-            // worker will assert its own
-            retrying_client.clone(),
+            // clone the connection if you intend to use it later
+            connection.clone(),
         );
 
-        // Do things with worker or client
-        let _ = retrying_client
+        // Do things with worker or connection
+        let _ = connection
             .list_namespaces(ListNamespacesRequest::default().into_request())
             .await;
     }
@@ -82,8 +83,9 @@ mod integ_tests {
     pub(crate) async fn mk_nexus_endpoint(starter: &mut CoreWfStarter) -> String {
         let client = starter.get_client().await;
         let endpoint = format!("mycoolendpoint-{}", rand_6_chars());
-        let mut op_client = client.get_client().inner().operator_svc();
-        op_client
+        client
+            .connection()
+            .clone()
             .create_nexus_endpoint(
                 CreateNexusEndpointRequest {
                     spec: Some(EndpointSpec {

package/sdk-core/crates/sdk-core/tests/manual_tests.rs

@@ -17,20 +17,114 @@ use rand::{Rng, SeedableRng};
 use std::{
     mem,
     net::SocketAddr,
+    sync::Arc,
     time::{Duration, Instant},
 };
 use temporalio_client::{
-    GetWorkflowResultOptions, WfClientExt, WorkflowClientTrait, WorkflowOptions,
+    NamespacedClient, UntypedSignal, UntypedWorkflow, WorkflowExecutionInfo,
+    WorkflowGetResultOptions, WorkflowSignalOptions, WorkflowStartOptions,
 };
 use temporalio_common::{
-    protos::coresdk::AsJsonPayloadExt,
-    telemetry::PrometheusExporterOptions,
-    worker::{PollerBehavior, WorkerTaskTypes},
+    data_converters::RawValue, telemetry::PrometheusExporterOptions, worker::WorkerTaskTypes,
 };
-use temporalio_sdk::{ActContext, ActivityOptions, WfContext};
-use temporalio_sdk_core::CoreRuntime;
+use temporalio_macros::{activities, workflow, workflow_methods};
+use temporalio_sdk::{
+    ActivityOptions, SyncWorkflowContext, WorkflowContext, WorkflowResult,
+    activities::{ActivityContext, ActivityError},
+};
+use temporalio_sdk_core::{CoreRuntime, PollerBehavior, TunerHolder};
 use tracing::info;
 
+struct JitteryEchoActivities;
+#[activities]
+impl JitteryEchoActivities {
+    #[activity]
+    async fn echo(_ctx: ActivityContext, echo: String) -> Result<String, ActivityError> {
+        // Add some jitter to completions
+        let rand_millis = rand::rng().random_range(0..500);
+        tokio::time::sleep(Duration::from_millis(rand_millis)).await;
+        Ok(echo)
+    }
+}
+
+#[workflow]
+#[derive(Default)]
+struct PollerLoadSpikyWf;
+
+#[workflow_methods]
+impl PollerLoadSpikyWf {
+    #[run(name = "poller_load")]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        for _ in 0..5 {
+            let _ = ctx
+                .start_activity(
+                    JitteryEchoActivities::echo,
+                    "hi!".to_string(),
+                    ActivityOptions {
+                        start_to_close_timeout: Some(Duration::from_secs(5)),
+                        ..Default::default()
+                    },
+                )
+                .await;
+        }
+
+        Ok(())
+    }
+
+    #[signal(name = "signame")]
+    fn drain_signal(&mut self, _ctx: &mut SyncWorkflowContext<Self>, _: ()) {}
+}
+
+#[workflow]
+#[derive(Default)]
+struct PollerLoadSustainedWf;
+
+#[workflow_methods]
+impl PollerLoadSustainedWf {
+    #[run(name = "poller_load")]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        let rs = ctx.random_seed();
+        let mut rand = rand::rngs::SmallRng::seed_from_u64(rs);
+        for _ in 0..100 {
+            let jitterms = rand.random_range(1000..3000);
+            ctx.timer(Duration::from_millis(jitterms)).await;
+        }
+
+        Ok(())
+    }
+
+    #[signal(name = "signame")]
+    fn drain_signal(&mut self, _ctx: &mut SyncWorkflowContext<Self>, _: ()) {}
+}
+
+#[workflow]
+#[derive(Default)]
+struct PollerLoadSpikeThenSustainedWf;
+
+#[workflow_methods]
+impl PollerLoadSpikeThenSustainedWf {
+    #[run(name = "poller_load")]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        for _ in 0..5 {
+            let _ = ctx
+                .start_activity(
+                    JitteryEchoActivities::echo,
+                    "hi!".to_string(),
+                    ActivityOptions {
+                        start_to_close_timeout: Some(Duration::from_secs(5)),
+                        ..Default::default()
+                    },
+                )
+                .await;
+        }
+
+        Ok(())
+    }
+
+    #[signal(name = "signame")]
+    fn drain_signal(&mut self, _ctx: &mut SyncWorkflowContext<Self>, _: ()) {}
+}
+
 #[tokio::test]
 async fn poller_load_spiky() {
     const SIGNAME: &str = "signame";
@@ -48,50 +142,25 @@ async fn poller_load_spiky() {
         };
     let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let mut starter = CoreWfStarter::new_with_runtime("poller_load", rt);
-    starter.worker_config.max_cached_workflows = 5000;
-    starter.worker_config.max_outstanding_workflow_tasks = Some(1000);
-    starter.worker_config.max_outstanding_activities = Some(1000);
-    starter.worker_config.workflow_task_poller_behavior = PollerBehavior::Autoscaling {
+    starter.sdk_config.max_cached_workflows = 5000;
+    starter.sdk_config.tuner = Arc::new(TunerHolder::fixed_size(1000, 1000, 100, 100));
+    starter.sdk_config.workflow_task_poller_behavior = PollerBehavior::Autoscaling {
         minimum: 1,
         maximum: 200,
         initial: 5,
     };
-    starter.worker_config.activity_task_poller_behavior = PollerBehavior::Autoscaling {
+    starter.sdk_config.activity_task_poller_behavior = PollerBehavior::Autoscaling {
         minimum: 1,
         maximum: 200,
         initial: 5,
     };
     let mut worker = starter.worker().await;
     let submitter = worker.get_submitter_handle();
-    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
-        let sigchan = ctx.make_signal_channel(SIGNAME).map(Ok);
-        let drained_fut = sigchan.forward(sink::drain());
-
-        let real_stuff = async move {
-            for _ in 0..5 {
-                ctx.activity(ActivityOptions {
-                    activity_type: "echo".to_string(),
-                    start_to_close_timeout: Some(Duration::from_secs(5)),
-                    input: "hi!".as_json_payload().expect("serializes fine"),
-                    ..Default::default()
-                })
-                .await;
-            }
-        };
-        tokio::select! {
-            _ = drained_fut => {}
-            _ = real_stuff => {}
-        }
 
-        Ok(().into())
-    });
-    worker.register_activity("echo", |_: ActContext, echo: String| async move {
-        // Add some jitter to completions
-        let rand_millis = rand::rng().random_range(0..500);
-        tokio::time::sleep(Duration::from_millis(rand_millis)).await;
-        Ok(echo)
-    });
+    worker.register_activities(JitteryEchoActivities);
+    worker.register_workflow::<PollerLoadSpikyWf>();
     let client = starter.get_client().await;
+    let tq = starter.get_task_queue().to_owned();
 
     info!("Prom bound to {:?}", addr);
 
@@ -101,17 +170,23 @@ async fn poller_load_spiky() {
         let wfid = format!("{wf_name}_{i}-{}", rand_6_chars());
         let rid = worker
             .submit_wf(
-                wfid.clone(),
                 wf_name.to_owned(),
                 vec![],
-                WorkflowOptions {
-                    execution_timeout: Some(Duration::from_secs(120)),
-                    ..Default::default()
-                },
+                WorkflowStartOptions::new(tq.clone(), wfid.clone())
+                    .execution_timeout(Duration::from_secs(120))
+                    .build(),
             )
             .await
             .unwrap();
-        workflow_handles.push(client.get_untyped_workflow_handle(wfid, rid));
+        workflow_handles.push(
+            WorkflowExecutionInfo {
+                namespace: client.namespace(),
+                workflow_id: wfid,
+                run_id: Some(rid),
+                first_execution_run_id: None,
+            }
+            .bind_untyped(client.clone()),
+        );
     }
     info!("Done starting workflows");
     let start_processing = Instant::now();
@@ -120,9 +195,7 @@ async fn poller_load_spiky() {
     let all_workflows_are_done = async {
         stream::iter(mem::take(&mut workflow_handles))
             .for_each_concurrent(25, |handle| async move {
-                let _ = handle
-                    .get_workflow_result(GetWorkflowResultOptions::default())
-                    .await;
+                let _ = handle.get_result(WorkflowGetResultOptions::default()).await;
             })
             .await;
         info!("Initial load ran for {:?}", start_processing.elapsed());
@@ -135,23 +208,27 @@ async fn poller_load_spiky() {
             let wfid = format!("{wf_name}_2_{i}-{}", rand_6_chars());
             let rid = submitter
                 .submit_wf(
-                    wfid.clone(),
                     wf_name.to_owned(),
                     vec![],
-                    WorkflowOptions {
-                        execution_timeout: Some(Duration::from_secs(120)),
-                        ..Default::default()
-                    },
+                    WorkflowStartOptions::new(tq.clone(), wfid.clone())
+                        .execution_timeout(Duration::from_secs(120))
+                        .build(),
                 )
                 .await
                 .unwrap();
-            workflow_handles.push(client.get_untyped_workflow_handle(wfid, rid));
+            workflow_handles.push(
+                WorkflowExecutionInfo {
+                    namespace: client.namespace(),
+                    workflow_id: wfid,
+                    run_id: Some(rid),
+                    first_execution_run_id: None,
+                }
+                .bind_untyped(client.clone()),
+            );
         }
         stream::iter(workflow_handles)
             .for_each_concurrent(25, |handle| async move {
-                let _ = handle
-                    .get_workflow_result(GetWorkflowResultOptions::default())
-                    .await;
+                let _ = handle.get_result(WorkflowGetResultOptions::default()).await;
             })
             .await;
         info!("Second load ran for {:?}", start_processing.elapsed());
@@ -164,13 +241,17 @@ async fn poller_load_spiky() {
             loop {
                 let sends: FuturesUnordered<_> = (0..num_workflows)
                     .map(|i| {
-                        client.signal_workflow_execution(
-                            format!("{wf_name}_{i}"),
-                            "".to_string(),
-                            SIGNAME.to_string(),
-                            None,
-                            None,
-                        )
+                        let handle =
+                            client.get_workflow_handle::<UntypedWorkflow>(format!("{wf_name}_{i}"));
+                        async move {
+                            handle
+                                .signal(
+                                    UntypedSignal::new(SIGNAME),
+                                    RawValue::empty(),
+                                    WorkflowSignalOptions::default(),
+                                )
+                                .await
+                        }
                     })
                     .collect();
                 sends
@@ -189,7 +270,6 @@ async fn poller_load_spiky() {
 
 #[tokio::test]
 async fn poller_load_sustained() {
-    const SIGNAME: &str = "signame";
     let num_workflows = 150;
     let wf_name = "poller_load";
     let (telemopts, addr, _aborter) =
@@ -204,35 +284,18 @@ async fn poller_load_sustained() {
         };
     let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let mut starter = CoreWfStarter::new_with_runtime("poller_load", rt);
-    starter.worker_config.max_cached_workflows = 5000;
-    starter.worker_config.max_outstanding_workflow_tasks = Some(1000);
-    starter.worker_config.workflow_task_poller_behavior = PollerBehavior::Autoscaling {
+    starter.sdk_config.max_cached_workflows = 5000;
+    starter.sdk_config.tuner = Arc::new(TunerHolder::fixed_size(1000, 100, 100, 100));
+    starter.sdk_config.workflow_task_poller_behavior = PollerBehavior::Autoscaling {
         minimum: 1,
         maximum: 200,
         initial: 5,
     };
-    starter.worker_config.task_types = WorkerTaskTypes::workflow_only();
+    starter.sdk_config.task_types = WorkerTaskTypes::workflow_only();
     let mut worker = starter.worker().await;
-    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
-        let sigchan = ctx.make_signal_channel(SIGNAME).map(Ok);
-        let drained_fut = sigchan.forward(sink::drain());
-
-        let real_stuff = async move {
-            let rs = ctx.random_seed();
-            let mut rand = rand::rngs::SmallRng::seed_from_u64(rs);
-            for _ in 0..100 {
-                let jitterms = rand.random_range(1000..3000);
-                ctx.timer(Duration::from_millis(jitterms)).await;
-            }
-        };
-        tokio::select! {
-            _ = drained_fut => {}
-            _ = real_stuff => {}
-        }
-
-        Ok(().into())
-    });
+    worker.register_workflow::<PollerLoadSustainedWf>();
     let client = starter.get_client().await;
+    let tq = starter.get_task_queue().to_owned();
 
     info!("Prom bound to {:?}", addr);
 
@@ -242,17 +305,23 @@ async fn poller_load_sustained() {
         let wfid = format!("{wf_name}_{i}-{}", rand_6_chars());
         let rid = worker
             .submit_wf(
-                wfid.clone(),
                 wf_name.to_owned(),
                 vec![],
-                WorkflowOptions {
-                    execution_timeout: Some(Duration::from_secs(800)),
-                    ..Default::default()
-                },
+                WorkflowStartOptions::new(tq.clone(), wfid.clone())
+                    .execution_timeout(Duration::from_secs(800))
+                    .build(),
             )
             .await
             .unwrap();
-        workflow_handles.push(client.get_untyped_workflow_handle(wfid, rid));
+        workflow_handles.push(
+            WorkflowExecutionInfo {
+                namespace: client.namespace(),
+                workflow_id: wfid,
+                run_id: Some(rid),
+                first_execution_run_id: None,
+            }
+            .bind_untyped(client.clone()),
+        );
     }
     info!("Done starting workflows");
     let start_processing = Instant::now();
@@ -260,9 +329,7 @@ async fn poller_load_sustained() {
     let all_workflows_are_done = async {
         stream::iter(mem::take(&mut workflow_handles))
             .for_each_concurrent(25, |handle| async move {
-                let _ = handle
-                    .get_workflow_result(GetWorkflowResultOptions::default())
-                    .await;
+                let _ = handle.get_result(WorkflowGetResultOptions::default()).await;
             })
             .await;
         info!("Initial load ran for {:?}", start_processing.elapsed());
@@ -292,49 +359,25 @@ async fn poller_load_spike_then_sustained() {
         };
     let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let mut starter = CoreWfStarter::new_with_runtime("poller_load", rt);
-    starter.worker_config.max_cached_workflows = 5000;
-    starter.worker_config.max_outstanding_workflow_tasks = Some(1000);
-    starter.worker_config.workflow_task_poller_behavior = PollerBehavior::Autoscaling {
+    starter.sdk_config.max_cached_workflows = 5000;
+    starter.sdk_config.tuner = Arc::new(TunerHolder::fixed_size(1000, 100, 100, 100));
+    starter.sdk_config.workflow_task_poller_behavior = PollerBehavior::Autoscaling {
         minimum: 1,
         maximum: 200,
         initial: 5,
     };
-    starter.worker_config.activity_task_poller_behavior = PollerBehavior::Autoscaling {
+    starter.sdk_config.activity_task_poller_behavior = PollerBehavior::Autoscaling {
         minimum: 1,
         maximum: 200,
         initial: 5,
     };
     let mut worker = starter.worker().await;
     let submitter = worker.get_submitter_handle();
-    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
-        let sigchan = ctx.make_signal_channel(SIGNAME).map(Ok);
-        let drained_fut = sigchan.forward(sink::drain());
-
-        let real_stuff = async move {
-            for _ in 0..5 {
-                ctx.activity(ActivityOptions {
-                    activity_type: "echo".to_string(),
-                    start_to_close_timeout: Some(Duration::from_secs(5)),
-                    input: "hi!".as_json_payload().expect("serializes fine"),
-                    ..Default::default()
-                })
-                .await;
-            }
-        };
-        tokio::select! {
-            _ = drained_fut => {}
-            _ = real_stuff => {}
-        }
 
-        Ok(().into())
-    });
-    worker.register_activity("echo", |_: ActContext, echo: String| async move {
-        // Add some jitter to completions
-        let rand_millis = rand::rng().random_range(0..500);
-        tokio::time::sleep(Duration::from_millis(rand_millis)).await;
-        Ok(echo)
-    });
+    worker.register_activities(JitteryEchoActivities);
+    worker.register_workflow::<PollerLoadSpikeThenSustainedWf>();
     let client = starter.get_client().await;
+    let tq = starter.get_task_queue().to_owned();
 
     info!("Prom bound to {:?}", addr);
 
@@ -344,17 +387,23 @@ async fn poller_load_spike_then_sustained() {
         let wfid = format!("{wf_name}_{i}-{}", rand_6_chars());
         let rid = worker
             .submit_wf(
-                wfid.clone(),
                 wf_name.to_owned(),
                 vec![],
-                WorkflowOptions {
-                    execution_timeout: Some(Duration::from_secs(100)),
-                    ..Default::default()
-                },
+                WorkflowStartOptions::new(tq.clone(), wfid.clone())
+                    .execution_timeout(Duration::from_secs(100))
+                    .build(),
             )
             .await
             .unwrap();
-        workflow_handles.push(client.get_untyped_workflow_handle(wfid, rid));
+        workflow_handles.push(
+            WorkflowExecutionInfo {
+                namespace: client.namespace(),
+                workflow_id: wfid,
+                run_id: Some(rid),
+                first_execution_run_id: None,
+            }
+            .bind_untyped(client.clone()),
+        );
     }
     info!("Done starting workflows");
     let start_processing = Instant::now();
@@ -363,9 +412,7 @@ async fn poller_load_spike_then_sustained() {
     let all_workflows_are_done = async {
         stream::iter(mem::take(&mut workflow_handles))
             .for_each_concurrent(25, |handle| async move {
-                let _ = handle
-                    .get_workflow_result(GetWorkflowResultOptions::default())
-                    .await;
+                let _ = handle.get_result(WorkflowGetResultOptions::default()).await;
             })
             .await;
         info!("Initial load ran for {:?}", start_processing.elapsed());
@@ -377,24 +424,28 @@ async fn poller_load_spike_then_sustained() {
             let wfid = format!("{wf_name}_2_{i}-{}", rand_6_chars());
             let rid = submitter
                 .submit_wf(
-                    wfid.clone(),
                     wf_name.to_owned(),
                     vec![],
-                    WorkflowOptions {
-                        execution_timeout: Some(Duration::from_secs(100)),
-                        ..Default::default()
-                    },
+                    WorkflowStartOptions::new(tq.clone(), wfid.clone())
+                        .execution_timeout(Duration::from_secs(100))
+                        .build(),
                 )
                 .await
                 .unwrap();
-            workflow_handles.push(client.get_untyped_workflow_handle(wfid, rid));
+            workflow_handles.push(
+                WorkflowExecutionInfo {
+                    namespace: client.namespace(),
+                    workflow_id: wfid,
+                    run_id: Some(rid),
+                    first_execution_run_id: None,
+                }
+                .bind_untyped(client.clone()),
+            );
             tokio::time::sleep(Duration::from_secs(1)).await;
         }
         stream::iter(workflow_handles)
             .for_each_concurrent(25, |handle| async move {
-                let _ = handle
-                    .get_workflow_result(GetWorkflowResultOptions::default())
-                    .await;
+                let _ = handle.get_result(WorkflowGetResultOptions::default()).await;
             })
             .await;
         info!("Second load ran for {:?}", start_processing.elapsed());
@@ -407,13 +458,17 @@ async fn poller_load_spike_then_sustained() {
             loop {
                 let sends: FuturesUnordered<_> = (0..num_workflows)
                     .map(|i| {
-                        client.signal_workflow_execution(
-                            format!("{wf_name}_{i}"),
-                            "".to_string(),
-                            SIGNAME.to_string(),
-                            None,
-                            None,
-                        )
+                        let handle =
+                            client.get_workflow_handle::<UntypedWorkflow>(format!("{wf_name}_{i}"));
+                        async move {
+                            handle
+                                .signal(
+                                    UntypedSignal::new(SIGNAME),
+                                    RawValue::empty(),
+                                    WorkflowSignalOptions::default(),
+                                )
+                                .await
+                        }
                     })
                     .collect();
                 sends