@temporalio/core-bridge 1.6.0 → 1.7.1

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

@@ -2,7 +2,8 @@ use super::{
     workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
     OnEventWrapper, WFMachinesAdapter, WFMachinesError,
 };
-use rustfsm::{fsm, MachineError, TransitionResult};
+use crate::worker::workflow::machines::HistEventData;
+use rustfsm::{fsm, MachineError, StateMachine, TransitionResult};
 use std::convert::TryFrom;
 use temporal_sdk_core_protos::{
     coresdk::{
@@ -85,10 +86,8 @@ pub(super) fn new_external_signal(
         Some(sig_we::Target::WorkflowExecution(we)) => (we, false),
     };
 
-    let mut s = SignalExternalMachine {
-        state: Created {}.into(),
-        shared_state: SharedState { seq: attrs.seq },
-    };
+    let mut s =
+        SignalExternalMachine::from_parts(Created {}.into(), SharedState { seq: attrs.seq });
     OnEventWrapper::on_event_mut(&mut s, SignalExternalMachineEvents::Schedule)
         .expect("Scheduling signal external wf command doesn't fail");
     let cmd_attrs = command::Attributes::SignalExternalWorkflowExecutionCommandAttributes(
@@ -183,10 +182,11 @@ impl TryFrom<CommandType> for SignalExternalMachineEvents {
         })
     }
 }
