@temporalio/core-bridge 1.13.2 → 1.14.0

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

@@ -1,18 +1,18 @@
 use super::{
-    EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError,
-    workflow_machines::MachineResponse,
+    EventInfo, MachineError, NewMachineWithCommand, OnEventWrapper, StateMachine, TransitionResult,
+    WFMachinesAdapter, WFMachinesError, fsm, workflow_machines::MachineResponse,
 };
 use crate::{
+    abstractions::dbg_panic,
     internal_flags::CoreInternalFlags,
-    worker::workflow::{InternalFlagsRef, machines::HistEventData},
+    worker::workflow::{InternalFlagsRef, fatal, machines::HistEventData, nondeterminism},
 };
 use itertools::Itertools;
-use rustfsm::{MachineError, StateMachine, TransitionResult, fsm};
 use std::{
     convert::{TryFrom, TryInto},
     string::ToString,
 };
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     coresdk::{
         child_workflow::{
             self as wfr, ChildWorkflowCancellationType, ChildWorkflowResult,
@@ -134,10 +134,9 @@ pub(super) struct Cancelled {
 }
 
 fn completion_of_not_abandoned_err() -> WFMachinesError {
-    WFMachinesError::Nondeterminism(
+    nondeterminism!(
         "Child workflows which don't have the ABANDON cancellation type cannot complete after \
          being cancelled."
-            .to_string(),
     )
 }
 
@@ -146,10 +145,9 @@ impl Cancelled {
         self,
     ) -> ChildWorkflowMachineTransition<Cancelled> {
         if self.seen_cancelled_event {
-            ChildWorkflowMachineTransition::Err(WFMachinesError::Fatal(
+            ChildWorkflowMachineTransition::Err(fatal!(
                 "Child workflow has already seen a ChildWorkflowExecutionCanceledEvent, and now \
                  another is being applied! This is a bug, please report."
-                    .to_string(),
             ))
         } else {
             ChildWorkflowMachineTransition::ok(
@@ -234,18 +232,20 @@ impl StartCommandCreated {
             event_dat.last_task_in_history,
         ) {
             if event_dat.wf_id != state.workflow_id {
-                return TransitionResult::Err(WFMachinesError::Nondeterminism(format!(
+                return TransitionResult::Err(nondeterminism!(
                     "Child workflow id of scheduled event '{}' does not \
                      match child workflow id of command '{}'",
-                    event_dat.wf_id, state.workflow_id
-                )));
+                    event_dat.wf_id,
+                    state.workflow_id
+                ));
             }
             if event_dat.wf_type != state.workflow_type {
-                return TransitionResult::Err(WFMachinesError::Nondeterminism(format!(
+                return TransitionResult::Err(nondeterminism!(
                     "Child workflow type of scheduled event '{}' does not \
                      match child workflow type of command '{}'",
-                    event_dat.wf_type, state.workflow_type
-                )));
+                    event_dat.wf_type,
+                    state.workflow_type
+                ));
             }
         }
         state.initiated_event_id = event_dat.event_id;
@@ -497,7 +497,10 @@ impl ChildWorkflowMachine {
                 | c @ ChildWorkflowCommand::IssueCancelAfterStarted { .. } => {
                     self.adapt_response(c, None)
                 }
-                x => panic!("Invalid cancel event response {x:?}"),
+                x => {
+                    dbg_panic!("Invalid cancel event response {x:?}");
+                    panic!("Invalid cancel event response {x:?}");
+                }
             })
             .flatten_ok()
             .try_collect()?;
@@ -530,8 +533,8 @@ impl TryFrom<HistEventData> for ChildWorkflowMachineEvents {
                         last_task_in_history,
                     })
                 } else {
-                    return Err(WFMachinesError::Fatal(
-                        "StartChildWorkflowExecutionInitiated attributes were unset".to_string(),
+                    return Err(fatal!(
+                        "StartChildWorkflowExecutionInitiated attributes were unset"
                     ));
                 }
             }
@@ -544,14 +547,12 @@ impl TryFrom<HistEventData> for ChildWorkflowMachineEvents {
                 {
                     Self::StartChildWorkflowExecutionFailed(
                         StartChildWorkflowExecutionFailedCause::try_from(cause).map_err(|_| {
-                            WFMachinesError::Fatal(
-                                "Invalid StartChildWorkflowExecutionFailedCause".to_string(),
-                            )
+                            fatal!("Invalid StartChildWorkflowExecutionFailedCause")
                         })?,
                     )
                 } else {
-                    return Err(WFMachinesError::Fatal(
-                        "StartChildWorkflowExecutionFailed attributes were unset".to_string(),
+                    return Err(fatal!(
+                        "StartChildWorkflowExecutionFailed attributes were unset"
                     ));
                 }
             }
@@ -570,9 +571,8 @@ impl TryFrom<HistEventData> for ChildWorkflowMachineEvents {
                         started_event_id: e.event_id,
                     })
                 } else {
-                    return Err(WFMachinesError::Fatal(
+                    return Err(fatal!(
                         "ChildWorkflowExecutionStarted attributes were unset or malformed"
-                            .to_string(),
                     ));
                 }
             }
@@ -585,9 +585,8 @@ impl TryFrom<HistEventData> for ChildWorkflowMachineEvents {
                 {
                     Self::ChildWorkflowExecutionCompleted(result)
                 } else {
-                    return Err(WFMachinesError::Fatal(
+                    return Err(fatal!(
                         "ChildWorkflowExecutionCompleted attributes were unset or malformed"
-                            .to_string(),
                     ));
                 }
             }
@@ -598,9 +597,7 @@ impl TryFrom<HistEventData> for ChildWorkflowMachineEvents {
                 {
                     Self::ChildWorkflowExecutionFailed(attrs)
                 } else {
-                    return Err(WFMachinesError::Fatal(
-                        "ChildWorkflowExecutionFailed attributes were unset".to_string(),
-                    ));
+                    return Err(fatal!("ChildWorkflowExecutionFailed attributes were unset"));
                 }
             }
             Ok(EventType::ChildWorkflowExecutionTimedOut) => {
@@ -610,9 +607,8 @@ impl TryFrom<HistEventData> for ChildWorkflowMachineEvents {
                 {
                     Self::ChildWorkflowExecutionTimedOut(atts.retry_state())
                 } else {
-                    return Err(WFMachinesError::Fatal(
+                    return Err(fatal!(
                         "ChildWorkflowExecutionTimedOut attributes were unset or malformed"
-                            .to_string(),
                     ));
                 }
             }
@@ -621,9 +617,9 @@ impl TryFrom<HistEventData> for ChildWorkflowMachineEvents {
             }
             Ok(EventType::ChildWorkflowExecutionCanceled) => Self::ChildWorkflowExecutionCancelled,
             _ => {
-                return Err(WFMachinesError::Nondeterminism(format!(
+                return Err(nondeterminism!(
                     "Child workflow machine does not handle this event: {e:?}"
-                )));
+                ));
             }
         })
     }
@@ -770,9 +766,7 @@ fn convert_payloads(
     result: Option<Payloads>,
 ) -> Result<Option<Payload>, WFMachinesError> {
     result.map(TryInto::try_into).transpose().map_err(|pe| {
-        WFMachinesError::Fatal(format!(
-            "Not exactly one payload in child workflow result ({pe}) for event: {event_info:?}"
-        ))
+        fatal!("Not exactly one payload in child workflow result ({pe}) for event: {event_info:?}")
     })
 }
 

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

@@ -1,11 +1,13 @@
 use super::{
-    EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError,
-    workflow_machines::MachineResponse,
+    EventInfo, NewMachineWithCommand, OnEventWrapper, StateMachine, TransitionResult,
+    WFMachinesAdapter, WFMachinesError, fsm, workflow_machines::MachineResponse,
+};
+use crate::{
+    abstractions::dbg_panic,
+    worker::workflow::{machines::HistEventData, nondeterminism},
 };
-use crate::worker::workflow::machines::HistEventData;
-use rustfsm::{StateMachine, TransitionResult, fsm};
 use std::convert::TryFrom;
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     coresdk::workflow_commands::CompleteWorkflowExecution,
     temporal::api::{
         command::v1::command,
@@ -42,7 +44,10 @@ pub(super) fn complete_workflow(attribs: CompleteWorkflowExecution) -> NewMachin
             .pop()
         {
             Some(CompleteWFCommand::AddCommand(c)) => c,
-            _ => panic!("complete wf machine on_schedule must produce command"),
+            unexpected => {
+                dbg_panic!("complete wf machine on_schedule must produce command: {unexpected:?}");
+                panic!("complete wf machine on_schedule must produce command");
+            }
         };
     NewMachineWithCommand {
         command: add_cmd,
@@ -58,9 +63,9 @@ impl TryFrom<HistEventData> for CompleteWorkflowMachineEvents {
         Ok(match e.event_type() {
             EventType::WorkflowExecutionCompleted => Self::WorkflowExecutionCompleted,
             _ => {
-                return Err(WFMachinesError::Nondeterminism(format!(
+                return Err(nondeterminism!(
                     "Complete workflow machine does not handle this event: {e}"
-                )));
+                ));
             }
         })
     }

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

@@ -1,11 +1,10 @@
 use super::{
-    EventInfo, MachineResponse, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter,
-    WFMachinesError,
+    EventInfo, MachineResponse, NewMachineWithCommand, OnEventWrapper, StateMachine,
+    TransitionResult, WFMachinesAdapter, WFMachinesError, fsm,
 };
-use crate::worker::workflow::machines::HistEventData;
-use rustfsm::{StateMachine, TransitionResult, fsm};
+use crate::worker::workflow::{machines::HistEventData, nondeterminism};
 use std::convert::TryFrom;
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     coresdk::workflow_commands::ContinueAsNewWorkflowExecution,
     temporal::api::{
         command::v1::continue_as_new_cmd_to_api,
@@ -74,9 +73,9 @@ impl TryFrom<HistEventData> for ContinueAsNewWorkflowMachineEvents {
         Ok(match e.event_type() {
             EventType::WorkflowExecutionContinuedAsNew => Self::WorkflowExecutionContinuedAsNew,
             _ => {
-                return Err(WFMachinesError::Nondeterminism(format!(
+                return Err(nondeterminism!(
                     "Continue as new workflow machine does not handle this event: {e}"
-                )));
+                ));
             }
         })
     }

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

@@ -1,11 +1,10 @@
 use super::{
-    EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError,
-    workflow_machines::MachineResponse,
+    EventInfo, NewMachineWithCommand, OnEventWrapper, StateMachine, TransitionResult,
+    WFMachinesAdapter, WFMachinesError, fsm, workflow_machines::MachineResponse,
 };
-use crate::worker::workflow::machines::HistEventData;
-use rustfsm::{StateMachine, TransitionResult, fsm};
+use crate::worker::workflow::{machines::HistEventData, nondeterminism};
 use std::convert::TryFrom;
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     coresdk::workflow_commands::FailWorkflowExecution,
     temporal::api::{
         command::v1::command,
@@ -85,9 +84,9 @@ impl TryFrom<HistEventData> for FailWorkflowMachineEvents {
         Ok(match e.event_type() {
             EventType::WorkflowExecutionFailed => Self::WorkflowExecutionFailed,
             _ => {
-                return Err(WFMachinesError::Nondeterminism(format!(
+                return Err(nondeterminism!(
                     "Fail workflow machine does not handle this event: {e}"
-                )));
+                ));
             }
         })
     }

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

@@ -1,6 +1,6 @@
 use super::{
-    EventInfo, OnEventWrapper, WFMachinesAdapter, WFMachinesError,
-    workflow_machines::MachineResponse,
+    EventInfo, MachineError, OnEventWrapper, StateMachine, TransitionResult, WFMachinesAdapter,
+    WFMachinesError, fsm, workflow_machines::MachineResponse,
 };
 use crate::{
     internal_flags::CoreInternalFlags,
@@ -8,18 +8,18 @@ use crate::{
     worker::{
         LocalActivityExecutionResult,
         workflow::{
-            InternalFlagsRef,
+            InternalFlagsRef, fatal,
             machines::{HistEventData, activity_state_machine::activity_fail_info},
+            nondeterminism,
         },
     },
 };
 use itertools::Itertools;
-use rustfsm::{MachineError, StateMachine, TransitionResult, fsm};
 use std::{
     convert::TryFrom,
     time::{Duration, SystemTime},
 };
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     constants::LOCAL_ACTIVITY_MARKER_NAME,
     coresdk::{
         activity_result::{
@@ -163,8 +163,8 @@ pub(super) fn new_local_activity(
         }
     } else {
         if maybe_pre_resolved.is_some() {
-            return Err(WFMachinesError::Nondeterminism(
-                "Local activity cannot be created as pre-resolved while not replaying".to_string(),
+            return Err(nondeterminism!(
+                "Local activity cannot be created as pre-resolved while not replaying"
             ));
         }
         Executing {}.into()
@@ -211,10 +211,10 @@ impl LocalActivityMachine {
             LocalActivityMachineState::ResultNotified(_) => Ok(false),
             LocalActivityMachineState::WaitingMarkerEvent(_) => Ok(true),
             LocalActivityMachineState::WaitingMarkerEventPreResolved(_) => Ok(true),
-            _ => Err(WFMachinesError::Fatal(format!(
+            _ => Err(fatal!(
                 "Attempted to check for LA marker handling in invalid state {}",
                 self.state()
-            ))),
+            )),
         }
     }
 
@@ -242,12 +242,12 @@ impl LocalActivityMachine {
         let mut res =
             OnEventWrapper::on_event_mut(self, LocalActivityMachineEvents::StartedNonReplayWFT)
                 .map_err(|e| match e {
-                    MachineError::InvalidTransition => WFMachinesError::Fatal(format!(
+                    MachineError::InvalidTransition => fatal!(
                         "Invalid transition while notifying local activity (seq {})\
                          of non-replay-wft-started in {}",
                         self.shared_state.attrs.seq,
                         self.state(),
-                    )),
+                    ),
                     MachineError::Underlying(e) => e,
                 })?;
         let res = res.pop().expect("Always produces one response");
@@ -296,12 +296,12 @@ impl LocalActivityMachine {
             LocalActivityMachineEvents::HandleResult(dat)
         };
         let res = OnEventWrapper::on_event_mut(self, evt).map_err(|e| match e {
-            MachineError::InvalidTransition => WFMachinesError::Fatal(format!(
+            MachineError::InvalidTransition => fatal!(
                 "Invalid transition resolving local activity (seq {}, from marker: {}) in {}",
                 self.shared_state.attrs.seq,
                 from_marker,
                 self.state(),
-            )),
+            ),
             MachineError::Underlying(e) => e,
         })?;
 
@@ -543,16 +543,16 @@ impl ResultNotified {
         dat: CompleteLocalActivityData,
     ) -> LocalActivityMachineTransition<MarkerCommandRecorded> {
         if self.result_type == ResultType::Completed && dat.result.is_err() {
-            return TransitionResult::Err(WFMachinesError::Nondeterminism(format!(
+            return TransitionResult::Err(nondeterminism!(
                 "Local activity (seq {}) completed successfully locally, but history said \
                  it failed!",
                 shared.attrs.seq
-            )));
+            ));
         } else if self.result_type == ResultType::Failed && dat.result.is_ok() {
-            return TransitionResult::Err(WFMachinesError::Nondeterminism(format!(
+            return TransitionResult::Err(nondeterminism!(
                 "Local activity (seq {}) failed locally, but history said it completed!",
                 shared.attrs.seq
-            )));
+            ));
         }
         verify_marker_dat!(shared, &dat, TransitionResult::default())
     }
@@ -812,15 +812,15 @@ impl TryFrom<HistEventData> for LocalActivityMachineEvents {
     fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
         let e = e.event;
         if e.event_type() != EventType::MarkerRecorded {
-            return Err(WFMachinesError::Nondeterminism(format!(
+            return Err(nondeterminism!(
                 "Local activity machine cannot handle this event: {e}"
-            )));
+            ));
         }
 
         match e.into_local_activity_marker_details() {
             Some(marker_dat) => Ok(LocalActivityMachineEvents::MarkerRecorded(marker_dat)),
-            _ => Err(WFMachinesError::Nondeterminism(
-                "Local activity machine encountered an unparsable marker".to_string(),
+            _ => Err(nondeterminism!(
+                "Local activity machine encountered an unparsable marker"
             )),
         }
     }
@@ -831,11 +831,12 @@ fn verify_marker_data_matches(
     dat: &CompleteLocalActivityData,
 ) -> Result<(), WFMachinesError> {
     if shared.attrs.seq != dat.marker_dat.seq {
-        return Err(WFMachinesError::Nondeterminism(format!(
+        return Err(nondeterminism!(
             "Local activity marker data has sequence number {} but matched against LA \
             command with sequence number {}",
-            dat.marker_dat.seq, shared.attrs.seq
-        )));
+            dat.marker_dat.seq,
+            shared.attrs.seq
+        ));
     }
     // Here we use whether or not we were replaying when we _first invoked_ the LA, because we
     // are always replaying when we see the marker recorded event, and that would make this check
@@ -845,18 +846,20 @@ fn verify_marker_data_matches(
         !shared.replaying_when_invoked,
     ) {
         if dat.marker_dat.activity_id != shared.attrs.activity_id {
-            return Err(WFMachinesError::Nondeterminism(format!(
+            return Err(nondeterminism!(
                 "Activity id of recorded marker '{}' does not \
                  match activity id of local activity command '{}'",
-                dat.marker_dat.activity_id, shared.attrs.activity_id
-            )));
+                dat.marker_dat.activity_id,
+                shared.attrs.activity_id
+            ));
         }
         if dat.marker_dat.activity_type != shared.attrs.activity_type {
-            return Err(WFMachinesError::Nondeterminism(format!(
+            return Err(nondeterminism!(
                 "Activity type of recorded marker '{}' does not \
                  match activity type of local activity command '{}'",
-                dat.marker_dat.activity_type, shared.attrs.activity_type
-            )));
+                dat.marker_dat.activity_type,
+                shared.attrs.activity_type
+            ));
         }
     }
 

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

@@ -23,9 +23,13 @@ mod workflow_task_state_machine;
 #[cfg(test)]
 mod transition_coverage;
 
+pub(crate) use temporalio_common::fsm_trait::MachineError;
 pub(crate) use workflow_machines::{MachinesWFTResponseContent, WorkflowMachines};
 
-use crate::{telemetry::VecDisplayer, worker::workflow::WFMachinesError};
+use crate::{
+    telemetry::VecDisplayer,
+    worker::workflow::{WFMachinesError, fatal, nondeterminism},
+};
 use activity_state_machine::ActivityMachine;
 use cancel_external_state_machine::CancelExternalMachine;
 use cancel_workflow_state_machine::CancelWorkflowMachine;
@@ -37,16 +41,19 @@ use local_activity_state_machine::LocalActivityMachine;
 use modify_workflow_properties_state_machine::ModifyWorkflowPropertiesMachine;
 use nexus_operation_state_machine::NexusOperationMachine;
 use patch_state_machine::PatchMachine;
-use rustfsm::{MachineError, StateMachine};
 use signal_external_state_machine::SignalExternalMachine;
 use std::{
     convert::{TryFrom, TryInto},
     fmt::{Debug, Display},
 };
-use temporal_sdk_core_protos::temporal::api::{
-    enums::v1::{CommandType, EventType},
-    history::v1::HistoryEvent,
+use temporalio_common::{
+    fsm_trait::{StateMachine, TransitionResult},
+    protos::temporal::api::{
+        enums::v1::{CommandType, EventType},
+        history::v1::HistoryEvent,
+    },
 };
+use temporalio_macros::fsm;
 use timer_state_machine::TimerMachine;
 use update_state_machine::UpdateMachine;
 use upsert_search_attributes_state_machine::UpsertSearchAttributesMachine;
@@ -123,21 +130,19 @@ where
         if let Ok(converted_command) = command_type.try_into() {
             match OnEventWrapper::on_event_mut(self, converted_command) {
                 Ok(c) => process_machine_commands(self, c, None),
-                Err(MachineError::InvalidTransition) => {
-                    Err(WFMachinesError::Nondeterminism(format!(
-                        "Unexpected command producing an invalid transition {:?} in state {}",
-                        command_type,
-                        self.state()
-                    )))
-                }
+                Err(MachineError::InvalidTransition) => Err(nondeterminism!(
+                    "Unexpected command producing an invalid transition {:?} in state {}",
+                    command_type,
+                    self.state()
+                )),
                 Err(MachineError::Underlying(e)) => Err(e.into()),
             }
         } else {
-            Err(WFMachinesError::Nondeterminism(format!(
+            Err(nondeterminism!(
                 "Unexpected command {:?} generated by a {:?} machine",
                 command_type,
                 self.name()
-            )))
+            ))
         }
     }
 
@@ -159,12 +164,12 @@ where
 
         match OnEventWrapper::on_event_mut(self, converted_event) {
             Ok(c) => process_machine_commands(self, c, Some(event_info)),
-            Err(MachineError::InvalidTransition) => Err(WFMachinesError::Fatal(format!(
+            Err(MachineError::InvalidTransition) => Err(fatal!(
                 "{} in state {} says the transition is invalid during event {:?}",
                 self.name(),
                 self.state(),
                 event_info
-            ))),
+            )),
             Err(MachineError::Underlying(e)) => Err(e.into()),
         }
     }
@@ -288,7 +293,7 @@ where
 }
 
 struct NewMachineWithCommand {
-    command: temporal_sdk_core_protos::temporal::api::command::v1::command::Attributes,
+    command: temporalio_common::protos::temporal::api::command::v1::command::Attributes,
     machine: Machines,
 }
 

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

@@ -1,10 +1,11 @@
-use super::{NewMachineWithCommand, workflow_machines::MachineResponse};
+use super::{
+    NewMachineWithCommand, StateMachine, TransitionResult, fsm, workflow_machines::MachineResponse,
+};
 use crate::worker::workflow::{
     WFMachinesError,
     machines::{EventInfo, HistEventData, WFMachinesAdapter},
 };
-use rustfsm::{StateMachine, TransitionResult, fsm};
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     coresdk::workflow_commands::ModifyWorkflowProperties,
     temporal::api::enums::v1::{CommandType, EventType},
 };