@temporalio/core-bridge 1.9.2 → 1.10.0

package/sdk-core/core/src/worker/workflow/machines/patch_state_machine.rs

@@ -46,7 +46,6 @@ use temporal_sdk_core_protos::{
         },
         common::v1::SearchAttributes,
         enums::v1::CommandType,
-        history::v1::HistoryEvent,
     },
 };
 
@@ -237,10 +236,6 @@ impl WFMachinesAdapter for PatchMachine {
     ) -> Result<Vec<MachineResponse>, WFMachinesError> {
         panic!("Patch machine does not produce commands")
     }
-
-    fn matches_event(&self, event: &HistoryEvent) -> bool {
-        event.get_patch_marker_details().is_some()
-    }
 }
 
 impl Cancellable for PatchMachine {}

package/sdk-core/core/src/worker/workflow/machines/signal_external_state_machine.rs

@@ -19,7 +19,7 @@ use temporal_sdk_core_protos::{
         common::v1::WorkflowExecution as UpstreamWE,
         enums::v1::{CommandType, EventType, SignalExternalWorkflowExecutionFailedCause},
         failure::v1::{failure::FailureInfo, ApplicationFailureInfo, CanceledFailureInfo, Failure},
-        history::v1::{history_event, HistoryEvent},
+        history::v1::history_event,
     },
 };
 
@@ -260,15 +260,6 @@ impl WFMachinesAdapter for SignalExternalMachine {
             }
         })
     }
