temporalio 0.0.1 → 0.1.0

data/bridge/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-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"

data/bridge/sdk-core/sdk/src/interceptors.rs

@@ -1,7 +1,11 @@
 //! User-definable interceptors are defined in this module
 
 use crate::Worker;
-use temporal_sdk_core_protos::coresdk::workflow_completion::WorkflowActivationCompletion;
+use anyhow::bail;
+use temporal_sdk_core_protos::coresdk::{
+    workflow_activation::{remove_from_cache::EvictionReason, WorkflowActivation},
+    workflow_completion::WorkflowActivationCompletion,
+};
 
 /// Implementors can intercept certain actions that happen within the Worker.
 ///
@@ -10,8 +14,37 @@ use temporal_sdk_core_protos::coresdk::workflow_completion::WorkflowActivationCo
 pub trait WorkerInterceptor {
     /// Called every time a workflow activation completes (just before sending the completion to
     /// core).
-    async fn on_workflow_activation_completion(&self, completion: &WorkflowActivationCompletion);
+    async fn on_workflow_activation_completion(&self, _completion: &WorkflowActivationCompletion) {}
     /// Called after the worker has initiated shutdown and the workflow/activity polling loops
     /// have exited, but just before waiting for the inner core worker shutdown
-    fn on_shutdown(&self, sdk_worker: &Worker);
+    fn on_shutdown(&self, _sdk_worker: &Worker) {}
+    /// Called every time a workflow is about to be activated
+    async fn on_workflow_activation(
+        &self,
+        _activation: &WorkflowActivation,
+    ) -> Result<(), anyhow::Error> {
+        Ok(())
+    }
+}
+
+/// An interceptor which causes the worker's run function to exit early if nondeterminism errors are
+/// encountered
+pub struct FailOnNondeterminismInterceptor {}
+#[async_trait::async_trait(?Send)]
+impl WorkerInterceptor for FailOnNondeterminismInterceptor {
+    async fn on_workflow_activation(
+        &self,
+        activation: &WorkflowActivation,
+    ) -> Result<(), anyhow::Error> {
+        if matches!(
+            activation.eviction_reason(),
+            Some(EvictionReason::Nondeterminism)
+        ) {
+            bail!(
+                "Workflow is being evicted because of nondeterminism! {}",
+                activation
+            );
+        }
+        Ok(())
+    }
 }

data/bridge/sdk-core/sdk/src/lib.rs

@@ -10,8 +10,8 @@
 //! ```no_run
 //! use std::{str::FromStr, sync::Arc};
 //! use temporal_sdk::{sdk_client_options, ActContext, Worker};
-//! use temporal_sdk_core::{init_worker, telemetry_init, TelemetryOptionsBuilder, Url};
-//! use temporal_sdk_core_api::worker::WorkerConfigBuilder;
+//! use temporal_sdk_core::{init_worker, Url, CoreRuntime};
+//! use temporal_sdk_core_api::{worker::WorkerConfigBuilder, telemetry::TelemetryOptionsBuilder};
 //!
 //! #[tokio::main]
 //! async fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -20,14 +20,14 @@
 //!     let client = server_options.connect("default", None, None).await?;
 //!
 //!     let telemetry_options = TelemetryOptionsBuilder::default().build()?;
-//!     telemetry_init(&telemetry_options)?;
+//!     let runtime = CoreRuntime::new_assume_tokio(telemetry_options)?;
 //!
 //!     let worker_config = WorkerConfigBuilder::default()
 //!         .namespace("default")
 //!         .task_queue("task_queue")
 //!         .build()?;
 //!
-//!     let core_worker = init_worker(worker_config, client);
+//!     let core_worker = init_worker(&runtime, worker_config, client)?;
 //!
 //!     let mut worker = Worker::new_from_core(Arc::new(core_worker), "task_queue");
 //!     worker.register_activity(
@@ -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;
@@ -279,6 +280,9 @@ impl Worker {
                         }
                         o => o?,
                     };
+                    if let Some(ref i) = common.worker_interceptor {
+                        i.on_workflow_activation(&activation).await?;
+                    }
                     if let Some(wf_fut) = wf_half.workflow_activation_handler(
                         common,
                         shutdown_token.clone(),
@@ -304,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(())
@@ -333,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"))?,
@@ -410,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() => {
@@ -483,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
@@ -746,6 +761,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 {
@@ -753,6 +776,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
@@ -790,3 +823,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;
+}

data/bridge/sdk-core/sdk/src/workflow_context.rs

@@ -34,11 +34,11 @@ use temporal_sdk_core_protos::{
         workflow_commands::{
             request_cancel_external_workflow_execution as cancel_we,
             signal_external_workflow_execution as sig_we, workflow_command,
-            RequestCancelExternalWorkflowExecution, SetPatchMarker,
+            ModifyWorkflowProperties, RequestCancelExternalWorkflowExecution, SetPatchMarker,
             SignalExternalWorkflowExecution, StartTimer, UpsertWorkflowSearchAttributes,
         },
     },
-    temporal::api::common::v1::Payload,
+    temporal::api::common::v1::{Memo, Payload},
 };
 use tokio::sync::{mpsc, oneshot, watch};
 use tokio_stream::wrappers::UnboundedReceiverStream;
@@ -297,6 +297,17 @@ impl WfContext {
         ))
     }
 
+    /// Add or create a set of search attributes
+    pub fn upsert_memo(&self, attr_iter: impl IntoIterator<Item = (String, Payload)>) {
+        self.send(RustWfCmd::NewNonblockingCmd(
+            workflow_command::Variant::ModifyWorkflowProperties(ModifyWorkflowProperties {
+                upserted_memo: Some(Memo {
+                    fields: HashMap::from_iter(attr_iter.into_iter()),
+                }),
+            }),
+        ))
+    }
+
     /// Return a stream that produces values when the named signal is sent to this workflow
     pub fn make_signal_channel(&self, signal_name: impl Into<String>) -> DrainableSignalStream {
         let (tx, rx) = mpsc::unbounded_channel();

data/bridge/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");
     }
 
@@ -218,6 +216,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);
                 }
             }
@@ -283,11 +284,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(

data/bridge/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"

data/bridge/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(())
 }