@temporalio/core-bridge 0.19.2 → 0.20.2

package/sdk-core/core/src/workflow/machines/upsert_search_attributes_state_machine.rs

@@ -1,40 +1,248 @@
+use super::{
+    workflow_machines::{MachineResponse, WFMachinesError},
+    NewMachineWithCommand,
+};
+use crate::workflow::machines::{Cancellable, EventInfo, MachineKind, WFMachinesAdapter};
 use rustfsm::{fsm, TransitionResult};
+use temporal_sdk_core_protos::{
+    coresdk::workflow_commands::UpsertWorkflowSearchAttributes,
+    temporal::api::{
+        command::v1::Command,
+        enums::v1::{CommandType, EventType},
+        history::v1::HistoryEvent,
+    },
+};
 
 fsm! {
-    pub(super) name UpsertSearchAttributesMachine; command UpsertSearchAttributesCommand; error UpsertSearchAttributesMachineError;
+    pub(super) name UpsertSearchAttributesMachine;
+    command UpsertSearchAttributesMachineCommand;
+    error WFMachinesError;
+    shared_state SharedState;
 
-    Created --(Schedule, on_schedule) --> UpsertCommandCreated;
+    // Machine is instantiated into the Created state and then transitions into the CommandIssued
+    // state when it receives the CommandScheduled event that is a result of looping back the
+    // Command initially packaged with NewMachineWithCommand (see upsert_search_attrs)
+    Created --(CommandScheduled) --> CommandIssued;
 
-    UpsertCommandCreated --(CommandUpsertWorkflowSearchAttributes) --> UpsertCommandCreated;
-    UpsertCommandCreated --(UpsertWorkflowSearchAttributes, on_upsert_workflow_search_attributes) --> UpsertCommandRecorded;
+    // Having sent the command to the server, the machine transitions into a terminal state (Done)
+    // upon observing a history event indicating that the command has been recorded. Note that this
+    // does not imply that the command has been _executed_, only that it _will be_ executed at some
+    // point in the future.
+    CommandIssued --(CommandRecorded) --> Done;
 }
 
-#[derive(thiserror::Error, Debug)]
-pub(super) enum UpsertSearchAttributesMachineError {}
+/// Instantiates an UpsertSearchAttributesMachine and packs it together with an initial command
+/// to apply the provided search attribute update.
+pub(super) fn upsert_search_attrs(
+    attribs: UpsertWorkflowSearchAttributes,
+) -> NewMachineWithCommand {
+    let sm = UpsertSearchAttributesMachine::new();
+    let cmd = Command {
+        command_type: CommandType::UpsertWorkflowSearchAttributes as i32,
+        attributes: Some(attribs.into()),
+    };
+    NewMachineWithCommand {
+        command: cmd,
+        machine: sm.into(),
+    }
+}
+
+/// Unused but must exist
+type SharedState = ();
 
-pub(super) enum UpsertSearchAttributesCommand {}
+/// The state-machine-specific set of commands that are the results of state transition in the
+/// UpsertSearchAttributesMachine. There are none of these because this state machine emits the
+/// UpsertSearchAttributes API command during construction and then does not emit any subsequent
+/// state-machine specific commands.
+#[derive(Debug, derive_more::Display)]
+pub(super) enum UpsertSearchAttributesMachineCommand {}
 
-#[derive(Default, Clone)]
+/// The state of the UpsertSearchAttributesMachine at time zero (i.e. at instantiation)
+#[derive(Debug, Default, Clone, derive_more::Display)]
 pub(super) struct Created {}
 
