@temporalio/core-bridge 1.11.7 → 1.11.8

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

@@ -1,24 +1,24 @@
 use super::{
-    workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
-    OnEventWrapper, WFMachinesAdapter, WFMachinesError,
+    EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError,
+    workflow_machines::MachineResponse,
 };
 use crate::worker::workflow::machines::HistEventData;
-use rustfsm::{fsm, MachineError, StateMachine, TransitionResult};
+use rustfsm::{MachineError, StateMachine, TransitionResult, fsm};
 use std::convert::TryFrom;
 use temporal_sdk_core_protos::{
     coresdk::{
+        IntoPayloadsExt,
         common::NamespacedWorkflowExecution,
         workflow_activation::ResolveSignalExternalWorkflow,
         workflow_commands::{
-            signal_external_workflow_execution as sig_we, SignalExternalWorkflowExecution,
+            SignalExternalWorkflowExecution, signal_external_workflow_execution as sig_we,
         },
-        IntoPayloadsExt,
     },
     temporal::api::{
-        command::v1::{command, Command, SignalExternalWorkflowExecutionCommandAttributes},
+        command::v1::{SignalExternalWorkflowExecutionCommandAttributes, command},
         common::v1::WorkflowExecution as UpstreamWE,
         enums::v1::{CommandType, EventType, SignalExternalWorkflowExecutionFailedCause},
-        failure::v1::{failure::FailureInfo, ApplicationFailureInfo, CanceledFailureInfo, Failure},
+        failure::v1::{ApplicationFailureInfo, CanceledFailureInfo, Failure, failure::FailureInfo},
         history::v1::history_event,
     },
 };
@@ -73,7 +73,7 @@ pub(super) fn new_external_signal(
         None => {
             return Err(WFMachinesError::Fatal(
                 "Signal external workflow command had empty target field".to_string(),
-            ))
+            ));
         }
         Some(sig_we::Target::ChildWorkflowId(wfid)) => (
             NamespacedWorkflowExecution {
@@ -109,13 +109,8 @@ pub(super) fn new_external_signal(
             child_workflow_only: only_child,
         },
     );
-    let cmd = Command {
-        command_type: CommandType::SignalExternalWorkflowExecution as i32,
-        attributes: Some(cmd_attrs),
-        user_metadata: Default::default(),
-    };
     Ok(NewMachineWithCommand {
-        command: cmd,
+        command: cmd_attrs,
         machine: s.into(),
     })
 }
@@ -210,7 +205,7 @@ impl TryFrom<HistEventData> for SignalExternalMachineEvents {
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
                     "Signal external WF machine does not handle this event: {e}"
-                )))
+                )));
             }
         })
     }
