temporalio 0.0.1 → 0.1.0

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

@@ -8,11 +8,8 @@ mod complete_workflow_state_machine;
 mod continue_as_new_workflow_state_machine;
 mod fail_workflow_state_machine;
 mod local_activity_state_machine;
-#[allow(unused)]
-mod mutable_side_effect_state_machine;
+mod modify_workflow_properties_state_machine;
 mod patch_state_machine;
-#[allow(unused)]
-mod side_effect_state_machine;
 mod signal_external_state_machine;
 mod timer_state_machine;
 mod upsert_search_attributes_state_machine;
@@ -21,9 +18,9 @@ mod workflow_task_state_machine;
 #[cfg(test)]
 mod transition_coverage;
 
-pub(crate) use workflow_machines::{WFMachinesError, WorkflowMachines};
+pub(crate) use workflow_machines::WorkflowMachines;
 
-use crate::telemetry::VecDisplayer;
+use crate::{telemetry::VecDisplayer, worker::workflow::WFMachinesError};
 use activity_state_machine::ActivityMachine;
 use cancel_external_state_machine::CancelExternalMachine;
 use cancel_workflow_state_machine::CancelWorkflowMachine;
@@ -32,8 +29,8 @@ use complete_workflow_state_machine::CompleteWorkflowMachine;
 use continue_as_new_workflow_state_machine::ContinueAsNewWorkflowMachine;
 use fail_workflow_state_machine::FailWorkflowMachine;
 use local_activity_state_machine::LocalActivityMachine;
+use modify_workflow_properties_state_machine::ModifyWorkflowPropertiesMachine;
 use patch_state_machine::PatchMachine;
