@temporalio/core-bridge 0.23.0 → 1.0.0

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

@@ -112,6 +112,25 @@ async fn replay_using_wf_function() {
     worker.run().await.unwrap();
 }
 
+#[tokio::test]
+async fn replay_ok_ending_with_terminated_or_timed_out() {
+    let mut t1 = canned_histories::single_timer("1");
+    t1.add_workflow_execution_terminated();
+    let mut t2 = canned_histories::single_timer("1");
+    t2.add_workflow_execution_timed_out();
+    telemetry_init(&get_integ_telem_options()).unwrap();
+    for t in [t1, t2] {
+        let func = timers_wf(1);
+        let (worker, _) = init_core_replay_preloaded(
+            "replay_ok_terminate",
+            &t.get_full_history_info().unwrap().into(),
+        );
+        let mut worker = Worker::new_from_core(worker, "replay_ok_terminate".to_string());
+        worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
+        worker.run().await.unwrap();
+    }
+}
+
 fn timers_wf(num_timers: u32) -> WorkflowFunction {
     WorkflowFunction::new(move |ctx: WfContext| async move {
         for _ in 1..=num_timers {

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

@@ -15,7 +15,7 @@ async fn reset_workflow() {
     let wf_name = "reset_me_wf";
     let mut starter = CoreWfStarter::new(wf_name);
     let mut worker = starter.worker().await;
-    worker.auto_shutdown = false;
+    worker.fetch_results = false;
     let notify = Arc::new(Notify::new());
 
     let wf_notify = notify.clone();

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

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 use temporal_client::{WorkflowClientTrait, WorkflowOptions};
 use temporal_sdk::{WfContext, WorkflowResult};
-use temporal_sdk_core_protos::coresdk::AsJsonPayloadExt;
+use temporal_sdk_core_protos::coresdk::{AsJsonPayloadExt, FromJsonPayloadExt};
 use temporal_sdk_core_test_utils::CoreWfStarter;
 use uuid::Uuid;
 
@@ -61,6 +61,9 @@ async fn sends_upsert() {
             payload.metadata.get("encoding").unwrap()
         );
     }
-    assert_eq!("\"goodbye\"", txt_attr_payload.to_string());
-    assert_eq!("98", int_attr_payload.to_string());
+    assert_eq!(
+        "goodbye",
+        String::from_json_payload(txt_attr_payload).unwrap()
+    );
+    assert_eq!(98, usize::from_json_payload(int_attr_payload).unwrap());
 }

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

@@ -1,4 +1,5 @@
 mod activities;
+mod appdata_propagation;
 mod cancel_external;
 mod cancel_wf;
 mod child_workflows;
@@ -420,7 +421,8 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
     let mut wf_starter = CoreWfStarter::new("wft_timeout_doesnt_create_unsolvable_autocomplete");
     wf_starter
         // Test needs eviction on and a short timeout
-        .max_cached_workflows(0usize)
+        .max_cached_workflows(0)
+        .max_wft(1)
         .wft_timeout(Duration::from_secs(1));
     let core = wf_starter.get_worker().await;
     let client = wf_starter.get_client().await;
@@ -445,26 +447,6 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
         .unwrap();
         wf_task
     };
-    let poll_sched_act_poll = || async {
-        poll_sched_act().await;
-        let wf_task = core.poll_workflow_activation().await.unwrap();
-        assert_matches!(
-            wf_task.jobs.as_slice(),
-            [
-                WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::SignalWorkflow(_)),
-                },
-                WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::ResolveActivity(_)),
-                },
-                WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::SignalWorkflow(_)),
-                }
-            ]
-        );
-        wf_task
-    };
-
     wf_starter.start_wf().await;
 
     // Poll and schedule the activity
@@ -503,7 +485,8 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
         .await
         .unwrap();
     // Start from the beginning
-    let wf_task = poll_sched_act_poll().await;
+    poll_sched_act().await;
+    let wf_task = core.poll_workflow_activation().await.unwrap();
     // Time out this time
     sleep(Duration::from_secs(2)).await;
     // Poll again, which should not have any work to do and spin, until the complete goes through.
@@ -526,7 +509,11 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
         .await
         .unwrap();
     // Do it all over again, without timing out this time
-    let wf_task = poll_sched_act_poll().await;
+    poll_sched_act().await;
+    let wf_task = core.poll_workflow_activation().await.unwrap();
+    // Server can sometimes arbitrarily re-order the activity complete to be after the second signal
+    // Seeing 3 jobs is enough info.
+    assert_eq!(wf_task.jobs.len(), 3);
     core.complete_execution(&wf_task.run_id).await;
 }
 

package/sdk-core/tests/load_tests.rs

