@temporalio/core-bridge 1.4.4 → 1.5.1

package/sdk-core/protos/api_upstream/temporal/api/workflowservice/v1/service.proto

@@ -256,6 +256,17 @@ service WorkflowService {
     rpc TerminateWorkflowExecution (TerminateWorkflowExecutionRequest) returns (TerminateWorkflowExecutionResponse) {
     }
 
+    // DeleteWorkflowExecution asynchronously deletes a specific Workflow Execution (when
+    // WorkflowExecution.run_id is provided) or the latest Workflow Execution (when
+    // WorkflowExecution.run_id is not provided). If the Workflow Execution is Running, it will be
+    // terminated before deletion.
+    // (-- api-linter: core::0135::method-signature=disabled
+    //     aip.dev/not-precedent: DeleteNamespace RPC doesn't follow Google API format. --)
+    // (-- api-linter: core::0135::response-message-name=disabled
+    //     aip.dev/not-precedent: DeleteNamespace RPC doesn't follow Google API format. --)
+    rpc DeleteWorkflowExecution (DeleteWorkflowExecutionRequest) returns (DeleteWorkflowExecutionResponse) {
+    }
+
     // ListOpenWorkflowExecutions is a visibility API to list the open executions in a specific namespace.
     rpc ListOpenWorkflowExecutions (ListOpenWorkflowExecutionsRequest) returns (ListOpenWorkflowExecutionsResponse) {
     }
@@ -369,12 +380,15 @@ service WorkflowService {
     rpc ListSchedules (ListSchedulesRequest) returns (ListSchedulesResponse) {
     }
 
+    // Allows users to specify a graph of worker build id based versions on a
+    // per task queue basis. Versions are ordered, and may be either compatible
+    // with some extant version, or a new incompatible version.
     // (-- api-linter: core::0134::response-message-name=disabled
     //     aip.dev/not-precedent: UpdateWorkerBuildIdOrdering RPC doesn't follow Google API format. --)
     // (-- api-linter: core::0134::method-signature=disabled
     //     aip.dev/not-precedent: UpdateWorkerBuildIdOrdering RPC doesn't follow Google API format. --)
     rpc UpdateWorkerBuildIdOrdering (UpdateWorkerBuildIdOrderingRequest) returns (UpdateWorkerBuildIdOrderingResponse) {}
-    // This could / maybe should just be part of `DescribeTaskQueue`, but is broken out here to show easily.
+    // Fetches the worker build id versioning graph for some task queue.
     rpc GetWorkerBuildIdOrdering (GetWorkerBuildIdOrderingRequest) returns (GetWorkerBuildIdOrderingResponse) {}
 
     // Invokes the specified update function on user workflow code.

package/sdk-core/protos/local/temporal/sdk/core/workflow_activation/workflow_activation.proto

@@ -119,6 +119,8 @@ message StartWorkflow {
     temporal.api.common.v1.Memo memo = 21;
     // Search attributes created/updated when this workflow was started
     temporal.api.common.v1.SearchAttributes search_attributes = 22;
+    // When the workflow execution started event was first written
+    google.protobuf.Timestamp start_time = 23;
 }
 
 /// Notify a workflow that a timer has fired

package/sdk-core/protos/local/temporal/sdk/core/workflow_commands/workflow_commands.proto

@@ -35,6 +35,7 @@ message WorkflowCommand {
         ScheduleLocalActivity schedule_local_activity = 16;
         RequestCancelLocalActivity request_cancel_local_activity = 17;
         UpsertWorkflowSearchAttributes upsert_workflow_search_attributes = 18;
+        ModifyWorkflowProperties modify_workflow_properties = 19;
     }
 }
 
@@ -54,7 +55,6 @@ message ScheduleActivity {
     uint32 seq = 1;
     string activity_id = 2;
     string activity_type = 3;
-    string namespace = 4;
     // The name of the task queue to place this activity request in
     string task_queue = 5;
     map<string, temporal.api.common.v1.Payload> headers = 6;
@@ -295,3 +295,10 @@ message UpsertWorkflowSearchAttributes {
     /// value?
     map<string, temporal.api.common.v1.Payload> search_attributes = 1;
 }
+
+message ModifyWorkflowProperties {
+    // If set, update the workflow memo with the provided values. The values will be merged with
+    // the existing memo. If the user wants to delete values, a default/empty Payload should be
+    // used as the value for the key being deleted.
+    temporal.api.common.v1.Memo upserted_memo = 1;
+}

package/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(())
+    }
 }

