temporalio 0.1.1 → 0.2.0

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

@@ -1,435 +0,0 @@
-#![allow(clippy::large_enum_variant)]
-
-use super::{
-    workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
-    OnEventWrapper, WFMachinesAdapter,
-};
-use crate::worker::workflow::{machines::HistEventData, WFMachinesError};
-use rustfsm::{fsm, MachineError, StateMachine, TransitionResult};
-use std::convert::TryFrom;
-use temporal_sdk_core_protos::{
-    coresdk::{
-        workflow_activation::FireTimer,
-        workflow_commands::{CancelTimer, StartTimer},
-        HistoryEventId,
-    },
-    temporal::api::{
-        command::v1::Command,
-        enums::v1::{CommandType, EventType},
-        history::v1::{history_event, HistoryEvent, TimerFiredEventAttributes},
-    },
-};
-
-fsm! {
-    pub(super) name TimerMachine;
-    command TimerMachineCommand;
-    error WFMachinesError;
-    shared_state SharedState;
-
-    Created --(Schedule, on_schedule) --> StartCommandCreated;
-
-    StartCommandCreated --(CommandStartTimer) --> StartCommandCreated;
-    StartCommandCreated --(TimerStarted(HistoryEventId), on_timer_started) --> StartCommandRecorded;
-    StartCommandCreated --(Cancel, shared on_cancel) --> Canceled;
-
-    StartCommandRecorded --(TimerFired(TimerFiredEventAttributes), shared on_timer_fired) --> Fired;
-    StartCommandRecorded --(Cancel, shared on_cancel) --> CancelTimerCommandCreated;
-
-    CancelTimerCommandCreated --(Cancel) --> CancelTimerCommandCreated;
-    CancelTimerCommandCreated
-        --(CommandCancelTimer, on_command_cancel_timer) --> CancelTimerCommandSent;
-
-    CancelTimerCommandSent --(TimerCanceled) --> Canceled;
-
-    // Ignore any spurious cancellations after resolution
-    Canceled --(Cancel) --> Canceled;
-    Fired --(Cancel) --> Fired;
-}
-
-#[derive(Debug, derive_more::Display)]
-pub(super) enum TimerMachineCommand {
-    Complete,
-    IssueCancelCmd(Command),
-    // We don't issue activations for timer cancellations. Lang SDK is expected to cancel
-    // it's own timers when user calls cancel, and they cannot be cancelled by any other
-    // means.
-}
-
-#[derive(Default, Clone)]
-pub(super) struct SharedState {
-    attrs: StartTimer,
-    cancelled_before_sent: bool,
-}
-
-/// Creates a new, scheduled, timer as a [CancellableCommand]
-pub(super) fn new_timer(attribs: StartTimer) -> NewMachineWithCommand {
-    let (timer, add_cmd) = TimerMachine::new_scheduled(attribs);
-    NewMachineWithCommand {
-        command: add_cmd,
-        machine: timer.into(),
-    }
-}
-
-impl TimerMachine {
-    /// Create a new timer and immediately schedule it
-    fn new_scheduled(attribs: StartTimer) -> (Self, Command) {
-        let mut s = Self::new(attribs);
-        OnEventWrapper::on_event_mut(&mut s, TimerMachineEvents::Schedule)
-            .expect("Scheduling timers doesn't fail");
-        let cmd = Command {
-            command_type: CommandType::StartTimer as i32,
-            attributes: Some(s.shared_state().attrs.clone().into()),
-        };
-        (s, cmd)
-    }
-
-    fn new(attribs: StartTimer) -> Self {
-        Self {
-            state: Created {}.into(),
-            shared_state: SharedState {
-                attrs: attribs,
-                cancelled_before_sent: false,
-            },
-        }
-    }
-}
-
-impl TryFrom<HistEventData> for TimerMachineEvents {
-    type Error = WFMachinesError;
-
-    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
-        let e = e.event;
-        Ok(match e.event_type() {
-            EventType::TimerStarted => Self::TimerStarted(e.event_id),
-            EventType::TimerCanceled => Self::TimerCanceled,
-            EventType::TimerFired => {
-                if let Some(history_event::Attributes::TimerFiredEventAttributes(attrs)) =
-                    e.attributes
-                {
-                    Self::TimerFired(attrs)
-                } else {
-                    return Err(WFMachinesError::Fatal(format!(
-                        "Timer fired attribs were unset: {e}"
-                    )));
-                }
-            }
-            _ => {
-                return Err(WFMachinesError::Nondeterminism(format!(
-                    "Timer machine does not handle this event: {e}"
-                )))
-            }
-        })
-    }
-}
-
-impl TryFrom<CommandType> for TimerMachineEvents {
-    type Error = ();
-
-    fn try_from(c: CommandType) -> Result<Self, Self::Error> {
-        Ok(match c {
-            CommandType::StartTimer => Self::CommandStartTimer,
-            CommandType::CancelTimer => Self::CommandCancelTimer,
-            _ => return Err(()),
-        })
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct Created {}
-
-impl Created {
-    pub(super) fn on_schedule(self) -> TimerMachineTransition<StartCommandCreated> {
-        TransitionResult::default()
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct CancelTimerCommandCreated {}
-
-impl CancelTimerCommandCreated {
-    pub(super) fn on_command_cancel_timer(self) -> TimerMachineTransition<CancelTimerCommandSent> {
-        TransitionResult::ok(vec![], CancelTimerCommandSent::default())
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct CancelTimerCommandSent {}
-
-#[derive(Default, Clone)]
-pub(super) struct Canceled {}
-
-impl From<CancelTimerCommandSent> for Canceled {
-    fn from(_: CancelTimerCommandSent) -> Self {
-        Self::default()
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct Fired {}
-
-#[derive(Default, Clone)]
-pub(super) struct StartCommandCreated {}
-
-impl StartCommandCreated {
-    pub(super) fn on_timer_started(
-        self,
-        _id: HistoryEventId,
-    ) -> TimerMachineTransition<StartCommandRecorded> {
-        TransitionResult::default()
-    }
-
-    pub(super) fn on_cancel(self, dat: SharedState) -> TimerMachineTransition<Canceled> {
-        TransitionResult::ok_shared(
-            vec![],
-            Canceled::default(),
-            SharedState {
-                cancelled_before_sent: true,
-                ..dat
-            },
-        )
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct StartCommandRecorded {}
-
-impl StartCommandRecorded {
-    pub(super) fn on_timer_fired(
-        self,
-        dat: SharedState,
-        attrs: TimerFiredEventAttributes,
-    ) -> TimerMachineTransition<Fired> {
-        if dat.attrs.seq.to_string() == attrs.timer_id {
-            TransitionResult::ok(vec![TimerMachineCommand::Complete], Fired::default())
-        } else {
-            TransitionResult::Err(WFMachinesError::Fatal(format!(
-                "Timer fired event did not have expected timer id {}, it was {}!",
-                dat.attrs.seq, attrs.timer_id
-            )))
-        }
-    }
-
-    pub(super) fn on_cancel(
-        self,
-        dat: SharedState,
-    ) -> TimerMachineTransition<CancelTimerCommandCreated> {
-        let cmd = Command {
-            command_type: CommandType::CancelTimer as i32,
-            attributes: Some(CancelTimer { seq: dat.attrs.seq }.into()),
-        };
-        TransitionResult::ok(
-            vec![TimerMachineCommand::IssueCancelCmd(cmd)],
-            CancelTimerCommandCreated::default(),
-        )
-    }
-}
-
-impl WFMachinesAdapter for TimerMachine {
-    fn adapt_response(
-        &self,
-        my_command: TimerMachineCommand,
-        _event_info: Option<EventInfo>,
-    ) -> Result<Vec<MachineResponse>, WFMachinesError> {
-        Ok(match my_command {
-            // Fire the completion
-            TimerMachineCommand::Complete => vec![FireTimer {
-                seq: self.shared_state.attrs.seq,
-            }
-            .into()],
-            TimerMachineCommand::IssueCancelCmd(c) => vec![MachineResponse::IssueNewCommand(c)],
-        })
-    }
-
-    fn matches_event(&self, event: &HistoryEvent) -> bool {
-        matches!(
-            event.event_type(),
-            EventType::TimerStarted | EventType::TimerCanceled | EventType::TimerFired
-        )
-    }
-}
-
-impl Cancellable for TimerMachine {
-    fn cancel(&mut self) -> Result<Vec<MachineResponse>, MachineError<Self::Error>> {
-        Ok(
-            match OnEventWrapper::on_event_mut(self, TimerMachineEvents::Cancel)?.pop() {
-                Some(TimerMachineCommand::IssueCancelCmd(cmd)) => {
-                    vec![MachineResponse::IssueNewCommand(cmd)]
-                }
-                None => vec![],
-                x => panic!("Invalid cancel event response {x:?}"),
-            },
-        )
-    }
-
-    fn was_cancelled_before_sent_to_server(&self) -> bool {
-        self.shared_state().cancelled_before_sent
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::{
-        replay::TestHistoryBuilder, test_help::canned_histories, worker::workflow::ManagedWFFunc,
-    };
-    use rstest::{fixture, rstest};
-    use std::{mem::discriminant, time::Duration};
-    use temporal_sdk::{CancellableFuture, WfContext, WorkflowFunction};
-
-    #[fixture]
-    fn happy_wfm() -> ManagedWFFunc {
-        /*
-            We have two versions of this test, one which processes the history in two calls, and one
-            which replays all of it in one go. Both versions must produce the same two activations.
-            However, The former will iterate the machines three times and the latter will iterate
-            them twice.
-
-            There are two workflow tasks, so it seems we should iterate two times, but the reason
-            for the extra iteration in the incremental version is that we need to "wait" for the
-            timer to fire. In the all-in-one-go test, the timer is created and resolved in the same
-            task, hence no extra loop.
-        */
-        let func = WorkflowFunction::new(|command_sink: WfContext| async move {
-            command_sink.timer(Duration::from_secs(5)).await;
-            Ok(().into())
-        });
-
-        let t = canned_histories::single_timer("1");
-        assert_eq!(2, t.get_full_history_info().unwrap().wf_task_count());
-        ManagedWFFunc::new(t, func, vec![])
-    }
-
-    #[rstest]
-    #[tokio::test]
-    async fn test_fire_happy_path_inc(mut happy_wfm: ManagedWFFunc) {
-        happy_wfm.get_next_activation().await.unwrap();
-        let commands = happy_wfm.get_server_commands().commands;
-        assert_eq!(commands.len(), 1);
-        assert_eq!(commands[0].command_type, CommandType::StartTimer as i32);
-
-        happy_wfm.get_next_activation().await.unwrap();
-        let commands = happy_wfm.get_server_commands().commands;
-        assert_eq!(commands.len(), 1);
-        assert_eq!(commands.len(), 1);
-        assert_eq!(
-            commands[0].command_type,
-            CommandType::CompleteWorkflowExecution as i32
-        );
-        happy_wfm.shutdown().await.unwrap();
-    }
-
-    #[rstest]
-    #[tokio::test]
-    async fn test_fire_happy_path_full(mut happy_wfm: ManagedWFFunc) {
-        happy_wfm.process_all_activations().await.unwrap();
-        let commands = happy_wfm.get_server_commands().commands;
-        assert_eq!(commands.len(), 1);
-        assert_eq!(
-            commands[0].command_type,
-            CommandType::CompleteWorkflowExecution as i32
-        );
-        happy_wfm.shutdown().await.unwrap();
-    }
-
-    #[tokio::test]
-    async fn mismatched_timer_ids_errors() {
-        let func = WorkflowFunction::new(|command_sink: WfContext| async move {
-            command_sink.timer(Duration::from_secs(5)).await;
-            Ok(().into())
-        });
-
-        let t = canned_histories::single_timer("badid");
-        let mut wfm = ManagedWFFunc::new(t, func, vec![]);
-        let act = wfm.process_all_activations().await;
-        assert!(act
-            .unwrap_err()
-            .to_string()
-            .contains("Timer fired event did not have expected timer id 1"));
-        wfm.shutdown().await.unwrap();
-    }
-
-    #[fixture]
-    fn cancellation_setup() -> ManagedWFFunc {
-        let func = WorkflowFunction::new(|ctx: WfContext| async move {
-            let cancel_timer_fut = ctx.timer(Duration::from_secs(500));
-            ctx.timer(Duration::from_secs(5)).await;
-            // Cancel the first timer after having waited on the second
-            cancel_timer_fut.cancel(&ctx);
-            cancel_timer_fut.await;
-            Ok(().into())
-        });
-
-        let t = canned_histories::cancel_timer("2", "1");
-        ManagedWFFunc::new(t, func, vec![])
-    }
-
-    #[rstest]
-    #[tokio::test]
-    async fn incremental_cancellation(#[from(cancellation_setup)] mut wfm: ManagedWFFunc) {
-        wfm.get_next_activation().await.unwrap();
-        let commands = wfm.get_server_commands().commands;
-        assert_eq!(commands.len(), 2);
-        assert_eq!(commands[0].command_type, CommandType::StartTimer as i32);
-        assert_eq!(commands[1].command_type, CommandType::StartTimer as i32);
-
-        wfm.get_next_activation().await.unwrap();
-        let commands = wfm.get_server_commands().commands;
-        assert_eq!(commands.len(), 2);
-        assert_eq!(commands[0].command_type, CommandType::CancelTimer as i32);
-        assert_eq!(
-            commands[1].command_type,
-            CommandType::CompleteWorkflowExecution as i32
-        );
-
-        assert!(wfm.get_next_activation().await.unwrap().jobs.is_empty());
-        let commands = wfm.get_server_commands().commands;
-        // There should be no commands - the wf completed at the same time the timer was cancelled
-        assert_eq!(commands.len(), 0);
-        wfm.shutdown().await.unwrap();
-    }
-
-    #[rstest]
-    #[tokio::test]
-    async fn full_cancellation(#[from(cancellation_setup)] mut wfm: ManagedWFFunc) {
-        wfm.process_all_activations().await.unwrap();
-        let commands = wfm.get_server_commands().commands;
-        // There should be no commands - the wf completed at the same time the timer was cancelled
-        assert_eq!(commands.len(), 0);
-        wfm.shutdown().await.unwrap();
-    }
-
-    #[tokio::test]
-    async fn cancel_before_sent_to_server() {
-        let func = WorkflowFunction::new(|ctx: WfContext| async move {
-            let cancel_timer_fut = ctx.timer(Duration::from_secs(500));
-            // Immediately cancel the timer
-            cancel_timer_fut.cancel(&ctx);
-            cancel_timer_fut.await;
-            Ok(().into())
-        });
-
-        let mut t = TestHistoryBuilder::default();
-        t.add_by_type(EventType::WorkflowExecutionStarted);
-        t.add_full_wf_task();
-        t.add_workflow_execution_completed();
-        let mut wfm = ManagedWFFunc::new(t, func, vec![]);
-
-        wfm.process_all_activations().await.unwrap();
-        let commands = wfm.get_server_commands().commands;
-        assert_eq!(commands.len(), 0);
-        wfm.shutdown().await.unwrap();
-    }
-
-    #[test]
-    fn cancels_ignored_terminal() {
-        for state in [TimerMachineState::Canceled(Canceled {}), Fired {}.into()] {
-            let mut s = TimerMachine {
-                state: state.clone(),
-                shared_state: Default::default(),
-            };
-            let cmds = s.cancel().unwrap();
-            assert_eq!(cmds.len(), 0);
-            assert_eq!(discriminant(&state), discriminant(&s.state));
-        }
-    }
-}

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

@@ -1,175 +0,0 @@
-//! Look, I'm not happy about the code in here, and you shouldn't be either. This is all an awful,
-//! dirty hack to work around the fact that there's no such thing as "run this after all unit tests"
-//! in stable Rust. Don't do the things in here. They're bad. This is test only code, and should
-//! never ever be removed from behind `#[cfg(test)]` compilation.
-
-use dashmap::{mapref::entry::Entry, DashMap, DashSet};
-use std::{
-    path::PathBuf,
-    sync::{
-        mpsc::{sync_channel, SyncSender},
-        Mutex,
-    },
-    thread::JoinHandle,
-    time::Duration,
-};
-
-// During test we want to know about which transitions we've covered in state machines
-lazy_static::lazy_static! {
-    static ref COVERED_TRANSITIONS: DashMap<String, DashSet<CoveredTransition>>
-        = DashMap::new();
-    static ref COVERAGE_SENDER: SyncSender<(String, CoveredTransition)> =
-        spawn_save_coverage_at_end();
-    static ref THREAD_HANDLE: Mutex<Option<JoinHandle<()>>> = Mutex::new(None);
-}
-
-#[derive(Eq, PartialEq, Hash, Debug)]
-struct CoveredTransition {
-    from_state: String,
-    to_state: String,
-    event: String,
-}
-
-pub fn add_coverage(machine_name: String, from_state: String, to_state: String, event: String) {
-    let ct = CoveredTransition {
-        from_state,
-        to_state,
-        event,
-    };
-    let _ = COVERAGE_SENDER.send((machine_name, ct));
-}
-
-fn spawn_save_coverage_at_end() -> SyncSender<(String, CoveredTransition)> {
-    let (tx, rx) = sync_channel(1000);
-    let handle = std::thread::spawn(move || {
-        // Assume that, if the entire program hasn't run a state machine transition in the
-        // last second that we are probably done running all the tests. This is to avoid
-        // needing to instrument every single test.
-        while let Ok((machine_name, ct)) = rx.recv_timeout(Duration::from_secs(1)) {
-            match COVERED_TRANSITIONS.entry(machine_name) {
-                Entry::Occupied(o) => {
-                    o.get().insert(ct);
-                }
-                Entry::Vacant(v) => {
-                    v.insert({
-                        let ds = DashSet::new();
-                        ds.insert(ct);
-                        ds
-                    });
-                }
-            }
-        }
-    });
-    *THREAD_HANDLE.lock().unwrap() = Some(handle);
-    tx
-}
-
-#[cfg(test)]
-mod machine_coverage_report {
-    use super::*;
-    use crate::worker::workflow::machines::{
-        activity_state_machine::ActivityMachine,
-        cancel_external_state_machine::CancelExternalMachine,
-        cancel_workflow_state_machine::CancelWorkflowMachine,
-        child_workflow_state_machine::ChildWorkflowMachine,
-        complete_workflow_state_machine::CompleteWorkflowMachine,
-        continue_as_new_workflow_state_machine::ContinueAsNewWorkflowMachine,
-        fail_workflow_state_machine::FailWorkflowMachine,
-        local_activity_state_machine::LocalActivityMachine,
-        modify_workflow_properties_state_machine::ModifyWorkflowPropertiesMachine,
-        patch_state_machine::PatchMachine, signal_external_state_machine::SignalExternalMachine,
-        timer_state_machine::TimerMachine,
-        upsert_search_attributes_state_machine::UpsertSearchAttributesMachine,
-        workflow_task_state_machine::WorkflowTaskMachine,
-    };
-    use rustfsm::StateMachine;
-    use std::{fs::File, io::Write};
-
-    // This "test" needs to exist so that we have a way to join the spawned thread. Otherwise
-    // it'll just get abandoned.
-    #[test]
-    // Use `cargo test -- --include-ignored` to run this. We don't want to bother with it by default
-    // because it takes a minimum of a second.
-    #[ignore]
-    fn reporter() {
-        // Make sure thread handle exists
-        let _ = &*COVERAGE_SENDER;
-        // Join it
-        THREAD_HANDLE
-            .lock()
-            .unwrap()
-            .take()
-            .unwrap()
-            .join()
-            .unwrap();
-
-        // Gather visualizations for all machines
-        let mut activity = ActivityMachine::visualizer().to_owned();
-        let mut timer = TimerMachine::visualizer().to_owned();
-        let mut child_wf = ChildWorkflowMachine::visualizer().to_owned();
-        let mut complete_wf = CompleteWorkflowMachine::visualizer().to_owned();
-        let mut wf_task = WorkflowTaskMachine::visualizer().to_owned();
-        let mut fail_wf = FailWorkflowMachine::visualizer().to_owned();
-        let mut cont_as_new = ContinueAsNewWorkflowMachine::visualizer().to_owned();
-        let mut cancel_wf = CancelWorkflowMachine::visualizer().to_owned();
-        let mut version = PatchMachine::visualizer().to_owned();
-        let mut signal_ext = SignalExternalMachine::visualizer().to_owned();
-        let mut cancel_ext = CancelExternalMachine::visualizer().to_owned();
-        let mut la_mach = LocalActivityMachine::visualizer().to_owned();
-        let mut upsert_search_attr = UpsertSearchAttributesMachine::visualizer().to_owned();
-        let mut modify_wf_props = ModifyWorkflowPropertiesMachine::visualizer().to_owned();
-
-        // This isn't at all efficient but doesn't need to be.
-        // Replace transitions in the vizzes with green color if they are covered.
-        for item in COVERED_TRANSITIONS.iter() {
-            let (machine, coverage) = item.pair();
-            match machine.as_ref() {
-                m @ "ActivityMachine" => cover_transitions(m, &mut activity, coverage),
-                m @ "TimerMachine" => cover_transitions(m, &mut timer, coverage),
-                m @ "ChildWorkflowMachine" => cover_transitions(m, &mut child_wf, coverage),
-                m @ "CompleteWorkflowMachine" => cover_transitions(m, &mut complete_wf, coverage),
-                m @ "WorkflowTaskMachine" => cover_transitions(m, &mut wf_task, coverage),
-                m @ "FailWorkflowMachine" => cover_transitions(m, &mut fail_wf, coverage),
-                m @ "ContinueAsNewWorkflowMachine" => {
-                    cover_transitions(m, &mut cont_as_new, coverage);
-                }
-                m @ "CancelWorkflowMachine" => cover_transitions(m, &mut cancel_wf, coverage),
-                m @ "PatchMachine" => cover_transitions(m, &mut version, coverage),
-                m @ "SignalExternalMachine" => cover_transitions(m, &mut signal_ext, coverage),
-                m @ "CancelExternalMachine" => cover_transitions(m, &mut cancel_ext, coverage),
-                m @ "LocalActivityMachine" => cover_transitions(m, &mut la_mach, coverage),
-                m @ "UpsertSearchAttributesMachine" => {
-                    cover_transitions(m, &mut upsert_search_attr, coverage)
-                }
-                m @ "ModifyWorkflowPropertiesMachine" => {
-                    cover_transitions(m, &mut modify_wf_props, coverage)
-                }
-                m => panic!("Unknown machine {m}"),
-            }
-        }
-    }
-
-    fn cover_transitions(machine: &str, viz: &mut String, cov: &DashSet<CoveredTransition>) {
-        for trans in cov.iter() {
-            let find_line = format!(
-                "{} --> {}: {}",
-                trans.from_state, trans.to_state, trans.event
-            );
-            if let Some(start) = viz.find(&find_line) {
-                let new_line = format!(
-                    "{} -[#blue]-> {}: {}",
-                    trans.from_state, trans.to_state, trans.event
-                );
-                viz.replace_range(start..start + find_line.len(), &new_line);
-            }
-        }
-
-        // Dump the updated viz to a file
-        let mut d = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-        d.push("machine_coverage");
-        std::fs::create_dir_all(&d).unwrap();
-        d.push(format!("{machine}_Coverage.puml"));
-        let mut file = File::create(d).unwrap();
-        file.write_all(viz.as_bytes()).unwrap();
-    }
-}