temporalio 0.0.0 → 0.0.1

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

@@ -0,0 +1,298 @@
+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::{
+        common::NamespacedWorkflowExecution,
+        workflow_activation::ResolveRequestCancelExternalWorkflow,
+    },
+    temporal::api::{
+        command::v1::{command, Command, RequestCancelExternalWorkflowExecutionCommandAttributes},
+        enums::v1::{CancelExternalWorkflowExecutionFailedCause, CommandType, EventType},
+        failure::v1::{failure::FailureInfo, ApplicationFailureInfo, Failure},
+        history::v1::{history_event, HistoryEvent},
+    },
+};
+
+fsm! {
+    pub(super)
+    name CancelExternalMachine;
+    command CancelExternalCommand;
+    error WFMachinesError;
+    shared_state SharedState;
+
+    Created --(Schedule, on_schedule) --> RequestCancelExternalCommandCreated;
+
+    RequestCancelExternalCommandCreated --(CommandRequestCancelExternalWorkflowExecution)
+      --> RequestCancelExternalCommandCreated;
+    RequestCancelExternalCommandCreated
+      --(RequestCancelExternalWorkflowExecutionInitiated,
+         on_request_cancel_external_workflow_execution_initiated)
+      --> RequestCancelExternalCommandRecorded;
+
+    RequestCancelExternalCommandRecorded
+      --(ExternalWorkflowExecutionCancelRequested, on_external_workflow_execution_cancel_requested)
+      --> CancelRequested;
+    RequestCancelExternalCommandRecorded
+      --(RequestCancelExternalWorkflowExecutionFailed(CancelExternalWorkflowExecutionFailedCause),
+         on_request_cancel_external_workflow_execution_failed) --> RequestCancelFailed;
+}
+
+#[derive(Default, Clone)]
+pub(super) struct SharedState {
+    seq: u32,
+}
+
+#[derive(Debug, derive_more::Display)]
+pub(super) enum CancelExternalCommand {
+    /// The target workflow has been notified of the cancel
+    Requested,
+    #[display(fmt = "Failed")]
+    Failed(CancelExternalWorkflowExecutionFailedCause),
+}
+
+pub(super) fn new_external_cancel(
+    seq: u32,
+    workflow_execution: NamespacedWorkflowExecution,
+    only_child: bool,
+    reason: String,
+) -> NewMachineWithCommand {
+    let mut s = CancelExternalMachine {
+        state: Created {}.into(),
+        shared_state: SharedState { seq },
+    };
+    OnEventWrapper::on_event_mut(&mut s, CancelExternalMachineEvents::Schedule)
+        .expect("Scheduling cancel external wf command doesn't fail");
+    let cmd_attrs = command::Attributes::RequestCancelExternalWorkflowExecutionCommandAttributes(
+        RequestCancelExternalWorkflowExecutionCommandAttributes {
+            namespace: workflow_execution.namespace,
+            workflow_id: workflow_execution.workflow_id,
+            run_id: workflow_execution.run_id,
+            // Apparently this is effectively deprecated at this point
+            control: "".to_string(),
+            child_workflow_only: only_child,
+            reason,
+        },
+    );
+    let cmd = Command {
+        command_type: CommandType::RequestCancelExternalWorkflowExecution as i32,
+        attributes: Some(cmd_attrs),
+    };
+    NewMachineWithCommand {
+        command: cmd,
+        machine: s.into(),
+    }
+}
+
+#[derive(Default, Clone)]
+pub(super) struct CancelRequested {}
+
+#[derive(Default, Clone)]
+pub(super) struct Created {}
+
+impl Created {
+    pub(super) fn on_schedule(
+        self,
+    ) -> CancelExternalMachineTransition<RequestCancelExternalCommandCreated> {
+        TransitionResult::default()
+    }
+}
+
+#[derive(Default, Clone)]
+pub(super) struct RequestCancelExternalCommandCreated {}
+
+impl RequestCancelExternalCommandCreated {
+    pub(super) fn on_request_cancel_external_workflow_execution_initiated(
+        self,
+    ) -> CancelExternalMachineTransition<RequestCancelExternalCommandRecorded> {
+        TransitionResult::default()
+    }
+}
+
+#[derive(Default, Clone)]
+pub(super) struct RequestCancelExternalCommandRecorded {}
+
+impl RequestCancelExternalCommandRecorded {
+    pub(super) fn on_external_workflow_execution_cancel_requested(
+        self,
+    ) -> CancelExternalMachineTransition<CancelRequested> {
+        TransitionResult::commands(vec![CancelExternalCommand::Requested])
+    }
+    pub(super) fn on_request_cancel_external_workflow_execution_failed(
+        self,
+        cause: CancelExternalWorkflowExecutionFailedCause,
+    ) -> CancelExternalMachineTransition<RequestCancelFailed> {
+        TransitionResult::commands(vec![CancelExternalCommand::Failed(cause)])
+    }
+}
+
+#[derive(Default, Clone)]
+pub(super) struct RequestCancelFailed {}
+
+impl TryFrom<CommandType> for CancelExternalMachineEvents {
+    type Error = ();
+
+    fn try_from(c: CommandType) -> Result<Self, Self::Error> {
+        match c {
+            CommandType::RequestCancelExternalWorkflowExecution => {
+                Ok(Self::CommandRequestCancelExternalWorkflowExecution)
+            }
+            _ => Err(()),
+        }
+    }
+}
+
+impl TryFrom<HistoryEvent> for CancelExternalMachineEvents {
+    type Error = WFMachinesError;
+
+    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
+        Ok(match e.event_type() {
+            EventType::ExternalWorkflowExecutionCancelRequested => {
+                Self::ExternalWorkflowExecutionCancelRequested
+            }
+            EventType::RequestCancelExternalWorkflowExecutionInitiated => {
+                Self::RequestCancelExternalWorkflowExecutionInitiated
+            }
+            EventType::RequestCancelExternalWorkflowExecutionFailed => {
+                if let Some(history_event::Attributes::RequestCancelExternalWorkflowExecutionFailedEventAttributes(attrs)) = e.attributes {
+                    Self::RequestCancelExternalWorkflowExecutionFailed(attrs.cause())
+                } else {
+                    return Err(WFMachinesError::Fatal(format!(
+                        "Cancelworkflow failed attributes were unset: {}",
+                        e
+                    )));
+                }
+            }
+            _ => {
+                return Err(WFMachinesError::Nondeterminism(format!(
+                    "Cancel external WF machine does not handle this event: {}",
+                    e
+                )))
+            }
+        })
+    }
+}
+
+impl WFMachinesAdapter for CancelExternalMachine {
+    fn adapt_response(
+        &self,
+        my_command: Self::Command,
+        _event_info: Option<EventInfo>,
+    ) -> Result<Vec<MachineResponse>, WFMachinesError> {
+        Ok(match my_command {
+            CancelExternalCommand::Requested => {
+                vec![ResolveRequestCancelExternalWorkflow {
+                    seq: self.shared_state.seq,
+                    failure: None,
+                }
+                .into()]
+            }
+            CancelExternalCommand::Failed(f) => {
+                let reason = match f {
+                    CancelExternalWorkflowExecutionFailedCause::Unspecified => "unknown",
+                    CancelExternalWorkflowExecutionFailedCause::ExternalWorkflowExecutionNotFound
+                    | CancelExternalWorkflowExecutionFailedCause::NamespaceNotFound  => "not found"
+                };
+                vec![ResolveRequestCancelExternalWorkflow {
+                    seq: self.shared_state.seq,
+                    failure: Some(Failure {
+                        message: format!("Unable to cancel external workflow because {}", reason),
+                        failure_info: Some(FailureInfo::ApplicationFailureInfo(
+                            ApplicationFailureInfo {
+                                r#type: f.to_string(),
+                                ..Default::default()
+                            },
+                        )),
+                        ..Default::default()
+                    }),
+                }
+                .into()]
+            }
+        })
+    }
+
+    fn matches_event(&self, event: &HistoryEvent) -> bool {
+        matches!(
+            event.event_type(),
+            EventType::ExternalWorkflowExecutionCancelRequested
+                | EventType::RequestCancelExternalWorkflowExecutionFailed
+                | EventType::RequestCancelExternalWorkflowExecutionInitiated
+        )
+    }
+
+    fn kind(&self) -> MachineKind {
+        MachineKind::CancelExternalWorkflow
+    }
+}
+
+impl Cancellable for CancelExternalMachine {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{replay::TestHistoryBuilder, worker::workflow::ManagedWFFunc};
+    use temporal_sdk::{WfContext, WorkflowFunction, WorkflowResult};
+
+    async fn cancel_sender(ctx: WfContext) -> WorkflowResult<()> {
+        let res = ctx
+            .cancel_external(NamespacedWorkflowExecution {
+                namespace: "some_namespace".to_string(),
+                workflow_id: "fake_wid".to_string(),
+                run_id: "fake_rid".to_string(),
+            })
+            .await;
+        if res.is_err() {
+            Err(anyhow::anyhow!("Cancel fail!"))
+        } else {
+            Ok(().into())
+        }
+    }
+
+    #[rstest::rstest]
+    #[case::succeeds(false)]
+    #[case::fails(true)]
+    #[tokio::test]
+    async fn sends_cancel(#[case] fails: bool) {
+        let mut t = TestHistoryBuilder::default();
+        t.add_by_type(EventType::WorkflowExecutionStarted);
+        t.add_full_wf_task();
+        let id = t.add_cancel_external_wf(NamespacedWorkflowExecution {
+            namespace: "some_namespace".to_string(),
+            workflow_id: "fake_wid".to_string(),
+            run_id: "fake_rid".to_string(),
+        });
+        if fails {
+            t.add_cancel_external_wf_failed(id);
+        } else {
+            t.add_cancel_external_wf_completed(id);
+        }
+        t.add_full_wf_task();
+        t.add_workflow_execution_completed();
+
+        let wff = WorkflowFunction::new(cancel_sender);
+        let mut wfm = ManagedWFFunc::new(t, wff, vec![]);
+        wfm.get_next_activation().await.unwrap();
+        let cmds = wfm.get_server_commands().commands;
+        assert_eq!(cmds.len(), 1);
+        assert_eq!(
+            cmds[0].command_type(),
+            CommandType::RequestCancelExternalWorkflowExecution
+        );
+        wfm.get_next_activation().await.unwrap();
+        let cmds = wfm.get_server_commands().commands;
+        assert_eq!(cmds.len(), 1);
+        if fails {
+            assert_eq!(cmds[0].command_type(), CommandType::FailWorkflowExecution);
+        } else {
+            assert_eq!(
+                cmds[0].command_type(),
+                CommandType::CompleteWorkflowExecution
+            );
+        }
+
+        wfm.shutdown().await.unwrap();
+    }
+}

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