@@ -224,11 +219,13 @@ impl WFMachinesAdapter for SignalExternalMachine {
     ) -> Result<Vec<MachineResponse>, WFMachinesError> {
         Ok(match my_command {
             SignalExternalCommand::Signaled => {
-                vec![ResolveSignalExternalWorkflow {
-                    seq: self.shared_state.seq,
-                    failure: None,
-                }
-                .into()]
+                vec![
+                    ResolveSignalExternalWorkflow {
+                        seq: self.shared_state.seq,
+                        failure: None,
+                    }
+                    .into(),
+                ]
             }
             SignalExternalCommand::Failed(f) => {
                 let reason = match f {
@@ -240,21 +237,23 @@ impl WFMachinesAdapter for SignalExternalMachine {
                         "The per-workflow signal limit was exceeded"
                     }
                 };
-                vec![ResolveSignalExternalWorkflow {
-                    seq: self.shared_state.seq,
-                    // TODO: Create new failure type upstream for this
-                    failure: Some(Failure {
-                        message: format!("Unable to signal external workflow because {reason}"),
-                        failure_info: Some(FailureInfo::ApplicationFailureInfo(
-                            ApplicationFailureInfo {
-                                r#type: f.to_string(),
-                                ..Default::default()
-                            },
-                        )),
-                        ..Default::default()
-                    }),
-                }
-                .into()]
+                vec![
+                    ResolveSignalExternalWorkflow {
+                        seq: self.shared_state.seq,
+                        // TODO: Create new failure type upstream for this
+                        failure: Some(Failure {
+                            message: format!("Unable to signal external workflow because {reason}"),
+                            failure_info: Some(FailureInfo::ApplicationFailureInfo(
+                                ApplicationFailureInfo {
+                                    r#type: f.to_string(),
+                                    ..Default::default()
+                                },
+                            )),
+                            ..Default::default()
+                        }),
+                    }
+                    .into(),
+                ]
             }
             SignalExternalCommand::Cancelled => {
                 panic!("Cancelled command not expected as part of non-cancel transition")
@@ -263,23 +262,25 @@ impl WFMachinesAdapter for SignalExternalMachine {
     }
 }
 
-impl Cancellable for SignalExternalMachine {
-    fn cancel(&mut self) -> Result<Vec<MachineResponse>, MachineError<Self::Error>> {
+impl SignalExternalMachine {
+    pub(super) fn cancel(&mut self) -> Result<Vec<MachineResponse>, MachineError<WFMachinesError>> {
         let res = OnEventWrapper::on_event_mut(self, SignalExternalMachineEvents::Cancel)?;
         let mut ret = vec![];
         match res.first() {
             Some(SignalExternalCommand::Cancelled) => {
-                ret = vec![ResolveSignalExternalWorkflow {
-                    seq: self.shared_state.seq,
-                    failure: Some(Failure {
-                        message: SIG_CANCEL_MSG.to_string(),
-                        failure_info: Some(FailureInfo::CanceledFailureInfo(CanceledFailureInfo {
-                            details: None,
-                        })),
-                        ..Default::default()
-                    }),
-                }
-                .into()];
+                ret = vec![
+                    ResolveSignalExternalWorkflow {
+                        seq: self.shared_state.seq,
+                        failure: Some(Failure {
+                            message: SIG_CANCEL_MSG.to_string(),
+                            failure_info: Some(FailureInfo::CanceledFailureInfo(
+                                CanceledFailureInfo { details: None },
+                            )),
+                            ..Default::default()
+                        }),
+                    }
+                    .into(),
+                ];
             }
             Some(_) => panic!("Signal external machine cancel produced unexpected result"),
             None => (),
@@ -287,7 +288,7 @@ impl Cancellable for SignalExternalMachine {
         Ok(ret)
     }
 
-    fn was_cancelled_before_sent_to_server(&self) -> bool {
+    pub(super) 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(_))
@@ -299,13 +300,14 @@ mod tests {
     use super::*;
     use crate::{
         replay::TestHistoryBuilder,
-        test_help::{build_fake_sdk, MockPollCfg},
+        test_help::{MockPollCfg, build_fake_sdk},
     };
     use std::mem::discriminant;
     use temporal_sdk::{CancellableFuture, SignalWorkflowOptions, WfContext, WorkflowResult};
     use temporal_sdk_core_protos::{
-        coresdk::workflow_activation::{workflow_activation_job, WorkflowActivationJob},
         DEFAULT_WORKFLOW_TYPE,
+        coresdk::workflow_activation::{WorkflowActivationJob, workflow_activation_job},
+        temporal::api::command::v1::Command,
     };
     use temporal_sdk_core_test_utils::interceptors::ActivationAssertionsInterceptor;
 

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

@@ -1,22 +1,22 @@
 #![allow(clippy::large_enum_variant)]
 
 use super::{
-    workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
-    OnEventWrapper, WFMachinesAdapter,
+    EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter,
+    workflow_machines::MachineResponse,
 };
-use crate::worker::workflow::{machines::HistEventData, WFMachinesError};
-use rustfsm::{fsm, MachineError, StateMachine, TransitionResult};
+use crate::worker::workflow::{WFMachinesError, machines::HistEventData};
+use rustfsm::{MachineError, StateMachine, TransitionResult, fsm};
 use std::convert::TryFrom;
 use temporal_sdk_core_protos::{
     coresdk::{
+        HistoryEventId,
         workflow_activation::FireTimer,
         workflow_commands::{CancelTimer, StartTimer},
-        HistoryEventId,
     },
     temporal::api::{
-        command::v1::Command,
+        command::v1::command,
         enums::v1::{CommandType, EventType},
-        history::v1::{history_event, TimerFiredEventAttributes},
+        history::v1::{TimerFiredEventAttributes, history_event},
     },
 };
 
@@ -49,7 +49,7 @@ fsm! {
 #[derive(Debug, derive_more::Display)]
 pub(super) enum TimerMachineCommand {
     Complete,
-    IssueCancelCmd(Command),
+    IssueCancelCmd(command::Attributes),
     // We don't issue activations for timer cancellations. Lang SDK is expected to cancel
     // it's own timers when user calls cancel, and they cannot be cancelled by any other
     // means.
@@ -72,15 +72,11 @@ pub(super) fn new_timer(attribs: StartTimer) -> NewMachineWithCommand {
 
 impl TimerMachine {
     /// Create a new timer and immediately schedule it
-    fn new_scheduled(attribs: StartTimer) -> (Self, Command) {
+    fn new_scheduled(attribs: StartTimer) -> (Self, command::Attributes) {
         let mut s = Self::new(attribs);
         OnEventWrapper::on_event_mut(&mut s, TimerMachineEvents::Schedule)
             .expect("Scheduling timers doesn't fail");
-        let cmd = Command {
-            command_type: CommandType::StartTimer as i32,
-            attributes: Some(s.shared_state().attrs.into()),
-            user_metadata: Default::default(),
-        };
+        let cmd = s.shared_state().attrs.into();
         (s, cmd)
     }
 
@@ -93,6 +89,22 @@ impl TimerMachine {
             },
         )
     }
+
+    pub(super) fn cancel(&mut self) -> Result<Vec<MachineResponse>, MachineError<WFMachinesError>> {
+        Ok(
+            match OnEventWrapper::on_event_mut(self, TimerMachineEvents::Cancel)?.pop() {
+                Some(TimerMachineCommand::IssueCancelCmd(cmd)) => {
+                    vec![MachineResponse::IssueNewCommand(cmd.into())]
+                }
+                None => vec![],
+                x => panic!("Invalid cancel event response {x:?}"),
+            },
+        )
+    }
+
+    pub(super) fn was_cancelled_before_sent_to_server(&self) -> bool {
+        self.shared_state().cancelled_before_sent
+    }
 }
 
 impl TryFrom<HistEventData> for TimerMachineEvents {
@@ -117,7 +129,7 @@ impl TryFrom<HistEventData> for TimerMachineEvents {
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
                     "Timer machine does not handle this event: {e}"
-                )))
+                )));
             }
         })
     }
@@ -208,13 +220,10 @@ impl StartCommandRecorded {
         self,
         dat: &mut SharedState,
     ) -> TimerMachineTransition<CancelTimerCommandCreated> {
-        let cmd = Command {
-            command_type: CommandType::CancelTimer as i32,
-            attributes: Some(CancelTimer { seq: dat.attrs.seq }.into()),
-            user_metadata: Default::default(),
-        };
         TransitionResult::ok(
-            vec![TimerMachineCommand::IssueCancelCmd(cmd)],
+            vec![TimerMachineCommand::IssueCancelCmd(
+                CancelTimer { seq: dat.attrs.seq }.into(),
+            )],
             CancelTimerCommandCreated::default(),
         )
     }
@@ -228,45 +237,31 @@ impl WFMachinesAdapter for TimerMachine {
     ) -> Result<Vec<MachineResponse>, WFMachinesError> {
         Ok(match my_command {
             // Fire the completion
-            TimerMachineCommand::Complete => vec![FireTimer {
-                seq: self.shared_state.attrs.seq,
+            TimerMachineCommand::Complete => vec![
+                FireTimer {
+                    seq: self.shared_state.attrs.seq,
+                }
+                .into(),
+            ],
+            TimerMachineCommand::IssueCancelCmd(c) => {
+                vec![MachineResponse::IssueNewCommand(c.into())]
             }
-            .into()],
-            TimerMachineCommand::IssueCancelCmd(c) => vec![MachineResponse::IssueNewCommand(c)],
         })
     }
 }
 
-impl Cancellable for TimerMachine {
-    fn cancel(&mut self) -> Result<Vec<MachineResponse>, MachineError<Self::Error>> {
-        Ok(
-            match OnEventWrapper::on_event_mut(self, TimerMachineEvents::Cancel)?.pop() {
-                Some(TimerMachineCommand::IssueCancelCmd(cmd)) => {
-                    vec![MachineResponse::IssueNewCommand(cmd)]
-                }
-                None => vec![],
-                x => panic!("Invalid cancel event response {x:?}"),
-            },
-        )
-    }
-
-    fn was_cancelled_before_sent_to_server(&self) -> bool {
-        self.shared_state().cancelled_before_sent
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::*;
     use crate::{
         replay::TestHistoryBuilder,
-        test_help::{build_fake_sdk, canned_histories, MockPollCfg},
+        test_help::{MockPollCfg, build_fake_sdk, canned_histories},
     };
     use std::{mem::discriminant, time::Duration};
     use temporal_sdk::{CancellableFuture, WfContext, WorkflowResult};
     use temporal_sdk_core_protos::{
-        temporal::api::{enums::v1::WorkflowTaskFailedCause, failure::v1::Failure},
         DEFAULT_WORKFLOW_TYPE,
+        temporal::api::{enums::v1::WorkflowTaskFailedCause, failure::v1::Failure},
     };
 
     async fn happy_timer(ctx: WfContext) -> WorkflowResult<()> {

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

@@ -3,13 +3,13 @@
 //! in stable Rust. Don't do the things in here. They're bad. This is test only code, and should
 //! never ever be removed from behind `#[cfg(test)]` compilation.
 
-use dashmap::{mapref::entry::Entry, DashMap, DashSet};
+use dashmap::{DashMap, DashSet, mapref::entry::Entry};
 use std::sync::LazyLock;
 use std::{
     path::PathBuf,
     sync::{
-        mpsc::{sync_channel, SyncSender},
         Mutex,
+        mpsc::{SyncSender, sync_channel},
     },
     thread::JoinHandle,
     time::Duration,

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

@@ -1,25 +1,25 @@
-use super::{workflow_machines::MachineResponse, EventInfo, WFMachinesAdapter, WFMachinesError};
+use super::{EventInfo, WFMachinesAdapter, WFMachinesError, workflow_machines::MachineResponse};
 use crate::{
     protosext::protocol_messages::UpdateRequest,
-    worker::workflow::machines::{Cancellable, HistEventData, NewMachineWithResponse},
+    worker::workflow::machines::{HistEventData, NewMachineWithResponse},
 };
 use itertools::Itertools;
 use prost::EncodeError;
-use rustfsm::{fsm, MachineError, StateMachine, TransitionResult};
+use rustfsm::{MachineError, StateMachine, TransitionResult, fsm};
 use std::convert::TryFrom;
 use temporal_sdk_core_protos::{
     coresdk::{
         workflow_activation::DoUpdate,
-        workflow_commands::{update_response, UpdateResponse},
+        workflow_commands::{UpdateResponse, update_response},
     },
     temporal::api::{
-        command::v1::{command, ProtocolMessageCommandAttributes},
+        command::v1::{ProtocolMessageCommandAttributes, command},
         common::v1::Payload,
         enums::v1::{CommandType, EventType},
         failure::v1::Failure,
         protocol::v1::Message as ProtocolMessage,
         update,
-        update::v1::{outcome, Acceptance, Outcome, Rejection, Response},
+        update::v1::{Acceptance, Outcome, Rejection, Response, outcome},
     },
     utilities::pack_any,
 };
@@ -122,7 +122,7 @@ impl UpdateMachine {
                 return Err(WFMachinesError::Fatal(format!(
                     "Update response for update {} had an empty result, this is a lang layer bug.",
                     &self.shared_state.meta.update_id
-                )))
+                )));
             }
             Some(update_response::Response::Accepted(_)) => {
                 self.on_event(UpdateMachineEvents::Accept)
@@ -223,7 +223,7 @@ impl TryFrom<HistEventData> for UpdateMachineEvents {
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
                     "Update machine does not handle this event: {e}"
-                )))
+                )));
             }
         })
     }
