temporalio 0.0.1 → 0.0.2

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

@@ -0,0 +1,178 @@
+use super::{
+    workflow_machines::{MachineResponse, WFMachinesError},
+    NewMachineWithCommand,
+};
+use crate::worker::workflow::machines::{Cancellable, EventInfo, WFMachinesAdapter};
+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<HistoryEvent> for ModifyWorkflowPropertiesMachineEvents {
+    type Error = WFMachinesError;
+
+    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
+        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();
+    }
+}

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

@@ -18,7 +18,7 @@
 //! | replaying, no marker         | deprecate_patch | Call allowed                                                                       |
 
 use super::{
-    workflow_machines::MachineResponse, Cancellable, EventInfo, MachineKind, NewMachineWithCommand,
+    workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
     OnEventWrapper, WFMachinesAdapter, WFMachinesError,
 };
 use crate::protosext::HistoryEventExt;
@@ -186,10 +186,6 @@ impl WFMachinesAdapter for PatchMachine {
     fn matches_event(&self, event: &HistoryEvent) -> bool {
         event.get_patch_marker_details().is_some()
     }
-
-    fn kind(&self) -> MachineKind {
-        MachineKind::Patch
-    }
 }
 
 impl Cancellable for PatchMachine {}

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

@@ -1,5 +1,5 @@
 use super::{
-    workflow_machines::MachineResponse, Cancellable, EventInfo, MachineKind, NewMachineWithCommand,
+    workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
     OnEventWrapper, WFMachinesAdapter, WFMachinesError,
 };
 use rustfsm::{fsm, MachineError, TransitionResult};
@@ -268,10 +268,6 @@ impl WFMachinesAdapter for SignalExternalMachine {
                 | EventType::SignalExternalWorkflowExecutionFailed
         )
     }
-
-    fn kind(&self) -> MachineKind {
-        MachineKind::SignalExternalWorkflow
-    }
 }
 
 impl Cancellable for SignalExternalMachine {

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

@@ -2,7 +2,7 @@
 
 use super::{
     workflow_machines::{MachineResponse, WFMachinesError},
-    Cancellable, EventInfo, MachineKind, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter,
+    Cancellable, EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter,
 };
 use rustfsm::{fsm, MachineError, StateMachine, TransitionResult};
 use std::convert::TryFrom;
@@ -246,10 +246,6 @@ impl WFMachinesAdapter for TimerMachine {
             EventType::TimerStarted | EventType::TimerCanceled | EventType::TimerFired
         )
     }
-
-    fn kind(&self) -> MachineKind {
-        MachineKind::Timer
-    }
 }
 
 impl Cancellable for TimerMachine {

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

@@ -75,8 +75,10 @@ mod machine_coverage_report {
         complete_workflow_state_machine::CompleteWorkflowMachine,
         continue_as_new_workflow_state_machine::ContinueAsNewWorkflowMachine,
         fail_workflow_state_machine::FailWorkflowMachine,
-        local_activity_state_machine::LocalActivityMachine, patch_state_machine::PatchMachine,
-        signal_external_state_machine::SignalExternalMachine, timer_state_machine::TimerMachine,
+        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,
     };
@@ -115,6 +117,7 @@ mod machine_coverage_report {
         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.
@@ -138,6 +141,9 @@ mod machine_coverage_report {
                 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),
             }
         }

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

@@ -2,7 +2,7 @@ use super::{
     workflow_machines::{MachineResponse, WFMachinesError},
     NewMachineWithCommand,
 };
-use crate::worker::workflow::machines::{Cancellable, EventInfo, MachineKind, WFMachinesAdapter};
+use crate::worker::workflow::machines::{Cancellable, EventInfo, WFMachinesAdapter};
 use rustfsm::{fsm, TransitionResult};
 use temporal_sdk_core_protos::{
     coresdk::workflow_commands::UpsertWorkflowSearchAttributes,
@@ -102,10 +102,6 @@ impl WFMachinesAdapter for UpsertSearchAttributesMachine {
             EventType::UpsertWorkflowSearchAttributes
         )
     }
-
-    fn kind(&self) -> MachineKind {
-        MachineKind::UpsertSearchAttributes
-    }
 }
 
 impl Cancellable for UpsertSearchAttributesMachine {}

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

@@ -53,7 +53,7 @@ impl LocalActivityData {
             .chain(self.new_requests.drain(..).map(|sa| {
                 self.executing.insert(sa.seq);
                 LocalActRequest::New(NewLocalAct {
-                    schedule_time: sa.original_schedule_time.unwrap_or_else(SystemTime::now),
+                    schedule_time: SystemTime::now(),
                     schedule_cmd: sa,
                     workflow_type: wf_type.to_string(),
                     workflow_exec_info: WorkflowExecution {