temporalio 0.1.1 → 0.2.0

data/bridge/sdk-core/core/src/worker/workflow/machines/complete_workflow_state_machine.rs

@@ -1,137 +0,0 @@
-use super::{
-    workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
-    OnEventWrapper, WFMachinesAdapter, WFMachinesError,
-};
-use crate::worker::workflow::machines::HistEventData;
-use rustfsm::{fsm, TransitionResult};
-use std::convert::TryFrom;
-use temporal_sdk_core_protos::{
-    coresdk::workflow_commands::CompleteWorkflowExecution,
-    temporal::api::{
-        command::v1::Command,
-        enums::v1::{CommandType, EventType},
-        history::v1::HistoryEvent,
-    },
-};
-
-fsm! {
-    pub(super)
-    name CompleteWorkflowMachine;
-    command CompleteWFCommand;
-    error WFMachinesError;
-    shared_state CompleteWorkflowExecution;
-
-    Created --(Schedule, shared on_schedule) --> CompleteWorkflowCommandCreated;
-
-    CompleteWorkflowCommandCreated --(CommandCompleteWorkflowExecution)
-        --> CompleteWorkflowCommandCreated;
-    CompleteWorkflowCommandCreated --(WorkflowExecutionCompleted)
-        --> CompleteWorkflowCommandRecorded;
-}
-
-#[derive(Debug, derive_more::Display)]
-pub(super) enum CompleteWFCommand {
-    AddCommand(Command),
-}
-
-/// Complete a workflow
-pub(super) fn complete_workflow(attribs: CompleteWorkflowExecution) -> NewMachineWithCommand {
-    let (machine, add_cmd) = CompleteWorkflowMachine::new_scheduled(attribs);
-    NewMachineWithCommand {
-        command: add_cmd,
-        machine: machine.into(),
-    }
-}
-
-impl CompleteWorkflowMachine {
-    /// Create a new WF machine and schedule it
-    pub(crate) fn new_scheduled(attribs: CompleteWorkflowExecution) -> (Self, Command) {
-        let mut s = Self {
-            state: Created {}.into(),
-            shared_state: attribs,
-        };
-        let cmd =
-            match OnEventWrapper::on_event_mut(&mut s, CompleteWorkflowMachineEvents::Schedule)
-                .expect("Scheduling complete wf machines doesn't fail")
-                .pop()
-            {
-                Some(CompleteWFCommand::AddCommand(c)) => c,
-                _ => panic!("complete wf machine on_schedule must produce command"),
-            };
-        (s, cmd)
-    }
-}
-
-impl TryFrom<HistEventData> for CompleteWorkflowMachineEvents {
-    type Error = WFMachinesError;
-
-    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
-        let e = e.event;
-        Ok(match e.event_type() {
-            EventType::WorkflowExecutionCompleted => Self::WorkflowExecutionCompleted,
-            _ => {
-                return Err(WFMachinesError::Nondeterminism(format!(
-                    "Complete workflow machine does not handle this event: {e}"
-                )))
-            }
-        })
-    }
-}
-
-impl TryFrom<CommandType> for CompleteWorkflowMachineEvents {
-    type Error = ();
-
-    fn try_from(c: CommandType) -> Result<Self, Self::Error> {
-        Ok(match c {
-            CommandType::CompleteWorkflowExecution => Self::CommandCompleteWorkflowExecution,
-            _ => return Err(()),
-        })
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct Created {}
-
-impl Created {
-    pub(super) fn on_schedule(
-        self,
-        dat: CompleteWorkflowExecution,
-    ) -> CompleteWorkflowMachineTransition<CompleteWorkflowCommandCreated> {
-        let cmd = Command {
-            command_type: CommandType::CompleteWorkflowExecution as i32,
-            attributes: Some(dat.into()),
-        };
-        TransitionResult::commands(vec![CompleteWFCommand::AddCommand(cmd)])
-    }
-}
-
-#[derive(thiserror::Error, Debug)]
-pub(super) enum CompleteWorkflowMachineError {}
-
-#[derive(Default, Clone)]
-pub(super) struct CompleteWorkflowCommandCreated {}
-
-#[derive(Default, Clone)]
-pub(super) struct CompleteWorkflowCommandRecorded {}
-
-impl From<CompleteWorkflowCommandCreated> for CompleteWorkflowCommandRecorded {
-    fn from(_: CompleteWorkflowCommandCreated) -> Self {
-        Self::default()
-    }
-}
-
-impl WFMachinesAdapter for CompleteWorkflowMachine {
-    fn adapt_response(
-        &self,
-        _my_command: Self::Command,
-        _event_info: Option<EventInfo>,
-    ) -> Result<Vec<MachineResponse>, WFMachinesError> {
-        Ok(vec![])
-    }
-
-    fn matches_event(&self, event: &HistoryEvent) -> bool {
-        event.event_type() == EventType::WorkflowExecutionCompleted
-    }
-}
-
-impl Cancellable for CompleteWorkflowMachine {}

data/bridge/sdk-core/core/src/worker/workflow/machines/continue_as_new_workflow_state_machine.rs

@@ -1,158 +0,0 @@
-use super::{
-    Cancellable, EventInfo, HistoryEvent, MachineResponse, NewMachineWithCommand, OnEventWrapper,
-    WFMachinesAdapter, WFMachinesError,
-};
-use crate::worker::workflow::machines::HistEventData;
-use rustfsm::{fsm, TransitionResult};
-use std::convert::TryFrom;
-use temporal_sdk_core_protos::{
-    coresdk::workflow_commands::ContinueAsNewWorkflowExecution,
-    temporal::api::{
-        command::v1::Command,
-        enums::v1::{CommandType, EventType},
-    },
-};
-
-fsm! {
-    pub(super)
-    name ContinueAsNewWorkflowMachine;
-    command ContinueAsNewWorkflowCommand;
-    error WFMachinesError;
-
-    Created --(Schedule, on_schedule) --> ContinueAsNewWorkflowCommandCreated;
-
-    ContinueAsNewWorkflowCommandCreated --(CommandContinueAsNewWorkflowExecution)
-        --> ContinueAsNewWorkflowCommandCreated;
-    ContinueAsNewWorkflowCommandCreated --(WorkflowExecutionContinuedAsNew)
-        --> ContinueAsNewWorkflowCommandRecorded;
-}
-
-#[derive(Debug, derive_more::Display)]
-pub(super) enum ContinueAsNewWorkflowCommand {}
-
-pub(super) fn continue_as_new(attribs: ContinueAsNewWorkflowExecution) -> NewMachineWithCommand {
-    let mut machine = ContinueAsNewWorkflowMachine {
-        state: Created {}.into(),
-        shared_state: (),
-    };
-    OnEventWrapper::on_event_mut(&mut machine, ContinueAsNewWorkflowMachineEvents::Schedule)
-        .expect("Scheduling continue as new machine doesn't fail");
-    let command = Command {
-        command_type: CommandType::ContinueAsNewWorkflowExecution as i32,
-        attributes: Some(attribs.into()),
-    };
-    NewMachineWithCommand {
-        command,
-        machine: machine.into(),
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct ContinueAsNewWorkflowCommandCreated {}
-
-#[derive(Default, Clone)]
-pub(super) struct ContinueAsNewWorkflowCommandRecorded {}
-
-#[derive(Default, Clone)]
-pub(super) struct Created {}
-
-impl Created {
-    pub(super) fn on_schedule(
-        self,
-    ) -> ContinueAsNewWorkflowMachineTransition<ContinueAsNewWorkflowCommandCreated> {
-        TransitionResult::default()
-    }
-}
-
-impl From<ContinueAsNewWorkflowCommandCreated> for ContinueAsNewWorkflowCommandRecorded {
-    fn from(_: ContinueAsNewWorkflowCommandCreated) -> Self {
-        Self::default()
-    }
-}
-
-impl TryFrom<HistEventData> for ContinueAsNewWorkflowMachineEvents {
-    type Error = WFMachinesError;
-
-    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
-        let e = e.event;
-        Ok(match e.event_type() {
-            EventType::WorkflowExecutionContinuedAsNew => Self::WorkflowExecutionContinuedAsNew,
-            _ => {
-                return Err(WFMachinesError::Nondeterminism(format!(
-                    "Continue as new workflow machine does not handle this event: {e}"
-                )))
-            }
-        })
-    }
-}
-
-impl TryFrom<CommandType> for ContinueAsNewWorkflowMachineEvents {
-    type Error = ();
-
-    fn try_from(c: CommandType) -> Result<Self, Self::Error> {
-        Ok(match c {
-            CommandType::ContinueAsNewWorkflowExecution => {
-                Self::CommandContinueAsNewWorkflowExecution
-            }
-            _ => return Err(()),
-        })
-    }
-}
-
-impl WFMachinesAdapter for ContinueAsNewWorkflowMachine {
-    fn adapt_response(
-        &self,
-        _my_command: Self::Command,
-        _event_info: Option<EventInfo>,
-    ) -> Result<Vec<MachineResponse>, WFMachinesError> {
-        Ok(vec![])
-    }
-
-    fn matches_event(&self, event: &HistoryEvent) -> bool {
-        event.event_type() == EventType::WorkflowExecutionContinuedAsNew
-    }
-}
-
-impl Cancellable for ContinueAsNewWorkflowMachine {}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{test_help::canned_histories, worker::workflow::ManagedWFFunc};
-    use std::time::Duration;
-    use temporal_sdk::{WfContext, WfExitValue, WorkflowFunction, WorkflowResult};
-
-    async fn wf_with_timer(ctx: WfContext) -> WorkflowResult<()> {
-        ctx.timer(Duration::from_millis(500)).await;
-        Ok(WfExitValue::continue_as_new(
-            ContinueAsNewWorkflowExecution {
-                arguments: vec![[1].into()],
-                ..Default::default()
-            },
-        ))
-    }
-
-    #[tokio::test]
-    async fn wf_completing_with_continue_as_new() {
-        let func = WorkflowFunction::new(wf_with_timer);
-        let t = canned_histories::timer_then_continue_as_new("1");
-        let mut wfm = ManagedWFFunc::new(t, func, vec![]);
-        wfm.get_next_activation().await.unwrap();
-        let commands = wfm.get_server_commands().commands;
-        assert_eq!(commands.len(), 1);
-        assert_eq!(commands[0].command_type, CommandType::StartTimer as i32);
-
-        wfm.get_next_activation().await.unwrap();
-        let commands = wfm.get_server_commands().commands;
-        assert_eq!(commands.len(), 1);
-        assert_eq!(
-            commands[0].command_type,
-            CommandType::ContinueAsNewWorkflowExecution as i32
-        );
-
-        assert!(wfm.get_next_activation().await.unwrap().jobs.is_empty());
-        let commands = wfm.get_server_commands().commands;
-        assert_eq!(commands.len(), 0);
-        wfm.shutdown().await.unwrap();
-    }
-}

data/bridge/sdk-core/core/src/worker/workflow/machines/fail_workflow_state_machine.rs

@@ -1,130 +0,0 @@
-use super::{
-    workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
-    OnEventWrapper, WFMachinesAdapter, WFMachinesError,
-};
-use crate::worker::workflow::machines::HistEventData;
-use rustfsm::{fsm, TransitionResult};
-use std::convert::TryFrom;
-use temporal_sdk_core_protos::{
-    coresdk::workflow_commands::FailWorkflowExecution,
-    temporal::api::{
-        command::v1::Command as ProtoCommand,
-        enums::v1::{CommandType, EventType},
-        history::v1::HistoryEvent,
-    },
-};
-
-fsm! {
-    pub(super) name FailWorkflowMachine;
-    command FailWFCommand;
-    error WFMachinesError;
-    shared_state FailWorkflowExecution;
-
-    Created --(Schedule, shared on_schedule) --> FailWorkflowCommandCreated;
-
-    FailWorkflowCommandCreated --(CommandFailWorkflowExecution) --> FailWorkflowCommandCreated;
-    FailWorkflowCommandCreated --(WorkflowExecutionFailed) --> FailWorkflowCommandRecorded;
-}
-
-#[derive(Debug, derive_more::Display)]
-pub(super) enum FailWFCommand {
-    AddCommand(ProtoCommand),
-}
-
-/// Fail a workflow
-pub(super) fn fail_workflow(attribs: FailWorkflowExecution) -> NewMachineWithCommand {
-    let (machine, add_cmd) = FailWorkflowMachine::new_scheduled(attribs);
-    NewMachineWithCommand {
-        command: add_cmd,
-        machine: machine.into(),
-    }
-}
-
-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 cmd = match OnEventWrapper::on_event_mut(&mut s, FailWorkflowMachineEvents::Schedule)
-            .expect("Scheduling fail wf machines doesn't fail")
-            .pop()
-        {
-            Some(FailWFCommand::AddCommand(c)) => c,
-            _ => panic!("Fail wf machine on_schedule must produce command"),
-        };
-        (s, cmd)
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct Created {}
-
-impl Created {
-    pub(super) fn on_schedule(
-        self,
-        dat: FailWorkflowExecution,
-    ) -> FailWorkflowMachineTransition<FailWorkflowCommandCreated> {
-        let cmd = ProtoCommand {
-            command_type: CommandType::FailWorkflowExecution as i32,
-            attributes: Some(dat.into()),
-        };
-        TransitionResult::commands(vec![FailWFCommand::AddCommand(cmd)])
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct FailWorkflowCommandCreated {}
-
-#[derive(Default, Clone)]
-pub(super) struct FailWorkflowCommandRecorded {}
-
-impl From<FailWorkflowCommandCreated> for FailWorkflowCommandRecorded {
-    fn from(_: FailWorkflowCommandCreated) -> Self {
-        Self::default()
-    }
-}
-
-impl TryFrom<HistEventData> for FailWorkflowMachineEvents {
-    type Error = WFMachinesError;
-
-    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}"
-                )))
-            }
-        })
-    }
-}
-
-impl TryFrom<CommandType> for FailWorkflowMachineEvents {
-    type Error = ();
-
-    fn try_from(c: CommandType) -> Result<Self, Self::Error> {
-        Ok(match c {
-            CommandType::FailWorkflowExecution => Self::CommandFailWorkflowExecution,
-            _ => return Err(()),
-        })
-    }
-}
-
-impl WFMachinesAdapter for FailWorkflowMachine {
-    fn adapt_response(
-        &self,
-        _my_command: Self::Command,
-        _event_info: Option<EventInfo>,
-    ) -> Result<Vec<MachineResponse>, WFMachinesError> {
-        Ok(vec![])
-    }
-
-    fn matches_event(&self, event: &HistoryEvent) -> bool {
-        event.event_type() == EventType::WorkflowExecutionFailed
-    }
-}
-
-impl Cancellable for FailWorkflowMachine {}