-impl TryFrom<HistoryEvent> for SignalExternalMachineEvents {
+impl TryFrom<HistEventData> for SignalExternalMachineEvents {
     type Error = WFMachinesError;
 
-    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
+    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
+        let e = e.event;
         Ok(match e.event_type() {
             EventType::ExternalWorkflowExecutionSignaled => Self::ExternalWorkflowExecutionSignaled,
             EventType::SignalExternalWorkflowExecutionInitiated => {
@@ -295,7 +295,7 @@ impl Cancellable for SignalExternalMachine {
     fn was_cancelled_before_sent_to_server(&self) -> bool {
         // We are only ever in the cancelled state if cancelled before sent to server, there is no
         // after sent cancellation here.
-        matches!(self.state, SignalExternalMachineState::Cancelled(_))
+        matches!(self.state(), SignalExternalMachineState::Cancelled(_))
     }
 }
 
@@ -425,13 +425,10 @@ mod tests {
             SignalExternalMachineState::Cancelled(Cancelled {}),
             Signaled {}.into(),
         ] {
-            let mut s = SignalExternalMachine {
-                state: state.clone(),
-                shared_state: Default::default(),
-            };
+            let mut s = SignalExternalMachine::from_parts(state.clone(), Default::default());
             let cmds = s.cancel().unwrap();
             assert_eq!(cmds.len(), 0);
-            assert_eq!(discriminant(&state), discriminant(&s.state));
+            assert_eq!(discriminant(&state), discriminant(s.state()));
         }
     }
 }

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

@@ -4,7 +4,7 @@ use super::{
     workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
     OnEventWrapper, WFMachinesAdapter,
 };
-use crate::worker::workflow::WFMachinesError;
+use crate::worker::workflow::{machines::HistEventData, WFMachinesError};
 use rustfsm::{fsm, MachineError, StateMachine, TransitionResult};
 use std::convert::TryFrom;
 use temporal_sdk_core_protos::{
@@ -84,20 +84,21 @@ impl TimerMachine {
     }
 
     fn new(attribs: StartTimer) -> Self {
-        Self {
-            state: Created {}.into(),
-            shared_state: SharedState {
+        Self::from_parts(
+            Created {}.into(),
+            SharedState {
                 attrs: attribs,
                 cancelled_before_sent: false,
             },
-        }
+        )
     }
 }
 
-impl TryFrom<HistoryEvent> for TimerMachineEvents {
+impl TryFrom<HistEventData> for TimerMachineEvents {
     type Error = WFMachinesError;
 
-    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
+    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
+        let e = e.event;
         Ok(match e.event_type() {
             EventType::TimerStarted => Self::TimerStarted(e.event_id),
             EventType::TimerCanceled => Self::TimerCanceled,
@@ -177,15 +178,9 @@ impl StartCommandCreated {
         TransitionResult::default()
     }
 
-    pub(super) fn on_cancel(self, dat: SharedState) -> TimerMachineTransition<Canceled> {
-        TransitionResult::ok_shared(
-            vec![],
-            Canceled::default(),
-            SharedState {
-                cancelled_before_sent: true,
-                ..dat
-            },
-        )
+    pub(super) fn on_cancel(self, dat: &mut SharedState) -> TimerMachineTransition<Canceled> {
+        dat.cancelled_before_sent = true;
+        TransitionResult::default()
     }
 }
 
@@ -195,7 +190,7 @@ pub(super) struct StartCommandRecorded {}
 impl StartCommandRecorded {
     pub(super) fn on_timer_fired(
         self,
-        dat: SharedState,
+        dat: &mut SharedState,
         attrs: TimerFiredEventAttributes,
     ) -> TimerMachineTransition<Fired> {
         if dat.attrs.seq.to_string() == attrs.timer_id {
@@ -210,7 +205,7 @@ impl StartCommandRecorded {
 
     pub(super) fn on_cancel(
         self,
-        dat: SharedState,
+        dat: &mut SharedState,
     ) -> TimerMachineTransition<CancelTimerCommandCreated> {
         let cmd = Command {
             command_type: CommandType::CancelTimer as i32,
@@ -422,13 +417,10 @@ mod test {
     #[test]
     fn cancels_ignored_terminal() {
         for state in [TimerMachineState::Canceled(Canceled {}), Fired {}.into()] {
-            let mut s = TimerMachine {
-                state: state.clone(),
-                shared_state: Default::default(),
-            };
+            let mut s = TimerMachine::from_parts(state.clone(), Default::default());
             let cmds = s.cancel().unwrap();
             assert_eq!(cmds.len(), 0);
-            assert_eq!(discriminant(&state), discriminant(&s.state));
+            assert_eq!(discriminant(&state), discriminant(s.state()));
         }
     }
 }

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

@@ -1,18 +1,28 @@
 use super::{workflow_machines::MachineResponse, NewMachineWithCommand};
-use crate::worker::workflow::{
-    machines::{Cancellable, EventInfo, WFMachinesAdapter},
-    WFMachinesError,
+use crate::{
+    internal_flags::CoreInternalFlags,
+    worker::workflow::{
+        machines::{
+            patch_state_machine::VERSION_SEARCH_ATTR_KEY, Cancellable, EventInfo, HistEventData,
+            WFMachinesAdapter,
+        },
+        InternalFlagsRef, WFMachinesError,
+    },
 };
-use rustfsm::{fsm, TransitionResult};
+use rustfsm::{fsm, StateMachine, TransitionResult};
 use temporal_sdk_core_protos::{
     coresdk::workflow_commands::UpsertWorkflowSearchAttributes,
     temporal::api::{
-        command::v1::Command,
+        command::v1::{command, Command, UpsertWorkflowSearchAttributesCommandAttributes},
+        common::v1::SearchAttributes,
         enums::v1::{CommandType, EventType},
-        history::v1::HistoryEvent,
+        history::v1::{history_event, HistoryEvent},
     },
 };
 
+/// By default the server permits SA values under 2k.
+pub(crate) const MAX_SEARCH_ATTR_PAYLOAD_SIZE: usize = 2048;
+
 fsm! {
     pub(super) name UpsertSearchAttributesMachine;
     command UpsertSearchAttributesMachineCommand;
@@ -28,18 +38,54 @@ fsm! {
     // 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;
+    CommandIssued --(CommandRecorded, on_command_recorded) --> Done;
 }
 
 /// 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,
+    internal_flags: InternalFlagsRef,
+    replaying: bool,
+) -> NewMachineWithCommand {
+    let has_flag = internal_flags
+        .borrow_mut()
+        .try_use(CoreInternalFlags::UpsertSearchAttributeOnPatch, !replaying);
+    if has_flag
+        && attribs
+            .search_attributes
+            .contains_key(VERSION_SEARCH_ATTR_KEY)
+    {
+        warn!(
+            "Upserting the {VERSION_SEARCH_ATTR_KEY} search attribute directly from workflow code \
+             is not permitted and has no effect!"
+        );
+        // We must still create the command to preserve compatability with anyone previously doing
+        // this.
+        create_new(Default::default())
+    } else {
+        create_new(attribs.search_attributes.into())
+    }
+}
+
+/// May be used by other state machines / internal needs which desire upserting search attributes.
+pub(super) fn upsert_search_attrs_internal(
+    attribs: UpsertWorkflowSearchAttributesCommandAttributes,
 ) -> NewMachineWithCommand {
-    let sm = UpsertSearchAttributesMachine::new();
+    create_new(attribs.search_attributes.unwrap_or_default())
+}
+
+fn create_new(sa_map: SearchAttributes) -> NewMachineWithCommand {
+    let sm = UpsertSearchAttributesMachine::from_parts(Created {}.into(), SharedState {});
     let cmd = Command {
         command_type: CommandType::UpsertWorkflowSearchAttributes as i32,
-        attributes: Some(attribs.into()),
+        attributes: Some(
+            command::Attributes::UpsertWorkflowSearchAttributesCommandAttributes(
+                UpsertWorkflowSearchAttributesCommandAttributes {
+                    search_attributes: Some(sa_map),
+                },
+            ),
+        ),
     };
     NewMachineWithCommand {
         command: cmd,
@@ -47,8 +93,8 @@ pub(super) fn upsert_search_attrs(
     }
 }
 
-/// Unused but must exist
-type SharedState = ();
+#[derive(Clone)]
+pub(super) struct SharedState {}
 
 /// 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
@@ -66,20 +112,17 @@ pub(super) struct Created {}
 #[derive(Debug, Default, Clone, derive_more::Display)]
 pub(super) struct CommandIssued {}
 
+impl CommandIssued {
+    pub(super) fn on_command_recorded(self) -> UpsertSearchAttributesMachineTransition<Done> {
+        TransitionResult::default()
+    }
+}
+
 /// 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
@@ -109,12 +152,12 @@ 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 {
+impl TryFrom<HistEventData> for UpsertSearchAttributesMachineEvents {
     type Error = WFMachinesError;
 
-    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
-        match e.event_type() {
-            EventType::UpsertWorkflowSearchAttributes => {
+    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
+        match e.event.attributes {
+            Some(history_event::Attributes::UpsertWorkflowSearchAttributesEventAttributes(_)) => {
                 Ok(UpsertSearchAttributesMachineEvents::CommandRecorded)
             }
             _ => Err(Self::Error::Nondeterminism(format!(
@@ -141,13 +184,6 @@ impl TryFrom<CommandType> for UpsertSearchAttributesMachineEvents {
     }
 }
 
-// There is no Command/Response associated with this transition
-impl From<CommandIssued> for Done {
-    fn from(_: CommandIssued) -> Self {
-        Self {}
-    }
-}
-
 // There is no Command/Response associated with this transition
 impl From<Created> for CommandIssued {
     fn from(_: Created) -> Self {
@@ -158,12 +194,29 @@ impl From<Created> for CommandIssued {
 #[cfg(test)]
 mod tests {
     use super::{super::OnEventWrapper, *};
-    use crate::{replay::TestHistoryBuilder, worker::workflow::ManagedWFFunc};
+    use crate::{
+        replay::TestHistoryBuilder,
+        test_help::{build_mock_pollers, mock_worker, MockPollCfg, ResponseType},
+        worker::{
+            client::mocks::mock_workflow_client,
+            workflow::{machines::patch_state_machine::VERSION_SEARCH_ATTR_KEY, ManagedWFFunc},
+        },
+    };
     use rustfsm::StateMachine;
+    use std::collections::HashMap;
     use temporal_sdk::{WfContext, WorkflowFunction};
-    use temporal_sdk_core_protos::temporal::api::{
-        command::v1::command::Attributes, common::v1::Payload,
+    use temporal_sdk_core_api::Worker;
+    use temporal_sdk_core_protos::{
+        coresdk::{
+            workflow_commands::SetPatchMarker, workflow_completion::WorkflowActivationCompletion,
+            AsJsonPayloadExt,
+        },
+        temporal::api::{
+            command::v1::command::Attributes, common::v1::Payload,
+            history::v1::UpsertWorkflowSearchAttributesEventAttributes,
+        },
     };
+    use temporal_sdk_core_test_utils::WorkerTestHelpers;
 
     #[tokio::test]
     async fn upsert_search_attrs_from_workflow() {
@@ -216,27 +269,115 @@ mod tests {
         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());
+    #[rstest::rstest]
+    fn upsert_search_attrs_sm() {
+        let mut sm = UpsertSearchAttributesMachine::from_parts(Created {}.into(), SharedState {});
 
-        let cmd_scheduled_sm_event = CommandType::UpsertWorkflowSearchAttributes
-            .try_into()
-            .unwrap();
+        let sa_attribs = UpsertWorkflowSearchAttributesEventAttributes {
+            workflow_task_completed_event_id: 0,
+            search_attributes: Some(SearchAttributes {
+                indexed_fields: HashMap::from([("Yo".to_string(), Payload::default())]),
+            }),
+        };
         let recorded_history_event = HistoryEvent {
             event_type: EventType::UpsertWorkflowSearchAttributes as i32,
+            attributes: Some(
+                history_event::Attributes::UpsertWorkflowSearchAttributesEventAttributes(
+                    sa_attribs,
+                ),
+            ),
             ..Default::default()
         };
         assert!(sm.matches_event(&recorded_history_event));
-        let cmd_recorded_sm_event = recorded_history_event.try_into().unwrap();
+        let cmd_recorded_sm_event = HistEventData {
+            event: recorded_history_event,
+            replaying: false,
+            current_task_is_last_in_history: true,
+        }
+        .try_into()
+        .unwrap();
 
-        OnEventWrapper::on_event_mut(&mut sm, cmd_scheduled_sm_event)
-            .expect("CommandScheduled should transition Created -> CommandIssued");
+        OnEventWrapper::on_event_mut(
+            &mut sm,
+            CommandType::UpsertWorkflowSearchAttributes
+                .try_into()
+                .unwrap(),
+        )
+        .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");
+        let recorded_res = OnEventWrapper::on_event_mut(&mut sm, cmd_recorded_sm_event);
+        recorded_res.expect("CommandRecorded should transition CommandIssued -> Done");
         assert_eq!(Done {}.to_string(), sm.state().to_string());
     }
+
+    #[rstest::rstest]
+    #[tokio::test]
+    async fn upserting_change_version_directly(
+        #[values(true, false)] flag_in_history: bool,
+        #[values(true, false)] with_patched_cmd: bool,
+    ) {
+        let patch_id = "whatever".to_string();
+        let mut t = TestHistoryBuilder::default();
+        t.add_by_type(EventType::WorkflowExecutionStarted);
+        t.add_full_wf_task();
+        if flag_in_history {
+            t.set_flags_first_wft(
+                &[CoreInternalFlags::UpsertSearchAttributeOnPatch as u32],
+                &[],
+            );
+        }
+        if with_patched_cmd {
+            t.add_has_change_marker(&patch_id, false);
+        }
+        t.add_upsert_search_attrs_for_patch(&[patch_id.clone()]);
+        t.add_full_wf_task();
+        t.add_workflow_execution_completed();
+
+        let mut mp = MockPollCfg::from_resp_batches(
+            "fakeid",
+            t,
+            [ResponseType::ToTaskNum(1), ResponseType::AllHistory],
+            mock_workflow_client(),
+        );
+        // 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| {
+                assert_matches!(wftc.commands.get(0).and_then(|c| c.attributes.as_ref()).unwrap(),
+            Attributes::UpsertWorkflowSearchAttributesCommandAttributes(attrs)
+            if attrs.search_attributes.as_ref().unwrap().indexed_fields.is_empty())
+            }));
+        }
+        let core = mock_worker(build_mock_pollers(mp));
+
+        let mut ver_upsert = HashMap::new();
+        ver_upsert.insert(
+            VERSION_SEARCH_ATTR_KEY.to_string(),
+            "hi".as_json_payload().unwrap(),
+        );
+        let act = core.poll_workflow_activation().await.unwrap();
+        let mut cmds = if with_patched_cmd {
+            vec![SetPatchMarker {
+                patch_id,
+                deprecated: false,
+            }
+            .into()]
+        } else {
+            vec![]
+        };
+        cmds.push(
+            UpsertWorkflowSearchAttributes {
+                search_attributes: ver_upsert,
+            }
+            .into(),
+        );
+        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
+            act.run_id, cmds,
+        ))
+        .await
+        .unwrap();
+        // Now ensure that encountering the upsert in history works fine
+        let act = core.poll_workflow_activation().await.unwrap();
+        core.complete_execution(&act.run_id).await;
+    }
 }