@temporalio/core-bridge 1.13.0 → 1.13.2

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

@@ -0,0 +1,314 @@
+use crate::{ByteArray, ByteArrayRef};
+use serde::Serialize;
+use std::collections::HashMap;
+use temporal_sdk_core_api::envconfig::{
+    self, ClientConfig as CoreClientConfig, ClientConfigCodec as CoreClientConfigCodec,
+    ClientConfigProfile as CoreClientConfigProfile, ClientConfigTLS as CoreClientConfigTLS,
+    DataSource as CoreDataSource, LoadClientConfigOptions, LoadClientConfigProfileOptions,
+};
+
+/// OrFail result for client config loading operations.
+/// Either success or fail will be null, but never both.
+/// If success is not null, it contains JSON-serialized client configuration data.
+/// If fail is not null, it contains UTF-8 encoded error message.
+/// The returned ByteArrays must be freed by the caller.
+#[repr(C)]
+pub struct ClientEnvConfigOrFail {
+    pub success: *const ByteArray,
+    pub fail: *const ByteArray,
+}
+
+/// OrFail result for client config profile loading operations.
+/// Either success or fail will be null, but never both.
+/// If success is not null, it contains JSON-serialized client configuration profile data.
+/// If fail is not null, it contains UTF-8 encoded error message.
+/// The returned ByteArrays must be freed by the caller.
+#[repr(C)]
+pub struct ClientEnvConfigProfileOrFail {
+    pub success: *const ByteArray,
+    pub fail: *const ByteArray,
+}
+
+/// Options for loading client configuration.
+#[repr(C)]
+pub struct ClientEnvConfigLoadOptions {
+    pub path: ByteArrayRef,
+    pub data: ByteArrayRef,
+    pub config_file_strict: bool,
+    pub env_vars: ByteArrayRef,
+}
+
+/// Options for loading a specific client configuration profile.
+#[repr(C)]
+pub struct ClientEnvConfigProfileLoadOptions {
+    pub profile: ByteArrayRef,
+    pub path: ByteArrayRef,
+    pub data: ByteArrayRef,
+    pub disable_file: bool,
+    pub disable_env: bool,
+    pub config_file_strict: bool,
+    pub env_vars: ByteArrayRef,
+}
+
+// Wrapper types for JSON serialization
+#[derive(Serialize)]
+struct ClientEnvConfig {
+    profiles: HashMap<String, ClientEnvConfigProfile>,
+}
+
+impl From<CoreClientConfig> for ClientEnvConfig {
+    fn from(c: CoreClientConfig) -> Self {
+        Self {
+            profiles: c.profiles.into_iter().map(|(k, v)| (k, v.into())).collect(),
+        }
+    }
+}
+
+#[derive(Serialize)]
+struct ClientEnvConfigProfile {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    address: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    namespace: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    api_key: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    tls: Option<ClientEnvConfigTLS>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    codec: Option<ClientEnvConfigCodec>,
+    #[serde(skip_serializing_if = "HashMap::is_empty")]
+    grpc_meta: HashMap<String, String>,
+}
+
+impl From<CoreClientConfigProfile> for ClientEnvConfigProfile {
+    fn from(c: CoreClientConfigProfile) -> Self {
+        Self {
+            address: c.address,
+            namespace: c.namespace,
+            api_key: c.api_key,
+            tls: c.tls.map(Into::into),
+            codec: c.codec.map(Into::into),
+            grpc_meta: c.grpc_meta,
+        }
+    }
+}
+
+#[derive(Serialize)]
+struct ClientEnvConfigTLS {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    disabled: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    server_name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    server_ca_cert: Option<DataSource>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    client_cert: Option<DataSource>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    client_key: Option<DataSource>,
+}
+
+impl From<CoreClientConfigTLS> for ClientEnvConfigTLS {
+    fn from(c: CoreClientConfigTLS) -> Self {
+        Self {
+            disabled: c.disabled,
+            server_name: c.server_name,
+            server_ca_cert: c.server_ca_cert.map(Into::into),
+            client_cert: c.client_cert.map(Into::into),
+            client_key: c.client_key.map(Into::into),
+        }
+    }
+}
+
+#[derive(Serialize)]
+struct ClientEnvConfigCodec {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    endpoint: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    auth: Option<String>,
+}
+
+impl From<CoreClientConfigCodec> for ClientEnvConfigCodec {
+    fn from(c: CoreClientConfigCodec) -> Self {
+        Self {
+            endpoint: c.endpoint,
+            auth: c.auth,
+        }
+    }
+}
+
+#[derive(Serialize)]
+struct DataSource {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    path: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    data: Option<Vec<u8>>,
+}
+
+impl From<CoreDataSource> for DataSource {
+    fn from(c: CoreDataSource) -> Self {
+        match c {
+            CoreDataSource::Path(p) => Self {
+                path: Some(p),
+                data: None,
+            },
+            CoreDataSource::Data(d) => Self {
+                path: None,
+                data: Some(d),
+            },
+        }
+    }
+}
+
+// Helper functions
+fn parse_config_source(
+    path: &ByteArrayRef,
+    data: &ByteArrayRef,
+) -> Result<Option<CoreDataSource>, String> {
+    if !path.data.is_null() && path.size > 0 {
+        Ok(Some(CoreDataSource::Path(path.to_string())))
+    } else if !data.data.is_null() && data.size > 0 {
+        Ok(Some(CoreDataSource::Data(data.to_vec())))
+    } else {
+        Ok(None)
+    }
+}
+
+fn parse_env_vars(env_vars: &ByteArrayRef) -> Result<Option<HashMap<String, String>>, String> {
+    if env_vars.data.is_null() || env_vars.size == 0 {
+        return Ok(None);
+    }
+
+    let env_json = std::str::from_utf8(env_vars.to_slice())
+        .map_err(|e| format!("Invalid env vars UTF-8: {e}"))?;
+
+    serde_json::from_str(env_json)
+        .map(Some)
+        .map_err(|e| format!("Invalid env vars JSON: {e}"))
+}
+
+// Simple helper to handle serialization errors consistently
+fn serialize_or_error<T: Serialize>(data: T) -> Result<*const ByteArray, *const ByteArray> {
+    match serde_json::to_vec(&data) {
+        Ok(json_bytes) => {
+            let result = ByteArray::from_vec(json_bytes);
+            Ok(result.into_raw())
+        }
+        Err(e) => {
+            let err = ByteArray::from_utf8(format!("Failed to serialize: {e}"));
+            Err(err.into_raw())
+        }
+    }
+}
+
+/// Load all client profiles from given sources.
+/// Returns ClientConfigOrFail with either success JSON or error message.
+/// The returned ByteArrays must be freed by the caller.
+#[unsafe(no_mangle)]
+pub extern "C" fn temporal_core_client_env_config_load(
+    options: *const ClientEnvConfigLoadOptions,
+) -> ClientEnvConfigOrFail {
+    if options.is_null() {
+        let err = ByteArray::from_utf8("Options cannot be null".to_string());
+        return ClientEnvConfigOrFail {
+            success: std::ptr::null(),
+            fail: err.into_raw(),
+        };
+    }
+
+    let result = || -> Result<ClientEnvConfig, String> {
+        let opts = unsafe { &*options };
+        let env_vars_map = parse_env_vars(&opts.env_vars)?;
+
+        let load_options = LoadClientConfigOptions {
+            config_source: parse_config_source(&opts.path, &opts.data)?,
+            config_file_strict: opts.config_file_strict,
+        };
+
+        let core_config = envconfig::load_client_config(load_options, env_vars_map.as_ref())
+            .map_err(|e| e.to_string())?;
+
+        Ok(core_config.into())
+    };
+
+    match result() {
+        Ok(data) => match serialize_or_error(data) {
+            Ok(success) => ClientEnvConfigOrFail {
+                success,
+                fail: std::ptr::null(),
+            },
+            Err(fail) => ClientEnvConfigOrFail {
+                success: std::ptr::null(),
+                fail,
+            },
+        },
+        Err(e) => {
+            let err = ByteArray::from_utf8(e);
+            ClientEnvConfigOrFail {
+                success: std::ptr::null(),
+                fail: err.into_raw(),
+            }
+        }
+    }
+}
+
+/// Load a single client profile from given sources with env overrides.
+/// Returns ClientConfigProfileOrFail with either success JSON or error message.
+/// The returned ByteArrays must be freed by the caller.
+#[unsafe(no_mangle)]
+pub extern "C" fn temporal_core_client_env_config_profile_load(
+    options: *const ClientEnvConfigProfileLoadOptions,
+) -> ClientEnvConfigProfileOrFail {
+    if options.is_null() {
+        let err = ByteArray::from_utf8("Options cannot be null".to_string());
+        return ClientEnvConfigProfileOrFail {
+            success: std::ptr::null(),
+            fail: err.into_raw(),
+        };
+    }
+
+    let result = || -> Result<ClientEnvConfigProfile, String> {
+        let opts = unsafe { &*options };
+
+        let profile_name = if !opts.profile.data.is_null() && opts.profile.size > 0 {
+            Some(opts.profile.to_string())
+        } else {
+            None
+        };
+
+        let config_source = parse_config_source(&opts.path, &opts.data)?;
+        let env_vars_map = parse_env_vars(&opts.env_vars)?;
+
+        let load_options = LoadClientConfigProfileOptions {
+            config_source,
+            config_file_profile: profile_name,
+            config_file_strict: opts.config_file_strict,
+            disable_file: opts.disable_file,
+            disable_env: opts.disable_env,
+        };
+
+        let profile = envconfig::load_client_config_profile(load_options, env_vars_map.as_ref())
+            .map_err(|e| e.to_string())?;
+
+        Ok(profile.into())
+    };
+
+    match result() {
+        Ok(data) => match serialize_or_error(data) {
+            Ok(success) => ClientEnvConfigProfileOrFail {
+                success,
+                fail: std::ptr::null(),
+            },
+            Err(fail) => ClientEnvConfigProfileOrFail {
+                success: std::ptr::null(),
+                fail,
+            },
+        },
+        Err(e) => {
+            let err = ByteArray::from_utf8(e);
+            ClientEnvConfigProfileOrFail {
+                success: std::ptr::null(),
+                fail: err.into_raw(),
+            }
+        }
+    }
+}

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

