@temporalio/core-bridge 1.12.0 → 1.12.2

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

@@ -86,8 +86,8 @@ pub(super) enum NexusOperationCommand {
     Start { operation_token: String },
     #[display("StartSync")]
     StartSync,
-    #[display("CancelBeforeStart")]
-    CancelBeforeStart,
+    #[display("FailBeforeStart")]
+    FailBeforeStart(Failure),
     #[display("Complete")]
     Complete(Option<Payload>),
     #[display("Fail")]
@@ -174,7 +174,9 @@ impl ScheduleCommandCreated {
         state: &mut SharedState,
     ) -> NexusOperationMachineTransition<Cancelled> {
         state.cancelled_before_sent = true;
-        NexusOperationMachineTransition::commands([NexusOperationCommand::CancelBeforeStart])
+        NexusOperationMachineTransition::commands([NexusOperationCommand::FailBeforeStart(
+            state.cancelled_failure("Nexus Operation cancelled before scheduled".to_owned()),
+        )])
     }
 }
 
@@ -208,40 +210,37 @@ impl ScheduledEventRecorded {
         self,
         fa: NexusOperationFailedEventAttributes,
     ) -> NexusOperationMachineTransition<Failed> {
-        NexusOperationMachineTransition::commands([
-            NexusOperationCommand::StartSync,
-            NexusOperationCommand::Fail(fa.failure.unwrap_or_else(|| Failure {
+        NexusOperationMachineTransition::commands([NexusOperationCommand::FailBeforeStart(
+            fa.failure.unwrap_or_else(|| Failure {
                 message: "Nexus operation failed but failure field was not populated".to_owned(),
                 ..Default::default()
-            })),
-        ])
+            }),
+        )])
     }
 
     pub(super) fn on_canceled(
         self,
         ca: NexusOperationCanceledEventAttributes,
     ) -> NexusOperationMachineTransition<Cancelled> {
-        NexusOperationMachineTransition::commands([
-            NexusOperationCommand::StartSync,
-            NexusOperationCommand::Cancel(ca.failure.unwrap_or_else(|| Failure {
-                message:
-                    "Nexus operation was cancelled but failure field was not populated".to_owned(),
+        NexusOperationMachineTransition::commands([NexusOperationCommand::FailBeforeStart(
+            ca.failure.unwrap_or_else(|| Failure {
+                message: "Nexus operation was cancelled but failure field was not populated"
+                    .to_owned(),
                 ..Default::default()
-            })),
-        ])
+            }),
+        )])
     }
 
     pub(super) fn on_timed_out(
         self,
         toa: NexusOperationTimedOutEventAttributes,
     ) -> NexusOperationMachineTransition<TimedOut> {
-        NexusOperationMachineTransition::commands([
-            NexusOperationCommand::StartSync,
-            NexusOperationCommand::TimedOut(toa.failure.unwrap_or_else(|| Failure {
+        NexusOperationMachineTransition::commands([NexusOperationCommand::FailBeforeStart(
+            toa.failure.unwrap_or_else(|| Failure {
                 message: "Nexus operation timed out but failure field was not populated".to_owned(),
                 ..Default::default()
-            })),
-        ])
+            }),
+        )])
     }
 
     pub(super) fn on_started(
@@ -491,30 +490,15 @@ impl WFMachinesAdapter for NexusOperationMachine {
                     .into(),
                 ]
             }
