@temporalio/core-bridge 1.5.2 → 1.7.0

package/sdk-core/sdk/Cargo.toml

@@ -14,21 +14,22 @@ categories = ["development-tools"]
 
 [dependencies]
 async-trait = "0.1"
+thiserror = "1.0"
 anyhow = "1.0"
-base64 = "0.13"
+base64 = "0.21"
 crossbeam = "0.8"
 derive_more = "0.99"
 futures = "0.3"
 once_cell = "1.10"
 parking_lot = { version = "0.12", features = ["send_guard"] }
-prost-types = "0.11"
+prost-types = { version = "0.4", package = "prost-wkt-types" }
 sha2 = "0.10"
 serde = "1.0"
-tokio = { version = "1.1", features = ["rt", "rt-multi-thread", "parking_lot", "time", "fs"] }
+tokio = { version = "1.26", features = ["rt", "rt-multi-thread", "parking_lot", "time", "fs"] }
 tokio-util = { version = "0.7" }
 tokio-stream = "0.1"
 tonic = "0.8"
-tracing = { version = "0.1", features = ["log-always"] }
+tracing = "0.1"
 
 [dependencies.temporal-sdk-core]
 path = "../core"

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

@@ -46,7 +46,6 @@ extern crate tracing;
 
 mod activity_context;
 mod app_data;
-mod conversions;
 pub mod interceptors;
 mod payload_converter;
 mod workflow_context;
@@ -67,10 +66,12 @@ use anyhow::{anyhow, bail, Context};
 use app_data::AppData;
 use futures::{future::BoxFuture, FutureExt, StreamExt, TryFutureExt, TryStreamExt};
 use std::{
+    any::{Any, TypeId},
     cell::RefCell,
     collections::HashMap,
     fmt::{Debug, Display, Formatter},
     future::Future,
+    panic::AssertUnwindSafe,
     sync::Arc,
 };
 use temporal_client::ClientOptionsBuilder;