-impl Created {
-    pub(super) fn on_schedule(
-        self,
-    ) -> UpsertSearchAttributesMachineTransition<UpsertCommandCreated> {
-        unimplemented!()
+/// Once the UpsertSearchAttributesMachine has been known to have issued the upsert command to
+/// higher-level machinery, it transitions into this state.
+#[derive(Debug, Default, Clone, derive_more::Display)]
+pub(super) struct CommandIssued {}
+
+/// Once the server has recorded its receipt of the search attribute update, the
+/// UpsertSearchAttributesMachine transitions into this terminal state.
+#[derive(Debug, Default, Clone, derive_more::Display)]
+pub(super) struct Done {}
+
+impl UpsertSearchAttributesMachine {
+    fn new() -> Self {
+        Self {
+            state: Created {}.into(),
+            shared_state: (),
+        }
+    }
+}
+
+impl WFMachinesAdapter for UpsertSearchAttributesMachine {
+    /// Transforms an UpsertSearchAttributesMachine-specific command (i.e. an instance of the type
+    /// UpsertSearchAttributesMachineCommand) to a more generic form supported by the abstract
+    /// StateMachine type.
+    fn adapt_response(
+        &self,
+        _my_command: Self::Command,
+        _event_info: Option<EventInfo>,
+    ) -> Result<Vec<MachineResponse>, Self::Error> {
+        // No implementation needed until this state machine emits state machine commands
+        Err(Self::Error::Nondeterminism(
+            "UpsertWorkflowSearchAttributesMachine does not use commands".to_string(),
+        ))
+    }
+
+    /// Filters for EventType::UpsertWorkflowSearchAttributes
+    fn matches_event(&self, event: &HistoryEvent) -> bool {
+        matches!(
+            event.event_type(),
+            EventType::UpsertWorkflowSearchAttributes
+        )
+    }
+
+    fn kind(&self) -> MachineKind {
+        MachineKind::UpsertSearchAttributes
+    }
+}
+
+impl Cancellable for UpsertSearchAttributesMachine {}
+
+// Converts the generic history event with type EventType::UpsertWorkflowSearchAttributes into the
+// UpsertSearchAttributesMachine-specific event type
+// UpsertSearchAttributesMachineEvents::CommandRecorded.
+impl TryFrom<HistoryEvent> for UpsertSearchAttributesMachineEvents {
+    type Error = WFMachinesError;
+
+    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
+        match e.event_type() {
+            EventType::UpsertWorkflowSearchAttributes => {
+                Ok(UpsertSearchAttributesMachineEvents::CommandRecorded)
+            }
+            _ => Err(Self::Error::Nondeterminism(format!(
+                "UpsertWorkflowSearchAttributesMachine does not handle {e}"
+            ))),
+        }
+    }
+}
+
+// Converts generic state machine command type CommandType::UpsertWorkflowSearchAttributes into
+// the UpsertSearchAttributesMachine-specific event
+impl TryFrom<CommandType> for UpsertSearchAttributesMachineEvents {
+    type Error = WFMachinesError;
+
+    fn try_from(c: CommandType) -> Result<Self, Self::Error> {
+        match c {
+            CommandType::UpsertWorkflowSearchAttributes => {
+                Ok(UpsertSearchAttributesMachineEvents::CommandScheduled)
+            }
+            _ => Err(Self::Error::Nondeterminism(format!(
+                "UpsertWorkflowSearchAttributesMachine does not handle command type {c:?}"
+            ))),
+        }
     }
 }
 
-#[derive(Default, Clone)]
-pub(super) struct UpsertCommandCreated {}
+// There is no Command/Response associated with this transition
+impl From<CommandIssued> for Done {
+    fn from(_: CommandIssued) -> Self {
+        Self {}
+    }
+}
 
-impl UpsertCommandCreated {
-    pub(super) fn on_upsert_workflow_search_attributes(
-        self,
-    ) -> UpsertSearchAttributesMachineTransition<UpsertCommandRecorded> {
-        unimplemented!()
+// There is no Command/Response associated with this transition
+impl From<Created> for CommandIssued {
+    fn from(_: Created) -> Self {
+        Self {}
     }
 }
 
-#[derive(Default, Clone)]
-pub(super) struct UpsertCommandRecorded {}
+#[cfg(test)]
+mod tests {
+    use rustfsm::StateMachine;
+    use temporal_sdk::{WfContext, WorkflowFunction};
+    use temporal_sdk_core_protos::{
+        coresdk::common::Payload, temporal::api::command::v1::command::Attributes,
+    };
+
+    use crate::{replay::TestHistoryBuilder, workflow::managed_wf::ManagedWFFunc};
+
+    use super::{super::OnEventWrapper, *};
+
+    #[tokio::test]
+    async fn upsert_search_attrs_from_workflow() {
+        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_search_attributes([
+                (
+                    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::UpsertWorkflowSearchAttributes as i32
+        );
+        assert_matches!(
+        cmd.attributes.unwrap(),
+        Attributes::UpsertWorkflowSearchAttributesCommandAttributes(msg) => {
+            let fields = &msg.search_attributes.unwrap().indexed_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();
+    }
+
+    #[tokio::test]
+    async fn upsert_search_attrs_sm() {
+        let mut sm = UpsertSearchAttributesMachine::new();
+        assert_eq!(Created {}.to_string(), sm.state().to_string());
+
+        let cmd_scheduled_sm_event = CommandType::UpsertWorkflowSearchAttributes
+            .try_into()
+            .unwrap();
+        let recorded_history_event = HistoryEvent {
+            event_type: EventType::UpsertWorkflowSearchAttributes as i32,
+            ..Default::default()
+        };
+        assert!(sm.matches_event(&recorded_history_event));
+        let cmd_recorded_sm_event = recorded_history_event.try_into().unwrap();
+
+        OnEventWrapper::on_event_mut(&mut sm, cmd_scheduled_sm_event)
+            .expect("CommandScheduled should transition Created -> CommandIssued");
+        assert_eq!(CommandIssued {}.to_string(), sm.state().to_string());
+
+        OnEventWrapper::on_event_mut(&mut sm, cmd_recorded_sm_event)
+            .expect("CommandRecorded should transition CommandIssued -> Done");
+        assert_eq!(Done {}.to_string(), sm.state().to_string());
+    }
+}

package/sdk-core/core/src/workflow/machines/workflow_machines.rs

@@ -10,7 +10,8 @@ use super::{
     continue_as_new_workflow_state_machine::continue_as_new,
     fail_workflow_state_machine::fail_workflow, local_activity_state_machine::new_local_activity,
     patch_state_machine::has_change, signal_external_state_machine::new_external_signal,
-    timer_state_machine::new_timer, workflow_machines::local_acts::LocalActivityData,
+    timer_state_machine::new_timer, upsert_search_attributes_state_machine::upsert_search_attrs,
+    workflow_machines::local_acts::LocalActivityData,
     workflow_task_state_machine::WorkflowTaskMachine, MachineKind, Machines, NewMachineWithCommand,
     TemporalStateMachine,
 };
@@ -22,36 +23,32 @@ use crate::{
     },
     workflow::{
         CommandID, DrivenWorkflow, HistoryUpdate, LocalResolution, WFCommand, WorkflowFetcher,
+        WorkflowStartedInfo,
     },
 };
+use siphasher::sip::SipHasher13;
 use slotmap::SlotMap;
 use std::{
     borrow::{Borrow, BorrowMut},
-    collections::{hash_map::DefaultHasher, HashMap, VecDeque},
+    collections::{HashMap, VecDeque},
     convert::TryInto,
     hash::{Hash, Hasher},
     time::{Duration, Instant, SystemTime},
 };
 use temporal_sdk_core_protos::{
     coresdk::{
-        common::{NamespacedWorkflowExecution, Payload},
+        common::NamespacedWorkflowExecution,
         workflow_activation::{
             workflow_activation_job::{self, Variant},
-            NotifyHasPatch, StartWorkflow, UpdateRandomSeed, WorkflowActivation,
+            NotifyHasPatch, UpdateRandomSeed, WorkflowActivation,
         },
-        workflow_commands::{
-            request_cancel_external_workflow_execution as cancel_we,
-            signal_external_workflow_execution as sig_we,
-        },
-        FromPayloadsExt,
+        workflow_commands::request_cancel_external_workflow_execution as cancel_we,
     },
     temporal::api::{
         command::v1::Command as ProtoCommand,
-        common::v1::Header,
         enums::v1::EventType,
-        history::v1::{history_event, HistoryEvent, WorkflowExecutionStartedEventAttributes},
+        history::v1::{history_event, HistoryEvent},
     },
-    utilities::TryIntoOrNone,
 };
 
 type Result<T, E = WFMachinesError> = std::result::Result<T, E>;
@@ -296,17 +293,21 @@ impl WorkflowMachines {
         self.local_activity_data.outstanding_la_count()
     }
 
-    /// Returns the start attributes for the workflow if it has started
-    pub(crate) fn started_attrs(&self) -> Option<&WorkflowExecutionStartedEventAttributes> {
-        self.drive_me.get_started_attrs()
+    /// Returns start info for the workflow if it has started
+    pub(crate) fn get_started_info(&self) -> Option<&WorkflowStartedInfo> {
+        self.drive_me.get_started_info()
     }
 
     /// Handle a single event from the workflow history. `has_next_event` should be false if `event`
     /// is the last event in the history.
     ///
-    /// TODO: Describe what actually happens in here
+    /// This function will attempt to apply the event to the workflow state machines. If there is
+    /// not a matching machine for the event, a nondeterminism error is returned. Otherwise, the
+    /// event is applied to the machine, which may also return a nondeterminism error if the machine
+    /// does not match the expected type. A fatal error may be returned if the machine is in an
+    /// invalid state.
     #[instrument(level = "debug", skip(self, event), fields(event=%event))]
-    fn handle_event(&mut self, event: &HistoryEvent, has_next_event: bool) -> Result<()> {
+    fn handle_event(&mut self, event: HistoryEvent, has_next_event: bool) -> Result<()> {
         if event.is_final_wf_execution_event() {
             self.have_seen_terminal_event = true;
         }
@@ -329,20 +330,20 @@ impl WorkflowMachines {
                 // We remove the machine while we it handles events, then return it, to avoid
                 // borrowing from ourself mutably.
                 let maybe_machine = self.machines_by_event_id.remove(&initial_cmd_id);
-                if let Some(sm) = maybe_machine {
-                    self.submachine_handle_event(sm, event, has_next_event)?;
-                } else {
-                    return Err(WFMachinesError::Nondeterminism(format!(
-                        "During event handling, this event had an initial command ID but we could \
-                        not find a matching command for it: {:?}",
-                        event
-                    )));
-                }
-
-                // Restore machine if not in it's final state
-                if let Some(sm) = maybe_machine {
-                    if !self.machine(sm).is_final_state() {
-                        self.machines_by_event_id.insert(initial_cmd_id, sm);
+                match maybe_machine {
+                    Some(sm) => {
+                        self.submachine_handle_event(sm, event, has_next_event)?;
+                        // Restore machine if not in it's final state
+                        if !self.machine(sm).is_final_state() {
+                            self.machines_by_event_id.insert(initial_cmd_id, sm);
+                        }
+                    }
+                    None => {
+                        return Err(WFMachinesError::Nondeterminism(format!(
+                            "During event handling, this event had an initial command ID but we \
+                            could not find a matching command for it: {:?}",
+                            event
+                        )));
                     }
                 }
             }
@@ -385,7 +386,7 @@ impl WorkflowMachines {
     /// The handling consists of verifying that the next command in the commands queue is associated
     /// with a state machine, which is then notified about the event and the command is removed from
     /// the commands queue.
-    fn handle_command_event(&mut self, event: &HistoryEvent) -> Result<()> {
+    fn handle_command_event(&mut self, event: HistoryEvent) -> Result<()> {
         if event.is_local_activity_marker() {
             let deets = event.extract_local_activity_marker_data().ok_or_else(|| {
                 WFMachinesError::Fatal(format!("Local activity marker was unparsable: {:?}", event))
@@ -406,10 +407,12 @@ impl WorkflowMachines {
             }
         }
 
+        let event_id = event.event_id;
+
         let consumed_cmd = loop {
             if let Some(peek_machine) = self.commands.front() {
                 let mach = self.machine(peek_machine.machine);
-                match change_marker_handling(event, mach)? {
+                match change_marker_handling(&event, mach)? {
                     ChangeMarkerOutcome::SkipEvent => return Ok(()),
                     ChangeMarkerOutcome::SkipCommand => {
                         self.commands.pop_front();
@@ -442,7 +445,7 @@ impl WorkflowMachines {
 
         if !self.machine(consumed_cmd.machine).is_final_state() {
             self.machines_by_event_id
-                .insert(event.event_id, consumed_cmd.machine);
+                .insert(event_id, consumed_cmd.machine);
         }
 
         Ok(())
@@ -450,48 +453,30 @@ impl WorkflowMachines {
 
     fn handle_non_stateful_event(
         &mut self,
-        event: &HistoryEvent,
+        event: HistoryEvent,
         has_next_event: bool,
     ) -> Result<()> {
         debug!(
             event = %event,
             "handling non-stateful event"
         );
+        let event_id = event.event_id;
         match EventType::from_i32(event.event_type) {
             Some(EventType::WorkflowExecutionStarted) => {
                 if let Some(history_event::Attributes::WorkflowExecutionStartedEventAttributes(
                     attrs,
-                )) = &event.attributes
+                )) = event.attributes
                 {
-                    self.run_id = attrs.original_execution_run_id.clone();
-                    if let Some(st) = event.event_time.as_ref() {
-                        let as_systime: SystemTime = st.clone().try_into()?;
+                    if let Some(st) = event.event_time {
+                        let as_systime: SystemTime = st.try_into()?;
                         self.workflow_start_time = Some(as_systime);
                     }
-                    // We need to notify the lang sdk that it's time to kick off a workflow
-                    self.drive_me.send_job(
-                        StartWorkflow {
-                            workflow_type: attrs
-                                .workflow_type
-                                .as_ref()
-                                .map(|wt| wt.name.clone())
-                                .unwrap_or_default(),
-                            workflow_id: self.workflow_id.clone(),
-                            arguments: Vec::from_payloads(attrs.input.clone()),
-                            randomness_seed: str_to_randomness_seed(
-                                &attrs.original_execution_run_id,
-                            ),
-                            headers: match &attrs.header {
-                                None => HashMap::new(),
-                                Some(Header { fields }) => fields
-                                    .iter()
-                                    .map(|(k, v)| (k.clone(), Payload::from(v.clone())))
-                                    .collect(),
-                            },
-                        }
-                        .into(),
+                    // Notify the lang sdk that it's time to kick off a workflow
+                    self.drive_me.start(
+                        self.workflow_id.clone(),
+                        str_to_randomness_seed(&attrs.original_execution_run_id),
+                        attrs,
                     );
-                    self.drive_me.start(attrs.clone());
                 } else {
                     return Err(WFMachinesError::Fatal(format!(
                         "WorkflowExecutionStarted event did not have appropriate attributes: {}",
@@ -503,14 +488,14 @@ impl WorkflowMachines {
                 let wf_task_sm = WorkflowTaskMachine::new(self.next_started_event_id);
                 let key = self.all_machines.insert(wf_task_sm.into());
                 self.submachine_handle_event(key, event, has_next_event)?;
-                self.machines_by_event_id.insert(event.event_id, key);
+                self.machines_by_event_id.insert(event_id, key);
             }
             Some(EventType::WorkflowExecutionSignaled) => {
                 if let Some(history_event::Attributes::WorkflowExecutionSignaledEventAttributes(
                     attrs,
-                )) = &event.attributes
+                )) = event.attributes
                 {
-                    self.drive_me.signal(attrs.clone().into());
+                    self.drive_me.signal(attrs.into());
                 } else {
                     // err
                 }
@@ -520,9 +505,9 @@ impl WorkflowMachines {
                     history_event::Attributes::WorkflowExecutionCancelRequestedEventAttributes(
                         attrs,
                     ),
-                ) = &event.attributes
+                ) = event.attributes
                 {
-                    self.drive_me.cancel(attrs.clone().into());
+                    self.drive_me.cancel(attrs.into());
                 } else {
                     // err
                 }
@@ -640,25 +625,20 @@ impl WorkflowMachines {
             }
         }
 
-        let first_event_id = match events.first() {
-            Some(event) => event.event_id,
-            None => 0,
-        };
-        // Workflow has been evicted, but we've received partial history from the server.
-        // Need to reset sticky and trigger another poll.
-        if self.current_started_event_id == 0 && first_event_id != 1 && !events.is_empty() {
-            debug!("Cache miss.");
-            self.metrics.sticky_cache_miss();
-            return Err(WFMachinesError::CacheMiss);
-        }
-
-        let mut history = events.iter().peekable();
-
+        let mut history = events.into_iter().peekable();
         while let Some(event) = history.next() {
+            if event.event_id != self.last_processed_event + 1 {
+                return Err(WFMachinesError::Fatal(format!(
+                    "History is out of order. Last processed event: {}, event id: {}",
+                    self.last_processed_event, event.event_id
+                )));
+            }
             let next_event = history.peek();
+            let eid = event.event_id;
+            let etype = event.event_type;
             self.handle_event(event, next_event.is_some())?;
-            self.last_processed_event = event.event_id;
-            if event.event_type == EventType::WorkflowTaskStarted as i32 && next_event.is_none() {
+            self.last_processed_event = eid;
+            if etype == EventType::WorkflowTaskStarted as i32 && next_event.is_none() {
                 break;
             }
         }
@@ -695,7 +675,7 @@ impl WorkflowMachines {
     fn submachine_handle_event(
         &mut self,
         sm: MachineKey,
-        event: &HistoryEvent,
+        event: HistoryEvent,
         has_next_event: bool,
     ) -> Result<()> {
         let machine_responses = self.machine_mut(sm).handle_event(event, has_next_event)?;
@@ -813,6 +793,13 @@ impl WorkflowMachines {
                     let seq = attrs.seq;
                     self.add_cmd_to_wf_task(new_timer(attrs), Some(CommandID::Timer(seq)));
                 }
+                WFCommand::UpsertSearchAttributes(attrs) => {
+                    let seq = attrs.seq;
+                    self.add_cmd_to_wf_task(
+                        upsert_search_attrs(attrs),
+                        Some(CommandID::Timer(seq)),
+                    );
+                }
                 WFCommand::CancelTimer(attrs) => {
                     jobs.extend(self.process_cancellation(CommandID::Timer(attrs.seq))?);
                 }
@@ -824,10 +811,9 @@ impl WorkflowMachines {
                     let seq = attrs.seq;
                     let attrs: ValidScheduleLA = ValidScheduleLA::from_schedule_la(
                         attrs,
-                        self.started_attrs()
+                        self.get_started_info()
                             .as_ref()
-                            .map(|x| x.workflow_execution_timeout.clone().try_into_or_none())
-                            .flatten(),
+                            .and_then(|x| x.workflow_execution_timeout),
                     )
                     .map_err(|e| {
                         WFMachinesError::Fatal(format!(
@@ -925,33 +911,10 @@ impl WorkflowMachines {
                     );
                 }
                 WFCommand::SignalExternalWorkflow(attrs) => {
-                    let (we, only_child) = match attrs.target {
-                        None => {
-                            return Err(WFMachinesError::Fatal(
-                                "Signal external workflow command had empty target field"
-                                    .to_string(),
-                            ))
-                        }
-                        Some(sig_we::Target::ChildWorkflowId(wfid)) => (
-                            NamespacedWorkflowExecution {
-                                namespace: self.namespace.clone(),
-                                workflow_id: wfid,
-                                run_id: "".to_string(),
-                            },
-                            true,
-                        ),
-                        Some(sig_we::Target::WorkflowExecution(we)) => (we, false),
-                    };
-
+                    let seq = attrs.seq;
                     self.add_cmd_to_wf_task(
-                        new_external_signal(
-                            attrs.seq,
-                            we,
-                            attrs.signal_name,
-                            attrs.args,
-                            only_child,
-                        ),
-                        Some(CommandID::SignalExternal(attrs.seq)),
+                        new_external_signal(attrs, &self.namespace)?,
+                        Some(CommandID::SignalExternal(seq)),
                     );
                 }
                 WFCommand::CancelSignalWorkflow(attrs) => {
@@ -973,7 +936,8 @@ impl WorkflowMachines {
         let mut jobs = vec![];
         let m_key = self.get_machine_key(id)?;
         let machine_resps = self.machine_mut(m_key).cancel()?;
-        debug!(machine_responses = ?machine_resps, cmd_id = ?id, "Cancel request responses");
+        debug!(machine_responses = %machine_resps.display(), cmd_id = ?id,
+               "Cancel request responses");
         for r in machine_resps {
             match r {
                 MachineResponse::IssueNewCommand(c) => {
@@ -1084,7 +1048,9 @@ impl WorkflowMachines {
 }
 
 fn str_to_randomness_seed(run_id: &str) -> u64 {
-    let mut s = DefaultHasher::new();
+    // This was originally `DefaultHasher` but that is potentially unstable across Rust releases.
+    // This must forever be `SipHasher13` now or we risk breaking history compat.
+    let mut s = SipHasher13::new();
     run_id.hash(&mut s);
     s.finish()
 }

package/sdk-core/core/src/workflow/machines/workflow_task_state_machine.rs

@@ -64,8 +64,8 @@ impl WFMachinesAdapter for WorkflowTaskMachine {
                 task_started_event_id,
                 time,
             } => {
-                let (event, has_next_event) = if let Some(ei) = event_info {
-                    (ei.event, ei.has_next_event)
+                let (event_id, event_type, has_next_event) = if let Some(ei) = event_info {
+                    (ei.event_id, ei.event_type, ei.has_next_event)
                 } else {
                     return Err(WFMachinesError::Fatal(
                         "WF Task machine should never issue a task started trigger \
@@ -74,8 +74,8 @@ impl WFMachinesAdapter for WorkflowTaskMachine {
                     ));
                 };
 
-                let cur_event_past_or_at_start = event.event_id >= task_started_event_id;
-                if event.event_type() == EventType::WorkflowTaskStarted
+                let cur_event_past_or_at_start = event_id >= task_started_event_id;
+                if event_type == EventType::WorkflowTaskStarted
                     && (!cur_event_past_or_at_start || has_next_event)
                 {
                     return Ok(vec![]);