@@ -407,5 +407,3 @@ impl From<CompletedImmediatelyAcceptCreated> for CompletedImmediatelyCompleteCre
         CompletedImmediatelyCompleteCreated {}
     }
 }
-
-impl Cancellable for UpdateMachine {}

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

@@ -1,19 +1,19 @@
-use super::{workflow_machines::MachineResponse, NewMachineWithCommand};
+use super::{NewMachineWithCommand, workflow_machines::MachineResponse};
 use crate::{
     internal_flags::CoreInternalFlags,
     worker::workflow::{
+        InternalFlagsRef, WFMachinesError,
         machines::{
-            patch_state_machine::VERSION_SEARCH_ATTR_KEY, Cancellable, EventInfo, HistEventData,
-            WFMachinesAdapter,
+            EventInfo, HistEventData, WFMachinesAdapter,
+            patch_state_machine::VERSION_SEARCH_ATTR_KEY,
         },
-        InternalFlagsRef, WFMachinesError,
     },
 };
-use rustfsm::{fsm, StateMachine, TransitionResult};
+use rustfsm::{StateMachine, TransitionResult, fsm};
 use temporal_sdk_core_protos::{
     coresdk::workflow_commands::UpsertWorkflowSearchAttributes,
     temporal::api::{
-        command::v1::{command, Command, UpsertWorkflowSearchAttributesCommandAttributes},
+        command::v1::{UpsertWorkflowSearchAttributesCommandAttributes, command},
         common::v1::SearchAttributes,
         enums::v1::CommandType,
         history::v1::history_event,
@@ -77,19 +77,13 @@ pub(super) fn upsert_search_attrs_internal(
 
 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(
-            command::Attributes::UpsertWorkflowSearchAttributesCommandAttributes(
-                UpsertWorkflowSearchAttributesCommandAttributes {
-                    search_attributes: Some(sa_map),
-                },
-            ),
-        ),
-        user_metadata: Default::default(),
-    };
     NewMachineWithCommand {
-        command: cmd,
+        command: command::Attributes::UpsertWorkflowSearchAttributesCommandAttributes(
+            UpsertWorkflowSearchAttributesCommandAttributes {
+                search_attributes: Some(sa_map),
+            },
+        ),
+
         machine: sm.into(),
     }
 }
@@ -140,8 +134,6 @@ impl WFMachinesAdapter for UpsertSearchAttributesMachine {
     }
 }
 
