@temporalio/core-bridge 1.12.2 → 1.12.3

package/sdk-core/core/src/worker/heartbeat.rs

@@ -121,7 +121,9 @@ impl WorkerHeartbeatData {
             start_time: SystemTime::now(),
             heartbeat_time: None,
             worker_instance_key: Uuid::new_v4().to_string(),
-            heartbeat_interval: worker_config.heartbeat_interval,
+            heartbeat_interval: worker_config
+                .heartbeat_interval
+                .expect("WorkerHeartbeatData is only called when heartbeat_interval is Some"),
             reset_notify,
         }
     }

package/sdk-core/core-api/src/worker.rs

@@ -165,8 +165,8 @@ pub struct WorkerConfig {
     /// The interval within which the worker will send a heartbeat.
     /// The timer is reset on each existing RPC call that also happens to send this data, like
     /// `PollWorkflowTaskQueueRequest`.
-    #[builder(default = "Duration::from_secs(60)")]
-    pub heartbeat_interval: Duration,
+    #[builder(default)]
+    pub heartbeat_interval: Option<Duration>,
 }
 
 impl WorkerConfig {

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

@@ -10,6 +10,8 @@ crate-type = ["cdylib"]
 [dependencies]
 anyhow = "1.0"
 async-trait = "0.1"
+futures-util = { version = "0.3", default-features = false }
+http = "1.1"
 libc = "0.2"
 prost = { workspace = true }
 # We rely on Cargo semver rules not updating a 0.x to 0.y. Per the rand

package/sdk-core/core-c-bridge/include/temporal-sdk-core-c-bridge.h

@@ -58,6 +58,15 @@ typedef struct TemporalCoreCancellationToken TemporalCoreCancellationToken;
 
 typedef struct TemporalCoreClient TemporalCoreClient;
 
+/**
+ * Representation of gRPC request for the callback.
+ *
+ * Note, temporal_core_client_grpc_override_request_respond is effectively the "free" call for
+ * each request. Each request _must_ call that and the request can no longer be valid after that
+ * call.
+ */
+typedef struct TemporalCoreClientGrpcOverrideRequest TemporalCoreClientGrpcOverrideRequest;
+
 typedef struct TemporalCoreEphemeralServer TemporalCoreEphemeralServer;
 
 typedef struct TemporalCoreForwardedLog TemporalCoreForwardedLog;
@@ -114,6 +123,20 @@ typedef struct TemporalCoreClientHttpConnectProxyOptions {
   struct TemporalCoreByteArrayRef password;
 } TemporalCoreClientHttpConnectProxyOptions;
 
+/**
+ * Callback that is invoked for every gRPC call if set on the client options.
+ *
+ * Note, temporal_core_client_grpc_override_request_respond is effectively the "free" call for
+ * each request. Each request _must_ call that and the request can no longer be valid after that
+ * call. However, all of that work and the respond call may be done well after this callback
+ * returns. No data lifetime is related to the callback invocation itself.
+ *
+ * Implementers should return as soon as possible and perform the network request in the
+ * background.
+ */
+typedef void (*TemporalCoreClientGrpcOverrideCallback)(struct TemporalCoreClientGrpcOverrideRequest *request,
+                                                       void *user_data);
+
 typedef struct TemporalCoreClientOptions {
   struct TemporalCoreByteArrayRef target_url;
   struct TemporalCoreByteArrayRef client_name;
@@ -125,6 +148,21 @@ typedef struct TemporalCoreClientOptions {
   const struct TemporalCoreClientRetryOptions *retry_options;
   const struct TemporalCoreClientKeepAliveOptions *keep_alive_options;
   const struct TemporalCoreClientHttpConnectProxyOptions *http_connect_proxy_options;
+  /**
+   * If this is set, all gRPC calls go through it and no connection is made to server. The client
+   * connection call usually calls this for "GetSystemInfo" before the connect is complete. See
+   * the callback documentation for more important information about usage and data lifetimes.
+   *
+   * When a callback is set, target_url is not used to connect, but it must be set to a valid URL
+   * anyways in case it is used for logging or other reasons. Similarly, other connect-specific
+   * fields like tls_options, keep_alive_options, and http_connect_proxy_options will be
+   * completely ignored if a callback is set.
+   */
+  TemporalCoreClientGrpcOverrideCallback grpc_override_callback;
+  /**
+   * Optional user data passed to each callback call.
+   */
+  void *grpc_override_callback_user_data;
 } TemporalCoreClientOptions;
 
 typedef struct TemporalCoreByteArray {
@@ -147,6 +185,36 @@ typedef void (*TemporalCoreClientConnectCallback)(void *user_data,
                                                   struct TemporalCoreClient *success,
                                                   const struct TemporalCoreByteArray *fail);
 
+/**
+ * Response provided to temporal_core_client_grpc_override_request_respond. All values referenced
+ * inside here must live until that call returns.
+ */
+typedef struct TemporalCoreClientGrpcOverrideResponse {
+  /**
+   * Numeric gRPC status code, see https://grpc.io/docs/guides/status-codes/. 0 is success, non-0
+   * is failure.
+   */
+  int32_t status_code;
+  /**
+   * Headers for the response if any. Note, this is meant for user-defined metadata/headers, and
+   * not the gRPC system headers (like :status or content-type).
+   */
+  TemporalCoreMetadataRef headers;
+  /**
+   * Protobuf bytes for a successful response. Ignored if status_code is non-0.
+   */
+  struct TemporalCoreByteArrayRef success_proto;
+  /**
+   * UTF-8 failure message. Ignored if status_code is 0.
+   */
+  struct TemporalCoreByteArrayRef fail_message;
+  /**
+   * Optional details for the gRPC failure. If non-empty, this should be a protobuf-serialized
+   * google.rpc.Status. Ignored if status_code is 0.
+   */
+  struct TemporalCoreByteArrayRef fail_details;
+} TemporalCoreClientGrpcOverrideResponse;
+
 typedef struct TemporalCoreRpcCallOptions {
   enum TemporalCoreRpcService service;
   struct TemporalCoreByteArrayRef rpc;
@@ -656,6 +724,43 @@ void temporal_core_client_update_metadata(struct TemporalCoreClient *client,
 void temporal_core_client_update_api_key(struct TemporalCoreClient *client,
                                          struct TemporalCoreByteArrayRef api_key);
 
+/**
+ * Get a reference to the service name.
+ *
+ * Note, this is only valid until temporal_core_client_grpc_override_request_respond is called.
+ */
+struct TemporalCoreByteArrayRef temporal_core_client_grpc_override_request_service(const struct TemporalCoreClientGrpcOverrideRequest *req);
+
+/**
+ * Get a reference to the RPC name.
+ *
+ * Note, this is only valid until temporal_core_client_grpc_override_request_respond is called.
+ */
+struct TemporalCoreByteArrayRef temporal_core_client_grpc_override_request_rpc(const struct TemporalCoreClientGrpcOverrideRequest *req);
+
+/**
+ * Get a reference to the service headers.
+ *
+ * Note, this is only valid until temporal_core_client_grpc_override_request_respond is called.
+ */
+TemporalCoreMetadataRef temporal_core_client_grpc_override_request_headers(const struct TemporalCoreClientGrpcOverrideRequest *req);
+
+/**
+ * Get a reference to the request protobuf bytes.
+ *
+ * Note, this is only valid until temporal_core_client_grpc_override_request_respond is called.
+ */
+struct TemporalCoreByteArrayRef temporal_core_client_grpc_override_request_proto(const struct TemporalCoreClientGrpcOverrideRequest *req);
+
+/**
+ * Complete the request, freeing all request data.
+ *
+ * The data referenced in the response must live until this function returns. Once this call is
+ * made, none of the request data should be considered valid.
+ */
+void temporal_core_client_grpc_override_request_respond(struct TemporalCoreClientGrpcOverrideRequest *req,
+                                                        struct TemporalCoreClientGrpcOverrideResponse resp);
+
 /**
  * Client, options, and user data must live through callback.
  */

package/sdk-core/core-c-bridge/src/client.rs

@@ -1,18 +1,22 @@
-use crate::ByteArray;
-use crate::ByteArrayRef;
-use crate::CancellationToken;
-use crate::MetadataRef;
-use crate::UserDataHandle;
-use crate::runtime::Runtime;
+use crate::{
+    ByteArray, ByteArrayRef, CancellationToken, MetadataRef, UserDataHandle, runtime::Runtime,
+};
 
+use futures_util::FutureExt;
+use prost::bytes::Bytes;
+use std::cell::OnceCell;
 use std::str::FromStr;
+use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::Ordering;
 use std::time::Duration;
 use temporal_client::{
     ClientKeepAliveConfig, ClientOptions as CoreClientOptions, ClientOptionsBuilder,
     ClientTlsConfig, CloudService, ConfiguredClient, HealthService, HttpConnectProxyOptions,
     OperatorService, RetryClient, RetryConfig, TemporalServiceClientWithMetrics, TestService,
-    TlsConfig, WorkflowService,
+    TlsConfig, WorkflowService, callback_based,
 };
+use tokio::sync::oneshot;
 use tonic::metadata::MetadataKey;
 use url::Url;
 
@@ -28,6 +32,17 @@ pub struct ClientOptions {
     pub retry_options: *const ClientRetryOptions,
     pub keep_alive_options: *const ClientKeepAliveOptions,
     pub http_connect_proxy_options: *const ClientHttpConnectProxyOptions,
+    /// If this is set, all gRPC calls go through it and no connection is made to server. The client
+    /// connection call usually calls this for "GetSystemInfo" before the connect is complete. See
+    /// the callback documentation for more important information about usage and data lifetimes.
+    ///
+    /// When a callback is set, target_url is not used to connect, but it must be set to a valid URL
+    /// anyways in case it is used for logging or other reasons. Similarly, other connect-specific
+    /// fields like tls_options, keep_alive_options, and http_connect_proxy_options will be
+    /// completely ignored if a callback is set.
+    pub grpc_override_callback: ClientGrpcOverrideCallback,
+    /// Optional user data passed to each callback call.
+    pub grpc_override_callback_user_data: *mut libc::c_void,
 }
 
 #[repr(C)]
@@ -106,12 +121,19 @@ pub extern "C" fn temporal_core_client_connect(
             return;
         }
     };
+    // Create override if present
+    let service_override = options.grpc_override_callback.map(|cb| {
+        create_callback_based_grpc_service(runtime, cb, options.grpc_override_callback_user_data)
+    });
     // Spawn async call
     let user_data = UserDataHandle(user_data);
     let core = runtime.core.clone();
     runtime.core.tokio_handle().spawn(async move {
         match core_options
-            .connect_no_namespace(core.telemetry().get_temporal_metric_meter())
+            .connect_no_namespace_with_service_override(
+                core.telemetry().get_temporal_metric_meter(),
+                service_override,
+            )
             .await
         {
             Ok(core) => {
@@ -136,6 +158,75 @@ pub extern "C" fn temporal_core_client_connect(
     });
 }
 
+fn create_callback_based_grpc_service(
+    runtime: &Runtime,
+    cb: unsafe extern "C" fn(request: *mut ClientGrpcOverrideRequest, user_data: *mut libc::c_void),
+    user_data: *mut libc::c_void,
+) -> callback_based::CallbackBasedGrpcService {
+    let runtime = runtime.clone();
+    let user_data = Arc::new(UserDataHandle(user_data));
+    callback_based::CallbackBasedGrpcService {
+        callback: Arc::new(move |req| {
+            let runtime = runtime.clone();
+            let user_data = user_data.clone();
+            async move {
+                // Create a oneshot sender/receiver for the result
+                let (sender, receiver) = oneshot::channel();
+
+                // Create boxed request that is dropped when the caller sets the response. If the
+                // caller does not, this will be a memory leak.
+                //
+                // We have to cast this to a literal pointer integer because we use spawn_blocking
+                // and Rust can't validate things in either of two approaches. The first approach,
+                // just moving the *mut to spawn_blocking closure, will not work because it is not
+                // send (even if you wrap it in a marked-send struct). The second, approach, moving
+                // the box to the closure and into_raw'ing it there won't work because Rust thinks
+                // the "req" param to spawn_blocking may outlive this closure even though we're
+                // confident in our oneshot use this will never happen.
+                let req_ptr = Box::into_raw(Box::new(ClientGrpcOverrideRequest {
+                    core: req,
+                    built_headers: OnceCell::new(),
+                    response_sender: sender,
+                })) as usize;
+
+                // We want to make sure it reached user code. If spawn_blocking fails _and_ it
+                // didn't reach user code, it is on us to drop the box.
+                let reached_user_code = Arc::new(AtomicBool::new(false));
+
+                // Spawn the callback as blocking, failing on join failure. We use spawn_blocking
+                // just in case the user is doing something blocking in their closure, but we ask
+                // them not to.
+                let reached_user_code_clone = reached_user_code.clone();
+                let spawn_ret = runtime
+                    .core
+                    .tokio_handle()
+                    .spawn_blocking(move || unsafe {
+                        reached_user_code_clone.store(true, Ordering::Relaxed);
+                        cb(
+                            req_ptr as *mut ClientGrpcOverrideRequest,
+                            user_data.clone().0,
+                        );
+                    })
+                    .await;
+                if let Err(err) = spawn_ret {
+                    // Re-own box so it can be dropped if never reached user code
+                    if !reached_user_code.load(Ordering::Relaxed) {
+                        let _ = unsafe { Box::from_raw(req_ptr as *mut ClientGrpcOverrideRequest) };
+                    }
+                    return Err(tonic::Status::internal(format!("{err}")));
+                }
+
+                // Wait result and return. The receiver failure in theory can never happen. If it
+                // does, it means somehow the sender was dropped, but our code ensures the sender
+                // is not dropped until a value is sent. That's why we're panicking here instead
+                // of turning this into a Tonic error.
+                receiver.await.expect("Unexpected receiver failure")
+            }
+            .boxed()
+        }),
+    }
+}
+
 #[unsafe(no_mangle)]
 pub extern "C" fn temporal_core_client_free(client: *mut Client) {
     unsafe {
@@ -164,6 +255,164 @@ pub extern "C" fn temporal_core_client_update_api_key(client: *mut Client, api_k
         .set_api_key(api_key.to_option_string());
 }
 
+/// Callback that is invoked for every gRPC call if set on the client options.
+///
+/// Note, temporal_core_client_grpc_override_request_respond is effectively the "free" call for
+/// each request. Each request _must_ call that and the request can no longer be valid after that
+/// call. However, all of that work and the respond call may be done well after this callback
+/// returns. No data lifetime is related to the callback invocation itself.
+///
+/// Implementers should return as soon as possible and perform the network request in the
+/// background.
+pub type ClientGrpcOverrideCallback = Option<
+    unsafe extern "C" fn(request: *mut ClientGrpcOverrideRequest, user_data: *mut libc::c_void),
+>;
+
+/// Representation of gRPC request for the callback.
+///
+/// Note, temporal_core_client_grpc_override_request_respond is effectively the "free" call for
+/// each request. Each request _must_ call that and the request can no longer be valid after that
+/// call.
+pub struct ClientGrpcOverrideRequest {
+    core: callback_based::GrpcRequest,
+    built_headers: OnceCell<String>,
+    response_sender: oneshot::Sender<Result<callback_based::GrpcSuccessResponse, tonic::Status>>,
+}
+
+// Expected to be passed to user thread
+unsafe impl Send for ClientGrpcOverrideRequest {}
+unsafe impl Sync for ClientGrpcOverrideRequest {}
+
+/// Response provided to temporal_core_client_grpc_override_request_respond. All values referenced
+/// inside here must live until that call returns.
+#[repr(C)]
+pub struct ClientGrpcOverrideResponse {
+    /// Numeric gRPC status code, see https://grpc.io/docs/guides/status-codes/. 0 is success, non-0
+    /// is failure.
+    pub status_code: i32,
+
+    /// Headers for the response if any. Note, this is meant for user-defined metadata/headers, and
+    /// not the gRPC system headers (like :status or content-type).
+    pub headers: MetadataRef,
+
+    /// Protobuf bytes for a successful response. Ignored if status_code is non-0.
+    pub success_proto: ByteArrayRef,
+
+    /// UTF-8 failure message. Ignored if status_code is 0.
+    pub fail_message: ByteArrayRef,
+
+    /// Optional details for the gRPC failure. If non-empty, this should be a protobuf-serialized
+    /// google.rpc.Status. Ignored if status_code is 0.
+    pub fail_details: ByteArrayRef,
+}
+
+/// Get a reference to the service name.
+///
+/// Note, this is only valid until temporal_core_client_grpc_override_request_respond is called.
+#[unsafe(no_mangle)]
+pub extern "C" fn temporal_core_client_grpc_override_request_service(
+    req: *const ClientGrpcOverrideRequest,
+) -> ByteArrayRef {
+    let req = unsafe { &*req };
+    req.core.service.as_str().into()
+}
+
+/// Get a reference to the RPC name.
+///
+/// Note, this is only valid until temporal_core_client_grpc_override_request_respond is called.
+#[unsafe(no_mangle)]
+pub extern "C" fn temporal_core_client_grpc_override_request_rpc(
+    req: *const ClientGrpcOverrideRequest,
+) -> ByteArrayRef {
+    let req = unsafe { &*req };
+    req.core.rpc.as_str().into()
+}
+
+/// Get a reference to the service headers.
+///
+/// Note, this is only valid until temporal_core_client_grpc_override_request_respond is called.
+#[unsafe(no_mangle)]
+pub extern "C" fn temporal_core_client_grpc_override_request_headers(
+    req: *const ClientGrpcOverrideRequest,
+) -> MetadataRef {
+    let req = unsafe { &*req };
+    // Lazily create the headers on first access
+    let headers = req.built_headers.get_or_init(|| {
+        req.core
+            .headers
+            .iter()
+            .filter_map(|(name, value)| value.to_str().ok().map(|val| (name.as_str(), val)))
+            .flat_map(|(k, v)| [k, v])
+            .collect::<Vec<_>>()
+            .join("\n")
+    });
+    headers.as_str().into()
+}
+
+/// Get a reference to the request protobuf bytes.
+///
+/// Note, this is only valid until temporal_core_client_grpc_override_request_respond is called.
+#[unsafe(no_mangle)]
+pub extern "C" fn temporal_core_client_grpc_override_request_proto(
+    req: *const ClientGrpcOverrideRequest,
+) -> ByteArrayRef {
+    let req = unsafe { &*req };
+    (&*req.core.proto).into()
+}
+
+/// Complete the request, freeing all request data.
+///
+/// The data referenced in the response must live until this function returns. Once this call is
+/// made, none of the request data should be considered valid.
+#[unsafe(no_mangle)]
+pub extern "C" fn temporal_core_client_grpc_override_request_respond(
+    req: *mut ClientGrpcOverrideRequest,
+    resp: ClientGrpcOverrideResponse,
+) {
+    // This will be dropped at the end of this call
+    let req = unsafe { Box::from_raw(req) };
+    // Ignore failure if receiver no longer around (e.g. maybe a cancellation)
+    let _ = req
+        .response_sender
+        .send(resp.build_grpc_override_response());
+}
+
+impl ClientGrpcOverrideResponse {
+    #[allow(clippy::result_large_err)] // Tonic status, even though big, is reasonable as an Err
+    fn build_grpc_override_response(
+        self,
+    ) -> Result<callback_based::GrpcSuccessResponse, tonic::Status> {
+        let headers = Self::client_headers_from_metadata_ref(self.headers)
+            .map_err(tonic::Status::internal)?;
+        if self.status_code == 0 {
+            Ok(callback_based::GrpcSuccessResponse {
+                headers,
+                proto: self.success_proto.to_vec(),
+            })
+        } else {
+            Err(tonic::Status::with_details_and_metadata(
+                tonic::Code::from_i32(self.status_code),
+                self.fail_message.to_string(),
+                Bytes::copy_from_slice(self.fail_details.to_slice()),
+                tonic::metadata::MetadataMap::from_headers(headers),
+            ))
+        }
+    }
+
+    fn client_headers_from_metadata_ref(headers: MetadataRef) -> Result<http::HeaderMap, String> {
+        let key_values = headers.to_str_map_on_newlines();
+        let mut header_map = http::HeaderMap::with_capacity(key_values.len());
+        for (k, v) in key_values.into_iter() {
+            let name = http::HeaderName::try_from(k)
+                .map_err(|e| format!("Invalid header name '{k}': {e}"))?;
+            let value = http::HeaderValue::from_str(v)
+                .map_err(|e| format!("Invalid header value '{v}': {e}"))?;
+            header_map.insert(name, value);
+        }
+        Ok(header_map)
+    }
+}
+
 #[repr(C)]
 pub struct RpcCallOptions {
     pub service: RpcService,
@@ -326,6 +575,7 @@ async fn call_workflow_service(
         "DescribeWorkflowExecution" => rpc_call!(client, call, describe_workflow_execution),
         "DescribeWorkflowRule" => rpc_call!(client, call, describe_workflow_rule),
         "ExecuteMultiOperation" => rpc_call!(client, call, execute_multi_operation),
+        "FetchWorkerConfig" => rpc_call!(client, call, fetch_worker_config),
         "GetClusterInfo" => rpc_call!(client, call, get_cluster_info),
         "GetCurrentDeployment" => rpc_call!(client, call, get_current_deployment),
         "GetDeploymentReachability" => rpc_call!(client, call, get_deployment_reachability),
@@ -419,6 +669,8 @@ async fn call_workflow_service(
         }
         "UpdateNamespace" => rpc_call_on_trait!(client, call, WorkflowService, update_namespace),
         "UpdateSchedule" => rpc_call!(client, call, update_schedule),
+        "UpdateTaskQueueConfig" => rpc_call!(client, call, update_task_queue_config),
+        "UpdateWorkerConfig" => rpc_call!(client, call, update_worker_config),
         "UpdateWorkerDeploymentVersionMetadata" => {
             rpc_call!(client, call, update_worker_deployment_version_metadata)
         }
@@ -525,6 +777,11 @@ async fn call_cloud_service(client: &CoreClient, call: &RpcCallOptions) -> anyho
         "UpdateUserGroup" => rpc_call!(client, call, update_user_group),
         "UpdateUser" => rpc_call!(client, call, update_user),
         "ValidateNamespaceExportSink" => rpc_call!(client, call, validate_namespace_export_sink),
+        "UpdateNamespaceTags" => rpc_call!(client, call, update_namespace_tags),
+        "CreateConnectivityRule" => rpc_call!(client, call, create_connectivity_rule),
+        "GetConnectivityRule" => rpc_call!(client, call, get_connectivity_rule),
+        "GetConnectivityRules" => rpc_call!(client, call, get_connectivity_rules),
+        "DeleteConnectivityRule" => rpc_call!(client, call, delete_connectivity_rule),
         rpc => Err(anyhow::anyhow!("Unknown RPC call {}", rpc)),
     }
 }

package/sdk-core/core-c-bridge/src/tests/context.rs

@@ -277,6 +277,15 @@ impl Context {
     }
 
     pub fn client_connect(self: &Arc<Self>, options: Box<ClientOptions>) -> anyhow::Result<()> {
+        Self::client_connect_with_override(self, options, None, std::ptr::null_mut())
+    }
+
+    pub fn client_connect_with_override(
+        self: &Arc<Self>,
+        options: Box<ClientOptions>,
+        grpc_override_callback: crate::client::ClientGrpcOverrideCallback,
+        grpc_override_callback_user_data: *mut libc::c_void,
+    ) -> anyhow::Result<()> {
         let metadata = options
             .headers
             .as_ref()
@@ -339,6 +348,8 @@ impl Context {
             retry_options: &*retry_options,
             keep_alive_options: pointer_or_null(keep_alive_options.as_deref()),
             http_connect_proxy_options: pointer_or_null(proxy_options.as_deref()),
+            grpc_override_callback,
+            grpc_override_callback_user_data,
         });
 
         let client_options_ptr = &*client_options as *const _;