@temporalio/core-bridge 1.11.7 → 1.11.8

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

@@ -1,34 +1,33 @@
 #![allow(clippy::large_enum_variant)]
 
 use super::{
-    workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
-    OnEventWrapper, WFMachinesAdapter, WFMachinesError,
+    EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError,
+    workflow_machines::MachineResponse,
 };
 use crate::{
     abstractions::dbg_panic,
     internal_flags::CoreInternalFlags,
-    worker::workflow::{machines::HistEventData, InternalFlagsRef},
+    worker::workflow::{InternalFlagsRef, machines::HistEventData},
 };
-use rustfsm::{fsm, MachineError, StateMachine, TransitionResult};
+use rustfsm::{MachineError, StateMachine, TransitionResult, fsm};
 use std::convert::{TryFrom, TryInto};
 use temporal_sdk_core_protos::{
     coresdk::{
-        activity_result::{self as ar, activity_resolution, ActivityResolution, Cancellation},
+        activity_result::{self as ar, ActivityResolution, Cancellation, activity_resolution},
         workflow_activation::ResolveActivity,
         workflow_commands::{ActivityCancellationType, ScheduleActivity},
     },
     temporal::api::{
         command::v1::{
-            command, schedule_activity_cmd_to_api, Command,
-            RequestCancelActivityTaskCommandAttributes,
+            Command, RequestCancelActivityTaskCommandAttributes, command,
+            schedule_activity_cmd_to_api,
         },
         common::v1::{ActivityType, Payload, Payloads},
         enums::v1::{CommandType, EventType, RetryState},
-        failure::v1::{failure::FailureInfo, ActivityFailureInfo, CanceledFailureInfo, Failure},
+        failure::v1::{ActivityFailureInfo, CanceledFailureInfo, Failure, failure::FailureInfo},
         history::v1::{
-            history_event, ActivityTaskCanceledEventAttributes,
-            ActivityTaskCompletedEventAttributes, ActivityTaskFailedEventAttributes,
-            ActivityTaskTimedOutEventAttributes,
+            ActivityTaskCanceledEventAttributes, ActivityTaskCompletedEventAttributes,
+            ActivityTaskFailedEventAttributes, ActivityTaskTimedOutEventAttributes, history_event,
         },
     },
 };
@@ -128,16 +127,11 @@ impl ActivityMachine {
         );
         OnEventWrapper::on_event_mut(&mut s, ActivityMachineEvents::Schedule)
             .expect("Scheduling activities doesn't fail");
-        let command = Command {
-            command_type: CommandType::ScheduleActivityTask as i32,
-            attributes: Some(schedule_activity_cmd_to_api(
+        NewMachineWithCommand {
+            command: schedule_activity_cmd_to_api(
                 s.shared_state().attrs.clone(),
                 use_compatible_version,
-            )),
-            user_metadata: Default::default(),
-        };
-        NewMachineWithCommand {
-            command,
+            ),
             machine: s.into(),
         }
     }
@@ -169,6 +163,45 @@ impl ActivityMachine {
             is_local: false,
         }
     }
+
+    pub(super) fn cancel(&mut self) -> Result<Vec<MachineResponse>, MachineError<WFMachinesError>> {
+        if matches!(
+            self.state(),
+            ActivityMachineState::Completed(_)
+                | ActivityMachineState::Canceled(_)
+                | ActivityMachineState::Failed(_)
+                | ActivityMachineState::TimedOut(_)
+        ) {
+            // Ignore attempted cancels in terminal states
+            debug!(
+                "Attempted to cancel already resolved activity (seq {})",
+                self.shared_state.attrs.seq
+            );
+            return Ok(vec![]);
+        }
+        let event = match self.shared_state.cancellation_type {
+            ActivityCancellationType::Abandon => ActivityMachineEvents::Abandon,
+            _ => ActivityMachineEvents::Cancel,
+        };
+        let vec = OnEventWrapper::on_event_mut(self, event)?;
+        let res = vec
+            .into_iter()
+            .flat_map(|amc| match amc {
+                ActivityMachineCommand::RequestCancellation(cmd) => {
+                    self.machine_responses_from_cancel_request(cmd)
+                }
+                ActivityMachineCommand::Cancel(details) => {
+                    vec![self.create_cancelation_resolve(details).into()]
+                }
+                x => panic!("Invalid cancel event response {x:?}"),
+            })
+            .collect();
+        Ok(res)
+    }
+
+    pub(super) fn was_cancelled_before_sent_to_server(&self) -> bool {
+        self.shared_state().cancelled_before_sent
+    }
 }
 
 impl TryFrom<HistEventData> for ActivityMachineEvents {
@@ -245,7 +278,7 @@ impl TryFrom<HistEventData> for ActivityMachineEvents {
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
                     "Activity machine does not handle this event: {e}"
-                )))
+                )));
             }
         })
     }