@@ -87,7 +88,7 @@ use temporal_sdk_core_protos::{
         common::NamespacedWorkflowExecution,
         workflow_activation::{
             resolve_child_workflow_execution_start::Status as ChildWorkflowStartStatus,
-            workflow_activation_job::Variant, WorkflowActivation, WorkflowActivationJob,
+            workflow_activation_job::Variant, WorkflowActivation,
         },
         workflow_commands::{workflow_command, ContinueAsNewWorkflowExecution},
         workflow_completion::WorkflowActivationCompletion,
@@ -307,22 +308,17 @@ impl Worker {
             // makes tests which use mocks dramatically more manageable.
             async {
                 if !act_half.activity_fns.is_empty() {
-                    let shutdown_token = shutdown_token.clone();
                     loop {
-                        tokio::select! {
-                            activity = common.worker.poll_activity_task() => {
-                                if matches!(activity, Err(PollActivityError::ShutDown)) {
-                                    break;
-                                }
-                                act_half.activity_task_handler(
-                                    common.worker.clone(),
-                                    safe_app_data.clone(),
-                                    common.task_queue.clone(),
-                                    activity?
-                                )?;
-                            },
-                            _ = shutdown_token.cancelled() => { break }
+                        let activity = common.worker.poll_activity_task().await;
+                        if matches!(activity, Err(PollActivityError::ShutDown)) {
+                            break;
                         }
+                        act_half.activity_task_handler(
+                            common.worker.clone(),
+                            safe_app_data.clone(),
+                            common.task_queue.clone(),
+                            activity?,
+                        )?;
                     }
                 };
                 Result::<_, anyhow::Error>::Ok(())
@@ -336,6 +332,7 @@ impl Worker {
             i.on_shutdown(self);
         }
         self.common.worker.shutdown().await;
+        debug!("Worker shutdown complete");
         self.app_data = Some(
             Arc::try_unwrap(safe_app_data)
                 .map_err(|_| anyhow!("some references of AppData exist on worker shutdown"))?,
@@ -394,10 +391,10 @@ impl WorkflowHalf {
 
         // If the activation is to start a workflow, create a new workflow driver for it,
         // using the function associated with that workflow id
-        if let Some(WorkflowActivationJob {
-            variant: Some(Variant::StartWorkflow(sw)),
-        }) = activation.jobs.get(0)
-        {
+        if let Some(sw) = activation.jobs.iter().find_map(|j| match j.variant {
+            Some(Variant::StartWorkflow(ref sw)) => Some(sw),
+            _ => None,
+        }) {
             let workflow_type = &sw.workflow_type;
             let wf_fns_borrow = self.workflow_fns.borrow();
             let wf_function = wf_fns_borrow
@@ -413,7 +410,7 @@ impl WorkflowHalf {
             );
             let jh = tokio::spawn(async move {
                 tokio::select! {
-                    r = wff => r,
+                    r = wff.fuse() => r,
                     // TODO: This probably shouldn't abort early, as it could cause an in-progress
                     //  complete to abort. Send synthetic remove activation
                     _ = shutdown_token.cancelled() => {
@@ -486,15 +483,30 @@ impl ActivityHalf {
                     start,
                 );
                 tokio::spawn(async move {
-                    let output = (act_fn.act_func)(ctx, arg).await;
+                    let output = AssertUnwindSafe((act_fn.act_func)(ctx, arg))
+                        .catch_unwind()
+                        .await;
                     let result = match output {
-                        Ok(ActExitValue::Normal(p)) => ActivityExecutionResult::ok(p),
-                        Ok(ActExitValue::WillCompleteAsync) => {
+                        Err(e) => ActivityExecutionResult::fail(Failure::application_failure(
+                            format!("Activity function panicked: {}", panic_formatter(e)),
+                            true,
+                        )),
+                        Ok(Ok(ActExitValue::Normal(p))) => ActivityExecutionResult::ok(p),
+                        Ok(Ok(ActExitValue::WillCompleteAsync)) => {
                             ActivityExecutionResult::will_complete_async()
                         }
-                        Err(err) => match err.downcast::<ActivityCancelledError>() {
+                        Ok(Err(err)) => match err.downcast::<ActivityCancelledError>() {
                             Ok(ce) => ActivityExecutionResult::cancel_from_details(ce.details),
-                            Err(other_err) => ActivityExecutionResult::fail(other_err.into()),
+                            Err(other_err) => {
+                                match other_err.downcast::<NonRetryableActivityError>() {
+                                    Ok(nre) => ActivityExecutionResult::fail(
+                                        Failure::application_failure_from_error(nre.into(), true),
+                                    ),
+                                    Err(other_err) => ActivityExecutionResult::fail(
+                                        Failure::application_failure_from_error(other_err, false),
+                                    ),
+                                }
+                            }
                         },
                     };
                     worker
@@ -537,11 +549,13 @@ pub enum TimerResult {
 }
 
 /// Successful result of sending a signal to an external workflow
+#[derive(Debug)]
 pub struct SignalExternalOk;
 /// Result of awaiting on sending a signal to an external workflow
 pub type SignalExternalWfResult = Result<SignalExternalOk, Failure>;
 
 /// Successful result of sending a cancel request to an external workflow
+#[derive(Debug)]
 pub struct CancelExternalOk;
 /// Result of awaiting on sending a cancel request to an external workflow
 pub type CancelExternalWfResult = Result<CancelExternalOk, Failure>;
@@ -644,6 +658,20 @@ pub enum CancellableID {
     },
 }
 
+impl CancellableID {
+    /// Returns the type-specific sequence number used for this command
+    pub fn seq_num(&self) -> u32 {
+        match self {
+            CancellableID::Timer(seq) => *seq,
+            CancellableID::Activity(seq) => *seq,
+            CancellableID::LocalActivity(seq) => *seq,
+            CancellableID::ChildWorkflow(seq) => *seq,
+            CancellableID::SignalExternalWorkflow(seq) => *seq,
+            CancellableID::ExternalWorkflow { seqnum, .. } => *seqnum,
+        }
+    }
+}
+
 #[derive(derive_more::From)]
 #[allow(clippy::large_enum_variant)]
 enum RustWfCmd {
@@ -749,6 +777,14 @@ pub struct ActivityFunction {
 pub struct ActivityCancelledError {
     details: Option<Payload>,
 }
+impl ActivityCancelledError {
+    /// Include some details as part of concluding the activity as cancelled
+    pub fn with_details(payload: Payload) -> Self {
+        Self {
+            details: Some(payload),
+        }
+    }
+}
 impl std::error::Error for ActivityCancelledError {}
 impl Display for ActivityCancelledError {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
@@ -756,6 +792,16 @@ impl Display for ActivityCancelledError {
     }
 }
 
+/// Return this error to indicate that your activity non-retryable
+/// this is a transparent wrapper around anyhow Error so essentially any type of error
+/// could be used here.
+///
+/// In your activity function. Return something along the lines of:
+/// `Err(NonRetryableActivityError(anyhow::anyhow!("This should *not* be retried")).into())`
+#[derive(Debug, thiserror::Error)]
+#[error(transparent)]
+pub struct NonRetryableActivityError(pub anyhow::Error);
+
 /// Closures / functions which can be turned into activity functions implement this trait
 pub trait IntoActivityFunc<Args, Res, Out> {
     /// Consume the closure or fn pointer and turned it into a boxed activity function
@@ -793,3 +839,39 @@ where
         Arc::new(wrapper)
     }
 }
+
+/// Attempts to turn caught panics into something printable
+fn panic_formatter(panic: Box<dyn Any>) -> Box<dyn Display> {
+    _panic_formatter::<&str>(panic)
+}
+fn _panic_formatter<T: 'static + PrintablePanicType>(panic: Box<dyn Any>) -> Box<dyn Display> {
+    match panic.downcast::<T>() {
+        Ok(d) => d,
+        Err(orig) => {
+            if TypeId::of::<<T as PrintablePanicType>::NextType>()
+                == TypeId::of::<EndPrintingAttempts>()
+            {
+                return Box::new("Couldn't turn panic into a string");
+            }
+            _panic_formatter::<T::NextType>(orig)
+        }
+    }
+}
+trait PrintablePanicType: Display {
+    type NextType: PrintablePanicType;
+}
+impl PrintablePanicType for &str {
+    type NextType = String;
+}
+impl PrintablePanicType for String {
+    type NextType = EndPrintingAttempts;
+}
+struct EndPrintingAttempts {}
+impl Display for EndPrintingAttempts {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Will never be printed")
+    }
+}
+impl PrintablePanicType for EndPrintingAttempts {
+    type NextType = EndPrintingAttempts;
+}

package/sdk-core/sdk/src/workflow_context/options.rs

@@ -9,7 +9,10 @@ use temporal_sdk_core_protos::{
             StartChildWorkflowExecution,
         },
     },
-    temporal::api::common::v1::{Payload, RetryPolicy},
+    temporal::api::{
+        common::v1::{Payload, RetryPolicy},
+        enums::v1::ParentClosePolicy,
+    },
 };
 
 // TODO: Before release, probably best to avoid using proto types entirely here. They're awkward.
@@ -180,6 +183,8 @@ pub struct ChildWorkflowOptions {
     pub cancel_type: ChildWorkflowCancellationType,
     /// Common options
     pub options: WorkflowOptions,
+    /// How to respond to parent workflow ending
+    pub parent_close_policy: ParentClosePolicy,
 }
 
 impl IntoWorkflowCommand for ChildWorkflowOptions {
@@ -203,6 +208,7 @@ impl IntoWorkflowCommand for ChildWorkflowOptions {
             workflow_task_timeout: self.options.task_timeout.and_then(|d| d.try_into().ok()),
             search_attributes: self.options.search_attributes.unwrap_or_default(),
             cron_schedule: self.options.cron_schedule.unwrap_or_default(),
+            parent_close_policy: self.parent_close_policy as i32,
             ..Default::default()
         }
     }

package/sdk-core/sdk/src/workflow_context.rs

@@ -34,7 +34,8 @@ use temporal_sdk_core_protos::{
         workflow_commands::{
             request_cancel_external_workflow_execution as cancel_we,
             signal_external_workflow_execution as sig_we, workflow_command,
-            ModifyWorkflowProperties, RequestCancelExternalWorkflowExecution, SetPatchMarker,
+            CancelChildWorkflowExecution, ModifyWorkflowProperties,
+            RequestCancelExternalWorkflowExecution, SetPatchMarker,
             SignalExternalWorkflowExecution, StartTimer, UpsertWorkflowSearchAttributes,
         },
     },
@@ -98,6 +99,7 @@ pub struct WfContextSharedData {
     pub changes: HashMap<String, bool>,
     pub is_replaying: bool,
     pub wf_time: Option<SystemTime>,
+    pub history_length: u32,
 }
 
 // TODO: Dataconverter type interface to replace Payloads here. Possibly just use serde
@@ -148,6 +150,11 @@ impl WfContext {
         self.shared.read().wf_time
     }
 
+    /// Return the length of history so far at this point in the workflow
+    pub fn history_length(&self) -> u32 {
+        self.shared.read().history_length
+    }
+
     pub(crate) fn get_shared_data(&self) -> Arc<RwLock<WfContextSharedData>> {
         self.shared.clone()
     }
@@ -550,16 +557,16 @@ impl<'a> Future for LATimerBackoffFut<'a> {
         }
         let poll_res = self.current_fut.poll_unpin(cx);
         if let Poll::Ready(ref r) = poll_res {
-            // If we've already said we want to cancel, don't schedule the backoff timer. Just
-            // return cancel status. This can happen if cancel comes after the LA says it wants to
-            // back off but before we have scheduled the timer.
-            if self.did_cancel.load(Ordering::Acquire) {
-                return Poll::Ready(ActivityResolution {
-                    status: Some(activity_resolution::Status::Cancelled(Default::default())),
-                });
-            }
-
             if let Some(activity_resolution::Status::Backoff(b)) = r.status.as_ref() {
+                // If we've already said we want to cancel, don't schedule the backoff timer. Just
+                // return cancel status. This can happen if cancel comes after the LA says it wants
+                // to back off but before we have scheduled the timer.
+                if self.did_cancel.load(Ordering::Acquire) {
+                    return Poll::Ready(ActivityResolution {
+                        status: Some(activity_resolution::Status::Cancelled(Default::default())),
+                    });
+                }
+
                 let timer_f = self.ctx.timer(
                     b.backoff_duration
                         .clone()
@@ -673,13 +680,13 @@ impl StartedChildWorkflow {
     }
 
     /// Cancel the child workflow
-    pub fn cancel(&self, cx: &WfContext) -> impl Future<Output = CancelExternalWfResult> {
-        let target = NamespacedWorkflowExecution {
-            namespace: cx.namespace().to_string(),
-            workflow_id: self.common.workflow_id.clone(),
-            ..Default::default()
-        };
-        cx.cancel_external(target)
+    pub fn cancel(&self, cx: &WfContext) {
+        cx.send(RustWfCmd::NewNonblockingCmd(
+            CancelChildWorkflowExecution {
+                child_workflow_seq: self.common.result_future.cancellable_id.seq_num(),
+            }
+            .into(),
+        ));
     }
 
     /// Signal the child workflow

package/sdk-core/sdk/src/workflow_future.rs

@@ -1,7 +1,6 @@
 use crate::{
-    conversions::anyhow_to_fail, workflow_context::WfContextSharedData, CancellableID, RustWfCmd,
-    SignalData, TimerResult, UnblockEvent, WfContext, WfExitValue, WorkflowFunction,
-    WorkflowResult,
+    panic_formatter, workflow_context::WfContextSharedData, CancellableID, RustWfCmd, SignalData,
+    TimerResult, UnblockEvent, WfContext, WfExitValue, WorkflowFunction, WorkflowResult,
 };
 use anyhow::{anyhow, bail, Context as AnyhowContext, Error};
 use crossbeam::channel::Receiver;
@@ -63,7 +62,9 @@ impl WorkflowFunction {
                 // We need to mark the workflow future as unconstrained, otherwise Tokio will impose
                 // an artificial limit on how many commands we can unblock in one poll round.
                 // TODO: Now we *need* deadlock detection or we could hose the whole system
-                inner: tokio::task::unconstrained((self.wf_func)(wf_context)).boxed(),
+                inner: tokio::task::unconstrained((self.wf_func)(wf_context))
+                    .fuse()
+                    .boxed(),
                 incoming_commands: cmd_receiver,
                 outgoing_completions,
                 incoming_activations,
@@ -132,10 +133,7 @@ impl WorkflowFuture {
     fn fail_wft(&self, run_id: String, fail: Error) {
         warn!("Workflow task failed for {}: {}", run_id, fail);
         self.outgoing_completions
-            .send(WorkflowActivationCompletion::fail(
-                run_id,
-                anyhow_to_fail(fail),
-            ))
+            .send(WorkflowActivationCompletion::fail(run_id, fail.into()))
             .expect("Completion channel intact");
     }
 
@@ -183,8 +181,11 @@ impl WorkflowFuture {
                     Box::new(result.context("Child Workflow execution must have a result")?),
                 ))?,
                 Variant::UpdateRandomSeed(_) => (),
-                Variant::QueryWorkflow(_) => {
-                    todo!()
+                Variant::QueryWorkflow(q) => {
+                    error!(
+                        "Queries are not implemented in the Rust SDK. Got query '{}'",
+                        q.query_id
+                    );
                 }
                 Variant::CancelWorkflow(_) => {
                     // TODO: Cancel pending futures, etc
@@ -218,6 +219,9 @@ impl WorkflowFuture {
                 }
 
                 Variant::RemoveFromCache(_) => {
+                    // TODO: Need to abort any spawned tasks, etc. See also cancel WF.
+                    //   How best to do this in executor agnostic way? Is that possible?
+                    //  -- tokio JoinSet does this in a nice way.
                     return Ok(true);
                 }
             }
@@ -253,6 +257,7 @@ impl Future for WorkflowFuture {
                 let mut wlock = self.ctx_shared.write();
                 wlock.is_replaying = activation.is_replaying;
                 wlock.wf_time = activation.timestamp.try_into_or_none();
+                wlock.history_length = activation.history_length;
             }
 
             let mut die_of_eviction_when_done = false;
@@ -283,11 +288,7 @@ impl Future for WorkflowFuture {
                 .poll_unpin(cx)
             {
                 Poll::Ready(Err(e)) => {
-                    let errmsg = format!(
-                        "Workflow function panicked: {:?}",
-                        // Panics are typically strings
-                        e.downcast::<String>()
-                    );
+                    let errmsg = format!("Workflow function panicked: {}", panic_formatter(e));
                     warn!("{}", errmsg);
                     self.outgoing_completions
                         .send(WorkflowActivationCompletion::fail(

package/sdk-core/sdk-core-protos/Cargo.toml

@@ -12,13 +12,15 @@ categories = ["development-tools"]
 
 [features]
 history_builders = ["uuid", "rand"]
+serde_serialize = []
 
 [dependencies]
 anyhow = "1.0"
-base64 = "0.13"
+base64 = "0.21"
 derive_more = "0.99"
 prost = "0.11"
-prost-types = "0.11"
+prost-wkt = "0.4"
+prost-wkt-types = "0.4"
 rand = { version = "0.8", optional = true }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
@@ -28,3 +30,4 @@ uuid = { version = "1.1", features = ["v4"], optional = true }
 
 [build-dependencies]
 tonic-build = "0.8"
+prost-wkt-build = "0.4"

package/sdk-core/sdk-core-protos/build.rs

@@ -1,5 +1,9 @@
+use std::{env, path::PathBuf};
+
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("cargo:rerun-if-changed=../protos");
+    let out = PathBuf::from(env::var("OUT_DIR").unwrap());
+    let descriptor_file = out.join("descriptors.bin");
     tonic_build::configure()
         // We don't actually want to build the grpc definitions - we don't need them (for now).
         // Just build the message structs.
@@ -74,7 +78,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         // All external data is useful to be able to JSON serialize, so it can render in web UI
         .type_attribute(
             ".coresdk.external_data",
-            "#[derive(::serde::Serialize, ::serde::Deserialize)]",
+            "#[cfg_attr(not(feature = \"serde_serialize\"), derive(::serde::Serialize, ::serde::Deserialize))]",
+        )
+        .type_attribute(
+            ".",
+            "#[cfg_attr(feature = \"serde_serialize\", derive(::serde::Serialize, ::serde::Deserialize))]",
         )
         .field_attribute(
             "coresdk.external_data.LocalActivityMarkerData.complete_time",
@@ -88,10 +96,26 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             "coresdk.external_data.LocalActivityMarkerData.backoff",
             "#[serde(with = \"opt_duration\")]",
         )
+        .extern_path(
+            ".google.protobuf.Any",
+            "::prost_wkt_types::Any"
+        )
+        .extern_path(
+            ".google.protobuf.Timestamp",
+            "::prost_wkt_types::Timestamp"
+        )
+        .extern_path(
+            ".google.protobuf.Duration",
+            "::prost_wkt_types::Duration"
+        )
+        .extern_path(
+            ".google.protobuf.Value",
+            "::prost_wkt_types::Value"
+        )
+        .file_descriptor_set_path(#[allow(clippy::needless_borrow)] &descriptor_file)
         .compile(
             &[
                 "../protos/local/temporal/sdk/core/core_interface.proto",
-                "../protos/local/temporal/sdk/core/bridge/bridge.proto",
                 "../protos/api_upstream/temporal/api/workflowservice/v1/service.proto",
                 "../protos/api_upstream/temporal/api/operatorservice/v1/service.proto",
                 "../protos/testsrv_upstream/temporal/api/testservice/v1/service.proto",
@@ -104,5 +128,15 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                 "../protos/grpc",
             ],
         )?;
+
+    #[cfg(feature = "serde_serialize")]
+    {
+        use prost_wkt_build::{FileDescriptorSet, Message};
+
+        let descriptor_bytes = std::fs::read(descriptor_file)?;
+        let descriptor = FileDescriptorSet::decode(&descriptor_bytes[..])?;
+        prost_wkt_build::add_serde(out, descriptor);
+    }
+
     Ok(())
 }