@@ -9,6 +9,7 @@
 )]
 
 pub mod client;
+pub mod envconfig;
 pub mod metric;
 pub mod random;
 pub mod runtime;

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

@@ -32,9 +32,9 @@ pub extern "C" fn temporal_core_random_int32_range(
 ) -> i32 {
     let random = unsafe { &mut *random };
     if max_inclusive {
-        random.rand.gen_range(min..=max)
+        random.rand.random_range(min..=max)
     } else {
-        random.rand.gen_range(min..max)
+        random.rand.random_range(min..max)
     }
 }
 
@@ -47,9 +47,9 @@ pub extern "C" fn temporal_core_random_double_range(
 ) -> f64 {
     let random = unsafe { &mut *random };
     if max_inclusive {
-        random.rand.gen_range(min..=max)
+        random.rand.random_range(min..=max)
     } else {
-        random.rand.gen_range(min..max)
+        random.rand.random_range(min..max)
     }
 }
 

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

@@ -1,29 +1,28 @@
-use crate::ByteArray;
-use crate::ByteArrayRef;
-use crate::MetadataRef;
-use crate::metric::CustomMetricMeter;
-use crate::metric::CustomMetricMeterRef;
+use crate::{
+    ByteArray, ByteArrayRef, MetadataRef,
+    metric::{CustomMetricMeter, CustomMetricMeterRef},
+};
 
 use serde_json::json;
