@temporalio/core-bridge 1.14.1 → 1.15.0

package/sdk-core/crates/sdk-core/src/core_tests/workers.rs

@@ -333,19 +333,15 @@ async fn worker_shutdown_api(#[case] use_cache: bool, #[case] api_success: bool)
         .returning(|| ("test-core".to_string(), "0.0.0".to_string()));
     mock.expect_identity()
         .returning(|| "test-identity".to_string());
-    if use_cache {
-        if api_success {
-            mock.expect_shutdown_worker()
-                .times(1)
-                .returning(|_, _| Ok(ShutdownWorkerResponse {}));
-        } else {
-            // worker.shutdown() should succeed even if shutdown_worker fails
-            mock.expect_shutdown_worker()
-                .times(1)
-                .returning(|_, _| Err(tonic::Status::unavailable("fake shutdown error")));
-        }
+    if api_success {
+        mock.expect_shutdown_worker()
+            .times(1)
+            .returning(|_, _| Ok(ShutdownWorkerResponse {}));
     } else {
-        mock.expect_shutdown_worker().times(0);
+        // worker.shutdown() should succeed even if shutdown_worker fails
+        mock.expect_shutdown_worker()
+            .times(1)
+            .returning(|_, _| Err(tonic::Status::unavailable("fake shutdown error")));
     }
 
     let t = canned_histories::single_timer("1");
@@ -397,10 +393,16 @@ fn create_test_activity_task() -> PollActivityTaskQueueResponse {
 }
 
 fn create_test_nexus_task() -> PollNexusTaskQueueResponse {
+    create_test_nexus_task_with_headers(Default::default())
+}
+
+fn create_test_nexus_task_with_headers(
+    header: std::collections::HashMap<String, String>,
+) -> PollNexusTaskQueueResponse {
     PollNexusTaskQueueResponse {
         task_token: b"nex-task".to_vec(),
         request: Some(NexusRequest {
-            header: Default::default(),
+            header,
             scheduled_time: None,
             variant: Some(temporalio_common::protos::temporal::api::nexus::v1::request::Variant::StartOperation(
                 StartOperationRequest {
@@ -413,6 +415,7 @@ fn create_test_nexus_task() -> PollNexusTaskQueueResponse {
                     links: vec![],
                 }
             )),
+            endpoint: "".to_string(),
         }),
         poller_scaling_decision: None,
     }
@@ -589,3 +592,153 @@ async fn test_task_type_combinations_unified(
     worker.shutdown().await;
     worker.finalize_shutdown().await;
 }
+
+#[tokio::test]
+async fn nexus_request_deadline_missing_header() {
+    let mut client = mock_worker_client();
+    client
+        .expect_complete_nexus_task()
+        .returning(|_, _| Ok(RespondNexusTaskCompletedResponse::default()));
+    let nexus_task = create_test_nexus_task(); // No headers
+    let mut mocks = MocksHolder::from_client_with_custom(
+        client,
+        None::<stream::Empty<_>>,
+        None::<Vec<QueueResponse<PollActivityTaskQueueResponse>>>,
+        Some(vec![QueueResponse::from(nexus_task)]),
+    );
+    mocks.worker_cfg(|w| {
+        w.task_queue = "test-queue".to_string();
+        w.task_types = WorkerTaskTypes {
+            enable_workflows: false,
+            enable_local_activities: false,
+            enable_remote_activities: false,
+            enable_nexus: true,
+        };
+        w.skip_client_worker_set_check = true;
+    });
+    let worker = mock_worker(mocks);
+
+    let nexus_task = worker.poll_nexus_task().await.unwrap();
+    assert!(
+        nexus_task.request_deadline.is_none(),
+        "request_deadline should be None when header is missing"
+    );
+
+    worker
+        .complete_nexus_task(create_test_nexus_completion(nexus_task.task_token()))
+        .await
+        .unwrap();
+    worker.initiate_shutdown();
+    assert_matches!(
+        worker.poll_nexus_task().await.unwrap_err(),
+        PollError::ShutDown
+    );
+    worker.shutdown().await;
+    worker.finalize_shutdown().await;
+}
+
+#[tokio::test]
+async fn nexus_request_deadline_valid_header() {
+    let mut client = mock_worker_client();
+    client
+        .expect_complete_nexus_task()
+        .returning(|_, _| Ok(RespondNexusTaskCompletedResponse::default()));
+    let mut headers = std::collections::HashMap::new();
+    headers.insert("request-timeout".to_string(), "30s".to_string());
+    let nexus_task = create_test_nexus_task_with_headers(headers);
+    let mut mocks = MocksHolder::from_client_with_custom(
+        client,
+        None::<stream::Empty<_>>,
+        None::<Vec<QueueResponse<PollActivityTaskQueueResponse>>>,
+        Some(vec![QueueResponse::from(nexus_task)]),
+    );
+    mocks.worker_cfg(|w| {
+        w.task_queue = "test-queue".to_string();
+        w.task_types = WorkerTaskTypes {
+            enable_workflows: false,
+            enable_local_activities: false,
+            enable_remote_activities: false,
+            enable_nexus: true,
+        };
+        w.skip_client_worker_set_check = true;
+    });
+    let worker = mock_worker(mocks);
+
+    let before = std::time::SystemTime::now();
+    let nexus_task = worker.poll_nexus_task().await.unwrap();
+    let after = std::time::SystemTime::now();
+
+    assert!(
+        nexus_task.request_deadline.is_some(),
+        "request_deadline should be Some when valid header is present"
+    );
+    let deadline: std::time::SystemTime = nexus_task.request_deadline.unwrap().try_into().unwrap();
+    // Deadline should be approximately 30s from now
+    let expected_min = before + Duration::from_secs(30);
+    let expected_max = after + Duration::from_secs(30);
+    assert!(
+        deadline >= expected_min && deadline <= expected_max,
+        "deadline {:?} should be between {:?} and {:?}",
+        deadline,
+        expected_min,
+        expected_max
+    );
+
+    worker
+        .complete_nexus_task(create_test_nexus_completion(nexus_task.task_token()))
+        .await
+        .unwrap();
+    worker.initiate_shutdown();
+    assert_matches!(
+        worker.poll_nexus_task().await.unwrap_err(),
+        PollError::ShutDown
+    );
+    worker.shutdown().await;
+    worker.finalize_shutdown().await;
+}
+
+#[tokio::test]
+async fn nexus_request_deadline_invalid_header() {
+    let mut client = mock_worker_client();
+    client
+        .expect_complete_nexus_task()
+        .returning(|_, _| Ok(RespondNexusTaskCompletedResponse::default()));
+    let mut headers = std::collections::HashMap::new();
+    headers.insert("request-timeout".to_string(), "invalid".to_string());
+    let nexus_task = create_test_nexus_task_with_headers(headers);
+    let mut mocks = MocksHolder::from_client_with_custom(
+        client,
+        None::<stream::Empty<_>>,
+        None::<Vec<QueueResponse<PollActivityTaskQueueResponse>>>,
+        Some(vec![QueueResponse::from(nexus_task)]),
+    );
+    mocks.worker_cfg(|w| {
+        w.task_queue = "test-queue".to_string();
+        w.task_types = WorkerTaskTypes {
+            enable_workflows: false,
+            enable_local_activities: false,
+            enable_remote_activities: false,
+            enable_nexus: true,
+        };
+        w.skip_client_worker_set_check = true;
+    });
+    let worker = mock_worker(mocks);
+
+    let nexus_task = worker.poll_nexus_task().await.unwrap();
+    assert!(
+        nexus_task.request_deadline.is_none(),
+        "request_deadline should be None when header is invalid"
+    );
+
+    worker
+        .complete_nexus_task(create_test_nexus_completion(nexus_task.task_token()))
+        .await
+        .unwrap();
+    worker.initiate_shutdown();
+    assert_matches!(
+        worker.poll_nexus_task().await.unwrap_err(),
+        PollError::ShutDown
+    );
+    worker.shutdown().await;
+    worker.finalize_shutdown().await;
+}

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

@@ -1621,6 +1621,7 @@ async fn history_byte_size_and_can_suggestion_in_activation() {
             he.attributes
         {
             attrs.suggest_continue_as_new = true;
+            attrs.suggest_continue_as_new_reasons = vec![1, 2, 3, 4]
         }
     });
 
@@ -1645,6 +1646,7 @@ async fn history_byte_size_and_can_suggestion_in_activation() {
     let activation = worker.poll_workflow_activation().await.unwrap();
     assert_eq!(activation.history_size_bytes, 70);
     assert!(activation.continue_as_new_suggested);
+    assert_eq!(activation.suggest_continue_as_new_reasons, vec![1, 2, 3, 4])
 }
 
 /// This test verifies that WFTs which come as replies to completing a WFT are properly delivered
@@ -2022,12 +2024,15 @@ async fn no_race_acquiring_permits() {
         .returning(|_| async move { Ok(Default::default()) }.boxed());
 
     let worker = Worker::new_test(
-        test_worker_cfg()
-            .max_outstanding_workflow_tasks(2_usize)
-            .max_cached_workflows(0_usize)
-            .ignore_evicts_on_shutdown(false)
-            .build()
-            .unwrap(),
+        {
+            let mut cfg = test_worker_cfg()
+                .max_outstanding_workflow_tasks(2_usize)
+                .max_cached_workflows(0_usize)
+                .build()
+                .unwrap();
+            cfg.ignore_evicts_on_shutdown = false;
+            cfg
+        },
         mock_client,
     );
 
@@ -2667,13 +2672,14 @@ async fn poller_wont_run_ahead_of_task_slots() {
         .returning(|_| Ok(Default::default()));
 
     let worker = Worker::new_test(
-        test_worker_cfg()
-            .max_cached_workflows(10_usize)
-            .max_outstanding_workflow_tasks(10_usize)
-            .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(10_usize))
-            .task_types(WorkerTaskTypes::workflow_only())
-            .build()
-            .unwrap(),
+        {
+            let mut cfg = test_worker_cfg().build().unwrap();
+            cfg.max_cached_workflows = 10_usize;
+            cfg.max_outstanding_workflow_tasks = Some(10_usize);
+            cfg.workflow_task_poller_behavior = PollerBehavior::SimpleMaximum(10_usize);
+            cfg.task_types = WorkerTaskTypes::workflow_only();
+            cfg
+        },
         mock_client,
     );
 
@@ -2730,10 +2736,11 @@ async fn poller_wont_poll_until_lang_polls() {
         });
 
     let worker = Worker::new_test(
-        test_worker_cfg()
-            .task_types(WorkerTaskTypes::workflow_only())
-            .build()
-            .unwrap(),
+        {
+            let mut cfg = test_worker_cfg().build().unwrap();
+            cfg.task_types = WorkerTaskTypes::workflow_only();
+            cfg
+        },
         mock_client,
     );
 
@@ -2868,17 +2875,18 @@ async fn slot_provider_cant_hand_out_more_permits_than_cache_size() {
     }
 
     let worker = Worker::new_test(
-        test_worker_cfg()
-            .max_cached_workflows(10_usize)
-            .tuner(Arc::new(
+        {
+            let mut cfg = test_worker_cfg().build().unwrap();
+            cfg.max_cached_workflows = 10_usize;
+            cfg.tuner = Some(Arc::new(
                 TunerBuilder::default()
                     .workflow_slot_supplier(Arc::new(EndlessSupplier {}))
                     .build(),
-            ))
-            .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(10_usize))
-            .task_types(WorkerTaskTypes::workflow_only())
-            .build()
-            .unwrap(),
+            ));
+            cfg.workflow_task_poller_behavior = PollerBehavior::SimpleMaximum(10_usize);
+            cfg.task_types = WorkerTaskTypes::workflow_only();
+            cfg
+        },
         mock_client,
     );
 
@@ -3019,14 +3027,15 @@ async fn both_normal_and_sticky_pollers_poll_concurrently() {
         });
 
     let worker = Worker::new(
-        test_worker_cfg()
-            .max_cached_workflows(500_usize) // We need cache, but don't want to deal with evictions
-            .max_outstanding_workflow_tasks(2_usize)
-            .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(2_usize))
-            .nonsticky_to_sticky_poll_ratio(0.2)
-            .task_types(WorkerTaskTypes::workflow_only())
-            .build()
-            .unwrap(),
+        {
+            let mut cfg = test_worker_cfg().build().unwrap();
+            cfg.max_cached_workflows = 500_usize; // We need cache, but don't want to deal with evictions
+            cfg.max_outstanding_workflow_tasks = Some(2_usize);
+            cfg.workflow_task_poller_behavior = PollerBehavior::SimpleMaximum(2_usize);
+            cfg.nonsticky_to_sticky_poll_ratio = 0.2;
+            cfg.task_types = WorkerTaskTypes::workflow_only();
+            cfg
+        },
         Some("stickytq".to_string()),
         Arc::new(mock_client),
         None,

package/sdk-core/crates/sdk-core/src/ephemeral_server/mod.rs

@@ -24,30 +24,28 @@ use std::os::unix::fs::OpenOptionsExt;
 use std::process::Stdio;
 
 /// Configuration for Temporal CLI dev server.
-#[derive(Debug, Clone, derive_builder::Builder)]
+#[derive(Debug, Clone, bon::Builder)]
+#[builder(on(String, into))]
 pub struct TemporalDevServerConfig {
     /// Required path to executable or download info.
     pub exe: EphemeralExe,
     /// Namespace to use.
-    #[builder(default = "\"default\".to_owned()")]
+    #[builder(default = "default".to_owned())]
     pub namespace: String,
     /// IP to bind to.
-    #[builder(default = "\"127.0.0.1\".to_owned()")]
+    #[builder(default = "127.0.0.1".to_owned())]
     pub ip: String,
     /// Port to use or obtains a free one if none given.
-    #[builder(default)]
     pub port: Option<u16>,
     /// Port to use for the UI server or obtains a free one if none given.
-    #[builder(default)]
     pub ui_port: Option<u16>,
     /// Sqlite DB filename if persisting or non-persistent if none.
-    #[builder(default)]
     pub db_filename: Option<String>,
     /// Whether to enable the UI. If ui_port is set, assumes true.
     #[builder(default)]
     pub ui: bool,
     /// Log format and level
-    #[builder(default = "(\"pretty\".to_owned(), \"warn\".to_owned())")]
+    #[builder(default = ("pretty".to_owned(), "warn".to_owned()))]
     pub log: (String, String),
     /// Additional arguments to Temporal dev server.
     #[builder(default)]
@@ -131,12 +129,11 @@ impl TemporalDevServerConfig {
 }
 
 /// Configuration for the test server.
-#[derive(Debug, Clone, derive_builder::Builder)]
+#[derive(Debug, Clone, bon::Builder)]
 pub struct TestServerConfig {
     /// Required path to executable or download info.
     pub exe: EphemeralExe,
     /// Port to use or obtains a free one if none given.
-    #[builder(default)]
     pub port: Option<u16>,
     /// Additional arguments to the test server.
     #[builder(default)]

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

@@ -240,9 +240,9 @@ pub struct CoreRuntime {
     heartbeat_interval: Option<Duration>,
 }
 
-/// Holds telemetry options, as well as worker heartbeat_interval. Construct with [RuntimeOptionsBuilder]
-#[derive(Default, derive_builder::Builder)]
-#[builder(build_fn(validate = "Self::validate"))]
+/// Holds telemetry options, as well as worker heartbeat_interval. Construct with [RuntimeOptions::builder]
+#[derive(Default, bon::Builder)]
+#[builder(finish_fn(vis = "", name = build_internal))]
 #[non_exhaustive]
 pub struct RuntimeOptions {
     /// Telemetry configuration options.
@@ -252,21 +252,28 @@ pub struct RuntimeOptions {
     /// workers created using this runtime.
     ///
     /// Interval must be between 1s and 60s, inclusive.
-    #[builder(default = "Some(Duration::from_secs(60))")]
+    #[builder(required, default = Some(Duration::from_secs(60)))]
     heartbeat_interval: Option<Duration>,
 }
 
-impl RuntimeOptionsBuilder {
-    fn validate(&self) -> Result<(), String> {
-        if let Some(Some(interval)) = self.heartbeat_interval
-            && (interval < Duration::from_secs(1) || interval > Duration::from_secs(60))
+impl<S: runtime_options_builder::State> RuntimeOptionsBuilder<S> {
+    /// Builds the RuntimeOptions
+    ///
+    /// # Errors
+    /// Returns an error if heartbeat_interval is set but not between 1s and 60s inclusive.
+    pub fn build(self) -> Result<RuntimeOptions, String> {
+        let options = self.build_internal();
         {
-            return Err(format!(
-                "heartbeat_interval ({interval:?}) must be between 1s and 60s",
-            ));
+            if let Some(interval) = options.heartbeat_interval
+                && (interval < Duration::from_secs(1) || interval > Duration::from_secs(60))
+            {
+                return Err(format!(
+                    "heartbeat_interval ({interval:?}) must be between 1s and 60s",
+                ));
+            }
+
+            Ok(options)
         }
-
-        Ok(())
     }
 }