-
-    fn matches_event(&self, event: &HistoryEvent) -> bool {
-        matches!(
-            event.event_type(),
-            EventType::ExternalWorkflowExecutionSignaled
-                | EventType::SignalExternalWorkflowExecutionInitiated
-                | EventType::SignalExternalWorkflowExecutionFailed
-        )
-    }
 }
 
 impl Cancellable for SignalExternalMachine {

package/sdk-core/core/src/worker/workflow/machines/timer_state_machine.rs

@@ -16,7 +16,7 @@ use temporal_sdk_core_protos::{
     temporal::api::{
         command::v1::Command,
         enums::v1::{CommandType, EventType},
-        history::v1::{history_event, HistoryEvent, TimerFiredEventAttributes},
+        history::v1::{history_event, TimerFiredEventAttributes},
     },
 };
 
@@ -233,13 +233,6 @@ impl WFMachinesAdapter for TimerMachine {
             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 {
@@ -310,8 +303,8 @@ mod test {
         mock_cfg.num_expected_fails = 1;
         mock_cfg.expect_fail_wft_matcher = Box::new(move |_, cause, f| {
             matches!(cause, WorkflowTaskFailedCause::NonDeterministicError)
-                && matches!(f, Some(Failure { source, .. }) 
-            if source.contains("Timer fired event did not have expected timer id 1"))
+                && matches!(f, Some(Failure {message, .. })
+            if message.contains("Timer fired event did not have expected timer id 1"))
         });
         let mut worker = build_fake_sdk(mock_cfg);
         worker.register_wf(DEFAULT_WORKFLOW_TYPE, |ctx: WfContext| async move {

package/sdk-core/core/src/worker/workflow/machines/transition_coverage.rs

@@ -4,6 +4,7 @@
 //! never ever be removed from behind `#[cfg(test)]` compilation.
 
 use dashmap::{mapref::entry::Entry, DashMap, DashSet};
+use once_cell::sync::Lazy;
 use std::{
     path::PathBuf,
     sync::{
@@ -15,13 +16,11 @@ use std::{
 };
 
 // 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);
-}
+static COVERED_TRANSITIONS: Lazy<DashMap<String, DashSet<CoveredTransition>>> =
+    Lazy::new(DashMap::new);
+static COVERAGE_SENDER: Lazy<SyncSender<(String, CoveredTransition)>> =
+    Lazy::new(spawn_save_coverage_at_end);
+static THREAD_HANDLE: Lazy<Mutex<Option<JoinHandle<()>>>> = Lazy::new(|| Mutex::new(None));
 
 #[derive(Eq, PartialEq, Hash, Debug)]
 struct CoveredTransition {
@@ -30,7 +29,12 @@ struct CoveredTransition {
     event: String,
 }
 
-pub fn add_coverage(machine_name: String, from_state: String, to_state: String, event: String) {
+pub(super) fn add_coverage(
+    machine_name: String,
+    from_state: String,
+    to_state: String,
+    event: String,
+) {
     let ct = CoveredTransition {
         from_state,
         to_state,

package/sdk-core/core/src/worker/workflow/machines/update_state_machine.rs

@@ -17,7 +17,6 @@ use temporal_sdk_core_protos::{
         common::v1::Payload,
         enums::v1::{CommandType, EventType},
         failure::v1::Failure,
-        history::v1::HistoryEvent,
         protocol::v1::Message as ProtocolMessage,
         update::v1::{outcome, Acceptance, Outcome, Rejection, Response},
     },
@@ -271,15 +270,6 @@ impl WFMachinesAdapter for UpdateMachine {
             )?,
         })
     }
-
-    fn matches_event(&self, event: &HistoryEvent) -> bool {
-        matches!(
-            event.event_type(),
-            EventType::WorkflowExecutionUpdateAccepted
-                | EventType::WorkflowExecutionUpdateRejected
-                | EventType::WorkflowExecutionUpdateCompleted
-        )
-    }
 }
 
 impl TryFrom<CommandType> for UpdateMachineEvents {

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

@@ -15,8 +15,8 @@ use temporal_sdk_core_protos::{
     temporal::api::{
         command::v1::{command, Command, UpsertWorkflowSearchAttributesCommandAttributes},
         common::v1::SearchAttributes,
-        enums::v1::{CommandType, EventType},
-        history::v1::{history_event, HistoryEvent},
+        enums::v1::CommandType,
+        history::v1::history_event,
     },
 };
 
@@ -137,14 +137,6 @@ impl WFMachinesAdapter for UpsertSearchAttributesMachine {
             "UpsertWorkflowSearchAttributesMachine does not use commands".to_string(),
         ))
     }
-
-    /// Filters for EventType::UpsertWorkflowSearchAttributes
-    fn matches_event(&self, event: &HistoryEvent) -> bool {
-        matches!(
-            event.event_type(),
-            EventType::UpsertWorkflowSearchAttributes
-        )
-    }
 }
 
 impl Cancellable for UpsertSearchAttributesMachine {}
@@ -214,8 +206,10 @@ mod tests {
             AsJsonPayloadExt,
         },
         temporal::api::{
-            command::v1::command::Attributes, common::v1::Payload,
-            history::v1::UpsertWorkflowSearchAttributesEventAttributes,
+            command::v1::command::Attributes,
+            common::v1::Payload,
+            enums::v1::EventType,
+            history::v1::{HistoryEvent, UpsertWorkflowSearchAttributesEventAttributes},
         },
         DEFAULT_WORKFLOW_TYPE,
     };
@@ -291,7 +285,6 @@ mod tests {
             ),
             ..Default::default()
         };
-        assert!(sm.matches_event(&recorded_history_event));
         let cmd_recorded_sm_event = HistEventData {
             event: recorded_history_event,
             replaying: false,

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

@@ -92,18 +92,18 @@ pub(crate) struct WorkflowMachines {
     /// The event id of the most recent event processed. It's possible in some situations (ex legacy
     /// queries) to receive a history with no new workflow tasks. If the last history we processed
     /// also had no new tasks, we need a way to know not to apply the same events over again.
-    pub last_processed_event: i64,
+    pub(crate) last_processed_event: i64,
     /// True if the workflow is replaying from history
-    pub replaying: bool,
+    pub(crate) replaying: bool,
     /// Workflow identifier
-    pub workflow_id: String,
+    pub(crate) workflow_id: String,
     /// Workflow type identifier. (Function name, class, etc)
-    pub workflow_type: String,
+    pub(crate) workflow_type: String,
     /// Identifies the current run
-    pub run_id: String,
+    pub(crate) run_id: String,
     /// Is set to true once we've seen the final event in workflow history, to avoid accidentally
     /// re-applying the final workflow task.
-    pub have_seen_terminal_event: bool,
+    pub(crate) have_seen_terminal_event: bool,
     /// The time the workflow execution began, as told by the WEStarted event
     workflow_start_time: Option<SystemTime>,
     /// The time the workflow execution finished, as determined by when the machines handled
@@ -157,7 +157,7 @@ pub(crate) struct WorkflowMachines {
     drive_me: DrivenWorkflow,
 
     /// Metrics context
-    pub metrics: MetricsContext,
+    pub(crate) metrics: MetricsContext,
     worker_config: Arc<WorkerConfig>,
 }
 
@@ -376,7 +376,6 @@ impl WorkflowMachines {
             has_pending_jobs: self.has_pending_jobs(),
             have_seen_terminal_event: self.have_seen_terminal_event,
             have_pending_la_resolutions: self.has_pending_la_resolutions(),
-            last_processed_event: self.last_processed_event,
             me: self,
         }
     }
@@ -782,7 +781,7 @@ impl WorkflowMachines {
             };
         }
         if event.event_type() == EventType::Unspecified
-            || event.event_type() == EventType::WorkflowExecutionUpdateRequested
+            || event.event_type() == EventType::WorkflowExecutionUpdateAdmitted
             || event.attributes.is_none()
         {
             return if !event.worker_may_ignore {
@@ -905,8 +904,8 @@ impl WorkflowMachines {
     fn handle_non_stateful_event(&mut self, event_dat: HistEventData) -> Result<()> {
         trace!(event = %event_dat.event, "handling non-stateful event");
         let event_id = event_dat.event.event_id;
-        match EventType::from_i32(event_dat.event.event_type) {
-            Some(EventType::WorkflowExecutionStarted) => {
+        match EventType::try_from(event_dat.event.event_type) {
+            Ok(EventType::WorkflowExecutionStarted) => {
                 if let Some(history_event::Attributes::WorkflowExecutionStartedEventAttributes(
                     attrs,
                 )) = event_dat.event.attributes
@@ -932,13 +931,13 @@ impl WorkflowMachines {
                     )));
                 }
             }
-            Some(EventType::WorkflowTaskScheduled) => {
+            Ok(EventType::WorkflowTaskScheduled) => {
                 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_dat)?;
                 self.machines_by_event_id.insert(event_id, key);
             }
-            Some(EventType::WorkflowExecutionSignaled) => {
+            Ok(EventType::WorkflowExecutionSignaled) => {
                 if let Some(history_event::Attributes::WorkflowExecutionSignaledEventAttributes(
                     attrs,
                 )) = event_dat.event.attributes
@@ -949,7 +948,7 @@ impl WorkflowMachines {
                     // err
                 }
             }
-            Some(EventType::WorkflowExecutionCancelRequested) => {
+            Ok(EventType::WorkflowExecutionCancelRequested) => {
                 if let Some(
                     history_event::Attributes::WorkflowExecutionCancelRequestedEventAttributes(
                         attrs,
@@ -1293,21 +1292,12 @@ impl WorkflowMachines {
                     self.process_cancellation(CommandID::LocalActivity(attrs.seq))?;
                 }
                 WFCommand::CompleteWorkflow(attrs) => {
-                    if !self.replaying {
-                        self.metrics.wf_completed();
-                    }
                     self.add_terminal_command(complete_workflow(attrs));
                 }
                 WFCommand::FailWorkflow(attrs) => {
-                    if !self.replaying {
-                        self.metrics.wf_failed();
-                    }
                     self.add_terminal_command(fail_workflow(attrs));
                 }
                 WFCommand::ContinueAsNew(attrs) => {
-                    if !self.replaying {
-                        self.metrics.wf_continued_as_new();
-                    }
                     let attrs = self.augment_continue_as_new_with_current_values(attrs);
                     let use_compat = self.determine_use_compatible_flag(
                         attrs.versioning_intent(),
@@ -1316,9 +1306,6 @@ impl WorkflowMachines {
                     self.add_terminal_command(continue_as_new(attrs, use_compat));
                 }
                 WFCommand::CancelWorkflow(attrs) => {
-                    if !self.replaying {
-                        self.metrics.wf_canceled();
-                    }
                     self.add_terminal_command(cancel_workflow(attrs));
                 }
                 WFCommand::SetPatchMarker(attrs) => {
@@ -1535,7 +1522,7 @@ impl WorkflowMachines {
                     .unwrap_or_default();
             }
             if attrs.retry_policy.is_none() {
-                attrs.retry_policy = started_info.retry_policy.clone();
+                attrs.retry_policy.clone_from(&started_info.retry_policy);
             }
         }
         attrs
@@ -1560,25 +1547,28 @@ impl WorkflowMachines {
 /// Contains everything workflow machine internals need to bubble up when we're getting ready to
 /// respond with a WFT completion. Allows for lazy mutation of the machine, since mutation is not
 /// desired unless we are actually going to respond to the WFT, which may not always happen.
-pub struct MachinesWFTResponseContent<'a> {
+pub(crate) struct MachinesWFTResponseContent<'a> {
     me: &'a mut WorkflowMachines,
-    pub replaying: bool,
-    pub has_pending_jobs: bool,
-    pub have_seen_terminal_event: bool,
-    pub have_pending_la_resolutions: bool,
-    pub last_processed_event: i64,
+    pub(crate) replaying: bool,
+    pub(crate) has_pending_jobs: bool,
+    pub(crate) have_seen_terminal_event: bool,
+    pub(crate) have_pending_la_resolutions: bool,
 }
+
 impl<'a> MachinesWFTResponseContent<'a> {
-    pub fn commands(&self) -> Peekable<impl Iterator<Item = ProtoCommand> + '_> {
+    pub(crate) fn commands(&self) -> Peekable<impl Iterator<Item = ProtoCommand> + '_> {
         self.me.get_commands().peekable()
     }
-    pub fn has_messages(&self) -> bool {
+
+    pub(crate) fn has_messages(&self) -> bool {
         !self.me.message_outbox.is_empty()
     }
-    pub fn messages(&mut self) -> Vec<ProtocolMessage> {
+
+    pub(crate) fn messages(&mut self) -> Vec<ProtocolMessage> {
         self.me.message_outbox.drain(..).collect()
     }
-    pub fn metadata_for_complete(&mut self) -> WorkflowTaskCompletedMetadata {
+
+    pub(crate) fn metadata_for_complete(&mut self) -> WorkflowTaskCompletedMetadata {
         self.me.get_metadata_for_wft_complete()
     }
 }

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

@@ -11,7 +11,7 @@ use std::{
 };
 use temporal_sdk_core_protos::temporal::api::{
     enums::v1::{CommandType, EventType, WorkflowTaskFailedCause},
-    history::v1::{history_event::Attributes::WorkflowTaskFailedEventAttributes, HistoryEvent},
+    history::v1::history_event::Attributes::WorkflowTaskFailedEventAttributes,
 };
 
 fsm! {
@@ -88,17 +88,6 @@ impl WFMachinesAdapter for WorkflowTaskMachine {
             }
         }
     }
-
-    fn matches_event(&self, event: &HistoryEvent) -> bool {
-        matches!(
-            event.event_type(),
-            EventType::WorkflowTaskScheduled
-                | EventType::WorkflowTaskStarted
-                | EventType::WorkflowTaskTimedOut
-                | EventType::WorkflowTaskCompleted
-                | EventType::WorkflowTaskFailed
-        )
-    }
 }
 
 impl TryFrom<HistEventData> for WorkflowTaskMachineEvents {
@@ -136,9 +125,9 @@ impl TryFrom<HistEventData> for WorkflowTaskMachineEvents {
                     Self::WorkflowTaskFailed(WFTFailedDat {
                         new_run_id: match attributes {
                             WorkflowTaskFailedEventAttributes(a) => {
-                                let cause = WorkflowTaskFailedCause::from_i32(a.cause);
+                                let cause = WorkflowTaskFailedCause::try_from(a.cause);
                                 match cause {
-                                    Some(WorkflowTaskFailedCause::ResetWorkflow) => {
+                                    Ok(WorkflowTaskFailedCause::ResetWorkflow) => {
                                         Some(a.new_run_id)
                                     }
                                     _ => None,