@temporalio/core-bridge 1.1.0 → 1.3.1

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

@@ -2,66 +2,53 @@
 
 pub(crate) mod mocks;
 
-use std::{
-    borrow::Borrow,
-    ops::{Deref, DerefMut},
-};
-use temporal_client::{WorkflowClientTrait, WorkflowTaskCompletion, RETRYABLE_ERROR_CODES};
+use temporal_client::{Client, RetryClient, WorkflowService, WorkflowTaskCompletion};
 use temporal_sdk_core_protos::{
     coresdk::workflow_commands::QueryResult,
     temporal::api::{
-        common::v1::Payloads, enums::v1::WorkflowTaskFailedCause, failure::v1::Failure,
+        common::v1::{Payloads, WorkflowExecution},
+        enums::v1::{TaskQueueKind, WorkflowTaskFailedCause},
+        failure::v1::Failure,
+        query::v1::WorkflowQueryResult,
+        taskqueue::v1::{TaskQueue, TaskQueueMetadata},
         workflowservice::v1::*,
     },
     TaskToken,
 };
-use tonic::Code;
 
 type Result<T, E = tonic::Status> = std::result::Result<T, E>;
 
-/// Returns true if the network error should not be reported to lang. This can happen if we've
-/// exceeded the max number of retries, and we prefer to just warn rather than blowing up lang.
-pub(crate) fn should_swallow_net_error(err: &tonic::Status) -> bool {
-    RETRYABLE_ERROR_CODES.contains(&err.code())
-        || matches!(err.code(), Code::Cancelled | Code::DeadlineExceeded)
-}
-
 /// Contains everything a worker needs to interact with the server
 pub(crate) struct WorkerClientBag {
-    client: Box<dyn WorkerClient>,
+    client: RetryClient<Client>,
     namespace: String,
+    identity: String,
+    worker_build_id: String,
+    use_versioning: bool,
 }
 
 impl WorkerClientBag {
-    pub fn new(client: Box<dyn WorkerClient>, namespace: String) -> Self {
-        Self { client, namespace }
+    pub fn new(
+        client: RetryClient<Client>,
+        namespace: String,
+        identity: String,
+        worker_build_id: String,
+        use_versioning: bool,
+    ) -> Self {
+        Self {
+            client,
+            namespace,
+            identity,
+            worker_build_id,
+            use_versioning,
+        }
     }
-
-    pub fn namespace(&self) -> &str {
-        &self.namespace
-    }
-}
-impl Deref for WorkerClientBag {
-    type Target = dyn WorkerClient;
-
-    fn deref(&self) -> &Self::Target {
-        &*self.client
-    }
-}
-impl DerefMut for WorkerClientBag {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut *self.client
-    }
-}
-#[cfg(test)]
-impl<T> From<T> for WorkerClientBag
-where
-    T: WorkerClient + 'static,
-{
-    fn from(c: T) -> Self {
-        use temporal_sdk_core_test_utils::NAMESPACE;
-
-        WorkerClientBag::new(Box::new(c), NAMESPACE.to_string())
+    fn versioning_build_id(&self) -> String {
+        if self.use_versioning {
+            self.worker_build_id.clone()
+        } else {
+            "".to_string()
+        }
     }
 }
 
@@ -124,17 +111,37 @@ pub(crate) trait WorkerClient: Sync + Send {
 }
 
 #[async_trait::async_trait]
-impl<'a, T> WorkerClient for T
-where
-    // TODO: This should be workflow service... no reason to marry worker trait to sdk client trait
-    T: Borrow<dyn WorkflowClientTrait + 'a + Send + Sync> + Send + Sync,
-{
+impl WorkerClient for WorkerClientBag {
     async fn poll_workflow_task(
         &self,
         task_queue: String,
         is_sticky: bool,
     ) -> Result<PollWorkflowTaskQueueResponse> {
-        WorkflowClientTrait::poll_workflow_task(self.borrow(), task_queue, is_sticky).await
+        let request = PollWorkflowTaskQueueRequest {
+            namespace: self.namespace.clone(),
+            task_queue: Some(TaskQueue {
+                name: task_queue,
+                kind: if is_sticky {
+                    TaskQueueKind::Sticky
+                } else {
+                    TaskQueueKind::Normal
+                } as i32,
+            }),
+            identity: self.identity.clone(),
+            binary_checksum: if self.use_versioning {
+                "".to_string()
+            } else {
+                self.worker_build_id.clone()
+            },
+            worker_versioning_build_id: self.versioning_build_id(),
+        };
+
+        Ok(self
+            .client
+            .clone()
+            .poll_workflow_task_queue(request)
+            .await?
+            .into_inner())
     }
 
     async fn poll_activity_task(
@@ -142,14 +149,62 @@ where
         task_queue: String,
         max_tasks_per_sec: Option<f64>,
     ) -> Result<PollActivityTaskQueueResponse> {
-        WorkflowClientTrait::poll_activity_task(self.borrow(), task_queue, max_tasks_per_sec).await
+        let request = PollActivityTaskQueueRequest {
+            namespace: self.namespace.clone(),
+            task_queue: Some(TaskQueue {
+                name: task_queue,
+                kind: TaskQueueKind::Normal as i32,
+            }),
+            identity: self.identity.clone(),
+            task_queue_metadata: max_tasks_per_sec.map(|tps| TaskQueueMetadata {
+                max_tasks_per_second: Some(tps),
+            }),
+            worker_versioning_build_id: self.versioning_build_id(),
+        };
+
+        Ok(self
+            .client
+            .clone()
+            .poll_activity_task_queue(request)
+            .await?
+            .into_inner())
     }
 
     async fn complete_workflow_task(
         &self,
         request: WorkflowTaskCompletion,
     ) -> Result<RespondWorkflowTaskCompletedResponse> {
-        WorkflowClientTrait::complete_workflow_task(self.borrow(), request).await
+        let request = RespondWorkflowTaskCompletedRequest {
+            task_token: request.task_token.into(),
+            commands: request.commands,
+            identity: self.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.worker_build_id.clone(),
+            query_results: request
+                .query_responses
+                .into_iter()
+                .map(|qr| {
+                    let (id, completed_type, query_result, error_message) = qr.into_components();
+                    (
+                        id,
+                        WorkflowQueryResult {
+                            result_type: completed_type as i32,
+                            answer: query_result,
+                            error_message,
+                        },
+                    )
+                })
+                .collect(),
+            namespace: self.namespace.clone(),
+        };
+        Ok(self
+            .client
+            .clone()
+            .respond_workflow_task_completed(request)
+            .await?
+            .into_inner())
     }
 
     async fn complete_activity_task(
@@ -157,7 +212,17 @@ where
         task_token: TaskToken,
         result: Option<Payloads>,
     ) -> Result<RespondActivityTaskCompletedResponse> {
-        WorkflowClientTrait::complete_activity_task(self.borrow(), task_token, result).await
+        Ok(self
+            .client
+            .clone()
+            .respond_activity_task_completed(RespondActivityTaskCompletedRequest {
+                task_token: task_token.0,
+                result,
+                identity: self.identity.clone(),
+                namespace: self.namespace.clone(),
+            })
+            .await?
+            .into_inner())
     }
 
     async fn record_activity_heartbeat(
@@ -165,7 +230,17 @@ where
         task_token: TaskToken,
         details: Option<Payloads>,
     ) -> Result<RecordActivityTaskHeartbeatResponse> {
-        WorkflowClientTrait::record_activity_heartbeat(self.borrow(), task_token, details).await
+        Ok(self
+            .client
+            .clone()
+            .record_activity_task_heartbeat(RecordActivityTaskHeartbeatRequest {
+                task_token: task_token.0,
+                details,
+                identity: self.identity.clone(),
+                namespace: self.namespace.clone(),
+            })
+            .await?
+            .into_inner())
     }
 
     async fn cancel_activity_task(
@@ -173,7 +248,17 @@ where
         task_token: TaskToken,
         details: Option<Payloads>,
     ) -> Result<RespondActivityTaskCanceledResponse> {
-        WorkflowClientTrait::cancel_activity_task(self.borrow(), task_token, details).await
+        Ok(self
+            .client
+            .clone()
+            .respond_activity_task_canceled(RespondActivityTaskCanceledRequest {
+                task_token: task_token.0,
+                details,
+                identity: self.identity.clone(),
+                namespace: self.namespace.clone(),
+            })
+            .await?
+            .into_inner())
     }
 
     async fn fail_activity_task(
@@ -181,7 +266,19 @@ where
         task_token: TaskToken,
         failure: Option<Failure>,
     ) -> Result<RespondActivityTaskFailedResponse> {
-        WorkflowClientTrait::fail_activity_task(self.borrow(), task_token, failure).await
+        Ok(self
+            .client
+            .clone()
+            .respond_activity_task_failed(RespondActivityTaskFailedRequest {
+                task_token: task_token.0,
+                failure,
+                identity: self.identity.clone(),
+                namespace: self.namespace.clone(),
+                // TODO: Implement - https://github.com/temporalio/sdk-core/issues/293
+                last_heartbeat_details: None,
+            })
+            .await?
+            .into_inner())
     }
 
     async fn fail_workflow_task(
@@ -190,7 +287,20 @@ where
         cause: WorkflowTaskFailedCause,
         failure: Option<Failure>,
     ) -> Result<RespondWorkflowTaskFailedResponse> {
-        WorkflowClientTrait::fail_workflow_task(self.borrow(), task_token, cause, failure).await
+        let request = RespondWorkflowTaskFailedRequest {
+            task_token: task_token.0,
+            cause: cause as i32,
+            failure,
+            identity: self.identity.clone(),
+            binary_checksum: self.worker_build_id.clone(),
+            namespace: self.namespace.clone(),
+        };
+        Ok(self
+            .client
+            .clone()
+            .respond_workflow_task_failed(request)
+            .await?
+            .into_inner())
     }
 
     async fn get_workflow_execution_history(
@@ -199,13 +309,20 @@ where
         run_id: Option<String>,
         page_token: Vec<u8>,
     ) -> Result<GetWorkflowExecutionHistoryResponse> {
-        WorkflowClientTrait::get_workflow_execution_history(
-            self.borrow(),
-            workflow_id,
-            run_id,
-            page_token,
-        )
-        .await
+        Ok(self
+            .client
+            .clone()
+            .get_workflow_execution_history(GetWorkflowExecutionHistoryRequest {
+                namespace: self.namespace.clone(),
+                execution: Some(WorkflowExecution {
+                    workflow_id,
+                    run_id: run_id.unwrap_or_default(),
+                }),
+                next_page_token: page_token,
+                ..Default::default()
+            })
+            .await?
+            .into_inner())
     }
 
     async fn respond_legacy_query(
@@ -213,6 +330,18 @@ where
         task_token: TaskToken,
         query_result: QueryResult,
     ) -> Result<RespondQueryTaskCompletedResponse> {
-        WorkflowClientTrait::respond_legacy_query(self.borrow(), task_token, query_result).await
+        let (_, completed_type, query_result, error_message) = query_result.into_components();
+        Ok(self
+            .client
+            .clone()
+            .respond_query_task_completed(RespondQueryTaskCompletedRequest {
+                task_token: task_token.into(),
+                completed_type: completed_type as i32,
+                query_result,
+                error_message,
+                namespace: self.namespace.clone(),
+            })
+            .await?
+            .into_inner())
     }
 }

package/sdk-core/core/src/worker/mod.rs

@@ -25,8 +25,8 @@ use crate::{
     },
     worker::{
         activities::{DispatchOrTimeoutLA, LACompleteAction, LocalActivityManager},
-        client::{should_swallow_net_error, WorkerClientBag},
-        workflow::{LocalResolution, Workflows},
+        client::WorkerClient,
+        workflow::{LocalResolution, WorkflowBasics, Workflows},
     },
     ActivityHeartbeat, CompleteActivityError, PollActivityError, PollWfError, WorkerTrait,
 };
@@ -50,14 +50,10 @@ use temporal_sdk_core_protos::{
 };
 use tokio_util::sync::CancellationToken;
 
-#[cfg(test)]
-use crate::worker::client::WorkerClient;
-use crate::worker::workflow::WorkflowBasics;
-
 /// A worker polls on a certain task queue
 pub struct Worker {
     config: WorkerConfig,
-    wf_client: Arc<WorkerClientBag>,
+    wf_client: Arc<dyn WorkerClient>,
 
     /// Manages all workflows and WFT processing
     workflows: Workflows,
@@ -156,7 +152,7 @@ impl Worker {
     pub(crate) fn new(
         config: WorkerConfig,
         sticky_queue_name: Option<String>,
-        client: Arc<WorkerClientBag>,
+        client: Arc<dyn WorkerClient>,
         metrics: MetricsContext,
     ) -> Self {
         info!(task_queue = %config.task_queue, "Initializing worker");
@@ -228,13 +224,13 @@ impl Worker {
 
     #[cfg(test)]
     pub(crate) fn new_test(config: WorkerConfig, client: impl WorkerClient + 'static) -> Self {
-        Self::new(config, None, Arc::new(client.into()), Default::default())
+        Self::new(config, None, Arc::new(client), Default::default())
     }
 
     pub(crate) fn new_with_pollers(
         config: WorkerConfig,
         sticky_queue_name: Option<String>,
-        client: Arc<WorkerClientBag>,
+        client: Arc<dyn WorkerClient>,
         wft_stream: impl Stream<Item = Result<ValidPollWFTQResponse, tonic::Status>> + Send + 'static,
         act_poller: Option<BoxedActPoller>,
         metrics: MetricsContext,
@@ -266,6 +262,8 @@ impl Worker {
                     max_outstanding_wfts: config.max_outstanding_workflow_tasks,
                     shutdown_token: shutdown_token.child_token(),
                     metrics,
+                    namespace: config.namespace.clone(),
+                    task_queue: config.task_queue.clone(),
                 },
                 sticky_queue_name.map(|sq| StickyExecutionAttributes {
                     worker_task_queue: Some(TaskQueue {
@@ -273,7 +271,10 @@ impl Worker {
                         kind: TaskQueueKind::Sticky as i32,
                     }),
                     schedule_to_start_timeout: Some(
-                        config.sticky_queue_schedule_to_start_timeout.into(),
+                        config
+                            .sticky_queue_schedule_to_start_timeout
+                            .try_into()
+                            .expect("timeout fits into proto"),
                     ),
                 }),
                 client,
@@ -422,20 +423,14 @@ impl Worker {
         }
 
         if let Some(atm) = &self.at_task_mgr {
-            match atm.complete(task_token, status, &**self.wf_client).await {
-                Err(CompleteActivityError::TonicError(e)) if should_swallow_net_error(&e) => {
-                    warn!(error=?e, "Network error while completing activity");
-                    Ok(())
-                }
-                o => o,
-            }
+            atm.complete(task_token, status, &*self.wf_client).await;
         } else {
             error!(
                 "Tried to complete activity {} on a worker that does not have an activity manager",
                 task_token
             );
-            Ok(())
         }
+        Ok(())
     }
 
     #[instrument(level = "debug", skip(self), fields(run_id))]

package/sdk-core/core/src/worker/workflow/driven_workflow.rs

@@ -45,6 +45,9 @@ impl DrivenWorkflow {
                 .workflow_execution_timeout
                 .clone()
                 .try_into_or_none(),
+            memo: attribs.memo.clone(),
+            search_attrs: attribs.search_attributes.clone(),
+            retry_policy: attribs.retry_policy.clone(),
         };
         self.send_job(start_workflow_from_attribs(attribs, workflow_id, randomness_seed).into());
         self.started_attrs = Some(started_info);

package/sdk-core/core/src/worker/workflow/history_update.rs

@@ -1,6 +1,6 @@
 use crate::{
     replay::{HistoryInfo, TestHistoryBuilder},
-    worker::client::WorkerClientBag,
+    worker::client::WorkerClient,
 };
 use futures::{future::BoxFuture, stream, stream::BoxStream, FutureExt, Stream, StreamExt};
 use std::{
@@ -42,7 +42,7 @@ impl Debug for HistoryUpdate {
 
 pub struct HistoryPaginator {
     // Potentially this could actually be a ref w/ lifetime here
-    client: Arc<WorkerClientBag>,
+    client: Arc<dyn WorkerClient>,
     event_queue: VecDeque<HistoryEvent>,
     wf_id: String,
     run_id: String,
@@ -82,7 +82,7 @@ impl HistoryPaginator {
         wf_id: String,
         run_id: String,
         next_page_token: impl Into<NextPageToken>,
-        client: Arc<WorkerClientBag>,
+        client: Arc<dyn WorkerClient>,
     ) -> Self {
         let next_page_token = next_page_token.into();
         let (event_queue, final_events) =
@@ -397,7 +397,7 @@ pub mod tests {
                 "wfid".to_string(),
                 "runid".to_string(),
                 vec![2], // Start at page "2"
-                Arc::new(mock_client.into()),
+                Arc::new(mock_client),
             ),
             prev_started,
         );
@@ -442,7 +442,7 @@ pub mod tests {
                 "runid".to_string(),
                 // A cache miss means we'll try to fetch from start
                 NextPageToken::FetchFromStart,
-                Arc::new(mock_client.into()),
+                Arc::new(mock_client),
             ),
             1,
         );