-use std::collections::HashMap;
-use std::fmt;
-use std::net::SocketAddr;
-use std::str::FromStr;
-use std::sync::atomic::AtomicBool;
-use std::sync::atomic::Ordering;
-use std::sync::{Arc, Mutex};
-use std::time::Duration;
-use std::time::UNIX_EPOCH;
-use temporal_sdk_core::CoreRuntime;
-use temporal_sdk_core::TokioRuntimeBuilder;
-use temporal_sdk_core::telemetry::{build_otlp_metric_exporter, start_prometheus_metric_exporter};
-use temporal_sdk_core_api::telemetry::HistogramBucketOverrides;
-use temporal_sdk_core_api::telemetry::MetricTemporality;
-use temporal_sdk_core_api::telemetry::metrics::CoreMeter;
-use temporal_sdk_core_api::telemetry::{CoreLog, CoreLogConsumer};
+use std::{
+    collections::HashMap,
+    fmt,
+    net::SocketAddr,
+    str::FromStr,
+    sync::{
+        Arc, Mutex,
+        atomic::{AtomicBool, Ordering},
+    },
+    time::{Duration, UNIX_EPOCH},
+};
+use temporal_sdk_core::{
+    CoreRuntime, TokioRuntimeBuilder,
+    telemetry::{build_otlp_metric_exporter, start_prometheus_metric_exporter},
+};
 use temporal_sdk_core_api::telemetry::{
-    Logger, OtelCollectorOptionsBuilder, PrometheusExporterOptionsBuilder,
-    TelemetryOptions as CoreTelemetryOptions, TelemetryOptionsBuilder,
+    CoreLog, CoreLogConsumer, HistogramBucketOverrides, Logger, MetricTemporality,
+    OtelCollectorOptionsBuilder, PrometheusExporterOptionsBuilder,
+    TelemetryOptions as CoreTelemetryOptions, TelemetryOptionsBuilder, metrics::CoreMeter,
 };
 use tracing::Level;
 use url::Url;

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