package/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(
@@ -279,6 +279,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(),

package/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();

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

@@ -10,9 +10,10 @@ use crate::{
     },
     temporal::api::{
         common::v1::{Payload, Payloads, WorkflowExecution, WorkflowType},
-        enums::v1::{EventType, WorkflowTaskFailedCause},
+        enums::v1::{EventType, TaskQueueKind, WorkflowTaskFailedCause},
         failure::v1::{failure, CanceledFailureInfo, Failure},
         history::v1::{history_event::Attributes, *},
+        taskqueue::v1::TaskQueue,
     },
     HistoryInfo,
 };
@@ -38,6 +39,27 @@ pub struct TestHistoryBuilder {
 }
 
 impl TestHistoryBuilder {
+    pub fn from_history(events: Vec<HistoryEvent>) -> Self {
+        let find_matching_id = |etype: EventType| {
+            events
+                .iter()
+                .rev()
+                .find(|e| e.event_type() == etype)
+                .map(|e| e.event_id)
+                .unwrap_or_default()
+        };
+        Self {
+            current_event_id: events.last().map(|e| e.event_id).unwrap_or_default(),
+            workflow_task_scheduled_event_id: find_matching_id(EventType::WorkflowTaskScheduled),
+            final_workflow_task_started_event_id: find_matching_id(EventType::WorkflowTaskStarted),
+            previous_task_completed_id: find_matching_id(EventType::WorkflowTaskCompleted),
+            original_run_id: extract_original_run_id_from_events(&events)
+                .expect("Run id must be discoverable")
+                .to_string(),
+            events,
+        }
+    }
+
     /// Add an event by type with attributes. Bundles both into a [HistoryEvent] with an id that is
     /// incremented on each call to add.
     pub fn add(&mut self, event_type: EventType, attribs: Attributes) {
@@ -450,6 +472,26 @@ impl TestHistoryBuilder {
             .unwrap()
     }
 
+    /// Alter the workflow type of the history
+    pub fn set_wf_type(&mut self, name: &str) {
+        if let Some(Attributes::WorkflowExecutionStartedEventAttributes(wes)) =
+            self.events.get_mut(0).and_then(|e| e.attributes.as_mut())
+        {
+            wes.workflow_type = Some(WorkflowType {
+                name: name.to_string(),
+            })
+        }
+    }
+
+    /// Alter some specific event. You can easily craft nonsense histories this way, use carefully.
+    pub fn modify_event(&mut self, event_id: i64, modifier: impl FnOnce(&mut HistoryEvent)) {
+        let he = self
+            .events
+            .get_mut((event_id - 1) as usize)
+            .expect("Event must be present");
+        modifier(he);
+    }
+
     fn build_and_push_event(&mut self, event_type: EventType, attribs: Attributes) {
         self.current_event_id += 1;
         let evt = HistoryEvent {
@@ -492,6 +534,10 @@ pub fn default_wes_attribs() -> WorkflowExecutionStartedEventAttributes {
                 .try_into()
                 .expect("5 secs is a valid duration"),
         ),
+        task_queue: Some(TaskQueue {
+            name: "q".to_string(),
+            kind: TaskQueueKind::Normal as i32,
+        }),
         ..Default::default()
     }
 }

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

@@ -1,7 +1,7 @@
 use crate::temporal::api::{
     common::v1::WorkflowType,
     enums::v1::{EventType, TaskQueueKind},
-    history::v1::{history_event, History, HistoryEvent},
+    history::v1::{history_event, History, HistoryEvent, WorkflowExecutionStartedEventAttributes},
     taskqueue::v1::TaskQueue,
     workflowservice::v1::{GetWorkflowExecutionHistoryResponse, PollWorkflowTaskQueueResponse},
 };
@@ -18,6 +18,7 @@ pub struct HistoryInfo {
     events: Vec<HistoryEvent>,
     wf_task_count: usize,
     wf_type: String,
+    wf_exe_started_attrs: WorkflowExecutionStartedEventAttributes,
 }
 
 type Result<T, E = anyhow::Error> = std::result::Result<T, E>;
@@ -36,20 +37,18 @@ impl HistoryInfo {
         let mut workflow_task_started_event_id = 0;
         let mut wf_task_count = 0;
         let mut history = events.iter().peekable();
-
-        let wf_type = match &events.get(0).unwrap().attributes {
+        let started_attrs = match &events.get(0).unwrap().attributes {
             Some(history_event::Attributes::WorkflowExecutionStartedEventAttributes(attrs)) => {
-                attrs
-                    .workflow_type
-                    .as_ref()
-                    .ok_or_else(|| {
-                        anyhow!("No workflow type defined in execution started attributes")
-                    })?
-                    .name
-                    .clone()
+                attrs.clone()
             }
             _ => bail!("First event in history was not workflow execution started!"),
         };
+        let wf_type = started_attrs
+            .workflow_type
+            .as_ref()
+            .ok_or_else(|| anyhow!("No workflow type defined in execution started attributes"))?
+            .name
+            .clone();
 
         let mut events = vec![];
         while let Some(event) = history.next() {
@@ -87,6 +86,7 @@ impl HistoryInfo {
                             events,
                             wf_task_count,
                             wf_type,
+                            wf_exe_started_attrs: started_attrs,
                         });
                     }
                 } else if next_event.is_some() && !next_is_failed_or_timeout_or_term {
@@ -108,6 +108,7 @@ impl HistoryInfo {
                         events,
                         wf_task_count,
                         wf_type,
+                        wf_exe_started_attrs: started_attrs,
                     });
                 }
                 // No more events
@@ -135,16 +136,9 @@ impl HistoryInfo {
         &self.events
     }
 
-    /// Attempt to extract run id from internal events. If the first event is not workflow execution
-    /// started, it will panic.
+    /// Extract run id from the workflow execution started attributes.
     pub fn orig_run_id(&self) -> &str {
-        if let Some(history_event::Attributes::WorkflowExecutionStartedEventAttributes(wes)) =
-            &self.events[0].attributes
-        {
-            &wes.original_execution_run_id
-        } else {
-            panic!("First event is wrong type")
-        }
+        &self.wf_exe_started_attrs.original_execution_run_id
     }
 
     /// Return total workflow task count in this history
@@ -155,7 +149,7 @@ impl HistoryInfo {
     /// Create a workflow task polling response containing all the events in this history and a
     /// randomly generated task token. Caller should attach a meaningful `workflow_execution` if
     /// needed.
-    pub fn as_poll_wft_response(&self, task_q: impl Into<String>) -> PollWorkflowTaskQueueResponse {
+    pub fn as_poll_wft_response(&self) -> PollWorkflowTaskQueueResponse {
         let task_token: [u8; 16] = thread_rng().gen();
         PollWorkflowTaskQueueResponse {
             history: Some(History {
@@ -166,7 +160,13 @@ impl HistoryInfo {
                 name: self.wf_type.clone(),
             }),
             workflow_execution_task_queue: Some(TaskQueue {
-                name: task_q.into(),
+                name: self
+                    .wf_exe_started_attrs
+                    .task_queue
+                    .as_ref()
+                    .unwrap()
+                    .name
+                    .clone(),
                 kind: TaskQueueKind::Normal as i32,
             }),
             previous_started_event_id: self.previous_started_event_id,

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

@@ -66,7 +66,7 @@ pub mod coresdk {
                     "ActivityTaskCompletion(token: {}",
                     fmt_tt(&self.task_token),
                 )?;
-                if let Some(r) = self.result.as_ref() {
+                if let Some(r) = self.result.as_ref().and_then(|r| r.status.as_ref()) {
                     write!(f, ", {}", r)?;
                 } else {
                     write!(f, ", missing result")?;
@@ -120,21 +120,20 @@ pub mod coresdk {
             }
         }
 
-        impl Display for ActivityExecutionResult {
+        impl Display for aer::Status {
             fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
                 write!(f, "ActivityExecutionResult(")?;
-                match self.status.as_ref() {
-                    None => write!(f, "missing result)"),
-                    Some(aer::Status::Completed(v)) => {
+                match self {
+                    aer::Status::Completed(v) => {
                         write!(f, "{})", v)
                     }
-                    Some(aer::Status::Failed(v)) => {
+                    aer::Status::Failed(v) => {
                         write!(f, "{})", v)
                     }
-                    Some(aer::Status::Cancelled(v)) => {
+                    aer::Status::Cancelled(v) => {
                         write!(f, "{})", v)
                     }
-                    Some(aer::Status::WillCompleteAsync(_)) => {
+                    aer::Status::WillCompleteAsync(_) => {
                         write!(f, "Will complete async)")
                     }
                 }
@@ -405,6 +404,7 @@ pub mod coresdk {
                 query::v1::WorkflowQuery,
             },
         };
+        use prost_types::Timestamp;
         use std::{
             collections::HashMap,
             fmt::{Display, Formatter},
@@ -600,6 +600,7 @@ pub mod coresdk {
             attrs: WorkflowExecutionStartedEventAttributes,
             workflow_id: String,
             randomness_seed: u64,
+            start_time: Timestamp,
         ) -> StartWorkflow {
             StartWorkflow {
                 workflow_type: attrs.workflow_type.map(|wt| wt.name).unwrap_or_default(),
@@ -633,6 +634,7 @@ pub mod coresdk {
                 cron_schedule_to_schedule_interval: attrs.first_workflow_task_backoff,
                 memo: attrs.memo,
                 search_attributes: attrs.search_attributes,
+                start_time: Some(start_time),
             }
         }
     }
@@ -800,6 +802,16 @@ pub mod coresdk {
             }
         }
 
+        impl Display for ModifyWorkflowProperties {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(
+                    f,
+                    "ModifyWorkflowProperties(upserted memo keys: {:?})",
+                    self.upserted_memo.as_ref().map(|m| m.fields.keys())
+                )
+            }
+        }
+
         impl QueryResult {
             /// Helper to construct the Temporal API query result types.
             pub fn into_components(self) -> (String, QueryResultType, Option<Payloads>, String) {
@@ -1320,11 +1332,6 @@ pub mod coresdk {
 // This is disgusting, but unclear to me how to avoid it. TODO: Discuss w/ prost maintainer
 pub mod temporal {
     pub mod api {
-        pub mod cluster {
-            pub mod v1 {
-                tonic::include_proto!("temporal.api.cluster.v1");
-            }
-        }
         pub mod batch {
             pub mod v1 {
                 tonic::include_proto!("temporal.api.batch.v1");
@@ -1414,6 +1421,16 @@ pub mod temporal {
                     }
                 }
 
+                impl From<workflow_commands::ModifyWorkflowProperties> for command::Attributes {
+                    fn from(s: workflow_commands::ModifyWorkflowProperties) -> Self {
+                        Self::ModifyWorkflowPropertiesCommandAttributes(
+                            ModifyWorkflowPropertiesCommandAttributes {
+                                upserted_memo: s.upserted_memo.map(Into::into),
+                            },
+                        )
+                    }
+                }
+
                 impl From<workflow_commands::CancelTimer> for command::Attributes {
                     fn from(s: workflow_commands::CancelTimer) -> Self {
                         Self::CancelTimerCommandAttributes(CancelTimerCommandAttributes {
@@ -1647,14 +1664,7 @@ pub mod temporal {
 
                 impl History {
                     pub fn extract_run_id_from_start(&self) -> Result<&str, anyhow::Error> {
-                        if let Some(
-                            history_event::Attributes::WorkflowExecutionStartedEventAttributes(wes),
-                        ) = self.events.get(0).and_then(|x| x.attributes.as_ref())
-                        {
-                            Ok(&wes.original_execution_run_id)
-                        } else {
-                            bail!("First event is not WorkflowExecutionStarted?!?")
-                        }
+                        extract_original_run_id_from_events(&self.events)
                     }
 
                     /// Returns the event id of the final event in the history. Will return 0 if
@@ -1664,6 +1674,18 @@ pub mod temporal {
                     }
                 }
 
+                pub fn extract_original_run_id_from_events(
+                    events: &[HistoryEvent],
+                ) -> Result<&str, anyhow::Error> {
+                    if let Some(Attributes::WorkflowExecutionStartedEventAttributes(wes)) =
+                        events.get(0).and_then(|x| x.attributes.as_ref())
+                    {
+                        Ok(&wes.original_execution_run_id)
+                    } else {
+                        bail!("First event is not WorkflowExecutionStarted?!?")
+                    }
+                }
+
                 impl HistoryEvent {
                     /// Returns true if this is an event created to mirror a command
                     pub fn is_command_event(&self) -> bool {
@@ -1820,12 +1842,12 @@ pub mod temporal {
                 tonic::include_proto!("temporal.api.workflowservice.v1");
 
                 macro_rules! sched_to_start_impl {
-                    () => {
-                        /// Return the duration of the task schedule time to its start time if both
-                        /// are set and time went forward.
+                    ($sched_field:ident) => {
+                        /// Return the duration of the task schedule time (current attempt) to its
+                        /// start time if both are set and time went forward.
                         pub fn sched_to_start(&self) -> Option<Duration> {
                             if let Some((sch, st)) =
-                                self.scheduled_time.clone().zip(self.started_time.clone())
+                                self.$sched_field.clone().zip(self.started_time.clone())
                             {
                                 let sch: Result<SystemTime, _> = sch.try_into();
                                 let st: Result<SystemTime, _> = st.try_into();
@@ -1839,7 +1861,7 @@ pub mod temporal {
                 }
 
                 impl PollWorkflowTaskQueueResponse {
-                    sched_to_start_impl!();
+                    sched_to_start_impl!(scheduled_time);
                 }
 
                 impl Display for PollWorkflowTaskQueueResponse {
@@ -1881,7 +1903,7 @@ pub mod temporal {
                 }
 
                 impl PollActivityTaskQueueResponse {
-                    sched_to_start_impl!();
+                    sched_to_start_impl!(current_attempt_scheduled_time);
                 }
 
                 impl QueryWorkflowResponse {

package/sdk-core/test-utils/Cargo.toml

@@ -14,6 +14,7 @@ async-trait = "0.1"
 base64 = "0.13"
 futures = "0.3"
 log = "0.4"
+once_cell = "1.16"
 parking_lot = "0.12"
 prost = "0.11"
 prost-types = "0.11"