@temporalio/core-bridge 1.13.2 → 1.14.0

package/sdk-core/{client → crates/client}/src/raw.rs

@@ -6,21 +6,23 @@ use crate::{
     Client, ConfiguredClient, LONG_POLL_TIMEOUT, RequestExt, RetryClient, SharedReplaceableClient,
     TEMPORAL_NAMESPACE_HEADER_KEY, TemporalServiceClient,
     metrics::namespace_kv,
-    worker_registry::{Slot, SlotManager},
+    worker::{ClientWorkerSet, Slot},
 };
 use dyn_clone::DynClone;
 use futures_util::{FutureExt, TryFutureExt, future::BoxFuture};
 use std::{any::Any, marker::PhantomData, sync::Arc};
-use temporal_sdk_core_api::telemetry::metrics::MetricKeyValue;
-use temporal_sdk_core_protos::{
-    grpc::health::v1::{health_client::HealthClient, *},
-    temporal::api::{
-        cloud::cloudservice::{v1 as cloudreq, v1::cloud_service_client::CloudServiceClient},
-        operatorservice::v1::{operator_service_client::OperatorServiceClient, *},
-        taskqueue::v1::TaskQueue,
-        testservice::v1::{test_service_client::TestServiceClient, *},
-        workflowservice::v1::{workflow_service_client::WorkflowServiceClient, *},
+use temporalio_common::{
+    protos::{
+        grpc::health::v1::{health_client::HealthClient, *},
+        temporal::api::{
+            cloud::cloudservice::{v1 as cloudreq, v1::cloud_service_client::CloudServiceClient},
+            operatorservice::v1::{operator_service_client::OperatorServiceClient, *},
+            taskqueue::v1::TaskQueue,
+            testservice::v1::{test_service_client::TestServiceClient, *},
+            workflowservice::v1::{workflow_service_client::WorkflowServiceClient, *},
+        },
     },
+    telemetry::metrics::MetricKeyValue,
 };
 use tonic::{
     Request, Response, Status,
@@ -33,7 +35,7 @@ use tonic::{
 trait RawClientProducer {
     /// Returns information about workers associated with this client. Implementers outside of
     /// core can safely return `None`.
-    fn get_workers_info(&self) -> Option<Arc<SlotManager>>;
+    fn get_workers_info(&self) -> Option<Arc<ClientWorkerSet>>;
 
     /// Return a workflow service client instance
     fn workflow_client(&mut self) -> Box<dyn WorkflowService>;
@@ -175,7 +177,7 @@ impl<RC> RawClientProducer for RetryClient<RC>
 where
     RC: RawClientProducer + 'static,
 {
-    fn get_workers_info(&self) -> Option<Arc<SlotManager>> {
+    fn get_workers_info(&self) -> Option<Arc<ClientWorkerSet>> {
         self.get_client().get_workers_info()
     }
 
@@ -253,7 +255,7 @@ impl<RC> RawClientProducer for SharedReplaceableClient<RC>
 where
     RC: RawClientProducer + Clone + Send + Sync + 'static,
 {
-    fn get_workers_info(&self) -> Option<Arc<SlotManager>> {
+    fn get_workers_info(&self) -> Option<Arc<ClientWorkerSet>> {
         self.inner_cow().get_workers_info()
     }
     fn workflow_client(&mut self) -> Box<dyn WorkflowService> {
@@ -284,7 +286,7 @@ impl<RC> RawGrpcCaller for SharedReplaceableClient<RC> where
 }
 
 impl RawClientProducer for TemporalServiceClient {
-    fn get_workers_info(&self) -> Option<Arc<SlotManager>> {
+    fn get_workers_info(&self) -> Option<Arc<ClientWorkerSet>> {
         None
     }
 
@@ -312,7 +314,7 @@ impl RawClientProducer for TemporalServiceClient {
 impl RawGrpcCaller for TemporalServiceClient {}
 
 impl RawClientProducer for ConfiguredClient<TemporalServiceClient> {
-    fn get_workers_info(&self) -> Option<Arc<SlotManager>> {
+    fn get_workers_info(&self) -> Option<Arc<ClientWorkerSet>> {
         Some(self.workers())
     }
 
@@ -340,7 +342,7 @@ impl RawClientProducer for ConfiguredClient<TemporalServiceClient> {
 impl RawGrpcCaller for ConfiguredClient<TemporalServiceClient> {}
 
 impl RawClientProducer for Client {
-    fn get_workers_info(&self) -> Option<Arc<SlotManager>> {
+    fn get_workers_info(&self) -> Option<Arc<ClientWorkerSet>> {
         self.inner.get_workers_info()
     }
 
@@ -491,7 +493,7 @@ macro_rules! proxy_impl {
             mut request: tonic::Request<$req>,
         ) -> BoxFuture<'_, Result<tonic::Response<$resp>, tonic::Status>> {
             type_closure_arg(&mut request, $closure_request);
-            let data = type_closure_two_arg(&mut request, Option::<Arc<SlotManager>>::None,
+            let data = type_closure_two_arg(&mut request, Option::<Arc<ClientWorkerSet>>::None,
                                             $closure_before);
             async move {
                 type_closure_two_arg(<$client_type<_>>::$method(self, request).await,
@@ -649,16 +651,15 @@ proxier! {
                         Some(reservation) => {
                             // Populate eager_worker_deployment_options from the slot reservation
                             if let Some(opts) = reservation.deployment_options {
-                                req_mut.eager_worker_deployment_options = Some(temporal_sdk_core_protos::temporal::api::deployment::v1::WorkerDeploymentOptions {
+                                req_mut.eager_worker_deployment_options = Some(temporalio_common::protos::temporal::api::deployment::v1::WorkerDeploymentOptions {
                                     deployment_name: opts.version.deployment_name,
                                     build_id: opts.version.build_id,
                                     worker_versioning_mode: if opts.use_worker_versioning {
-                                        temporal_sdk_core_protos::temporal::api::enums::v1::WorkerVersioningMode::Versioned.into()
+                                        temporalio_common::protos::temporal::api::enums::v1::WorkerVersioningMode::Versioned.into()
                                     } else {
-                                        temporal_sdk_core_protos::temporal::api::enums::v1::WorkerVersioningMode::Unversioned.into()
+                                        temporalio_common::protos::temporal::api::enums::v1::WorkerVersioningMode::Unversioned.into()
                                     },
-                                });
-                            }
+                                });                            }
                             slot = Some(reservation.slot);
                         }
                         None => req_mut.request_eager_execution = false
@@ -1574,6 +1575,8 @@ proxier! {
     (get_connectivity_rule, cloudreq::GetConnectivityRuleRequest, cloudreq::GetConnectivityRuleResponse);
     (get_connectivity_rules, cloudreq::GetConnectivityRulesRequest, cloudreq::GetConnectivityRulesResponse);
     (delete_connectivity_rule, cloudreq::DeleteConnectivityRuleRequest, cloudreq::DeleteConnectivityRuleResponse);
+    (set_service_account_namespace_access, cloudreq::SetServiceAccountNamespaceAccessRequest, cloudreq::SetServiceAccountNamespaceAccessResponse);
+    (validate_account_audit_log_sink, cloudreq::ValidateAccountAuditLogSinkRequest, cloudreq::ValidateAccountAuditLogSinkResponse);
 }
 
 proxier! {
@@ -1595,19 +1598,28 @@ proxier! {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{ClientOptionsBuilder, RetryClient};
+    use crate::{ClientOptions, RetryClient};
     use std::collections::HashSet;
-    use temporal_sdk_core_protos::temporal::api::{
-        operatorservice::v1::DeleteNamespaceRequest, workflowservice::v1::ListNamespacesRequest,
+    use temporalio_common::{
+        protos::temporal::api::{
+            operatorservice::v1::DeleteNamespaceRequest, workflowservice::v1::ListNamespacesRequest,
+        },
+        worker::WorkerTaskTypes,
     };
     use tonic::IntoRequest;
+    use url::Url;
+    use uuid::Uuid;
 
     // Just to help make sure some stuff compiles. Not run.
     #[allow(dead_code)]
     async fn raw_client_retry_compiles() {
-        let opts = ClientOptionsBuilder::default().build().unwrap();
+        let opts = ClientOptions::builder()
+            .target_url(Url::parse("http://localhost:7233").unwrap())
+            .client_name("test")
+            .client_version("0.0.0")
+            .build();
         let raw_client = opts.connect_no_namespace(None).await.unwrap();
-        let mut retry_client = RetryClient::new(raw_client, opts.retry_config);
+        let mut retry_client = RetryClient::new(raw_client, opts.retry_options);
 
         let list_ns_req = ListNamespacesRequest::default();
         let fact = |c: &mut RetryClient<_>, req| {
@@ -1690,7 +1702,7 @@ mod tests {
     fn verify_all_workflow_service_methods_implemented() {
         // This is less work than trying to hook into the codegen process
         let proto_def = include_str!(
-            "../../sdk-core-protos/protos/api_upstream/temporal/api/workflowservice/v1/service.proto"
+            "../../common/protos/api_upstream/temporal/api/workflowservice/v1/service.proto"
         );
         verify_methods(proto_def, ALL_IMPLEMENTED_WORKFLOW_SERVICE_RPCS);
     }
@@ -1698,7 +1710,7 @@ mod tests {
     #[test]
     fn verify_all_operator_service_methods_implemented() {
         let proto_def = include_str!(
-            "../../sdk-core-protos/protos/api_upstream/temporal/api/operatorservice/v1/service.proto"
+            "../../common/protos/api_upstream/temporal/api/operatorservice/v1/service.proto"
         );
         verify_methods(proto_def, ALL_IMPLEMENTED_OPERATOR_SERVICE_RPCS);
     }
@@ -1706,7 +1718,7 @@ mod tests {
     #[test]
     fn verify_all_cloud_service_methods_implemented() {
         let proto_def = include_str!(
-            "../../sdk-core-protos/protos/api_cloud_upstream/temporal/api/cloud/cloudservice/v1/service.proto"
+            "../../common/protos/api_cloud_upstream/temporal/api/cloud/cloudservice/v1/service.proto"
         );
         verify_methods(proto_def, ALL_IMPLEMENTED_CLOUD_SERVICE_RPCS);
     }
@@ -1714,14 +1726,14 @@ mod tests {
     #[test]
     fn verify_all_test_service_methods_implemented() {
         let proto_def = include_str!(
-            "../../sdk-core-protos/protos/testsrv_upstream/temporal/api/testservice/v1/service.proto"
+            "../../common/protos/testsrv_upstream/temporal/api/testservice/v1/service.proto"
         );
         verify_methods(proto_def, ALL_IMPLEMENTED_TEST_SERVICE_RPCS);
     }
 
     #[test]
     fn verify_all_health_service_methods_implemented() {
-        let proto_def = include_str!("../../sdk-core-protos/protos/grpc/health/v1/health.proto");
+        let proto_def = include_str!("../../common/protos/grpc/health/v1/health.proto");
         verify_methods(proto_def, ALL_IMPLEMENTED_HEALTH_SERVICE_RPCS);
     }
 
@@ -1791,9 +1803,11 @@ mod tests {
     #[case::without_versioning(false)]
     #[tokio::test]
     async fn eager_reservations_attach_deployment_options(#[case] use_worker_versioning: bool) {
-        use crate::worker_registry::{MockSlot, MockSlotProvider};
-        use temporal_sdk_core_api::worker::{WorkerDeploymentOptions, WorkerDeploymentVersion};
-        use temporal_sdk_core_protos::temporal::api::enums::v1::WorkerVersioningMode;
+        use crate::worker::{MockClientWorker, MockSlot};
+        use temporalio_common::{
+            protos::temporal::api::enums::v1::WorkerVersioningMode,
+            worker::{WorkerDeploymentOptions, WorkerDeploymentVersion},
+        };
 
         let expected_mode = if use_worker_versioning {
             WorkerVersioningMode::Versioned
@@ -1803,13 +1817,13 @@ mod tests {
 
         #[derive(Clone)]
         struct MyFakeServices {
-            slot_manager: Arc<SlotManager>,
+            client_worker_set: Arc<ClientWorkerSet>,
             expected_mode: WorkerVersioningMode,
         }
         impl RawGrpcCaller for MyFakeServices {}
         impl RawClientProducer for MyFakeServices {
-            fn get_workers_info(&self) -> Option<Arc<SlotManager>> {
-                Some(self.slot_manager.clone())
+            fn get_workers_info(&self) -> Option<Arc<ClientWorkerSet>> {
+                Some(self.client_worker_set.clone())
             }
             fn workflow_client(&mut self) -> Box<dyn WorkflowService> {
                 Box::new(MyFakeWfClient {
@@ -1839,7 +1853,7 @@ mod tests {
             default_versioning_behavior: None,
         };
 
-        let mut mock_provider = MockSlotProvider::new();
+        let mut mock_provider = MockClientWorker::new();
         mock_provider
             .expect_namespace()
             .return_const("test-namespace".to_string());
@@ -1854,9 +1868,24 @@ mod tests {
         mock_provider
             .expect_deployment_options()
             .return_const(Some(deployment_opts.clone()));
-
-        let slot_manager = Arc::new(SlotManager::new());
-        slot_manager.register(Box::new(mock_provider));
+        mock_provider.expect_heartbeat_enabled().return_const(false);
+        let uuid = Uuid::new_v4();
+        mock_provider
+            .expect_worker_instance_key()
+            .return_const(uuid);
+        mock_provider
+            .expect_worker_task_types()
+            .return_const(WorkerTaskTypes {
+                enable_workflows: true,
+                enable_local_activities: true,
+                enable_remote_activities: true,
+                enable_nexus: true,
+            });
+
+        let client_worker_set = Arc::new(ClientWorkerSet::new());
+        client_worker_set
+            .register_worker(Arc::new(mock_provider), true)
+            .unwrap();
 
         #[derive(Clone)]
         struct MyFakeWfClient {
@@ -1886,7 +1915,7 @@ mod tests {
         }
 
         let mut mfs = MyFakeServices {
-            slot_manager,
+            client_worker_set,
             expected_mode,
         };
 
@@ -1895,7 +1924,7 @@ mod tests {
             namespace: "test-namespace".to_string(),
             workflow_id: "test-wf-id".to_string(),
             workflow_type: Some(
-                temporal_sdk_core_protos::temporal::api::common::v1::WorkflowType {
+                temporalio_common::protos::temporal::api::common::v1::WorkflowType {
                     name: "test-workflow".to_string(),
                 },
             ),

package/sdk-core/crates/client/src/request_extensions.rs

@@ -0,0 +1,40 @@
+//! Request extensions for tonic gRPC requests.
+//!
+//! These types can be inserted into tonic request extensions to modify behavior of the
+//! [RetryClient](crate::RetryClient) or other request handling logic.
+
+use crate::RetryOptions;
+use std::time::Duration;
+
+/// A request extension that, when set, should make the [RetryClient](crate::RetryClient) consider
+/// this call to be a [CallType::TaskLongPoll](crate::CallType::TaskLongPoll)
+#[derive(Copy, Clone, Debug)]
+pub struct IsWorkerTaskLongPoll;
+
+/// A request extension that, when set, and a call is being processed by a
+/// [RetryClient](crate::RetryClient), allows the caller to request certain matching errors to
+/// short-circuit-return immediately and not follow normal retry logic.
+#[derive(Copy, Clone, Debug)]
+pub struct NoRetryOnMatching {
+    /// Return true if the passed-in gRPC error should be immediately returned to the caller
+    pub predicate: fn(&tonic::Status) -> bool,
+}
+
+/// A request extension that forces overriding the current retry policy of the
+/// [RetryClient](crate::RetryClient).
+#[derive(Clone, Debug)]
+pub struct RetryConfigForCall(pub RetryOptions);
+
+/// Extension trait for tonic requests to set default timeouts
+pub trait RequestExt {
+    /// Set a timeout for a request if one is not already specified in the metadata
+    fn set_default_timeout(&mut self, duration: Duration);
+}
+
+impl<T> RequestExt for tonic::Request<T> {
+    fn set_default_timeout(&mut self, duration: Duration) {
+        if !self.metadata().contains_key("grpc-timeout") {
+            self.set_timeout(duration)
+        }
+    }
+}

package/sdk-core/{client → crates/client}/src/retry.rs

@@ -1,6 +1,8 @@
 use crate::{
-    ERROR_RETURNED_DUE_TO_SHORT_CIRCUIT, IsWorkerTaskLongPoll, MESSAGE_TOO_LARGE_KEY,
-    NamespacedClient, NoRetryOnMatching, Result, RetryConfig, raw::IsUserLongPoll,
+    ERROR_RETURNED_DUE_TO_SHORT_CIRCUIT, MESSAGE_TOO_LARGE_KEY, NamespacedClient, Result,
+    RetryOptions,
+    raw::IsUserLongPoll,
+    request_extensions::{IsWorkerTaskLongPoll, NoRetryOnMatching, RetryConfigForCall},
 };
 use backoff::{Clock, SystemClock, backoff::Backoff, exponential::ExponentialBackoff};
 use futures_retry::{ErrorHandler, FutureRetry, RetryPolicy};
@@ -8,6 +10,7 @@ use std::{error::Error, fmt::Debug, future::Future, sync::Arc, time::Duration};
 use tonic::{Code, Request};
 
 /// List of gRPC error codes that client will retry.
+#[doc(hidden)]
 pub const RETRYABLE_ERROR_CODES: [Code; 7] = [
     Code::DataLoss,
     Code::Internal,
@@ -19,17 +22,17 @@ pub const RETRYABLE_ERROR_CODES: [Code; 7] = [
 ];
 const LONG_POLL_FATAL_GRACE: Duration = Duration::from_secs(60);
 
-/// A wrapper for a [WorkflowClientTrait] or [crate::WorkflowService] implementor which performs
-/// auto-retries
+/// A wrapper for a [crate::WorkflowClientTrait] or [crate::WorkflowService] implementor which
+/// performs auto-retries
 #[derive(Debug, Clone)]
 pub struct RetryClient<SG> {
     client: SG,
-    retry_config: Arc<RetryConfig>,
+    retry_config: Arc<RetryOptions>,
 }
 
 impl<SG> RetryClient<SG> {
     /// Use the provided retry config with the provided client
-    pub fn new(client: SG, retry_config: RetryConfig) -> Self {
+    pub fn new(client: SG, retry_config: RetryOptions) -> Self {
         Self {
             client,
             retry_config: Arc::new(retry_config),
@@ -60,6 +63,7 @@ impl<SG> RetryClient<SG> {
     ) -> CallInfo {
         let mut call_type = CallType::Normal;
         let mut retry_short_circuit = None;
+        let mut retry_cfg_override = None;
         if let Some(r) = request.as_ref() {
             let ext = r.extensions();
             if ext.get::<IsUserLongPoll>().is_some() {
@@ -69,9 +73,12 @@ impl<SG> RetryClient<SG> {
             }
 
             retry_short_circuit = ext.get::<NoRetryOnMatching>().cloned();
+            retry_cfg_override = ext.get::<RetryConfigForCall>().cloned();
         }
-        let retry_cfg = if call_type == CallType::TaskLongPoll {
-            RetryConfig::task_poll_retry_policy()
+        let retry_cfg = if let Some(ovr) = retry_cfg_override {
+            ovr.0
+        } else if call_type == CallType::TaskLongPoll {
+            RetryOptions::task_poll_retry_policy()
         } else {
             (*self.retry_config).clone()
         };
@@ -93,7 +100,7 @@ impl<SG> RetryClient<SG> {
     {
         FutureRetry::new(
             factory,
-            TonicErrorHandler::new(info, RetryConfig::throttle_retry_policy()),
+            TonicErrorHandler::new(info, RetryOptions::throttle_retry_policy()),
         )
     }
 }
@@ -122,7 +129,7 @@ pub(crate) struct TonicErrorHandler<C: Clock> {
     retry_short_circuit: Option<NoRetryOnMatching>,
 }
 impl TonicErrorHandler<SystemClock> {
-    fn new(call_info: CallInfo, throttle_cfg: RetryConfig) -> Self {
+    fn new(call_info: CallInfo, throttle_cfg: RetryOptions) -> Self {
         Self::new_with_clock(
             call_info,
             throttle_cfg,
@@ -137,7 +144,7 @@ where
 {
     fn new_with_clock(
         call_info: CallInfo,
-        throttle_cfg: RetryConfig,
+        throttle_cfg: RetryOptions,
         clock: C,
         throttle_clock: C,
     ) -> Self {
@@ -178,7 +185,7 @@ where
 pub(crate) struct CallInfo {
     pub call_type: CallType,
     call_name: &'static str,
-    retry_cfg: RetryConfig,
+    retry_cfg: RetryOptions,
     retry_short_circuit: Option<NoRetryOnMatching>,
 }
 
@@ -304,13 +311,13 @@ mod tests {
     use assert_matches::assert_matches;
     use backoff::Clock;
     use std::{ops::Add, time::Instant};
-    use temporal_sdk_core_protos::temporal::api::workflowservice::v1::{
+    use temporalio_common::protos::temporal::api::workflowservice::v1::{
         PollActivityTaskQueueRequest, PollNexusTaskQueueRequest, PollWorkflowTaskQueueRequest,
     };
     use tonic::{IntoRequest, Status};
 
     /// Predefined retry configs with low durations to make unit tests faster
-    const TEST_RETRY_CONFIG: RetryConfig = RetryConfig {
+    const TEST_RETRY_CONFIG: RetryOptions = RetryOptions {
         initial_interval: Duration::from_millis(1),
         randomization_factor: 0.0,
         multiplier: 1.1,
@@ -403,7 +410,7 @@ mod tests {
                 retry_cfg: TEST_RETRY_CONFIG,
                 retry_short_circuit: None,
             },
-            RetryConfig {
+            RetryOptions {
                 initial_interval: Duration::from_millis(2),
                 randomization_factor: 0.0,
                 multiplier: 4.0,
@@ -524,7 +531,7 @@ mod tests {
         for i in 1..=50 {
             let mut err_handler = TonicErrorHandler::new(
                 fake_retry.get_call_info::<R>(call_name, Some(&req)),
-                RetryConfig::throttle_retry_policy(),
+                RetryOptions::throttle_retry_policy(),
             );
             let result = err_handler.handle(i, Status::new(Code::Unknown, "Ahh"));
             assert_matches!(result, RetryPolicy::WaitRetry(_));
@@ -557,7 +564,7 @@ mod tests {
         for code in [Code::Cancelled, Code::DeadlineExceeded] {
             let mut err_handler = TonicErrorHandler::new(
                 fake_retry.get_call_info::<R>(call_name, Some(&req)),
-                RetryConfig::throttle_retry_policy(),
+                RetryOptions::throttle_retry_policy(),
             );
             for i in 1..=5 {
                 let result = err_handler.handle(i, Status::new(code, "retryable failure"));