@temporalio/core-bridge 1.4.3 → 1.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporalio/core-bridge",
-  "version": "1.4.3",
+  "version": "1.4.4",
   "description": "Temporal.io SDK Core<>Node bridge",
   "main": "index.js",
   "types": "index.d.ts",
@@ -42,5 +42,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "be51cfac7016b66151d70dbd5aca7f7ef02b260a"
+  "gitHead": "7ae3fba6332000b35d521411404c11e32052f282"
 }

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

@@ -614,6 +614,83 @@ async fn max_tq_acts_set_passed_to_poll_properly() {
     worker.poll_activity_task().await.unwrap();
 }
 
+/// This test doesn't test the real worker config since [mock_worker] bypasses the worker
+/// constructor, [mock_worker] will not pass an activity poller to the worker when
+/// `no_remote_activities` is set to `true`.
+#[tokio::test]
+async fn no_eager_activities_requested_when_worker_options_disable_remote_activities() {
+    let wfid = "fake_wf_id";
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+    let scheduled_event_id = t.add_activity_task_scheduled("act_id");
+    let started_event_id = t.add_activity_task_started(scheduled_event_id);
+    t.add_activity_task_completed(scheduled_event_id, started_event_id, b"hi".into());
+    t.add_full_wf_task();
+    t.add_workflow_execution_completed();
+    let num_eager_requested = Arc::new(AtomicUsize::new(0));
+    // Clone it to move into the callback below
+    let num_eager_requested_clone = num_eager_requested.clone();
+
+    let mut mock = mock_workflow_client();
+    mock.expect_complete_workflow_task()
+        .times(1)
+        .returning(move |req| {
+            // Store the number of eager activities requested to be checked below
+            let count = req
+                .commands
+                .into_iter()
+                .filter(|c| match c.attributes {
+                    Some(Attributes::ScheduleActivityTaskCommandAttributes(
+                        ScheduleActivityTaskCommandAttributes {
+                            request_eager_execution,
+                            ..
+                        },
+                    )) => request_eager_execution,
+                    _ => false,
+                })
+                .count();
+            num_eager_requested_clone.store(count, Ordering::Relaxed);
+            Ok(RespondWorkflowTaskCompletedResponse {
+                workflow_task: None,
+                activity_tasks: vec![],
+            })
+        });
+    let mut mock = single_hist_mock_sg(wfid, t, [1], mock, true);
+    let mut mock_poller = mock_manual_poller();
+    mock_poller
+        .expect_poll()
+        .returning(|| futures::future::pending().boxed());
+    mock.set_act_poller(Box::new(mock_poller));
+    mock.worker_cfg(|wc| {
+        wc.max_cached_workflows = 2;
+        wc.no_remote_activities = true;
+    });
+    let core = mock_worker(mock);
+
+    // Test start
+    let wf_task = core.poll_workflow_activation().await.unwrap();
+    let cmds = vec![ScheduleActivity {
+        seq: 1,
+        activity_id: "act_id".to_string(),
+        task_queue: TEST_Q.to_string(),
+        cancellation_type: ActivityCancellationType::TryCancel as i32,
+        ..Default::default()
+    }
+    .into()];
+
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
+        wf_task.run_id,
+        cmds,
+    ))
+    .await
+    .unwrap();
+
+    core.shutdown().await;
+
+    assert_eq!(num_eager_requested.load(Ordering::Relaxed), 0);
+}
+
 /// This test verifies that activity tasks which come as replies to completing a WFT are properly
 /// delivered via polling.
 #[tokio::test]

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

@@ -133,12 +133,17 @@ pub(crate) fn build_fake_worker(
 
 pub(crate) fn mock_worker(mocks: MocksHolder) -> Worker {
     let sticky_q = sticky_q_name_for_worker("unit-test", &mocks.inputs.config);
+    let act_poller = if mocks.inputs.config.no_remote_activities {
+        None
+    } else {
+        mocks.inputs.act_poller
+    };
     Worker::new_with_pollers(
         mocks.inputs.config,
         sticky_q,
         mocks.client,
         mocks.inputs.wft_stream,
-        mocks.inputs.act_poller,
+        act_poller,
         Default::default(),
         CancellationToken::new(),
     )

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

@@ -458,32 +458,34 @@ impl Workflows {
         commands: &mut [Command],
     ) -> Vec<OwnedMeteredSemPermit> {
         let mut reserved = vec![];
-        if let Some(at_handle) = self.activity_tasks_handle.as_ref() {
-            for cmd in commands {
-                if let Some(Attributes::ScheduleActivityTaskCommandAttributes(attrs)) =
-                    cmd.attributes.as_mut()
-                {
-                    // If request_eager_execution was already false, that means lang explicitly
-                    // told us it didn't want to eagerly execute for some reason. So, we only
-                    // ever turn *off* eager execution if a slot is not available or the activity
-                    // is scheduled on a different task queue.
-                    if attrs.request_eager_execution {
-                        let same_task_queue = attrs
-                            .task_queue
+        for cmd in commands {
+            if let Some(Attributes::ScheduleActivityTaskCommandAttributes(attrs)) =
+                cmd.attributes.as_mut()
+            {
+                // If request_eager_execution was already false, that means lang explicitly
+                // told us it didn't want to eagerly execute for some reason. So, we only
+                // ever turn *off* eager execution if a slot is not available or the activity
+                // is scheduled on a different task queue.
+                if attrs.request_eager_execution {
+                    let same_task_queue = attrs
+                        .task_queue
+                        .as_ref()
+                        .map(|q| q.name == self.task_queue)
+                        .unwrap_or_default();
+                    if same_task_queue
+                        && reserved.len() < MAX_EAGER_ACTIVITY_RESERVATIONS_PER_WORKFLOW_TASK
+                    {
+                        if let Some(p) = self
+                            .activity_tasks_handle
                             .as_ref()
-                            .map(|q| q.name == self.task_queue)
-                            .unwrap_or_default();
-                        if same_task_queue
-                            && reserved.len() < MAX_EAGER_ACTIVITY_RESERVATIONS_PER_WORKFLOW_TASK
+                            .and_then(|h| h.reserve_slot())
                         {
-                            if let Some(p) = at_handle.reserve_slot() {
-                                reserved.push(p);
-                            } else {
-                                attrs.request_eager_execution = false;
-                            }
+                            reserved.push(p);
                         } else {
                             attrs.request_eager_execution = false;
                         }
+                    } else {
+                        attrs.request_eager_execution = false;
                     }
                 }
             }