@temporalio/core-bridge 1.10.2 → 1.11.0

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

@@ -7,7 +7,7 @@ use std::{
 };
 use temporal_client::WorkflowOptions;
 use temporal_sdk::{
-    interceptors::WorkerInterceptor, ActContext, ActivityCancelledError, CancellableFuture,
+    interceptors::WorkerInterceptor, ActContext, ActivityError, CancellableFuture,
     LocalActivityOptions, WfContext, WorkflowResult,
 };
 use temporal_sdk_core::replay::HistoryForReplay;
@@ -172,7 +172,7 @@ async fn local_act_retry_timer_backoff() {
         Ok(().into())
     });
     worker.register_activity("echo", |_: ActContext, _: String| async {
-        Result::<(), _>::Err(anyhow!("Oh no I failed!"))
+        Result::<(), _>::Err(anyhow!("Oh no I failed!").into())
     });
 
     let run_id = worker
@@ -223,7 +223,7 @@ async fn cancel_immediate(#[case] cancel_type: ActivityCancellationType) {
             tokio::select! {
                 _ = tokio::time::sleep(Duration::from_secs(10)) => {},
                 _ = ctx.cancelled() => {
-                    return Err(anyhow!(ActivityCancelledError::default()))
+                    return Err(ActivityError::cancelled())
                 }
                 _ = manual_cancel_act.cancelled() => {}
             }
@@ -326,22 +326,22 @@ async fn cancel_after_act_starts(
         async move {
             if cancel_on_backoff.is_some() {
                 if ctx.is_cancelled() {
-                    return Err(anyhow!(ActivityCancelledError::default()));
+                    return Err(ActivityError::cancelled());
                 }
                 // Just fail constantly so we get stuck on the backoff timer
-                return Err(anyhow!("Oh no I failed!"));
+                return Err(anyhow!("Oh no I failed!").into());
             } else {
                 tokio::select! {
                     _ = tokio::time::sleep(Duration::from_secs(100)) => {},
                     _ = ctx.cancelled() => {
-                        return Err(anyhow!(ActivityCancelledError::default()))
+                        return Err(ActivityError::cancelled())
                     }
                     _ = manual_cancel_act.cancelled() => {
                         return Ok(())
                     }
                 }
             }
-            Err(anyhow!("Oh no I failed!"))
+            Err(anyhow!("Oh no I failed!").into())
         }
     });
 
