@temporalio/core-bridge 1.13.0 → 1.13.2

package/sdk-core/client/src/replaceable.rs

@@ -0,0 +1,253 @@
+use crate::NamespacedClient;
+use std::{
+    borrow::Cow,
+    sync::{
+        Arc, RwLock,
+        atomic::{AtomicU32, Ordering},
+    },
+};
+
+/// A client wrapper that allows replacing the underlying client at a later point in time.
+/// Clones of this struct have a shared reference to the underlying client, and each clone also
+/// has its own cached clone of the underlying client. Before every service call, a check is made
+/// whether the shared client was replaced, and the cached clone is updated accordingly.
+///
+/// This struct is fully thread-safe, and it works in a lock-free manner except when the client is
+/// being replaced. A read-write lock is used then, with minimal locking time.
+#[derive(Debug)]
+pub struct SharedReplaceableClient<C>
+where
+    C: Clone + Send + Sync,
+{
+    shared_data: Arc<SharedClientData<C>>,
+    cloned_client: C,
+    cloned_generation: u32,
+}
+
+#[derive(Debug)]
+struct SharedClientData<C>
+where
+    C: Clone + Send + Sync,
+{
+    client: RwLock<C>,
+    generation: AtomicU32,
+}
+
+impl<C> SharedClientData<C>
+where
+    C: Clone + Send + Sync,
+{
+    fn fetch(&self) -> (C, u32) {
+        let lock = self.client.read().unwrap();
+        let client = lock.clone();
+        // Loading generation under lock to ensure the client won't be updated in the meantime.
+        let generation = self.generation.load(Ordering::Acquire);
+        (client, generation)
+    }
+
+    fn fetch_newer_than(&self, current_generation: u32) -> Option<(C, u32)> {
+        // fetch() will do a second atomic load, but it's necessary to avoid a race condition.
+        (current_generation != self.generation.load(Ordering::Acquire)).then(|| self.fetch())
+    }
+
+    fn replace_client(&self, client: C) {
+        let mut lock = self.client.write().unwrap();
+        *lock = client;
+        // Updating generation under lock to guarantee consistency when multiple threads replace the
+        // client at the same time. The client stored last is always the one with latest generation.
+        self.generation.fetch_add(1, Ordering::AcqRel);
+    }
+}
+
+impl<C> SharedReplaceableClient<C>
+where
+    C: Clone + Send + Sync,
+{
+    /// Creates the initial instance of replaceable client with the provided underlying client.
+    /// Use [`clone()`](Self::clone) method to create more instances that share the same underlying client.
+    pub fn new(client: C) -> Self {
+        let cloned_client = client.clone();
+        Self {
+            shared_data: Arc::new(SharedClientData {
+                client: RwLock::new(client),
+                generation: AtomicU32::new(0),
+            }),
+            cloned_client,
+            cloned_generation: 0,
+        }
+    }
+
+    /// Replaces the client for all instances that share this instance's underlying client.
+    pub fn replace_client(&self, new_client: C) {
+        self.shared_data.replace_client(new_client); // cloned_client will be updated on next mutable call
+    }
+
+    /// Returns a clone of the underlying client.
+    pub fn inner_clone(&self) -> C {
+        self.inner_cow().into_owned()
+    }
+
+    /// Returns an immutable reference to this instance's cached clone of the underlying client if
+    /// it's up to date, or a fresh clone of the shared client otherwise. Because it's an immutable
+    /// method, it will not update this instance's cached clone. For this reason, prefer to use
+    /// [`inner_mut_refreshed()`](Self::inner_mut_refreshed) when possible.
+    pub fn inner_cow(&self) -> Cow<'_, C> {
+        self.shared_data
+            .fetch_newer_than(self.cloned_generation)
+            .map(|(c, _)| Cow::Owned(c))
+            .unwrap_or_else(|| Cow::Borrowed(&self.cloned_client))
+    }
+
+    /// Returns a mutable reference to this instance's cached clone of the underlying client. If the
+    /// cached clone is not up to date, it's refreshed before the reference is returned. This method
+    /// is called automatically by most other mutable methods, in particular by all service calls,
+    /// so most of the time it doesn't need to be called directly.
+    ///
+    /// While this method allows mutable access to the underlying client, any configuration changes
+    /// will not be shared with other instances, and will be lost if the client gets replaced from
+    /// anywhere. To make configuration changes, use [`replace_client()`](Self::replace_client) instead.
+    pub fn inner_mut_refreshed(&mut self) -> &mut C {
+        if let Some((client, generation)) =
+            self.shared_data.fetch_newer_than(self.cloned_generation)
+        {
+            self.cloned_client = client;
+            self.cloned_generation = generation;
+        }
+        &mut self.cloned_client
+    }
+}
+
+impl<C> Clone for SharedReplaceableClient<C>
+where
+    C: Clone + Send + Sync,
+{
+    /// Creates a new instance of replaceable client that shares the underlying client with this
+    /// instance. Replacing a client in either instance will replace it for both instances, and all
+    /// other clones too.
+    fn clone(&self) -> Self {
+        // self's cloned_client could've been modified through a mutable reference,
+        // so for consistent behavior, we need to fetch it from shared_data.
+        let (client, generation) = self.shared_data.fetch();
+        Self {
+            shared_data: self.shared_data.clone(),
+            cloned_client: client,
+            cloned_generation: generation,
+        }
+    }
+}
+
+impl<C> NamespacedClient for SharedReplaceableClient<C>
+where
+    C: NamespacedClient + Clone + Send + Sync,
+{
+    fn namespace(&self) -> String {
+        self.inner_cow().namespace()
+    }
+
+    fn identity(&self) -> String {
+        self.inner_cow().identity()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::NamespacedClient;
+    use std::borrow::Cow;
+
+    #[derive(Debug, Clone)]
+    struct StubClient {
+        identity: String,
+    }
+
+    impl StubClient {
+        fn new(identity: &str) -> Self {
+            Self {
+                identity: identity.to_owned(),
+            }
+        }
+    }
+
+    impl NamespacedClient for StubClient {
+        fn namespace(&self) -> String {
+            "default".into()
+        }
+
+        fn identity(&self) -> String {
+            self.identity.clone()
+        }
+    }
+
+    #[test]
+    fn cow_returns_reference_before_and_clone_after_refresh() {
+        let mut client = SharedReplaceableClient::new(StubClient::new("1"));
+        let Cow::Borrowed(inner) = client.inner_cow() else {
+            panic!("expected borrowed inner");
+        };
+        assert_eq!(inner.identity, "1");
+
+        client.replace_client(StubClient::new("2"));
+        let Cow::Owned(inner) = client.inner_cow() else {
+            panic!("expected owned inner");
+        };
+        assert_eq!(inner.identity, "2");
+
+        assert_eq!(client.inner_mut_refreshed().identity, "2");
+        let Cow::Borrowed(inner) = client.inner_cow() else {
+            panic!("expected borrowed inner");
+        };
+        assert_eq!(inner.identity, "2");
+    }
+
+    #[test]
+    fn client_replaced_in_clones() {
+        let original1 = SharedReplaceableClient::new(StubClient::new("1"));
+        let clone1 = original1.clone();
+        assert_eq!(original1.identity(), "1");
+        assert_eq!(clone1.identity(), "1");
+
+        original1.replace_client(StubClient::new("2"));
+        assert_eq!(original1.identity(), "2");
+        assert_eq!(clone1.identity(), "2");
+
+        let original2 = SharedReplaceableClient::new(StubClient::new("3"));
+        let clone2 = original2.clone();
+        assert_eq!(original2.identity(), "3");
+        assert_eq!(clone2.identity(), "3");
+
+        clone2.replace_client(StubClient::new("4"));
+        assert_eq!(original2.identity(), "4");
+        assert_eq!(clone2.identity(), "4");
+        assert_eq!(original1.identity(), "2");
+        assert_eq!(clone1.identity(), "2");
+    }
+
+    #[test]
+    fn client_replaced_from_multiple_threads() {
+        let mut client = SharedReplaceableClient::new(StubClient::new("original"));
+        std::thread::scope(|scope| {
+            for thread_no in 0..100 {
+                let mut client = client.clone();
+                scope.spawn(move || {
+                    for i in 0..1000 {
+                        let old_generation = client.cloned_generation;
+                        client.inner_mut_refreshed();
+                        let current_generation = client.cloned_generation;
+                        assert!(current_generation >= old_generation);
+                        let replace_identity = format!("{thread_no}-{i}");
+                        client.replace_client(StubClient::new(&replace_identity));
+                        client.inner_mut_refreshed();
+                        assert!(client.cloned_generation > current_generation);
+                        let refreshed_identity = client.identity();
+                        if refreshed_identity.split('-').next().unwrap() == thread_no.to_string() {
+                            assert_eq!(replace_identity, refreshed_identity);
+                        }
+                    }
+                });
+            }
+        });
+        client.inner_mut_refreshed();
+        assert_eq!(client.cloned_generation, 100_000);
+        assert!(client.identity().ends_with("-999"));
+    }
+}

package/sdk-core/client/src/retry.rs

@@ -1,5 +1,5 @@
 use crate::{
-    Client, ERROR_RETURNED_DUE_TO_SHORT_CIRCUIT, IsWorkerTaskLongPoll, MESSAGE_TOO_LARGE_KEY,
+    ERROR_RETURNED_DUE_TO_SHORT_CIRCUIT, IsWorkerTaskLongPoll, MESSAGE_TOO_LARGE_KEY,
     NamespacedClient, NoRetryOnMatching, Result, RetryConfig, raw::IsUserLongPoll,
 };
 use backoff::{Clock, SystemClock, backoff::Backoff, exponential::ExponentialBackoff};
@@ -98,13 +98,16 @@ impl<SG> RetryClient<SG> {
     }
 }
 
