@temporalio/core-bridge 1.11.1 → 1.11.3

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

@@ -1,9 +1,19 @@
+use crate::integ_tests::activity_functions::echo;
 use futures::StreamExt;
-use std::{sync::Arc, time::Duration};
+use std::{
+    sync::{
+        atomic::{AtomicBool, AtomicU64, Ordering},
+        Arc,
+    },
+    time::Duration,
+};
 use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions, WorkflowService};
-use temporal_sdk::WfContext;
-use temporal_sdk_core_protos::temporal::api::{
-    common::v1::WorkflowExecution, workflowservice::v1::ResetWorkflowExecutionRequest,
+use temporal_sdk::{LocalActivityOptions, WfContext};
+use temporal_sdk_core_protos::{
+    coresdk::AsJsonPayloadExt,
+    temporal::api::{
+        common::v1::WorkflowExecution, workflowservice::v1::ResetWorkflowExecutionRequest,
+    },
 };
 use temporal_sdk_core_test_utils::{CoreWfStarter, NAMESPACE};
 use tokio::sync::Notify;
@@ -92,3 +102,128 @@ async fn reset_workflow() {
     let (_, rr) = tokio::join!(resetter_fut, run_fut);
     rr.unwrap();
 }
+
+#[tokio::test]
+async fn reset_randomseed() {
+    let wf_name = "reset_randomseed";
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter.worker_config.no_remote_activities(true);
+    let mut worker = starter.worker().await;
+    worker.fetch_results = false;
+    let notify = Arc::new(Notify::new());
+
+    const POST_FAIL_SIG: &str = "post-fail";
+    static DID_FAIL: AtomicBool = AtomicBool::new(false);
+    static RAND_SEED: AtomicU64 = AtomicU64::new(0);
+
+    let wf_notify = notify.clone();
+    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| {
+        let notify = wf_notify.clone();
+        async move {
+            let _ = RAND_SEED.compare_exchange(
+                0,
+                ctx.random_seed(),
+                Ordering::Relaxed,
+                Ordering::Relaxed,
+            );
+            // Make a couple workflow tasks
+            ctx.timer(Duration::from_millis(100)).await;
+            ctx.timer(Duration::from_millis(100)).await;
+            if DID_FAIL
+                .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
+                .is_ok()
+            {
+                // Tell outer scope to send the post-task-failure-signal
+                notify.notify_one();
+                panic!("Ahh");
+            }
+            // Make a command that is one thing with the initial seed, but another after reset
+            if RAND_SEED.load(Ordering::Relaxed) == ctx.random_seed() {
+                ctx.timer(Duration::from_millis(100)).await;
+            } else {
+                ctx.local_activity(LocalActivityOptions {
+                    activity_type: "echo".to_string(),
+                    input: "hi!".as_json_payload().expect("serializes fine"),
+                    ..Default::default()
+                })
+                .await;
+            }
+            // Wait for the post-task-fail signal
+            let _ = ctx.make_signal_channel(POST_FAIL_SIG).next().await.unwrap();
+            // Tell outer scope to send the reset
+            notify.notify_one();
+            let _ = ctx
+                .make_signal_channel(POST_RESET_SIG)
+                .next()
+                .await
+                .unwrap();
+            Ok(().into())
+        }
+    });
+    worker.register_activity("echo", echo);
+
+    let run_id = worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+
+    let mut client = starter.get_client().await;
+    let client = Arc::make_mut(&mut client);
+    let client_fur = async {
+        notify.notified().await;
+        WorkflowClientTrait::signal_workflow_execution(
+            client,
+            wf_name.to_owned(),
+            run_id.clone(),
+            POST_FAIL_SIG.to_string(),
+            None,
+            None,
+        )
+        .await
+        .unwrap();
+        notify.notified().await;
+        // Reset the workflow to be after first timer has fired
+        client
+            .reset_workflow_execution(ResetWorkflowExecutionRequest {
+                namespace: NAMESPACE.to_owned(),
+                workflow_execution: Some(WorkflowExecution {
+                    workflow_id: wf_name.to_owned(),
+                    run_id: run_id.clone(),
+                }),
+                workflow_task_finish_event_id: 14,
+                request_id: "test-req-id".to_owned(),
+                ..Default::default()
+            })
+            .await
+            .unwrap();
+
+        // Unblock the workflow by sending the signal. Run ID will have changed after reset so
+        // we use empty run id
+        WorkflowClientTrait::signal_workflow_execution(
+            client,
+            wf_name.to_owned(),
+            "".to_owned(),
+            POST_RESET_SIG.to_owned(),
+            None,
+            None,
+        )
+        .await
+        .unwrap();
+
+        // Wait for the now-reset workflow to finish
+        client
+            .get_untyped_workflow_handle(wf_name.to_owned(), "")
+            .get_workflow_result(Default::default())
+            .await
+            .unwrap();
+        starter.shutdown().await;
+    };
+    let run_fut = worker.run_until_done();
+    let (_, rr) = tokio::join!(client_fur, run_fut);
+    rr.unwrap();
+}

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

