@temporalio/core-bridge 0.23.0 → 1.0.0

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

@@ -8,16 +8,25 @@
 //!
 //! An example of running an activity worker:
 //! ```no_run
-//! use std::{sync::Arc, str::FromStr};
-//! use temporal_sdk::{sdk_client_options, Worker, ActContext};
-//! use temporal_sdk_core::{init_worker, Url};
-//! use temporal_sdk_core_api::worker::{WorkerConfig, WorkerConfigBuilder};
+//! 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;
 //!
 //! #[tokio::main]
 //! async fn main() -> Result<(), Box<dyn std::error::Error>> {
 //!     let server_options = sdk_client_options(Url::from_str("http://localhost:7233")?).build()?;
-//!     let client = server_options.connect("my_namespace", None, None).await?;
-//!     let worker_config = WorkerConfigBuilder::default().build()?;
+//!
+//!     let client = server_options.connect("default", None, None).await?;
+//!
+//!     let telemetry_options = TelemetryOptionsBuilder::default().build()?;
+//!     telemetry_init(&telemetry_options)?;
+//!
+//!     let worker_config = WorkerConfigBuilder::default()
+//!         .namespace("default")
+//!         .task_queue("task_queue")
+//!         .build()?;
+//!
 //!     let core_worker = init_worker(worker_config, client);
 //!
 //!     let mut worker = Worker::new_from_core(Arc::new(core_worker), "task_queue");
@@ -25,7 +34,9 @@
 //!         "echo_activity",
 //!         |_ctx: ActContext, echo_me: String| async move { Ok(echo_me) },
 //!     );
+//!
 //!     worker.run().await?;
+//!
 //!     Ok(())
 //! }
 //! ```
@@ -34,6 +45,7 @@
 extern crate tracing;
 
 mod activity_context;
+mod app_data;
 mod conversions;
 pub mod interceptors;
 mod payload_converter;
@@ -51,9 +63,9 @@ use crate::{
     interceptors::WorkerInterceptor,
     workflow_context::{ChildWfCommon, PendingChildWorkflow},
 };
-use anyhow::{anyhow, bail};
+use anyhow::{anyhow, bail, Context};
+use app_data::AppData;
 use futures::{future::BoxFuture, FutureExt, StreamExt, TryFutureExt, TryStreamExt};
