remove no_remote_activities

Author: yuandrew

crates/common/src/lib.rs

@@ -129,8 +129,8 @@ pub trait Worker: Send + Sync {
     /// [Worker::complete_workflow_activation] and [Worker::complete_activity_task] for those
     /// workflows & activities until they are done. At that point, the lang SDK can end the process,
     /// or drop the [Worker] instance via [Worker::finalize_shutdown], which will close the
-    /// connection and free resources. If you have set [WorkerConfig::no_remote_activities], you may
-    /// skip calling [Worker::poll_activity_task].
+    /// connection and free resources. If you have set [WorkerConfig::task_types] to exclude
+    /// [WorkerTaskTypes::ACTIVITIES], you may skip calling [Worker::poll_activity_task].
     ///
     /// Lang implementations should use [Worker::initiate_shutdown] followed by
     /// [Worker::finalize_shutdown].

crates/common/src/worker.rs

@@ -103,21 +103,11 @@ pub struct WorkerConfig {
     /// By default, workers poll for all task types (workflows, activities, and nexus).
     /// You can restrict this to any combination. For example, a workflow-only worker would use
     /// `WorkerTaskTypes::WORKFLOWS`, while a worker handling activities and nexus but not workflows
-    /// would use `WorkerTaskTypes::ACTIVITIES | WorkerTaskTypes::NEXUS`. If using in combination
-    /// with `no_remote_activites`, it must be ensured that `ACTIVITIES` is not selected, as
-    /// validation will fail.
+    /// would use `WorkerTaskTypes::ACTIVITIES | WorkerTaskTypes::NEXUS`.
     ///
     /// Note: At least one task type must be specified or the worker will fail validation.
     #[builder(default = "WorkerTaskTypes::all()")]
     pub task_types: WorkerTaskTypes,
-    /// If set to true this worker will only handle workflow tasks and local activities, it will not
-    /// poll for activity tasks. If this is used with `task_types`, users must ensure
-    /// `WorkerTaskTypes::ACTIVITIES` is not set.
-    ///
-    /// This is equivalent to setting
-    /// `task_types = WorkerTaskTypes::WORKFLOWS | WorkerTaskTypes::NEXUS`.
-    #[builder(default = "false")]
-    pub no_remote_activities: bool,
     /// How long a workflow task is allowed to sit on the sticky queue before it is timed out
     /// and moved to the non-sticky queue where it may be picked up by any worker.
     #[builder(default = "Duration::from_secs(10)")]
@@ -225,18 +215,6 @@ pub struct WorkerConfig {
 }
 
 impl WorkerConfig {
-    /// Returns the effective task types this worker should poll for, taking into account
-    /// `no_remote_activities` field.
-    ///
-    /// If `no_remote_activities` is true, activities are excluded from the task types.
-    pub fn effective_task_types(&self) -> WorkerTaskTypes {
-        if self.no_remote_activities {
-            self.task_types - WorkerTaskTypes::ACTIVITIES
-        } else {
-            self.task_types
-        }
-    }
-
     /// Returns true if the configuration specifies we should fail a workflow on a certain error
     /// type rather than failing the workflow task.
     pub fn should_fail_workflow(
@@ -285,19 +263,6 @@ impl WorkerConfigBuilder {
             return Err("At least one task type must be enabled in `task_types`".to_owned());
         }
 
-        // Handle backward compatibility with no_remote_activities
-        if let Some(true) = self.no_remote_activities {
-            // If no_remote_activities is set to true, warn if task_types was also explicitly set
-            // and includes activities
-            if self.task_types.is_some() && task_types.contains(WorkerTaskTypes::ACTIVITIES) {
-                return Err(
-                    "Conflicting configuration: `no_remote_activities` is true but `task_types` includes ACTIVITIES. \
-                     Please update `task_types` to not allow for ACTIVITIES."
-                        .to_owned(),
-                );
-            }
-        }
-
         if let Some(b) = self.workflow_task_poller_behavior.as_ref() {
             b.validate()?
         }

crates/common/tests/worker_task_types_test.rs

@@ -15,7 +15,7 @@ fn test_default_configuration_polls_all_types() {
         .build()
         .expect("Failed to build default config");
 
-    let effective = config.effective_task_types();
+    let effective = config.task_types;
     assert!(
         effective.polls_workflows(),
         "Should poll workflows by default"
@@ -38,7 +38,7 @@ fn test_workflow_only_worker() {
         .build()
         .expect("Failed to build workflow-only config");
 
-    let effective = config.effective_task_types();
+    let effective = config.task_types;
     assert!(effective.polls_workflows(), "Should poll workflows");
     assert!(!effective.polls_activities(), "Should NOT poll activities");
     assert!(!effective.polls_nexus(), "Should NOT poll nexus");
@@ -55,28 +55,12 @@ fn test_activity_and_nexus_worker() {
         .build()
         .expect("Failed to build activity+nexus config");
 
-    let effective = config.effective_task_types();
+    let effective = config.task_types;
     assert!(!effective.polls_workflows(), "Should NOT poll workflows");
     assert!(effective.polls_activities(), "Should poll activities");
     assert!(effective.polls_nexus(), "Should poll nexus");
 }
 
-#[test]
-fn test_backward_compatibility_with_no_remote_activities() {
-    let config = WorkerConfigBuilder::default()
-        .namespace("default")
-        .task_queue("test-queue")
-        .versioning_strategy(default_versioning_strategy())
-        .no_remote_activities(true)
-        .build()
-        .expect("Failed to build config with no_remote_activities");
-
-    let effective = config.effective_task_types();
-    assert!(effective.polls_workflows(), "Should poll workflows");
-    assert!(!effective.polls_activities(), "Should NOT poll activities");
-    assert!(effective.polls_nexus(), "Should poll nexus");
-}
-
 #[test]
 fn test_empty_task_types_fails_validation() {
     let result = WorkerConfigBuilder::default()
@@ -115,26 +99,6 @@ fn test_workflow_cache_without_workflows_fails() {
     );
 }
 
-#[test]
-fn test_conflicting_no_remote_activities_and_task_types_fails() {
-    #[allow(deprecated)]
-    let result = WorkerConfigBuilder::default()
-        .namespace("default")
-        .task_queue("test-queue")
-        .versioning_strategy(default_versioning_strategy())
-        .task_types(WorkerTaskTypes::ACTIVITIES)
-        .no_remote_activities(true)
-        .build();
-
-    assert!(result.is_err(), "Conflicting settings should fail");
-
-    let err = result.err().unwrap().to_string();
-    assert!(
-        err.contains("Conflicting configuration"),
-        "Error should mention conflict: {err}",
-    );
-}
-
 #[test]
 fn test_all_combinations() {
     let combinations = [
@@ -165,7 +129,7 @@ fn test_all_combinations() {
             .build()
             .unwrap_or_else(|e| panic!("Failed to build config for {description}: {e:?}"));
 
-        let effective = config.effective_task_types();
+        let effective = config.task_types;
         assert_eq!(
             effective, task_types,
             "Effective types should match for {description}",

crates/sdk-core-c-bridge/src/worker.rs

@@ -44,7 +44,6 @@ pub struct WorkerOptions {
     pub max_cached_workflows: u32,
     pub tuner: TunerHolder,
     pub task_types: u8,
-    pub no_remote_activities: bool,
     pub sticky_queue_schedule_to_start_timeout_millis: u64,
     pub max_heartbeat_throttle_interval_millis: u64,
     pub default_heartbeat_throttle_interval_millis: u64,
@@ -1191,7 +1190,6 @@ impl TryFrom<&WorkerOptions> for temporalio_sdk_core::WorkerConfig {
                     temporalio_common::worker::WorkerTaskTypes::from_bits_truncate(opt.task_types)
                 }
             })
-            .no_remote_activities(opt.no_remote_activities)
             .sticky_queue_schedule_to_start_timeout(Duration::from_millis(
                 opt.sticky_queue_schedule_to_start_timeout_millis,
             ))

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

@@ -53,7 +53,7 @@ use temporalio_common::{
         },
         test_utils::start_timer_cmd,
     },
-    worker::PollerBehavior,
+    worker::{PollerBehavior, WorkerTaskTypes},
 };
 use tokio::{join, time::sleep};
 use tokio_util::sync::CancellationToken;
@@ -725,7 +725,7 @@ async fn no_eager_activities_requested_when_worker_options_disable_it(
     mock.worker_cfg(|wc| {
         wc.max_cached_workflows = 2;
         if reason == "no_remote" {
-            wc.no_remote_activities = true;
+            wc.task_types = WorkerTaskTypes::WORKFLOWS;
         } else {
             wc.max_task_queue_activities_per_second = Some(1.0);
         }

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

@@ -29,7 +29,7 @@ use temporalio_common::{
         },
         test_utils::start_timer_cmd,
     },
-    worker::PollerBehavior,
+    worker::{PollerBehavior, WorkerTaskTypes},
 };
 use tokio::sync::{Barrier, watch};
 
@@ -135,7 +135,7 @@ async fn can_shutdown_local_act_only_worker_when_act_polling() {
     let mh = MockPollCfg::from_resp_batches("fakeid", t, [1], mock);
     let mut mock = build_mock_pollers(mh);
     mock.worker_cfg(|w| {
-        w.no_remote_activities = true;
+        w.task_types = WorkerTaskTypes::WORKFLOWS;
         w.max_cached_workflows = 1;
     });
     let worker = mock_worker(mock);

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

@@ -28,6 +28,7 @@ use std::{
     time::Duration,
 };
 use temporalio_client::MESSAGE_TOO_LARGE_KEY;
+use temporalio_common::worker::WorkerTaskTypes;
 use temporalio_common::{
     Worker as WorkerTrait,
     errors::PollError,
@@ -2671,7 +2672,7 @@ async fn poller_wont_run_ahead_of_task_slots() {
             .max_cached_workflows(10_usize)
             .max_outstanding_workflow_tasks(10_usize)
             .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(10_usize))
-            .no_remote_activities(true)
+            .task_types(WorkerTaskTypes::WORKFLOWS)
             .build()
             .unwrap(),
         mock_client,
@@ -2731,7 +2732,7 @@ async fn poller_wont_poll_until_lang_polls() {
 
     let worker = Worker::new_test(
         test_worker_cfg()
-            .no_remote_activities(true)
+            .task_types(WorkerTaskTypes::WORKFLOWS)
             .build()
             .unwrap(),
         mock_client,
@@ -2876,7 +2877,7 @@ async fn slot_provider_cant_hand_out_more_permits_than_cache_size() {
                     .build(),
             ))
             .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(10_usize))
-            .no_remote_activities(true)
+            .task_types(WorkerTaskTypes::WORKFLOWS)
             .build()
             .unwrap(),
         mock_client,
@@ -3024,7 +3025,7 @@ async fn both_normal_and_sticky_pollers_poll_concurrently() {
             .max_outstanding_workflow_tasks(2_usize)
             .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(2_usize))
             .nonsticky_to_sticky_poll_ratio(0.2)
-            .no_remote_activities(true)
+            .task_types(WorkerTaskTypes::WORKFLOWS)
             .build()
             .unwrap(),
         Some("stickytq".to_string()),

crates/sdk-core/src/replay/mod.rs

@@ -19,6 +19,7 @@ use std::{
 pub use temporalio_common::protos::{
     DEFAULT_WORKFLOW_TYPE, HistoryInfo, TestHistoryBuilder, default_wes_attribs,
 };
+use temporalio_common::worker::WorkerTaskTypes;
 use temporalio_common::{
     protos::{
         coresdk::workflow_activation::remove_from_cache::EvictionReason,
@@ -62,7 +63,7 @@ where
     pub(crate) fn into_core_worker(mut self) -> Result<Worker, anyhow::Error> {
         self.config.max_cached_workflows = 1;
         self.config.workflow_task_poller_behavior = PollerBehavior::SimpleMaximum(1);
-        self.config.no_remote_activities = true;
+        self.config.task_types = WorkerTaskTypes::WORKFLOWS;
         self.config.skip_client_worker_set_check = true;
         let historator = Historator::new(self.history_stream);
         let post_activate = historator.get_post_activate_hook();

crates/sdk-core/src/test_help/integ_helpers.rs

@@ -36,6 +36,7 @@ use std::{
     task::{Context, Poll},
     time::Duration,
 };
+use temporalio_common::worker::WorkerTaskTypes;
 use temporalio_common::{
     Worker as WorkerTrait,
     errors::PollError,
@@ -184,10 +185,15 @@ pub fn build_fake_worker(
 
 pub fn mock_worker(mocks: MocksHolder) -> Worker {
     let sticky_q = sticky_q_name_for_worker("unit-test", mocks.inputs.config.max_cached_workflows);
-    let act_poller = if mocks.inputs.config.no_remote_activities {
-        None
-    } else {
+    let act_poller = if mocks
+        .inputs
+        .config
+        .task_types
+        .contains(WorkerTaskTypes::ACTIVITIES)
+    {
         mocks.inputs.act_poller
+    } else {
+        None
     };
     Worker::new_with_pollers(
         mocks.inputs.config,

crates/sdk-core/src/worker/heartbeat.rs

@@ -5,6 +5,7 @@ use crate::{
 use parking_lot::RwLock;
 use std::{collections::HashMap, sync::Arc, time::Duration};
 use temporalio_client::SharedNamespaceWorkerTrait;
+use temporalio_common::worker::WorkerTaskTypes;
 use temporalio_common::{
     protos::temporal::api::worker::v1::WorkerHeartbeat,
     worker::{PollerBehavior, WorkerConfigBuilder, WorkerVersioningStrategy},
@@ -38,7 +39,7 @@ impl SharedNamespaceWorker {
                 "temporal-sys/worker-commands/{namespace}/{}",
                 client.worker_grouping_key(),
             ))
-            .no_remote_activities(true)
+            .task_types(WorkerTaskTypes::NEXUS)
             .max_outstanding_nexus_tasks(5_usize)
             .versioning_strategy(WorkerVersioningStrategy::None {
                 build_id: "1.0".to_owned(),