@temporalio/core-bridge 0.20.1 → 0.20.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporalio/core-bridge",
-  "version": "0.20.1",
+  "version": "0.20.2",
   "description": "Temporal.io SDK Core<>Node bridge",
   "main": "index.js",
   "types": "index.d.ts",
@@ -43,5 +43,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "a9fc2f32f9e1624758f334319e2135f25ff9ed24"
+  "gitHead": "ce4a3b017cdc327fb9f2d3812e3278304f6514b4"
 }

package/sdk-core/core/src/core_tests/workflow_tasks.rs

@@ -35,7 +35,7 @@ use temporal_sdk_core_protos::{
     temporal::api::{
         enums::v1::{EventType, WorkflowTaskFailedCause},
         failure::v1::Failure,
-        history::v1::{history_event, TimerFiredEventAttributes},
+        history::v1::{history_event, History, TimerFiredEventAttributes},
         workflowservice::v1::{
             GetWorkflowExecutionHistoryResponse, RespondWorkflowTaskCompletedResponse,
         },
@@ -1694,3 +1694,46 @@ async fn tasks_from_completion_are_delivered() {
     .unwrap();
     core.shutdown().await;
 }
+
+#[tokio::test]
+async fn evict_missing_wf_during_poll_doesnt_eat_permit() {
+    let wfid = "fake_wf_id";
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+    t.add_we_signaled("sig", vec![]);
+    t.add_full_wf_task();
+    t.add_workflow_execution_completed();
+
+    let tasks = [hist_to_poll_resp(
+        &t,
+        wfid.to_owned(),
+        // Use a partial task so that we'll fetch history
+        ResponseType::OneTask(2),
+        TEST_Q.to_string(),
+    )];
+    let mut mock = mock_workflow_client();
+    mock.expect_get_workflow_execution_history()
+        .times(1)
+        .returning(move |_, _, _| {
+            Ok(GetWorkflowExecutionHistoryResponse {
+                // Empty history so we error applying it (no jobs)
+                history: Some(History { events: vec![] }),
+                raw_history: vec![],
+                next_page_token: vec![],
+                archived: false,
+            })
+        });
+    let mut mock = MocksHolder::from_client_with_responses(mock, tasks, []);
+    mock.worker_cfg(|wc| {
+        wc.max_cached_workflows = 1;
+        wc.max_outstanding_workflow_tasks = 1;
+    });
+    let core = mock_worker(mock);
+
+    // Should error because mock is out of work
+    assert_matches!(core.poll_workflow_activation().await, Err(_));
+    assert_eq!(core.available_wft_permits(), 1);
+
+    core.shutdown().await;
+}

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

@@ -14,7 +14,10 @@ use temporal_sdk_core_protos::{
         activity_task::{activity_task, ActivityCancelReason, ActivityTask, Cancel, Start},
         common::WorkflowExecution,
     },
-    temporal::api::enums::v1::TimeoutType,
+    temporal::api::{
+        enums::v1::TimeoutType,
+        failure::v1::{failure::FailureInfo, ApplicationFailureInfo},
+    },
 };
 use tokio::{
     sync::{
@@ -420,10 +423,13 @@ impl LocalActivityManager {
                 LocalActivityExecutionResult::Failed(f) => {
                     if let Some(backoff_dur) = info.la_info.schedule_cmd.retry_policy.should_retry(
                         info.attempt as usize,
-                        &f.failure
-                            .as_ref()
-                            .map(|f| format!("{:?}", f))
-                            .unwrap_or_else(|| "".to_string()),
+                        f.failure.as_ref().map_or("", |f| match &f.failure_info {
+                            Some(FailureInfo::ApplicationFailureInfo(ApplicationFailureInfo {
+                                r#type,
+                                ..
+                            })) => r#type.as_str(),
+                            _ => "",
+                        }),
                     ) {
                         let will_use_timer =
                             backoff_dur > info.la_info.schedule_cmd.local_retry_threshold;
@@ -637,7 +643,9 @@ impl Drop for TimeoutBag {
 mod tests {
     use super::*;
     use crate::protosext::LACloseTimeouts;
-    use temporal_sdk_core_protos::coresdk::common::RetryPolicy;
+    use temporal_sdk_core_protos::{
+        coresdk::common::RetryPolicy, temporal::api::failure::v1::Failure,
+    };
     use tokio::{sync::mpsc::error::TryRecvError, task::yield_now};
 
     impl DispatchOrTimeoutLA {
@@ -785,6 +793,50 @@ mod tests {
         )
     }
 
+    #[tokio::test]
+    async fn respects_non_retryable_error_types() {
+        let lam = LocalActivityManager::test(1);
+        lam.enqueue([NewLocalAct {
+            schedule_cmd: ValidScheduleLA {
+                seq: 1,
+                activity_id: "1".to_string(),
+                attempt: 1,
+                retry_policy: RetryPolicy {
+                    initial_interval: Some(Duration::from_secs(1).into()),
+                    backoff_coefficient: 10.0,
+                    maximum_interval: Some(Duration::from_secs(10).into()),
+                    maximum_attempts: 10,
+                    non_retryable_error_types: vec!["TestError".to_string()],
+                },
+                local_retry_threshold: Duration::from_secs(5),
+                ..Default::default()
+            },
+            workflow_type: "".to_string(),
+            workflow_exec_info: Default::default(),
+            schedule_time: SystemTime::now(),
+        }
+        .into()]);
+
+        let next = lam.next_pending().await.unwrap().unwrap();
+        let tt = TaskToken(next.task_token);
+        let res = lam.complete(
+            &tt,
+            &LocalActivityExecutionResult::Failed(ActFail {
+                failure: Some(Failure {
+                    failure_info: Some(FailureInfo::ApplicationFailureInfo(
+                        ApplicationFailureInfo {
+                            r#type: "TestError".to_string(),
+                            non_retryable: false,
+                            ..Default::default()
+                        },
+                    )),
+                    ..Default::default()
+                }),
+            }),
+        );
+        assert_matches!(res, LACompleteAction::Report(_));
+    }
+
     #[tokio::test]
     async fn can_cancel_during_local_backoff() {
         let lam = LocalActivityManager::test(1);

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

@@ -65,6 +65,7 @@ use tracing_futures::Instrument;
 
 #[cfg(test)]
 use crate::worker::client::WorkerClient;
+use crate::workflow::workflow_tasks::EvictionRequestResult;
 
 /// A worker polls on a certain task queue
 pub struct Worker {
@@ -530,13 +531,18 @@ impl Worker {
         self.workflows_semaphore.add_permit();
     }
 
+    /// Request a workflow eviction. Returns true if we actually queued up a new eviction request.
     pub(crate) fn request_wf_eviction(
         &self,
         run_id: &str,
         message: impl Into<String>,
         reason: EvictionReason,
-    ) {
-        self.wft_manager.request_eviction(run_id, message, reason);
+    ) -> bool {
+        match self.wft_manager.request_eviction(run_id, message, reason) {
+            EvictionRequestResult::EvictionIssued(_) => true,
+            EvictionRequestResult::NotFound => false,
+            EvictionRequestResult::EvictionAlreadyOutstanding => false,
+        }
     }
 
     /// Sets a function to be called at the end of each activation completion
@@ -675,11 +681,16 @@ impl Worker {
             }
             NewWfTaskOutcome::Evict(e) => {
                 warn!(error=?e, run_id=%we.run_id, "Error while applying poll response to workflow");
-                self.request_wf_eviction(
+                let did_issue_eviction = self.request_wf_eviction(
                     &we.run_id,
                     format!("Error while applying poll response to workflow: {:?}", e),
                     e.evict_reason(),
                 );
+                // If we didn't actually need to issue an eviction, then return the WFT permit.
+                // EX: The workflow we tried to evict wasn't in the cache.
+                if !did_issue_eviction {
+                    self.return_workflow_task_permit();
+                }
                 None
             }
         })

package/sdk-core/core/src/workflow/workflow_tasks/concurrency_manager.rs

@@ -8,11 +8,11 @@ use crate::{
 };
 use futures::future::{BoxFuture, FutureExt};
 use parking_lot::{Mutex, RwLock, RwLockReadGuard, RwLockWriteGuard};
-use std::sync::Arc;
 use std::{
     collections::HashMap,
     fmt::Debug,
     ops::{Deref, DerefMut},
+    sync::Arc,
 };
 use temporal_sdk_core_protos::coresdk::workflow_activation::WorkflowActivation;
 

package/sdk-core/core/src/workflow/workflow_tasks/mod.rs

@@ -150,6 +150,13 @@ pub(crate) enum ActivationAction {
     RespondLegacyQuery { result: QueryResult },
 }
 
+#[derive(Debug, Eq, PartialEq, Hash)]
+pub(crate) enum EvictionRequestResult {
+    EvictionIssued(Option<u32>),
+    NotFound,
+    EvictionAlreadyOutstanding,
+}
+
 macro_rules! machine_mut {
     ($myself:ident, $run_id:ident, $clos:expr) => {{
         $myself
@@ -247,7 +254,7 @@ impl WorkflowTaskManager {
         run_id: &str,
         message: impl Into<String>,
         reason: EvictionReason,
-    ) -> Option<u32> {
+    ) -> EvictionRequestResult {
         if self.workflow_machines.exists(run_id) {
             if !self.activation_has_eviction(run_id) {
                 let message = message.into();
@@ -256,13 +263,17 @@ impl WorkflowTaskManager {
                 self.pending_activations
                     .notify_needs_eviction(run_id, message, reason);
                 self.pending_activations_notifier.notify_waiters();
+                EvictionRequestResult::EvictionIssued(
+                    self.workflow_machines
+                        .get_task(run_id)
+                        .map(|wt| wt.info.attempt),
+                )
+            } else {
+                EvictionRequestResult::EvictionAlreadyOutstanding
             }
-            self.workflow_machines
-                .get_task(run_id)
-                .map(|wt| wt.info.attempt)
         } else {
             warn!(%run_id, "Eviction requested for unknown run");
-            None
+            EvictionRequestResult::NotFound
         }
     }
 
@@ -304,9 +315,11 @@ impl WorkflowTaskManager {
             return NewWfTaskOutcome::TaskBuffered;
         };
 
+        let start_event_id = work.history.events.first().map(|e| e.event_id);
         debug!(
             task_token = %&work.task_token,
             history_length = %work.history.events.len(),
+            start_event_id = ?start_event_id,
             attempt = %work.attempt,
             run_id = %work.workflow_execution.run_id,
             "Applying new workflow task from server"
@@ -559,9 +572,10 @@ impl WorkflowTaskManager {
             FailedActivationOutcome::ReportLegacyQueryFailure(tt)
         } else {
             // Blow up any cached data associated with the workflow
-            let should_report = self
-                .request_eviction(run_id, failstr, reason)
-                .map_or(true, |attempt| attempt <= 1);
+            let should_report = match self.request_eviction(run_id, failstr, reason) {
+                EvictionRequestResult::EvictionIssued(Some(attempt)) => attempt <= 1,
+                _ => false,
+            };
             if should_report {
                 FailedActivationOutcome::Report(tt)
             } else {

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

@@ -389,7 +389,7 @@ impl ActivityHalf {
                 tokio::spawn(ACT_CANCEL_TOK.scope(ct, async move {
                     let mut inputs = start.input;
                     let arg = inputs.pop().unwrap_or_default();
-                    let output = (&act_fn.act_func)(arg).await;
+                    let output = (act_fn.act_func)(arg).await;
                     let result = match output {
                         Ok(res) => ActivityExecutionResult::ok(res),
                         Err(err) => match err.downcast::<ActivityCancelledError>() {

package/sdk-core/tests/integ_tests/workflow_tests/continue_as_new.rs

@@ -1,5 +1,5 @@
 use std::time::Duration;
-use temporal_client::{WorkflowClientTrait, WorkflowOptions};
+use temporal_client::WorkflowOptions;
 use temporal_sdk::{WfContext, WfExitValue, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::workflow_commands::ContinueAsNewWorkflowExecution;
 use temporal_sdk_core_test_utils::CoreWfStarter;
@@ -33,13 +33,31 @@ async fn continue_as_new_happy_path() {
         )
         .await
         .unwrap();
+    // The four additional runs
+    worker.incr_expected_run_count(4);
     worker.run_until_done().await.unwrap();
+}
 
-    // Terminate the continued workflow
-    starter
-        .get_client()
-        .await
-        .terminate_workflow_execution(wf_name.to_owned(), None)
-        .await
-        .unwrap();
+#[tokio::test]
+async fn continue_as_new_multiple_concurrent() {
+    let wf_name = "continue_as_new_multiple_concurrent";
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter.max_cached_workflows(3).max_wft(3);
+    let mut worker = starter.worker().await;
+    worker.register_wf(wf_name.to_string(), continue_as_new_wf);
+
+    let wf_names = (1..=20).map(|i| format!("{}-{}", wf_name, i));
+    for name in wf_names.clone() {
+        worker
+            .submit_wf(
+                name.to_string(),
+                wf_name.to_string(),
+                vec![[1].into()],
+                WorkflowOptions::default(),
+            )
+            .await
+            .unwrap();
+    }
+    worker.incr_expected_run_count(20 * 4);
+    worker.run_until_done().await.unwrap();
 }