@temporalio/core-bridge 1.10.3 → 1.11.1

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

@@ -6,7 +6,7 @@ use crate::{
 use itertools::Itertools;
 use prost::EncodeError;
 use rustfsm::{fsm, MachineError, StateMachine, TransitionResult};
-use std::{convert::TryFrom, mem};
+use std::convert::TryFrom;
 use temporal_sdk_core_protos::{
     coresdk::{
         workflow_activation::DoUpdate,
@@ -18,6 +18,7 @@ use temporal_sdk_core_protos::{
         enums::v1::{CommandType, EventType},
         failure::v1::Failure,
         protocol::v1::Message as ProtocolMessage,
+        update,
         update::v1::{outcome, Acceptance, Outcome, Rejection, Response},
     },
     utilities::pack_any,
@@ -59,9 +60,9 @@ fsm! {
 #[derive(Debug, derive_more::Display)]
 pub(super) enum UpdateMachineCommand {
     #[display(fmt = "Accept")]
-    Accept,
+    Accept(update::v1::Request),
     #[display(fmt = "Reject")]
-    Reject(Failure),
+    Reject(update::v1::Request, Failure),
     #[display(fmt = "Complete")]
     Complete(Payload),
     #[display(fmt = "Fail")]
@@ -73,7 +74,7 @@ pub(super) struct SharedState {
     message_id: String,
     instance_id: String,
     event_seq_id: i64,
-    request: UpdateRequest,
+    meta: update::v1::Meta,
 }
 
 impl UpdateMachine {
@@ -81,27 +82,31 @@ impl UpdateMachine {
         message_id: String,
         instance_id: String,
         event_seq_id: i64,
-        mut request: UpdateRequest,
+        request: UpdateRequest,
         replaying: bool,
     ) -> NewMachineWithResponse {
+        let meta = request.meta().clone();
+        let do_update = DoUpdate {
+            id: meta.update_id.clone(),
+            protocol_instance_id: instance_id.clone(),
+            name: request.name().to_string(),
+            input: request.input(),
+            headers: request.headers(),
+            meta: Some(meta.clone()),
+            run_validator: !replaying,
+        };
         let me = Self::from_parts(
-            RequestInitiated {}.into(),
+            RequestInitiated {
+                original_request: request.original,
+            }
+            .into(),
             SharedState {
                 message_id,
-                instance_id: instance_id.clone(),
+                instance_id,
                 event_seq_id,
-                request: request.clone(),
+                meta,
             },
         );
-        let do_update = DoUpdate {
-            id: mem::replace(&mut request.meta.update_id, "".to_string()),
-            protocol_instance_id: instance_id,
-            name: request.name,
-            input: request.input,
-            headers: request.headers,
-            meta: Some(request.meta),
-            run_validator: !replaying,
-        };
         NewMachineWithResponse {
             machine: me.into(),
             response: MachineResponse::PushWFJob(do_update.into()),
@@ -116,7 +121,7 @@ impl UpdateMachine {
             None => {
                 return Err(WFMachinesError::Fatal(format!(
                     "Update response for update {} had an empty result, this is a lang layer bug.",
-                    &self.shared_state.request.meta.update_id
+                    &self.shared_state.meta.update_id
                 )))
             }
             Some(update_response::Response::Accepted(_)) => {
@@ -132,7 +137,7 @@ impl UpdateMachine {
         .map_err(|e| match e {
             MachineError::InvalidTransition => WFMachinesError::Nondeterminism(format!(
                 "Invalid transition while handling update response (id {}) in state {}",
-                &self.shared_state.request.meta.update_id,
+                &self.shared_state.meta.update_id,
                 self.state(),
             )),
             MachineError::Underlying(e) => e,
@@ -231,29 +236,29 @@ impl WFMachinesAdapter for UpdateMachine {
         _event_info: Option<EventInfo>,
     ) -> Result<Vec<MachineResponse>, WFMachinesError> {
         Ok(match my_command {
-            UpdateMachineCommand::Accept => self.build_command_msg(
+            UpdateMachineCommand::Accept(orig) => self.build_command_msg(
                 format!("{}/accept", self.shared_state.message_id),
                 UpdateMsg::Accept(Acceptance {
                     accepted_request_message_id: self.shared_state.message_id.clone(),
                     accepted_request_sequencing_event_id: self.shared_state.event_seq_id,
-                    ..Default::default()
+                    accepted_request: Some(orig),
                 }),
             )?,
-            UpdateMachineCommand::Reject(fail) => {
+            UpdateMachineCommand::Reject(orig, fail) => {
                 vec![self.build_msg(
                     format!("{}/reject", self.shared_state.message_id),
                     UpdateMsg::Reject(Rejection {
                         rejected_request_message_id: self.shared_state.message_id.clone(),
                         rejected_request_sequencing_event_id: self.shared_state.event_seq_id,
+                        rejected_request: Some(orig),
                         failure: Some(fail),
-                        ..Default::default()
                     }),
                 )?]
             }
             UpdateMachineCommand::Complete(p) => self.build_command_msg(
                 format!("{}/complete", self.shared_state.message_id),
                 UpdateMsg::Response(Response {
-                    meta: Some(self.shared_state.request.meta.clone()),
+                    meta: Some(self.shared_state.meta.clone()),
                     outcome: Some(Outcome {
                         value: Some(outcome::Value::Success(p.into())),
                     }),
@@ -262,7 +267,7 @@ impl WFMachinesAdapter for UpdateMachine {
             UpdateMachineCommand::Fail(f) => self.build_command_msg(
                 format!("{}/complete", self.shared_state.message_id),
                 UpdateMsg::Response(Response {
-                    meta: Some(self.shared_state.request.meta.clone()),
+                    meta: Some(self.shared_state.meta.clone()),
                     outcome: Some(Outcome {
                         value: Some(outcome::Value::Failure(f)),
                     }),
@@ -284,13 +289,18 @@ impl TryFrom<CommandType> for UpdateMachineEvents {
 }
 
 #[derive(Default, Clone)]
-pub(super) struct RequestInitiated {}
+pub(super) struct RequestInitiated {
+    original_request: update::v1::Request,
+}
 impl RequestInitiated {
     fn on_accept(self) -> UpdateMachineTransition<Accepted> {
-        UpdateMachineTransition::commands([UpdateMachineCommand::Accept])
+        UpdateMachineTransition::commands([UpdateMachineCommand::Accept(self.original_request)])
     }
     fn on_reject(self, fail: Failure) -> UpdateMachineTransition<Rejected> {
-        UpdateMachineTransition::commands([UpdateMachineCommand::Reject(fail)])
+        UpdateMachineTransition::commands([UpdateMachineCommand::Reject(
+            self.original_request,
+            fail,
+        )])
     }
 }
 

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

@@ -86,6 +86,7 @@ fn create_new(sa_map: SearchAttributes) -> NewMachineWithCommand {
                 },
             ),
         ),
+        user_metadata: Default::default(),
     };
     NewMachineWithCommand {
         command: cmd,
@@ -339,7 +340,7 @@ mod tests {
         );
         // Ensure the upsert command has an empty map when not using the patched command
         if !with_patched_cmd {
-            mp.completion_asserts = Some(Box::new(|wftc| {
+            mp.completion_mock_fn = Some(Box::new(|wftc| {
                 let cmd_attrs = wftc
                     .commands
                     .first()
@@ -349,11 +350,12 @@ mod tests {
                     cmd_attrs,
                     Attributes::CompleteWorkflowExecutionCommandAttributes(_)
                 ) {
-                    return;
+                    return Ok(Default::default());
                 }
                 assert_matches!(cmd_attrs,
                     Attributes::UpsertWorkflowSearchAttributesCommandAttributes(attrs)
                     if attrs.search_attributes.clone().unwrap_or_default().indexed_fields.is_empty());
+                Ok(Default::default())
             }));
         }
         let mut mock = build_mock_pollers(mp);

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

@@ -14,7 +14,7 @@ use super::{
 };
 use crate::{
     abstractions::dbg_panic,
-    internal_flags::InternalFlags,
+    internal_flags::{CoreInternalFlags, InternalFlags},
     protosext::{
         protocol_messages::{IncomingProtocolMessage, IncomingProtocolMessageBody},
         CompleteLocalActivityData, HistoryEventExt, ValidScheduleLA,
@@ -37,6 +37,7 @@ use crate::{
         ExecutingLAId, LocalActRequest, LocalActivityExecutionResult, LocalActivityResolution,
     },
 };
+use anyhow::Context;
 use siphasher::sip::SipHasher13;
 use slotmap::{SlotMap, SparseSecondaryMap};
 use std::{
@@ -238,7 +239,7 @@ impl WorkflowMachines {
     pub(crate) fn new(basics: RunBasics, driven_wf: DrivenWorkflow) -> Self {
         let replaying = basics.history.previous_wft_started_id > 0;
         let mut observed_internal_flags = InternalFlags::new(basics.capabilities);
-        // Peek ahead to determine used patches in the first WFT.
+        // Peek ahead to determine used flags in the first WFT.
         if let Some(attrs) = basics.history.peek_next_wft_completed(0) {
             observed_internal_flags.add_from_complete(attrs);
         };
@@ -469,22 +470,30 @@ impl WorkflowMachines {
             .add_lang_used(flags);
     }
 
+    pub(crate) fn try_use_flag(&self, flag: CoreInternalFlags, should_record: bool) -> bool {
+        self.observed_internal_flags
+            .borrow_mut()
+            .try_use(flag, should_record)
+    }
+
     /// Undo a speculative workflow task by resetting to a certain WFT Started ID. This can happen
     /// when an update request is rejected.
     pub(crate) fn reset_last_started_id(&mut self, id: i64) {
         debug!("Resetting back to event id {} due to speculative WFT", id);
         self.current_started_event_id = id;
-        // This is pretty nasty to just + 1 like this, but, we know WFT complete always follows
-        // WFT started, which the id given to us to reset to must be, and we need to avoid
-        // re-applying the WFT Completed event, so we make sure to consider that processed
-        self.last_processed_event = id + 1;
+        // We must reset the last event we "processed" to be after the last WFT we really completed
+        // + any command events (since the SDK "processed" those when it emitted the commands). This
+        // is also equal to what we just processed in the speculative task, minus two, since we
+        // would've just handled the most recent WFT started event, and we need to drop that & the
+        // schedule event just before it.
+        self.last_processed_event -= 2;
         // Then, we have to drop any state machines (which should only be one workflow task machine)
         // we may have created when servicing the speculative task.
         // Remove when https://github.com/rust-lang/rust/issues/59618 is stable
         let remove_these: Vec<_> = self
             .machines_by_event_id
             .iter()
-            .filter(|(mid, _)| **mid > id)
+            .filter(|(mid, _)| **mid > self.last_processed_event)
             .map(|(mid, mkey)| (*mid, *mkey))
             .collect();
         for (mid, mkey) in remove_these {
@@ -526,43 +535,6 @@ impl WorkflowMachines {
             return Ok(0);
         }
 
-        fn get_processable_messages(
-            me: &mut WorkflowMachines,
-            for_event_id: i64,
-        ) -> Vec<IncomingProtocolMessage> {
-            // Another thing to replace when `drain_filter` exists
-            let mut ret = vec![];
-            me.protocol_msgs = std::mem::take(&mut me.protocol_msgs)
-                .into_iter()
-                .filter_map(|x| {
-                    if x.processable_after_event_id()
-                        .is_some_and(|eid| eid <= for_event_id)
-                    {
-                        ret.push(x);
-                        None
-                    } else {
-                        Some(x)
-                    }
-                })
-                .collect();
-            ret
-        }
-
-        // Peek to the next WFT complete and update ourselves with data we might need in it.
-        if let Some(next_complete) = self
-            .last_history_from_server
-            .peek_next_wft_completed(self.last_processed_event)
-        {
-            // We update the internal flags before applying the current task
-            (*self.observed_internal_flags)
-                .borrow_mut()
-                .add_from_complete(next_complete);
-            // Save this tasks' Build ID if it had one
-            if let Some(bid) = next_complete.worker_version.as_ref().map(|wv| &wv.build_id) {
-                self.current_wft_build_id = Some(bid.to_string());
-            }
-        }
-
         let last_handled_wft_started_id = self.current_started_event_id;
         let (events, has_final_event) = match self
             .last_history_from_server
@@ -584,7 +556,37 @@ impl WorkflowMachines {
         };
         let num_events_to_process = events.len();
 
-        // We're caught up on reply if there are no new events to process
+        // Process any WFT completed events in the next sequence, as well as peek ahead to the
+        // subsequent one to properly apply flags & any other data. Macro used to avoid self
+        // double-borrow.
+        macro_rules! apply_wft_complete_data {
+            ($me:expr, $wtc:expr) => {{
+                (*$me.observed_internal_flags)
+                    .borrow_mut()
+                    .add_from_complete($wtc);
+                if let Some(bid) = $wtc.worker_version.as_ref().map(|wv| &wv.build_id) {
+                    $me.current_wft_build_id = Some(bid.to_string());
+                }
+            }};
+        }
+        let mut peeked_events = events.iter().peekable();
+        while let Some(event) = peeked_events.next() {
+            if let Some(history_event::Attributes::WorkflowTaskCompletedEventAttributes(ref wtc)) =
+                event.attributes
+            {
+                apply_wft_complete_data!(self, wtc);
+            }
+            if peeked_events.peek().is_none() {
+                if let Some(wtc) = self
+                    .last_history_from_server
+                    .peek_next_wft_completed(event.event_id)
+                {
+                    apply_wft_complete_data!(self, wtc);
+                }
+            }
+        }
+
+        // We're caught up on replay if there are no new events to process
         if events.is_empty() {
             self.replaying = false;
         }
@@ -596,6 +598,7 @@ impl WorkflowMachines {
             }
         }
 
+        let mut update_admitted_event_messages = HashMap::<String, IncomingProtocolMessage>::new();
         let mut do_handle_event = true;
         let mut history = events.into_iter().peekable();
         while let Some(event) = history.next() {
@@ -628,8 +631,42 @@ impl WorkflowMachines {
                 self.replaying = false;
             }
 
+            if matches!(
+                event.attributes,
+                Some(history_event::Attributes::WorkflowExecutionUpdateAdmittedEventAttributes(_)),
+            ) {
+                // The server has sent a durable update admitted event: create the message that would have been sent
+                // for a non-durable update request message.
+                let msg = IncomingProtocolMessage::try_from(&event).context(
+                    "Failed to create protocol message from WorkflowExecutionUpdateAdmittedEvent",
+                )?;
+                if self.replaying {
+                    // Stash the message for use if the update request is accepted.
+                    update_admitted_event_messages.insert(msg.protocol_instance_id.clone(), msg);
+                } else {
+                    // Use the message now.
+                    self.protocol_msgs.push(msg);
+                }
+                do_handle_event = false;
+            }
+
             // Process any messages that should be processed before the event we're about to handle
-            let processable_msgs = get_processable_messages(self, eid - 1);
+            let for_event_id = eid - 1;
+            // Another thing to replace when `drain_filter` exists
+            let mut processable_msgs = vec![];
+            self.protocol_msgs = std::mem::take(&mut self.protocol_msgs)
+                .into_iter()
+                .filter_map(|x| {
+                    if x.processable_after_event_id()
+                        .is_some_and(|eid| eid <= for_event_id)
+                    {
+                        processable_msgs.push(x);
+                        None
+                    } else {
+                        Some(x)
+                    }
+                })
+                .collect();
             for msg in processable_msgs {
                 self.handle_protocol_message(msg)?;
             }
@@ -699,26 +736,16 @@ impl WorkflowMachines {
                 history_event::Attributes::WorkflowExecutionUpdateAcceptedEventAttributes(ref atts),
             ) = e.attributes
             {
-                // If we see a workflow update accepted event, initialize the machine for it by
-                // pretending we received the message we would've under not-replay.
-                delayed_actions.push(DelayedAction::ProtocolMessage(IncomingProtocolMessage {
-                    id: atts.accepted_request_message_id.clone(),
-                    protocol_instance_id: atts.protocol_instance_id.clone(),
-                    sequencing_id: Some(SequencingId::EventId(
-                        atts.accepted_request_sequencing_event_id,
-                    )),
-                    body: IncomingProtocolMessageBody::UpdateRequest(
-                        atts.accepted_request
-                            .clone()
-                            .ok_or_else(|| {
-                                WFMachinesError::Fatal(
-                                    "Update accepted event must contain accepted request"
-                                        .to_string(),
-                                )
-                            })?
-                            .try_into()?,
-                    ),
-                }));
+                // We've encountered an UpdateAccepted event during replay: pretend that we received the message we
+                // would have when receiving an update request under not-replay. If this event was preceded by an
+                // UpdateAdmitted event, then use the message that we created when we encountered that.
+                delayed_actions.push(DelayedAction::ProtocolMessage(
+                    update_admitted_event_messages
+                        .remove(&atts.protocol_instance_id)
+                        .map_or_else(|| e.try_into().context(
+                            "Failed to create protocol message from WorkflowExecutionUpdateAcceptedEvent",
+                        ), Ok)?,
+                ));
             }
         }
         for action in delayed_actions {
@@ -780,10 +807,7 @@ impl WorkflowMachines {
                 Ok(EventHandlingOutcome::Normal)
             };
         }
-        if event.event_type() == EventType::Unspecified
-            || event.event_type() == EventType::WorkflowExecutionUpdateAdmitted
-            || event.attributes.is_none()
-        {
+        if event.event_type() == EventType::Unspecified || event.attributes.is_none() {
             return if !event.worker_may_ignore {
                 Err(WFMachinesError::Fatal(format!(
                     "Event type is unspecified! This history is invalid. Event detail: {event:?}"
@@ -910,7 +934,7 @@ impl WorkflowMachines {
                     attrs,
                 )) = event_dat.event.attributes
                 {
-                    if let Some(st) = event_dat.event.event_time.clone() {
+                    if let Some(st) = event_dat.event.event_time {
                         let as_systime: SystemTime = st.try_into()?;
                         self.workflow_start_time = Some(as_systime);
                         // Set the workflow time to be the event time of the first event, so that

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

@@ -98,7 +98,7 @@ impl TryFrom<HistEventData> for WorkflowTaskMachineEvents {
         Ok(match e.event_type() {
             EventType::WorkflowTaskScheduled => Self::WorkflowTaskScheduled,
             EventType::WorkflowTaskStarted => Self::WorkflowTaskStarted({
-                let time = if let Some(time) = e.event_time.clone() {
+                let time = if let Some(time) = e.event_time {
                     match time.try_into() {
                         Ok(t) => t,
                         Err(_) => {