-use prost::alloc::fmt::Formatter;
 use rustfsm::{MachineError, StateMachine};
 use signal_external_state_machine::SignalExternalMachine;
 use std::{
@@ -53,23 +50,6 @@ use workflow_task_state_machine::WorkflowTaskMachine;
 #[cfg(test)]
 use transition_coverage::add_coverage;
 
-#[derive(Copy, Clone, Debug, derive_more::Display, Eq, PartialEq)]
-enum MachineKind {
-    Activity,
-    CancelWorkflow,
-    ChildWorkflow,
-    CompleteWorkflow,
-    ContinueAsNewWorkflow,
-    FailWorkflow,
-    Timer,
-    Patch,
-    WorkflowTask,
-    SignalExternalWorkflow,
-    CancelExternalWorkflow,
-    LocalActivity,
-    UpsertSearchAttributes,
-}
-
 #[enum_dispatch::enum_dispatch]
 #[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
 enum Machines {
@@ -86,14 +66,14 @@ enum Machines {
     TimerMachine,
     WorkflowTaskMachine,
     UpsertSearchAttributesMachine,
+    ModifyWorkflowPropertiesMachine,
 }
 
 /// Extends [rustfsm::StateMachine] with some functionality specific to the temporal SDK.
 ///
 /// Formerly known as `EntityStateMachine` in Java.
 #[enum_dispatch::enum_dispatch(Machines)]
-trait TemporalStateMachine: Send {
-    fn kind(&self) -> MachineKind;
+trait TemporalStateMachine {
     fn handle_command(
         &mut self,
         command_type: CommandType,
@@ -108,8 +88,7 @@ trait TemporalStateMachine: Send {
     /// to update the overall state of the workflow. EX: To issue outgoing WF activations.
     fn handle_event(
         &mut self,
-        event: HistoryEvent,
-        has_next_event: bool,
+        event: HistEventData,
     ) -> Result<Vec<MachineResponse>, WFMachinesError>;
 
     /// Attempt to cancel the command associated with this state machine, if it is cancellable
@@ -121,21 +100,20 @@ trait TemporalStateMachine: Send {
 
     /// Returns true if the state machine is in a final state
     fn is_final_state(&self) -> bool;
+
+    /// Returns a friendly name for the type of this machine
+    fn name(&self) -> &str;
 }
 
 impl<SM> TemporalStateMachine for SM
 where
-    SM: StateMachine + WFMachinesAdapter + Cancellable + OnEventWrapper + Clone + Send + 'static,
-    <SM as StateMachine>::Event: TryFrom<HistoryEvent> + TryFrom<CommandType> + Display,
-    WFMachinesError: From<<<SM as StateMachine>::Event as TryFrom<HistoryEvent>>::Error>,
+    SM: StateMachine + WFMachinesAdapter + Cancellable + OnEventWrapper + Clone + 'static,
+    <SM as StateMachine>::Event: TryFrom<HistEventData> + TryFrom<CommandType> + Display,
+    WFMachinesError: From<<<SM as StateMachine>::Event as TryFrom<HistEventData>>::Error>,
     <SM as StateMachine>::Command: Debug + Display,
     <SM as StateMachine>::State: Display,
     <SM as StateMachine>::Error: Into<WFMachinesError> + 'static + Send + Sync,
 {
-    fn kind(&self) -> MachineKind {
-        self.kind()
-    }
-
     fn handle_command(
         &mut self,
         command_type: CommandType,
@@ -162,7 +140,7 @@ where
             Err(WFMachinesError::Nondeterminism(format!(
                 "Unexpected command {:?} generated by a {:?} machine",
                 command_type,
-                self.kind()
+                self.name()
             )))
         }
     }
@@ -173,21 +151,19 @@ where
 
     fn handle_event(
         &mut self,
-        event: HistoryEvent,
-        has_next_event: bool,
+        event_dat: HistEventData,
     ) -> Result<Vec<MachineResponse>, WFMachinesError> {
         trace!(
-            event = %event,
+            event = %event_dat.event,
             machine_name = %self.name(),
             state = %self.state(),
             "handling event"
         );
         let event_info = EventInfo {
-            event_id: event.event_id,
-            event_type: event.event_type(),
-            has_next_event,
+            event_id: event_dat.event.event_id,
+            event_type: event_dat.event.event_type(),
         };
-        let converted_event: <Self as StateMachine>::Event = event.try_into()?;
+        let converted_event: <Self as StateMachine>::Event = event_dat.try_into()?;
 
         match OnEventWrapper::on_event_mut(self, converted_event) {
             Ok(c) => process_machine_commands(self, c, Some(event_info)),
@@ -220,6 +196,10 @@ where
     fn is_final_state(&self) -> bool {
         self.has_reached_final_state()
     }
+
+    fn name(&self) -> &str {
+        self.name()
+    }
 }
 
 fn process_machine_commands<SM>(
@@ -234,8 +214,8 @@ where
     <SM as StateMachine>::State: Display,
 {
     if !commands.is_empty() {
-        debug!(commands=%commands.display(), state=%machine.state(),
-               machine_name=%TemporalStateMachine::kind(machine), "Machine produced commands");
+        trace!(commands=%commands.display(), state=%machine.state(),
+               machine_name=%TemporalStateMachine::name(machine), "Machine produced commands");
     }
     let mut machine_responses = vec![];
     for cmd in commands {
@@ -260,16 +240,24 @@ trait WFMachinesAdapter: StateMachine {
     /// ahead of time if it's worth trying to call [TemporalStateMachine::handle_event] without
     /// requiring mutable access.
     fn matches_event(&self, event: &HistoryEvent) -> bool;
+}
 
-    /// Allows robust identification of the type of machine
-    fn kind(&self) -> MachineKind;
+/// Wraps a history event with extra relevant data that a machine might care about while the event
+/// is being applied to it.
+#[derive(Debug, derive_more::Display)]
+#[display(fmt = "{event}")]
+struct HistEventData {
+    event: HistoryEvent,
+    /// Is the current workflow task under replay or not during application of this event?
+    replaying: bool,
+    /// Is the current workflow task the last task in history?
+    current_task_is_last_in_history: bool,
 }
 
 #[derive(Debug, Copy, Clone)]
 struct EventInfo {
     event_id: i64,
     event_type: EventType,
-    has_next_event: bool,
 }
 
 trait Cancellable: StateMachine {
@@ -334,9 +322,3 @@ struct NewMachineWithCommand {
     command: ProtoCommand,
     machine: Machines,
 }
-
-impl Debug for dyn TemporalStateMachine {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        std::fmt::Display::fmt(&self.kind(), f)
-    }
-}

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

@@ -0,0 +1,179 @@
+use super::{workflow_machines::MachineResponse, NewMachineWithCommand};
+use crate::worker::workflow::{
+    machines::{Cancellable, EventInfo, HistEventData, WFMachinesAdapter},
+    WFMachinesError,
+};
+use rustfsm::{fsm, TransitionResult};
+use temporal_sdk_core_protos::{
+    coresdk::workflow_commands::ModifyWorkflowProperties,
+    temporal::api::{
+        command::v1::Command,
+        enums::v1::{CommandType, EventType},
+        history::v1::HistoryEvent,
+    },
+};
+
+fsm! {
+    pub(super) name ModifyWorkflowPropertiesMachine;
+    command ModifyWorkflowPropertiesMachineCommand;
+    error WFMachinesError;
+    shared_state SharedState;
+
+    Created --(CommandScheduled) --> CommandIssued;
+    CommandIssued --(CommandRecorded) --> Done;
+}
+
+/// Instantiates an ModifyWorkflowPropertiesMachine and packs it together with the command to
+/// be sent to server.
+pub(super) fn modify_workflow_properties(
+    lang_cmd: ModifyWorkflowProperties,
+) -> NewMachineWithCommand {
+    let sm = ModifyWorkflowPropertiesMachine {
+        state: Created {}.into(),
+        shared_state: (),
+    };
+    let cmd = Command {
+        command_type: CommandType::ModifyWorkflowProperties as i32,
+        attributes: Some(lang_cmd.into()),
+    };
+    NewMachineWithCommand {
+        command: cmd,
+        machine: sm.into(),
+    }
+}
+
+type SharedState = ();
+
+#[derive(Debug, derive_more::Display)]
+pub(super) enum ModifyWorkflowPropertiesMachineCommand {}
+
+#[derive(Debug, Default, Clone, derive_more::Display)]
+pub(super) struct Created {}
+
+#[derive(Debug, Default, Clone, derive_more::Display)]
+pub(super) struct CommandIssued {}
+
+#[derive(Debug, Default, Clone, derive_more::Display)]
+pub(super) struct Done {}
+
+impl WFMachinesAdapter for ModifyWorkflowPropertiesMachine {
+    fn adapt_response(
+        &self,
+        _my_command: Self::Command,
+        _event_info: Option<EventInfo>,
+    ) -> Result<Vec<MachineResponse>, Self::Error> {
+        Err(Self::Error::Nondeterminism(
+            "ModifyWorkflowProperties does not use state machine commands".to_string(),
+        ))
+    }
+
+    fn matches_event(&self, event: &HistoryEvent) -> bool {
+        matches!(event.event_type(), EventType::WorkflowPropertiesModified)
+    }
+}
+
+impl Cancellable for ModifyWorkflowPropertiesMachine {}
+
+impl TryFrom<HistEventData> for ModifyWorkflowPropertiesMachineEvents {
+    type Error = WFMachinesError;
+
+    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
+        let e = e.event;
+        match e.event_type() {
+            EventType::WorkflowPropertiesModified => {
+                Ok(ModifyWorkflowPropertiesMachineEvents::CommandRecorded)
+            }
+            _ => Err(Self::Error::Nondeterminism(format!(
+                "ModifyWorkflowPropertiesMachine does not handle {e}"
+            ))),
+        }
+    }
+}
+
+impl TryFrom<CommandType> for ModifyWorkflowPropertiesMachineEvents {
+    type Error = WFMachinesError;
+
+    fn try_from(c: CommandType) -> Result<Self, Self::Error> {
+        match c {
+            CommandType::ModifyWorkflowProperties => {
+                Ok(ModifyWorkflowPropertiesMachineEvents::CommandScheduled)
+            }
+            _ => Err(Self::Error::Nondeterminism(format!(
+                "ModifyWorkflowPropertiesMachine does not handle command type {c:?}"
+            ))),
+        }
+    }
+}
+
+impl From<CommandIssued> for Done {
+    fn from(_: CommandIssued) -> Self {
+        Self {}
+    }
+}
+
+impl From<Created> for CommandIssued {
+    fn from(_: Created) -> Self {
+        Self {}
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{replay::TestHistoryBuilder, worker::workflow::ManagedWFFunc};
+    use temporal_sdk::{WfContext, WorkflowFunction};
+    use temporal_sdk_core_protos::temporal::api::{
+        command::v1::command::Attributes, common::v1::Payload,
+    };
+
+    #[tokio::test]
+    async fn workflow_modify_props() {
+        let mut t = TestHistoryBuilder::default();
+        t.add_by_type(EventType::WorkflowExecutionStarted);
+        t.add_full_wf_task();
+        t.add_workflow_execution_completed();
+
+        let (k1, k2) = ("foo", "bar");
+
+        let wff = WorkflowFunction::new(move |ctx: WfContext| async move {
+            ctx.upsert_memo([
+                (
+                    String::from(k1),
+                    Payload {
+                        data: vec![0x01],
+                        ..Default::default()
+                    },
+                ),
+                (
+                    String::from(k2),
+                    Payload {
+                        data: vec![0x02],
+                        ..Default::default()
+                    },
+                ),
+            ]);
+            Ok(().into())
+        });
+        let mut wfm = ManagedWFFunc::new(t, wff, vec![]);
+
+        wfm.get_next_activation().await.unwrap();
+        let commands = wfm.get_server_commands().commands;
+        assert!(!commands.is_empty());
+        let cmd = commands[0].clone();
+        assert_eq!(
+            cmd.command_type,
+            CommandType::ModifyWorkflowProperties as i32
+        );
+        assert_matches!(
+        cmd.attributes.unwrap(),
+        Attributes::ModifyWorkflowPropertiesCommandAttributes(msg) => {
+            let fields = &msg.upserted_memo.unwrap().fields;
+            let payload1 = fields.get(k1).unwrap();
+            let payload2 = fields.get(k2).unwrap();
+            assert_eq!(payload1.data[0], 0x01);
+            assert_eq!(payload2.data[0], 0x02);
+            assert_eq!(fields.len(), 2);
+        });
+        wfm.shutdown().await.unwrap();
+    }
+}