@temporalio/core-bridge 1.13.2 → 1.14.0

package/sdk-core/{core → crates/sdk-core}/src/worker/tuner.rs

@@ -3,12 +3,14 @@ mod resource_based;
 
 pub use fixed_size::FixedSizeSlotSupplier;
 pub use resource_based::{
-    RealSysInfo, ResourceBasedSlotsOptions, ResourceBasedSlotsOptionsBuilder, ResourceBasedTuner,
+    ResourceBasedSlotsOptions, ResourceBasedSlotsOptionsBuilder, ResourceBasedTuner,
     ResourceSlotOptions,
 };
 
+pub(crate) use resource_based::{RealSysInfo, SystemResourceInfo};
+
 use std::sync::Arc;
-use temporal_sdk_core_api::worker::{
+use temporalio_common::worker::{
     ActivitySlotKind, LocalActivitySlotKind, NexusSlotKind, SlotKind, SlotSupplier, WorkerConfig,
     WorkerTuner, WorkflowSlotKind,
 };
@@ -126,6 +128,9 @@ impl TunerHolderOptions {
             }
             None => {}
         }
+        if let Some(tuner) = rb_tuner {
+            builder.sys_info(tuner.sys_info());
+        }
         Ok(builder.build())
     }
 }
@@ -138,7 +143,7 @@ pub enum SlotSupplierOptions<SK: SlotKind> {
         /// The number of slots the fixed supplier will have
         slots: usize,
     },
-    /// Options for a [ResourceBasedSlots]
+    /// Options for resource-based slot suppliers
     ResourceBased(ResourceSlotOptions),
     /// A user-implemented slot supplier
     #[debug("Custom")]
