@temporalio/core-bridge 0.16.4 → 0.18.0

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

@@ -0,0 +1,193 @@
+use std::str::FromStr;
+use temporal_sdk_core_protos::coresdk::bridge;
+
+// Present for try-from only
+pub struct CoreInitOptions(pub bridge::InitRequest);
+
+impl TryFrom<CoreInitOptions> for temporal_sdk_core::CoreInitOptions {
+    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))?,
+                );
+            }
+            if !req_gateway_opts.namespace.is_empty() {
+                gateway_opts.namespace(req_gateway_opts.namespace);
+            }
+            if !req_gateway_opts.client_name.is_empty() {
+                gateway_opts.client_name(req_gateway_opts.client_name);
+            }
+            if !req_gateway_opts.client_version.is_empty() {
+                gateway_opts.client_version(req_gateway_opts.client_version);
+            }
+            if !req_gateway_opts.static_headers.is_empty() {
+                gateway_opts.static_headers(req_gateway_opts.static_headers);
+            }
+            if !req_gateway_opts.identity.is_empty() {
+                gateway_opts.identity(req_gateway_opts.identity);
+            }
+            if !req_gateway_opts.worker_binary_id.is_empty() {
+                gateway_opts.worker_binary_id(req_gateway_opts.worker_binary_id);
+            }
+            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 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);
+            }
+            core_opts.gateway_opts(
+                gateway_opts
+                    .build()
+                    .map_err(|err| format!("invalid gateway options: {}", err))?,
+            );
+        }
+        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 !req_telemetry_opts.tracing_filter.is_empty() {
+                telemetry_opts.tracing_filter(req_telemetry_opts.tracing_filter.clone());
+            }
+            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 !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))?,
+                );
+            }
+            core_opts.telemetry_opts(
+                telemetry_opts
+                    .build()
+                    .map_err(|err| format!("invalid telemetry options: {}", err))?,
+            );
+        }
+        core_opts
+            .build()
+            .map_err(|err| format!("invalid options: {}", err))
+    }
+}
+
+// Present for try-from only
+pub struct WorkerConfig(pub bridge::RegisterWorkerRequest);
+
+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/client/Cargo.toml

@@ -0,0 +1,32 @@
+[package]
+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"]
+
+[dependencies]
+async-trait = "0.1"
+backoff = "0.3.0"
+derive_builder = "0.10"
+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"
+prost-types = "0.9"
+thiserror = "1.0"
+tokio = "1.1"
+tonic = "0.6"
+tower = "0.4"
+tracing = "0.1"
+url = "2.2"
+uuid = { version = "0.8.2", features = ["v4"] }
+
+[dependencies.temporal-sdk-core-protos]
+path = "../sdk-core-protos"
+version = "0.1"
+

package/sdk-core/{src/pollers/gateway.rs → client/src/lib.rs}

@@ -1,33 +1,50 @@
-use crate::{
-    pollers::{retry::RetryGateway, Result},
-    protosext::WorkflowTaskCompletion,
-    task_token::TaskToken,
-    telemetry::metrics::{svc_operation, MetricsContext},
-    CoreInitError,
-};
+#![warn(missing_docs)] // error if there are missing docs
+
+//! This crate contains client implementations that can be used to contact the Temporal service.
+//!
+//! It implements auto-retry behavior and metrics collection.
+
+#[macro_use]
+extern crate tracing;
+
+mod metrics;
+#[cfg(any(feature = "mocks", test))]
+pub mod mocks;
+mod retry;
+
+pub use crate::retry::RetryGateway;
+#[cfg(any(feature = "mocks", test))]
+pub use mocks::MockManualGateway;
+
+use crate::metrics::{svc_operation, MetricsContext};
 use backoff::{ExponentialBackoff, SystemClock};
 use futures::{future::BoxFuture, task::Context, FutureExt};