-impl NamespacedClient for RetryClient<Client> {
-    fn namespace(&self) -> &str {
-        &self.client.namespace
+impl<SG> NamespacedClient for RetryClient<SG>
+where
+    SG: NamespacedClient,
+{
+    fn namespace(&self) -> String {
+        self.client.namespace()
     }
 
-    fn get_identity(&self) -> &str {
-        &self.client.options().identity
+    fn identity(&self) -> String {
+        self.client.identity()
     }
 }
 

package/sdk-core/client/src/worker_registry/mod.rs

@@ -22,6 +22,8 @@ pub trait SlotProvider: std::fmt::Debug {
     fn task_queue(&self) -> &str;
     /// Try to reserve a slot on this worker.
     fn try_reserve_wft_slot(&self) -> Option<Box<dyn Slot + Send>>;
+    /// Get the worker deployment options for this worker, if using deployment-based versioning.
+    fn deployment_options(&self) -> Option<temporal_sdk_core_api::worker::WorkerDeploymentOptions>;
 }
 
 /// This trait represents a slot reserved for processing a WFT by a worker.
@@ -34,6 +36,14 @@ pub trait Slot {
     ) -> Result<(), anyhow::Error>;
 }
 
+/// Result of reserving a workflow task slot, including deployment options if applicable.
+pub(crate) struct SlotReservation {
+    /// The reserved slot for processing the workflow task
+    pub slot: Box<dyn Slot + Send>,
+    /// Worker deployment options, if the worker is using deployment-based versioning
+    pub deployment_options: Option<temporal_sdk_core_api::worker::WorkerDeploymentOptions>,
+}
+
 #[derive(PartialEq, Eq, Hash, Debug, Clone)]
 struct SlotKey {
     namespace: String,
@@ -71,12 +81,16 @@ impl SlotManagerImpl {
         &self,
         namespace: String,
         task_queue: String,
-    ) -> Option<Box<dyn Slot + Send>> {
+    ) -> Option<SlotReservation> {
         let key = SlotKey::new(namespace, task_queue);
         if let Some(p) = self.providers.get(&key)
             && let Some(slot) = p.try_reserve_wft_slot()
         {
-            return Some(slot);
+            let deployment_options = p.deployment_options();
+            return Some(SlotReservation {
+                slot,
+                deployment_options,
+            });
         }
         None
     }
@@ -126,11 +140,12 @@ impl SlotManager {
     }
 
     /// Try to reserve a compatible processing slot in any of the registered workers.
+    /// Returns the slot and the worker's deployment options (if using deployment-based versioning).
     pub(crate) fn try_reserve_wft_slot(
         &self,
         namespace: String,
         task_queue: String,
-    ) -> Option<Box<dyn Slot + Send>> {
+    ) -> Option<SlotReservation> {
         self.manager
             .read()
             .try_reserve_wft_slot(namespace, task_queue)
@@ -188,6 +203,7 @@ mod tests {
             });
         mock_provider.expect_namespace().return_const(namespace);
         mock_provider.expect_task_queue().return_const(task_queue);
+        mock_provider.expect_deployment_options().return_const(None);
         mock_provider
     }
 

package/sdk-core/client/src/workflow_handle/mod.rs

@@ -1,4 +1,4 @@
-use crate::{InterceptedMetricsSvc, RawClientLike, WorkflowService};
+use crate::WorkflowService;
 use anyhow::{anyhow, bail};
 use std::{fmt::Debug, marker::PhantomData};
 use temporal_sdk_core_protos::{
@@ -11,6 +11,7 @@ use temporal_sdk_core_protos::{
         workflowservice::v1::GetWorkflowExecutionHistoryRequest,
     },
 };
+use tonic::IntoRequest;
 
 /// Enumerates terminal states for a particular workflow execution
 // TODO: Add non-proto failure types, flesh out details, etc.
@@ -81,7 +82,7 @@ impl WorkflowExecutionInfo {
     /// Bind the workflow info to a specific client, turning it into a workflow handle
     pub fn bind_untyped<CT>(self, client: CT) -> UntypedWorkflowHandle<CT>
     where
-        CT: RawClientLike<SvcType = InterceptedMetricsSvc> + Clone,
+        CT: WorkflowService + Clone,
     {
         UntypedWorkflowHandle::new(client, self)
     }
@@ -92,7 +93,7 @@ pub(crate) type UntypedWorkflowHandle<CT> = WorkflowHandle<CT, Vec<Payload>>;
 
 impl<CT, RT> WorkflowHandle<CT, RT>
 where
-    CT: RawClientLike<SvcType = InterceptedMetricsSvc> + Clone,
+    CT: WorkflowService + Clone,
     // TODO: Make more generic, capable of (de)serialization w/ serde
     RT: FromPayloadsExt,
 {
@@ -125,18 +126,21 @@ where
             let server_res = self
                 .client
                 .clone()
-                .get_workflow_execution_history(GetWorkflowExecutionHistoryRequest {
-                    namespace: self.info.namespace.to_string(),
-                    execution: Some(WorkflowExecution {
-                        workflow_id: self.info.workflow_id.clone(),
-                        run_id: run_id.clone(),
-                    }),
-                    skip_archival: true,
-                    wait_new_event: true,
-                    history_event_filter_type: HistoryEventFilterType::CloseEvent as i32,
-                    next_page_token: next_page_tok.clone(),
-                    ..Default::default()
-                })
+                .get_workflow_execution_history(
+                    GetWorkflowExecutionHistoryRequest {
+                        namespace: self.info.namespace.to_string(),
+                        execution: Some(WorkflowExecution {
+                            workflow_id: self.info.workflow_id.clone(),
+                            run_id: run_id.clone(),
+                        }),
+                        skip_archival: true,
+                        wait_new_event: true,
+                        history_event_filter_type: HistoryEventFilterType::CloseEvent as i32,
+                        next_page_token: next_page_tok.clone(),
+                        ..Default::default()
+                    }
+                    .into_request(),
+                )
                 .await?
                 .into_inner();
 
@@ -200,8 +204,7 @@ where
                 o => Err(anyhow!(
                     "Server returned an event that didn't match the CloseEvent filter. \
                      This is either a server bug or a new event the SDK does not understand. \
-                     Event details: {:?}",
-                    o
+                     Event details: {o:?}"
                 )),
             };
         }

package/sdk-core/core/Cargo.toml

@@ -1,7 +1,10 @@
 [package]
 name = "temporal-sdk-core"
 version = "0.1.0"
-authors = ["Spencer Judge <spencer@temporal.io>", "Vitaly Arbuzov <vitaly@temporal.io>"]
+authors = [
+    "Spencer Judge <spencer@temporal.io>",
+    "Vitaly Arbuzov <vitaly@temporal.io>",
+]
 edition = "2024"
 license-file = { workspace = true }
 description = "Library for building new Temporal SDKs"
@@ -14,64 +17,107 @@ categories = ["development-tools"]
 
 [features]
 default = ["otel", "prom"]
-otel = ["dep:opentelemetry", "dep:opentelemetry_sdk", "dep:opentelemetry-otlp", "dep:hyper",
-    "dep:hyper-util", "dep:http-body-util"]
+otel = [
+    "dep:opentelemetry",
+    "dep:opentelemetry_sdk",
+    "dep:opentelemetry-otlp",
+    "dep:hyper",
+    "dep:hyper-util",
+    "dep:http-body-util",
+]
 prom = ["dep:prometheus"]
 tokio-console = ["console-subscriber"]
 ephemeral-server = ["dep:flate2", "dep:reqwest", "dep:tar", "dep:zip"]
 debug-plugin = ["dep:reqwest"]
+test-utilities = ["dep:assert_matches", "dep:bimap"]
 
 [dependencies]
 anyhow = "1.0"
+assert_matches = { version = "1.5", optional = true }
+bimap = { version = "0.6.3", optional = true }
 async-trait = "0.1"
 console-subscriber = { version = "0.4", optional = true }
 crossbeam-channel = "0.5"
 crossbeam-queue = "0.3"
 crossbeam-utils = "0.8"
-dashmap = "6.0"
+dashmap = "6.1"
 derive_builder = { workspace = true }
 derive_more = { workspace = true }
 enum_dispatch = "0.3"
 enum-iterator = "2"
-flate2 = { version = "1.0", optional = true }
+flate2 = { version = "1.1", optional = true }
 futures-util = { version = "0.3", default-features = false }
-futures-channel = { version = "0.3", default-features = false, features = ["std"] }
+futures-channel = { version = "0.3", default-features = false, features = [
+    "std",
+] }
 gethostname = "1.0.2"
-governor = "0.8"
+governor = "0.10"
 http-body-util = { version = "0.1", optional = true }
-hyper = { version = "1.2", optional = true }
-hyper-util = { version = "0.1", features = ["server", "http1", "http2", "tokio"], optional = true }
+hyper = { version = "1.7", optional = true }
+hyper-util = { version = "0.1", features = [
+    "server",
+    "http1",
+    "http2",
+    "tokio",
+], optional = true }
 itertools = "0.14"
-lru = "0.13"
+lru = "0.16"
 mockall = "0.13"
 opentelemetry = { workspace = true, features = ["metrics"], optional = true }
-opentelemetry_sdk = { version = "0.30", features = ["rt-tokio", "metrics", "spec_unstable_metrics_views"], optional = true }
-opentelemetry-otlp = { version = "0.30", features = ["tokio", "metrics", "tls", "http-proto", "grpc-tonic"], optional = true }
+opentelemetry_sdk = { version = "0.31", features = [
+    "rt-tokio",
+    "metrics",
+    "spec_unstable_metrics_views",
+], optional = true }
+opentelemetry-otlp = { version = "0.31", features = [
+    "tokio",
+    "metrics",
+    "tls",
+    "http-proto",
+    "grpc-tonic",
+], optional = true }
 parking_lot = { version = "0.12", features = ["send_guard"] }
 pid = "4.0"
-pin-project = "1.0"
+pin-project = "1.1"
 prometheus = { version = "0.14", optional = true }
 prost = { workspace = true }
-prost-types = { version = "0.6", package = "prost-wkt-types" }
+prost-types = { workspace = true }
 rand = "0.9"
-reqwest = { version = "0.12", features = ["json", "stream", "rustls-tls-native-roots"], default-features = false, optional = true }
+reqwest = { version = "0.12", features = [
+    "json",
+    "stream",
+    "rustls-tls-native-roots",
+], default-features = false, optional = true }
 ringbuf = "0.4"
 serde = "1.0"
 serde_json = "1.0"
 siphasher = "1.0"
 slotmap = "1.0"
-sysinfo = { version = "0.33", default-features = false, features = ["system"] }
+sysinfo = { version = "0.37", default-features = false, features = ["system"] }
 tar = { version = "0.4", optional = true }
 thiserror = { workspace = true }
-tokio = { version = "1.37", features = ["rt", "rt-multi-thread", "parking_lot", "time", "fs", "process"] }
+tokio = { version = "1.47", features = [
+    "rt",
+    "rt-multi-thread",
+    "parking_lot",
+    "time",
+    "fs",
+    "process",
+] }
 tokio-util = { version = "0.7", features = ["io", "io-util"] }
 tokio-stream = "0.1"
 tonic = { workspace = true, features = ["tls-ring", "tls-native-roots"] }
 tracing = "0.1"
-tracing-subscriber = { version = "0.3", default-features = false, features = ["parking_lot", "env-filter", "registry", "ansi"] }
-url = "2.2"
-uuid = { version = "1.1", features = ["v4"] }
-zip = { version = "2.0", optional = true }
+tracing-subscriber = { version = "0.3", default-features = false, features = [
+    "parking_lot",
+    "env-filter",
+    "registry",
+    "ansi",
+] }
+url = "2.5"
+uuid = { version = "1.18", features = ["v4"] }
+# Only need specific features to decompress zip files for ephemeral server download
+zip = { version = "4.6", optional = true, default-features = false, features = ["deflate", "bzip2", "zstd"] }
 
 # 1st party local deps
 [dependencies.temporal-sdk-core-api]
@@ -80,7 +126,7 @@ features = ["otel_impls"]
 
 [dependencies.temporal-sdk-core-protos]
 path = "../sdk-core-protos"
-features = ["history_builders"]
+features = ["history_builders", "test-utilities"]
 
 [dependencies.temporal-client]
 path = "../client"
@@ -89,14 +135,23 @@ path = "../client"
 path = "../fsm"
 
 [dev-dependencies]
-assert_matches = "1.4"
-bimap = "0.6.1"
-clap = { version = "4.0", features = ["derive"] }
-criterion = { version = "0.6", features = ["async", "async_tokio"] }
-rstest = "0.25"
-temporal-sdk-core-test-utils = { path = "../test-utils" }
+assert_matches = "1.5"
+bimap = "0.6.3"
+bytes = "1.10"
+clap = { version = "4.5", features = ["derive"] }
+criterion = { version = "0.7", features = ["async", "async_tokio"] }
+rstest = "0.26"
+semver = "1.0"
 temporal-sdk = { path = "../sdk" }
-tokio = { version = "1.37", features = ["rt", "rt-multi-thread", "parking_lot", "time", "fs", "process", "test-util"] }
+tokio = { version = "1.47", features = [
+    "rt",
+    "rt-multi-thread",
+    "parking_lot",
+    "time",
+    "fs",
+    "process",
+    "test-util",
+] }
 tokio-stream = { version = "0.1", features = ["net"] }
 
 [[test]]
@@ -105,30 +160,39 @@ path = "../tests/main.rs"
 # Prevents autodiscovery, and hence these getting run with `cargo test`. Run with
 # `cargo test --test integ_tests`
 test = false
-required-features = ["temporal-sdk-core-protos/serde_serialize"]
+required-features = [
+    "temporal-sdk-core-protos/serde_serialize",
+    "test-utilities",
+    "ephemeral-server",
+]
 
 [[test]]
 name = "heavy_tests"
 path = "../tests/heavy_tests.rs"
 test = false
+required-features = ["test-utilities"]
 
 [[test]]
 name = "manual_tests"
 path = "../tests/manual_tests.rs"
 test = false
+required-features = ["test-utilities"]
 
 [[test]]
 name = "global_metric_tests"
 path = "../tests/global_metric_tests.rs"
 test = false
+required-features = ["test-utilities"]
 
 [[test]]
 name = "cloud_tests"
 path = "../tests/cloud_tests.rs"
 test = false
+required-features = ["test-utilities"]
 
 [[bench]]
 name = "workflow_replay"
+path = "../tests/workflow_replay_bench.rs"
 harness = false
 
 # The integration test runner should compile with the same configuration as the
@@ -140,7 +204,12 @@ name = "integ_runner"
 path = "../tests/runner.rs"
 harness = false
 test = false
-required-features = ["temporal-sdk-core-protos/serde_serialize"]
+required-features = [
+    "temporal-sdk-core-protos/serde_serialize",
+    "test-utilities",
+    "ephemeral-server",
+]
+
 
 [lints]
 workspace = true