@temporalio/core-bridge 1.5.2 → 1.7.0

package/sdk-core/core/src/worker/workflow/machines/fail_workflow_state_machine.rs

@@ -2,7 +2,8 @@ use super::{
     workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
     OnEventWrapper, WFMachinesAdapter, WFMachinesError,
 };
-use rustfsm::{fsm, TransitionResult};
+use crate::worker::workflow::machines::HistEventData;
+use rustfsm::{fsm, StateMachine, TransitionResult};
 use std::convert::TryFrom;
 use temporal_sdk_core_protos::{
     coresdk::workflow_commands::FailWorkflowExecution,
@@ -17,9 +18,9 @@ fsm! {
     pub(super) name FailWorkflowMachine;
     command FailWFCommand;
     error WFMachinesError;
-    shared_state FailWorkflowExecution;
+    shared_state ();
 
-    Created --(Schedule, shared on_schedule) --> FailWorkflowCommandCreated;
+    Created --(Schedule, on_schedule) --> FailWorkflowCommandCreated;
 
     FailWorkflowCommandCreated --(CommandFailWorkflowExecution) --> FailWorkflowCommandCreated;
     FailWorkflowCommandCreated --(WorkflowExecutionFailed) --> FailWorkflowCommandRecorded;
@@ -42,10 +43,7 @@ pub(super) fn fail_workflow(attribs: FailWorkflowExecution) -> NewMachineWithCom
 impl FailWorkflowMachine {
     /// Create a new WF machine and schedule it
     pub(crate) fn new_scheduled(attribs: FailWorkflowExecution) -> (Self, ProtoCommand) {
-        let mut s = Self {
-            state: Created {}.into(),
-            shared_state: attribs,
-        };
+        let mut s = Self::from_parts(Created { attribs }.into(), ());
         let cmd = match OnEventWrapper::on_event_mut(&mut s, FailWorkflowMachineEvents::Schedule)
             .expect("Scheduling fail wf machines doesn't fail")
             .pop()
@@ -58,16 +56,15 @@ impl FailWorkflowMachine {
 }
 
 #[derive(Default, Clone)]
-pub(super) struct Created {}
+pub(super) struct Created {
+    attribs: FailWorkflowExecution,
+}
 
 impl Created {
-    pub(super) fn on_schedule(
-        self,
-        dat: FailWorkflowExecution,
-    ) -> FailWorkflowMachineTransition<FailWorkflowCommandCreated> {
+    pub(super) fn on_schedule(self) -> FailWorkflowMachineTransition<FailWorkflowCommandCreated> {
         let cmd = ProtoCommand {
             command_type: CommandType::FailWorkflowExecution as i32,
-            attributes: Some(dat.into()),
+            attributes: Some(self.attribs.into()),
         };
         TransitionResult::commands(vec![FailWFCommand::AddCommand(cmd)])
     }
@@ -85,16 +82,16 @@ impl From<FailWorkflowCommandCreated> for FailWorkflowCommandRecorded {
     }
 }
 
-impl TryFrom<HistoryEvent> for FailWorkflowMachineEvents {
+impl TryFrom<HistEventData> for FailWorkflowMachineEvents {
     type Error = WFMachinesError;
 
-    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
+    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
+        let e = e.event;
         Ok(match e.event_type() {
             EventType::WorkflowExecutionFailed => Self::WorkflowExecutionFailed,
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
-                    "Fail workflow machine does not handle this event: {}",
-                    e
+                    "Fail workflow machine does not handle this event: {e}"
                 )))
             }
         })