-use once_cell::sync::OnceCell;
 use std::{
     cell::RefCell,
     collections::HashMap,
@@ -72,7 +84,7 @@ use temporal_sdk_core_protos::{
         activity_result::{ActivityExecutionResult, ActivityResolution},
         activity_task::{activity_task, ActivityTask},
         child_workflow::ChildWorkflowResult,
-        common::{NamespacedWorkflowExecution, Payload},
+        common::NamespacedWorkflowExecution,
         workflow_activation::{
             resolve_child_workflow_execution_start::Status as ChildWorkflowStartStatus,
             workflow_activation_job::Variant, WorkflowActivation, WorkflowActivationJob,
@@ -81,7 +93,7 @@ use temporal_sdk_core_protos::{
         workflow_completion::WorkflowActivationCompletion,
         ActivityTaskCompletion, AsJsonPayloadExt, FromJsonPayloadExt,
     },
-    temporal::api::failure::v1::Failure,
+    temporal::api::{common::v1::Payload, failure::v1::Failure},
     TaskToken,
 };
 use tokio::{
@@ -103,8 +115,7 @@ pub fn sdk_client_options(url: impl Into<Url>) -> ClientOptionsBuilder {
     builder
         .target_url(url)
         .client_name("rust-sdk".to_string())
-        .client_version(VERSION.to_string())
-        .worker_binary_id(binary_id().to_string());
+        .client_version(VERSION.to_string());
 
     builder
 }
@@ -115,6 +126,7 @@ pub struct Worker {
     common: CommonWorker,
     workflow_half: WorkflowHalf,
     activity_half: ActivityHalf,
+    app_data: Option<AppData>,
 }
 
 struct CommonWorker {
@@ -146,8 +158,7 @@ struct ActivityHalf {
 }
 
 impl Worker {
-    #[doc(hidden)]
-    /// Create a new rust worker from a core worker
+    /// Create a new Rust SDK worker from a core worker
     pub fn new_from_core(worker: Arc<dyn CoreWorker>, task_queue: impl Into<String>) -> Self {
         Self {
             common: CommonWorker {
@@ -163,6 +174,7 @@ impl Worker {
                 activity_fns: Default::default(),
                 task_tokens_to_cancels: Default::default(),
             },
+            app_data: Some(Default::default()),
         }
     }
 
@@ -206,11 +218,21 @@ impl Worker {
         );
     }
 
+    /// Insert Custom App Context for Workflows and Activities
+    pub fn insert_app_data<T: Send + Sync + 'static>(&mut self, data: T) {
+        self.app_data.as_mut().map(|a| a.insert(data));
+    }
+
     /// Runs the worker. Eventually resolves after the worker has been explicitly shut down,
     /// or may return early with an error in the event of some unresolvable problem.
     pub async fn run(&mut self) -> Result<(), anyhow::Error> {
         let shutdown_token = CancellationToken::new();
-        let (common, wf_half, act_half) = self.split_apart();
+        let (common, wf_half, act_half, app_data) = self.split_apart();
+        let safe_app_data = Arc::new(
+            app_data
+                .take()
+                .ok_or_else(|| anyhow!("app_data should exist on run"))?,
+        );
         let (wf_future_tx, wf_future_rx) = unbounded_channel();
         let (completions_tx, completions_rx) = unbounded_channel();
         let wf_future_joiner = async {
@@ -225,15 +247,17 @@ impl Worker {
                         let wf_half = &*wf_half;
                         async move {
                             join_handle.await??;
+                            info!(run_id=%run_id, "Removing workflow from cache");
                             wf_half.workflows.borrow_mut().remove(&run_id);
                             Ok(())
                         }
                     },
                 )
                 .await
+                .context("Workflow futures encountered an error")
         };
         let wf_completion_processor = async {
-            let r = UnboundedReceiverStream::new(completions_rx)
+            UnboundedReceiverStream::new(completions_rx)
                 .map(Ok)
                 .try_for_each_concurrent(None, |completion| async {
                     if let Some(ref i) = common.worker_interceptor {
@@ -241,9 +265,9 @@ impl Worker {
                     }
                     common.worker.complete_workflow_activation(completion).await
                 })
-                .map_err(Into::into)
-                .await;
-            r
+                .map_err(anyhow::Error::from)
+                .await
+                .context("Workflow completions processor encountered an error")
         };
         tokio::try_join!(
             // Workflow polling loop
@@ -287,9 +311,12 @@ impl Worker {
                                 if matches!(activity, Err(PollActivityError::ShutDown)) {
                                     break;
                                 }
-                                act_half.activity_task_handler(common.worker.clone(),
-                                                               common.task_queue.clone(),
-                                                               activity?)?;
+                                act_half.activity_task_handler(
+                                    common.worker.clone(),
+                                    safe_app_data.clone(),
+                                    common.task_queue.clone(),
+                                    activity?
+                                )?;
                             },
                             _ = shutdown_token.cancelled() => { break }
                         }
@@ -306,6 +333,10 @@ impl Worker {
             i.on_shutdown(self);
         }
         self.common.worker.shutdown().await;
+        self.app_data = Some(
+            Arc::try_unwrap(safe_app_data)
+                .map_err(|_| anyhow!("some references of AppData exist on worker shutdown"))?,
+        );
         Ok(())
     }
 
@@ -327,11 +358,19 @@ impl Worker {
         self.workflow_half.workflows.borrow().len()
     }
 
-    fn split_apart(&mut self) -> (&mut CommonWorker, &mut WorkflowHalf, &mut ActivityHalf) {
+    fn split_apart(
+        &mut self,
+    ) -> (
+        &mut CommonWorker,
+        &mut WorkflowHalf,
+        &mut ActivityHalf,
+        &mut Option<AppData>,
+    ) {
         (
             &mut self.common,
             &mut self.workflow_half,
             &mut self.activity_half,
+            &mut self.app_data,
         )
     }
 }
@@ -398,7 +437,11 @@ impl WorkflowHalf {
                 .send(activation)
                 .expect("Workflow should exist if we're sending it an activation");
         } else {
-            bail!("Got activation for unknown workflow");
+            bail!(
+                "Got activation {:?} for unknown workflow {}",
+                activation,
+                run_id
+            );
         };
 
         Ok(res)
@@ -410,6 +453,7 @@ impl ActivityHalf {
     fn activity_task_handler(
         &mut self,
         worker: Arc<dyn CoreWorker>,
+        app_data: Arc<AppData>,
         task_queue: String,
         activity: ActivityTask,
     ) -> Result<(), anyhow::Error> {
@@ -430,8 +474,14 @@ impl ActivityHalf {
                 self.task_tokens_to_cancels
                     .insert(task_token.clone().into(), ct.clone());
 
-                let (ctx, arg) =
-                    ActContext::new(worker.clone(), ct, task_queue, task_token.clone(), start);
+                let (ctx, arg) = ActContext::new(
+                    worker.clone(),
+                    app_data,
+                    ct,
+                    task_queue,
+                    task_token.clone(),
+                    start,
+                );
                 tokio::spawn(async move {
                     let output = (act_fn.act_func)(ctx, arg).await;
                     let result = match output {
@@ -713,20 +763,3 @@ where
         Arc::new(wrapper)
     }
 }
-
-/// Reads own binary, hashes it, and returns b64 str version of that hash
-fn binary_id() -> &'static str {
-    use sha2::{Digest, Sha256};
-    use std::{env, fs, io};
-
-    static INSTANCE: OnceCell<String> = OnceCell::new();
-    INSTANCE.get_or_init(|| {
-        let exe_path = env::current_exe().expect("Cannot read own binary to determine binary id");
-        let mut exe_file =
-            fs::File::open(exe_path).expect("Cannot read own binary to determine binary id");
-        let mut hasher = Sha256::new();
-        io::copy(&mut exe_file, &mut hasher).expect("Copying data into binary hasher works");
-        let hash = hasher.finalize();
-        base64::encode(hash)
-    })
-}

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

@@ -1,11 +1,13 @@
 use std::{collections::HashMap, time::Duration};
-use temporal_sdk_core_protos::coresdk::{
-    child_workflow::ChildWorkflowCancellationType,
-    common::{Payload, RetryPolicy},
-    workflow_commands::{
-        ActivityCancellationType, ScheduleActivity, ScheduleLocalActivity,
-        StartChildWorkflowExecution,
+use temporal_sdk_core_protos::{
+    coresdk::{
+        child_workflow::ChildWorkflowCancellationType,
+        workflow_commands::{
+            ActivityCancellationType, ScheduleActivity, ScheduleLocalActivity,
+            StartChildWorkflowExecution,
+        },
     },
+    temporal::api::common::v1::{Payload, RetryPolicy},
 };
 
 // TODO: Before release, probably best to avoid using proto types entirely here. They're awkward.

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

@@ -25,17 +25,20 @@ use std::{
     task::Poll,
     time::{Duration, SystemTime},
 };
-use temporal_sdk_core_protos::coresdk::{
-    activity_result::{activity_resolution, ActivityResolution},
-    child_workflow::ChildWorkflowResult,
-    common::{NamespacedWorkflowExecution, Payload},
-    workflow_activation::resolve_child_workflow_execution_start::Status as ChildWorkflowStartStatus,
-    workflow_commands::{
-        request_cancel_external_workflow_execution as cancel_we,
-        signal_external_workflow_execution as sig_we, workflow_command,
-        RequestCancelExternalWorkflowExecution, SetPatchMarker, SignalExternalWorkflowExecution,
-        StartTimer, UpsertWorkflowSearchAttributes,
+use temporal_sdk_core_protos::{
+    coresdk::{
+        activity_result::{activity_resolution, ActivityResolution},
+        child_workflow::ChildWorkflowResult,
+        common::NamespacedWorkflowExecution,
+        workflow_activation::resolve_child_workflow_execution_start::Status as ChildWorkflowStartStatus,
+        workflow_commands::{
+            request_cancel_external_workflow_execution as cancel_we,
+            signal_external_workflow_execution as sig_we, workflow_command,
+            RequestCancelExternalWorkflowExecution, SetPatchMarker,
+            SignalExternalWorkflowExecution, StartTimer, UpsertWorkflowSearchAttributes,
+        },
     },
+    temporal::api::common::v1::Payload,
 };
 use tokio::sync::{mpsc, oneshot, watch};
 use tokio_stream::wrappers::UnboundedReceiverStream;
@@ -59,7 +62,6 @@ struct WfCtxProtectedDat {
     next_child_workflow_sequence_number: u32,
     next_cancel_external_wf_sequence_number: u32,
     next_signal_external_wf_sequence_number: u32,
-    next_upsert_search_attrs_sequence_number: u32,
 }
 
 impl WfCtxProtectedDat {
@@ -88,11 +90,6 @@ impl WfCtxProtectedDat {
         self.next_signal_external_wf_sequence_number += 1;
         seq
     }
-    fn next_upsert_search_attrs_wf_seq(&mut self) -> u32 {
-        let seq = self.next_upsert_search_attrs_sequence_number;
-        self.next_upsert_search_attrs_sequence_number += 1;
-        seq
-    }
 }
 
 #[derive(Clone, Debug, Default)]
@@ -130,7 +127,6 @@ impl WfContext {
                     next_child_workflow_sequence_number: 1,
                     next_cancel_external_wf_sequence_number: 1,
                     next_signal_external_wf_sequence_number: 1,
-                    next_upsert_search_attrs_sequence_number: 1,
                 }),
             },
             rx,
@@ -289,9 +285,8 @@ impl WfContext {
     /// Add or create a set of search attributes
     pub fn upsert_search_attributes(&self, attr_iter: impl IntoIterator<Item = (String, Payload)>) {
         self.send(RustWfCmd::NewNonblockingCmd(
-            workflow_command::Variant::UpsertWorkflowSearchAttributesCommandAttributes(
+            workflow_command::Variant::UpsertWorkflowSearchAttributes(
                 UpsertWorkflowSearchAttributes {
-                    seq: self.seq_nums.write().next_upsert_search_attrs_wf_seq(),
                     search_attributes: HashMap::from_iter(attr_iter.into_iter()),
                 },
             ),

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

@@ -17,7 +17,6 @@ use std::{
 };
 use temporal_sdk_core_protos::{
     coresdk::{
-        common::Payload,
         workflow_activation::{
             workflow_activation_job::Variant, FireTimer, NotifyHasPatch, ResolveActivity,
             ResolveChildWorkflowExecution, ResolveChildWorkflowExecutionStart, WorkflowActivation,
@@ -33,7 +32,7 @@ use temporal_sdk_core_protos::{
         },
         workflow_completion::WorkflowActivationCompletion,
     },
-    temporal::api::failure::v1::Failure,
+    temporal::api::{common::v1::Payload, failure::v1::Failure},
     utilities::TryIntoOrNone,
 };
 use tokio::sync::{
@@ -123,11 +122,10 @@ impl WorkflowFuture {
             UnblockEvent::CancelExternal(seq, _) => CommandID::CancelExternal(seq),
         };
         let unblocker = self.command_status.remove(&cmd_id);
-        unblocker
+        let _ = unblocker
             .ok_or_else(|| anyhow!("Command {:?} not found to unblock!", cmd_id))?
             .unblocker
-            .send(event)
-            .expect("Receive half of unblock channel must exist");
+            .send(event);
         Ok(())
     }
 
@@ -238,7 +236,14 @@ impl Future for WorkflowFuture {
         'activations: loop {
             // WF must always receive an activation first before responding with commands
             let activation = match self.incoming_activations.poll_recv(cx) {
-                Poll::Ready(a) => a.expect("activation channel not dropped"),
+                Poll::Ready(a) => match a {
+                    Some(act) => act,
+                    None => {
+                        return Poll::Ready(Err(anyhow!(
+                            "Workflow future's activation channel was lost!"
+                        )))
+                    }
+                },
                 Poll::Pending => return Poll::Pending,
             };
 

package/sdk-core/sdk-core-protos/src/history_builder.rs

@@ -3,7 +3,7 @@ use crate::{
     coresdk::{
         common::{
             build_has_change_marker_details, build_local_activity_marker_details,
-            NamespacedWorkflowExecution, Payload as CorePayload,
+            NamespacedWorkflowExecution,
         },
         external_data::LocalActivityMarkerData,
         IntoPayloadsExt,
@@ -116,6 +116,20 @@ impl TestHistoryBuilder {
         self.build_and_push_event(EventType::WorkflowExecutionCompleted, attrs.into());
     }
 
+    pub fn add_workflow_execution_terminated(&mut self) {
+        let attrs = WorkflowExecutionTerminatedEventAttributes {
+            ..Default::default()
+        };
+        self.build_and_push_event(EventType::WorkflowExecutionTerminated, attrs.into());
+    }
+
+    pub fn add_workflow_execution_timed_out(&mut self) {
+        let attrs = WorkflowExecutionTimedOutEventAttributes {
+            ..Default::default()
+        };
+        self.build_and_push_event(EventType::WorkflowExecutionTimedOut, attrs.into());
+    }
+
     pub fn add_workflow_execution_failed(&mut self) {
         let attrs = WorkflowExecutionFailedEventAttributes {
             workflow_task_completed_event_id: self.previous_task_completed_id,
@@ -170,7 +184,7 @@ impl TestHistoryBuilder {
         &mut self,
         scheduled_event_id: i64,
         started_event_id: i64,
-        payload: CorePayload,
+        payload: Payload,
     ) {
         self.add(
             EventType::ActivityTaskCompleted,
@@ -254,7 +268,7 @@ impl TestHistoryBuilder {
         &mut self,
         seq: u32,
         activity_id: &str,
-        payload: Option<CorePayload>,
+        payload: Option<Payload>,
         failure: Option<Failure>,
         complete_time: Option<Timestamp>,
     ) {
@@ -283,7 +297,7 @@ impl TestHistoryBuilder {
         &mut self,
         seq: u32,
         activity_id: &str,
-        payload: CorePayload,
+        payload: Payload,
     ) {
         self.add_local_activity_marker(seq, activity_id, Some(payload), None, None);
     }
@@ -292,7 +306,7 @@ impl TestHistoryBuilder {
         &mut self,
         seq: u32,
         activity_id: &str,
-        payload: CorePayload,
+        payload: Payload,
         complete_time: Timestamp,
     ) {
         self.add_local_activity_marker(seq, activity_id, Some(payload), None, Some(complete_time));

package/sdk-core/sdk-core-protos/src/history_info.rs

@@ -60,9 +60,14 @@ impl HistoryInfo {
                 let next_is_completed = next_event.map_or(false, |ne| {
                     ne.event_type == EventType::WorkflowTaskCompleted as i32
                 });
-                let next_is_failed_or_timeout = next_event.map_or(false, |ne| {
-                    ne.event_type == EventType::WorkflowTaskFailed as i32
-                        || ne.event_type == EventType::WorkflowTaskTimedOut as i32
+                let next_is_failed_or_timeout_or_term = next_event.map_or(false, |ne| {
+                    matches!(
+                        ne.event_type(),
+                        EventType::WorkflowTaskFailed
+                            | EventType::WorkflowTaskTimedOut
+                            | EventType::WorkflowExecutionTerminated
+                            | EventType::WorkflowExecutionTimedOut
+                    )
                 });
 
                 if next_event.is_none() || next_is_completed {
@@ -84,10 +89,10 @@ impl HistoryInfo {
                             wf_type,
                         });
                     }
-                } else if next_event.is_some() && !next_is_failed_or_timeout {
+                } else if next_event.is_some() && !next_is_failed_or_timeout_or_term {
                     bail!(
-                        "Invalid history! Event {event:?} should be WFT \
-                           completed, failed, or timed out"
+                        "Invalid history! Event {next_event:?} should be WFT \
+                           completed, failed, or timed out - or WE terminated."
                     );
                 }
             }