@temporalio/core-bridge 1.13.2 → 1.14.0

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

@@ -1,13 +1,14 @@
+use super::{MachineError, StateMachine, TransitionResult, fsm};
 use crate::worker::workflow::{
     WFMachinesError,
     machines::{
         EventInfo, HistEventData, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter,
         workflow_machines::MachineResponse,
     },
+    nondeterminism,
 };
 use itertools::Itertools;
-use rustfsm::{MachineError, StateMachine, TransitionResult, fsm};
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     coresdk::{
         nexus::{NexusOperationCancellationType, NexusOperationResult, nexus_operation_result},
         workflow_activation::{
@@ -392,10 +393,9 @@ pub(super) struct TimedOut;
 pub(super) struct Cancelled;
 
 fn completion_of_not_abandoned_err() -> WFMachinesError {
-    WFMachinesError::Nondeterminism(
+    nondeterminism!(
         "Nexus operation which don't have the ABANDON cancellation type cannot complete after \
          being cancelled."
-            .to_string(),
     )
 }
 
@@ -455,8 +455,8 @@ impl TryFrom<HistEventData> for NexusOperationMachineEvents {
                         event_id: e.event_id,
                     })
                 } else {
-                    return Err(WFMachinesError::Nondeterminism(
-                        "NexusOperationScheduled attributes were unset or malformed".to_string(),
+                    return Err(nondeterminism!(
+                        "NexusOperationScheduled attributes were unset or malformed"
                     ));
                 }
             }
@@ -466,8 +466,8 @@ impl TryFrom<HistEventData> for NexusOperationMachineEvents {
                 {
                     Self::NexusOperationStarted(sa)
                 } else {
-                    return Err(WFMachinesError::Nondeterminism(
-                        "NexusOperationStarted attributes were unset or malformed".to_string(),
+                    return Err(nondeterminism!(
+                        "NexusOperationStarted attributes were unset or malformed"
                     ));
                 }
             }
@@ -477,8 +477,8 @@ impl TryFrom<HistEventData> for NexusOperationMachineEvents {
                 {
                     Self::NexusOperationCompleted(ca)
                 } else {
-                    return Err(WFMachinesError::Nondeterminism(
-                        "NexusOperationCompleted attributes were unset or malformed".to_string(),
+                    return Err(nondeterminism!(
+                        "NexusOperationCompleted attributes were unset or malformed"
                     ));
                 }
             }
@@ -488,8 +488,8 @@ impl TryFrom<HistEventData> for NexusOperationMachineEvents {
                 {
                     Self::NexusOperationFailed(fa)
                 } else {
-                    return Err(WFMachinesError::Nondeterminism(
-                        "NexusOperationFailed attributes were unset or malformed".to_string(),
+                    return Err(nondeterminism!(
+                        "NexusOperationFailed attributes were unset or malformed"
                     ));
                 }
             }
@@ -499,8 +499,8 @@ impl TryFrom<HistEventData> for NexusOperationMachineEvents {
                 {
                     Self::NexusOperationCanceled(ca)
                 } else {
-                    return Err(WFMachinesError::Nondeterminism(
-                        "NexusOperationCanceled attributes were unset or malformed".to_string(),
+                    return Err(nondeterminism!(
+                        "NexusOperationCanceled attributes were unset or malformed"
                     ));
                 }
             }
@@ -510,8 +510,8 @@ impl TryFrom<HistEventData> for NexusOperationMachineEvents {
                 {
                     Self::NexusOperationTimedOut(toa)
                 } else {
-                    return Err(WFMachinesError::Nondeterminism(
-                        "NexusOperationTimedOut attributes were unset or malformed".to_string(),
+                    return Err(nondeterminism!(
+                        "NexusOperationTimedOut attributes were unset or malformed"
                     ));
                 }
             }
@@ -525,9 +525,8 @@ impl TryFrom<HistEventData> for NexusOperationMachineEvents {
                 {
                     Self::NexusOperationCancelRequestCompleted(attrs)
                 } else {
-                    return Err(WFMachinesError::Nondeterminism(
+                    return Err(nondeterminism!(
                         "NexusOperationCancelRequestCompleted attributes were unset or malformed"
-                            .to_string(),
                     ));
                 }
             }
@@ -540,16 +539,15 @@ impl TryFrom<HistEventData> for NexusOperationMachineEvents {
                 {
                     Self::NexusOperationCancelRequestFailed(attrs)
                 } else {
-                    return Err(WFMachinesError::Nondeterminism(
+                    return Err(nondeterminism!(
                         "NexusOperationCancelRequestFailed attributes were unset or malformed"
-                            .to_string(),
                     ));
                 }
             }
             _ => {
-                return Err(WFMachinesError::Nondeterminism(format!(
+                return Err(nondeterminism!(
                     "Nexus operation machine does not handle this event: {e:?}"
-                )));
+                ));
             }
         })
     }

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

@@ -18,26 +18,26 @@
 //! | replaying, no marker         | deprecate_patch | Call allowed                                                                       |
 
 use super::{
-    EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError,
-    workflow_machines::MachineResponse,
+    EventInfo, NewMachineWithCommand, OnEventWrapper, StateMachine, TransitionResult,
+    WFMachinesAdapter, WFMachinesError, fsm, workflow_machines::MachineResponse,
 };
 use crate::{
     internal_flags::CoreInternalFlags,
     protosext::HistoryEventExt,
     worker::workflow::{
-        InternalFlagsRef,
+        InternalFlagsRef, fatal,
         machines::{
             HistEventData, upsert_search_attributes_state_machine::MAX_SEARCH_ATTR_PAYLOAD_SIZE,
         },
+        nondeterminism,
     },
 };
 use anyhow::Context;
-use rustfsm::{StateMachine, TransitionResult, fsm};
 use std::{
     collections::{BTreeSet, HashMap},
     convert::TryFrom,
 };
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     VERSION_SEARCH_ATTR_KEY,
     constants::PATCH_MARKER_NAME,
     coresdk::{AsJsonPayloadExt, common::build_has_change_marker_details},
@@ -130,7 +130,7 @@ pub(super) fn has_change<'a>(
         let mut serialized = all_ids
             .as_json_payload()
             .context("Could not serialize search attribute value for patch machine")
-            .map_err(|e| WFMachinesError::Fatal(e.to_string()))?;
+            .map_err(|e| fatal!("{}", e))?;
 
         if serialized.data.len() >= MAX_SEARCH_ATTR_PAYLOAD_SIZE {
             warn!(
@@ -220,10 +220,11 @@ impl Notified {
         id: String,
     ) -> PatchMachineTransition<MarkerCommandRecorded> {
         if id != dat.patch_id {
-            return TransitionResult::Err(WFMachinesError::Nondeterminism(format!(
+            return TransitionResult::Err(nondeterminism!(
                 "Change id {} does not match expected id {}",
-                id, dat.patch_id
-            )));
+                id,
+                dat.patch_id
+            ));
         }
         TransitionResult::default()
     }
@@ -257,9 +258,9 @@ impl TryFrom<HistEventData> for PatchMachineEvents {
         let e = e.event;
         match e.get_patch_marker_details() {
             Some((id, _)) => Ok(Self::MarkerRecorded(id)),
-            _ => Err(WFMachinesError::Nondeterminism(format!(
+            _ => Err(nondeterminism!(
                 "Change machine cannot handle this event: {e}"
-            ))),
+            )),
         }
     }
 }

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

@@ -1,11 +1,10 @@
 use super::{
-    EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError,
-    workflow_machines::MachineResponse,
+    EventInfo, MachineError, NewMachineWithCommand, OnEventWrapper, StateMachine, TransitionResult,
+    WFMachinesAdapter, WFMachinesError, fsm, workflow_machines::MachineResponse,
 };
-use crate::worker::workflow::machines::HistEventData;
-use rustfsm::{MachineError, StateMachine, TransitionResult, fsm};
+use crate::worker::workflow::{fatal, machines::HistEventData, nondeterminism};
 use std::convert::TryFrom;
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     coresdk::{
         IntoPayloadsExt,
         common::NamespacedWorkflowExecution,
@@ -71,8 +70,8 @@ pub(super) fn new_external_signal(
 ) -> Result<NewMachineWithCommand, WFMachinesError> {
     let (workflow_execution, only_child) = match attrs.target {
         None => {
-            return Err(WFMachinesError::Fatal(
-                "Signal external workflow command had empty target field".to_string(),
+            return Err(fatal!(
+                "Signal external workflow command had empty target field"
             ));
         }
         Some(sig_we::Target::ChildWorkflowId(wfid)) => (
@@ -196,15 +195,13 @@ impl TryFrom<HistEventData> for SignalExternalMachineEvents {
                 {
                     Self::SignalExternalWorkflowExecutionFailed(attrs.cause())
                 } else {
-                    return Err(WFMachinesError::Fatal(format!(
-                        "Signal workflow failed attributes were unset: {e}"
-                    )));
+                    return Err(fatal!("Signal workflow failed attributes were unset: {e}"));
                 }
             }
             _ => {
-                return Err(WFMachinesError::Nondeterminism(format!(
+                return Err(nondeterminism!(
                     "Signal external WF machine does not handle this event: {e}"
-                )));
+                ));
             }
         })
     }

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

@@ -1,13 +1,12 @@
 #![allow(clippy::large_enum_variant)]
 
 use super::{
-    EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter,
-    workflow_machines::MachineResponse,
+    EventInfo, MachineError, NewMachineWithCommand, OnEventWrapper, StateMachine, TransitionResult,
+    WFMachinesAdapter, fsm, workflow_machines::MachineResponse,
 };
-use crate::worker::workflow::{WFMachinesError, machines::HistEventData};
-use rustfsm::{MachineError, StateMachine, TransitionResult, fsm};
+use crate::worker::workflow::{WFMachinesError, fatal, machines::HistEventData, nondeterminism};
 use std::convert::TryFrom;
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     coresdk::{
         HistoryEventId,
         workflow_activation::FireTimer,
@@ -121,15 +120,13 @@ impl TryFrom<HistEventData> for TimerMachineEvents {
                 {
                     Self::TimerFired(attrs)
                 } else {
-                    return Err(WFMachinesError::Fatal(format!(
-                        "Timer fired attribs were unset: {e}"
-                    )));
+                    return Err(fatal!("Timer fired attribs were unset: {e}"));
                 }
             }
             _ => {
-                return Err(WFMachinesError::Nondeterminism(format!(
+                return Err(nondeterminism!(
                     "Timer machine does not handle this event: {e}"
-                )));
+                ));
             }
         })
     }
@@ -193,6 +190,14 @@ impl StartCommandCreated {
 
     pub(super) fn on_cancel(self, dat: &mut SharedState) -> TimerMachineTransition<Canceled> {
         dat.cancelled_before_sent = true;
+
+        #[cfg(feature = "antithesis_assertions")]
+        crate::antithesis::assert_sometimes!(
+            true,
+            "Timer cancelled before sent to server",
+            ::serde_json::json!({"timer_seq": dat.attrs.seq})
+        );
+
         TransitionResult::default()
     }
 }
@@ -209,10 +214,11 @@ impl StartCommandRecorded {
         if dat.attrs.seq.to_string() == attrs.timer_id {
             TransitionResult::ok(vec![TimerMachineCommand::Complete], Fired::default())
         } else {
-            TransitionResult::Err(WFMachinesError::Nondeterminism(format!(
+            TransitionResult::Err(nondeterminism!(
                 "Timer fired event did not have expected timer id {}, it was {}!",
-                dat.attrs.seq, attrs.timer_id
-            )))
+                dat.attrs.seq,
+                attrs.timer_id
+            ))
         }
     }
 
@@ -220,6 +226,13 @@ impl StartCommandRecorded {
         self,
         dat: &mut SharedState,
     ) -> TimerMachineTransition<CancelTimerCommandCreated> {
+        #[cfg(feature = "antithesis_assertions")]
+        crate::antithesis::assert_sometimes!(
+            true,
+            "Timer cancelled after started",
+            ::serde_json::json!({"timer_seq": dat.attrs.seq})
+        );
+
         TransitionResult::ok(
             vec![TimerMachineCommand::IssueCancelCmd(
                 CancelTimer { seq: dat.attrs.seq }.into(),

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

@@ -71,7 +71,7 @@ fn spawn_save_coverage_at_end() -> SyncSender<(String, CoveredTransition)> {
 mod machine_coverage_report {
     use super::*;
     use crate::worker::workflow::machines::{
-        activity_state_machine::ActivityMachine,
+        StateMachine, activity_state_machine::ActivityMachine,
         cancel_external_state_machine::CancelExternalMachine,
         cancel_workflow_state_machine::CancelWorkflowMachine,
         child_workflow_state_machine::ChildWorkflowMachine,
@@ -85,7 +85,6 @@ mod machine_coverage_report {
         upsert_search_attributes_state_machine::UpsertSearchAttributesMachine,
         workflow_task_state_machine::WorkflowTaskMachine,
     };
-    use rustfsm::StateMachine;
     use std::{fs::File, io::Write};
 
     // This "test" needs to exist so that we have a way to join the spawned thread. Otherwise

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

@@ -1,13 +1,19 @@
-use super::{EventInfo, WFMachinesAdapter, WFMachinesError, workflow_machines::MachineResponse};
+use super::{
+    EventInfo, MachineError, StateMachine, TransitionResult, WFMachinesAdapter, WFMachinesError,
+    fsm, workflow_machines::MachineResponse,
+};
 use crate::{
     protosext::protocol_messages::UpdateRequest,
-    worker::workflow::machines::{HistEventData, NewMachineWithResponse},
+    worker::workflow::{
+        fatal,
+        machines::{HistEventData, NewMachineWithResponse},
+        nondeterminism,
+    },
 };
 use itertools::Itertools;
 use prost::EncodeError;
-use rustfsm::{MachineError, StateMachine, TransitionResult, fsm};
 use std::convert::TryFrom;
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     coresdk::{
         workflow_activation::DoUpdate,
         workflow_commands::{UpdateResponse, update_response},
@@ -119,10 +125,10 @@ impl UpdateMachine {
     ) -> Result<Vec<MachineResponse>, WFMachinesError> {
         let cmds = match resp.response {
             None => {
-                return Err(WFMachinesError::Fatal(format!(
+                return Err(fatal!(
                     "Update response for update {} had an empty result, this is a lang layer bug.",
                     &self.shared_state.meta.update_id
-                )));
+                ));
             }
             Some(update_response::Response::Accepted(_)) => {
                 self.on_event(UpdateMachineEvents::Accept)
@@ -135,11 +141,11 @@ impl UpdateMachine {
             }
         }
         .map_err(|e| match e {
-            MachineError::InvalidTransition => WFMachinesError::Nondeterminism(format!(
+            MachineError::InvalidTransition => nondeterminism!(
                 "Invalid transition while handling update response (id {}) in state {}",
                 &self.shared_state.meta.update_id,
                 self.state(),
-            )),
+            ),
             MachineError::Underlying(e) => e,
         })?;
         cmds.into_iter()
@@ -172,9 +178,9 @@ impl UpdateMachine {
         outgoing_id: String,
         msg: UpdateMsg,
     ) -> Result<MachineResponse, WFMachinesError> {
-        let accept_body = msg.pack().map_err(|e| {
-            WFMachinesError::Fatal(format!("Failed to serialize update response: {e:?}"))
-        })?;
+        let accept_body = msg
+            .pack()
+            .map_err(|e| fatal!("Failed to serialize update response: {e:?}"))?;
         Ok(MachineResponse::IssueNewMessage(ProtocolMessage {
             id: outgoing_id.clone(),
             protocol_instance_id: self.shared_state.instance_id.clone(),
@@ -221,9 +227,9 @@ impl TryFrom<HistEventData> for UpdateMachineEvents {
                 UpdateMachineEvents::WorkflowExecutionUpdateCompleted
             }
             _ => {
-                return Err(WFMachinesError::Nondeterminism(format!(
+                return Err(nondeterminism!(
                     "Update machine does not handle this event: {e}"
-                )));
+                ));
             }
         })
     }

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

@@ -1,4 +1,6 @@
-use super::{NewMachineWithCommand, workflow_machines::MachineResponse};
+use super::{
+    NewMachineWithCommand, StateMachine, TransitionResult, fsm, workflow_machines::MachineResponse,
+};
 use crate::{
     internal_flags::CoreInternalFlags,
     worker::workflow::{
@@ -6,8 +8,7 @@ use crate::{
         machines::{EventInfo, HistEventData, WFMachinesAdapter},
     },
 };
-use rustfsm::{StateMachine, TransitionResult, fsm};
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     VERSION_SEARCH_ATTR_KEY,
     coresdk::workflow_commands::UpsertWorkflowSearchAttributes,
     temporal::api::{
@@ -176,7 +177,7 @@ impl From<Created> for CommandIssued {
 
 #[cfg(test)]
 mod tests {
-    use super::{super::OnEventWrapper, *};
+    use super::{super::OnEventWrapper, StateMachine, *};
     use crate::{
         replay::TestHistoryBuilder,
         test_help::{
@@ -184,21 +185,22 @@ mod tests {
         },
         worker::client::mocks::mock_worker_client,
     };
-    use rustfsm::StateMachine;
     use std::collections::HashMap;
-    use temporal_sdk_core_api::Worker;
-    use temporal_sdk_core_protos::{
-        coresdk::{
-            AsJsonPayloadExt,
-            workflow_activation::{WorkflowActivationJob, workflow_activation_job},
-            workflow_commands::SetPatchMarker,
-            workflow_completion::WorkflowActivationCompletion,
-        },
-        temporal::api::{
-            command::v1::command::Attributes,
-            common::v1::Payload,
-            enums::v1::EventType,
-            history::v1::{HistoryEvent, UpsertWorkflowSearchAttributesEventAttributes},
+    use temporalio_common::{
+        Worker,
+        protos::{
+            coresdk::{
+                AsJsonPayloadExt,
+                workflow_activation::{WorkflowActivationJob, workflow_activation_job},
+                workflow_commands::SetPatchMarker,
+                workflow_completion::WorkflowActivationCompletion,
+            },
+            temporal::api::{
+                command::v1::command::Attributes,
+                common::v1::Payload,
+                enums::v1::EventType,
+                history::v1::{HistoryEvent, UpsertWorkflowSearchAttributesEventAttributes},
+            },
         },
     };
 

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

@@ -7,7 +7,7 @@ use std::{
     collections::{HashMap, HashSet},
     time::SystemTime,
 };
-use temporal_sdk_core_protos::temporal::api::common::v1::WorkflowExecution;
+use temporalio_common::protos::temporal::api::common::v1::WorkflowExecution;
 
 #[derive(Default)]
 pub(super) struct LocalActivityData {