@temporalio/core-bridge 1.8.2 → 1.8.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporalio/core-bridge",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "description": "Temporal.io SDK Core<>Node bridge",
   "main": "index.js",
   "types": "lib/index.d.ts",
@@ -23,7 +23,7 @@
   "license": "MIT",
   "dependencies": {
     "@opentelemetry/api": "^1.4.1",
-    "@temporalio/common": "1.8.2",
+    "@temporalio/common": "1.8.4",
     "arg": "^5.0.2",
     "cargo-cp-artifact": "^0.1.6",
     "which": "^2.0.2"
@@ -53,5 +53,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "d85bf54da757741b438f8d39a0e7265b80d4f0d6"
+  "gitHead": "7e65cf816b1deef72973dc64ccbf2c93916a3eb1"
 }

package/sdk-core/core/src/core_tests/replay_flag.rs

@@ -1,8 +1,21 @@
-use crate::{test_help::canned_histories, worker::ManagedWFFunc};
+use crate::{
+    test_help::{
+        build_mock_pollers, canned_histories, hist_to_poll_resp, mock_worker, MockPollCfg,
+    },
+    worker::{client::mocks::mock_workflow_client, ManagedWFFunc, LEGACY_QUERY_ID},
+};
 use rstest::{fixture, rstest};
-use std::time::Duration;
+use std::{collections::VecDeque, time::Duration};
 use temporal_sdk::{WfContext, WorkflowFunction};
-use temporal_sdk_core_protos::temporal::api::enums::v1::CommandType;
+use temporal_sdk_core_api::Worker;
+use temporal_sdk_core_protos::{
+    coresdk::{
+        workflow_commands::{workflow_command::Variant::RespondToQuery, QueryResult, QuerySuccess},
+        workflow_completion::WorkflowActivationCompletion,
+    },
+    temporal::api::{enums::v1::CommandType, query::v1::WorkflowQuery},
+};
+use temporal_sdk_core_test_utils::start_timer_cmd;
 
 fn timers_wf(num_timers: u32) -> WorkflowFunction {
     WorkflowFunction::new(move |command_sink: WfContext| async move {
@@ -63,3 +76,60 @@ async fn replay_flag_is_correct_partial_history() {
     assert_eq!(commands[0].command_type, CommandType::StartTimer as i32);
     wfm.shutdown().await.unwrap();
 }
+
+#[tokio::test]
+async fn replay_flag_correct_with_query() {
+    let wfid = "fake_wf_id";
+    let t = canned_histories::single_timer("1");
+    let tasks = VecDeque::from(vec![
+        {
+            let mut pr = hist_to_poll_resp(&t, wfid.to_owned(), 2.into());
+            // Server can issue queries that contain the WFT completion and the subsequent
+            // commands, but not the consequences yet.
+            pr.query = Some(WorkflowQuery {
+                query_type: "query-type".to_string(),
+                query_args: Some(b"hi".into()),
+                header: None,
+            });
+            let h = pr.history.as_mut().unwrap();
+            h.events.truncate(5);
+            pr.started_event_id = 3;
+            dbg!(&pr.resp);
+            pr
+        },
+        hist_to_poll_resp(&t, wfid.to_owned(), 2.into()),
+    ]);
+    let mut mock = MockPollCfg::from_resp_batches(wfid, t, tasks, mock_workflow_client());
+    mock.num_expected_legacy_query_resps = 1;
+    let mut mock = build_mock_pollers(mock);
+    mock.worker_cfg(|wc| wc.max_cached_workflows = 10);
+    let core = mock_worker(mock);
+
+    let task = core.poll_workflow_activation().await.unwrap();
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+        task.run_id,
+        start_timer_cmd(1, Duration::from_secs(1)),
+    ))
+    .await
+    .unwrap();
+
+    let task = core.poll_workflow_activation().await.unwrap();
+    assert!(task.is_replaying);
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+        task.run_id,
+        RespondToQuery(QueryResult {
+            query_id: LEGACY_QUERY_ID.to_string(),
+            variant: Some(
+                QuerySuccess {
+                    response: Some("hi".into()),
+                }
+                .into(),
+            ),
+        }),
+    ))
+    .await
+    .unwrap();
+
+    let task = core.poll_workflow_activation().await.unwrap();
+    assert!(!task.is_replaying);
+}

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

