temporalio 0.0.1 → 0.1.0

data/bridge/sdk-core/client/Cargo.toml

@@ -14,7 +14,7 @@ categories = ["development-tools"]
 anyhow = "1.0"
 async-trait = "0.1"
 backoff = "0.4"
-derive_builder = "0.11"
+derive_builder = "0.12"
 derive_more = "0.99"
 futures = "0.3"
 futures-retry = "0.6.0"

data/bridge/sdk-core/client/src/lib.rs

@@ -13,14 +13,17 @@ mod retry;
 mod workflow_handle;
 
 pub use crate::retry::{CallType, RetryClient, RETRYABLE_ERROR_CODES};
+pub use metrics::ClientMetricProvider;
 pub use raw::{HealthService, OperatorService, TestService, WorkflowService};
 pub use temporal_sdk_core_protos::temporal::api::{
+    enums::v1::ArchivalState,
     filter::v1::{StartTimeFilter, StatusFilter, WorkflowExecutionFilter, WorkflowTypeFilter},
     workflowservice::v1::{
         list_closed_workflow_executions_request::Filters as ListClosedFilters,
         list_open_workflow_executions_request::Filters as ListOpenFilters,
     },
 };
+pub use tonic;
 pub use workflow_handle::{WorkflowExecutionInfo, WorkflowExecutionResult};
 
 use crate::{
@@ -32,7 +35,6 @@ use crate::{
 use backoff::{exponential, ExponentialBackoff, SystemClock};
 use http::uri::InvalidUri;
 use once_cell::sync::OnceCell;
-use opentelemetry::metrics::Meter;
 use parking_lot::RwLock;
 use std::{
     collections::HashMap,
@@ -46,13 +48,13 @@ use temporal_sdk_core_protos::{
     coresdk::{workflow_commands::QueryResult, IntoPayloadsExt},
     grpc::health::v1::health_client::HealthClient,
     temporal::api::{
-        command::v1::Command,
         common::v1::{Header, Payload, Payloads, WorkflowExecution, WorkflowType},
         enums::v1::{TaskQueueKind, WorkflowIdReusePolicy, WorkflowTaskFailedCause},
         failure::v1::Failure,
         operatorservice::v1::operator_service_client::OperatorServiceClient,
         query::v1::WorkflowQuery,
-        taskqueue::v1::{StickyExecutionAttributes, TaskQueue},
+        replication::v1::ClusterReplicationConfig,
+        taskqueue::v1::TaskQueue,
         testservice::v1::test_service_client::TestServiceClient,
         workflowservice::v1::{workflow_service_client::WorkflowServiceClient, *},
     },
@@ -181,6 +183,17 @@ impl RetryConfig {
         }
     }
 
+    pub(crate) const fn throttle_retry_policy() -> Self {
+        Self {
+            initial_interval: Duration::from_secs(1),
+            randomization_factor: 0.2,
+            multiplier: 2.0,
+            max_interval: Duration::from_secs(10),
+            max_elapsed_time: None,
+            max_retries: 0,
+        }
+    }
+
     pub(crate) fn into_exp_backoff<C>(self, clock: C) -> exponential::ExponentialBackoff<C> {
         exponential::ExponentialBackoff {
             current_interval: self.initial_interval,
@@ -273,7 +286,7 @@ impl ClientOptions {
     pub async fn connect(
         &self,
         namespace: impl Into<String>,
-        metrics_meter: Option<&Meter>,
+        metrics_meter: Option<&dyn ClientMetricProvider>,
         headers: Option<Arc<RwLock<HashMap<String, String>>>>,
     ) -> Result<RetryClient<Client>, ClientInitError> {
         let client = self
@@ -291,7 +304,7 @@ impl ClientOptions {
     /// See [RetryClient] for more
     pub async fn connect_no_namespace(
         &self,
-        metrics_meter: Option<&Meter>,
+        metrics_meter: Option<&dyn ClientMetricProvider>,
         headers: Option<Arc<RwLock<HashMap<String, String>>>>,
     ) -> Result<RetryClient<ConfiguredClient<TemporalServiceClientWithMetrics>>, ClientInitError>
     {
@@ -362,24 +375,6 @@ impl ClientOptions {
     }
 }
 
-/// 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,
-}
-
 /// Interceptor which attaches common metadata (like "client-name") to every outgoing call
 #[derive(Clone)]
 pub struct ServiceCallInterceptor {
@@ -600,6 +595,133 @@ impl Namespace {
     }
 }
 
+/// Default workflow execution retention for a Namespace is 3 days
+pub const DEFAULT_WORKFLOW_EXECUTION_RETENTION_PERIOD: Duration =
+    Duration::from_secs(60 * 60 * 24 * 3);
+
+/// Helper struct for `register_namespace`.
+#[derive(Clone, derive_builder::Builder)]
+pub struct RegisterNamespaceOptions {
+    /// Name (required)
+    #[builder(setter(into))]
+    pub namespace: String,
+    /// Description (required)
+    #[builder(setter(into))]
+    pub description: String,
+    /// Owner's email
+    #[builder(setter(into), default)]
+    pub owner_email: String,
+    /// Workflow execution retention period
+    #[builder(default = "DEFAULT_WORKFLOW_EXECUTION_RETENTION_PERIOD")]
+    pub workflow_execution_retention_period: Duration,
+    /// Cluster settings
+    #[builder(setter(strip_option, custom), default)]
+    pub clusters: Vec<ClusterReplicationConfig>,
+    /// Active cluster name
+    #[builder(setter(into), default)]
+    pub active_cluster_name: String,
+    /// Custom Data
+    #[builder(default)]
+    pub data: HashMap<String, String>,
+    /// Security Token
+    #[builder(setter(into), default)]
+    pub security_token: String,
+    /// Global namespace
+    #[builder(default)]
+    pub is_global_namespace: bool,
+    /// History Archival setting
+    #[builder(setter(into), default = "ArchivalState::Unspecified")]
+    pub history_archival_state: ArchivalState,
+    /// History Archival uri
+    #[builder(setter(into), default)]
+    pub history_archival_uri: String,
+    /// Visibility Archival setting
+    #[builder(setter(into), default = "ArchivalState::Unspecified")]
+    pub visibility_archival_state: ArchivalState,
+    /// Visibility Archival uri
+    #[builder(setter(into), default)]
+    pub visibility_archival_uri: String,
+}
+
+impl RegisterNamespaceOptions {
+    /// Builder convenience.  Less `use` imports
+    pub fn builder() -> RegisterNamespaceOptionsBuilder {
+        Default::default()
+    }
+}
+
+impl From<RegisterNamespaceOptions> for RegisterNamespaceRequest {
+    fn from(val: RegisterNamespaceOptions) -> Self {
+        RegisterNamespaceRequest {
+            namespace: val.namespace,
+            description: val.description,
+            owner_email: val.owner_email,
+            workflow_execution_retention_period: val
+                .workflow_execution_retention_period
+                .try_into()
+                .ok(),
+            clusters: val.clusters,
+            active_cluster_name: val.active_cluster_name,
+            data: val.data,
+            security_token: val.security_token,
+            is_global_namespace: val.is_global_namespace,
+            history_archival_state: val.history_archival_state as i32,
+            history_archival_uri: val.history_archival_uri,
+            visibility_archival_state: val.visibility_archival_state as i32,
+            visibility_archival_uri: val.visibility_archival_uri,
+        }
+    }
+}
+
+impl RegisterNamespaceOptionsBuilder {
+    /// Custum builder function for convenience
+    /// Warning: setting cluster_names could blow away any previously set cluster configs
+    pub fn cluster_names(&mut self, clusters: Vec<String>) {
+        self.clusters = Some(
+            clusters
+                .into_iter()
+                .map(|s| ClusterReplicationConfig { cluster_name: s })
+                .collect(),
+        );
+    }
+}
+
+/// Helper struct for `signal_with_start_workflow_execution`.
+#[derive(Clone, derive_builder::Builder)]
+pub struct SignalWithStartOptions {
+    /// Input payload for the workflow run
+    #[builder(setter(strip_option), default)]
+    pub input: Option<Payloads>,
+    /// Task Queue to target (required)
+    #[builder(setter(into))]
+    pub task_queue: String,
+    /// Workflow id for the workflow run
+    #[builder(setter(into))]
+    pub workflow_id: String,
+    /// Workflow type for the workflow run
+    #[builder(setter(into))]
+    pub workflow_type: String,
+    #[builder(setter(strip_option), default)]
+    /// Request id for idempotency/deduplication
+    pub request_id: Option<String>,
+    /// The signal name to send (required)
+    #[builder(setter(into))]
+    pub signal_name: String,
+    /// Payloads for the signal
+    #[builder(default)]
+    pub signal_input: Option<Payloads>,
+    #[builder(setter(strip_option), default)]
+    /// Headers for the signal
+    pub signal_header: Option<Header>,
+}
+
+impl SignalWithStartOptions {
+    /// Builder convenience.  Less `use` imports
+    pub fn builder() -> SignalWithStartOptionsBuilder {
+        Default::default()
+    }
+}
+
 /// This trait provides higher-level friendlier interaction with the server.
 /// See the [WorkflowService] trait for a lower-level client.
 #[cfg_attr(test, mockall::automock)]
@@ -685,15 +807,8 @@ pub trait WorkflowClientTrait {
     #[allow(clippy::too_many_arguments)]
     async fn signal_with_start_workflow_execution(
         &self,
-        input: Option<Payloads>,
-        task_queue: String,
-        workflow_id: String,
-        workflow_type: String,
-        request_id: Option<String>,
-        options: WorkflowOptions,
-        signal_name: String,
-        signal_input: Option<Payloads>,
-        signal_header: Option<Header>,
+        options: SignalWithStartOptions,
+        workflow_options: WorkflowOptions,
     ) -> Result<SignalWithStartWorkflowExecutionResponse>;
 
     /// Request a query of a certain workflow instance
@@ -742,13 +857,19 @@ pub trait WorkflowClientTrait {
         run_id: Option<String>,
     ) -> Result<TerminateWorkflowExecutionResponse>;
 
+    /// Register a new namespace
+    async fn register_namespace(
+        &self,
+        options: RegisterNamespaceOptions,
+    ) -> Result<RegisterNamespaceResponse>;
+
     /// Lists all available namespaces
     async fn list_namespaces(&self) -> Result<ListNamespacesResponse>;
 
     /// Query namespace details
     async fn describe_namespace(&self, namespace: Namespace) -> Result<DescribeNamespaceResponse>;
 
-    /// List open workflows with Standard Visibility filtering
+    /// List open workflow executions with Standard Visibility filtering
     async fn list_open_workflow_executions(
         &self,
         max_page_size: i32,
@@ -757,7 +878,7 @@ pub trait WorkflowClientTrait {
         filters: Option<ListOpenFilters>,
     ) -> Result<ListOpenWorkflowExecutionsResponse>;
 
-    /// List closed workflows Standard Visibility filtering
+    /// List closed workflow executions Standard Visibility filtering
     async fn list_closed_workflow_executions(
         &self,
         max_page_size: i32,
@@ -766,14 +887,25 @@ pub trait WorkflowClientTrait {
         filters: Option<ListClosedFilters>,
     ) -> Result<ListClosedWorkflowExecutionsResponse>;
 
-    /// List workflows with Advanced Visibility filtering
+    /// List workflow executions with Advanced Visibility filtering
     async fn list_workflow_executions(
         &self,
-        max_page_size: i32,
+        page_size: i32,
         next_page_token: Vec<u8>,
         query: String,
     ) -> Result<ListWorkflowExecutionsResponse>;
 
+    /// List archived workflow executions
+    async fn list_archived_workflow_executions(
+        &self,
+        page_size: i32,
+        next_page_token: Vec<u8>,
+        query: String,
+    ) -> Result<ListArchivedWorkflowExecutionsResponse>;
+
+    /// Get Cluster Search Attributes
+    async fn get_search_attributes(&self) -> Result<GetSearchAttributesResponse>;
+
     /// Returns options that were used to initialize the client
     fn get_options(&self) -> &ClientOptions;
 
@@ -945,6 +1077,7 @@ impl WorkflowClientTrait for Client {
             identity: self.inner.options.identity.clone(),
             binary_checksum: self.bound_worker_build_id.clone().unwrap_or_default(),
             namespace: self.namespace.clone(),
+            messages: vec![],
         };
         Ok(self
             .wf_svc()
@@ -981,42 +1114,43 @@ impl WorkflowClientTrait for Client {
 
     async fn signal_with_start_workflow_execution(
         &self,
-        input: Option<Payloads>,
-        task_queue: String,
-        workflow_id: String,
-        workflow_type: String,
-        request_id: Option<String>,
-        options: WorkflowOptions,
-        signal_name: String,
-        signal_input: Option<Payloads>,
-        signal_header: Option<Header>,
+        options: SignalWithStartOptions,
+        workflow_options: WorkflowOptions,
     ) -> Result<SignalWithStartWorkflowExecutionResponse> {
         Ok(self
             .wf_svc()
             .signal_with_start_workflow_execution(SignalWithStartWorkflowExecutionRequest {
                 namespace: self.namespace.clone(),
-                workflow_id,
+                workflow_id: options.workflow_id,
                 workflow_type: Some(WorkflowType {
-                    name: workflow_type,
+                    name: options.workflow_type,
                 }),
                 task_queue: Some(TaskQueue {
-                    name: task_queue,
+                    name: options.task_queue,
                     kind: TaskQueueKind::Normal as i32,
                 }),
-                input,
-                signal_name,
-                signal_input,
+                input: options.input,
+                signal_name: options.signal_name,
+                signal_input: options.signal_input,
                 identity: self.inner.options.identity.clone(),
-                request_id: request_id.unwrap_or_else(|| Uuid::new_v4().to_string()),
-                workflow_id_reuse_policy: options.id_reuse_policy as i32,
-                workflow_execution_timeout: options
+                request_id: options
+                    .request_id
+                    .unwrap_or_else(|| Uuid::new_v4().to_string()),
+                workflow_id_reuse_policy: workflow_options.id_reuse_policy as i32,
+                workflow_execution_timeout: workflow_options
                     .execution_timeout
                     .and_then(|d| d.try_into().ok()),
-                workflow_run_timeout: options.execution_timeout.and_then(|d| d.try_into().ok()),
-                workflow_task_timeout: options.task_timeout.and_then(|d| d.try_into().ok()),
-                search_attributes: options.search_attributes.and_then(|d| d.try_into().ok()),
-                cron_schedule: options.cron_schedule.unwrap_or_default(),
-                header: signal_header,
+                workflow_run_timeout: workflow_options
+                    .execution_timeout
+                    .and_then(|d| d.try_into().ok()),
+                workflow_task_timeout: workflow_options
+                    .task_timeout
+                    .and_then(|d| d.try_into().ok()),
+                search_attributes: workflow_options
+                    .search_attributes
+                    .and_then(|d| d.try_into().ok()),
+                cron_schedule: workflow_options.cron_schedule.unwrap_or_default(),
+                header: options.signal_header,
                 ..Default::default()
             })
             .await?
@@ -1148,6 +1282,14 @@ impl WorkflowClientTrait for Client {
             .into_inner())
     }
 
+    async fn register_namespace(
+        &self,
+        options: RegisterNamespaceOptions,
+    ) -> Result<RegisterNamespaceResponse> {
+        let req = Into::<RegisterNamespaceRequest>::into(options);
+        Ok(self.wf_svc().register_namespace(req).await?.into_inner())
+    }
+
     async fn list_namespaces(&self) -> Result<ListNamespacesResponse> {
         Ok(self
             .wf_svc()
@@ -1222,6 +1364,32 @@ impl WorkflowClientTrait for Client {
             .into_inner())
     }
 
+    async fn list_archived_workflow_executions(
+        &self,
+        page_size: i32,
+        next_page_token: Vec<u8>,
+        query: String,
+    ) -> Result<ListArchivedWorkflowExecutionsResponse> {
+        Ok(self
+            .wf_svc()
+            .list_archived_workflow_executions(ListArchivedWorkflowExecutionsRequest {
+                namespace: self.namespace.clone(),
+                page_size,
+                next_page_token,
+                query,
+            })
+            .await?
+            .into_inner())
+    }
+
+    async fn get_search_attributes(&self) -> Result<GetSearchAttributesResponse> {
+        Ok(self
+            .wf_svc()
+            .get_search_attributes(GetSearchAttributesRequest {})
+            .await?
+            .into_inner())
+    }
+
     fn get_options(&self) -> &ClientOptions {
         &self.inner.options
     }

data/bridge/sdk-core/client/src/metrics.rs

@@ -1,7 +1,7 @@
 use crate::{AttachMetricLabels, LONG_POLL_METHOD_NAMES};
 use futures::{future::BoxFuture, FutureExt};
 use opentelemetry::{
-    metrics::{Counter, Histogram, Meter},
+    metrics::{Counter, Histogram},
     KeyValue,
 };
 use std::{
@@ -30,18 +30,27 @@ pub struct MetricsContext {
     long_svc_request_latency: Histogram<u64>,
 }
 
+/// Things that can provide metrics for the client implement this. Trait exists to avoid having
+/// to make a whole new lower-level crate just for a tiny shared wrapper around OTel meters.
+pub trait ClientMetricProvider {
+    /// Construct a counter metric
+    fn counter(&self, name: &'static str) -> Counter<u64>;
+    /// Construct a histogram metric
+    fn histogram(&self, name: &'static str) -> Histogram<u64>;
+}
+
 impl MetricsContext {
-    pub(crate) fn new(kvs: Vec<KeyValue>, meter: &Meter) -> Self {
+    pub(crate) fn new(kvs: Vec<KeyValue>, metric_provider: &dyn ClientMetricProvider) -> Self {
         Self {
             ctx: opentelemetry::Context::current(),
             kvs: Arc::new(kvs),
             poll_is_long: false,
-            svc_request: meter.u64_counter("request").init(),
-            svc_request_failed: meter.u64_counter("request_failure").init(),
-            long_svc_request: meter.u64_counter("long_request").init(),
-            long_svc_request_failed: meter.u64_counter("long_request_failure").init(),
-            svc_request_latency: meter.u64_histogram("request_latency").init(),
-            long_svc_request_latency: meter.u64_histogram("long_request_latency").init(),
+            svc_request: metric_provider.counter("request"),
+            svc_request_failed: metric_provider.counter("request_failure"),
+            long_svc_request: metric_provider.counter("long_request"),
+            long_svc_request_failed: metric_provider.counter("long_request_failure"),
+            svc_request_latency: metric_provider.histogram("request_latency"),
+            long_svc_request_latency: metric_provider.histogram("long_request_latency"),
         }
     }
 

data/bridge/sdk-core/client/src/raw.rs

@@ -542,6 +542,15 @@ proxier! {
             r.extensions_mut().insert(labels);
         }
     );
+    (
+        delete_workflow_execution,
+        DeleteWorkflowExecutionRequest,
+        DeleteWorkflowExecutionResponse,
+        |r| {
+            let labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
+            r.extensions_mut().insert(labels);
+        }
+    );
     (
         list_open_workflow_executions,
         ListOpenWorkflowExecutionsRequest,
@@ -751,9 +760,9 @@ proxier! {
         }
     );
     (
-        update_workflow,
-        UpdateWorkflowRequest,
-        UpdateWorkflowResponse,
+        update_workflow_execution,
+        UpdateWorkflowExecutionRequest,
+        UpdateWorkflowExecutionResponse,
         |r| {
             let labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
             r.extensions_mut().insert(labels);
@@ -808,17 +817,9 @@ proxier! {
             r.extensions_mut().insert(labels);
         }
     );
-    (delete_workflow_execution, DeleteWorkflowExecutionRequest, DeleteWorkflowExecutionResponse,
-        |r| {
-            let labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
-            r.extensions_mut().insert(labels);
-        }
-    );
     (add_or_update_remote_cluster, AddOrUpdateRemoteClusterRequest, AddOrUpdateRemoteClusterResponse);
     (remove_remote_cluster, RemoveRemoteClusterRequest, RemoveRemoteClusterResponse);
-    (describe_cluster, DescribeClusterRequest, DescribeClusterResponse);
     (list_clusters, ListClustersRequest, ListClustersResponse);
-    (list_cluster_members, ListClusterMembersRequest, ListClusterMembersResponse);
 }
 
 proxier! {
@@ -897,7 +898,7 @@ mod tests {
         let no_underscores: HashSet<_> = impl_list.iter().map(|x| x.replace('_', "")).collect();
         for method in methods {
             if !no_underscores.contains(&method.to_lowercase()) {
-                panic!("RPC method {} is not implemented by raw client", method)
+                panic!("RPC method {method} is not implemented by raw client")
             }
         }
     }