@temporalio/core-bridge 0.19.2 → 0.20.2

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

@@ -1,142 +1,137 @@
-use std::str::FromStr;
+use log::LevelFilter;
+use std::{net::SocketAddr, str::FromStr};
+use temporal_sdk_core::{TelemetryOptionsBuilder, Url};
 use temporal_sdk_core_protos::coresdk::bridge;
 
 // Present for try-from only
-pub struct CoreInitOptions(pub bridge::InitRequest);
+pub struct InitTelemetryRequest(pub bridge::InitTelemetryRequest);
 
-impl TryFrom<CoreInitOptions> for temporal_sdk_core::CoreInitOptions {
+impl TryFrom<InitTelemetryRequest> for temporal_sdk_core::TelemetryOptions {
     type Error = String;
 
-    fn try_from(CoreInitOptions(req): CoreInitOptions) -> Result<Self, Self::Error> {
-        let mut core_opts = temporal_sdk_core::CoreInitOptionsBuilder::default();
-        if let Some(req_gateway_opts) = req.gateway_options {
-            let mut gateway_opts = temporal_sdk_core::ServerGatewayOptionsBuilder::default();
-            if !req_gateway_opts.target_url.is_empty() {
-                gateway_opts.target_url(
-                    temporal_sdk_core::Url::parse(&req_gateway_opts.target_url)
-                        .map_err(|err| format!("invalid target URL: {}", err))?,
-                );
+    fn try_from(InitTelemetryRequest(req): InitTelemetryRequest) -> Result<Self, Self::Error> {
+        let mut telemetry_opts = TelemetryOptionsBuilder::default();
+        if !req.otel_collector_url.is_empty() {
+            telemetry_opts.otel_collector_url(
+                Url::parse(&req.otel_collector_url)
+                    .map_err(|err| format!("invalid OpenTelemetry collector URL: {}", err))?,
+            );
+        }
+        if !req.tracing_filter.is_empty() {
+            telemetry_opts.tracing_filter(req.tracing_filter.clone());
+        }
+        match req.log_forwarding_level() {
+            bridge::LogLevel::Unspecified => {}
+            bridge::LogLevel::Off => {
+                telemetry_opts.log_forwarding_level(LevelFilter::Off);
             }
-            if !req_gateway_opts.namespace.is_empty() {
-                gateway_opts.namespace(req_gateway_opts.namespace);
+            bridge::LogLevel::Error => {
+                telemetry_opts.log_forwarding_level(LevelFilter::Error);
             }
-            if !req_gateway_opts.client_name.is_empty() {
-                gateway_opts.client_name(req_gateway_opts.client_name);
+            bridge::LogLevel::Warn => {
+                telemetry_opts.log_forwarding_level(LevelFilter::Warn);
             }
-            if !req_gateway_opts.client_version.is_empty() {
-                gateway_opts.client_version(req_gateway_opts.client_version);
+            bridge::LogLevel::Info => {
+                telemetry_opts.log_forwarding_level(LevelFilter::Info);
             }
-            if !req_gateway_opts.static_headers.is_empty() {
-                gateway_opts.static_headers(req_gateway_opts.static_headers);
+            bridge::LogLevel::Debug => {
+                telemetry_opts.log_forwarding_level(LevelFilter::Debug);
             }
-            if !req_gateway_opts.identity.is_empty() {
-                gateway_opts.identity(req_gateway_opts.identity);
+            bridge::LogLevel::Trace => {
+                telemetry_opts.log_forwarding_level(LevelFilter::Trace);
             }
-            if !req_gateway_opts.worker_binary_id.is_empty() {
-                gateway_opts.worker_binary_id(req_gateway_opts.worker_binary_id);
+        }
+        if !req.prometheus_export_bind_address.is_empty() {
+            telemetry_opts.prometheus_export_bind_address(
+                SocketAddr::from_str(&req.prometheus_export_bind_address)
+                    .map_err(|err| format!("invalid Prometheus address: {}", err))?,
+            );
+        }
+
+        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.static_headers.is_empty() {
+            client_opts.static_headers(req.static_headers);
+        }
+        if !req.identity.is_empty() {
+            client_opts.identity(req.identity);
+        }
+        if !req.worker_binary_id.is_empty() {
+            client_opts.worker_binary_id(req.worker_binary_id);
+        }
+        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 let Some(req_tls_config) = req_gateway_opts.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,
-                    })
-                }
-                gateway_opts.tls_cfg(tls_config);
+            if !req_tls_config.domain.is_empty() {
+                tls_config.domain = Some(req_tls_config.domain);
             }
-            if let Some(req_retry_config) = req_gateway_opts.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;
-                }
-                gateway_opts.retry_config(retry_config);
+            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,
+                })
             }
-            core_opts.gateway_opts(
-                gateway_opts
-                    .build()
-                    .map_err(|err| format!("invalid gateway options: {}", err))?,
-            );
+            client_opts.tls_cfg(tls_config);
         }
-        if let Some(req_telemetry_opts) = req.telemetry_options {
-            let mut telemetry_opts = temporal_sdk_core::TelemetryOptionsBuilder::default();
-            if !req_telemetry_opts.otel_collector_url.is_empty() {
-                telemetry_opts.otel_collector_url(
-                    temporal_sdk_core::Url::parse(&req_telemetry_opts.otel_collector_url)
-                        .map_err(|err| format!("invalid OpenTelemetry collector URL: {}", err))?,
-                );
+        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 !req_telemetry_opts.tracing_filter.is_empty() {
-                telemetry_opts.tracing_filter(req_telemetry_opts.tracing_filter.clone());
+            if let Some(v) = req_retry_config.randomization_factor {
+                retry_config.randomization_factor = v;
             }
-            match req_telemetry_opts.log_forwarding_level() {
-                bridge::LogLevel::Unspecified => {}
-                bridge::LogLevel::Off => {
-                    telemetry_opts.log_forwarding_level(log::LevelFilter::Off);
-                }
-                bridge::LogLevel::Error => {
-                    telemetry_opts.log_forwarding_level(log::LevelFilter::Error);
-                }
-                bridge::LogLevel::Warn => {
-                    telemetry_opts.log_forwarding_level(log::LevelFilter::Warn);
-                }
-                bridge::LogLevel::Info => {
-                    telemetry_opts.log_forwarding_level(log::LevelFilter::Info);
-                }
-                bridge::LogLevel::Debug => {
-                    telemetry_opts.log_forwarding_level(log::LevelFilter::Debug);
-                }
-                bridge::LogLevel::Trace => {
-                    telemetry_opts.log_forwarding_level(log::LevelFilter::Trace);
-                }
+            if let Some(v) = req_retry_config.multiplier {
+                retry_config.multiplier = v;
             }
-            if !req_telemetry_opts.prometheus_export_bind_address.is_empty() {
-                telemetry_opts.prometheus_export_bind_address(
-                    std::net::SocketAddr::from_str(
-                        &req_telemetry_opts.prometheus_export_bind_address,
-                    )
-                    .map_err(|err| format!("invalid Prometheus address: {}", err))?,
-                );
+            if let Some(v) = req_retry_config.max_interval {
+                retry_config.max_interval = v.try_into().map_err(|_| "invalid max interval")?;
             }
-            core_opts.telemetry_opts(
-                telemetry_opts
-                    .build()
-                    .map_err(|err| format!("invalid telemetry options: {}", err))?,
-            );
+            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);
         }
-        core_opts
+        client_opts
             .build()
-            .map_err(|err| format!("invalid options: {}", err))
+            .map_err(|err| format!("invalid client options: {}", err))
     }
 }
 
 // Present for try-from only
-pub struct WorkerConfig(pub bridge::RegisterWorkerRequest);
+pub struct WorkerConfig(pub bridge::CreateWorkerRequest);
 
 impl TryFrom<WorkerConfig> for temporal_sdk_core_api::worker::WorkerConfig {
     type Error = String;

package/sdk-core/client/Cargo.toml

@@ -2,25 +2,27 @@
 name = "temporal-client"
 version = "0.1.0"
 edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-[features]
-mocks = ["mockall"]
+authors = ["Spencer Judge <spencer@temporal.io>"]
+license-file = "LICENSE.txt"
+description = "Clients for interacting with Temporal Clusters"
+homepage = "https://temporal.io/"
+repository = "https://github.com/temporalio/sdk-core"
+keywords = ["temporal", "workflow"]
+categories = ["development-tools"]
 
 [dependencies]
 async-trait = "0.1"
-backoff = "0.3.0"
-derive_builder = "0.10"
+backoff = "0.4"
+derive_builder = "0.11"
 derive_more = "0.99"
 futures = "0.3"
 futures-retry = "0.6.0"
 http = "0.2"
-mockall = { version = "0.11.0", optional = true }
-opentelemetry = "0.16"
+opentelemetry = { version = "0.17", features = ["metrics"] }
 prost-types = "0.9"
 thiserror = "1.0"
 tokio = "1.1"
-tonic = "0.6"
+tonic = { version = "0.6", features = ["tls", "tls-roots"] }
 tower = "0.4"
 tracing = "0.1"
 url = "2.2"
@@ -30,3 +32,5 @@ uuid = { version = "0.8.2", features = ["v4"] }
 path = "../sdk-core-protos"
 version = "0.1"
 
+[dev-dependencies]
+mockall = "0.11"

package/sdk-core/client/LICENSE.txt

@@ -0,0 +1,23 @@
+Temporal Core SDK
+
+The MIT License
+
+Copyright (c) 2021 Temporal Technologies, Inc. All Rights Reserved
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.