@temporalio/core-bridge 1.14.2-canary-release-testing.0 → 1.16.0

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

@@ -7,7 +7,8 @@ mod fuzzy_workflow;
 
 use crate::common::get_integ_runtime_options;
 use common::{
-    CoreWfStarter, init_integ_telem, prom_metrics, rand_6_chars, workflows::la_problem_workflow,
+    CoreWfStarter, activity_functions::StdActivities, init_integ_telem, prom_metrics, rand_6_chars,
+    workflows::LaProblemWorkflow,
 };
 use futures_util::{
     StreamExt,
@@ -22,75 +23,84 @@ use std::{
     time::{Duration, Instant},
 };
 use temporalio_client::{
-    GetWorkflowResultOptions, WfClientExt, WorkflowClientTrait, WorkflowOptions,
+    NamespacedClient, UntypedSignal, UntypedWorkflow, WorkflowExecutionInfo,
+    WorkflowGetResultOptions, WorkflowSignalOptions, WorkflowStartOptions,
 };
+use temporalio_common::{
+    data_converters::RawValue, protos::temporal::api::enums::v1::WorkflowIdConflictPolicy,
+};
+use temporalio_macros::{activities, workflow, workflow_methods};
 
 use temporalio_common::{
     protos::{
-        coresdk::{AsJsonPayloadExt, workflow_commands::ActivityCancellationType},
+        coresdk::workflow_commands::ActivityCancellationType,
         temporal::api::enums::v1::WorkflowIdReusePolicy,
     },
-    worker::{PollerBehavior, WorkerTaskTypes},
+    worker::WorkerTaskTypes,
+};
+use temporalio_sdk::{
+    ActivityOptions, SyncWorkflowContext, WorkflowContext, WorkflowResult,
+    activities::{ActivityContext, ActivityError},
+};
+use temporalio_sdk_core::{
+    CoreRuntime, PollerBehavior, ResourceBasedTuner, ResourceSlotOptions, TunerHolder,
 };
-use temporalio_sdk::{ActContext, ActivityOptions, WfContext, WorkflowResult};
-use temporalio_sdk_core::{CoreRuntime, ResourceBasedTuner, ResourceSlotOptions};
+
+#[workflow]
+#[derive(Clone, Default)]
+struct ActivityLoadWf;
+
+#[workflow_methods]
+impl ActivityLoadWf {
+    #[run(name = "activity_load")]
+    async fn run(ctx: &mut WorkflowContext<Self>, tq: String) -> WorkflowResult<()> {
+        let input_str = "yo".to_string();
+        let res = ctx
+            .start_activity(
+                StdActivities::echo,
+                input_str.clone(),
+                ActivityOptions {
+                    activity_id: Some("act-1".to_string()),
+                    task_queue: Some(tq),
+                    schedule_to_start_timeout: Some(Duration::from_secs(8)),
+                    start_to_close_timeout: Some(Duration::from_secs(8)),
+                    schedule_to_close_timeout: Some(Duration::from_secs(8)),
+                    heartbeat_timeout: Some(Duration::from_secs(8)),
+                    cancellation_type: ActivityCancellationType::TryCancel,
+                    ..Default::default()
+                },
+            )
+            .await?;
+        assert_eq!(res, input_str);
+        Ok(())
+    }
+}
 
 #[tokio::test]
 async fn activity_load() {
     const CONCURRENCY: usize = 512;
 
     let mut starter = CoreWfStarter::new("activity_load");
-    starter
-        .worker_config
-        .max_outstanding_workflow_tasks(CONCURRENCY)
-        .max_cached_workflows(CONCURRENCY)
-        .activity_task_poller_behavior(PollerBehavior::SimpleMaximum(10_usize))
-        .max_outstanding_activities(CONCURRENCY);
+    starter.sdk_config.max_cached_workflows = CONCURRENCY;
+    starter.sdk_config.activity_task_poller_behavior = PollerBehavior::SimpleMaximum(10);
+    starter.sdk_config.tuner =
+        Arc::new(TunerHolder::fixed_size(CONCURRENCY, CONCURRENCY, 100, 100));
+    starter.sdk_config.register_activities(StdActivities);
+    let task_queue = starter.get_task_queue().to_owned();
     let mut worker = starter.worker().await;
 
-    let activity_id = "act-1";
-    let activity_timeout = Duration::from_secs(8);
-    let task_queue = Some(starter.get_task_queue().to_owned());
-
-    let wf_fn = move |ctx: WfContext| {
-        let task_queue = task_queue.clone();
-        let payload = "yo".as_json_payload().unwrap();
-        async move {
-            let activity = ActivityOptions {
-                activity_id: Some(activity_id.to_string()),
-                activity_type: "test_activity".to_string(),
-                input: payload.clone(),
-                task_queue,
-                schedule_to_start_timeout: Some(activity_timeout),
-                start_to_close_timeout: Some(activity_timeout),
-                schedule_to_close_timeout: Some(activity_timeout),
-                heartbeat_timeout: Some(activity_timeout),
-                cancellation_type: ActivityCancellationType::TryCancel,
-                ..Default::default()
-            };
-            let res = ctx.activity(activity).await.unwrap_ok_payload();
-            assert_eq!(res.data, payload.data);
-            Ok(().into())
-        }
-    };
-
     let starting = Instant::now();
-    let wf_type = "activity_load";
-    worker.register_wf(wf_type.to_owned(), wf_fn);
-    worker.register_activity(
-        "test_activity",
-        |_ctx: ActContext, echo: String| async move { Ok(echo) },
-    );
+    worker.register_workflow::<ActivityLoadWf>();
     join_all((0..CONCURRENCY).map(|i| {
         let worker = &worker;
         let wf_id = format!("activity_load_{i}");
+        let tq = task_queue.clone();
         async move {
             worker
-                .submit_wf(
-                    wf_id,
-                    wf_type.to_owned(),
-                    vec![],
-                    WorkflowOptions::default(),
+                .submit_workflow(
+                    ActivityLoadWf::run,
+                    tq.clone(),
+                    WorkflowStartOptions::new(tq, wf_id).build(),
                 )
                 .await
                 .unwrap();
@@ -105,16 +115,56 @@ async fn activity_load() {
     dbg!(running.elapsed());
 }
 
+#[workflow]
+#[derive(Default)]
+struct ChunkyActivityWf;
+
+#[workflow_methods]
+impl ChunkyActivityWf {
+    #[run(name = "chunky_activity_wf")]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        let input_str = "yo".to_string();
+        let res = ctx
+            .start_activity(
+                ChunkyActivities::chunky_echo,
+                input_str.clone(),
+                ActivityOptions {
+                    activity_id: Some("act-1".to_string()),
+                    start_to_close_timeout: Some(Duration::from_secs(30)),
+                    ..Default::default()
+                },
+            )
+            .await?;
+        assert_eq!(res, input_str);
+        Ok(())
+    }
+}
+
+struct ChunkyActivities;
+#[activities]
+impl ChunkyActivities {
+    #[activity]
+    async fn chunky_echo(_ctx: ActivityContext, echo: String) -> Result<String, ActivityError> {
+        tokio::task::spawn_blocking(move || {
+            let mut mem = vec![0_u8; 1000 * 1024 * 1024];
+            for _ in 1..10 {
+                for i in 0..mem.len() {
+                    mem[i] &= mem[mem.len() - 1 - i]
+                }
+            }
+            Ok(echo)
+        })
+        .await?
+    }
+}
+
 #[tokio::test]
 async fn chunky_activities_resource_based() {
     const WORKFLOWS: usize = 100;
 
     let mut starter = CoreWfStarter::new("chunky_activities_resource_based");
-    starter
-        .worker_config
-        .clear_max_outstanding_opts()
-        .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(10_usize))
-        .activity_task_poller_behavior(PollerBehavior::SimpleMaximum(10_usize));
+    starter.sdk_config.workflow_task_poller_behavior = PollerBehavior::SimpleMaximum(10_usize);
+    starter.sdk_config.activity_task_poller_behavior = PollerBehavior::SimpleMaximum(10_usize);
     let mut tuner = ResourceBasedTuner::new(0.7, 0.7);
     tuner
         .with_workflow_slots_options(ResourceSlotOptions::new(
@@ -123,60 +173,27 @@ async fn chunky_activities_resource_based() {
             Duration::from_millis(0),
         ))
         .with_activity_slots_options(ResourceSlotOptions::new(5, 1000, Duration::from_millis(50)));
-    starter.worker_config.tuner(Arc::new(tuner));
-    let mut worker = starter.worker().await;
+    starter.sdk_config.tuner = Arc::new(tuner);
 
-    let activity_id = "act-1";
-    let activity_timeout = Duration::from_secs(30);
-
-    let wf_fn = move |ctx: WfContext| {
-        let payload = "yo".as_json_payload().unwrap();
-        async move {
-            let activity = ActivityOptions {
-                activity_id: Some(activity_id.to_string()),
-                activity_type: "test_activity".to_string(),
-                input: payload.clone(),
-                start_to_close_timeout: Some(activity_timeout),
-                ..Default::default()
-            };
-            let res = ctx.activity(activity).await.unwrap_ok_payload();
-            assert_eq!(res.data, payload.data);
-            Ok(().into())
-        }
-    };
+    starter.sdk_config.register_activities(ChunkyActivities);
+    let task_queue = starter.get_task_queue().to_owned();
+    let mut worker = starter.worker().await;
 
     let starting = Instant::now();
-    let wf_type = "chunky_activity_wf";
-    worker.register_wf(wf_type.to_owned(), wf_fn);
-    worker.register_activity(
-        "test_activity",
-        |_ctx: ActContext, echo: String| async move {
-            tokio::task::spawn_blocking(move || {
-                // Allocate a gig and then do some CPU stuff on it
-                let mut mem = vec![0_u8; 1000 * 1024 * 1024];
-                for _ in 1..10 {
-                    for i in 0..mem.len() {
-                        mem[i] &= mem[mem.len() - 1 - i]
-                    }
-                }
-                Ok(echo)
-            })
-            .await?
-        },
-    );
+    worker.register_workflow::<ChunkyActivityWf>();
     join_all((0..WORKFLOWS).map(|i| {
         let worker = &worker;
         let wf_id = format!("chunk_activity_{i}");
+        let tq = task_queue.clone();
         async move {
             worker
-                .submit_wf(
-                    wf_id,
-                    wf_type.to_owned(),
-                    vec![],
-                    WorkflowOptions {
-                        id_reuse_policy: WorkflowIdReusePolicy::TerminateIfRunning,
-                        ..Default::default()
-                    },
+                .submit_workflow(
+                    ChunkyActivityWf::run,
+                    (),
+                    WorkflowStartOptions::new(tq, wf_id)
+                        .id_conflict_policy(WorkflowIdConflictPolicy::TerminateExisting)
+                        .id_reuse_policy(WorkflowIdReusePolicy::AllowDuplicate)
+                        .build(),
                 )
                 .await
                 .unwrap();
@@ -191,9 +208,37 @@ async fn chunky_activities_resource_based() {
     dbg!(running.elapsed());
 }
 
+#[workflow]
+#[derive(Default)]
+struct WorkflowLoadWf;
+
+#[workflow_methods]
+impl WorkflowLoadWf {
+    #[run(name = "workflow_load")]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        for _ in 0..5 {
+            let _ = ctx
+                .start_activity(
+                    StdActivities::echo,
+                    "hi!".to_string(),
+                    ActivityOptions {
+                        start_to_close_timeout: Some(Duration::from_secs(5)),
+                        ..Default::default()
+                    },
+                )
+                .await;
+            ctx.timer(Duration::from_secs(1)).await;
+        }
+
+        Ok(())
+    }
+
+    #[signal]
+    fn drain_signal(&mut self, _ctx: &mut SyncWorkflowContext<Self>) {}
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
 async fn workflow_load() {
-    const SIGNAME: &str = "signame";
     let num_workflows = 500;
     let wf_name = "workflow_load";
     let (mut telemopts, _, _aborter) = prom_metrics(None);
@@ -203,68 +248,40 @@ async fn workflow_load() {
     init_integ_telem();
     let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let mut starter = CoreWfStarter::new_with_runtime("workflow_load", rt);
-    starter
-        .worker_config
-        .max_outstanding_workflow_tasks(5_usize)
-        .max_cached_workflows(200_usize)
-        .activity_task_poller_behavior(PollerBehavior::SimpleMaximum(10_usize))
-        .max_outstanding_activities(100_usize);
+    starter.sdk_config.max_cached_workflows = 200;
+    starter.sdk_config.activity_task_poller_behavior = PollerBehavior::SimpleMaximum(10);
+    starter.sdk_config.tuner = Arc::new(TunerHolder::fixed_size(5, 100, 100, 100));
+    starter.sdk_config.register_activities(StdActivities);
+    let task_queue = starter.get_task_queue().to_owned();
     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 {
-            for _ in 0..5 {
-                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;
-                ctx.timer(Duration::from_secs(1)).await;
-            }
-        };
-        tokio::select! {
-            _ = drained_fut => {}
-            _ = real_stuff => {}
-        }
-
-        Ok(().into())
-    });
-    worker.register_activity(
-        "echo_activity",
-        |_ctx: ActContext, echo_me: String| async move { Ok(echo_me) },
-    );
-    let client = starter.get_client().await;
+    worker.register_workflow::<WorkflowLoadWf>();
 
     let mut workflow_handles = vec![];
     for i in 0..num_workflows {
         let wfid = format!("{wf_name}_{i}");
-        let rid = worker
-            .submit_wf(
-                wfid.clone(),
-                wf_name.to_owned(),
-                vec![],
-                WorkflowOptions::default(),
+        let handle = worker
+            .submit_workflow(
+                WorkflowLoadWf::run,
+                (),
+                WorkflowStartOptions::new(task_queue.clone(), wfid).build(),
             )
             .await
             .unwrap();
-        workflow_handles.push(client.get_untyped_workflow_handle(wfid, rid));
+        workflow_handles.push(handle);
     }
 
     let sig_sender = async {
         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 sends: FuturesUnordered<_> = workflow_handles
+                .iter()
+                .map(|handle| async move {
+                    handle
+                        .signal(
+                            WorkflowLoadWf::drain_signal,
+                            (),
+                            WorkflowSignalOptions::default(),
+                        )
+                        .await
                 })
                 .collect();
             sends
@@ -282,51 +299,49 @@ async fn workflow_load() {
 async fn evict_while_la_running_no_interference() {
     let wf_name = "evict_while_la_running_no_interference";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter
-        .worker_config
-        .max_outstanding_local_activities(20_usize)
-        .max_cached_workflows(20_usize);
+    starter.sdk_config.max_cached_workflows = 20;
     // Though it doesn't make sense to set wft higher than cached workflows, leaving this commented
     // introduces more instability that can be useful in the test.
     // starter.max_wft(20);
+    starter.sdk_config.tuner = Arc::new(TunerHolder::fixed_size(100, 10, 20, 1));
+    starter.sdk_config.register_activities(StdActivities);
+    let task_queue = starter.get_task_queue().to_owned();
     let mut worker = starter.worker().await;
 
-    worker.register_wf(wf_name.to_owned(), la_problem_workflow);
-    worker.register_activity("delay", |_: ActContext, _: String| async {
-        tokio::time::sleep(Duration::from_secs(15)).await;
-        Ok(())
-    });
+    worker.register_workflow::<LaProblemWorkflow>();
 
     let client = starter.get_client().await;
     let subfs = FuturesUnordered::new();
     for i in 1..100 {
         let wf_id = format!("{wf_name}-{i}");
-        let run_id = worker
-            .submit_wf(
-                &wf_id,
-                wf_name.to_owned(),
-                vec![],
-                WorkflowOptions::default(),
+        let handle = worker
+            .submit_workflow(
+                LaProblemWorkflow::run,
+                (),
+                WorkflowStartOptions::new(task_queue.clone(), wf_id.clone()).build(),
             )
             .await
             .unwrap();
-        let cw = worker.core_worker.clone();
+        let run_id = handle.run_id().unwrap().to_owned();
+        let cw = worker.core_worker();
         let client = client.clone();
         subfs.push(async move {
-            // Evict the workflow
             tokio::time::sleep(Duration::from_secs(1)).await;
             cw.request_workflow_eviction(&run_id);
-            // Wake up workflow by sending signal
-            client
-                .signal_workflow_execution(
-                    wf_id,
-                    run_id.clone(),
-                    "whaatever".to_string(),
-                    None,
-                    None,
-                )
-                .await
-                .unwrap();
+            WorkflowExecutionInfo {
+                namespace: client.namespace(),
+                workflow_id: wf_id,
+                run_id: Some(run_id),
+                first_execution_run_id: None,
+            }
+            .bind_untyped(client)
+            .signal(
+                UntypedSignal::new("whaatever"),
+                RawValue::empty(),
+                WorkflowSignalOptions::default(),
+            )
+            .await
+            .unwrap();
         });
     }
     let runf = async {
@@ -335,49 +350,60 @@ async fn evict_while_la_running_no_interference() {
     tokio::join!(subfs.collect::<Vec<_>>(), runf);
 }
 
-pub async fn many_parallel_timers_longhist(ctx: WfContext) -> WorkflowResult<()> {
-    for _ in 0..120 {
-        let mut futs = vec![];
-        for _ in 0..100 {
-            futs.push(ctx.timer(Duration::from_millis(100)));
+#[workflow]
+#[derive(Default)]
+struct ManyParallelTimersLonghistWf;
+
+#[workflow_methods]
+impl ManyParallelTimersLonghistWf {
+    #[run(name = "can_paginate_long_history")]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        for _ in 0..120 {
+            let mut futs = vec![];
+            for _ in 0..100 {
+                futs.push(ctx.timer(Duration::from_millis(100)));
+            }
+            join_all(futs).await;
         }
-        join_all(futs).await;
+        Ok(())
     }
-    Ok(().into())
 }
 
 #[tokio::test]
 async fn can_paginate_long_history() {
     let wf_name = "can_paginate_long_history";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter
-        .worker_config
-        .task_types(WorkerTaskTypes::workflow_only())
-        // Do not use sticky queues so we are forced to paginate once history gets long
-        .max_cached_workflows(0_usize);
+    starter.sdk_config.task_types = WorkerTaskTypes::workflow_only();
+    starter.sdk_config.max_cached_workflows = 0;
 
     let mut worker = starter.worker().await;
-    worker.register_wf(wf_name.to_owned(), many_parallel_timers_longhist);
-    let run_id = worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
+    worker.register_workflow::<ManyParallelTimersLonghistWf>();
+    let task_queue = starter.get_task_queue().to_owned();
+    let handle = worker
+        .submit_workflow(
+            ManyParallelTimersLonghistWf::run,
+            (),
+            WorkflowStartOptions::new(task_queue, wf_name.to_owned()).build(),
         )
         .await
         .unwrap();
+    let run_id = handle.run_id().unwrap().to_owned();
     let client = starter.get_client().await;
     tokio::spawn(async move {
+        let handle = WorkflowExecutionInfo {
+            namespace: client.namespace(),
+            workflow_id: wf_name.into(),
+            run_id: Some(run_id),
+            first_execution_run_id: None,
+        }
+        .bind_untyped(client);
         loop {
             for _ in 0..10 {
-                client
-                    .signal_workflow_execution(
-                        wf_name.to_owned(),
-                        run_id.clone(),
-                        "sig".to_string(),
-                        None,
-                        None,
+                handle
+                    .signal(
+                        UntypedSignal::new("sig"),
+                        RawValue::empty(),
+                        WorkflowSignalOptions::default(),
                     )
                     .await
                     .unwrap();
@@ -388,84 +414,92 @@ async fn can_paginate_long_history() {
     worker.run_until_done().await.unwrap();
 }
 
+struct JitteryActivities;
+#[activities]
+impl JitteryActivities {
+    #[activity]
+    async fn jittery_echo(_ctx: ActivityContext, echo: String) -> Result<String, ActivityError> {
+        let rand_millis = rand::rng().random_range(0..500);
+        tokio::time::sleep(Duration::from_millis(rand_millis)).await;
+        Ok(echo)
+    }
+}
+
+#[workflow]
+#[derive(Default)]
+struct PollerLoadWf;
+
+#[workflow_methods]
+impl PollerLoadWf {
+    #[run(name = "poller_load")]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        for _ in 0..5 {
+            let _ = ctx
+                .start_activity(
+                    JitteryActivities::jittery_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_autoscaling_basic_loadtest() {
     const SIGNAME: &str = "signame";
     let num_workflows = 100;
     let wf_name = "poller_load";
     let mut starter = CoreWfStarter::new("poller_load");
-    starter
-        .worker_config
-        .max_cached_workflows(5000_usize)
-        .max_outstanding_workflow_tasks(1000_usize)
-        .max_outstanding_activities(1000_usize)
-        .workflow_task_poller_behavior(PollerBehavior::Autoscaling {
-            minimum: 1,
-            maximum: 200,
-            initial: 5,
-        })
-        .activity_task_poller_behavior(PollerBehavior::Autoscaling {
-            minimum: 1,
-            maximum: 200,
-            initial: 5,
-        });
+    starter.sdk_config.max_cached_workflows = 5000;
+    starter.sdk_config.tuner = Arc::new(TunerHolder::fixed_size(1000, 1000, 100, 1));
+    starter.sdk_config.workflow_task_poller_behavior = PollerBehavior::Autoscaling {
+        minimum: 1,
+        maximum: 200,
+        initial: 5,
+    };
+    starter.sdk_config.activity_task_poller_behavior = PollerBehavior::Autoscaling {
+        minimum: 1,
+        maximum: 200,
+        initial: 5,
+    };
+
+    starter.sdk_config.register_activities(JitteryActivities);
     let mut worker = starter.worker().await;
     let shutdown_handle = worker.inner_mut().shutdown_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_workflow::<PollerLoadWf>();
     let client = starter.get_client().await;
 
+    let task_queue = starter.get_task_queue().to_owned();
     let mut workflow_handles = vec![];
     for i in 0..num_workflows {
         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()
-                },
+        let handle = worker
+            .submit_workflow(
+                PollerLoadWf::run,
+                (),
+                WorkflowStartOptions::new(task_queue.clone(), wfid)
+                    .execution_timeout(Duration::from_secs(120))
+                    .build(),
             )
             .await
             .unwrap();
-        workflow_handles.push(client.get_untyped_workflow_handle(wfid, rid));
+        workflow_handles.push(handle);
     }
 
     let (ah, abort_reg) = AbortHandle::new_pair();
     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;
         ah.abort();
@@ -477,13 +511,17 @@ async fn poller_autoscaling_basic_loadtest() {
             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