-            NexusOperationCommand::CancelBeforeStart => {
+            NexusOperationCommand::FailBeforeStart(failure) => {
                 vec![
                     ResolveNexusOperationStart {
                         seq: self.shared_state.lang_seq_num,
-                        status: Some(resolve_nexus_operation_start::Status::CancelledBeforeStart(
-                            self.cancelled_failure(
-                                "Nexus Operation cancelled before scheduled".to_owned(),
-                                &self.shared_state.operation_token,
-                            ),
+                        status: Some(resolve_nexus_operation_start::Status::Failed(
+                            failure.clone(),
                         )),
                     }
                     .into(),
-                    ResolveNexusOperation {
-                        seq: self.shared_state.lang_seq_num,
-                        result: Some(NexusOperationResult {
-                            status: Some(nexus_operation_result::Status::Cancelled(
-                                self.cancelled_failure(
-                                    "Nexus Operation cancelled before scheduled".to_owned(),
-                                    &self.shared_state.operation_token,
-                                ),
-                            )),
-                        }),
-                    }
-                    .into(),
                 ]
             }
             NexusOperationCommand::Complete(c) => {
@@ -586,9 +570,8 @@ impl WFMachinesAdapter for NexusOperationMachine {
                             seq: self.shared_state.lang_seq_num,
                             result: Some(NexusOperationResult {
                                 status: Some(nexus_operation_result::Status::Cancelled(
-                                    self.cancelled_failure(
+                                    self.shared_state.cancelled_failure(
                                         "Nexus operation cancelled after starting".to_owned(),
-                                        &self.shared_state.operation_token,
                                     ),
                                 )),
                             }),
@@ -614,8 +597,8 @@ impl TryFrom<CommandType> for NexusOperationMachineEvents {
     }
 }
 
-impl NexusOperationMachine {
-    fn cancelled_failure(&self, message: String, operation_token: &Option<String>) -> Failure {
+impl SharedState {
+    fn cancelled_failure(&self, message: String) -> Failure {
         Failure {
             message,
             cause: Some(Box::new(Failure {
@@ -624,12 +607,12 @@ impl NexusOperationMachine {
             })),
             failure_info: Some(FailureInfo::NexusOperationExecutionFailureInfo(
                 failure::NexusOperationFailureInfo {
-                    scheduled_event_id: self.shared_state.scheduled_event_id,
-                    endpoint: self.shared_state.endpoint.clone(),
-                    service: self.shared_state.service.clone(),
-                    operation: self.shared_state.operation.clone(),
-                    operation_id: "".to_string(),
-                    operation_token: operation_token.clone().unwrap_or_default(),
+                    scheduled_event_id: self.scheduled_event_id,
+                    endpoint: self.endpoint.clone(),
+                    service: self.service.clone(),
+                    operation: self.operation.clone(),
+                    operation_token: self.operation_token.clone().unwrap_or_default(),
+                    ..Default::default()
                 },
             )),
             ..Default::default()

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

@@ -104,9 +104,8 @@ pub(super) fn new_external_signal(
             },
             signal_name: attrs.signal_name,
             input: attrs.args.into_payloads(),
-            // Is deprecated
-            control: "".to_string(),
             child_workflow_only: only_child,
+            ..Default::default()
         },
     );
     Ok(NewMachineWithCommand {

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

@@ -183,7 +183,7 @@ mod tests {
         replay::TestHistoryBuilder,
         test_help::{MockPollCfg, ResponseType, build_fake_sdk, build_mock_pollers, mock_worker},
         worker::{
-            client::mocks::mock_workflow_client,
+            client::mocks::mock_worker_client,
             workflow::machines::patch_state_machine::VERSION_SEARCH_ATTR_KEY,
         },
     };
@@ -319,7 +319,7 @@ mod tests {
         if with_patched_cmd {
             t.add_has_change_marker(&patch_id, false);
         }
-        t.add_upsert_search_attrs_for_patch(&[patch_id.clone()]);
+        t.add_upsert_search_attrs_for_patch(std::slice::from_ref(&patch_id));
         t.add_we_signaled("hi", vec![]);
         t.add_full_wf_task();
         t.add_workflow_execution_completed();
@@ -328,7 +328,7 @@ mod tests {
             "fakeid",
             t,
             [ResponseType::ToTaskNum(1), ResponseType::ToTaskNum(2)],
-            mock_workflow_client(),
+            mock_worker_client(),
         );
         // Ensure the upsert command has an empty map when not using the patched command
         if !with_patched_cmd {

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

@@ -395,7 +395,7 @@ impl WorkflowMachines {
         self.current_started_event_id
     }
 
-    pub(crate) fn prepare_for_wft_response(&mut self) -> MachinesWFTResponseContent {
+    pub(crate) fn prepare_for_wft_response(&mut self) -> MachinesWFTResponseContent<'_> {
         MachinesWFTResponseContent {
             replaying: self.replaying,
             has_pending_jobs: self.has_pending_jobs(),
@@ -839,6 +839,9 @@ impl WorkflowMachines {
         if event.is_final_wf_execution_event() {
             self.have_seen_terminal_event = true;
         }
+        if event.is_ignorable() {
+            return Ok(EventHandlingOutcome::Normal);
+        }
         if matches!(
             event.event_type(),
             EventType::WorkflowExecutionTerminated | EventType::WorkflowExecutionTimedOut

package/sdk-core/core/src/worker/workflow/managed_run.rs

@@ -1441,7 +1441,7 @@ impl WorkflowManager {
 
     /// Must be called when we're ready to respond to a WFT after handling catching up on replay
     /// and handling all activation completions from lang.
-    fn prepare_for_wft_response(&mut self) -> MachinesWFTResponseContent {
+    fn prepare_for_wft_response(&mut self) -> MachinesWFTResponseContent<'_> {
         self.machines.prepare_for_wft_response()
     }
 

package/sdk-core/core/src/worker/workflow/mod.rs

@@ -22,15 +22,13 @@ use crate::{
     },
     internal_flags::InternalFlags,
     pollers::TrackedPermittedTqResp,
-    protosext::{
-        ValidPollWFTQResponse, legacy_query_failure, protocol_messages::IncomingProtocolMessage,
-    },
+    protosext::{ValidPollWFTQResponse, protocol_messages::IncomingProtocolMessage},
     telemetry::{TelemetryInstance, VecDisplayer, set_trace_subscriber_for_current_thread},
     worker::{
         LocalActRequest, LocalActivityExecutionResult, LocalActivityResolution,
         PostActivateHookData,
         activities::{ActivitiesFromWFTsHandle, LocalActivityManager},
-        client::{WorkerClient, WorkflowTaskCompletion},
+        client::{LegacyQueryResult, WorkerClient, WorkflowTaskCompletion},
         workflow::{
             history_update::HistoryPaginator,
             managed_run::RunUpdateAct,
@@ -50,7 +48,6 @@ use std::{
     collections::VecDeque,
     fmt::Debug,
     future::Future,
-    mem,
     ops::DerefMut,
     rc::Rc,
     result,
@@ -408,10 +405,9 @@ impl Workflows {
                                 ),
                                 force_cause: 0,
                             };
-                            // TODO: tim - Update workflow cause when API is ready
                             let new_outcome = FailedActivationWFTReport::Report(
                                 task_token,
-                                WorkflowTaskFailedCause::WorkflowWorkerUnhandledFailure,
+                                WorkflowTaskFailedCause::GrpcMessageTooLarge,
                                 failure,
                             );
                             self.handle_activation_failed(run_id, completion_time, new_outcome)
@@ -434,7 +430,8 @@ impl Workflows {
                 task_token,
                 action: ActivationAction::RespondLegacyQuery { result },
             } => {
-                self.respond_legacy_query(task_token, *result).await;
+                self.respond_legacy_query(task_token, LegacyQueryResult::Succeeded(*result))
+                    .await;
                 WFTReportStatus::Reported {
                     reset_last_started_to: None,
                     completion_time,
@@ -465,7 +462,7 @@ impl Workflows {
             }
             FailedActivationWFTReport::ReportLegacyQueryFailure(task_token, failure) => {
                 warn!(run_id=%run_id, failure=?failure, "Failing legacy query request");
-                self.respond_legacy_query(task_token, legacy_query_failure(failure))
+                self.respond_legacy_query(task_token, LegacyQueryResult::Failed(failure))
                     .await;
                 WFTReportStatus::Reported {
                     reset_last_started_to: None,
@@ -808,7 +805,7 @@ impl Workflows {
     }
 
     /// Wraps responding to legacy queries. Handles ignore-able failures.
-    async fn respond_legacy_query(&self, tt: TaskToken, res: QueryResult) {
+    async fn respond_legacy_query(&self, tt: TaskToken, res: LegacyQueryResult) {
         match self.client.respond_legacy_query(tt, res).await {
             Ok(_) => {}
             Err(e) if e.code() == tonic::Code::NotFound => {
@@ -1100,8 +1097,7 @@ struct BufferedTasks {
     /// current one has been processed).
     query_only_tasks: VecDeque<PermittedWFT>,
     /// These are query-only tasks for the *buffered* wft, if any. They will all be discarded if
-    /// a buffered wft is replaced before being handled. They move to `query_only_tasks` once the
-    /// buffered task is taken.
+    /// a buffered wft is replaced before being handled.
     query_only_tasks_for_buffered: VecDeque<PermittedWFT>,
 }
 
@@ -1136,9 +1132,13 @@ impl BufferedTasks {
         if let Some(q) = self.query_only_tasks.pop_front() {
             return Some(q);
         }
-        if let Some(t) = self.wft.take() {
-            self.query_only_tasks = mem::take(&mut self.query_only_tasks_for_buffered);
-            return Some(t);
+        if self.wft.is_some() {
+            if let Some(q) = self.query_only_tasks_for_buffered.pop_front() {
+                return Some(q);
+            }
+            if let Some(t) = self.wft.take() {
+                return Some(t);
+            }
         }
         None
     }

package/sdk-core/core-api/Cargo.toml

@@ -14,10 +14,9 @@ categories = ["development-tools"]
 
 [features]
 otel_impls = ["dep:opentelemetry"]
-envconfig = ["dep:toml", "dep:serde", "dep:dirs", "dep:anyhow"]
+envconfig = ["dep:toml", "dep:serde", "dep:dirs"]
 
 [dependencies]
-anyhow = { version = "1.0", optional = true }
 async-trait = "0.1"
 dirs = { version = "5.0", optional = true }
 derive_builder = { workspace = true }
@@ -29,6 +28,7 @@ serde_json = "1.0"
 thiserror = { workspace = true }
 toml = { version = "0.8", optional = true }
 tonic = { workspace = true }
+tracing = "0.1"
 tracing-core = "0.1"
 url = "2.3"