temporalio 0.1.1 → 0.2.0

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

@@ -1,294 +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::{
-        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<HistEventData> for CancelExternalMachineEvents {
-    type Error = WFMachinesError;
-
-    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
-        let e = e.event;
-        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
-        )
-    }
-}
-
-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

@@ -1,168 +0,0 @@
-use super::{
-    workflow_machines::MachineResponse, Cancellable, EventInfo, HistoryEvent,
-    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::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<HistEventData> for CancelWorkflowMachineEvents {
-    type Error = WFMachinesError;
-
-    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
-        let e = e.event;
-        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
-    }
-}
-
-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();
-    }
-}