@temporalio/core-bridge 1.5.2 → 1.7.0

package/sdk-core/bridge-ffi/src/wrappers.rs

@@ -1,221 +0,0 @@
-use std::{net::SocketAddr, str::FromStr};
-use temporal_sdk_core::Url;
-use temporal_sdk_core_api::telemetry::{
-    Logger, MetricsExporter, OtelCollectorOptions, TelemetryOptions, TelemetryOptionsBuilder,
-    TraceExportConfig, TraceExporter,
-};
-use temporal_sdk_core_protos::coresdk::bridge;
-
-// Present for try-from only
-pub struct InitTelemetryRequest(pub bridge::InitTelemetryRequest);
-
-impl TryFrom<InitTelemetryRequest> for TelemetryOptions {
-    type Error = String;
-
-    fn try_from(InitTelemetryRequest(req): InitTelemetryRequest) -> Result<Self, Self::Error> {
-        let mut telemetry_opts = TelemetryOptionsBuilder::default();
-        match req.logging {
-            None => {}
-            Some(bridge::init_telemetry_request::Logging::Console(_)) => {
-                telemetry_opts.logging(Logger::Console {
-                    filter: req.tracing_filter.clone(),
-                });
-            }
-            Some(bridge::init_telemetry_request::Logging::Forward(
-                bridge::init_telemetry_request::ForwardLoggerOptions { level },
-            )) => {
-                if let Some(_level) = bridge::LogLevel::from_i32(level) {
-                    // TODO: This is ignored now, but I'm not fixing since we may never use this.
-                    // let level = match level {
-                    //     bridge::LogLevel::Unspecified => {
-                    //         return Err("Must specify log level".to_string())
-                    //     }
-                    //     bridge::LogLevel::Off => LevelFilter::OFF,
-                    //     bridge::LogLevel::Error => LevelFilter::ERROR,
-                    //     bridge::LogLevel::Warn => LevelFilter::WARN,
-                    //     bridge::LogLevel::Info => LevelFilter::INFO,
-                    //     bridge::LogLevel::Debug => LevelFilter::DEBUG,
-                    //     bridge::LogLevel::Trace => LevelFilter::TRACE,
-                    // };
-                    telemetry_opts.logging(Logger::Forward {
-                        filter: req.tracing_filter.clone(),
-                    });
-                } else {
-                    return Err(format!("Unknown LogLevel: {}", level));
-                }
-            }
-        }
-        match req.metrics {
-            None => {}
-            Some(bridge::init_telemetry_request::Metrics::Prometheus(
-                bridge::init_telemetry_request::PrometheusOptions {
-                    export_bind_address,
-                },
-            )) => {
-                telemetry_opts.metrics(MetricsExporter::Prometheus(
-                    SocketAddr::from_str(&export_bind_address)
-                        .map_err(|err| format!("invalid Prometheus address: {}", err))?,
-                ));
-            }
-            Some(bridge::init_telemetry_request::Metrics::OtelMetrics(
-                bridge::init_telemetry_request::OtelCollectorOptions { url, headers },
-            )) => {
-                telemetry_opts.metrics(MetricsExporter::Otel(OtelCollectorOptions {
-                    url: Url::parse(&url).map_err(|err| {
-                        format!("invalid OpenTelemetry collector URL for metrics: {}", err)
-                    })?,
-                    headers,
-                    metric_periodicity: None,
-                }));
-            }
-        }
-        match req.tracing {
-            None => {}
-            Some(bridge::init_telemetry_request::Tracing::OtelTracing(
-                bridge::init_telemetry_request::OtelCollectorOptions { url, headers },
-            )) => {
-                telemetry_opts.tracing(TraceExportConfig {
-                    filter: req.tracing_filter.clone(),
-                    exporter: TraceExporter::Otel(OtelCollectorOptions {
-                        url: Url::parse(&url).map_err(|err| {
-                            format!("invalid OpenTelemetry collector URL for tracing: {}", err)
-                        })?,
-                        headers,
-                        metric_periodicity: None,
-                    }),
-                });
-            }
-        }
-
-        telemetry_opts
-            .build()
-            .map_err(|err| format!("invalid telemetry options: {}", err))
-    }
-}
-
-pub struct ClientOptions(pub bridge::CreateClientRequest);
-
-impl TryFrom<ClientOptions> for temporal_sdk_core::ClientOptions {
-    type Error = String;
-
-    fn try_from(ClientOptions(req): ClientOptions) -> Result<Self, Self::Error> {
-        let mut client_opts = temporal_sdk_core::ClientOptionsBuilder::default();
-        if !req.target_url.is_empty() {
-            client_opts.target_url(
-                temporal_sdk_core::Url::parse(&req.target_url)
-                    .map_err(|err| format!("invalid target URL: {}", err))?,
-            );
-        }
-        if !req.client_name.is_empty() {
-            client_opts.client_name(req.client_name);
-        }
-        if !req.client_version.is_empty() {
-            client_opts.client_version(req.client_version);
-        }
-        if !req.identity.is_empty() {
-            client_opts.identity(req.identity);
-        }
-        if let Some(req_tls_config) = req.tls_config {
-            let mut tls_config = temporal_sdk_core::TlsConfig::default();
-            if !req_tls_config.server_root_ca_cert.is_empty() {
-                tls_config.server_root_ca_cert = Some(req_tls_config.server_root_ca_cert);
-            }
-            if !req_tls_config.domain.is_empty() {
-                tls_config.domain = Some(req_tls_config.domain);
-            }
-            if !req_tls_config.client_cert.is_empty()
-                || !req_tls_config.client_private_key.is_empty()
-            {
-                tls_config.client_tls_config = Some(temporal_sdk_core::ClientTlsConfig {
-                    client_cert: req_tls_config.client_cert,
-                    client_private_key: req_tls_config.client_private_key,
-                })
-            }
-            client_opts.tls_cfg(tls_config);
-        }
-        if let Some(req_retry_config) = req.retry_config {
-            let mut retry_config = temporal_sdk_core::RetryConfig::default();
-            if let Some(v) = req_retry_config.initial_interval {
-                retry_config.initial_interval =
-                    v.try_into().map_err(|_| "invalid initial interval")?;
-            }
-            if let Some(v) = req_retry_config.randomization_factor {
-                retry_config.randomization_factor = v;
-            }
-            if let Some(v) = req_retry_config.multiplier {
-                retry_config.multiplier = v;
-            }
-            if let Some(v) = req_retry_config.max_interval {
-                retry_config.max_interval = v.try_into().map_err(|_| "invalid max interval")?;
-            }
-            if let Some(v) = req_retry_config.max_elapsed_time {
-                retry_config.max_elapsed_time =
-                    Some(v.try_into().map_err(|_| "invalid max elapsed time")?);
-            }
-            if let Some(v) = req_retry_config.max_retries {
-                retry_config.max_retries = v as usize;
-            }
-            client_opts.retry_config(retry_config);
-        }
-        client_opts
-            .build()
-            .map_err(|err| format!("invalid client options: {}", err))
-    }
-}
-
-// Present for try-from only
-pub struct WorkerConfig(pub bridge::CreateWorkerRequest);
-
-impl TryFrom<WorkerConfig> for temporal_sdk_core_api::worker::WorkerConfig {
-    type Error = String;
-
-    fn try_from(WorkerConfig(req): WorkerConfig) -> Result<Self, Self::Error> {
-        let mut config = temporal_sdk_core_api::worker::WorkerConfigBuilder::default();
-        if !req.task_queue.is_empty() {
-            config.task_queue(req.task_queue);
-        }
-        if let Some(v) = req.max_cached_workflows {
-            config.max_cached_workflows(v as usize);
-        }
-        if let Some(v) = req.max_outstanding_workflow_tasks {
-            config.max_outstanding_workflow_tasks(v as usize);
-        }
-        if let Some(v) = req.max_outstanding_activities {
-            config.max_outstanding_activities(v as usize);
-        }
-        if let Some(v) = req.max_outstanding_local_activities {
-            config.max_outstanding_local_activities(v as usize);
-        }
-        if let Some(v) = req.max_concurrent_wft_polls {
-            config.max_concurrent_wft_polls(v as usize);
-        }
-        if let Some(v) = req.nonsticky_to_sticky_poll_ratio {
-            config.nonsticky_to_sticky_poll_ratio(v);
-        }
-        if let Some(v) = req.max_concurrent_at_polls {
-            config.max_concurrent_at_polls(v as usize);
-        }
-        config.no_remote_activities(req.no_remote_activities);
-        if let Some(v) = req.sticky_queue_schedule_to_start_timeout {
-            let v: std::time::Duration = v
-                .try_into()
-                .map_err(|_| "invalid sticky queue schedule to start timeout".to_string())?;
-            config.sticky_queue_schedule_to_start_timeout(v);
-        }
-        if let Some(v) = req.max_heartbeat_throttle_interval {
-            let v: std::time::Duration = v
-                .try_into()
-                .map_err(|_| "invalid max heartbeat throttle interval".to_string())?;
-            config.max_heartbeat_throttle_interval(v);
-        }
-        if let Some(v) = req.default_heartbeat_throttle_interval {
-            let v: std::time::Duration = v
-                .try_into()
-                .map_err(|_| "invalid default heartbeat throttle interval".to_string())?;
-            config.default_heartbeat_throttle_interval(v);
-        }
-        config
-            .build()
-            .map_err(|err| format!("invalid request: {}", err))
-    }
-}

