temporalio 0.0.0 → 0.0.1

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

@@ -0,0 +1,140 @@
+use super::{
+    workflow_machines::MachineResponse, Cancellable, EventInfo, MachineKind, NewMachineWithCommand,
+    OnEventWrapper, WFMachinesAdapter, WFMachinesError,
+};
+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<HistoryEvent> for CompleteWorkflowMachineEvents {
+    type Error = WFMachinesError;
+
+    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
+        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
+    }
+
+    fn kind(&self) -> MachineKind {
+        MachineKind::CompleteWorkflow
+    }
+}
+
+impl Cancellable for CompleteWorkflowMachine {}

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

@@ -0,0 +1,161 @@
+use super::{
+    Cancellable, EventInfo, HistoryEvent, MachineKind, MachineResponse, NewMachineWithCommand,
+    OnEventWrapper, WFMachinesAdapter, WFMachinesError,
+};
+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<HistoryEvent> for ContinueAsNewWorkflowMachineEvents {
+    type Error = WFMachinesError;
+
+    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
+        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
+    }
+
+    fn kind(&self) -> MachineKind {
+        MachineKind::ContinueAsNewWorkflow
+    }
+}
+
+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

@@ -0,0 +1,133 @@
+use super::{
+    workflow_machines::MachineResponse, Cancellable, EventInfo, MachineKind, NewMachineWithCommand,
+    OnEventWrapper, WFMachinesAdapter, WFMachinesError,
+};
+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<HistoryEvent> for FailWorkflowMachineEvents {
+    type Error = WFMachinesError;
+
+    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
+        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
+    }
+
+    fn kind(&self) -> MachineKind {
+        MachineKind::FailWorkflow
+    }
+}
+
+impl Cancellable for FailWorkflowMachine {}