@@ -1,9 +1,6 @@
 use std::time::Duration;
 
-use crate::ByteArray;
-use crate::ByteArrayRef;
-use crate::UserDataHandle;
-use crate::runtime::Runtime;
+use crate::{ByteArray, ByteArrayRef, UserDataHandle, runtime::Runtime};
 
 use temporal_sdk_core::ephemeral_server;
 

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

@@ -1,28 +1,34 @@
-use crate::client::{
-    Client, ClientHttpConnectProxyOptions, ClientKeepAliveOptions, ClientRetryOptions,
-    ClientTlsOptions, RpcCallOptions, temporal_core_client_connect, temporal_core_client_free,
-    temporal_core_client_rpc_call,
-};
-use crate::runtime::{
-    Runtime, RuntimeOptions, RuntimeOrFail, temporal_core_byte_array_free,
-    temporal_core_runtime_free, temporal_core_runtime_new,
-};
-use crate::testing::{
-    DevServerOptions, EphemeralServer, TestServerOptions, temporal_core_ephemeral_server_free,
-    temporal_core_ephemeral_server_shutdown, temporal_core_ephemeral_server_start_dev_server,
+use crate::{
+    client::{
+        Client, ClientHttpConnectProxyOptions, ClientKeepAliveOptions, ClientRetryOptions,
+        ClientTlsOptions, RpcCallOptions, temporal_core_client_connect, temporal_core_client_free,
+        temporal_core_client_rpc_call,
+    },
+    runtime::{
+        Runtime, RuntimeOptions, RuntimeOrFail, temporal_core_byte_array_free,
+        temporal_core_runtime_free, temporal_core_runtime_new,
+    },
+    testing::{
+        DevServerOptions, EphemeralServer, TestServerOptions, temporal_core_ephemeral_server_free,
+        temporal_core_ephemeral_server_shutdown, temporal_core_ephemeral_server_start_dev_server,
+    },
 };
 
-use crate::tests::utils::{
-    MetadataMap, OwnedRpcCallOptions, RpcCallError, byte_array_to_string, byte_array_to_vec,
-    pointer_or_null,
+use crate::{
+    ByteArray, ByteArrayRef,
+    tests::utils::{
+        MetadataMap, OwnedRpcCallOptions, RpcCallError, byte_array_to_string, byte_array_to_vec,
+        pointer_or_null,
+    },
 };
-use crate::{ByteArray, ByteArrayRef};
 use anyhow::anyhow;
-use std::any::Any;
-use std::panic::{AssertUnwindSafe, UnwindSafe};
-use std::ptr::NonNull;
-use std::sync::{Arc, Condvar, Mutex, MutexGuard, PoisonError, Weak};
-use std::time::Duration;
+use std::{
+    any::Any,
+    panic::{AssertUnwindSafe, UnwindSafe},
+    ptr::NonNull,
+    sync::{Arc, Condvar, Mutex, MutexGuard, PoisonError, Weak},
+    time::Duration,
+};
 use temporal_client::ClientOptions;
 use temporal_sdk_core::ephemeral_server::{
     EphemeralExe, EphemeralExeVersion, TemporalDevServerConfig,
@@ -156,11 +162,7 @@ impl Context {
                 temporal_core_runtime_free(runtime);
                 ""
             };
-            Err(anyhow!(
-                "Runtime creation failed: {}{}",
-                runtime_is_null,
-                fail
-            ))
+            Err(anyhow!("Runtime creation failed: {runtime_is_null}{fail}"))
         } else if runtime.is_null() {
             Err(anyhow!("Runtime creation failed: runtime is null"))
         } else {
@@ -516,8 +518,7 @@ extern "C" fn ephemeral_server_start_callback(
 
             if let Some(fail) = fail {
                 ContextOperationState::CallbackError(anyhow!(
-                    "Ephemeral server start failed: {}",
-                    fail
+                    "Ephemeral server start failed: {fail}"
                 ))
             } else if server.is_null() {
                 ContextOperationState::CallbackError(anyhow!(
@@ -562,8 +563,7 @@ extern "C" fn ephemeral_server_shutdown_callback(
         let _ = context.complete_operation_catch_unwind(|guard| {
             if let Some(fail) = byte_array_to_string(guard.runtime, std::mem::take(&mut fail)) {
                 ContextOperationState::CallbackError(anyhow!(
-                    "Ephemeral server shutdown failed: {}",
-                    fail
+                    "Ephemeral server shutdown failed: {fail}"
                 ))
             } else {
                 ContextOperationState::CallbackOk(None)
@@ -585,7 +585,7 @@ extern "C" fn client_connect_callback(
     if let Some(context) = user_data.context.upgrade() {
         let _ = context.complete_operation_catch_unwind(|guard| {
             if let Some(fail) = byte_array_to_string(guard.runtime, std::mem::take(&mut fail)) {
-                ContextOperationState::CallbackError(anyhow!("Client connect failed: {}", fail))
+                ContextOperationState::CallbackError(anyhow!("Client connect failed: {fail}"))
             } else {
                 guard.client = std::mem::take(&mut client);
                 ContextOperationState::CallbackOk(None)

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

@@ -1,22 +1,26 @@
-use crate::ByteArrayRef;
-use crate::client::{
-    ClientGrpcOverrideRequest, ClientGrpcOverrideResponse, RpcService,
-    temporal_core_client_grpc_override_request_headers,
-    temporal_core_client_grpc_override_request_proto,
-    temporal_core_client_grpc_override_request_respond,
-    temporal_core_client_grpc_override_request_rpc,
-    temporal_core_client_grpc_override_request_service,
-};
-use crate::tests::utils::{
-    OwnedRpcCallOptions, RpcCallError, default_client_options, default_server_config,
+use crate::{
+    ByteArrayRef,
+    client::{
+        ClientGrpcOverrideRequest, ClientGrpcOverrideResponse, RpcService,
+        temporal_core_client_grpc_override_request_headers,
+        temporal_core_client_grpc_override_request_proto,
+        temporal_core_client_grpc_override_request_respond,
+        temporal_core_client_grpc_override_request_rpc,
+        temporal_core_client_grpc_override_request_service,
+    },
+    tests::utils::{
+        OwnedRpcCallOptions, RpcCallError, default_client_options, default_server_config,
+    },
 };
 use context::Context;
 use prost::Message;
 use std::sync::{Arc, LazyLock, Mutex};
-use temporal_sdk_core_protos::temporal::api::failure::v1::Failure;
-use temporal_sdk_core_protos::temporal::api::workflowservice::v1::{
-    GetSystemInfoRequest, GetSystemInfoResponse, QueryWorkflowRequest,
-    StartWorkflowExecutionRequest, StartWorkflowExecutionResponse,
+use temporal_sdk_core_protos::temporal::api::{
+    failure::v1::Failure,
+    workflowservice::v1::{
+        GetSystemInfoRequest, GetSystemInfoResponse, QueryWorkflowRequest,
+        StartWorkflowExecutionRequest, StartWorkflowExecutionResponse,
+    },
 };
 
 mod context;
@@ -313,7 +317,7 @@ fn test_simple_callback_override() {
             }))
             .unwrap();
         let start_resp = StartWorkflowExecutionResponse::decode(&*start_resp_raw).unwrap();
-        assert!(start_resp.run_id == "run-id for my-workflow-id");
+        assert_eq!(start_resp.run_id, "run-id for my-workflow-id");
 
         // Try a query where a query failure will actually be delivered as failure details.
         // However, we don't currently have temporal_sdk_core_protos::google::rpc::Status in
@@ -332,23 +336,23 @@ fn test_simple_callback_override() {
             .unwrap_err()
             .downcast::<RpcCallError>()
             .unwrap();
-        assert!(query_err.status_code == tonic::Code::Internal as u32);
-        assert!(query_err.message == "query-fail");
-        assert!(
+        assert_eq!(query_err.status_code, tonic::Code::Internal as u32);
+        assert_eq!(query_err.message, "query-fail");
+        assert_eq!(
             Failure::decode(query_err.details.as_ref().unwrap().as_slice())
                 .unwrap()
-                .message
-                == "intentional failure"
+                .message,
+            "intentional failure"
         );
 
         // Confirm we got the expected calls
-        assert!(
-            *CALLBACK_OVERRIDE_CALLS.lock().unwrap()
-                == vec![
-                    "service: temporal.api.workflowservice.v1.WorkflowService, rpc: GetSystemInfo",
-                    "service: temporal.api.workflowservice.v1.WorkflowService, rpc: StartWorkflowExecution",
-                    "service: temporal.api.workflowservice.v1.WorkflowService, rpc: QueryWorkflow"
-                ]
+        assert_eq!(
+            *CALLBACK_OVERRIDE_CALLS.lock().unwrap(),
+            vec![
+                "service: temporal.api.workflowservice.v1.WorkflowService, rpc: GetSystemInfo",
+                "service: temporal.api.workflowservice.v1.WorkflowService, rpc: StartWorkflowExecution",
+                "service: temporal.api.workflowservice.v1.WorkflowService, rpc: QueryWorkflow"
+            ]
         );
     });
 }

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

@@ -1,13 +1,13 @@
-use crate::client::RpcService;
-use crate::runtime::{Runtime, temporal_core_byte_array_free};
-use crate::{ByteArray, CancellationToken};
-use std::collections::HashMap;
-use std::ops::Deref;
+use crate::{
+    ByteArray, CancellationToken,
+    client::RpcService,
+    runtime::{Runtime, temporal_core_byte_array_free},
+};
+use std::{collections::HashMap, ops::Deref};
 use temporal_client::{ClientOptions, ClientOptionsBuilder};
 use temporal_sdk_core::ephemeral_server::{
-    TemporalDevServerConfig, TemporalDevServerConfigBuilder,
+    TemporalDevServerConfig, TemporalDevServerConfigBuilder, default_cached_download,
 };
-use temporal_sdk_core_test_utils::default_cached_download;
 use url::Url;
 
 pub fn byte_array_to_vec(runtime: *mut Runtime, byte_array: *const ByteArray) -> Option<Vec<u8>> {