package/sdk-core/protos/local/temporal/sdk/core/bridge/bridge.proto

@@ -1,210 +0,0 @@
-syntax = "proto3";
-
-package coresdk.bridge;
-
-import "google/protobuf/duration.proto";
-import "google/protobuf/timestamp.proto";
-import "google/protobuf/wrappers.proto";
-import "temporal/sdk/core/core_interface.proto";
-import "temporal/sdk/core/activity_task/activity_task.proto";
-import "temporal/sdk/core/workflow_activation/workflow_activation.proto";
-import "temporal/sdk/core/workflow_completion/workflow_completion.proto";
-
-enum LogLevel {
-  LOG_LEVEL_UNSPECIFIED = 0;
-  OFF = 1;
-  ERROR = 2;
-  WARN = 3;
-  INFO = 4;
-  DEBUG = 5;
-  TRACE = 6;
-}
-
-message InitTelemetryRequest {
-  string tracing_filter = 1;
-  oneof logging {
-    ConsoleLoggerOptions console = 2;
-    ForwardLoggerOptions forward = 3;
-  };
-
-  oneof tracing {
-    OtelCollectorOptions otel_tracing = 4;
-  }
-
-  oneof metrics {
-    OtelCollectorOptions otel_metrics = 5;
-    PrometheusOptions prometheus = 6;
-  }
-
-  message ConsoleLoggerOptions {}
-  message ForwardLoggerOptions {
-    LogLevel level = 1;
-  }
-
-  message OtelCollectorOptions {
-    string url = 1;
-    map<string, string> headers = 2;
-  }
-  message PrometheusOptions {
-    string export_bind_address = 1;
-  }
-}
-
-message CreateClientRequest {
-  string target_url = 1;
-  string namespace = 2;
-  string client_name = 3;
-  string client_version = 4;
-  string identity = 6;
-  TlsConfig tls_config = 8;
-  RetryConfig retry_config = 9;
-
-  message TlsConfig {
-    bytes server_root_ca_cert = 1;
-    string domain = 2;
-    bytes client_cert = 3;
-    bytes client_private_key = 4;
-  }
-
-  message RetryConfig {
-    google.protobuf.Duration initial_interval = 1;
-    google.protobuf.DoubleValue randomization_factor = 2;
-    google.protobuf.DoubleValue multiplier = 3;
-    google.protobuf.Duration max_interval = 4;
-    google.protobuf.Duration max_elapsed_time = 5;
-    google.protobuf.UInt32Value max_retries = 6;
-  }
-}
-
-message InitResponse {
-  Error error = 1;
-
-  message Error {
-    string message = 1;
-  }
-}
-
-message CreateWorkerRequest {
-  string task_queue = 1;
-  google.protobuf.UInt32Value max_cached_workflows = 2;
-  google.protobuf.UInt32Value max_outstanding_workflow_tasks = 3;
-  google.protobuf.UInt32Value max_outstanding_activities = 4;
-  google.protobuf.UInt32Value max_outstanding_local_activities = 5;
-  google.protobuf.UInt32Value max_concurrent_wft_polls = 6;
-  google.protobuf.FloatValue nonsticky_to_sticky_poll_ratio = 7;
-  google.protobuf.UInt32Value max_concurrent_at_polls = 8;
-  bool no_remote_activities = 9;
-  google.protobuf.Duration sticky_queue_schedule_to_start_timeout = 10;
-  google.protobuf.Duration max_heartbeat_throttle_interval = 11;
-  google.protobuf.Duration default_heartbeat_throttle_interval = 12;
-}
-
-message RegisterWorkerResponse {
-  Error error = 1;
-
-  message Error {
-    string message = 1;
-  }
-}
-
-message PollWorkflowActivationRequest {
-}
-
-message PollWorkflowActivationResponse {
-  oneof response {
-    coresdk.workflow_activation.WorkflowActivation activation = 1;
-    Error error = 2;
-  }
-
-  message Error {
-    string message = 1;
-    bool shutdown = 2;
-  }
-}
-
-message PollActivityTaskRequest {
-}
-
-message PollActivityTaskResponse {
-  oneof response {
-    coresdk.activity_task.ActivityTask task = 1;
-    Error error = 2;
-  }
-
-  message Error {
-    string message = 1;
-    bool shutdown = 2;
-  }
-}
-
-message CompleteWorkflowActivationRequest {
-  coresdk.workflow_completion.WorkflowActivationCompletion completion = 1;
-}
-
-message CompleteWorkflowActivationResponse {
-  Error error = 1;
-
-  message Error {
-    string message = 1;
-  }
-}
-
-message CompleteActivityTaskRequest {
-  coresdk.ActivityTaskCompletion completion = 1;
-}
-
-message CompleteActivityTaskResponse {
-  Error error = 1;
-
-  message Error {
-    string message = 1;
-  }
-}
-
-message RecordActivityHeartbeatRequest {
-  coresdk.ActivityHeartbeat heartbeat = 1;
-}
-
-message RecordActivityHeartbeatResponse {
-  Error error = 1;
-
-  message Error {
-    string message = 1;
-  }
-}
-
-message RequestWorkflowEvictionRequest {
-  string run_id = 1;
-}
-
-message RequestWorkflowEvictionResponse {
-  Error error = 1;
-
-  message Error {
-    string message = 1;
-  }
-}
-
-message ShutdownWorkerRequest {
-}
-
-message ShutdownWorkerResponse {
-  Error error = 1;
-
-  message Error {
-    string message = 1;
-  }
-}
-
-message FetchBufferedLogsRequest {
-}
-
-message FetchBufferedLogsResponse {
-  repeated LogEntry entries = 1;
-
-  message LogEntry {
-    string message = 1;
-    google.protobuf.Timestamp timestamp = 2;
-    LogLevel level = 3;
-  }
-}

package/sdk-core/sdk/src/conversions.rs

@@ -1,8 +0,0 @@
-use temporal_sdk_core_protos::temporal::api::failure::v1::Failure;
-
-pub(crate) fn anyhow_to_fail(e: anyhow::Error) -> Failure {
-    Failure {
-        message: e.to_string(),
-        ..Default::default()
-    }
-}