+use http::uri::InvalidUri;
+use opentelemetry::metrics::Meter;
 use std::{
+    collections::HashMap,
     fmt::{Debug, Formatter},
-    ops::Deref,
-    sync::Arc,
+    str::FromStr,
     task::Poll,
     time::{Duration, Instant},
 };
 use temporal_sdk_core_protos::{
     coresdk::{common::Payload, workflow_commands::QueryResult, IntoPayloadsExt},
     temporal::api::{
+        command::v1::Command,
         common::v1::{Payloads, WorkflowExecution, WorkflowType},
         enums::v1::{TaskQueueKind, WorkflowTaskFailedCause},
         failure::v1::Failure,
         query::v1::{WorkflowQuery, WorkflowQueryResult},
-        taskqueue::v1::TaskQueue,
+        taskqueue::v1::{StickyExecutionAttributes, TaskQueue},
         workflowservice::v1::{workflow_service_client::WorkflowServiceClient, *},
     },
+    TaskToken,
 };
 use tonic::{
     body::BoxBody,
     codegen::{InterceptedService, Service},
+    metadata::{MetadataKey, MetadataValue},
     service::Interceptor,
     transport::{Certificate, Channel, Endpoint, Identity},
     IntoRequest, Status,
@@ -36,37 +53,15 @@ use tower::ServiceBuilder;
 use url::Url;
 use uuid::Uuid;
 
-#[cfg(test)]
+#[cfg(any(feature = "mocks", test))]
 use futures::Future;
-use std::{collections::HashMap, str::FromStr};
-use tonic::metadata::{MetadataKey, MetadataValue};
 
 static LONG_POLL_METHOD_NAMES: [&str; 2] = ["PollWorkflowTaskQueue", "PollActivityTaskQueue"];
 /// The server times out polls after 60 seconds. Set our timeout to be slightly beyond that.
 const LONG_POLL_TIMEOUT: Duration = Duration::from_secs(70);
 const OTHER_CALL_TIMEOUT: Duration = Duration::from_secs(30);
 
-pub struct GatewayRef {
-    pub gw: Arc<dyn ServerGatewayApis + Send + Sync>,
-    pub options: ServerGatewayOptions,
-}
-
-impl GatewayRef {
-    pub fn new<SG: ServerGatewayApis + Send + Sync + 'static>(
-        gw: Arc<SG>,
-        options: ServerGatewayOptions,
-    ) -> Self {
-        Self { gw, options }
-    }
-}
-
-impl Deref for GatewayRef {
-    type Target = dyn ServerGatewayApis + Send + Sync;
-
-    fn deref(&self) -> &Self::Target {
-        self.gw.as_ref()
-    }
-}
+type Result<T, E = tonic::Status> = std::result::Result<T, E>;
 
 /// Options for the connection to the temporal server. Construct with [ServerGatewayOptionsBuilder]
 #[derive(Clone, Debug, derive_builder::Builder)]
@@ -199,14 +194,33 @@ impl Debug for ClientTlsConfig {
     }
 }
 