@@ -235,14 +235,14 @@ impl StartCommandCreated {
             if event_dat.wf_id != state.workflow_id {
                 return TransitionResult::Err(WFMachinesError::Nondeterminism(format!(
                     "Child workflow id of scheduled event '{}' does not \
-                     match child workflow id of activity command '{}'",
+                     match child workflow id of command '{}'",
                     event_dat.wf_id, state.workflow_id
                 )));
             }
             if event_dat.wf_type != state.workflow_type {
                 return TransitionResult::Err(WFMachinesError::Nondeterminism(format!(
                     "Child workflow type of scheduled event '{}' does not \
-                     match child workflow type of activity command '{}'",
+                     match child workflow type of command '{}'",
                     event_dat.wf_type, state.workflow_type
                 )));
             }

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

@@ -270,6 +270,13 @@ impl TryFrom<HistEventData> for PatchMachineEvents {
     }
 }
 
+impl PatchMachine {
+    /// Returns true if this patch machine has the same id as the one provided
+    pub(crate) fn matches_patch(&self, id: &str) -> bool {
+        self.shared_state.patch_id == id
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::{

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

@@ -138,7 +138,7 @@ pub(crate) struct WorkflowMachines {
     current_wf_task_commands: VecDeque<CommandAndMachine>,
 
     /// Information about patch markers we have already seen while replaying history
-    encountered_change_markers: HashMap<String, ChangeInfo>,
+    encountered_patch_markers: HashMap<String, ChangeInfo>,
 
     /// Contains extra local-activity related data
     local_activity_data: LocalActivityData,
@@ -255,7 +255,7 @@ impl WorkflowMachines {
             id_to_machine: Default::default(),
             commands: Default::default(),
             current_wf_task_commands: Default::default(),
-            encountered_change_markers: Default::default(),
+            encountered_patch_markers: Default::default(),
             local_activity_data: LocalActivityData::default(),
             have_seen_terminal_event: false,
         }
@@ -367,9 +367,17 @@ impl WorkflowMachines {
     /// "no work" situation. Possibly, it may know about some work the machines don't, like queries.
     pub(crate) fn get_wf_activation(&mut self) -> WorkflowActivation {
         let jobs = self.drive_me.drain_jobs();
+        // Even though technically we may have satisfied all the criteria to be done with replay,
+        // query only activations are always "replaying" to keep things sane.
+        let all_query = jobs.iter().all(|j| {
+            matches!(
+                j.variant,
+                Some(workflow_activation_job::Variant::QueryWorkflow(_))
+            )
+        });
         WorkflowActivation {
             timestamp: self.current_wf_time.map(Into::into),
-            is_replaying: self.replaying,
+            is_replaying: self.replaying || all_query,
             run_id: self.run_id.clone(),
             history_length: self.last_processed_event as u32,
             jobs,
@@ -488,7 +496,6 @@ impl WorkflowMachines {
             }
         }
 
-        let mut saw_completed = false;
         let mut do_handle_event = true;
         let mut history = events.into_iter().peekable();
         while let Some(event) = history.next() {
@@ -504,17 +511,21 @@ impl WorkflowMachines {
             // This definition of replaying here is that we are no longer replaying as soon as we
             // see new events that have never been seen or produced by the SDK.
             //
-            // Specifically, replay ends once we have seen the last command-event which was produced
-            // as a result of the last completed WFT. Thus, replay would be false for things like
-            // signals which were received and after the last completion, and thus generated the
-            // current WFT being handled.
-            if self.replaying && has_final_event && saw_completed && !event.is_command_event() {
+            // Specifically, replay ends once we have seen any non-command event (IE: events that
+            // aren't a result of something we produced in the SDK) on a WFT which has the final
+            // event in history (meaning we are processing the most recent WFT and there are no
+            // more subsequent WFTs). WFT Completed in this case does not count as a non-command
+            // event, because that will typically show up as the first event in an incremental
+            // history, and we want to ignore it and its associated commands since we "produced"
+            // them.
+            if self.replaying
+                && has_final_event
+                && event.event_type() != EventType::WorkflowTaskCompleted
+                && !event.is_command_event()
+            {
                 // Replay is finished
                 self.replaying = false;
             }
-            if event.event_type() == EventType::WorkflowTaskCompleted {
-                saw_completed = true;
-            }
 
             if do_handle_event {
                 let eho = self.handle_event(
@@ -547,7 +558,7 @@ impl WorkflowMachines {
             .peek_next_wft_sequence(last_handled_wft_started_id)
         {
             if let Some((patch_id, _)) = e.get_patch_marker_details() {
-                self.encountered_change_markers.insert(
+                self.encountered_patch_markers.insert(
                     patch_id.clone(),
                     ChangeInfo {
                         created_command: false,
@@ -718,7 +729,7 @@ impl WorkflowMachines {
         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, next_event)? {
+                match patch_marker_handling(event, mach, next_event)? {
                     EventHandlingOutcome::SkipCommand => {
                         self.commands.pop_front();
                         continue;
@@ -1138,7 +1149,7 @@ impl WorkflowMachines {
                 WFCommand::SetPatchMarker(attrs) => {
                     // Do not create commands for change IDs that we have already created commands
                     // for.
-                    let encountered_entry = self.encountered_change_markers.get(&attrs.patch_id);
+                    let encountered_entry = self.encountered_patch_markers.get(&attrs.patch_id);
                     if !matches!(encountered_entry,
                                  Some(ChangeInfo {created_command}) if *created_command)
                     {
@@ -1147,17 +1158,17 @@ impl WorkflowMachines {
                             self.replaying,
                             attrs.deprecated,
                             encountered_entry.is_some(),
-                            self.encountered_change_markers.keys().map(|s| s.as_str()),
+                            self.encountered_patch_markers.keys().map(|s| s.as_str()),
                             self.observed_internal_flags.clone(),
                         )?;
                         let mkey =
                             self.add_cmd_to_wf_task(patch_machine, CommandIdKind::NeverResolves);
                         self.process_machine_responses(mkey, other_cmds)?;
 
-                        if let Some(ci) = self.encountered_change_markers.get_mut(&attrs.patch_id) {
+                        if let Some(ci) = self.encountered_patch_markers.get_mut(&attrs.patch_id) {
                             ci.created_command = true;
                         } else {
-                            self.encountered_change_markers.insert(
+                            self.encountered_patch_markers.insert(
                                 attrs.patch_id,
                                 ChangeInfo {
                                     created_command: true,
@@ -1360,45 +1371,62 @@ enum EventHandlingOutcome {
 
 /// Special handling for patch markers, when handling command events as in
 /// [WorkflowMachines::handle_command_event]
-fn change_marker_handling(
+fn patch_marker_handling(
     event: &HistoryEvent,
     mach: &Machines,
     next_event: Option<&HistoryEvent>,
 ) -> Result<EventHandlingOutcome> {
-    if !mach.matches_event(event) {
-        // Version markers can be skipped in the event they are deprecated
-        if let Some((patch_name, deprecated)) = event.get_patch_marker_details() {
+    let patch_machine = match mach {
+        Machines::PatchMachine(pm) => Some(pm),
+        _ => None,
+    };
+    let patch_details = event.get_patch_marker_details();
+    fn skip_one_or_two_events(next_event: Option<&HistoryEvent>) -> Result<EventHandlingOutcome> {
+        // Also ignore the subsequent upsert event if present
+        let mut skip_next_event = false;
+        if let Some(Attributes::UpsertWorkflowSearchAttributesEventAttributes(atts)) =
+            next_event.and_then(|ne| ne.attributes.as_ref())
+        {
+            if let Some(ref sa) = atts.search_attributes {
+                skip_next_event = sa.indexed_fields.contains_key(VERSION_SEARCH_ATTR_KEY);
+            }
+        }
+
+        Ok(EventHandlingOutcome::SkipEvent { skip_next_event })
+    }
+
+    if let Some((patch_name, deprecated)) = patch_details {
+        if let Some(pm) = patch_machine {
+            // If the next machine *is* a patch machine, but this marker is deprecated, it may
+            // either apply to this machine (the `deprecate_patch` call is still in workflow code) -
+            // or it could be another `patched` or `deprecate_patch` call for a *different* patch,
+            // which we should also permit. In the latter case, we should skip this event.
+            if !pm.matches_patch(&patch_name) && deprecated {
+                skip_one_or_two_events(next_event)
+            } else {
+                Ok(EventHandlingOutcome::Normal)
+            }
+        } else {
+            // Version markers can be skipped in the event they are deprecated
             // Is deprecated. We can simply ignore this event, as deprecated change
             // markers are allowed without matching changed calls.
             if deprecated {
-                debug!("Deprecated patch marker tried against wrong machine, skipping.");
-
-                // Also ignore the subsequent upsert event if present
-                let mut skip_next_event = false;
-                if let Some(Attributes::UpsertWorkflowSearchAttributesEventAttributes(atts)) =
-                    next_event.and_then(|ne| ne.attributes.as_ref())
-                {
-                    if let Some(ref sa) = atts.search_attributes {
-                        skip_next_event = sa.indexed_fields.contains_key(VERSION_SEARCH_ATTR_KEY);
-                    }
-                }
-
-                return Ok(EventHandlingOutcome::SkipEvent { skip_next_event });
+                debug!("Deprecated patch marker tried against non-patch machine, skipping.");
+                skip_one_or_two_events(next_event)
+            } else {
+                Err(WFMachinesError::Nondeterminism(format!(
+                    "Non-deprecated patch marker encountered for change {patch_name}, but there is \
+                     no corresponding change command!"
+                )))
             }
-            return Err(WFMachinesError::Nondeterminism(format!(
-                "Non-deprecated patch marker encountered for change {patch_name}, \
-                            but there is no corresponding change command!"
-            )));
-        }
-        // Patch machines themselves may also not *have* matching markers, where non-deprecated
-        // calls take the old path, and deprecated calls assume history is produced by a new-code
-        // worker.
-        if matches!(mach, Machines::PatchMachine(_)) {
-            debug!("Skipping non-matching event against patch machine");
-            return Ok(EventHandlingOutcome::SkipCommand);
         }
+    } else if patch_machine.is_some() {
+        debug!("Skipping non-matching event against patch machine");
+        Ok(EventHandlingOutcome::SkipCommand)
+    } else {
+        // Not a patch machine or a patch event
+        Ok(EventHandlingOutcome::Normal)
     }
-    Ok(EventHandlingOutcome::Normal)
 }
 
 #[derive(derive_more::From)]

package/sdk-core/sdk/src/workflow_context.rs

@@ -249,8 +249,8 @@ impl WfContext {
 
     /// Record that this workflow history was created with the provided patch, and it is being
     /// phased out.
-    pub fn deprecate_patch(&self, patch_id: &str) {
-        self.patch_impl(patch_id, true);
+    pub fn deprecate_patch(&self, patch_id: &str) -> bool {
+        self.patch_impl(patch_id, true)
     }
 
     fn patch_impl(&self, patch_id: &str, deprecated: bool) -> bool {

package/sdk-core/tests/integ_tests/workflow_tests/patches.rs

@@ -1,5 +1,8 @@
 use std::{
-    sync::atomic::{AtomicBool, Ordering},
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
     time::Duration,
 };
 
@@ -117,3 +120,34 @@ async fn patched_on_second_workflow_task_is_deterministic() {
     starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }
+
+#[tokio::test]
+async fn can_remove_deprecated_patch_near_other_patch() {
+    let wf_name = "can_add_change_markers";
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
+    let mut worker = starter.worker().await;
+    let did_die = Arc::new(AtomicBool::new(false));
+    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| {
+        let did_die = did_die.clone();
+        async move {
+            ctx.timer(Duration::from_millis(200)).await;
+            if !did_die.load(Ordering::Acquire) {
+                assert!(ctx.deprecate_patch("getting-deprecated"));
+                assert!(ctx.patched("staying"));
+            } else {
+                assert!(ctx.patched("staying"));
+            }
+            ctx.timer(Duration::from_millis(200)).await;
+
+            if !did_die.load(Ordering::Acquire) {
+                did_die.store(true, Ordering::Release);
+                ctx.force_task_fail(anyhow::anyhow!("i'm ded"));
+            }
+            Ok(().into())
+        }
+    });
+
+    starter.start_with_worker(wf_name, &mut worker).await;
+    worker.run_until_done().await.unwrap();
+}