@@ -0,0 +1,171 @@
+use super::{
+    workflow_machines::MachineResponse, Cancellable, EventInfo, HistoryEvent, MachineKind,
+    NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError,
+};
+use rustfsm::{fsm, TransitionResult};
+use std::convert::TryFrom;
+use temporal_sdk_core_protos::{
+    coresdk::workflow_commands::CancelWorkflowExecution,
+    temporal::api::{
+        command::v1::Command,
+        enums::v1::{CommandType, EventType},
+    },
+};
+
+fsm! {
+    pub(super)
+    name CancelWorkflowMachine;
+    command CancelWorkflowCommand;
+    error WFMachinesError;
+
+    Created --(Schedule, on_schedule) --> CancelWorkflowCommandCreated;
+
+    CancelWorkflowCommandCreated --(CommandCancelWorkflowExecution)
+        --> CancelWorkflowCommandCreated;
+    CancelWorkflowCommandCreated --(WorkflowExecutionCanceled)
+        --> CancelWorkflowCommandRecorded;
+}
+
+#[derive(thiserror::Error, Debug)]
+pub(super) enum CancelWorkflowMachineError {}
+
+#[derive(Debug, derive_more::Display)]
+pub(super) enum CancelWorkflowCommand {}
+
+pub(super) fn cancel_workflow(attribs: CancelWorkflowExecution) -> NewMachineWithCommand {
+    let mut machine = CancelWorkflowMachine {
+        state: Created {}.into(),
+        shared_state: (),
+    };
+    OnEventWrapper::on_event_mut(&mut machine, CancelWorkflowMachineEvents::Schedule)
+        .expect("Scheduling continue as new machine doesn't fail");
+    let command = Command {
+        command_type: CommandType::CancelWorkflowExecution as i32,
+        attributes: Some(attribs.into()),
+    };
+    NewMachineWithCommand {
+        command,
+        machine: machine.into(),
+    }
+}
+
+#[derive(Default, Clone)]
+pub(super) struct CancelWorkflowCommandCreated {}
+
+#[derive(Default, Clone)]
+pub(super) struct CancelWorkflowCommandRecorded {}
+
+impl From<CancelWorkflowCommandCreated> for CancelWorkflowCommandRecorded {
+    fn from(_: CancelWorkflowCommandCreated) -> Self {
+        Self::default()
+    }
+}
+
+#[derive(Default, Clone)]
+pub(super) struct Created {}
+
+impl Created {
+    pub(super) fn on_schedule(
+        self,
+    ) -> CancelWorkflowMachineTransition<CancelWorkflowCommandCreated> {
+        TransitionResult::default()
+    }
+}
+
+impl TryFrom<HistoryEvent> for CancelWorkflowMachineEvents {
+    type Error = WFMachinesError;
+
+    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
+        Ok(match EventType::from_i32(e.event_type) {
+            Some(EventType::WorkflowExecutionCanceled) => Self::WorkflowExecutionCanceled,
+            _ => {
+                return Err(WFMachinesError::Nondeterminism(format!(
+                    "Cancel workflow machine does not handle this event: {}",
+                    e
+                )))
+            }
+        })
+    }
+}
+
+impl TryFrom<CommandType> for CancelWorkflowMachineEvents {
+    type Error = ();
+
+    fn try_from(c: CommandType) -> Result<Self, Self::Error> {
+        Ok(match c {
+            CommandType::CancelWorkflowExecution => Self::CommandCancelWorkflowExecution,
+            _ => return Err(()),
+        })
+    }
+}
+
+impl WFMachinesAdapter for CancelWorkflowMachine {
+    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::WorkflowExecutionCanceled
+    }
+
+    fn kind(&self) -> MachineKind {
+        MachineKind::CancelWorkflow
+    }
+}
+
+impl Cancellable for CancelWorkflowMachine {}
+
+#[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};
+    use temporal_sdk_core_protos::coresdk::workflow_activation::{
+        workflow_activation_job, WorkflowActivationJob,
+    };
+
+    async fn wf_with_timer(ctx: WfContext) -> WorkflowResult<()> {
+        ctx.timer(Duration::from_millis(500)).await;
+        Ok(WfExitValue::Cancelled)
+    }
+
+    #[tokio::test]
+    async fn wf_completing_with_cancelled() {
+        let func = WorkflowFunction::new(wf_with_timer);
+        let t = canned_histories::timer_wf_cancel_req_cancelled("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);
+
+        let act = wfm.get_next_activation().await.unwrap();
+        assert_matches!(
+            act.jobs.as_slice(),
+            [
+                WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::FireTimer(_)),
+                },
+                WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::CancelWorkflow(_)),
+                }
+            ]
+        );
+        let commands = wfm.get_server_commands().commands;
+        assert_eq!(commands.len(), 1);
+        assert_eq!(
+            commands[0].command_type,
+            CommandType::CancelWorkflowExecution 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();
+    }
+}