+/// Errors thrown while attempting to establish a connection to the server
+#[derive(thiserror::Error, Debug)]
+pub enum GatewayInitError {
+    /// Invalid URI. Configuration error, fatal.
+    #[error("Invalid URI: {0:?}")]
+    InvalidUri(#[from] InvalidUri),
+    /// Server connection error. Crashing and restarting the worker is likely best.
+    #[error("Server connection error: {0:?}")]
+    TonicTransportError(#[from] tonic::transport::Error),
+}
+
 impl ServerGatewayOptions {
     /// Attempt to establish a connection to the Temporal server
-    pub async fn connect(&self) -> Result<RetryGateway<ServerGateway>, CoreInitError> {
+    pub async fn connect(
+        &self,
+        metrics_meter: Option<&Meter>,
+    ) -> Result<RetryGateway<ServerGateway>, GatewayInitError> {
         let channel = Channel::from_shared(self.target_url.to_string())?;
         let channel = self.add_tls_to_channel(channel).await?;
         let channel = channel.connect().await?;
         let service = ServiceBuilder::new()
-            .layer_fn(|c| GrpcMetricSvc::new(c, MetricsContext::top_level(self.namespace.clone())))
+            .layer_fn(|channel| {
+                GrpcMetricSvc::new(
+                    channel,
+                    metrics_meter.map(|mm| MetricsContext::top_level(self.namespace.clone(), mm)),
+                )
+            })
             .service(channel);
         let interceptor = ServiceCallInterceptor { opts: self.clone() };
         let service = WorkflowServiceClient::with_interceptor(service, interceptor);
@@ -220,7 +234,10 @@ impl ServerGatewayOptions {
 
     /// If TLS is configured, set the appropriate options on the provided channel and return it.
     /// Passes it through if TLS options not set.
-    async fn add_tls_to_channel(&self, channel: Endpoint) -> Result<Endpoint, CoreInitError> {
+    async fn add_tls_to_channel(
+        &self,
+        channel: Endpoint,
+    ) -> Result<Endpoint, tonic::transport::Error> {
         if let Some(tls_cfg) = &self.tls_cfg {
             let mut tls = tonic::transport::ClientTlsConfig::new();
 
@@ -239,14 +256,32 @@ impl ServerGatewayOptions {
                 tls = tls.identity(client_identity);
             }
 
-            return Ok(channel.tls_config(tls)?);
+            return channel.tls_config(tls);
         }
         Ok(channel)
     }
 }
 
+/// A version of [RespondWorkflowTaskCompletedRequest] that will finish being filled out by the
+/// server client
+#[derive(Debug, Clone, PartialEq)]
+pub struct WorkflowTaskCompletion {
+    /// The task token that would've been received from polling for a workflow activation
+    pub task_token: TaskToken,
+    /// A list of new commands to send to the server, such as starting a timer.
+    pub commands: Vec<Command>,
+    /// If set, indicate that next task should be queued on sticky queue with given attributes.
+    pub sticky_attributes: Option<StickyExecutionAttributes>,
+    /// Responses to queries in the `queries` field of the workflow task.
+    pub query_responses: Vec<QueryResult>,
+    /// Indicate that the task completion should return a new WFT if one is available
+    pub return_new_workflow_task: bool,
+    /// Force a new WFT to be created after this completion
+    pub force_create_new_workflow_task: bool,
+}
+
 #[derive(Clone)]
-pub struct ServiceCallInterceptor {
+struct ServiceCallInterceptor {
     opts: ServerGatewayOptions,
 }
 
@@ -286,7 +321,8 @@ impl Interceptor for ServiceCallInterceptor {
 #[derive(derive_more::Constructor, Debug, Clone)]
 pub(crate) struct GrpcMetricSvc {
     inner: Channel,
-    metrics: MetricsContext,
+    // If set to none, metrics are a no-op
+    metrics: Option<MetricsContext>,
 }
 
 impl Service<http::Request<BoxBody>> for GrpcMetricSvc {
@@ -299,21 +335,17 @@ impl Service<http::Request<BoxBody>> for GrpcMetricSvc {
     }
 
     fn call(&mut self, req: http::Request<BoxBody>) -> Self::Future {
-        let metrics = req
-            .uri()
-            .to_string()
-            .rsplitn(2, '/')
-            .next()
-            .map(|method_name| {
-                let mut metrics = self
-                    .metrics
-                    .with_new_attrs([svc_operation(method_name.to_string())]);
+        let metrics = self.metrics.as_ref().and_then(|metrics| {
+            req.uri().to_string().rsplit_once('/').map(|split_tup| {
+                let method_name = split_tup.1;
+                let mut metrics = metrics.with_new_attrs([svc_operation(method_name.to_string())]);
                 if LONG_POLL_METHOD_NAMES.contains(&method_name) {
                     metrics.set_is_long_poll();
                 }
                 metrics.svc_request();
                 metrics
-            });
+            })
+        });
         let callfut = self.inner.call(req);
         async move {
             let started = Instant::now();
@@ -340,7 +372,7 @@ pub struct ServerGateway {
 }
 
 /// This trait provides ways to call the temporal server
-#[cfg_attr(test, mockall::automock)]
+#[cfg_attr(any(feature = "mocks", test), mockall::automock)]
 #[async_trait::async_trait]
 pub trait ServerGatewayApis {
     /// Starts workflow execution.
@@ -366,8 +398,8 @@ pub trait ServerGatewayApis {
     async fn poll_activity_task(&self, task_queue: String)
         -> Result<PollActivityTaskQueueResponse>;
 
-    /// Notifies the server that workflow tasks for a given workflow should be sent to the normal non-sticky task queue.
-    /// This normally happens when workflow has been evicted from the cache.
+    /// Notifies the server that workflow tasks for a given workflow should be sent to the normal
+    /// non-sticky task queue. This normally happens when workflow has been evicted from the cache.
     async fn reset_sticky_task_queue(
         &self,
         workflow_id: String,
@@ -381,17 +413,18 @@ pub trait ServerGatewayApis {
     ) -> Result<RespondWorkflowTaskCompletedResponse>;
 
     /// Complete activity task by sending response to the server. `task_token` contains activity
-    /// identifier that would've been received from [crate::Core::poll_activity_task] API. `result`
-    /// is a blob that contains activity response.
+    /// identifier that would've been received from polling for an activity task. `result` is a blob
+    /// that contains activity response.
     async fn complete_activity_task(
         &self,
         task_token: TaskToken,
         result: Option<Payloads>,
     ) -> Result<RespondActivityTaskCompletedResponse>;
 
-    /// Report activity task heartbeat by sending details to the server. `task_token` contains activity
-    /// identifier that would've been received from [crate::Core::poll_activity_task] API.
-    /// `result` contains `cancel_requested` flag, which if set to true indicates that activity has been cancelled.
+    /// Report activity task heartbeat by sending details to the server. `task_token` contains
+    /// activity identifier that would've been received from polling for an activity task. `result`
+    /// contains `cancel_requested` flag, which if set to true indicates that activity has been
+    /// cancelled.
     async fn record_activity_heartbeat(
         &self,
         task_token: TaskToken,
@@ -399,8 +432,8 @@ pub trait ServerGatewayApis {
     ) -> Result<RecordActivityTaskHeartbeatResponse>;
 
     /// Cancel activity task by sending response to the server. `task_token` contains activity
-    /// identifier that would've been received from [crate::Core::poll_activity_task] API. `details`
-    /// is a blob that provides arbitrary user defined cancellation info.
+    /// identifier that would've been received from polling for an activity task. `details` is a
+    /// blob that provides arbitrary user defined cancellation info.
     async fn cancel_activity_task(
         &self,
         task_token: TaskToken,
@@ -408,8 +441,8 @@ pub trait ServerGatewayApis {
     ) -> Result<RespondActivityTaskCanceledResponse>;
 
     /// Fail activity task by sending response to the server. `task_token` contains activity
-    /// identifier that would've been received from [crate::Core::poll_activity_task] API. `failure`
-    /// provides failure details, such as message, cause and stack trace.
+    /// identifier that would've been received from polling for an activity task. `failure` provides
+    /// failure details, such as message, cause and stack trace.
     async fn fail_activity_task(
         &self,
         task_token: TaskToken,
@@ -417,7 +450,7 @@ pub trait ServerGatewayApis {
     ) -> Result<RespondActivityTaskFailedResponse>;
 
     /// Fail task by sending the failure to the server. `task_token` is the task token that would've
-    /// been received from [crate::Core::poll_workflow_activation].
+    /// been received from polling for a workflow activation.
     async fn fail_workflow_task(
         &self,
         task_token: TaskToken,
@@ -480,6 +513,9 @@ pub trait ServerGatewayApis {
 
     /// Lists all available namespaces
     async fn list_namespaces(&self) -> Result<ListNamespacesResponse>;
+
+    /// Returns options that were used to initialize the gateway
+    fn get_options(&self) -> &ServerGatewayOptions;
 }
 
 #[async_trait::async_trait]
@@ -883,138 +919,8 @@ impl ServerGatewayApis for ServerGateway {
             .await?
             .into_inner())
     }
-}
 
-// Need a version of the mock that can return futures so we can return potentially pending
-// results. This is really annoying b/c of the async trait stuff. Need
-// https://github.com/asomers/mockall/issues/189 to be fixed for it to go away.
-#[cfg(test)]
-mockall::mock! {
-    pub ManualGateway {}
-    impl ServerGatewayApis for ManualGateway {
-        fn start_workflow<'a, 'b>(
-            &self,
-            input: Vec<Payload>,
-            task_queue: String,
-            workflow_id: String,
-            workflow_type: String,
-            task_timeout: Option<Duration>,
-        ) -> impl Future<Output = Result<StartWorkflowExecutionResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn poll_workflow_task<'a, 'b>(&'a self, task_queue: String, is_sticky: bool)
-            -> impl Future<Output = Result<PollWorkflowTaskQueueResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn poll_activity_task<'a, 'b>(&self, task_queue: String)
-            -> impl Future<Output = Result<PollActivityTaskQueueResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn reset_sticky_task_queue<'a, 'b>(
-            &self,
-            workflow_id: String,
-            run_id: String,
-        ) -> impl Future<Output = Result<ResetStickyTaskQueueResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn complete_workflow_task<'a, 'b>(
-            &self,
-            request: WorkflowTaskCompletion,
-        ) -> impl Future<Output = Result<RespondWorkflowTaskCompletedResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn complete_activity_task<'a, 'b>(
-            &self,
-            task_token: TaskToken,
-            result: Option<Payloads>,
-        ) -> impl Future<Output = Result<RespondActivityTaskCompletedResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn cancel_activity_task<'a, 'b>(
-            &self,
-            task_token: TaskToken,
-            details: Option<Payloads>,
-        ) -> impl Future<Output = Result<RespondActivityTaskCanceledResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn fail_activity_task<'a, 'b>(
-            &self,
-            task_token: TaskToken,
-            failure: Option<Failure>,
-        ) -> impl Future<Output = Result<RespondActivityTaskFailedResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn fail_workflow_task<'a, 'b>(
-            &self,
-            task_token: TaskToken,
-            cause: WorkflowTaskFailedCause,
-            failure: Option<Failure>,
-        ) -> impl Future<Output = Result<RespondWorkflowTaskFailedResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn signal_workflow_execution<'a, 'b>(
-            &self,
-            workflow_id: String,
-            run_id: String,
-            signal_name: String,
-            payloads: Option<Payloads>,
-        ) -> impl Future<Output = Result<SignalWorkflowExecutionResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn record_activity_heartbeat<'a, 'b>(
-           &self,
-           task_token: TaskToken,
-           details: Option<Payloads>,
-        ) -> impl Future<Output = Result<RecordActivityTaskHeartbeatResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn query_workflow_execution<'a, 'b>(
-            &self,
-            workflow_id: String,
-            run_id: String,
-            query: WorkflowQuery,
-        ) -> impl Future<Output = Result<QueryWorkflowResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn describe_workflow_execution<'a, 'b>(
-            &self,
-            workflow_id: String,
-            run_id: Option<String>,
-        ) -> impl Future<Output = Result<DescribeWorkflowExecutionResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn get_workflow_execution_history<'a, 'b>(
-            &self,
-            workflow_id: String,
-            run_id: Option<String>,
-            page_token: Vec<u8>
-        ) -> impl Future<Output = Result<GetWorkflowExecutionHistoryResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn respond_legacy_query<'a, 'b>(
-            &self,
-            task_token: TaskToken,
-            query_result: QueryResult,
-        ) -> impl Future<Output = Result<RespondQueryTaskCompletedResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn cancel_workflow_execution<'a, 'b>(
-            &self,
-            workflow_id: String,
-            run_id: Option<String>,
-        ) -> impl Future<Output = Result<RequestCancelWorkflowExecutionResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn terminate_workflow_execution<'a, 'b>(
-            &self,
-            workflow_id: String,
-            run_id: Option<String>,
-        ) -> impl Future<Output = Result<TerminateWorkflowExecutionResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn list_namespaces<'a, 'b>(
-            &self,
-        ) -> impl Future<Output = Result<ListNamespacesResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
+    fn get_options(&self) -> &ServerGatewayOptions {
+        &self.opts
     }
 }