@@ -405,7 +405,7 @@ async fn x_to_close_timeout(#[case] is_schedule: bool) {
         tokio::select! {
             _ = tokio::time::sleep(Duration::from_secs(100)) => {},
             _ = ctx.cancelled() => {
-                return Err(anyhow!(ActivityCancelledError::default()))
+                return Err(ActivityError::cancelled())
             }
         };
         Ok(())
@@ -452,7 +452,7 @@ async fn schedule_to_close_timeout_across_timer_backoff(#[case] cached: bool) {
     let num_attempts: &'static _ = Box::leak(Box::new(AtomicU8::new(0)));
     worker.register_activity("echo", move |_: ActContext, _: String| async {
         num_attempts.fetch_add(1, Ordering::Relaxed);
-        Result::<(), _>::Err(anyhow!("Oh no I failed!"))
+        Result::<(), _>::Err(anyhow!("Oh no I failed!").into())
     });
 
     starter.start_with_worker(wf_name, &mut worker).await;
@@ -528,7 +528,7 @@ async fn timer_backoff_concurrent_with_non_timer_backoff() {
         Ok(().into())
     });
     worker.register_activity("echo", |_: ActContext, _: String| async {
-        Result::<(), _>::Err(anyhow!("Oh no I failed!"))
+        Result::<(), _>::Err(anyhow!("Oh no I failed!").into())
     });
 
     starter.start_with_worker(wf_name, &mut worker).await;

package/sdk-core/tests/main.rs

@@ -16,6 +16,7 @@ mod integ_tests {
     mod queries_tests;
     mod update_tests;
     mod visibility_tests;
+    mod worker_tests;
     mod workflow_tests;
 
     use std::str::FromStr;

package/src/conversions.rs

@@ -20,7 +20,9 @@ use temporal_sdk_core::{
         TestServerConfigBuilder,
     },
     telemetry::{build_otlp_metric_exporter, start_prometheus_metric_exporter},
-    ClientOptions, ClientOptionsBuilder, ClientTlsConfig, RetryConfig, TlsConfig, Url,
+    ClientOptions, ClientOptionsBuilder, ClientTlsConfig, ResourceBasedSlotsOptions,
+    ResourceBasedSlotsOptionsBuilder, ResourceSlotOptions, RetryConfig, SlotSupplierOptions,
+    TlsConfig, TunerHolderOptionsBuilder, Url,
 };
 
 pub enum EphemeralServerConfig {
@@ -49,7 +51,7 @@ type BoxedMeterMaker = Box<dyn FnOnce() -> Result<Arc<dyn CoreMeter>, String> +
 
 pub(crate) type TelemOptsRes = (TelemetryOptions, Option<BoxedMeterMaker>);
 
-pub trait ObjectHandleConversionsExt {
+pub(crate) trait ObjectHandleConversionsExt {
     fn set_default(&self, cx: &mut FunctionContext, key: &str, value: &str) -> NeonResult<()>;
     fn as_client_options(&self, ctx: &mut FunctionContext) -> NeonResult<ClientOptions>;
     fn as_telemetry_options(&self, cx: &mut FunctionContext) -> NeonResult<TelemOptsRes>;
@@ -63,6 +65,11 @@ pub trait ObjectHandleConversionsExt {
         &self,
         cx: &mut FunctionContext,
     ) -> NeonResult<HashMap<String, String>>;
+    fn as_slot_supplier(
+        &self,
+        cx: &mut FunctionContext,
+        rbo: &mut Option<ResourceBasedSlotsOptions>,
+    ) -> NeonResult<SlotSupplierOptions>;
 }
 
 impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
@@ -354,12 +361,6 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
         let task_queue = js_value_getter!(cx, self, "taskQueue", JsString);
         let enable_remote_activities =
             js_value_getter!(cx, self, "enableNonLocalActivities", JsBoolean);
-        let max_outstanding_activities =
-            js_value_getter!(cx, self, "maxConcurrentActivityTaskExecutions", JsNumber) as usize;
-        let max_outstanding_local_activities =
-            js_value_getter!(cx, self, "maxConcurrentLocalActivityExecutions", JsNumber) as usize;
-        let max_outstanding_workflow_tasks =
-            js_value_getter!(cx, self, "maxConcurrentWorkflowTaskExecutions", JsNumber) as usize;
         let max_concurrent_wft_polls =
             js_value_getter!(cx, self, "maxConcurrentWorkflowTaskPolls", JsNumber) as usize;
         let max_concurrent_at_polls =
@@ -401,14 +402,46 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
         let nonsticky_to_sticky_poll_ratio =
             js_value_getter!(cx, self, "nonStickyToStickyPollRatio", JsNumber) as f32;
 
+        let tuner = if let Some(tuner) = js_optional_getter!(cx, self, "tuner", JsObject) {
+            let mut tuner_holder = TunerHolderOptionsBuilder::default();
+            let mut rbo = None;
+
+            if let Some(wf_slot_supp) =
+                js_optional_getter!(cx, &tuner, "workflowTaskSlotSupplier", JsObject)
+            {
+                tuner_holder.workflow_slot_options(wf_slot_supp.as_slot_supplier(cx, &mut rbo)?);
+            }
+            if let Some(act_slot_supp) =
+                js_optional_getter!(cx, &tuner, "activityTaskSlotSupplier", JsObject)
+            {
+                tuner_holder.activity_slot_options(act_slot_supp.as_slot_supplier(cx, &mut rbo)?);
+            }
+            if let Some(local_act_slot_supp) =
+                js_optional_getter!(cx, &tuner, "localActivityTaskSlotSupplier", JsObject)
+            {
+                tuner_holder.local_activity_slot_options(
+                    local_act_slot_supp.as_slot_supplier(cx, &mut rbo)?,
+                );
+            }
+            if let Some(rbo) = rbo {
+                tuner_holder.resource_based_options(rbo);
+            }
+            match tuner_holder.build_tuner_holder() {
+                Err(e) => {
+                    return cx.throw_error(format!("Invalid tuner options: {:?}", e));
+                }
+                Ok(th) => Arc::new(th),
+            }
+        } else {
+            return cx.throw_error("Missing tuner");
+        };
+
         match WorkerConfigBuilder::default()
             .worker_build_id(js_value_getter!(cx, self, "buildId", JsString))
             .client_identity_override(Some(js_value_getter!(cx, self, "identity", JsString)))
             .use_worker_versioning(js_value_getter!(cx, self, "useVersioning", JsBoolean))
             .no_remote_activities(!enable_remote_activities)
-            .max_outstanding_workflow_tasks(max_outstanding_workflow_tasks)
-            .max_outstanding_activities(max_outstanding_activities)
-            .max_outstanding_local_activities(max_outstanding_local_activities)
+            .tuner(tuner)
             .max_concurrent_wft_polls(max_concurrent_wft_polls)
             .max_concurrent_at_polls(max_concurrent_at_polls)
             .nonsticky_to_sticky_poll_ratio(nonsticky_to_sticky_poll_ratio)
@@ -533,4 +566,44 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             )),
         }
     }