@@ -113,6 +113,7 @@ async fn activity_load() {
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
 async fn workflow_load() {
     const SIGNAME: &str = "signame";
+    let num_workflows = 200;
     let wf_name = "workflow_load";
     let mut starter = CoreWfStarter::new("workflow_load");
     starter
@@ -151,7 +152,7 @@ async fn workflow_load() {
     let client = starter.get_client().await;
 
     let mut workflow_handles = vec![];
-    for i in 0..200 {
+    for i in 0..num_workflows {
         let wfid = format!("{}_{}", wf_name, i);
         let rid = worker
             .submit_wf(
@@ -167,7 +168,7 @@ async fn workflow_load() {
 
     let sig_sender = async {
         loop {
-            let sends: FuturesUnordered<_> = (0..200)
+            let sends: FuturesUnordered<_> = (0..num_workflows)
                 .map(|i| {
                     client.signal_workflow_execution(
                         format!("{}_{}", wf_name, i),
@@ -177,7 +178,11 @@ async fn workflow_load() {
                     )
                 })
                 .collect();
-            sends.map(|_| Ok(())).forward(sink::drain()).await.unwrap();
+            sends
+                .map(|_| Ok(()))
+                .forward(sink::drain())
+                .await
+                .expect("Sending signals works");
             tokio::time::sleep(Duration::from_secs(2)).await;
         }
     };

package/sdk-core/tests/main.rs

@@ -73,7 +73,8 @@ mod integ_tests {
         .unwrap();
         let sgo = ClientOptionsBuilder::default()
             .target_url(Url::from_str("https://localhost:7233").unwrap())
-            .worker_binary_id("binident".to_string())
+            .client_name("tls_tester")
+            .client_version("clientver")
             .tls_cfg(TlsConfig {
                 server_root_ca_cert: Some(root),
                 domain: Some("tls-sample".to_string()),

package/src/conversions.rs

@@ -1,9 +1,10 @@
 use log::LevelFilter;
+use neon::types::buffer::TypedArray;
 use neon::{
     context::Context,
     handle::Handle,
     prelude::*,
-    types::{JsNumber, JsString},
+    types::{JsBoolean, JsNumber, JsString},
 };
 use opentelemetry::trace::{SpanContext, SpanId, TraceFlags, TraceId, TraceState};
 use std::{collections::HashMap, fmt::Display, net::SocketAddr, str::FromStr, time::Duration};
@@ -14,30 +15,27 @@ use temporal_sdk_core::{
     TraceExporter, Url,
 };
 
-macro_rules! js_value_getter {
-    ($js_cx:expr, $js_obj:ident, $prop_name:expr, $js_type:ty) => {
-        $js_obj
-            .get($js_cx, $prop_name)?
-            .downcast::<$js_type, _>($js_cx)
-            .map_err(|_| {
-                $js_cx
-                    .throw_type_error::<_, Option<Vec<u8>>>(format!("Invalid {}", $prop_name))
-                    .unwrap_err()
-            })?
-            .value($js_cx)
-    };
-}
-
 #[macro_export]
 macro_rules! js_optional_getter {
     ($js_cx:expr, $js_obj:expr, $prop_name:expr, $js_type:ty) => {
         match get_optional($js_cx, $js_obj, $prop_name) {
-            Some(val) => Some(val.downcast::<$js_type, _>($js_cx).map_err(|_| {
-                $js_cx
-                    .throw_type_error::<_, Option<Vec<u8>>>(format!("Invalid {}", $prop_name))
-                    .unwrap_err()
-            })?),
             None => None,
+            Some(val) => {
+                if val.is_a::<$js_type, _>($js_cx) {
+                    Some(val.downcast_or_throw::<$js_type, _>($js_cx)?)
+                } else {
+                    Some($js_cx.throw_type_error(format!("Invalid {}", $prop_name))?)
+                }
+            }
+        }
+    };
+}
+
+macro_rules! js_value_getter {
+    ($js_cx:expr, $js_obj:expr, $prop_name:expr, $js_type:ty) => {
+        match js_optional_getter!($js_cx, $js_obj, $prop_name, $js_type) {
+            Some(val) => val.value($js_cx),
+            None => $js_cx.throw_type_error(format!("{} must be defined", $prop_name))?,
         }
     };
 }
@@ -53,7 +51,7 @@ where
     K: neon::object::PropertyKey,
     C: Context<'a>,
 {
-    match obj.get(cx, attr) {
+    match obj.get_value(cx, attr) {
         Err(_) => None,
         Ok(val) => match val.is_a::<JsUndefined, _>(cx) {
             true => None,
@@ -77,7 +75,7 @@ where
             cx.throw_type_error::<_, Option<Vec<u8>>>(format!("Invalid {}", attr))
                 .unwrap_err()
         })?;
-        Ok(Some(cx.borrow(&buf, |data| data.as_slice::<u8>().to_vec())))
+        Ok(Some(buf.as_slice(cx).to_vec()))
     } else {
         Ok(None)
     }
@@ -99,7 +97,7 @@ where
             cx.throw_type_error::<_, Option<Vec<u8>>>(format!("Invalid {}", attr))
                 .unwrap_err()
         })?;
-        Ok(cx.borrow(&buf, |data| data.as_slice::<u8>().to_vec()))
+        Ok(buf.as_slice(cx).to_vec())
     } else {
         cx.throw_type_error::<_, Vec<u8>>(format!("Invalid or missing {}", full_attr_path))
     }
@@ -139,7 +137,7 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
         let mut map = HashMap::new();
         for k in props {
             let k = k.to_string(cx)?;
-            let v = self.get(cx, k)?.to_string(cx)?.value(cx);
+            let v = self.get::<JsString, _, _>(cx, k)?.value(cx);
             let k = k.value(cx);
             map.insert(k, v);
         }
@@ -189,7 +187,7 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
 
         let retry_config = match js_optional_getter!(cx, self, "retry", JsObject) {
             None => RetryConfig::default(),
-            Some(retry_config) => RetryConfig {
+            Some(ref retry_config) => RetryConfig {
                 initial_interval: Duration::from_millis(js_value_getter!(
                     cx,
                     retry_config,
@@ -229,8 +227,6 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             .client_name("temporal-typescript".to_string())
             .client_version(js_value_getter!(cx, self, "sdkVersion", JsString))
             .target_url(url)
-            .identity(js_value_getter!(cx, self, "identity", JsString))
-            .worker_binary_id(js_value_getter!(cx, self, "workerBinaryId", JsString))
             .retry_config(retry_config)
             .build()
             .expect("Core server gateway options must be valid"))
@@ -242,10 +238,16 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
         if let Some(tf) = js_optional_getter!(cx, self, "tracingFilter", JsString) {
             telemetry_opts.tracing_filter(tf.value(cx));
         }
+        telemetry_opts.no_temporal_prefix_for_metrics(
+            js_optional_getter!(cx, self, "noTemporalPrefixForMetrics", JsBoolean)
+                .map(|b| b.value(cx))
+                .unwrap_or_default(),
+        );
         if let Some(ref logging) = js_optional_getter!(cx, self, "logging", JsObject) {
             if let Some(_) = get_optional(cx, logging, "console") {
                 telemetry_opts.logging(Logger::Console);
-            } else if let Some(forward) = js_optional_getter!(cx, logging, "forward", JsObject) {
+            } else if let Some(ref forward) = js_optional_getter!(cx, logging, "forward", JsObject)
+            {
                 let level = js_value_getter!(cx, forward, "level", JsString);
                 match LevelFilter::from_str(&level) {
                     Ok(level) => {
@@ -321,16 +323,14 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
     fn as_worker_config(&self, cx: &mut FunctionContext) -> NeonResult<WorkerConfig> {
         let namespace = js_value_getter!(cx, self, "namespace", JsString);
         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 =
-            js_value_getter!(cx, self, "maxConcurrentActivityTaskPolls", JsNumber) as usize;
-        let nonsticky_to_sticky_poll_ratio =
-            js_value_getter!(cx, self, "nonStickyToStickyPollRatio", JsNumber) as f32;
         let sticky_queue_schedule_to_start_timeout = Duration::from_millis(js_value_getter!(
             cx,
             self,
@@ -354,20 +354,28 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             JsNumber
         ) as u64);
 
+        let max_worker_activities_per_second =
+            js_optional_getter!(cx, self, "maxActivitiesPerSecond", JsNumber)
+                .map(|num| num.value(cx) as f64);
+        let max_task_queue_activities_per_second =
+            js_optional_getter!(cx, self, "maxTaskQueueActivitiesPerSecond", JsNumber)
+                .map(|num| num.value(cx) as f64);
+
         match WorkerConfigBuilder::default()
-            .no_remote_activities(false) // TODO: make this configurable once Core implements local activities
-            .max_concurrent_at_polls(max_concurrent_at_polls)
-            .max_concurrent_wft_polls(max_concurrent_wft_polls)
+            .worker_build_id(js_value_getter!(cx, self, "buildId", JsString))
+            .client_identity_override(Some(js_value_getter!(cx, self, "identity", JsString)))
+            .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)
             .max_cached_workflows(max_cached_workflows)
-            .nonsticky_to_sticky_poll_ratio(nonsticky_to_sticky_poll_ratio)
             .sticky_queue_schedule_to_start_timeout(sticky_queue_schedule_to_start_timeout)
             .namespace(namespace)
             .task_queue(task_queue)
             .max_heartbeat_throttle_interval(max_heartbeat_throttle_interval)
             .default_heartbeat_throttle_interval(default_heartbeat_throttle_interval)
-            .max_outstanding_local_activities(10_usize) // TODO: Pass in
+            .max_worker_activities_per_second(max_worker_activities_per_second)
+            .max_task_queue_activities_per_second(max_task_queue_activities_per_second)
             .build()
         {
             Ok(worker_cfg) => Ok(worker_cfg),

package/src/errors.rs

@@ -6,8 +6,6 @@ pub static TRANSPORT_ERROR: OnceCell<Root<JsFunction>> = OnceCell::new();
 /// Thrown after shutdown was requested as a response to a poll function, JS should stop polling
 /// once this error is encountered
 pub static SHUTDOWN_ERROR: OnceCell<Root<JsFunction>> = OnceCell::new();
-/// Thrown when using a method for a worker that does not exist (never registered or already shut down)
-pub static NO_WORKER_ERROR: OnceCell<Root<JsFunction>> = OnceCell::new();
 /// Something unexpected happened, considered fatal
 pub static UNEXPECTED_ERROR: OnceCell<Root<JsFunction>> = OnceCell::new();
 /// Used in different parts of the project to signal that something unexpected has happened
@@ -22,14 +20,14 @@ pub trait CustomError {
     where
         C: Context<'a>;
 
-    fn from_string<'a, C>(&self, cx: &mut C, message: String) -> JsResult<'a, JsObject>
+    fn from_string<'a, C>(&self, cx: &mut C, message: impl Into<String>) -> JsResult<'a, JsObject>
     where
         C: Context<'a>;
 
     fn from_error<'a, C, E>(&self, cx: &mut C, err: E) -> JsResult<'a, JsObject>
     where
         C: Context<'a>,
-        E: std::fmt::Display;
+        E: std::error::Error;
 }
 
 // Implement `CustomError` for ALL errors in a `OnceCell`. This only needs to be
@@ -48,20 +46,20 @@ impl CustomError for OnceCell<Root<JsFunction>> {
         error.construct(cx, args)
     }
 
-    fn from_string<'a, C>(&self, cx: &mut C, message: String) -> JsResult<'a, JsObject>
+    fn from_string<'a, C>(&self, cx: &mut C, message: impl Into<String>) -> JsResult<'a, JsObject>
     where
         C: Context<'a>,
     {
-        let args = vec![cx.string(message).upcast()];
+        let args = vec![cx.string(message.into()).upcast()];
         self.construct(cx, args)
     }
 
     fn from_error<'a, C, E>(&self, cx: &mut C, err: E) -> JsResult<'a, JsObject>
     where
         C: Context<'a>,
-        E: std::fmt::Display,
+        E: std::error::Error,
     {
-        self.from_string(cx, format!("{}", err))
+        self.from_string(cx, format!("{:?}", err))
     }
 }
 
@@ -77,29 +75,20 @@ pub fn register_errors(mut cx: FunctionContext) -> JsResult<JsUndefined> {
 
     let mapping = cx.argument::<JsObject>(0)?;
     let shutdown_error = mapping
-        .get(&mut cx, "ShutdownError")?
-        .downcast_or_throw::<JsFunction, FunctionContext>(&mut cx)?
-        .root(&mut cx);
-    let no_worker_error = mapping
-        .get(&mut cx, "NoWorkerRegisteredError")?
-        .downcast_or_throw::<JsFunction, FunctionContext>(&mut cx)?
+        .get::<JsFunction, _, _>(&mut cx, "ShutdownError")?
         .root(&mut cx);
     let transport_error = mapping
-        .get(&mut cx, "TransportError")?
-        .downcast_or_throw::<JsFunction, FunctionContext>(&mut cx)?
+        .get::<JsFunction, _, _>(&mut cx, "TransportError")?
         .root(&mut cx);
     let unexpected_error = mapping
-        .get(&mut cx, "UnexpectedError")?
-        .downcast_or_throw::<JsFunction, FunctionContext>(&mut cx)?
+        .get::<JsFunction, _, _>(&mut cx, "UnexpectedError")?
         .root(&mut cx);
     let illegal_state_error = mapping
-        .get(&mut cx, "IllegalStateError")?
-        .downcast_or_throw::<JsFunction, FunctionContext>(&mut cx)?
+        .get::<JsFunction, _, _>(&mut cx, "IllegalStateError")?
         .root(&mut cx);
 
     TRANSPORT_ERROR.get_or_try_init(|| Ok(transport_error))?;
     SHUTDOWN_ERROR.get_or_try_init(|| Ok(shutdown_error))?;
-    NO_WORKER_ERROR.get_or_try_init(|| Ok(no_worker_error))?;
     UNEXPECTED_ERROR.get_or_try_init(|| Ok(unexpected_error))?;
     ILLEGAL_STATE_ERROR.get_or_try_init(|| Ok(illegal_state_error))?;