@temporalio/core-bridge 1.13.1 → 1.14.0

package/sdk-core/{tests → crates/sdk-core/tests}/manual_tests.rs

@@ -1,6 +1,12 @@
 //! These tests are expensive and meant to be run manually. Use them for things like perf and
 //! load testing.
 
+// All non-main.rs tests ignore dead common code so that the linter doesn't complain about about it.
+#[allow(dead_code)]
+mod common;
+
+use crate::common::get_integ_runtime_options;
+use common::{CoreWfStarter, prom_metrics, rand_6_chars};
 use futures_util::{
     StreamExt,
     future::{AbortHandle, Abortable},
@@ -13,12 +19,16 @@ use std::{
     net::SocketAddr,
     time::{Duration, Instant},
 };
-use temporal_client::{GetWorkflowResultOpts, WfClientExt, WorkflowClientTrait, WorkflowOptions};
-use temporal_sdk::{ActContext, ActivityOptions, WfContext};
-use temporal_sdk_core::CoreRuntime;
-use temporal_sdk_core_api::{telemetry::PrometheusExporterOptionsBuilder, worker::PollerBehavior};
-use temporal_sdk_core_protos::coresdk::AsJsonPayloadExt;
-use temporal_sdk_core_test_utils::{CoreWfStarter, prom_metrics, rand_6_chars};
+use temporalio_client::{
+    GetWorkflowResultOptions, WfClientExt, WorkflowClientTrait, WorkflowOptions,
+};
+use temporalio_common::{
+    protos::coresdk::AsJsonPayloadExt,
+    telemetry::PrometheusExporterOptionsBuilder,
+    worker::{PollerBehavior, WorkerTaskTypes},
+};
+use temporalio_sdk::{ActContext, ActivityOptions, WfContext};
+use temporalio_sdk_core::CoreRuntime;
 use tracing::info;
 
 #[tokio::test]
@@ -37,7 +47,7 @@ async fn poller_load_spiky() {
         } else {
             prom_metrics(None)
         };
-    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    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
@@ -114,7 +124,7 @@ async fn poller_load_spiky() {
         stream::iter(mem::take(&mut workflow_handles))
             .for_each_concurrent(25, |handle| async move {
                 let _ = handle
-                    .get_workflow_result(GetWorkflowResultOpts::default())
+                    .get_workflow_result(GetWorkflowResultOptions::default())
                     .await;
             })
             .await;
@@ -143,7 +153,7 @@ async fn poller_load_spiky() {
         stream::iter(workflow_handles)
             .for_each_concurrent(25, |handle| async move {
                 let _ = handle
-                    .get_workflow_result(GetWorkflowResultOpts::default())
+                    .get_workflow_result(GetWorkflowResultOptions::default())
                     .await;
             })
             .await;
@@ -196,7 +206,7 @@ async fn poller_load_sustained() {
         } else {
             prom_metrics(None)
         };
-    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    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
@@ -207,7 +217,7 @@ async fn poller_load_sustained() {
             maximum: 200,
             initial: 5,
         })
-        .no_remote_activities(true);
+        .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);
@@ -257,7 +267,7 @@ async fn poller_load_sustained() {
         stream::iter(mem::take(&mut workflow_handles))
             .for_each_concurrent(25, |handle| async move {
                 let _ = handle
-                    .get_workflow_result(GetWorkflowResultOpts::default())
+                    .get_workflow_result(GetWorkflowResultOptions::default())
                     .await;
             })
             .await;
@@ -287,7 +297,7 @@ async fn poller_load_spike_then_sustained() {
         } else {
             prom_metrics(None)
         };
-    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    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
@@ -363,7 +373,7 @@ async fn poller_load_spike_then_sustained() {
         stream::iter(mem::take(&mut workflow_handles))
             .for_each_concurrent(25, |handle| async move {
                 let _ = handle
-                    .get_workflow_result(GetWorkflowResultOpts::default())
+                    .get_workflow_result(GetWorkflowResultOptions::default())
                     .await;
             })
             .await;
@@ -392,7 +402,7 @@ async fn poller_load_spike_then_sustained() {
         stream::iter(workflow_handles)
             .for_each_concurrent(25, |handle| async move {
                 let _ = handle
-                    .get_workflow_result(GetWorkflowResultOpts::default())
+                    .get_workflow_result(GetWorkflowResultOptions::default())
                     .await;
             })
             .await;

package/sdk-core/{tests → crates/sdk-core/tests}/runner.rs

@@ -1,19 +1,24 @@
+// All non-main.rs tests ignore dead common code so that the linter doesn't complain about about it.
+#[allow(dead_code)]
+mod common;
+
+use crate::common::integ_dev_server_config;
 use anyhow::{anyhow, bail};
 use clap::Parser;
+use common::INTEG_SERVER_TARGET_ENV_VAR;
 use std::{
     env,
     path::{Path, PathBuf},
     process::Stdio,
 };
-use temporal_sdk_core::ephemeral_server::{
-    EphemeralExe, EphemeralExeVersion, TemporalDevServerConfigBuilder, TestServerConfigBuilder,
-};
-use temporal_sdk_core_test_utils::{
-    INTEG_SERVER_TARGET_ENV_VAR, INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR,
-    INTEG_TEST_SERVER_USED_ENV_VAR, SEARCH_ATTR_INT, SEARCH_ATTR_TXT, default_cached_download,
-};
+use temporalio_sdk_core::ephemeral_server::{TestServerConfigBuilder, default_cached_download};
 use tokio::{self, process::Command};
 
+/// This env var is set (to any value) if temporal CLI dev server is in use
+const INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR: &str = "INTEG_TEMPORAL_DEV_SERVER_ON";
+/// This env var is set (to any value) if the test server is in use
+const INTEG_TEST_SERVER_USED_ENV_VAR: &str = "INTEG_TEST_SERVER_ON";
+
 #[derive(clap::Parser)]
 #[command(author, version, about, long_about = None)]
 struct Cli {
@@ -58,10 +63,15 @@ async fn main() -> Result<(), anyhow::Error> {
     } = Cli::parse();
     let cargo = env::var("CARGO").unwrap_or_else(|_| "cargo".to_string());
     // Try building first, so that we error early on build failures & don't start server
+    // Unclear why --all-features doesn't work here
     let test_args_preamble = [
         "test",
         "--features",
-        "temporal-sdk-core-protos/serde_serialize",
+        "temporalio-common/serde_serialize",
+        "--features",
+        "test-utilities",
+        "--features",
+        "ephemeral-server",
         "--test",
         &test_name,
     ]
@@ -84,39 +94,11 @@ async fn main() -> Result<(), anyhow::Error> {
 
     let (server, envs) = match server_kind {
         ServerKind::TemporalCLI => {
-            let cli_version = if let Some(ver_override) = option_env!("CLI_VERSION_OVERRIDE") {
-                EphemeralExe::CachedDownload {
-                    version: EphemeralExeVersion::Fixed(ver_override.to_owned()),
-                    dest_dir: None,
-                    ttl: None,
-                }
-            } else {
-                default_cached_download()
-            };
-            let config = TemporalDevServerConfigBuilder::default()
-                .exe(cli_version)
-                .extra_args(vec![
-                    // TODO: Delete when temporalCLI enables it by default.
-                    "--dynamic-config-value".to_string(),
-                    "system.enableEagerWorkflowStart=true".to_string(),
-                    "--dynamic-config-value".to_string(),
-                    "system.enableNexus=true".to_string(),
-                    "--dynamic-config-value".to_owned(),
-                    "frontend.workerVersioningWorkflowAPIs=true".to_owned(),
-                    "--dynamic-config-value".to_owned(),
-                    "frontend.workerVersioningDataAPIs=true".to_owned(),
-                    "--dynamic-config-value".to_owned(),
-                    "system.enableDeploymentVersions=true".to_owned(),
-                    "--http-port".to_string(),
-                    "7243".to_string(),
-                    "--search-attribute".to_string(),
-                    format!("{SEARCH_ATTR_TXT}=Text"),
-                    "--search-attribute".to_string(),
-                    format!("{SEARCH_ATTR_INT}=Int"),
-                ])
-                .ui(true)
-                .build()?;
-            println!("Using temporal CLI: {:?}", config);
+            let config =
+                integ_dev_server_config(vec!["--http-port".to_string(), "7243".to_string()])
+                    .ui(true)
+                    .build()?;
+            println!("Using temporal CLI: {config:?}");
             (
                 Some(
                     config

package/sdk-core/{tests → crates/sdk-core/tests}/shared_tests/mod.rs

@@ -1,12 +1,15 @@
 //! Shared tests that are meant to be run against both local dev server and cloud
 
+use crate::common::CoreWfStarter;
 use std::sync::atomic::{AtomicBool, Ordering::Relaxed};
-use temporal_sdk::WfContext;
-use temporal_sdk_core_protos::temporal::api::{
-    enums::v1::{EventType, WorkflowTaskFailedCause::GrpcMessageTooLarge},
-    history::v1::history_event::Attributes::WorkflowTaskFailedEventAttributes,
+use temporalio_common::{
+    protos::temporal::api::{
+        enums::v1::{EventType, WorkflowTaskFailedCause::GrpcMessageTooLarge},
+        history::v1::history_event::Attributes::WorkflowTaskFailedEventAttributes,
+    },
+    worker::WorkerTaskTypes,
 };
-use temporal_sdk_core_test_utils::CoreWfStarter;
+use temporalio_sdk::WfContext;
 
 pub(crate) mod priority;
 
@@ -15,7 +18,9 @@ pub(crate) async fn grpc_message_too_large() {
     let mut starter = CoreWfStarter::new_cloud_or_local(wf_name, "")
         .await
         .unwrap();
-    starter.worker_config.no_remote_activities(true);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
     let mut core = starter.worker().await;
 
     static OVERSIZE_GRPC_MESSAGE_RUN: AtomicBool = AtomicBool::new(false);

package/sdk-core/{tests → crates/sdk-core/tests}/shared_tests/priority.rs

@@ -1,13 +1,13 @@
+use crate::common::CoreWfStarter;
 use std::time::Duration;
-use temporal_client::{
-    GetWorkflowResultOpts, Priority, WfClientExt, WorkflowClientTrait, WorkflowOptions,
+use temporalio_client::{
+    GetWorkflowResultOptions, Priority, WfClientExt, WorkflowClientTrait, WorkflowOptions,
 };
-use temporal_sdk::{ActContext, ActivityOptions, ChildWorkflowOptions, WfContext};
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     coresdk::AsJsonPayloadExt,
     temporal::api::{common, history::v1::history_event::Attributes},
 };
-use temporal_sdk_core_test_utils::CoreWfStarter;
+use temporalio_sdk::{ActContext, ActivityOptions, ChildWorkflowOptions, WfContext};
 
 pub(crate) async fn priority_values_sent_to_server() {
     let mut starter = if let Some(wfs) =
@@ -93,7 +93,7 @@ pub(crate) async fn priority_values_sent_to_server() {
     let client = starter.get_client().await;
     let handle = client.get_untyped_workflow_handle(starter.get_task_queue(), "");
     let res = handle
-        .get_workflow_result(GetWorkflowResultOpts::default())
+        .get_workflow_result(GetWorkflowResultOptions::default())
         .await
         .unwrap();
     // Expect workflow success

package/sdk-core/crates/sdk-core-c-bridge/Cargo.toml

@@ -0,0 +1,59 @@
+[package]
+name = "temporalio-sdk-core-c-bridge"
+version = "0.1.0"
+edition = "2024"
+authors = ["Spencer Judge <spencer@temporal.io>"]
+license-file = { workspace = true }
+description = "C bridge for Temporal Core SDK"
+homepage = "https://temporal.io/"
+repository = "https://github.com/temporalio/sdk-core"
+
+[lib]
+name = "temporalio_sdk_core_c_bridge"
+crate-type = ["cdylib"]
+
+[dependencies]
+anyhow = "1.0"
+async-trait = "0.1"
+crossbeam-utils = "0.8"
+futures-util = { version = "0.3", default-features = false }
+http = "1.3"
+libc = "0.2"
+prost = { workspace = true }
+# We rely on Cargo semver rules not updating a 0.x to 0.y. Per the rand
+# documentation, before 1.0, minor 0.x updates _can_ break portability which can
+# cause non-determinism.
+rand = "0.9.2"
+rand_pcg = "0.9.0"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+tokio = "1.47"
+tokio-stream = "0.1"
+tokio-util = "0.7"
+tonic = { workspace = true }
+tracing = "0.1"
+url = "2.5"
+# This is only needed as an explicit dependency so we can enable static as a feature
+xz2 = { version = "0.1" }
+
+[dependencies.temporalio-client]
+path = "../client"
+
+[dependencies.temporalio-sdk-core]
+path = "../sdk-core"
+features = ["ephemeral-server"]
+
+[dependencies.temporalio-common]
+path = "../common"
+features = ["envconfig"]
+
+[dev-dependencies]
+futures-util = "0.3"
+thiserror = { workspace = true }
+
+[build-dependencies]
+cbindgen = { version = "0.29", default-features = false }
+
+[features]
+antithesis_assertions = ["temporalio-sdk-core/antithesis_assertions"]
+xz2-static = ["xz2/static"]