@temporalio/core-bridge 1.1.0 → 1.4.0

package/sdk-core/core/src/worker/activities/activity_heartbeat_manager.rs

@@ -1,5 +1,5 @@
 use crate::{
-    worker::{activities::PendingActivityCancel, client::WorkerClientBag},
+    worker::{activities::PendingActivityCancel, client::WorkerClient},
     TaskToken,
 };
 use futures::StreamExt;
@@ -304,7 +304,7 @@ impl HeartbeatStreamState {
 impl ActivityHeartbeatManager {
     /// Creates a new instance of an activity heartbeat manager and returns a handle to the user,
     /// which allows to send new heartbeats and initiate the shutdown.
-    pub fn new(client: Arc<WorkerClientBag>) -> Self {
+    pub fn new(client: Arc<dyn WorkerClient>) -> Self {
         let (heartbeat_stream_state, heartbeat_tx_source, shutdown_token) =
             HeartbeatStreamState::new();
         let (cancels_tx, cancels_rx) = unbounded_channel();
@@ -425,7 +425,7 @@ mod test {
             .expect_record_activity_heartbeat()
             .returning(|_, _| Ok(RecordActivityTaskHeartbeatResponse::default()))
             .times(2);
-        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client.into()));
+        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client));
         let fake_task_token = vec![1, 2, 3];
         // Send 2 heartbeat requests for 20ms apart.
         // The first heartbeat should be sent right away, and
@@ -446,9 +446,9 @@ mod test {
             .expect_record_activity_heartbeat()
             .returning(|_, _| Ok(RecordActivityTaskHeartbeatResponse::default()))
             .times(3);
-        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client.into()));
+        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client));
         let fake_task_token = vec![1, 2, 3];
-        // Heartbeats always get sent if recorded less frequently than the throttle intreval
+        // Heartbeats always get sent if recorded less frequently than the throttle interval
         for i in 0_u8..3 {
             record_heartbeat(&hm, fake_task_token.clone(), i, Duration::from_millis(10));
             sleep(Duration::from_millis(20)).await;
@@ -466,7 +466,7 @@ mod test {
             .expect_record_activity_heartbeat()
             .returning(|_, _| Ok(RecordActivityTaskHeartbeatResponse::default()))
             .times(1);
-        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client.into()));
+        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client));
         let fake_task_token = vec![1, 2, 3];
         // Send a whole bunch of heartbeats very fast. We should still only send one total.
         for i in 0_u8..50 {
@@ -485,7 +485,7 @@ mod test {
             .expect_record_activity_heartbeat()
             .returning(|_, _| Ok(RecordActivityTaskHeartbeatResponse::default()))
             .times(2);
-        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client.into()));
+        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client));
         let fake_task_token = vec![1, 2, 3];
         record_heartbeat(&hm, fake_task_token.clone(), 0, Duration::from_millis(100));
         sleep(Duration::from_millis(500)).await;
@@ -502,7 +502,7 @@ mod test {
             .expect_record_activity_heartbeat()
             .returning(|_, _| Ok(RecordActivityTaskHeartbeatResponse::default()))
             .times(2);
-        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client.into()));
+        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client));
         let fake_task_token = vec![1, 2, 3];
         record_heartbeat(&hm, fake_task_token.clone(), 0, Duration::from_millis(100));
         // Let it propagate
@@ -522,7 +522,7 @@ mod test {
             .expect_record_activity_heartbeat()
             .returning(|_, _| Ok(RecordActivityTaskHeartbeatResponse::default()))
             .times(1);
-        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client.into()));
+        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client));
         let fake_task_token = vec![1, 2, 3];
         record_heartbeat(&hm, fake_task_token.clone(), 0, Duration::from_millis(100));
         hm.evict(fake_task_token.clone().into()).await;