-impl Cancellable for UpsertSearchAttributesMachine {}
-
 // Converts the generic history event with type EventType::UpsertWorkflowSearchAttributes into the
 // UpsertSearchAttributesMachine-specific event type
 // UpsertSearchAttributesMachineEvents::CommandRecorded.
@@ -189,7 +181,7 @@ mod tests {
     use super::{super::OnEventWrapper, *};
     use crate::{
         replay::TestHistoryBuilder,
-        test_help::{build_fake_sdk, build_mock_pollers, mock_worker, MockPollCfg, ResponseType},
+        test_help::{MockPollCfg, ResponseType, build_fake_sdk, build_mock_pollers, mock_worker},
         worker::{
             client::mocks::mock_workflow_client,
             workflow::machines::patch_state_machine::VERSION_SEARCH_ATTR_KEY,
@@ -200,19 +192,19 @@ mod tests {
     use temporal_sdk::WfContext;
     use temporal_sdk_core_api::Worker;
     use temporal_sdk_core_protos::{
+        DEFAULT_WORKFLOW_TYPE,
         coresdk::{
-            workflow_activation::{workflow_activation_job, WorkflowActivationJob},
+            AsJsonPayloadExt,
+            workflow_activation::{WorkflowActivationJob, workflow_activation_job},
             workflow_commands::SetPatchMarker,
             workflow_completion::WorkflowActivationCompletion,
-            AsJsonPayloadExt,
         },
         temporal::api::{
-            command::v1::command::Attributes,
+            command::v1::{Command, command::Attributes},
             common::v1::Payload,
             enums::v1::EventType,
             history::v1::{HistoryEvent, UpsertWorkflowSearchAttributesEventAttributes},
         },
-        DEFAULT_WORKFLOW_TYPE,
     };
     use temporal_sdk_core_test_utils::WorkerTestHelpers;
 
@@ -369,11 +361,13 @@ mod tests {
         );
         let act = core.poll_workflow_activation().await.unwrap();
         let mut cmds = if with_patched_cmd {
-            vec![SetPatchMarker {
-                patch_id,
-                deprecated: false,
-            }
-            .into()]
+            vec![
+                SetPatchMarker {
+                    patch_id,
+                    deprecated: false,
+                }
+                .into(),
+            ]
         } else {
             vec![]
         };