temporalio 0.0.1 → 0.0.2

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

@@ -1,211 +0,0 @@
-use log::LevelFilter;
-use std::{net::SocketAddr, str::FromStr};
-use temporal_sdk_core::{
-    Logger, MetricsExporter, OtelCollectorOptions, TelemetryOptionsBuilder, TraceExporter, Url,
-};
-use temporal_sdk_core_protos::coresdk::bridge;
-
-// Present for try-from only
-pub struct InitTelemetryRequest(pub bridge::InitTelemetryRequest);
-
-impl TryFrom<InitTelemetryRequest> for temporal_sdk_core::TelemetryOptions {
-    type Error = String;
-
-    fn try_from(InitTelemetryRequest(req): InitTelemetryRequest) -> Result<Self, Self::Error> {
-        let mut telemetry_opts = TelemetryOptionsBuilder::default();
-        telemetry_opts.tracing_filter(req.tracing_filter.clone());
-        match req.logging {
-            None => {}
-            Some(bridge::init_telemetry_request::Logging::Console(_)) => {
-                telemetry_opts.logging(Logger::Console);
-            }
-            Some(bridge::init_telemetry_request::Logging::Forward(
-                bridge::init_telemetry_request::ForwardLoggerOptions { level },
-            )) => {
-                if let Some(level) = bridge::LogLevel::from_i32(level) {
-                    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(level));
-                } 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,
-                }));
-            }
-        }
-        match req.tracing {
-            None => {}
-            Some(bridge::init_telemetry_request::Tracing::OtelTracing(
-                bridge::init_telemetry_request::OtelCollectorOptions { url, headers },
-            )) => {
-                telemetry_opts.tracing(TraceExporter::Otel(OtelCollectorOptions {
-                    url: Url::parse(&url).map_err(|err| {
-                        format!("invalid OpenTelemetry collector URL for tracing: {}", err)
-                    })?,
-                    headers,
-                }));
-            }
-        }
-
-        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))
-    }
-}

data/bridge/sdk-core/core/src/log_export.rs

@@ -1,62 +0,0 @@
-use log::{LevelFilter, Log, Metadata, Record};
-use ringbuf::{Consumer, Producer, RingBuffer};
-use std::{sync::Mutex, time::SystemTime};
-use temporal_sdk_core_api::CoreLog;
-
-pub(crate) struct CoreExportLogger {
-    logs_in: Mutex<Producer<CoreLog>>,
-    logs_out: Mutex<Consumer<CoreLog>>,
-    level_filter: LevelFilter,
-}
-
-impl CoreExportLogger {
-    pub(crate) fn new(level: LevelFilter) -> Self {
-        let (lin, lout) = RingBuffer::new(2048).split();
-        Self {
-            logs_in: Mutex::new(lin),
-            logs_out: Mutex::new(lout),
-            level_filter: level,
-        }
-    }
-
-    pub(crate) fn drain(&self) -> Vec<CoreLog> {
-        let mut lout = self
-            .logs_out
-            .lock()
-            .expect("Logging output mutex must be acquired");
-        let mut retme = Vec::with_capacity(lout.len());
-        lout.pop_each(
-            |el| {
-                retme.push(el);
-                true
-            },
-            None,
-        );
-        retme
-    }
-}
-
-impl Log for CoreExportLogger {
-    fn enabled(&self, metadata: &Metadata) -> bool {
-        // Never forward logging from other crates
-        if !metadata.target().contains("temporal_sdk_core") {
-            return false;
-        }
-        metadata.level() <= self.level_filter
-    }
-
-    fn log(&self, record: &Record) {
-        let clog = CoreLog {
-            message: format!("[{}] {}", record.target(), record.args()),
-            timestamp: SystemTime::now(),
-            level: record.level(),
-        };
-        let _ = self
-            .logs_in
-            .lock()
-            .expect("Logging mutex must be acquired")
-            .push(clog);
-    }
-
-    fn flush(&self) {}
-}

data/bridge/sdk-core/core/src/worker/workflow/machines/mutable_side_effect_state_machine.rs

