@temporalio/core-bridge 0.19.2 → 0.20.2

package/sdk-core/client/src/lib.rs

@@ -8,24 +8,25 @@
 extern crate tracing;
 
 mod metrics;
-#[cfg(any(feature = "mocks", test))]
-pub mod mocks;
+mod raw;
 mod retry;
 
-pub use crate::retry::RetryGateway;
-#[cfg(any(feature = "mocks", test))]
-pub use mocks::MockManualGateway;
+pub use crate::retry::{CallType, RetryClient};
+pub use raw::WorkflowService;
 
-use crate::metrics::{svc_operation, MetricsContext};
+use crate::{
+    metrics::{GrpcMetricSvc, MetricsContext},
+    raw::{sealed::RawClientLike, AttachMetricLabels},
+};
 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, DerefMut},
     str::FromStr,
-    task::Poll,
+    sync::Arc,
     time::{Duration, Instant},
 };
 use temporal_sdk_core_protos::{
@@ -42,19 +43,17 @@ use temporal_sdk_core_protos::{
     TaskToken,
 };
 use tonic::{
-    body::BoxBody,
-    codegen::{InterceptedService, Service},
+    codegen::InterceptedService,
     metadata::{MetadataKey, MetadataValue},
     service::Interceptor,
     transport::{Certificate, Channel, Endpoint, Identity},
-    IntoRequest, Status,
+    Code, Status,
 };
 use tower::ServiceBuilder;
 use url::Url;
 use uuid::Uuid;
 
-#[cfg(any(feature = "mocks", test))]
-use futures::Future;
+use temporal_sdk_core_protos::temporal::api::taskqueue::v1::TaskQueueMetadata;
 
 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.
@@ -63,17 +62,14 @@ const OTHER_CALL_TIMEOUT: Duration = Duration::from_secs(30);
 
 type Result<T, E = tonic::Status> = std::result::Result<T, E>;
 
-/// Options for the connection to the temporal server. Construct with [ServerGatewayOptionsBuilder]
+/// Options for the connection to the temporal server. Construct with [ClientOptionsBuilder]
 #[derive(Clone, Debug, derive_builder::Builder)]
 #[non_exhaustive]
-pub struct ServerGatewayOptions {
+pub struct ClientOptions {
     /// The URL of the Temporal server to connect to
     #[builder(setter(into))]
     pub target_url: Url,
 
-    /// What namespace will we operate under
-    pub namespace: String,
-
     /// The name of the SDK being implemented on top of core. Is set as `client-name` header in
     /// all RPC calls
     pub client_name: String,
@@ -99,7 +95,7 @@ pub struct ServerGatewayOptions {
     #[builder(setter(strip_option), default)]
     pub tls_cfg: Option<TlsConfig>,
 
-    /// Retry configuration for the server gateway. Default is [RetryConfig::default]
+    /// Retry configuration for the server client. Default is [RetryConfig::default]
     #[builder(default)]
     pub retry_config: RetryConfig,
 }
@@ -196,40 +192,152 @@ impl Debug for ClientTlsConfig {
 
 /// Errors thrown while attempting to establish a connection to the server
 #[derive(thiserror::Error, Debug)]
-pub enum GatewayInitError {
+pub enum ClientInitError {
     /// 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),
+    /// We couldn't successfully make the `get_system_info` call at connection time to establish
+    /// server capabilities / verify server is responding.
+    #[error("`get_system_info` call error after connection: {0:?}")]
+    SystemInfoCallError(tonic::Status),
+}
+
+#[doc(hidden)]
+/// Allows passing different kinds of clients into things that want to be flexible. Motivating
+/// use-case was worker initialization.
+///
+/// Needs to exist in this crate to avoid blanket impl conflicts.
+pub enum AnyClient {
+    /// A high level client, like the type workers work with
+    HighLevel(Arc<dyn WorkflowClientTrait + Send + Sync>),
+    /// A low level gRPC client, wrapped with the typical interceptors
+    LowLevel(Box<ConfiguredClient<WorkflowServiceClientWithMetrics>>),
+}
+
+impl<SGA> From<SGA> for AnyClient
+where
+    SGA: WorkflowClientTrait + Send + Sync + 'static,
+{
+    fn from(s: SGA) -> Self {
+        Self::HighLevel(Arc::new(s))
+    }
+}
+impl<SGA> From<Arc<SGA>> for AnyClient
+where
+    SGA: WorkflowClientTrait + Send + Sync + 'static,
+{
+    fn from(s: Arc<SGA>) -> Self {
+        Self::HighLevel(s)
+    }
+}
+impl From<RetryClient<ConfiguredClient<WorkflowServiceClientWithMetrics>>> for AnyClient {
+    fn from(c: RetryClient<ConfiguredClient<WorkflowServiceClientWithMetrics>>) -> Self {
+        Self::LowLevel(Box::new(c.into_inner()))
+    }
+}
+impl From<ConfiguredClient<WorkflowServiceClientWithMetrics>> for AnyClient {
+    fn from(c: ConfiguredClient<WorkflowServiceClientWithMetrics>) -> Self {
+        Self::LowLevel(Box::new(c))
+    }
+}
+
+/// A client with [ClientOptions] attached, which can be passed to initialize workers,
+/// or can be used directly.
+#[derive(Clone, Debug)]
+pub struct ConfiguredClient<C> {
+    client: C,
+    options: ClientOptions,
+    /// Capabilities as read from the `get_system_info` RPC call made on client connection
+    capabilities: Option<get_system_info_response::Capabilities>,
+}
+
+impl<C> ConfiguredClient<C> {
+    /// Returns the options the client is configured with
+    pub fn options(&self) -> &ClientOptions {
+        &self.options
+    }
+
+    /// Returns the server capabilities we (may have) learned about when establishing an initial
+    /// connection
+    pub fn capabilities(&self) -> Option<&get_system_info_response::Capabilities> {
+        self.capabilities.as_ref()
+    }
+
+    /// De-constitute this type
+    pub fn into_parts(self) -> (C, ClientOptions) {
+        (self.client, self.options)
+    }
 }
 
-impl ServerGatewayOptions {
-    /// Attempt to establish a connection to the Temporal server
+// The configured client is effectively a "smart" (dumb) pointer
+impl<C> Deref for ConfiguredClient<C> {
+    type Target = C;
+
+    fn deref(&self) -> &Self::Target {
+        &self.client
+    }
+}
+impl<C> DerefMut for ConfiguredClient<C> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.client
+    }
+}
+
+impl ClientOptions {
+    /// Attempt to establish a connection to the Temporal server in a specific namespace. The
+    /// returned client is bound to that namespace.
     pub async fn connect(
+        &self,
+        namespace: impl Into<String>,
+        metrics_meter: Option<&Meter>,
+    ) -> Result<RetryClient<Client>, ClientInitError> {
+        let client = self.connect_no_namespace(metrics_meter).await?.into_inner();
+        let client = Client::new(client, namespace.into());
+        let retry_client = RetryClient::new(client, self.retry_config.clone());
+        Ok(retry_client)
+    }
+
+    /// Attempt to establish a connection to the Temporal server and return a gRPC client which is
+    /// intercepted with retry, default headers functionality, and metrics if provided.
+    ///
+    /// See [RetryClient] for more
+    pub async fn connect_no_namespace(
         &self,
         metrics_meter: Option<&Meter>,
-    ) -> Result<RetryGateway<ServerGateway>, GatewayInitError> {
+    ) -> Result<RetryClient<ConfiguredClient<WorkflowServiceClientWithMetrics>>, ClientInitError>
+    {
         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(|channel| {
-                GrpcMetricSvc::new(
-                    channel,
-                    metrics_meter.map(|mm| MetricsContext::top_level(self.namespace.clone(), mm)),
-                )
+            .layer_fn(|channel| GrpcMetricSvc {
+                inner: channel,
+                metrics: metrics_meter.map(|mm| MetricsContext::new(vec![], mm)),
             })
             .service(channel);
         let interceptor = ServiceCallInterceptor { opts: self.clone() };
-        let service = WorkflowServiceClient::with_interceptor(service, interceptor);
-        let gateway = ServerGateway {
-            service,
-            opts: self.clone(),
+
+        let mut client = ConfiguredClient {
+            client: WorkflowServiceClient::with_interceptor(service, interceptor),
+            options: self.clone(),
+            capabilities: None,
         };
-        let retry_gateway = RetryGateway::new(gateway, self.retry_config.clone());
-        Ok(retry_gateway)
+        match client
+            .get_system_info(GetSystemInfoRequest::default())
+            .await
+        {
+            Ok(sysinfo) => {
+                client.capabilities = sysinfo.into_inner().capabilities;
+            }
+            Err(status) => match status.code() {
+                Code::Unimplemented => {}
+                _ => return Err(ClientInitError::SystemInfoCallError(status)),
+            },
+        };
+        Ok(RetryClient::new(client, self.retry_config.clone()))
     }
 
     /// If TLS is configured, set the appropriate options on the provided channel and return it.
@@ -280,9 +388,10 @@ pub struct WorkflowTaskCompletion {
     pub force_create_new_workflow_task: bool,
 }
 
+/// Interceptor which attaches common metadata (like "client-name") to every outgoing call
 #[derive(Clone)]
-struct ServiceCallInterceptor {
-    opts: ServerGatewayOptions,
+pub struct ServiceCallInterceptor {
+    opts: ClientOptions,
 }
 
 impl Interceptor for ServiceCallInterceptor {
@@ -317,64 +426,67 @@ impl Interceptor for ServiceCallInterceptor {
     }
 }
 
-/// Implements metrics functionality for gRPC (really, any http) calls
-#[derive(derive_more::Constructor, Debug, Clone)]
-pub(crate) struct GrpcMetricSvc {
-    inner: Channel,
-    // If set to none, metrics are a no-op
-    metrics: Option<MetricsContext>,
+/// A [WorkflowServiceClient] with the default interceptors attached.
+pub type WorkflowServiceClientWithMetrics = WorkflowServiceClient<InterceptedMetricsSvc>;
+type InterceptedMetricsSvc = InterceptedService<GrpcMetricSvc, ServiceCallInterceptor>;
+
+/// Contains an instance of a namespace-bound client for interacting with the Temporal server
+#[derive(Debug)]
+pub struct Client {
+    /// Client for interacting with workflow service
+    inner: ConfiguredClient<WorkflowServiceClientWithMetrics>,
+    /// The namespace this client interacts with
+    namespace: String,
 }
 
-impl Service<http::Request<BoxBody>> for GrpcMetricSvc {
-    type Response = http::Response<tonic::transport::Body>;
-    type Error = tonic::transport::Error;
-    type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
-
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.inner.poll_ready(cx).map_err(Into::into)
-    }
-
-    fn call(&mut self, req: http::Request<BoxBody>) -> Self::Future {
-        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();
-            let res = callfut.await;
-            if let Some(metrics) = metrics {
-                metrics.record_svc_req_latency(started.elapsed());
-                if res.is_err() {
-                    metrics.svc_request_failed();
-                }
-            }
-            res
+impl Client {
+    /// Create a new client from an existing configured lower level client and a namespace
+    pub fn new(
+        client: ConfiguredClient<WorkflowServiceClientWithMetrics>,
+        namespace: String,
+    ) -> Self {
+        Client {
+            inner: client,
+            namespace,
         }
-        .boxed()
     }
-}
 
-/// Contains an instance of a client for interacting with the temporal server
-#[derive(Debug)]
-pub struct ServerGateway {
-    /// Client for interacting with workflow service
-    service: WorkflowServiceClient<InterceptedService<GrpcMetricSvc, ServiceCallInterceptor>>,
-    /// Options gateway was initialized with
-    pub opts: ServerGatewayOptions,
+    /// Return an auto-retrying version of the underling grpc client (instrumented with metrics
+    /// collection, if enabled).
+    ///
+    /// Note that it is reasonably cheap to clone the returned type if you need to own it. Such
+    /// clones will keep re-using the same channel.
+    pub fn raw_retry_client(&self) -> RetryClient<WorkflowServiceClientWithMetrics> {
+        RetryClient::new(
+            self.raw_client().clone(),
+            self.inner.options.retry_config.clone(),
+        )
+    }
+
+    /// Access the underling grpc client. This raw client is not bound to a specific namespace.
+    ///
+    /// Note that it is reasonably cheap to clone the returned type if you need to own it. Such
+    /// clones will keep re-using the same channel.
+    pub fn raw_client(&self) -> &WorkflowServiceClientWithMetrics {
+        self.inner.deref()
+    }
+
+    /// Return the options this client was initialized with
+    pub fn options(&self) -> &ClientOptions {
+        &self.inner.options
+    }
+
+    /// Used to access the client as a [WorkflowService] implementor rather than the raw struct
+    fn wf_svc(&self) -> impl RawClientLike<SvcType = InterceptedMetricsSvc> {
+        self.raw_client().clone()
+    }
 }
 
-/// This trait provides ways to call the temporal server
-#[cfg_attr(any(feature = "mocks", test), mockall::automock)]
+/// This trait provides higher-level friendlier interaction with the server.
+/// See the [WorkflowService] trait for a lower-level client.
+#[cfg_attr(test, mockall::automock)]
 #[async_trait::async_trait]
-pub trait ServerGatewayApis {
+pub trait WorkflowClientTrait {
     /// Starts workflow execution.
     async fn start_workflow(
         &self,
@@ -382,7 +494,7 @@ pub trait ServerGatewayApis {
         task_queue: String,
         workflow_id: String,
         workflow_type: String,
-        task_timeout: Option<Duration>,
+        options: WorkflowOptions,
     ) -> Result<StartWorkflowExecutionResponse>;
 
     /// Fetch new workflow tasks from the provided queue. Should block indefinitely if there is no
@@ -395,8 +507,11 @@ pub trait ServerGatewayApis {
 
     /// Fetch new activity tasks from the provided queue. Should block indefinitely if there is no
     /// work.
-    async fn poll_activity_task(&self, task_queue: String)
-        -> Result<PollActivityTaskQueueResponse>;
+    async fn poll_activity_task(
+        &self,
+        task_queue: String,
+        max_tasks_per_sec: Option<f64>,
+    ) -> 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.
@@ -514,27 +629,39 @@ 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;
+    /// Returns options that were used to initialize the client
+    fn get_options(&self) -> &ClientOptions;
+
+    /// Returns the namespace this client is bound to
+    fn namespace(&self) -> &str;
+}
+
+/// Optional fields supplied at the start of workflow execution
+#[derive(Debug, Clone, Default)]
+pub struct WorkflowOptions {
+    /// Optionally indicates the default task timeout for workflow tasks
+    pub task_timeout: Option<Duration>,
+
+    /// Optionally associate extra search attributes with a workflow
+    pub search_attributes: Option<HashMap<String, Payload>>,
 }
 
 #[async_trait::async_trait]
-impl ServerGatewayApis for ServerGateway {
+impl WorkflowClientTrait for Client {
     async fn start_workflow(
         &self,
         input: Vec<Payload>,
         task_queue: String,
         workflow_id: String,
         workflow_type: String,
-        task_timeout: Option<Duration>,
+        options: WorkflowOptions,
     ) -> Result<StartWorkflowExecutionResponse> {
         let request_id = Uuid::new_v4().to_string();
 
         Ok(self
-            .service
-            .clone()
+            .wf_svc()
             .start_workflow_execution(StartWorkflowExecutionRequest {
-                namespace: self.opts.namespace.clone(),
+                namespace: self.namespace.clone(),
                 input: input.into_payloads(),
                 workflow_id,
                 workflow_type: Some(WorkflowType {
@@ -545,7 +672,8 @@ impl ServerGatewayApis for ServerGateway {
                     kind: 0,
                 }),
                 request_id,
-                workflow_task_timeout: task_timeout.map(Into::into),
+                workflow_task_timeout: options.task_timeout.map(Into::into),
+                search_attributes: options.search_attributes.map(Into::into),
                 ..Default::default()
             })
             .await?
@@ -557,8 +685,8 @@ impl ServerGatewayApis for ServerGateway {
         task_queue: String,
         is_sticky: bool,
     ) -> Result<PollWorkflowTaskQueueResponse> {
-        let mut request = PollWorkflowTaskQueueRequest {
-            namespace: self.opts.namespace.clone(),
+        let request = PollWorkflowTaskQueueRequest {
+            namespace: self.namespace.clone(),
             task_queue: Some(TaskQueue {
                 name: task_queue,
                 kind: if is_sticky {
@@ -567,15 +695,12 @@ impl ServerGatewayApis for ServerGateway {
                     TaskQueueKind::Normal
                 } as i32,
             }),
-            identity: self.opts.identity.clone(),
-            binary_checksum: self.opts.worker_binary_id.clone(),
-        }
-        .into_request();
-        request.set_timeout(LONG_POLL_TIMEOUT);
+            identity: self.inner.options.identity.clone(),
+            binary_checksum: self.inner.options.worker_binary_id.clone(),
+        };
 
         Ok(self
-            .service
-            .clone()
+            .wf_svc()
             .poll_workflow_task_queue(request)
             .await?
             .into_inner())
@@ -584,22 +709,22 @@ impl ServerGatewayApis for ServerGateway {
     async fn poll_activity_task(
         &self,
         task_queue: String,
+        max_tasks_per_sec: Option<f64>,
     ) -> Result<PollActivityTaskQueueResponse> {
-        let mut request = PollActivityTaskQueueRequest {
-            namespace: self.opts.namespace.clone(),
+        let request = PollActivityTaskQueueRequest {
+            namespace: self.namespace.clone(),
             task_queue: Some(TaskQueue {
                 name: task_queue,
                 kind: TaskQueueKind::Normal as i32,
             }),
-            identity: self.opts.identity.clone(),
-            task_queue_metadata: None,
-        }
-        .into_request();
-        request.set_timeout(LONG_POLL_TIMEOUT);
+            identity: self.inner.options.identity.clone(),
+            task_queue_metadata: max_tasks_per_sec.map(|tps| TaskQueueMetadata {
+                max_tasks_per_second: Some(tps),
+            }),
+        };
 
         Ok(self
-            .service
-            .clone()
+            .wf_svc()
             .poll_activity_task_queue(request)
             .await?
             .into_inner())
@@ -611,15 +736,14 @@ impl ServerGatewayApis for ServerGateway {
         run_id: String,
     ) -> Result<ResetStickyTaskQueueResponse> {
         let request = ResetStickyTaskQueueRequest {
-            namespace: self.opts.namespace.clone(),
+            namespace: self.namespace.clone(),
             execution: Some(WorkflowExecution {
                 workflow_id,
                 run_id,
             }),
         };
         Ok(self
-            .service
-            .clone()
+            .wf_svc()
             .reset_sticky_task_queue(request)
             .await?
             .into_inner())
@@ -632,11 +756,11 @@ impl ServerGatewayApis for ServerGateway {
         let request = RespondWorkflowTaskCompletedRequest {
             task_token: request.task_token.into(),
             commands: request.commands,
-            identity: self.opts.identity.clone(),
+            identity: self.inner.options.identity.clone(),
             sticky_attributes: request.sticky_attributes,
             return_new_workflow_task: request.return_new_workflow_task,
             force_create_new_workflow_task: request.force_create_new_workflow_task,
-            binary_checksum: self.opts.worker_binary_id.clone(),
+            binary_checksum: self.inner.options.worker_binary_id.clone(),
             query_results: request
                 .query_responses
                 .into_iter()
@@ -652,11 +776,10 @@ impl ServerGatewayApis for ServerGateway {
                     )
                 })
                 .collect(),
-            namespace: self.opts.namespace.clone(),
+            namespace: self.namespace.clone(),
         };
         Ok(self
-            .service
-            .clone()
+            .wf_svc()
             .respond_workflow_task_completed(request)
             .await?
             .into_inner())
@@ -668,13 +791,12 @@ impl ServerGatewayApis for ServerGateway {
         result: Option<Payloads>,
     ) -> Result<RespondActivityTaskCompletedResponse> {
         Ok(self
-            .service
-            .clone()
+            .wf_svc()
             .respond_activity_task_completed(RespondActivityTaskCompletedRequest {
                 task_token: task_token.0,
                 result,
-                identity: self.opts.identity.clone(),
-                namespace: self.opts.namespace.clone(),
+                identity: self.inner.options.identity.clone(),
+                namespace: self.namespace.clone(),
             })
             .await?
             .into_inner())
@@ -686,13 +808,12 @@ impl ServerGatewayApis for ServerGateway {
         details: Option<Payloads>,
     ) -> Result<RecordActivityTaskHeartbeatResponse> {
         Ok(self
-            .service
-            .clone()
+            .wf_svc()
             .record_activity_task_heartbeat(RecordActivityTaskHeartbeatRequest {
                 task_token: task_token.0,
                 details,
-                identity: self.opts.identity.clone(),
-                namespace: self.opts.namespace.clone(),
+                identity: self.inner.options.identity.clone(),
+                namespace: self.namespace.clone(),
             })
             .await?
             .into_inner())
@@ -704,13 +825,12 @@ impl ServerGatewayApis for ServerGateway {
         details: Option<Payloads>,
     ) -> Result<RespondActivityTaskCanceledResponse> {
         Ok(self
-            .service
-            .clone()
+            .wf_svc()
             .respond_activity_task_canceled(RespondActivityTaskCanceledRequest {
                 task_token: task_token.0,
                 details,
-                identity: self.opts.identity.clone(),
-                namespace: self.opts.namespace.clone(),
+                identity: self.inner.options.identity.clone(),
+                namespace: self.namespace.clone(),
             })
             .await?
             .into_inner())
@@ -722,13 +842,12 @@ impl ServerGatewayApis for ServerGateway {
         failure: Option<Failure>,
     ) -> Result<RespondActivityTaskFailedResponse> {
         Ok(self
-            .service
-            .clone()
+            .wf_svc()
             .respond_activity_task_failed(RespondActivityTaskFailedRequest {
                 task_token: task_token.0,
                 failure,
-                identity: self.opts.identity.clone(),
-                namespace: self.opts.namespace.clone(),
+                identity: self.inner.options.identity.clone(),
+                namespace: self.namespace.clone(),
             })
             .await?
             .into_inner())
@@ -744,13 +863,12 @@ impl ServerGatewayApis for ServerGateway {
             task_token: task_token.0,
             cause: cause as i32,
             failure,
-            identity: self.opts.identity.clone(),
-            binary_checksum: self.opts.worker_binary_id.clone(),
-            namespace: self.opts.namespace.clone(),
+            identity: self.inner.options.identity.clone(),
+            binary_checksum: self.inner.options.worker_binary_id.clone(),
+            namespace: self.namespace.clone(),
         };
         Ok(self
-            .service
-            .clone()
+            .wf_svc()
             .respond_workflow_task_failed(request)
             .await?
             .into_inner())
@@ -764,17 +882,16 @@ impl ServerGatewayApis for ServerGateway {
         payloads: Option<Payloads>,
     ) -> Result<SignalWorkflowExecutionResponse> {
         Ok(self
-            .service
-            .clone()
+            .wf_svc()
             .signal_workflow_execution(SignalWorkflowExecutionRequest {
-                namespace: self.opts.namespace.clone(),
+                namespace: self.namespace.clone(),
                 workflow_execution: Some(WorkflowExecution {
                     workflow_id,
                     run_id,
                 }),
                 signal_name,
                 input: payloads,
-                identity: self.opts.identity.clone(),
+                identity: self.inner.options.identity.clone(),
                 ..Default::default()
             })
             .await?
@@ -788,10 +905,9 @@ impl ServerGatewayApis for ServerGateway {
         query: WorkflowQuery,
     ) -> Result<QueryWorkflowResponse> {
         Ok(self
-            .service
-            .clone()
+            .wf_svc()
             .query_workflow(QueryWorkflowRequest {
-                namespace: self.opts.namespace.clone(),
+                namespace: self.namespace.clone(),
                 execution: Some(WorkflowExecution {
                     workflow_id,
                     run_id,
@@ -809,10 +925,9 @@ impl ServerGatewayApis for ServerGateway {
         run_id: Option<String>,
     ) -> Result<DescribeWorkflowExecutionResponse> {
         Ok(self
-            .service
-            .clone()
+            .wf_svc()
             .describe_workflow_execution(DescribeWorkflowExecutionRequest {
-                namespace: self.opts.namespace.clone(),
+                namespace: self.namespace.clone(),
                 execution: Some(WorkflowExecution {
                     workflow_id,
                     run_id: run_id.unwrap_or_default(),
@@ -829,10 +944,9 @@ impl ServerGatewayApis for ServerGateway {
         page_token: Vec<u8>,
     ) -> Result<GetWorkflowExecutionHistoryResponse> {
         Ok(self
-            .service
-            .clone()
+            .wf_svc()
             .get_workflow_execution_history(GetWorkflowExecutionHistoryRequest {
-                namespace: self.opts.namespace.clone(),
+                namespace: self.namespace.clone(),
                 execution: Some(WorkflowExecution {
                     workflow_id,
                     run_id: run_id.unwrap_or_default(),
@@ -851,35 +965,32 @@ impl ServerGatewayApis for ServerGateway {
     ) -> Result<RespondQueryTaskCompletedResponse> {
         let (_, completed_type, query_result, error_message) = query_result.into_components();
         Ok(self
-            .service
-            .clone()
+            .wf_svc()
             .respond_query_task_completed(RespondQueryTaskCompletedRequest {
                 task_token: task_token.into(),
                 completed_type: completed_type as i32,
                 query_result,
                 error_message,
-                namespace: self.opts.namespace.clone(),
+                namespace: self.namespace.clone(),
             })
             .await?
             .into_inner())
     }
 
-    /// Cancel a currently executing workflow
     async fn cancel_workflow_execution(
         &self,
         workflow_id: String,
         run_id: Option<String>,
     ) -> Result<RequestCancelWorkflowExecutionResponse> {
         Ok(self
-            .service
-            .clone()
+            .wf_svc()
             .request_cancel_workflow_execution(RequestCancelWorkflowExecutionRequest {
-                namespace: self.opts.namespace.clone(),
+                namespace: self.namespace.clone(),
                 workflow_execution: Some(WorkflowExecution {
                     workflow_id,
                     run_id: run_id.unwrap_or_default(),
                 }),
-                identity: self.opts.identity.clone(),
+                identity: self.inner.options.identity.clone(),
                 request_id: "".to_string(),
                 first_execution_run_id: "".to_string(),
             })
@@ -887,24 +998,22 @@ impl ServerGatewayApis for ServerGateway {
             .into_inner())
     }
 
-    /// Terminate a currently executing workflow
     async fn terminate_workflow_execution(
         &self,
         workflow_id: String,
         run_id: Option<String>,
     ) -> Result<TerminateWorkflowExecutionResponse> {
         Ok(self
-            .service
-            .clone()
+            .wf_svc()
             .terminate_workflow_execution(TerminateWorkflowExecutionRequest {
-                namespace: self.opts.namespace.clone(),
+                namespace: self.namespace.clone(),
                 workflow_execution: Some(WorkflowExecution {
                     workflow_id,
                     run_id: run_id.unwrap_or_default(),
                 }),
                 reason: "".to_string(),
                 details: None,
-                identity: self.opts.identity.clone(),
+                identity: self.inner.options.identity.clone(),
                 first_execution_run_id: "".to_string(),
             })
             .await?
@@ -913,14 +1022,17 @@ impl ServerGatewayApis for ServerGateway {
 
     async fn list_namespaces(&self) -> Result<ListNamespacesResponse> {
         Ok(self
-            .service
-            .clone()
+            .wf_svc()
             .list_namespaces(ListNamespacesRequest::default())
             .await?
             .into_inner())
     }
 
-    fn get_options(&self) -> &ServerGatewayOptions {
-        &self.opts
+    fn get_options(&self) -> &ClientOptions {
+        &self.inner.options
+    }
+
+    fn namespace(&self) -> &str {
+        &self.namespace
     }
 }