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

package/sdk-core/crates/sdk-core/tests/common/workflows.rs

@@ -1,31 +1,44 @@
+use crate::common::activity_functions::StdActivities;
 use std::time::Duration;
-use temporalio_common::{
-    prost_dur,
-    protos::{coresdk::AsJsonPayloadExt, temporal::api::common::v1::RetryPolicy},
-};
-use temporalio_sdk::{ActivityOptions, LocalActivityOptions, WfContext, WorkflowResult};
+use temporalio_common::{prost_dur, protos::temporal::api::common::v1::RetryPolicy};
+use temporalio_macros::{workflow, workflow_methods};
+use temporalio_sdk::{ActivityOptions, LocalActivityOptions, WorkflowContext, WorkflowResult};
 
-pub(crate) async fn la_problem_workflow(ctx: WfContext) -> WorkflowResult<()> {
-    ctx.local_activity(LocalActivityOptions {
-        activity_type: "delay".to_string(),
-        input: "hi".as_json_payload().expect("serializes fine"),
-        retry_policy: RetryPolicy {
-            initial_interval: Some(prost_dur!(from_micros(15))),
-            backoff_coefficient: 1_000.,
-            maximum_interval: Some(prost_dur!(from_millis(1500))),
-            maximum_attempts: 4,
-            non_retryable_error_types: vec![],
-        },
-        timer_backoff_threshold: Some(Duration::from_secs(1)),
-        ..Default::default()
-    })
-    .await;
-    ctx.activity(ActivityOptions {
-        activity_type: "delay".to_string(),
-        start_to_close_timeout: Some(Duration::from_secs(20)),
-        input: "hi!".as_json_payload().expect("serializes fine"),
-        ..Default::default()
-    })
-    .await;
-    Ok(().into())
+#[workflow]
+#[derive(Default)]
+pub(crate) struct LaProblemWorkflow;
+
+#[workflow_methods]
+impl LaProblemWorkflow {
+    #[run(name = "evict_while_la_running_no_interference")]
+    pub(crate) async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        ctx.start_local_activity(
+            StdActivities::delay,
+            Duration::from_secs(15),
+            LocalActivityOptions {
+                retry_policy: RetryPolicy {
+                    initial_interval: Some(prost_dur!(from_micros(15))),
+                    backoff_coefficient: 1_000.,
+                    maximum_interval: Some(prost_dur!(from_millis(1500))),
+                    maximum_attempts: 4,
+                    non_retryable_error_types: vec![],
+                },
+                timer_backoff_threshold: Some(Duration::from_secs(1)),
+                ..Default::default()
+            },
+        )
+        .await
+        .map_err(|e| anyhow::anyhow!("{e}"))?;
+        ctx.start_activity(
+            StdActivities::delay,
+            Duration::from_secs(15),
+            ActivityOptions {
+                start_to_close_timeout: Some(Duration::from_secs(20)),
+                ..Default::default()
+            },
+        )
+        .await
+        .map_err(|e| anyhow::anyhow!("{e}"))?;
+        Ok(())
+    }
 }

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

@@ -7,12 +7,10 @@ use common::CoreWfStarter;
 use parking_lot::Mutex;
 use std::{sync::Arc, time::Duration};
 use temporalio_common::telemetry::{
-    Logger, OtelCollectorOptionsBuilder, TelemetryOptionsBuilder, metrics::CoreMeter,
-};
-use temporalio_sdk_core::{
-    CoreRuntime,
-    telemetry::{build_otlp_metric_exporter, construct_filter_string, telemetry_init_global},
+    Logger, OtelCollectorOptions, TelemetryOptions, build_otlp_metric_exporter,
+    construct_filter_string, metrics::CoreMeter, telemetry_init_global,
 };
+use temporalio_sdk_core::CoreRuntime;
 use tracing::Level;
 use tracing_subscriber::fmt::MakeWriter;
 
@@ -58,28 +56,25 @@ async fn otel_errors_logged_as_errors() {
             .with_env_filter("debug")
             .finish(),
     );
-    let opts = OtelCollectorOptionsBuilder::default()
+    let opts = OtelCollectorOptions::builder()
         .url("https://localhost:12345/v1/metrics".parse().unwrap()) // Nothing bound on that port
-        .build()
-        .unwrap();
+        .build();
     let exporter = build_otlp_metric_exporter(opts).unwrap();
 
     // Global initialization is needed to capture (some) otel logging.
     telemetry_init_global(
-        TelemetryOptionsBuilder::default()
+        TelemetryOptions::builder()
             .subscriber_override(subscriber)
-            .build()
-            .unwrap(),
+            .build(),
     )
     .unwrap();
-    let telemopts = TelemetryOptionsBuilder::default()
+    let telemopts = TelemetryOptions::builder()
         .metrics(Arc::new(exporter) as Arc<dyn CoreMeter>)
         // Importantly, _not_ using subscriber override, is using console.
         .logging(Logger::Console {
             filter: construct_filter_string(Level::INFO, Level::WARN),
         })
-        .build()
-        .unwrap();
+        .build();
 
     let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let mut starter = CoreWfStarter::new_with_runtime("otel_errors_logged_as_errors", rt);

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

@@ -1,13 +1,14 @@
-use crate::common::CoreWfStarter;
-use futures_util::{FutureExt, StreamExt, sink, stream::FuturesUnordered};
+use crate::common::{CoreWfStarter, activity_functions::StdActivities};
+use futures_util::{StreamExt, sink, stream::FuturesUnordered};
 use rand::{Rng, SeedableRng, prelude::Distribution, rngs::SmallRng};