@@ -1,22 +1,33 @@
-use std::{collections::HashMap, env};
-use temporal_client::{WorkflowClientTrait, WorkflowOptions};
-use temporal_sdk::{WfContext, WorkflowResult};
+use assert_matches::assert_matches;
+use std::{collections::HashMap, time::Duration};
+use temporal_client::{
+    GetWorkflowResultOpts, WfClientExt, WorkflowClientTrait, WorkflowExecutionResult,
+    WorkflowOptions,
+};
+use temporal_sdk::{WfContext, WfExitValue, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::{AsJsonPayloadExt, FromJsonPayloadExt};
-use temporal_sdk_core_test_utils::{CoreWfStarter, INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR};
-use tracing::warn;
+use temporal_sdk_core_test_utils::{CoreWfStarter, SEARCH_ATTR_INT, SEARCH_ATTR_TXT};
 use uuid::Uuid;
 
-// These are initialized on the server as part of the autosetup container which we
-// use for integration tests.
-static TXT_ATTR: &str = "CustomTextField";
-static INT_ATTR: &str = "CustomIntField";
-
 async fn search_attr_updater(ctx: WfContext) -> WorkflowResult<()> {
+    let mut int_val = ctx
+        .search_attributes()
+        .indexed_fields
+        .get(SEARCH_ATTR_INT)
+        .cloned()
+        .unwrap_or_default();
+    let orig_val = int_val.data[0];
+    int_val.data[0] += 1;
     ctx.upsert_search_attributes([
-        (TXT_ATTR.to_string(), "goodbye".as_json_payload().unwrap()),
-        (INT_ATTR.to_string(), 98.as_json_payload().unwrap()),
+        (SEARCH_ATTR_TXT.to_string(), "goodbye".as_json_payload()?),
+        (SEARCH_ATTR_INT.to_string(), int_val),
     ]);
-    Ok(().into())
+    // 49 is ascii 1
+    if orig_val == 49 {
+        Ok(WfExitValue::ContinueAsNew(Box::default()))
+    } else {
+        Ok(().into())
+    }
 }
 
 #[tokio::test]
@@ -26,23 +37,22 @@ async fn sends_upsert() {
     let mut starter = CoreWfStarter::new(wf_name);
     starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
-    // TODO: this should be supported in server 1.20, remove this condition when CLI is upgraded.
-    if env::var(INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR).is_ok() {
-        warn!("skipping sends_upsert -- does not work on temporal dev server");
-        return;
-    }
 
     worker.register_wf(wf_name, search_attr_updater);
-    let run_id = worker
+    worker
         .submit_wf(
             wf_id.to_string(),
             wf_name,
             vec![],
             WorkflowOptions {
                 search_attributes: Some(HashMap::from([
-                    (TXT_ATTR.to_string(), "hello".as_json_payload().unwrap()),
-                    (INT_ATTR.to_string(), 1.as_json_payload().unwrap()),
+                    (
+                        SEARCH_ATTR_TXT.to_string(),
+                        "hello".as_json_payload().unwrap(),
+                    ),
+                    (SEARCH_ATTR_INT.to_string(), 1.as_json_payload().unwrap()),
                 ])),
+                execution_timeout: Some(Duration::from_secs(4)),
                 ..Default::default()
             },
         )
@@ -50,10 +60,9 @@ async fn sends_upsert() {
         .unwrap();
     worker.run_until_done().await.unwrap();
 
-    let search_attrs = starter
-        .get_client()
-        .await
-        .describe_workflow_execution(wf_id.to_string(), Some(run_id))
+    let client = starter.get_client().await;
+    let search_attrs = client
+        .describe_workflow_execution(wf_id.to_string(), None)
         .await
         .unwrap()
         .workflow_execution_info
@@ -61,8 +70,8 @@ async fn sends_upsert() {
         .search_attributes
         .unwrap()
         .indexed_fields;
-    let txt_attr_payload = search_attrs.get(TXT_ATTR).unwrap();
-    let int_attr_payload = search_attrs.get(INT_ATTR).unwrap();
+    let txt_attr_payload = search_attrs.get(SEARCH_ATTR_TXT).unwrap();
+    let int_attr_payload = search_attrs.get(SEARCH_ATTR_INT).unwrap();
     for payload in [txt_attr_payload, int_attr_payload] {
         assert!(payload.is_json_payload());
     }
@@ -70,5 +79,11 @@ async fn sends_upsert() {
         "goodbye",
         String::from_json_payload(txt_attr_payload).unwrap()
     );
-    assert_eq!(98, usize::from_json_payload(int_attr_payload).unwrap());
+    assert_eq!(3, usize::from_json_payload(int_attr_payload).unwrap());
+    let handle = client.get_untyped_workflow_handle(wf_id.to_string(), "");
+    let res = handle
+        .get_workflow_result(GetWorkflowResultOpts::default())
+        .await
+        .unwrap();
+    assert_matches!(res, WorkflowExecutionResult::Succeeded(_));
 }

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

@@ -79,7 +79,7 @@ async fn parallel_workflows_same_queue() {
         assert_matches!(
             task.jobs.as_slice(),
             [WorkflowActivationJob {
-                variant: Some(workflow_activation_job::Variant::StartWorkflow(_)),
+                variant: Some(workflow_activation_job::Variant::InitializeWorkflow(_)),
             }]
         );
         worker
@@ -222,6 +222,7 @@ async fn fail_wf_task(#[values(true, false)] replay: bool) {
     core.complete_workflow_activation(WorkflowActivationCompletion::fail(
         task.run_id,
         Failure::application_failure("I did an oopsie".to_string(), false),
+        None,
     ))
     .await
     .unwrap();

package/sdk-core/tests/main.rs

@@ -19,7 +19,7 @@ mod integ_tests {
     mod worker_tests;
     mod workflow_tests;
 
-    use std::str::FromStr;
+    use std::{env, str::FromStr};
     use temporal_client::WorkflowService;
     use temporal_sdk_core::{
         init_worker, ClientOptionsBuilder, ClientTlsConfig, CoreRuntime, TlsConfig,
@@ -27,9 +27,7 @@ mod integ_tests {
     };
     use temporal_sdk_core_api::worker::WorkerConfigBuilder;
     use temporal_sdk_core_protos::temporal::api::workflowservice::v1::ListNamespacesRequest;
-    use temporal_sdk_core_test_utils::{
-        get_integ_server_options, get_integ_telem_options, init_integ_telem,
-    };
+    use temporal_sdk_core_test_utils::{get_integ_server_options, get_integ_telem_options};
     use url::Url;
 
     // Create a worker like a bridge would (unwraps aside)
@@ -61,37 +59,48 @@ mod integ_tests {
             .await;
     }
 
-    // Manually run to verify tls works against cloud. You will need certs in place in the
-    // indicated directory.
     #[tokio::test]
-    #[ignore]
     async fn tls_test() {
-        init_integ_telem();
-        let root = tokio::fs::read("../.cloud_certs/ca.pem").await.unwrap();
-        let client_cert = tokio::fs::read("../.cloud_certs/client.pem").await.unwrap();
-        let client_private_key = tokio::fs::read("../.cloud_certs/client.key").await.unwrap();
+        let cloud_addr = env::var("TEMPORAL_CLOUD_ADDRESS");
+        let cloud_key = env::var("TEMPORAL_CLIENT_KEY");
+
+        let (cloud_addr, cloud_key) = if let (Ok(c), Ok(ck)) = (cloud_addr, cloud_key) {
+            if ck.is_empty() {
+                return; // secret not present in github, could be a fork, just skip
+            }
+            (c, ck)
+        } else {
+            // Skip the test
+            return;
+        };
+
+        let client_cert = env::var("TEMPORAL_CLIENT_CERT")
+            .expect("TEMPORAL_CLIENT_CERT must be set")
+            .replace("\\n", "\n")
+            .into_bytes();
+        let client_private_key = cloud_key.replace("\\n", "\n").into_bytes();
         let sgo = ClientOptionsBuilder::default()
-            .target_url(Url::from_str("https://spencer.temporal-dev.tmprl.cloud:7233").unwrap())
+            .target_url(Url::from_str(&cloud_addr).unwrap())
             .client_name("tls_tester")
             .client_version("clientver")
             .tls_cfg(TlsConfig {
-                server_root_ca_cert: Some(root),
-                // Not necessary, but illustrates functionality for people using proxies, etc.
-                domain: Some("spencer.temporal-dev.tmprl.cloud".to_string()),
                 client_tls_config: Some(ClientTlsConfig {
                     client_cert,
                     client_private_key,
                 }),
+                ..Default::default()
             })
             .build()
             .unwrap();
         let con = sgo
-            .connect("spencer.temporal-dev".to_string(), None)
+            .connect(
+                env::var("TEMPORAL_CLOUD_NAMESPACE").expect("TEMPORAL_CLOUD_NAMESPACE must be set"),
+                None,
+            )
             .await
             .unwrap();
-        dbg!(con
-            .list_workflow_executions(100, vec![], "".to_string())
+        con.list_workflow_executions(100, vec![], "".to_string())
             .await
-            .unwrap());
+            .unwrap();
     }
 }

package/sdk-core/tests/runner.rs

@@ -10,7 +10,7 @@ use temporal_sdk_core::ephemeral_server::{
 };
 use temporal_sdk_core_test_utils::{
     default_cached_download, INTEG_SERVER_TARGET_ENV_VAR, INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR,
-    INTEG_TEST_SERVER_USED_ENV_VAR,
+    INTEG_TEST_SERVER_USED_ENV_VAR, SEARCH_ATTR_INT, SEARCH_ATTR_TXT,
 };
 use tokio::{self, process::Command};
 
@@ -70,11 +70,16 @@ async fn main() -> Result<(), anyhow::Error> {
         ServerKind::TemporalCLI => {
             let config = TemporalDevServerConfigBuilder::default()
                 .exe(default_cached_download())
-                // TODO: Delete when temporalCLI enables it by default.
                 .extra_args(vec![
+                    // TODO: Delete when temporalCLI enables it by default.
                     "--dynamic-config-value".to_string(),
                     "system.enableEagerWorkflowStart=true".to_string(),
+                    "--search-attribute".to_string(),
+                    format!("{SEARCH_ATTR_TXT}=Text"),
+                    "--search-attribute".to_string(),
+                    format!("{SEARCH_ATTR_INT}=Int"),
                 ])
+                .ui(true)
                 .build()?;
             println!("Using temporal CLI");
             (

package/ts/errors.ts

@@ -18,7 +18,14 @@ export class TransportError extends Error {}
  * Something unexpected happened, considered fatal
  */
 @SymbolBasedInstanceOfError('UnexpectedError')
-export class UnexpectedError extends Error {}
+export class UnexpectedError extends Error {
+  constructor(
+    message: string,
+    public cause?: unknown
+  ) {
+    super(message);
+  }
+}
 
 export { IllegalStateError };
 
@@ -47,7 +54,7 @@ export function convertFromNamedError(e: unknown, keepStackTrace: boolean): unkn
         return newerr;
 
       case 'UnexpectedError':
-        newerr = new UnexpectedError(e.message);
+        newerr = new UnexpectedError(e.message, e);
         newerr.stack = keepStackTrace ? e.stack : undefined;
         return newerr;
     }

package/ts/index.ts

@@ -133,6 +133,9 @@ export interface OtelCollectorExporter {
   otel: {
     /**
      * URL of a gRPC OpenTelemetry collector.
+     *
+     * @format Starts with "grpc://" or "http://" for an unsecured connection (typical), or "grpcs://" or "https://" for a TLS connection.
+     * @note The `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable, if set, will override this property.
      */
     url: string;
     /**