@@ -537,7 +537,7 @@ mod test {
             .expect_record_activity_heartbeat()
             .returning(|_, _| Ok(RecordActivityTaskHeartbeatResponse::default()))
             .times(0);
-        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client.into()));
+        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client));
         hm.shutdown().await;
         match hm.record(
             ActivityHeartbeat {

package/sdk-core/core/src/worker/activities/local_activities.rs

@@ -389,8 +389,8 @@ impl LocalActivityManager {
                 current_attempt_scheduled_time: Some(new_la.schedule_time.into()),
                 started_time: Some(SystemTime::now().into()),
                 attempt,
-                schedule_to_close_timeout: schedule_to_close.map(Into::into),
-                start_to_close_timeout: start_to_close.map(Into::into),
+                schedule_to_close_timeout: schedule_to_close.and_then(|d| d.try_into().ok()),
+                start_to_close_timeout: start_to_close.and_then(|d| d.try_into().ok()),
                 heartbeat_timeout: None,
                 retry_policy: Some(sa.retry_policy),
                 is_local: true,
@@ -440,7 +440,7 @@ impl LocalActivityManager {
                             // We want this to be reported, as the workflow will mark this
                             // failure down, then start a timer for backoff.
                             return LACompleteAction::LangDoesTimerBackoff(
-                                backoff_dur.into(),
+                                backoff_dur.try_into().expect("backoff fits into proto"),
                                 info,
                             );
                         }
@@ -638,7 +638,7 @@ impl Drop for TimeoutBag {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::protosext::LACloseTimeouts;
+    use crate::{prost_dur, protosext::LACloseTimeouts};
     use temporal_sdk_core_protos::temporal::api::{
         common::v1::RetryPolicy,
         failure::v1::{failure::FailureInfo, ApplicationFailureInfo, Failure},
@@ -764,9 +764,9 @@ mod tests {
                 activity_id: 1.to_string(),
                 attempt: 5,
                 retry_policy: RetryPolicy {
-                    initial_interval: Some(Duration::from_secs(1).into()),
+                    initial_interval: Some(prost_dur!(from_secs(1))),
                     backoff_coefficient: 10.0,
-                    maximum_interval: Some(Duration::from_secs(10).into()),
+                    maximum_interval: Some(prost_dur!(from_secs(10))),
                     maximum_attempts: 10,
                     non_retryable_error_types: vec![],
                 },
@@ -799,9 +799,9 @@ mod tests {
                 activity_id: "1".to_string(),
                 attempt: 1,
                 retry_policy: RetryPolicy {
-                    initial_interval: Some(Duration::from_secs(1).into()),
+                    initial_interval: Some(prost_dur!(from_secs(1))),
                     backoff_coefficient: 10.0,
-                    maximum_interval: Some(Duration::from_secs(10).into()),
+                    maximum_interval: Some(prost_dur!(from_secs(10))),
                     maximum_attempts: 10,
                     non_retryable_error_types: vec!["TestError".to_string()],
                 },
@@ -843,9 +843,9 @@ mod tests {
                 activity_id: 1.to_string(),
                 attempt: 5,
                 retry_policy: RetryPolicy {
-                    initial_interval: Some(Duration::from_secs(10).into()),
+                    initial_interval: Some(prost_dur!(from_secs(10))),
                     backoff_coefficient: 1.0,
-                    maximum_interval: Some(Duration::from_secs(10).into()),
+                    maximum_interval: Some(prost_dur!(from_secs(10))),
                     maximum_attempts: 10,
                     non_retryable_error_types: vec![],
                 },
@@ -892,7 +892,7 @@ mod tests {
                 activity_id: 1.to_string(),
                 attempt: 5,
                 retry_policy: RetryPolicy {
-                    initial_interval: Some(Duration::from_millis(10).into()),
+                    initial_interval: Some(prost_dur!(from_millis(10))),
                     backoff_coefficient: 1.0,
                     ..Default::default()
                 },
@@ -929,7 +929,7 @@ mod tests {
                 activity_id: 1.to_string(),
                 attempt: 5,
                 retry_policy: RetryPolicy {
-                    initial_interval: Some(Duration::from_millis(10).into()),
+                    initial_interval: Some(prost_dur!(from_millis(10))),
                     backoff_coefficient: 1.0,
                     ..Default::default()
                 },
@@ -975,7 +975,7 @@ mod tests {
                 activity_id: 1.to_string(),
                 attempt: 5,
                 retry_policy: RetryPolicy {
-                    initial_interval: Some(Duration::from_millis(10).into()),
+                    initial_interval: Some(prost_dur!(from_millis(10))),
                     backoff_coefficient: 1.0,
                     ..Default::default()
                 },

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

@@ -12,10 +12,9 @@ use crate::{
     pollers::BoxedActPoller,
     telemetry::metrics::{activity_type, activity_worker_type, workflow_type, MetricsContext},
     worker::{
-        activities::activity_heartbeat_manager::ActivityHeartbeatError,
-        client::{WorkerClient, WorkerClientBag},
+        activities::activity_heartbeat_manager::ActivityHeartbeatError, client::WorkerClient,
     },
-    CompleteActivityError, PollActivityError, TaskToken,
+    PollActivityError, TaskToken,
 };
 use activity_heartbeat_manager::ActivityHeartbeatManager;
 use dashmap::DashMap;
@@ -136,7 +135,7 @@ impl WorkerActivityTasks {
         max_activity_tasks: usize,
         max_worker_act_per_sec: Option<f64>,
         poller: BoxedActPoller,
-        client: Arc<WorkerClientBag>,
+        client: Arc<dyn WorkerClient>,
         metrics: MetricsContext,
         max_heartbeat_throttle_interval: Duration,
         default_heartbeat_throttle_interval: Duration,
@@ -232,7 +231,7 @@ impl WorkerActivityTasks {
         task_token: TaskToken,
         status: aer::Status,
         client: &dyn WorkerClient,
-    ) -> Result<(), CompleteActivityError> {
+    ) {
         if let Some((_, act_info)) = self.outstanding_activity_tasks.remove(&task_token) {
             let act_metrics = self.metrics.with_new_attrs([
                 activity_type(act_info.base.activity_type.clone()),
@@ -285,7 +284,7 @@ impl WorkerActivityTasks {
                         completion. This may happen if the activity has already been cancelled but \
                         completed anyway.");
                     } else {
-                        return Err(e.into());
+                        warn!(error=?e, "Network error while completing activity");
                     };
                 };
             };
@@ -295,7 +294,6 @@ impl WorkerActivityTasks {
                 &task_token
             );
         }
-        Ok(())
     }
 
     /// Attempt to record an activity heartbeat
@@ -446,15 +444,11 @@ mod tests {
             }
             .into(),
         ]);
-        let client = WorkerClientBag::new(
-            Box::new(mock_manual_workflow_client()),
-            "fake_namespace".to_string(),
-        );
         let atm = WorkerActivityTasks::new(
             10,
             Some(2.0),
             poller,
-            Arc::new(client),
+            Arc::new(mock_manual_workflow_client()),
             MetricsContext::default(),
             Duration::from_secs(1),
             Duration::from_secs(1),

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

@@ -17,6 +17,7 @@ pub(crate) fn mock_manual_workflow_client() -> MockManualWorkerClient {
 // https://github.com/asomers/mockall/issues/189 to be fixed for it to go away.
 mockall::mock! {
     pub ManualWorkerClient {}
+    #[allow(unused)]
     impl WorkerClient for ManualWorkerClient {
         fn poll_workflow_task<'a, 'b>(&'a self, task_queue: String, is_sticky: bool)
             -> impl Future<Output = Result<PollWorkflowTaskQueueResponse>> + Send + 'b

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())
     }
 }