-use std::{future, time::Duration};
-use temporalio_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions};
-use temporalio_common::protos::coresdk::{AsJsonPayloadExt, FromJsonPayloadExt, IntoPayloadsExt};
-use temporalio_sdk::{
-    ActContext, ActivityError, ActivityOptions, LocalActivityOptions, WfContext, WorkflowResult,
+use std::{sync::Arc, time::Duration};
+use temporalio_client::{
+    UntypedSignal, UntypedWorkflow, WorkflowSignalOptions, WorkflowStartOptions,
 };
-use tokio_util::sync::CancellationToken;
+use temporalio_common::{data_converters::RawValue, protos::coresdk::AsJsonPayloadExt};
+use temporalio_macros::{workflow, workflow_methods};
+use temporalio_sdk::{ActivityOptions, LocalActivityOptions, WorkflowContext, WorkflowResult};
+use temporalio_sdk_core::TunerHolder;
 
 const FUZZY_SIG: &str = "fuzzy_sig";
 
@@ -30,46 +31,50 @@ impl Distribution<FuzzyWfAction> for FuzzyWfActionSampler {
     }
 }
 
-async fn echo(_ctx: ActContext, echo_me: String) -> Result<String, ActivityError> {
-    Ok(echo_me)
+#[workflow]
+#[derive(Default)]
+struct FuzzyWf {
+    done: bool,
 }
 
-async fn fuzzy_wf_def(ctx: WfContext) -> WorkflowResult<()> {
-    let sigchan = ctx
-        .make_signal_channel(FUZZY_SIG)
-        .map(|sd| FuzzyWfAction::from_json_payload(&sd.input[0]).expect("Can deserialize signal"));
-    let done = CancellationToken::new();
-    let done_setter = done.clone();
+#[workflow_methods]
+impl FuzzyWf {
+    #[run(name = "fuzzy_wf")]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        ctx.wait_condition(|s| s.done).await;
+        Ok(())
+    }
 
-    sigchan
-        .take_until(done.cancelled())
-        .for_each_concurrent(None, |action| match action {
-            FuzzyWfAction::DoAct => 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()
-                })
-                .map(|_| ())
-                .boxed(),
-            FuzzyWfAction::DoLocalAct => ctx
-                .local_activity(LocalActivityOptions {
-                    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()
-                })
-                .map(|_| ())
-                .boxed(),
-            FuzzyWfAction::Shutdown => {
-                done_setter.cancel();
-                future::ready(()).boxed()
+    #[signal(name = "fuzzy_sig")]
+    async fn fuzzy_signal(ctx: &mut WorkflowContext<Self>, action: FuzzyWfAction) {
+        match action {
+            FuzzyWfAction::Shutdown => ctx.state_mut(|s| s.done = true),
+            FuzzyWfAction::DoAct => {
+                let _ = ctx
+                    .start_activity(
+                        StdActivities::echo,
+                        "hi!".to_string(),
+                        ActivityOptions {
+                            start_to_close_timeout: Some(Duration::from_secs(5)),
+                            ..Default::default()
+                        },
+                    )
+                    .await;
             }
-        })
-        .await;
-
-    Ok(().into())
+            FuzzyWfAction::DoLocalAct => {
+                let _ = ctx
+                    .start_local_activity(
+                        StdActivities::echo,
+                        "hi!".to_string(),
+                        LocalActivityOptions {
+                            start_to_close_timeout: Some(Duration::from_secs(5)),
+                            ..Default::default()
+                        },
+                    )
+                    .await;
+            }
+        }
+    }
 }
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
@@ -77,29 +82,25 @@ async fn fuzzy_workflow() {
     let num_workflows = 200;
     let wf_name = "fuzzy_wf";
     let mut starter = CoreWfStarter::new("fuzzy_workflow");
-    starter
-        .worker_config
-        .max_outstanding_workflow_tasks(25_usize)
-        .max_cached_workflows(25_usize)
-        .max_outstanding_activities(25_usize);
+    starter.sdk_config.max_cached_workflows = 25;
+    starter.sdk_config.tuner = Arc::new(TunerHolder::fixed_size(25, 25, 100, 100));
     let mut worker = starter.worker().await;
-    worker.register_wf(wf_name.to_owned(), fuzzy_wf_def);
-    worker.register_activity("echo_activity", echo);
+    worker.register_workflow::<FuzzyWf>();
+    worker.register_activities(StdActivities);
+
     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}");
-        let rid = worker
-            .submit_wf(
-                wfid.clone(),
-                wf_name.to_owned(),
-                vec![],
-                WorkflowOptions::default(),
+        worker
+            .submit_workflow(
+                FuzzyWf::run,
+                (),
+                WorkflowStartOptions::new(task_queue.clone(), wfid).build(),
             )
             .await
             .unwrap();
-        workflow_handles.push(client.get_untyped_workflow_handle(wfid, rid));
     }
 
     let rng = SmallRng::seed_from_u64(523189);
@@ -110,13 +111,19 @@ async fn fuzzy_workflow() {
         for action in actions {
             let sends: FuturesUnordered<_> = (0..num_workflows)
                 .map(|i| {
-                    client.signal_workflow_execution(
-                        format!("{wf_name}_{i}"),
-                        "".to_string(),
-                        FUZZY_SIG.to_string(),
-                        [action.as_json_payload().expect("Serializes ok")].into_payloads(),
-                        None,
-                    )
+                    let handle =
+                        client.get_workflow_handle::<UntypedWorkflow>(format!("{wf_name}_{i}"));
+                    async move {
+                        handle
+                            .signal(
+                                UntypedSignal::new(FUZZY_SIG),
+                                RawValue::new(vec![
+                                    action.as_json_payload().expect("Serializes ok"),
+                                ]),
+                                WorkflowSignalOptions::default(),
+                            )
+                            .await
+                    }
                 })
                 .collect();
             sends