+
+    fn as_slot_supplier(
+        &self,
+        cx: &mut FunctionContext,
+        rbo: &mut Option<ResourceBasedSlotsOptions>,
+    ) -> NeonResult<SlotSupplierOptions> {
+        match js_value_getter!(cx, self, "type", JsString).as_str() {
+            "fixed-size" => Ok(SlotSupplierOptions::FixedSize {
+                slots: js_value_getter!(cx, self, "numSlots", JsNumber) as usize,
+            }),
+            "resource-based" => {
+                let min_slots = js_value_getter!(cx, self, "minimumSlots", JsNumber);
+                let max_slots = js_value_getter!(cx, self, "maximumSlots", JsNumber);
+                let ramp_throttle = js_value_getter!(cx, self, "rampThrottleMs", JsNumber) as u64;
+                if let Some(tuner_opts) = js_optional_getter!(cx, self, "tunerOptions", JsObject) {
+                    let target_mem =
+                        js_value_getter!(cx, &tuner_opts, "targetMemoryUsage", JsNumber);
+                    let target_cpu = js_value_getter!(cx, &tuner_opts, "targetCpuUsage", JsNumber);
+                    *rbo = Some(
+                        ResourceBasedSlotsOptionsBuilder::default()
+                            .target_cpu_usage(target_cpu)
+                            .target_mem_usage(target_mem)
+                            .build()
+                            .expect("Building ResourceBasedSlotsOptions can't fail"),
+                    )
+                } else {
+                    return cx
+                        .throw_type_error("Resource based slot supplier requires tunerOptions");
+                };
+                Ok(SlotSupplierOptions::ResourceBased(
+                    ResourceSlotOptions::new(
+                        min_slots as usize,
+                        max_slots as usize,
+                        Duration::from_millis(ramp_throttle),
+                    ),
+                ))
+            }
+            _ => cx.throw_type_error("Invalid slot supplier type"),
+        }
+    }
 }

package/src/runtime.rs