@@ -259,28 +292,32 @@ impl WFMachinesAdapter for ActivityMachine {
     ) -> Result<Vec<MachineResponse>, WFMachinesError> {
         Ok(match my_command {
             ActivityMachineCommand::Complete(result) => {
-                vec![ResolveActivity {
-                    seq: self.shared_state.attrs.seq,
-                    result: Some(ActivityResolution {
-                        status: Some(activity_resolution::Status::Completed(ar::Success {
-                            result: convert_payloads(event_info, result)?,
-                        })),
-                    }),
-                    is_local: false,
-                }
-                .into()]
+                vec![
+                    ResolveActivity {
+                        seq: self.shared_state.attrs.seq,
+                        result: Some(ActivityResolution {
+                            status: Some(activity_resolution::Status::Completed(ar::Success {
+                                result: convert_payloads(event_info, result)?,
+                            })),
+                        }),
+                        is_local: false,
+                    }
+                    .into(),
+                ]
             }
             ActivityMachineCommand::Fail(failure) => {
-                vec![ResolveActivity {
-                    seq: self.shared_state.attrs.seq,
-                    result: Some(ActivityResolution {
-                        status: Some(activity_resolution::Status::Failed(ar::Failure {
-                            failure: Some(failure),
-                        })),
-                    }),
-                    is_local: false,
-                }
-                .into()]
+                vec![
+                    ResolveActivity {
+                        seq: self.shared_state.attrs.seq,
+                        result: Some(ActivityResolution {
+                            status: Some(activity_resolution::Status::Failed(ar::Failure {
+                                failure: Some(failure),
+                            })),
+                        }),
+                        is_local: false,
+                    }
+                    .into(),
+                ]
             }
             ActivityMachineCommand::RequestCancellation(c) => {
                 self.machine_responses_from_cancel_request(c)
@@ -304,47 +341,6 @@ impl TryFrom<CommandType> for ActivityMachineEvents {
     }
 }
 
-impl Cancellable for ActivityMachine {
-    fn cancel(&mut self) -> Result<Vec<MachineResponse>, MachineError<Self::Error>> {
-        if matches!(
-            self.state(),
-            ActivityMachineState::Completed(_)
-                | ActivityMachineState::Canceled(_)
-                | ActivityMachineState::Failed(_)
-                | ActivityMachineState::TimedOut(_)
-        ) {
-            // Ignore attempted cancels in terminal states
-            debug!(
-                "Attempted to cancel already resolved activity (seq {})",
-                self.shared_state.attrs.seq
-            );
-            return Ok(vec![]);
-        }
-        let event = match self.shared_state.cancellation_type {
-            ActivityCancellationType::Abandon => ActivityMachineEvents::Abandon,
-            _ => ActivityMachineEvents::Cancel,
-        };
-        let vec = OnEventWrapper::on_event_mut(self, event)?;
-        let res = vec
-            .into_iter()
-            .flat_map(|amc| match amc {
-                ActivityMachineCommand::RequestCancellation(cmd) => {
-                    self.machine_responses_from_cancel_request(cmd)
-                }
-                ActivityMachineCommand::Cancel(details) => {
-                    vec![self.create_cancelation_resolve(details).into()]
-                }
-                x => panic!("Invalid cancel event response {x:?}"),
-            })
-            .collect();
-        Ok(res)
-    }
-
-    fn was_cancelled_before_sent_to_server(&self) -> bool {
-        self.shared_state().cancelled_before_sent
-    }
-}
-
 #[derive(Clone)]
 pub(super) struct SharedState {
     scheduled_event_id: i64,
@@ -757,7 +753,7 @@ fn new_cancel_failure(dat: &SharedState, attrs: ActivityTaskCanceledEventAttribu
         message: "Activity cancelled".to_string(),
         cause: Some(Box::from(Failure {
             failure_info: Some(FailureInfo::CanceledFailureInfo(CanceledFailureInfo {
-                details: attrs.details.map(Into::into),
+                details: attrs.details,
             })),
             ..Default::default()
         })),
@@ -808,14 +804,14 @@ mod test {
     use crate::{
         internal_flags::InternalFlags,
         replay::TestHistoryBuilder,
-        test_help::{build_fake_sdk, MockPollCfg, ResponseType},
-        worker::workflow::{machines::Machines, OutgoingJob},
+        test_help::{MockPollCfg, ResponseType, build_fake_sdk},
+        worker::workflow::{OutgoingJob, machines::Machines},
     };
     use std::{cell::RefCell, mem::discriminant, rc::Rc};
     use temporal_sdk::{ActivityOptions, CancellableFuture, WfContext, WorkflowFunction};
     use temporal_sdk_core_protos::{
-        coresdk::workflow_activation::{workflow_activation_job, WorkflowActivationJob},
         DEFAULT_WORKFLOW_TYPE,
+        coresdk::workflow_activation::{WorkflowActivationJob, workflow_activation_job},
     };
     use temporal_sdk_core_test_utils::interceptors::ActivationAssertionsInterceptor;
 
@@ -881,7 +877,7 @@ mod test {
                     attrs: Default::default(),
                     cancellation_type: Default::default(),
                     cancelled_before_sent: false,
-                    internal_flags: Rc::new(RefCell::new(InternalFlags::new(&Default::default()))),
+                    internal_flags: Rc::new(RefCell::new(InternalFlags::default())),
                 },
             );
             let cmds = s.cancel().unwrap();
@@ -899,7 +895,7 @@ mod test {
                 cancellation_type: ActivityCancellationType::Abandon.into(),
                 ..Default::default()
             },
-            Rc::new(RefCell::new(InternalFlags::new(&Default::default()))),
+            Rc::new(RefCell::new(InternalFlags::default())),
             true,
         );
         let mut s = if let Machines::ActivityMachine(am) = s.machine {

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

@@ -1,9 +1,9 @@
 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, StateMachine, TransitionResult};
+use rustfsm::{StateMachine, TransitionResult, fsm};
 use std::convert::TryFrom;
 use temporal_sdk_core_protos::{
     coresdk::{
@@ -11,9 +11,9 @@ use temporal_sdk_core_protos::{
         workflow_activation::ResolveRequestCancelExternalWorkflow,
     },
     temporal::api::{
-        command::v1::{command, Command, RequestCancelExternalWorkflowExecutionCommandAttributes},
+        command::v1::{RequestCancelExternalWorkflowExecutionCommandAttributes, command},
         enums::v1::{CancelExternalWorkflowExecutionFailedCause, CommandType, EventType},
-        failure::v1::{failure::FailureInfo, ApplicationFailureInfo, Failure},
+        failure::v1::{ApplicationFailureInfo, Failure, failure::FailureInfo},
         history::v1::history_event,
     },
 };
@@ -75,13 +75,8 @@ pub(super) fn new_external_cancel(
             reason,
         },
     );
-    let cmd = Command {
-        command_type: CommandType::RequestCancelExternalWorkflowExecution as i32,
-        attributes: Some(cmd_attrs),
-        user_metadata: Default::default(),
-    };
     NewMachineWithCommand {
-        command: cmd,
+        command: cmd_attrs,
         machine: s.into(),
     }
 }
@@ -182,11 +177,13 @@ impl WFMachinesAdapter for CancelExternalMachine {
     ) -> Result<Vec<MachineResponse>, WFMachinesError> {
         Ok(match my_command {
             CancelExternalCommand::Requested => {
-                vec![ResolveRequestCancelExternalWorkflow {
-                    seq: self.shared_state.seq,
-                    failure: None,
-                }
-                .into()]
+                vec![
+                    ResolveRequestCancelExternalWorkflow {
+                        seq: self.shared_state.seq,
+                        failure: None,
+                    }
+                    .into(),
+                ]
             }
             CancelExternalCommand::Failed(f) => {
                 let reason = match f {
@@ -194,44 +191,47 @@ impl WFMachinesAdapter for CancelExternalMachine {
                     CancelExternalWorkflowExecutionFailedCause::ExternalWorkflowExecutionNotFound
                     | CancelExternalWorkflowExecutionFailedCause::NamespaceNotFound  => "not found"
                 };
-                vec![ResolveRequestCancelExternalWorkflow {
-                    seq: self.shared_state.seq,
-                    failure: Some(Failure {
-                        message: format!("Unable to cancel external workflow because {reason}"),
-                        failure_info: Some(FailureInfo::ApplicationFailureInfo(
-                            ApplicationFailureInfo {
-                                r#type: f.to_string(),
-                                ..Default::default()
-                            },
-                        )),
-                        ..Default::default()
-                    }),
-                }
-                .into()]
+                vec![
+                    ResolveRequestCancelExternalWorkflow {
+                        seq: self.shared_state.seq,
+                        failure: Some(Failure {
+                            message: format!("Unable to cancel external workflow because {reason}"),
+                            failure_info: Some(FailureInfo::ApplicationFailureInfo(
+                                ApplicationFailureInfo {
+                                    r#type: f.to_string(),
+                                    ..Default::default()
+                                },
+                            )),
+                            ..Default::default()
+                        }),
+                    }
+                    .into(),
+                ]
             }
         })
     }
 }
 
-impl Cancellable for CancelExternalMachine {}
-
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::{
         replay::TestHistoryBuilder,
-        test_help::{build_fake_sdk, MockPollCfg},
+        test_help::{MockPollCfg, build_fake_sdk},
     };
     use temporal_sdk::{WfContext, WorkflowResult};
     use temporal_sdk_core_protos::DEFAULT_WORKFLOW_TYPE;
 
     async fn cancel_sender(ctx: WfContext) -> WorkflowResult<()> {
         let res = ctx
-            .cancel_external(NamespacedWorkflowExecution {
-                namespace: "some_namespace".to_string(),
-                workflow_id: "fake_wid".to_string(),
-                run_id: "fake_rid".to_string(),
-            })
+            .cancel_external(
+                NamespacedWorkflowExecution {
+                    namespace: "some_namespace".to_string(),
+                    workflow_id: "fake_wid".to_string(),
+                    run_id: "fake_rid".to_string(),
+                },
+                "cancel reason".to_string(),
+            )
             .await;
         if res.is_err() {
             Err(anyhow::anyhow!("Cancel fail!"))

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

@@ -0,0 +1,117 @@
+use super::{
+    workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
+    WFMachinesAdapter, WFMachinesError,
+};
+use crate::worker::workflow::machines::HistEventData;
+use rustfsm::{fsm, StateMachine, TransitionResult};
+use std::convert::TryFrom;
+use temporal_sdk_core_protos::{
+    coresdk::workflow_activation::ResolveCancelNexusOperation,
+    temporal::api::{
+        command::v1::{command, RequestCancelNexusOperationCommandAttributes},
+        enums::v1::{CommandType, EventType},
+    },
+};
+
+fsm! {
+    pub(super)
+    name CancelNexusOpMachine;
+    command CancelNexusOpCommand;
+    error WFMachinesError;
+    shared_state SharedState;
+
+    RequestCancelNexusOpCommandCreated --(CommandRequestCancelNexusOpWorkflowExecution)
+      --> RequestCancelNexusOpCommandCreated;
+
+    RequestCancelNexusOpCommandCreated --(NexusOpCancelRequested, on_cancel_requested)
+      --> CancelRequested;
+}
+
+#[derive(Default, Clone)]
+pub(super) struct SharedState {
+    seq: u32,
+}
+
+#[derive(Debug, derive_more::Display)]
+pub(super) enum CancelNexusOpCommand {
+    Requested,
+}
+
+pub(super) fn new_nexus_op_cancel(
+    seq: u32,
+    nexus_op_scheduled_event_id: i64,
+) -> NewMachineWithCommand {
+    let s = CancelNexusOpMachine::from_parts(
+        RequestCancelNexusOpCommandCreated {}.into(),
+        SharedState { seq },
+    );
+    let cmd_attrs = command::Attributes::RequestCancelNexusOperationCommandAttributes(
+        RequestCancelNexusOperationCommandAttributes {
+            scheduled_event_id: nexus_op_scheduled_event_id,
+        },
+    );
+    NewMachineWithCommand {
+        command: cmd_attrs,
+        machine: s.into(),
+    }
+}
+
+#[derive(Default, Clone)]
+pub(super) struct CancelRequested {}
+
+#[derive(Default, Clone)]
+pub(super) struct RequestCancelNexusOpCommandCreated {}
+
+impl RequestCancelNexusOpCommandCreated {
+    pub(super) fn on_cancel_requested(self) -> CancelNexusOpMachineTransition<CancelRequested> {
+        TransitionResult::commands(vec![CancelNexusOpCommand::Requested])
+    }
+}
+
+impl TryFrom<HistEventData> for CancelNexusOpMachineEvents {
+    type Error = WFMachinesError;
+
+    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
+        let e = e.event;
+        Ok(match e.event_type() {
+            EventType::NexusOperationCancelRequested => Self::NexusOpCancelRequested,
+            _ => {
+                return Err(WFMachinesError::Nondeterminism(format!(
+                    "Cancel external WF machine does not handle this event: {e}"
+                )))
+            }
+        })
+    }
+}
+
+impl TryFrom<CommandType> for CancelNexusOpMachineEvents {
+    type Error = ();
+
+    fn try_from(c: CommandType) -> Result<Self, Self::Error> {
+        Ok(match c {
+            CommandType::RequestCancelNexusOperation => {
+                Self::CommandRequestCancelNexusOpWorkflowExecution
+            }
+            _ => return Err(()),
+        })
+    }
+}
+
+impl WFMachinesAdapter for CancelNexusOpMachine {
+    fn adapt_response(
+        &self,
+        my_command: Self::Command,
+        _event_info: Option<EventInfo>,
+    ) -> Result<Vec<MachineResponse>, WFMachinesError> {
+        Ok(match my_command {
+            CancelNexusOpCommand::Requested => {
+                vec![ResolveCancelNexusOperation {
+                    seq: self.shared_state.seq,
+                }
+                .into()]
+            }
+        })
+    }
+}
+
+impl Cancellable for CancelNexusOpMachine {}

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

@@ -1,16 +1,13 @@
 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, StateMachine, TransitionResult};
+use rustfsm::{StateMachine, TransitionResult, fsm};
 use std::convert::TryFrom;
 use temporal_sdk_core_protos::{
     coresdk::workflow_commands::CancelWorkflowExecution,
-    temporal::api::{
-        command::v1::Command,
-        enums::v1::{CommandType, EventType},
-    },
+    temporal::api::enums::v1::{CommandType, EventType},
 };
 
 fsm! {
@@ -34,13 +31,8 @@ pub(super) fn cancel_workflow(attribs: CancelWorkflowExecution) -> NewMachineWit
     let mut machine = CancelWorkflowMachine::from_parts(Created {}.into(), ());
     OnEventWrapper::on_event_mut(&mut machine, CancelWorkflowMachineEvents::Schedule)
         .expect("Scheduling continue as new machine doesn't fail");
-    let command = Command {
-        command_type: CommandType::CancelWorkflowExecution as i32,
-        attributes: Some(attribs.into()),
-        user_metadata: Default::default(),
-    };
     NewMachineWithCommand {
-        command,
+        command: attribs.into(),
         machine: machine.into(),
     }
 }
@@ -78,7 +70,7 @@ impl TryFrom<HistEventData> for CancelWorkflowMachineEvents {
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
                     "Cancel workflow machine does not handle this event: {e}"
-                )))
+                )));
             }
         })
     }
@@ -105,17 +97,15 @@ impl WFMachinesAdapter for CancelWorkflowMachine {
     }
 }
 
-impl Cancellable for CancelWorkflowMachine {}
-
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_help::{build_fake_sdk, canned_histories, MockPollCfg};
+    use crate::test_help::{MockPollCfg, build_fake_sdk, canned_histories};
     use std::time::Duration;
     use temporal_sdk::{WfContext, WfExitValue, WorkflowResult};
     use temporal_sdk_core_protos::{
-        coresdk::workflow_activation::{workflow_activation_job, WorkflowActivationJob},
         DEFAULT_WORKFLOW_TYPE,
+        coresdk::workflow_activation::{WorkflowActivationJob, workflow_activation_job},
     };
     use temporal_sdk_core_test_utils::interceptors::ActivationAssertionsInterceptor;