@temporalio/core-bridge 1.13.2 → 1.14.0

package/sdk-core/{core → crates/sdk-core}/src/worker/workflow/machines/workflow_machines.rs

@@ -25,7 +25,7 @@ use crate::{
         workflow::{
             CommandID, DrivenWorkflow, HistoryUpdate, InternalFlagsRef, LocalResolution,
             OutgoingJob, RunBasics, WFCommand, WFCommandVariant, WFMachinesError,
-            WorkflowStartedInfo,
+            WorkflowStartedInfo, fatal,
             history_update::NextWFT,
             machines::{
                 HistEventData, activity_state_machine::ActivityMachine,
@@ -35,6 +35,7 @@ use crate::{
                 update_state_machine::UpdateMachine,
                 upsert_search_attributes_state_machine::upsert_search_attrs_internal,
             },
+            nondeterminism,
         },
     },
 };
@@ -51,25 +52,27 @@ use std::{
     sync::Arc,
     time::{Duration, Instant, SystemTime},
 };
-use temporal_sdk_core_api::worker::{WorkerConfig, WorkerDeploymentVersion};
-use temporal_sdk_core_protos::{
-    VERSION_SEARCH_ATTR_KEY,
-    coresdk::{
-        common::{NamespacedWorkflowExecution, VersioningIntent},
-        workflow_activation::{
-            self, NotifyHasPatch, UpdateRandomSeed, WorkflowActivation, workflow_activation_job,
+use temporalio_common::{
+    protos::{
+        VERSION_SEARCH_ATTR_KEY,
+        coresdk::{
+            common::{NamespacedWorkflowExecution, VersioningIntent},
+            workflow_activation::{
+                self, NotifyHasPatch, UpdateRandomSeed, WorkflowActivation, workflow_activation_job,
+            },
+            workflow_commands::ContinueAsNewWorkflowExecution,
         },
-        workflow_commands::ContinueAsNewWorkflowExecution,
-    },
-    temporal::api::{
-        command::v1::{
-            Command as ProtoCommand, CommandAttributesExt, command::Attributes as ProtoCmdAttrs,
+        temporal::api::{
+            command::v1::{
+                Command as ProtoCommand, CommandAttributesExt, command::Attributes as ProtoCmdAttrs,
+            },
+            enums::v1::EventType,
+            history::v1::{HistoryEvent, history_event},
+            protocol::v1::{Message as ProtocolMessage, message::SequencingId},
+            sdk::v1::{UserMetadata, WorkflowTaskCompletedMetadata},
         },
-        enums::v1::EventType,
-        history::v1::{HistoryEvent, history_event},
-        protocol::v1::{Message as ProtocolMessage, message::SequencingId},
-        sdk::v1::{UserMetadata, WorkflowTaskCompletedMetadata},
     },
+    worker::{WorkerConfig, WorkerDeploymentVersion},
 };
 
 type Result<T, E = WFMachinesError> = std::result::Result<T, E>;
@@ -244,11 +247,11 @@ macro_rules! cancel_machine {
         let machine = if let Machines::$machine_variant(m) = $self.machine_mut(m_key) {
             m
         } else {
-            return Err(WFMachinesError::Nondeterminism(format!(
+            return Err(nondeterminism!(
                 "Machine was not a {} when it should have been during cancellation: {:?}",
                 stringify!($machine_variant),
                 $cmd_id
-            )));
+            ));
         };
         let machine_resps = machine.$cancel_method($($args),*)?;
         $self.process_machine_responses(m_key, machine_resps)?
@@ -364,10 +367,10 @@ impl WorkflowMachines {
                     }
                     self.process_machine_responses(mk, resps)?;
                 } else {
-                    return Err(WFMachinesError::Nondeterminism(format!(
+                    return Err(nondeterminism!(
                         "Command matching activity with seq num {seq} existed but was not a \
                         local activity!"
-                    )));
+                    ));
                 }
                 self.local_activity_data.done_executing(seq);
             }
@@ -571,10 +574,9 @@ impl WorkflowMachines {
                 (evts, has_final_event)
             }
             NextWFT::NeedFetch => {
-                return Err(WFMachinesError::Fatal(
+                return Err(fatal!(
                     "Need to fetch history events to continue applying workflow task, but this \
                      should be prevented ahead of time! This is a Core SDK bug."
-                        .to_string(),
                 ));
             }
         };
@@ -647,10 +649,11 @@ impl WorkflowMachines {
         while let Some(event) = history.next() {
             let eid = event.event_id;
             if eid != self.last_processed_event + 1 {
-                return Err(WFMachinesError::Fatal(format!(
+                return Err(fatal!(
                     "History is out of order. Last processed event: {}, event id: {}",
-                    self.last_processed_event, eid
-                )));
+                    self.last_processed_event,
+                    eid
+                ));
             }
             let next_event = history.peek();
 
@@ -780,9 +783,7 @@ impl WorkflowMachines {
                         self.local_activity_data.insert_peeked_marker(la_dat);
                     }
                 } else {
-                    return Err(WFMachinesError::Fatal(format!(
-                        "Local activity marker was unparsable: {e:?}"
-                    )));
+                    return Err(fatal!("Local activity marker was unparsable: {e:?}"));
                 }
             } else if let Some(
                 history_event::Attributes::WorkflowExecutionUpdateAcceptedEventAttributes(ref atts),
@@ -854,10 +855,9 @@ impl WorkflowMachines {
             let are_more_events =
                 next_event.is_some() || !event_dat.current_task_is_last_in_history;
             return if are_more_events {
-                Err(WFMachinesError::Fatal(
+                Err(fatal!(
                     "Machines were fed a history which has an event after workflow execution was \
                      terminated!"
-                        .to_string(),
                 ))
             } else {
                 Ok(EventHandlingOutcome::Normal)
@@ -865,9 +865,9 @@ impl WorkflowMachines {
         }
         if event.event_type() == EventType::Unspecified || event.attributes.is_none() {
             return if !event.worker_may_ignore {
-                Err(WFMachinesError::Fatal(format!(
+                Err(fatal!(
                     "Event type is unspecified! This history is invalid. Event detail: {event:?}"
-                )))
+                ))
             } else {
                 debug!("Event is ignorable");
                 Ok(EventHandlingOutcome::SkipEvent {
@@ -892,10 +892,10 @@ impl WorkflowMachines {
                 .machines_by_event_id
                 .get(&initial_cmd_id)
                 .ok_or_else(|| {
-                    WFMachinesError::Nondeterminism(format!(
+                    nondeterminism!(
                         "During event handling, this event had an initial command ID but we \
                          could not find a matching command for it: {event:?}"
-                    ))
+                    )
                 })?;
             self.submachine_handle_event(*mkey, event_dat)?;
         } else {
@@ -922,9 +922,9 @@ impl WorkflowMachines {
         let event = &event_dat.event;
 
         if event.is_local_activity_marker() {
-            let deets = event.extract_local_activity_marker_data().ok_or_else(|| {
-                WFMachinesError::Fatal(format!("Local activity marker was unparsable: {event:?}"))
-            })?;
+            let deets = event
+                .extract_local_activity_marker_data()
+                .ok_or_else(|| fatal!("Local activity marker was unparsable: {event:?}"))?;
             let cmdid = CommandID::LocalActivity(deets.seq);
             let mkey = self.get_machine_key(cmdid)?;
             if let Machines::LocalActivityMachine(lam) = self.machine(mkey) {
@@ -933,10 +933,10 @@ impl WorkflowMachines {
                     return Ok(EventHandlingOutcome::Normal);
                 }
             } else {
-                return Err(WFMachinesError::Fatal(format!(
+                return Err(fatal!(
                     "Encountered local activity marker but the associated machine was of the \
                      wrong type! {event:?}"
-                )));
+                ));
             }
         }
 
@@ -957,9 +957,7 @@ impl WorkflowMachines {
             let command = if let Some(c) = maybe_command {
                 c
             } else {
-                return Err(WFMachinesError::Nondeterminism(format!(
-                    "No command scheduled for event {event}"
-                )));
+                return Err(nondeterminism!("No command scheduled for event {event}"));
             };
 
             let canceled_before_sent = self
@@ -1006,9 +1004,9 @@ impl WorkflowMachines {
                         attrs,
                     );
                 } else {
-                    return Err(WFMachinesError::Fatal(format!(
+                    return Err(fatal!(
                         "WorkflowExecutionStarted event did not have appropriate attributes: {event_dat}"
-                    )));
+                    ));
                 }
             }
             Ok(EventType::WorkflowTaskScheduled) => {
@@ -1042,9 +1040,9 @@ impl WorkflowMachines {
                 }
             }
             _ => {
-                return Err(WFMachinesError::Fatal(format!(
+                return Err(fatal!(
                     "The event is not a non-stateful event, but we tried to handle it as one: {event_dat}"
-                )));
+                ));
             }
         }
         Ok(())
@@ -1080,13 +1078,12 @@ impl WorkflowMachines {
 
         match message.body {
             IncomingProtocolMessageBody::UpdateRequest(ur) => {
-                let seq_id = if let SequencingId::EventId(eid) = message
-                    .sequencing_id
-                    .ok_or_else(|| WFMachinesError::Fatal(SEQIDERR.to_string()))?
+                let seq_id = if let SequencingId::EventId(eid) =
+                    message.sequencing_id.ok_or_else(|| fatal!("{SEQIDERR}"))?
                 {
                     eid
                 } else {
-                    return Err(WFMachinesError::Fatal(SEQIDERR.to_string()));
+                    return Err(fatal!("{SEQIDERR}"));
                 };
                 let um = UpdateMachine::init(
                     message.id,
@@ -1211,9 +1208,9 @@ impl WorkflowMachines {
                         );
                     }
                     c => {
-                        return Err(WFMachinesError::Fatal(format!(
+                        return Err(fatal!(
                             "A machine requested to create a new command of an unsupported type: {c:?}"
-                        )));
+                        ));
                     }
                 },
                 MachineResponse::IssueFakeLocalActivityMarker(seq) => {
@@ -1358,9 +1355,7 @@ impl WorkflowMachines {
                     let seq = attrs.seq;
                     let attrs: ValidScheduleLA =
                         ValidScheduleLA::from_schedule_la(attrs, cmd.metadata).map_err(|e| {
-                            WFMachinesError::Fatal(format!(
-                                "Invalid schedule local activity request (seq {seq}): {e}"
-                            ))
+                            fatal!("Invalid schedule local activity request (seq {seq}): {e}")
                         })?;
                     let (la, mach_resp) = new_local_activity(
                         attrs,
@@ -1468,10 +1463,7 @@ impl WorkflowMachines {
                 }
                 WFCommandVariant::RequestCancelExternalWorkflow(attrs) => {
                     let we = attrs.workflow_execution.ok_or_else(|| {
-                        WFMachinesError::Fatal(
-                            "Cancel external workflow command had no workflow_execution field"
-                                .to_string(),
-                        )
+                        fatal!("Cancel external workflow command had no workflow_execution field")
                     })?;
                     self.add_cmd_to_wf_task(
                         new_external_cancel(
@@ -1519,11 +1511,11 @@ impl WorkflowMachines {
                     let m = if let Machines::UpdateMachine(m) = self.machine_mut(m_key) {
                         m
                     } else {
-                        return Err(WFMachinesError::Nondeterminism(format!(
+                        return Err(nondeterminism!(
                             "Tried to handle an update response for \
                              update with instance id {} but it was not found!",
                             &ur.protocol_instance_id
-                        )));
+                        ));
                     };
                     let resps = m.handle_response(ur)?;
                     self.process_machine_responses(m_key, resps)?;
@@ -1551,9 +1543,10 @@ impl WorkflowMachines {
     }
 
     fn get_machine_key(&self, id: CommandID) -> Result<MachineKey> {
-        Ok(*self.id_to_machine.get(&id).ok_or_else(|| {
-            WFMachinesError::Nondeterminism(format!("Missing associated machine for {id:?}"))
-        })?)
+        Ok(*self
+            .id_to_machine
+            .get(&id)
+            .ok_or_else(|| nondeterminism!("Missing associated machine for {id:?}"))?)
     }
 
     fn get_machine_by_msg(&self, protocol_instance_id: &str) -> Result<MachineKey> {
@@ -1561,9 +1554,7 @@ impl WorkflowMachines {
             .machines_by_protocol_instance_id
             .get(protocol_instance_id)
             .ok_or_else(|| {
-                WFMachinesError::Fatal(format!(
-                    "Missing associated machine for protocol message {protocol_instance_id}"
-                ))
+                fatal!("Missing associated machine for protocol message {protocol_instance_id}")
             })?)
     }
 
@@ -1756,10 +1747,10 @@ fn patch_marker_handling(
                 debug!("Deprecated patch marker tried against non-patch machine, skipping.");
                 skip_one_or_two_events(next_event)
             } else {
-                Err(WFMachinesError::Nondeterminism(format!(
+                Err(nondeterminism!(
                     "Non-deprecated patch marker encountered for change {patch_name}, but there is \
                      no corresponding change command!"
-                )))
+                ))
             }
         }
     } else if patch_machine.is_some() {

package/sdk-core/{core → crates/sdk-core}/src/worker/workflow/machines/workflow_task_state_machine.rs

@@ -1,13 +1,15 @@
 #![allow(clippy::enum_variant_names)]
 
-use super::{EventInfo, WFMachinesAdapter, WFMachinesError, workflow_machines::MachineResponse};
-use crate::worker::workflow::machines::HistEventData;
-use rustfsm::{StateMachine, TransitionResult, fsm};
+use super::{
+    EventInfo, StateMachine, TransitionResult, WFMachinesAdapter, WFMachinesError, fsm,
+    workflow_machines::MachineResponse,
+};
+use crate::worker::workflow::{fatal, machines::HistEventData, nondeterminism};
 use std::{
     convert::{TryFrom, TryInto},
     time::SystemTime,
 };
-use temporal_sdk_core_protos::temporal::api::{
+use temporalio_common::protos::temporal::api::{
     enums::v1::{CommandType, EventType, WorkflowTaskFailedCause},
     history::v1::history_event::Attributes::WorkflowTaskFailedEventAttributes,
 };
@@ -65,10 +67,9 @@ impl WFMachinesAdapter for WorkflowTaskMachine {
                 let (event_id, event_type) = if let Some(ei) = event_info {
                     (ei.event_id, ei.event_type)
                 } else {
-                    return Err(WFMachinesError::Fatal(
+                    return Err(fatal!(
                         "WF Task machine should never issue a task started trigger \
                         command in response to non-history events"
-                            .to_string(),
                     ));
                 };
 
@@ -100,16 +101,15 @@ impl TryFrom<HistEventData> for WorkflowTaskMachineEvents {
                     match time.try_into() {
                         Ok(t) => t,
                         Err(_) => {
-                            return Err(WFMachinesError::Fatal(
+                            return Err(fatal!(
                                 "Workflow task started event timestamp was inconvertible"
-                                    .to_string(),
                             ));
                         }
                     }
                 } else {
-                    return Err(WFMachinesError::Fatal(format!(
+                    return Err(fatal!(
                         "Workflow task started event must contain timestamp: {e}"
-                    )));
+                    ));
                 };
                 WFTStartedDat {
                     started_event_id: e.event_id,
@@ -135,15 +135,13 @@ impl TryFrom<HistEventData> for WorkflowTaskMachineEvents {
                         },
                     })
                 } else {
-                    return Err(WFMachinesError::Fatal(format!(
-                        "Workflow task failed is missing attributes: {e}"
-                    )));
+                    return Err(fatal!("Workflow task failed is missing attributes: {e}"));
                 }
             }
             _ => {
-                return Err(WFMachinesError::Nondeterminism(format!(
+                return Err(nondeterminism!(
                     "Event does not apply to a wf task machine: {e}"
-                )));
+                ));
             }
         })
     }

package/sdk-core/{core → crates/sdk-core}/src/worker/workflow/managed_run.rs

@@ -28,22 +28,25 @@ use std::{
     sync::{Arc, mpsc::Sender},
     time::{Duration, Instant},
 };
-use temporal_sdk_core_api::{errors::WorkflowErrorType, worker::WorkerConfig};
-use temporal_sdk_core_protos::{
-    TaskToken,
-    coresdk::{
-        workflow_activation::{
-            WorkflowActivation, create_evict_activation, query_to_job,
-            remove_from_cache::EvictionReason, workflow_activation_job,
+use temporalio_common::{
+    errors::WorkflowErrorType,
+    protos::{
+        TaskToken,
+        coresdk::{
+            workflow_activation::{
+                WorkflowActivation, create_evict_activation, query_to_job,
+                remove_from_cache::EvictionReason, workflow_activation_job,
+            },
+            workflow_commands::{FailWorkflowExecution, QueryResult},
+            workflow_completion,
+        },
+        temporal::api::{
+            command::v1::command::Attributes as CmdAttribs,
+            enums::v1::{VersioningBehavior, WorkflowTaskFailedCause},
+            failure::v1::Failure,
         },
-        workflow_commands::{FailWorkflowExecution, QueryResult},
-        workflow_completion,
-    },
-    temporal::api::{
-        command::v1::command::Attributes as CmdAttribs,
-        enums::v1::{VersioningBehavior, WorkflowTaskFailedCause},
-        failure::v1::Failure,
     },
+    worker::WorkerConfig,
 };
 use tokio::sync::oneshot;
 use tracing::Span;
@@ -70,7 +73,9 @@ pub(super) struct ManagedRun {
     /// pushing things out and then directly back in. The downside is this is the only "impure" part
     /// of the in/out nature of workflow state management. If there's ever a sensible way to lift it
     /// up, that'd be nice.
-    local_activity_request_sink: Rc<dyn LocalActivityRequestSink>,
+    ///
+    /// This field is `None` when `WorkerTaskTypes.enable_local_activities` is false.
+    local_activity_request_sink: Option<Rc<dyn LocalActivityRequestSink>>,
     /// Set if the run is currently waiting on the execution of some local activities.
     waiting_on_la: Option<WaitingOnLAs>,
     /// Is set to true if the machines encounter an error and the only subsequent thing we should
@@ -105,7 +110,7 @@ impl ManagedRun {
     pub(super) fn new(
         basics: RunBasics,
         wft: PermittedWFT,
-        local_activity_request_sink: Rc<dyn LocalActivityRequestSink>,
+        local_activity_request_sink: Option<Rc<dyn LocalActivityRequestSink>>,
     ) -> (Self, RunUpdateAct) {
         let metrics = basics.metrics.clone();
         let config = basics.worker_config.clone();
@@ -240,10 +245,10 @@ impl ManagedRun {
             let r = self.wfm.get_next_activation()?;
             if r.jobs.is_empty() {
                 return Err(RunUpdateErr {
-                    source: WFMachinesError::Fatal(format!(
+                    source: crate::worker::workflow::fatal!(
                         "Machines created for {} with no jobs",
                         self.wfm.machines.run_id
-                    )),
+                    ),
                     complete_resp_chan: None,
                 });
             }
@@ -261,7 +266,7 @@ impl ManagedRun {
                     lawait.hb_timeout_handle.abort();
                     lawait.hb_timeout_handle = sink_heartbeat_timeout_start(
                         self.wfm.machines.run_id.clone(),
-                        self.local_activity_request_sink.as_ref(),
+                        self.local_activity_request_sink.as_deref(),
                         start_time,
                         lawait.wft_timeout,
                     );
@@ -307,9 +312,13 @@ impl ManagedRun {
                 self.wfm.machines.reset_last_started_id(id);
             }
             // Tell the LA manager that we're done with the WFT
-            self.local_activity_request_sink.sink_reqs(vec![
-                LocalActRequest::IndicateWorkflowTaskCompleted(self.wfm.machines.run_id.clone()),
-            ]);
+            if let Some(ref local_act_request_sink) = self.local_activity_request_sink {
+                local_act_request_sink.sink_reqs(vec![
+                    LocalActRequest::IndicateWorkflowTaskCompleted(
+                        self.wfm.machines.run_id.clone(),
+                    ),
+                ]);
+            }
         }
 
         retme
@@ -402,7 +411,7 @@ impl ManagedRun {
             }) {
                 ActivationCompleteOutcome::ReportWFTFail(FailedActivationWFTReport::Report(
                     tt,
-                    WorkflowTaskFailedCause::Unspecified,
+                    WorkflowTaskFailedCause::WorkflowWorkerUnhandledFailure,
                     Failure::application_failure(reason, true).into(),
                 ))
             } else {
@@ -759,7 +768,7 @@ impl ManagedRun {
                     completion_dat: Some((data, completion.resp_chan)),
                     hb_timeout_handle: sink_heartbeat_timeout_start(
                         self.run_id().to_string(),
-                        self.local_activity_request_sink.as_ref(),
+                        self.local_activity_request_sink.as_deref(),
                         start_t,
                         wft_timeout,
                     ),
@@ -885,7 +894,7 @@ impl ManagedRun {
             // We just checked it is some, unwrap OK.
             let c = self.completion_waiting_on_page_fetch.take().unwrap();
             let run_upd = self.failed_completion(
-                WorkflowTaskFailedCause::Unspecified,
+                WorkflowTaskFailedCause::WorkflowWorkerUnhandledFailure,
                 info.reason,
                 Failure::application_failure(info.message, false).into(),
                 true,
@@ -1019,7 +1028,7 @@ impl ManagedRun {
                     let fail_cause = if matches!(&fail.source, WFMachinesError::Nondeterminism(_)) {
                         WorkflowTaskFailedCause::NonDeterministicError
                     } else {
-                        WorkflowTaskFailedCause::Unspecified
+                        WorkflowTaskFailedCause::WorkflowWorkerUnhandledFailure
                     };
                     self.failed_completion(
                         fail_cause,
@@ -1139,6 +1148,7 @@ impl ManagedRun {
                 }
             }
 
+            let attempt = self.wft.as_ref().map(|t| t.info.attempt).unwrap_or(1);
             ActivationCompleteOutcome::ReportWFTSuccess(ServerCommandsWithWorkflowInfo {
                 task_token: data.task_token,
                 action: ActivationAction::WftComplete {
@@ -1148,6 +1158,7 @@ impl ManagedRun {
                     query_responses,
                     sdk_metadata: machines_wft_response.metadata_for_complete(),
                     versioning_behavior: data.versioning_behavior,
+                    attempt,
                 },
             })
         } else {
@@ -1168,7 +1179,12 @@ impl ManagedRun {
         &mut self,
         new_local_acts: Vec<LocalActRequest>,
     ) -> Result<(), WFMachinesError> {
-        let immediate_resolutions = self.local_activity_request_sink.sink_reqs(new_local_acts);
+        let immediate_resolutions =
+            if let Some(ref local_act_request_sink) = self.local_activity_request_sink {
+                local_act_request_sink.sink_reqs(new_local_acts)
+            } else {
+                Vec::new()
+            };
         for resolution in immediate_resolutions {
             self.wfm
                 .notify_of_local_result(LocalResolution::LocalActivity(resolution))?;
@@ -1306,21 +1322,23 @@ fn put_queries_in_act(act: &mut WorkflowActivation, wft: &mut OutstandingTask) {
 }
 fn sink_heartbeat_timeout_start(
     run_id: String,
-    sink: &dyn LocalActivityRequestSink,
+    sink: Option<&dyn LocalActivityRequestSink>,
     wft_start_time: Instant,
     wft_timeout: Duration,
 ) -> AbortHandle {
     // The heartbeat deadline is 80% of the WFT timeout
     let deadline = wft_start_time.add(wft_timeout.mul_f32(WFT_HEARTBEAT_TIMEOUT_FRACTION));
     let (abort_handle, abort_reg) = AbortHandle::new_pair();
-    sink.sink_reqs(vec![LocalActRequest::StartHeartbeatTimeout {
-        send_on_elapse: HeartbeatTimeoutMsg {
-            run_id,
-            span: Span::current(),
-        },
-        deadline,
-        abort_reg,
-    }]);
+    if let Some(la_sink) = sink {
+        la_sink.sink_reqs(vec![LocalActRequest::StartHeartbeatTimeout {
+            send_on_elapse: HeartbeatTimeoutMsg {
+                run_id,
+                span: Span::current(),
+            },
+            deadline,
+            abort_reg,
+        }]);
+    }
     abort_handle
 }
 
@@ -1606,7 +1624,7 @@ mod tests {
     }
 
     mod command_utils {
-        use temporal_sdk_core_protos::coresdk::workflow_commands::{
+        use temporalio_common::protos::coresdk::workflow_commands::{
             CancelWorkflowExecution, CompleteWorkflowExecution, QueryResult, UpdateResponse,
         };