@@ -250,15 +250,12 @@ pub fn start_bridge_loop(
                     let client = (*client).clone();
                     match init_worker(&core_runtime, config, client) {
                         Ok(worker) => {
-                            let (tx, rx) = unbounded_channel();
                             core_runtime.tokio_handle().spawn(start_worker_loop(
                                 worker,
-                                rx,
-                                channel.clone(),
+                                channel,
+                                callback,
+                                None
                             ));
-                            send_result(channel.clone(), callback, |cx| {
-                                Ok(cx.boxed(RefCell::new(Some(WorkerHandle { sender: tx }))))
-                            });
                         }
                         Err(err) => send_error(channel.clone(), callback, move |cx| {
                             make_named_error_from_error(cx, UNEXPECTED_ERROR, err.deref())
@@ -273,21 +270,12 @@ pub fn start_bridge_loop(
                     let (tunnel, stream) = HistoryForReplayTunnel::new(runtime);
                     match init_replay_worker(ReplayWorkerInput::new(config, Box::pin(stream))) {
                         Ok(worker) => {
-                            let (tx, rx) = unbounded_channel();
                             core_runtime.tokio_handle().spawn(start_worker_loop(
                                 worker,
-                                rx,
                                 channel.clone(),
+                                callback,
+                                Some(tunnel)
                             ));
-                            send_result(channel.clone(), callback, |cx| {
-                                let worker =
-                                    cx.boxed(RefCell::new(Some(WorkerHandle { sender: tx })));
-                                let tunnel = cx.boxed(tunnel);
-                                let retme = cx.empty_object();
-                                retme.set(cx, "worker", worker)?;
-                                retme.set(cx, "pusher", tunnel)?;
-                                Ok(retme)
-                            })
                         }
                         Err(err) => send_error(channel.clone(), callback, move |cx| {
                             make_named_error_from_error(cx, UNEXPECTED_ERROR, err.deref())

package/src/worker.rs

@@ -18,7 +18,7 @@ use temporal_sdk_core::{
     },
     Worker as CoreWorker,
 };
-use tokio::sync::mpsc::{UnboundedReceiver, UnboundedSender};
+use tokio::sync::mpsc::{unbounded_channel, UnboundedSender};
 use tokio_stream::wrappers::UnboundedReceiverStream;
 
 /// Worker struct, hold a reference for the channel sender responsible for sending requests from
@@ -70,9 +70,34 @@ pub enum WorkerRequest {
 /// Returns when the given channel is dropped.
 pub async fn start_worker_loop(
     worker: CoreWorker,
-    rx: UnboundedReceiver<WorkerRequest>,
     channel: Arc<Channel>,
+    callback: Root<JsFunction>,
+    is_replay: Option<HistoryForReplayTunnel>,
 ) {
+    if is_replay.is_none() {
+        if let Err(e) = worker.validate().await {
+            send_error(channel, callback, move |cx| {
+                make_named_error_from_error(cx, TRANSPORT_ERROR, e)
+            });
+            return;
+        }
+    }
+    let (tx, rx) = unbounded_channel();
+    // Return the worker after validation has happened
+    if let Some(tunnel) = is_replay {
+        send_result(channel.clone(), callback, |cx| {
+            let worker = cx.boxed(RefCell::new(Some(WorkerHandle { sender: tx })));
+            let tunnel = cx.boxed(tunnel);
+            let retme = cx.empty_object();
+            retme.set(cx, "worker", worker)?;
+            retme.set(cx, "pusher", tunnel)?;
+            Ok(retme)
+        })
+    } else {
+        send_result(channel.clone(), callback, |cx| {
+            Ok(cx.boxed(RefCell::new(Some(WorkerHandle { sender: tx }))))
+        });
+    }
     UnboundedReceiverStream::new(rx)
         .for_each_concurrent(None, |request| {
             let worker = &worker;
@@ -158,10 +183,6 @@ async fn handle_poll_workflow_activation_request(
             send_error(channel, callback, move |cx| match err {
                 PollWfError::ShutDown => make_named_error_from_error(cx, SHUTDOWN_ERROR, err),
                 PollWfError::TonicError(_) => make_named_error_from_error(cx, TRANSPORT_ERROR, err),
-                PollWfError::AutocompleteError(CompleteWfError::MalformedWorkflowCompletion {
-                    reason,
-                    ..
-                }) => Ok(JsError::type_error(cx, reason)?),
             });
         }
     }

package/ts/index.ts

@@ -1,5 +1,14 @@
 import { LogLevel, Duration } from '@temporalio/common';
 import type { TLSConfig, ProxyConfig, HttpConnectProxyConfig } from '@temporalio/common/lib/internal-non-workflow';
+import { WorkerTuner } from './worker-tuner';
+
+export {
+  WorkerTuner,
+  SlotSupplier,
+  ResourceBasedSlotOptions,
+  ResourceBasedTunerOptions,
+  FixedSizeSlotSupplier,
+} from './worker-tuner';
 
 export type { TLSConfig, ProxyConfig, HttpConnectProxyConfig };
 
@@ -287,9 +296,11 @@ export interface WorkerOptions {
    */
   taskQueue: string;
 
-  maxConcurrentActivityTaskExecutions: number;
-  maxConcurrentWorkflowTaskExecutions: number;
-  maxConcurrentLocalActivityExecutions: number;
+  /**
+   * The tuner the worker will use
+   */
+  tuner: WorkerTuner;
+
   nonStickyToStickyPollRatio: number;
 
   /**
@@ -410,12 +421,16 @@ export interface TimeSkippingServerConfig {
   port?: number;
   /**
    * Extra args to pass to the executable command.
+   *
+   * Note that the Test Server implementation may be changed to another one in the future. Therefore, there is
+   * no guarantee that server options, and particularly those provided through the `extraArgs` array, will continue to
+   * be supported in the future.
    */
   extraArgs?: string[];
 }
 
 /**
- * Configuration for the Temporal CLI dev server.
+ * Configuration for the Temporal CLI Dev Server.
  */
 export interface DevServerConfig {
   type: 'dev-server';
@@ -453,6 +468,10 @@ export interface DevServerConfig {
   port?: number;
   /**
    * Extra args to pass to the executable command.
+   *
+   * Note that the Dev Server implementation may be changed to another one in the future. Therefore, there is no
+   * guarantee that Dev Server options, and particularly those provided through the `extraArgs` array, will continue to
+   * be supported in the future.
    */
   extraArgs?: string[];
 }
@@ -460,7 +479,7 @@ export interface DevServerConfig {
 /**
  * Configuration for spawning an ephemeral Temporal server.
  *
- * Both the time-skipping test server and Temporal CLI dev server are supported.
+ * Both the time-skipping Test Server and Temporal CLI dev server are supported.
  */
 export type EphemeralServerConfig = TimeSkippingServerConfig | DevServerConfig;
 

package/ts/worker-tuner.ts

@@ -0,0 +1,71 @@
+/**
+ * A worker tuner allows the customization of the performance characteristics of workers by
+ * controlling how "slots" are handed out for different task types. In order to poll for and then
+ * run tasks, a slot must first be reserved by the {@link SlotSupplier} returned by the tuner.
+ *
+ * @experimental
+ */
+export interface WorkerTuner {
+  workflowTaskSlotSupplier: SlotSupplier;
+  activityTaskSlotSupplier: SlotSupplier;
+  localActivityTaskSlotSupplier: SlotSupplier;
+}
+
+/**
+ * Controls how slots are handed out for a specific task type.
+ *
+ * For now, only {@link ResourceBasedSlotOptions} and {@link FixedSizeSlotSupplier} are supported,
+ * but we may add support for custom tuners in the future.
+ *
+ * @experimental
+ */
+export type SlotSupplier = ResourceBasedSlotsForType | FixedSizeSlotSupplier;
+
+/**
+ * Options for a specific slot type within a {@link ResourceBasedSlotsForType}
+ *
+ * @experimental
+ */
+export interface ResourceBasedSlotOptions {
+  // Amount of slots that will be issued regardless of any other checks
+  minimumSlots: number;
+  // Maximum amount of slots permitted
+  maximumSlots: number;
+  // Minimum time we will wait (after passing the minimum slots number) between handing out new
+  // slots in milliseconds.
+  rampThrottleMs: number;
+}
+
+/**
+ * @experimental
+ */
+type ResourceBasedSlotsForType = ResourceBasedSlotOptions & {
+  type: 'resource-based';
+  tunerOptions: ResourceBasedTunerOptions;
+};
+
+/**
+ * Options for a {@link ResourceBasedTuner} to control target resource usage
+ *
+ * @experimental
+ */
+export interface ResourceBasedTunerOptions {
+  // A value between 0 and 1 that represents the target (system) memory usage. It's not recommended
+  // to set this higher than 0.8, since how much memory a workflow may use is not predictable, and
+  // you don't want to encounter OOM errors.
+  targetMemoryUsage: number;
+  // A value between 0 and 1 that represents the target (system) CPU usage. This can be set to 1.0
+  // if desired, but it's recommended to leave some headroom for other processes.
+  targetCpuUsage: number;
+}
+
+/**
+ * A fixed-size slot supplier that will never issue more than a fixed number of slots.
+ *
+ * @experimental
+ */
+export interface FixedSizeSlotSupplier {
+  type: 'fixed-size';
+  // The maximum number of slots that can be issued
+  numSlots: number;
+}