@@ -187,6 +192,7 @@ pub struct TunerBuilder {
     local_activity_slot_supplier:
         Option<Arc<dyn SlotSupplier<SlotKind = LocalActivitySlotKind> + Send + Sync>>,
     nexus_slot_supplier: Option<Arc<dyn SlotSupplier<SlotKind = NexusSlotKind> + Send + Sync>>,
+    sys_info: Option<Arc<dyn SystemResourceInfo + Send + Sync>>,
 }
 
 impl TunerBuilder {
@@ -243,6 +249,17 @@ impl TunerBuilder {
         self
     }
 
+    /// Sets a field that implements [SystemResourceInfo]
+    fn sys_info(&mut self, sys_info: Arc<dyn SystemResourceInfo + Send + Sync>) -> &mut Self {
+        self.sys_info = Some(sys_info);
+        self
+    }
+
+    /// Gets the field that implements [SystemResourceInfo]
+    pub(crate) fn get_sys_info(&self) -> Option<Arc<dyn SystemResourceInfo + Send + Sync>> {
+        self.sys_info.clone()
+    }
+
     /// Build a [WorkerTuner] from the configured slot suppliers
     pub fn build(&mut self) -> TunerHolder {
         TunerHolder {
@@ -296,7 +313,7 @@ impl WorkerTuner for TunerHolder {
 mod tests {
     use super::*;
     use std::time::Duration;
-    use temporal_sdk_core_api::worker::{
+    use temporalio_common::worker::{
         SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext, SlotSupplierPermit,
     };
 

package/sdk-core/{core → crates/sdk-core}/src/worker/workflow/driven_workflow.rs

@@ -7,7 +7,7 @@ use std::{
     collections::HashMap,
     sync::mpsc::{self, Receiver, Sender},
 };
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     coresdk::workflow_activation::{WorkflowActivationJob, start_workflow_from_attribs},
     temporal::api::{common::v1::Payload, history::v1::WorkflowExecutionStartedEventAttributes},
     utilities::TryIntoOrNone,

package/sdk-core/{core → crates/sdk-core}/src/worker/workflow/history_update.rs

@@ -17,7 +17,7 @@ use std::{
     sync::{Arc, LazyLock},
     task::{Context, Poll},
 };
-use temporal_sdk_core_protos::temporal::api::{
+use temporalio_common::protos::temporal::api::{
     enums::v1::EventType,
     history::v1::{
         History, HistoryEvent, WorkflowTaskCompletedEventAttributes, history_event::Attributes,
@@ -810,7 +810,7 @@ mod tests {
         worker::client::mocks::mock_worker_client,
     };
     use futures_util::TryStreamExt;
-    use temporal_sdk_core_protos::{
+    use temporalio_common::protos::{
         canned_histories,
         temporal::api::{
             common::v1::WorkflowExecution, enums::v1::WorkflowTaskFailedCause,

package/sdk-core/{core → crates/sdk-core}/src/worker/workflow/machines/activity_state_machine.rs

@@ -1,17 +1,16 @@
 #![allow(clippy::large_enum_variant)]
 
 use super::{
-    EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError,
-    workflow_machines::MachineResponse,
+    EventInfo, MachineError, NewMachineWithCommand, OnEventWrapper, StateMachine, TransitionResult,
+    WFMachinesAdapter, WFMachinesError, workflow_machines::MachineResponse,
 };
 use crate::{
     abstractions::dbg_panic,
     internal_flags::CoreInternalFlags,
-    worker::workflow::{InternalFlagsRef, machines::HistEventData},
+    worker::workflow::{InternalFlagsRef, fatal, machines::HistEventData, nondeterminism},
 };
-use rustfsm::{MachineError, StateMachine, TransitionResult, fsm};
 use std::convert::{TryFrom, TryInto};
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     coresdk::{
         activity_result::{self as ar, ActivityResolution, Cancellation, activity_resolution},
         workflow_activation::ResolveActivity,
@@ -31,6 +30,7 @@ use temporal_sdk_core_protos::{
         },
     },
 };
+use temporalio_macros::fsm;
 
 fsm! {
     pub(super) name ActivityMachine;
@@ -173,6 +173,16 @@ impl ActivityMachine {
                 | ActivityMachineState::TimedOut(_)
         ) {
             // Ignore attempted cancels in terminal states
+            #[cfg(feature = "antithesis_assertions")]
+            crate::antithesis::assert_always!(
+                true,
+                "Activity cancel ignored in terminal state",
+                ::serde_json::json!({
+                    "seq": self.shared_state.attrs.seq,
+                    "state": format!("{}", self.state())
+                })
+            );
+
             debug!(
                 "Attempted to cancel already resolved activity (seq {})",
                 self.shared_state.attrs.seq
@@ -193,7 +203,10 @@ impl ActivityMachine {
                 ActivityMachineCommand::Cancel(details) => {
                     vec![self.create_cancelation_resolve(details).into()]
                 }
-                x => panic!("Invalid cancel event response {x:?}"),
+                x => {
+                    dbg_panic!("Invalid cancel event response {x:?}");
+                    panic!("Invalid cancel event response {x:?}");
+                }
             })
             .collect();
         Ok(res)
@@ -223,9 +236,7 @@ impl TryFrom<HistEventData> for ActivityMachineEvents {
                         last_task_in_history,
                     })
                 } else {
-                    return Err(WFMachinesError::Fatal(format!(
-                        "Activity scheduled attributes were unset: {e}"
-                    )));
+                    return Err(fatal!("Activity scheduled attributes were unset: {e}"));
                 }
             }
             EventType::ActivityTaskStarted => Self::ActivityTaskStarted(e.event_id),
@@ -236,9 +247,7 @@ impl TryFrom<HistEventData> for ActivityMachineEvents {
                 {
                     Self::ActivityTaskCompleted(attrs)
                 } else {
-                    return Err(WFMachinesError::Fatal(format!(
-                        "Activity completion attributes were unset: {e}"
-                    )));
+                    return Err(fatal!("Activity completion attributes were unset: {e}"));
                 }
             }
             EventType::ActivityTaskFailed => {
@@ -247,9 +256,7 @@ impl TryFrom<HistEventData> for ActivityMachineEvents {
                 {
                     Self::ActivityTaskFailed(attrs)
                 } else {
-                    return Err(WFMachinesError::Fatal(format!(
-                        "Activity failure attributes were unset: {e}"
-                    )));
+                    return Err(fatal!("Activity failure attributes were unset: {e}"));
                 }
             }
             EventType::ActivityTaskTimedOut => {
@@ -258,9 +265,7 @@ impl TryFrom<HistEventData> for ActivityMachineEvents {
                 {
                     Self::ActivityTaskTimedOut(attrs)
                 } else {
-                    return Err(WFMachinesError::Fatal(format!(
-                        "Activity timeout attributes were unset: {e}"
-                    )));
+                    return Err(fatal!("Activity timeout attributes were unset: {e}"));
                 }
             }
             EventType::ActivityTaskCancelRequested => Self::ActivityTaskCancelRequested,
@@ -270,15 +275,13 @@ impl TryFrom<HistEventData> for ActivityMachineEvents {
                 {
                     Self::ActivityTaskCanceled(attrs)
                 } else {
-                    return Err(WFMachinesError::Fatal(format!(
-                        "Activity cancellation attributes were unset: {e}"
-                    )));
+                    return Err(fatal!("Activity cancellation attributes were unset: {e}"));
                 }
             }
             _ => {
-                return Err(WFMachinesError::Nondeterminism(format!(
+                return Err(nondeterminism!(
                     "Activity machine does not handle this event: {e}"
-                )));
+                ));
             }
         })
     }
@@ -375,18 +378,20 @@ impl ScheduleCommandCreated {
             sched_dat.last_task_in_history,
         ) {
             if sched_dat.act_id != dat.attrs.activity_id {
-                return TransitionResult::Err(WFMachinesError::Nondeterminism(format!(
+                return TransitionResult::Err(nondeterminism!(
                     "Activity id of scheduled event '{}' does not \
                  match activity id of activity command '{}'",
-                    sched_dat.act_id, dat.attrs.activity_id
-                )));
+                    sched_dat.act_id,
+                    dat.attrs.activity_id
+                ));
             }
             if sched_dat.act_type != dat.attrs.activity_type {
-                return TransitionResult::Err(WFMachinesError::Nondeterminism(format!(
+                return TransitionResult::Err(nondeterminism!(
                     "Activity type of scheduled event '{}' does not \
                  match activity type of activity command '{}'",
-                    sched_dat.act_type, dat.attrs.activity_type
-                )));
+                    sched_dat.act_type,
+                    dat.attrs.activity_type
+                ));
             }
         }
         dat.scheduled_event_id = sched_dat.event_id;
@@ -427,6 +432,15 @@ impl ScheduledEventRecorded {
         dat: &mut SharedState,
         attrs: ActivityTaskTimedOutEventAttributes,
     ) -> ActivityMachineTransition<TimedOut> {
+        #[cfg(feature = "antithesis_assertions")]
+        crate::antithesis::assert_sometimes!(
+            true,
+            "Activity timed out before starting",
+            ::serde_json::json!({
+                "activity_id": dat.attrs.activity_id,
+                "state": "ScheduledEventRecorded"
+            })
+        );
         notify_lang_activity_timed_out(dat, attrs)
     }
 
@@ -434,12 +448,27 @@ impl ScheduledEventRecorded {
         self,
         dat: &mut SharedState,
     ) -> ActivityMachineTransition<ScheduledActivityCancelCommandCreated> {
+        #[cfg(feature = "antithesis_assertions")]
+        crate::antithesis::assert_sometimes!(
+            true,
+            "Activity cancelled in scheduled state",
+            ::serde_json::json!({
+                "activity_id": dat.attrs.activity_id,
+                "cancellation_type": format!("{:?}", dat.cancellation_type)
+            })
+        );
         create_request_cancel_activity_task_command(
             dat,
             ScheduledActivityCancelCommandCreated::default(),
         )
     }
     pub(super) fn on_abandoned(self) -> ActivityMachineTransition<Canceled> {
+        #[cfg(feature = "antithesis_assertions")]
+        crate::antithesis::assert_sometimes!(
+            true,
+            "Activity abandoned",
+            ::serde_json::json!({"mode": "Abandon"})
+        );
         notify_lang_activity_cancelled(None)
     }
 }
@@ -452,6 +481,14 @@ impl Started {
         self,
         attrs: ActivityTaskCompletedEventAttributes,
     ) -> ActivityMachineTransition<Completed> {
+        #[cfg(feature = "antithesis_assertions")]
+        crate::antithesis::assert_sometimes!(
+            true,
+            "Activity completed successfully",
+            ::serde_json::json!({
+                "has_result": attrs.result.is_some()
+            })
+        );
         ActivityMachineTransition::ok(
             vec![ActivityMachineCommand::Complete(attrs.result)],
             Completed::default(),
@@ -462,6 +499,16 @@ impl Started {
         dat: &mut SharedState,
         attrs: ActivityTaskFailedEventAttributes,
     ) -> ActivityMachineTransition<Failed> {
+        #[cfg(feature = "antithesis_assertions")]
+        crate::antithesis::assert_sometimes!(
+            true,
+            "Activity task failed",
+            ::serde_json::json!({
+                "activity_id": dat.attrs.activity_id,
+                "activity_type": dat.attrs.activity_type,
+                "retry_state": attrs.retry_state
+            })
+        );
         ActivityMachineTransition::ok(
             vec![ActivityMachineCommand::Fail(new_failure(dat, attrs))],
             Failed::default(),
@@ -473,6 +520,15 @@ impl Started {
         dat: &mut SharedState,
         attrs: ActivityTaskTimedOutEventAttributes,
     ) -> ActivityMachineTransition<TimedOut> {
+        #[cfg(feature = "antithesis_assertions")]
+        crate::antithesis::assert_sometimes!(
+            true,
+            "Activity timed out after starting",
+            ::serde_json::json!({
+                "activity_id": dat.attrs.activity_id,
+                "state": "Started"
+            })
+        );
         notify_lang_activity_timed_out(dat, attrs)
     }
 
@@ -480,12 +536,27 @@ impl Started {
         self,
         dat: &mut SharedState,
     ) -> ActivityMachineTransition<StartedActivityCancelCommandCreated> {
+        #[cfg(feature = "antithesis_assertions")]
+        crate::antithesis::assert_sometimes!(
+            true,
+            "Activity cancelled after started",
+            ::serde_json::json!({
+                "activity_id": dat.attrs.activity_id,
+                "cancellation_type": format!("{:?}", dat.cancellation_type)
+            })
+        );
         create_request_cancel_activity_task_command(
             dat,
             StartedActivityCancelCommandCreated::default(),
         )
     }
     pub(super) fn on_abandoned(self) -> ActivityMachineTransition<Canceled> {
+        #[cfg(feature = "antithesis_assertions")]
+        crate::antithesis::assert_sometimes!(
+            true,
+            "Activity abandoned in started state",
+            ::serde_json::json!({"state": "Started"})
+        );
         notify_lang_activity_cancelled(None)
     }
 }
@@ -502,6 +573,14 @@ impl ScheduledActivityCancelEventRecorded {
         dat: &mut SharedState,
         attrs: ActivityTaskCanceledEventAttributes,
     ) -> ActivityMachineTransition<Canceled> {
+        #[cfg(feature = "antithesis_assertions")]
+        crate::antithesis::assert_sometimes!(
+            true,
+            "Activity cancellation completed",
+            ::serde_json::json!({
+                "has_details": attrs.details.is_some()
+            })
+        );
         notify_if_not_already_cancelled(dat, |_| notify_lang_activity_cancelled(Some(attrs)))
     }
 
@@ -532,6 +611,14 @@ impl StartedActivityCancelEventRecorded {
         dat: &mut SharedState,
         attrs: ActivityTaskCompletedEventAttributes,
     ) -> ActivityMachineTransition<Completed> {
+        #[cfg(feature = "antithesis_assertions")]
+        crate::antithesis::assert_sometimes!(
+            true,
+            "Activity completed despite cancel request",
+            ::serde_json::json!({
+                "cancellation_type": format!("{:?}", dat.cancellation_type)
+            })
+        );
         notify_if_not_already_cancelled(dat, |_| {
             TransitionResult::commands(vec![ActivityMachineCommand::Complete(attrs.result)])
         })
@@ -541,6 +628,14 @@ impl StartedActivityCancelEventRecorded {
         dat: &mut SharedState,
         attrs: ActivityTaskFailedEventAttributes,
     ) -> ActivityMachineTransition<Failed> {
+        #[cfg(feature = "antithesis_assertions")]
+        crate::antithesis::assert_sometimes!(
+            true,
+            "Activity failed despite cancel request",
+            ::serde_json::json!({
+                "cancellation_type": format!("{:?}", dat.cancellation_type)
+            })
+        );
         notify_if_not_already_cancelled(dat, |dat| {
             TransitionResult::commands(vec![ActivityMachineCommand::Fail(new_failure(dat, attrs))])
         })
@@ -647,12 +742,21 @@ impl Canceled {
     ) -> ActivityMachineTransition<Canceled> {
         // Abandoned activities might start anyway. Ignore the result.
         if dat.cancellation_type == ActivityCancellationType::Abandon {
+            #[cfg(feature = "antithesis_assertions")]
+            crate::antithesis::assert_always!(
+                true,
+                "Abandoned activity can start after cancellation",
+                ::serde_json::json!({
+                    "seq_num": seq_num,
+                    "cancellation_type": "Abandon"
+                })
+            );
             TransitionResult::default()
         } else {
-            TransitionResult::Err(WFMachinesError::Nondeterminism(format!(
+            TransitionResult::Err(nondeterminism!(
                 "Non-Abandon cancel mode activities cannot be started after being cancelled. \
                  Seq: {seq_num:?}"
-            )))
+            ))
         }
     }
     pub(super) fn on_activity_task_completed(
@@ -662,11 +766,19 @@ impl Canceled {
     ) -> ActivityMachineTransition<Canceled> {
         // Abandoned activities might complete anyway. Ignore the result.
         if dat.cancellation_type == ActivityCancellationType::Abandon {
+            #[cfg(feature = "antithesis_assertions")]
+            crate::antithesis::assert_always!(
+                true,
+                "Abandoned activity can complete after cancellation",
+                ::serde_json::json!({
+                    "activity_id": dat.attrs.activity_id
+                })
+            );
             TransitionResult::default()
         } else {
-            TransitionResult::Err(WFMachinesError::Nondeterminism(format!(
+            TransitionResult::Err(nondeterminism!(
                 "Non-Abandon cancel mode activities cannot be completed after being cancelled: {attrs:?}"
-            )))
+            ))
         }
     }
 }
@@ -792,9 +904,7 @@ fn convert_payloads(
     result: Option<Payloads>,
 ) -> Result<Option<Payload>, WFMachinesError> {
     result.map(TryInto::try_into).transpose().map_err(|pe| {
-        WFMachinesError::Fatal(format!(
-            "Not exactly one payload in activity result ({pe}) for event: {event_info:?}"
-        ))
+        fatal!("Not exactly one payload in activity result ({pe}) for event: {event_info:?}")
     })
 }
 
@@ -806,7 +916,7 @@ mod test {
         worker::workflow::{OutgoingJob, machines::Machines},
     };
     use std::{cell::RefCell, mem::discriminant, rc::Rc};
-    use temporal_sdk_core_protos::coresdk::workflow_activation::workflow_activation_job;
+    use temporalio_common::protos::coresdk::workflow_activation::workflow_activation_job;
 
     #[test]
     fn cancels_ignored_terminal() {

package/sdk-core/{core → crates/sdk-core}/src/worker/workflow/machines/cancel_external_state_machine.rs

@@ -1,11 +1,10 @@
 use super::{
-    EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError,
-    workflow_machines::MachineResponse,
+    EventInfo, NewMachineWithCommand, OnEventWrapper, StateMachine, TransitionResult,
+    WFMachinesAdapter, WFMachinesError, fsm, workflow_machines::MachineResponse,
 };
-use crate::worker::workflow::machines::HistEventData;
-use rustfsm::{StateMachine, TransitionResult, fsm};
+use crate::worker::workflow::{fatal, machines::HistEventData, nondeterminism};
 use std::convert::TryFrom;
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     coresdk::{
         common::NamespacedWorkflowExecution,
         workflow_activation::ResolveRequestCancelExternalWorkflow,
@@ -154,15 +153,15 @@ impl TryFrom<HistEventData> for CancelExternalMachineEvents {
                 if let Some(history_event::Attributes::RequestCancelExternalWorkflowExecutionFailedEventAttributes(attrs)) = e.attributes {
                     Self::RequestCancelExternalWorkflowExecutionFailed(attrs.cause())
                 } else {
-                    return Err(WFMachinesError::Fatal(format!(
+                    return Err(fatal!(
                         "Cancelworkflow failed attributes were unset: {e}"
-                    )));
+                    ));
                 }
             }
             _ => {
-                return Err(WFMachinesError::Nondeterminism(format!(
+                return Err(nondeterminism!(
                     "Cancel external WF machine does not handle this event: {e}"
-                )))
+                ))
             }
         })
     }

package/sdk-core/{core → crates/sdk-core}/src/worker/workflow/machines/cancel_nexus_op_state_machine.rs

@@ -1,14 +1,14 @@
 use super::{
-    workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
-    WFMachinesAdapter, WFMachinesError,
+    Cancellable, EventInfo, NewMachineWithCommand, WFMachinesAdapter, WFMachinesError,
+    workflow_machines::MachineResponse,
 };
-use crate::worker::workflow::machines::HistEventData;
-use rustfsm::{fsm, StateMachine, TransitionResult};
+use super::{StateMachine, TransitionResult, fsm};
+use crate::worker::workflow::{machines::HistEventData, nondeterminism, fatal};
 use std::convert::TryFrom;
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     coresdk::workflow_activation::ResolveCancelNexusOperation,
     temporal::api::{
-        command::v1::{command, RequestCancelNexusOperationCommandAttributes},
+        command::v1::{RequestCancelNexusOperationCommandAttributes, command},
         enums::v1::{CommandType, EventType},
     },
 };
@@ -76,9 +76,9 @@ impl TryFrom<HistEventData> for CancelNexusOpMachineEvents {
         Ok(match e.event_type() {
             EventType::NexusOperationCancelRequested => Self::NexusOpCancelRequested,
             _ => {
-                return Err(WFMachinesError::Nondeterminism(format!(
+                return Err(nondeterminism!(
                     "Cancel external WF machine does not handle this event: {e}"
-                )))
+                ));
             }
         })
     }
@@ -105,10 +105,12 @@ impl WFMachinesAdapter for CancelNexusOpMachine {
     ) -> Result<Vec<MachineResponse>, WFMachinesError> {
         Ok(match my_command {
             CancelNexusOpCommand::Requested => {
-                vec![ResolveCancelNexusOperation {
-                    seq: self.shared_state.seq,
-                }
-                .into()]
+                vec![
+                    ResolveCancelNexusOperation {
+                        seq: self.shared_state.seq,
+                    }
+                    .into(),
+                ]
             }
         })
     }

package/sdk-core/{core → crates/sdk-core}/src/worker/workflow/machines/cancel_workflow_state_machine.rs

@@ -1,11 +1,10 @@
 use super::{
-    EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError,
-    workflow_machines::MachineResponse,
+    EventInfo, NewMachineWithCommand, OnEventWrapper, StateMachine, TransitionResult,
+    WFMachinesAdapter, WFMachinesError, fsm, workflow_machines::MachineResponse,
 };
-use crate::worker::workflow::machines::HistEventData;
-use rustfsm::{StateMachine, TransitionResult, fsm};
+use crate::worker::workflow::{machines::HistEventData, nondeterminism};
 use std::convert::TryFrom;
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     coresdk::workflow_commands::CancelWorkflowExecution,
     temporal::api::enums::v1::{CommandType, EventType},
 };
@@ -68,9 +67,9 @@ impl TryFrom<HistEventData> for CancelWorkflowMachineEvents {
         Ok(match EventType::try_from(e.event_type) {
             Ok(EventType::WorkflowExecutionCanceled) => Self::WorkflowExecutionCanceled,
             _ => {
-                return Err(WFMachinesError::Nondeterminism(format!(
+                return Err(nondeterminism!(
                     "Cancel workflow machine does not handle this event: {e}"
-                )));
+                ));
             }
         })
     }