@@ -1,127 +0,0 @@
-use rustfsm::{fsm, TransitionResult};
-
-fsm! {
-    pub(super) name MutableSideEffectMachine; command MutableSideEffectCommand; error MutableSideEffectMachineError;
-
-    Created --(CheckExecutionState, on_check_execution_state) --> Replaying;
-    Created --(CheckExecutionState, on_check_execution_state) --> Executing;
-
-    Executing --(Schedule, on_schedule) --> MarkerCommandCreated;
-    Executing --(Schedule, on_schedule) --> Skipped;
-
-    MarkerCommandCreated --(CommandRecordMarker, on_command_record_marker) --> ResultNotified;
-
-    MarkerCommandCreatedReplaying --(CommandRecordMarker) --> ResultNotifiedReplaying;
-
-    Replaying --(Schedule, on_schedule) --> MarkerCommandCreatedReplaying;
-
-    ResultNotified --(MarkerRecorded, on_marker_recorded) --> MarkerCommandRecorded;
-
-    ResultNotifiedReplaying --(NonMatchingEvent, on_non_matching_event) --> SkippedNotified;
-    ResultNotifiedReplaying --(MarkerRecorded, on_marker_recorded) --> MarkerCommandRecorded;
-    ResultNotifiedReplaying --(MarkerRecorded, on_marker_recorded) --> SkippedNotified;
-
-    Skipped --(CommandRecordMarker, on_command_record_marker) --> SkippedNotified;
-}
-
-#[derive(thiserror::Error, Debug)]
-pub(super) enum MutableSideEffectMachineError {}
-
-pub(super) enum MutableSideEffectCommand {}
-
-#[derive(Default, Clone)]
-pub(super) struct Created {}
-
-impl Created {
-    pub(super) fn on_check_execution_state(
-        self,
-    ) -> MutableSideEffectMachineTransition<ReplayingOrExecuting> {
-        unimplemented!()
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct Executing {}
-
-impl Executing {
-    pub(super) fn on_schedule(
-        self,
-    ) -> MutableSideEffectMachineTransition<MarkerCommandCreatedOrSkipped> {
-        unimplemented!()
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct MarkerCommandCreated {}
-
-impl MarkerCommandCreated {
-    pub(super) fn on_command_record_marker(
-        self,
-    ) -> MutableSideEffectMachineTransition<ResultNotified> {
-        unimplemented!()
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct MarkerCommandCreatedReplaying {}
-
-#[derive(Default, Clone)]
-pub(super) struct MarkerCommandRecorded {}
-
-#[derive(Default, Clone)]
-pub(super) struct Replaying {}
-
-impl Replaying {
-    pub(super) fn on_schedule(
-        self,
-    ) -> MutableSideEffectMachineTransition<MarkerCommandCreatedReplaying> {
-        unimplemented!()
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct ResultNotified {}
-
-impl ResultNotified {
-    pub(super) fn on_marker_recorded(
-        self,
-    ) -> MutableSideEffectMachineTransition<MarkerCommandRecorded> {
-        unimplemented!()
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct ResultNotifiedReplaying {}
-
-impl ResultNotifiedReplaying {
-    pub(super) fn on_non_matching_event(
-        self,
-    ) -> MutableSideEffectMachineTransition<SkippedNotified> {
-        unimplemented!()
-    }
-    pub(super) fn on_marker_recorded(
-        self,
-    ) -> MutableSideEffectMachineTransition<MarkerCommandRecordedOrSkippedNotified> {
-        unimplemented!()
-    }
-}
-
-impl From<MarkerCommandCreatedReplaying> for ResultNotifiedReplaying {
-    fn from(_: MarkerCommandCreatedReplaying) -> Self {
-        Self::default()
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct Skipped {}
-
-impl Skipped {
-    pub(super) fn on_command_record_marker(
-        self,
-    ) -> MutableSideEffectMachineTransition<SkippedNotified> {
-        unimplemented!()
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct SkippedNotified {}

data/bridge/sdk-core/core/src/worker/workflow/machines/side_effect_state_machine.rs

@@ -1,71 +0,0 @@
-use rustfsm::{fsm, TransitionResult};
-
-fsm! {
-    pub(super) name SideEffectMachine; command SideEffectCommand; error SideEffectMachineError;
-
-    Created --(Schedule, on_schedule) --> MarkerCommandCreated;
-    Created --(Schedule, on_schedule) --> MarkerCommandCreatedReplaying;
-
-    MarkerCommandCreated --(CommandRecordMarker, on_command_record_marker) --> ResultNotified;
-
-    MarkerCommandCreatedReplaying --(CommandRecordMarker) --> ResultNotifiedReplaying;
-
-    ResultNotified --(MarkerRecorded, on_marker_recorded) --> MarkerCommandRecorded;
-
-    ResultNotifiedReplaying --(MarkerRecorded, on_marker_recorded) --> MarkerCommandRecorded;
-}
-
-#[derive(thiserror::Error, Debug)]
-pub(super) enum SideEffectMachineError {}
-
-pub(super) enum SideEffectCommand {}
-
-#[derive(Default, Clone)]
-pub(super) struct Created {}
-
-impl Created {
-    pub(super) fn on_schedule(
-        self,
-    ) -> SideEffectMachineTransition<MarkerCommandCreatedOrMarkerCommandCreatedReplaying> {
-        unimplemented!()
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct MarkerCommandCreated {}
-
-impl MarkerCommandCreated {
-    pub(super) fn on_command_record_marker(self) -> SideEffectMachineTransition<ResultNotified> {
-        unimplemented!()
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct MarkerCommandCreatedReplaying {}
-
-#[derive(Default, Clone)]
-pub(super) struct MarkerCommandRecorded {}
-
-#[derive(Default, Clone)]
-pub(super) struct ResultNotified {}
-
-impl ResultNotified {
-    pub(super) fn on_marker_recorded(self) -> SideEffectMachineTransition<MarkerCommandRecorded> {
-        unimplemented!()
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct ResultNotifiedReplaying {}
-
-impl ResultNotifiedReplaying {
-    pub(super) fn on_marker_recorded(self) -> SideEffectMachineTransition<MarkerCommandRecorded> {
-        unimplemented!()
-    }
-}
-
-impl From<MarkerCommandCreatedReplaying> for ResultNotifiedReplaying {
-    fn from(_: MarkerCommandCreatedReplaying) -> Self {
-        Self::default()
-    }
-}

data/bridge/sdk-core/protos/api_upstream/temporal/api/cluster/v1/message.proto

@@ -1,83 +0,0 @@
-// The MIT License
-//
-// Copyright (c) 2022 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.
-
-syntax = "proto3";
-
-package temporal.api.cluster.v1;
-
-option go_package = "go.temporal.io/api/cluster/v1;cluster";
-option java_package = "io.temporal.api.cluster.v1";
-option java_multiple_files = true;
-option java_outer_classname = "MessageProto";
-option ruby_package = "Temporal::Api::Cluster::V1";
-option csharp_namespace = "Temporal.Api.Cluster.V1";
-
-import "dependencies/gogoproto/gogo.proto";
-import "google/protobuf/timestamp.proto";
-
-import "temporal/api/enums/v1/cluster.proto";
-import "temporal/api/enums/v1/common.proto";
-import "temporal/api/version/v1/message.proto";
-
-// data column
-message ClusterMetadata {
-  string cluster = 1;
-  int32 history_shard_count = 2;
-  string cluster_id = 3;
-  temporal.api.version.v1.VersionInfo version_info = 4;
-  map<string,IndexSearchAttributes> index_search_attributes = 5;
-  string cluster_address = 6;
-  int64 failover_version_increment = 7;
-  int64 initial_failover_version = 8;
-  bool is_global_namespace_enabled = 9;
-  bool is_connection_enabled = 10;
-}
-
-message IndexSearchAttributes{
-  map<string,temporal.api.enums.v1.IndexedValueType> custom_search_attributes = 1;
-}
-
-message HostInfo {
-  string identity = 1;
-}
-
-message RingInfo {
-  string role = 1;
-  int32 member_count = 2;
-  repeated HostInfo members = 3;
-}
-
-message MembershipInfo {
-  HostInfo current_host = 1;
-  repeated string reachable_members = 2;
-  repeated RingInfo rings = 3;
-}
-
-message ClusterMember {
-  temporal.api.enums.v1.ClusterMemberRole role = 1;
-  string host_id = 2;
-  string rpc_address = 3;
-  int32 rpc_port = 4;
-  google.protobuf.Timestamp session_start_time = 5 [(gogoproto.stdtime) = true];
-  google.protobuf.Timestamp last_heartbit_time = 6 [(gogoproto.stdtime) = true];
-  google.protobuf.Timestamp record_expiry_time = 7 [(gogoproto.stdtime) = true];
-}