@temporalio/core-bridge 1.11.7 → 1.11.8

package/sdk-core/etc/otel-collector-ci.yaml

@@ -0,0 +1,36 @@
+receivers:
+  otlp:
+    protocols:
+      grpc:
+        endpoint: 0.0.0.0:4317
+      http:
+        endpoint: 0.0.0.0:4318
+
+exporters:
+  prometheus:
+    endpoint: '0.0.0.0:8889'
+    namespace: temporal_sdk
+
+  debug:
+
+processors:
+  batch:
+
+extensions:
+  health_check:
+  pprof:
+    endpoint: :1888
+  zpages:
+    endpoint: :55679
+
+service:
+  extensions: [ pprof, zpages, health_check ]
+  pipelines:
+    traces:
+      receivers: [ otlp ]
+      processors: [ batch ]
+      exporters: [ debug, ]
+    metrics:
+      receivers: [ otlp ]
+      processors: [ batch ]
+      exporters: [ debug, prometheus ]

package/sdk-core/etc/otel-collector-config.yaml

@@ -11,7 +11,7 @@ exporters:
     endpoint: '0.0.0.0:8889'
     namespace: temporal_sdk
 
-  logging:
+  debug:
 
   otlp/jaeger:
     endpoint: jaeger:14250
@@ -32,8 +32,8 @@ service:
     traces:
       receivers: [ otlp ]
       processors: [ batch ]
-      exporters: [ logging, otlp/jaeger ]
+      exporters: [ debug, otlp/jaeger ]
     metrics:
       receivers: [ otlp ]
       processors: [ batch ]
-      exporters: [ logging, prometheus ]
+      exporters: [ debug, prometheus ]

package/sdk-core/etc/prometheus.yaml

@@ -1,6 +1,6 @@
 scrape_configs:
   - job_name: 'otel-collector'
-    scrape_interval: 3s
+    scrape_interval: 1s
     static_configs:
       - targets: ['otel-collector:8889']
       - targets: ['otel-collector:8888']

package/sdk-core/fsm/Cargo.toml

@@ -2,7 +2,7 @@
 name = "rustfsm"
 version = "0.1.0"
 authors = ["Spencer Judge <spencer@temporal.io>"]
-edition = "2021"
+edition = "2024"
 license-file = "LICENSE.txt"
 description = "Define state machines that can accept events and produce commands"
 homepage = "https://temporal.io/"

package/sdk-core/fsm/rustfsm_procmacro/Cargo.toml

@@ -2,7 +2,7 @@
 name = "rustfsm_procmacro"
 version = "0.1.0"
 authors = ["Spencer Judge <spencer@temporal.io>"]
-edition = "2021"
+edition = "2024"
 license-file = "LICENSE.txt"
 description = "Procmacro sub-crate of the `rustfsm` crate"
 

package/sdk-core/fsm/rustfsm_procmacro/src/lib.rs

@@ -1,12 +1,11 @@
 use proc_macro::TokenStream;
 use quote::{quote, quote_spanned};
-use std::collections::{hash_map::Entry, HashMap, HashSet};
+use std::collections::{HashMap, HashSet, hash_map::Entry};
 use syn::{
-    parenthesized,
+    Error, Fields, Ident, Token, Type, Variant, Visibility, parenthesized,
     parse::{Parse, ParseStream, Result},
     parse_macro_input,
     spanned::Spanned,
-    Error, Fields, Ident, Token, Type, Variant, Visibility,
 };
 
 /// Parses a DSL for defining finite state machines, and produces code implementing the
@@ -287,7 +286,7 @@ impl Parse for Transition {
                 return Err(Error::new(
                     event.span(),
                     "Struct variants are not supported for events",
-                ))
+                ));
             }
             Fields::Unnamed(uf) => {
                 if uf.unnamed.len() != 1 {

package/sdk-core/fsm/rustfsm_procmacro/tests/trybuild/no_handle_conversions_require_into_fail.stderr

@@ -2,7 +2,7 @@ error[E0277]: the trait bound `One: From<Two>` is not satisfied
   --> tests/trybuild/no_handle_conversions_require_into_fail.rs:11:5
    |
 11 |     Two --(B)--> One;
-   |     ^^^ the trait `From<Two>` is not implemented for `One`, which is required by `Two: Into<One>`
+   |     ^^^ the trait `From<Two>` is not implemented for `One`
    |
    = note: required for `Two` to implement `Into<One>`
 note: required by a bound in `TransitionResult::<Sm, Ds>::from`

package/sdk-core/fsm/rustfsm_trait/Cargo.toml

@@ -2,7 +2,7 @@
 name = "rustfsm_trait"
 version = "0.1.0"
 authors = ["Spencer Judge <spencer@temporal.io>"]
-edition = "2021"
+edition = "2024"
 license-file = "LICENSE.txt"
 description = "Trait sub-crate of the `rustfsm` crate"
 

package/sdk-core/sdk/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "temporal-sdk"
 version = "0.1.0-alpha.1"
-edition = "2021"
+edition = "2024"
 authors = ["Spencer Judge <spencer@temporal.io>"]
 license-file = { workspace = true }
 description = "Temporal Rust SDK"
@@ -12,7 +12,6 @@ categories = ["development-tools"]
 
 [dependencies]
 async-trait = "0.1"
-thiserror = "1.0"
 anyhow = "1.0"
 derive_more = { workspace = true }
 futures-util = { version = "0.3", default-features = false }

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

@@ -8,7 +8,7 @@ use std::{
 };
 use temporal_sdk_core_api::Worker;
 use temporal_sdk_core_protos::{
-    coresdk::{activity_task, ActivityHeartbeat},
+    coresdk::{ActivityHeartbeat, activity_task},
     temporal::api::common::v1::{Payload, RetryPolicy, WorkflowExecution},
     utilities::TryIntoOrNone,
 };

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

@@ -3,7 +3,7 @@
 use crate::Worker;
 use anyhow::bail;
 use temporal_sdk_core_protos::coresdk::{
-    workflow_activation::{remove_from_cache::EvictionReason, WorkflowActivation},
+    workflow_activation::{WorkflowActivation, remove_from_cache::EvictionReason},
     workflow_completion::WorkflowActivationCompletion,
 };
 

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

@@ -53,17 +53,20 @@ mod workflow_future;
 
 pub use activity_context::ActContext;
 pub use temporal_client::Namespace;
-use tracing::{field, Instrument, Span};
+use tracing::{Instrument, Span, field};
 pub use workflow_context::{
     ActivityOptions, CancellableFuture, ChildWorkflow, ChildWorkflowOptions, LocalActivityOptions,
-    PendingChildWorkflow, Signal, SignalData, SignalWorkflowOptions, StartedChildWorkflow,
-    WfContext,
+    NexusOperationOptions, PendingChildWorkflow, Signal, SignalData, SignalWorkflowOptions,
+    StartedChildWorkflow, TimerOptions, WfContext,
 };
 
-use crate::{interceptors::WorkerInterceptor, workflow_context::ChildWfCommon};
-use anyhow::{anyhow, bail, Context};
+use crate::{
+    interceptors::WorkerInterceptor,
+    workflow_context::{ChildWfCommon, NexusUnblockData, StartedNexusOperation},
+};
+use anyhow::{Context, anyhow, bail};
 use app_data::AppData;
-use futures_util::{future::BoxFuture, FutureExt, StreamExt, TryFutureExt, TryStreamExt};
+use futures_util::{FutureExt, StreamExt, TryFutureExt, TryStreamExt, future::BoxFuture};
 use serde::Serialize;
 use std::{
     any::{Any, TypeId},
@@ -77,34 +80,33 @@ use std::{
 };
 use temporal_client::ClientOptionsBuilder;
 use temporal_sdk_core::Url;
-use temporal_sdk_core_api::{
-    errors::{PollActivityError, PollWfError},
-    Worker as CoreWorker,
-};
+use temporal_sdk_core_api::{Worker as CoreWorker, errors::PollError};
 use temporal_sdk_core_protos::{
+    TaskToken,
     coresdk::{
+        ActivityTaskCompletion, AsJsonPayloadExt, FromJsonPayloadExt,
         activity_result::{ActivityExecutionResult, ActivityResolution},
-        activity_task::{activity_task, ActivityTask},
+        activity_task::{ActivityTask, activity_task},
         child_workflow::ChildWorkflowResult,
         common::NamespacedWorkflowExecution,
+        nexus::NexusOperationResult,
         workflow_activation::{
+            WorkflowActivation,
             resolve_child_workflow_execution_start::Status as ChildWorkflowStartStatus,
-            workflow_activation_job::Variant, WorkflowActivation,
+            resolve_nexus_operation_start, workflow_activation_job::Variant,
         },
-        workflow_commands::{workflow_command, ContinueAsNewWorkflowExecution},
+        workflow_commands::{ContinueAsNewWorkflowExecution, WorkflowCommand, workflow_command},
         workflow_completion::WorkflowActivationCompletion,
-        ActivityTaskCompletion, AsJsonPayloadExt, FromJsonPayloadExt,
     },
     temporal::api::{
         common::v1::Payload,
         enums::v1::WorkflowTaskFailedCause,
-        failure::v1::{failure, Failure},
+        failure::v1::{Failure, failure},
     },
-    TaskToken,
 };
 use tokio::{
     sync::{
-        mpsc::{unbounded_channel, UnboundedSender},
+        mpsc::{UnboundedSender, unbounded_channel},
         oneshot,
     },
     task::JoinError,
@@ -191,7 +193,7 @@ impl Worker {
 
     /// Return a handle that can be used to initiate shutdown.
     /// TODO: Doc better after shutdown changes
-    pub fn shutdown_handle(&self) -> impl Fn() {
+    pub fn shutdown_handle(&self) -> impl Fn() + use<> {
         let w = self.common.worker.clone();
         move || w.initiate_shutdown()
     }
@@ -280,7 +282,7 @@ impl Worker {
             async {
                 loop {
                     let activation = match common.worker.poll_workflow_activation().await {
-                        Err(PollWfError::ShutDown) => {
+                        Err(PollError::ShutDown) => {
                             break;
                         }
                         o => o?,
@@ -315,7 +317,7 @@ impl Worker {
                 if !act_half.activity_fns.is_empty() {
                     loop {
                         let activity = common.worker.poll_activity_task().await;
-                        if matches!(activity, Err(PollActivityError::ShutDown)) {
+                        if matches!(activity, Err(PollError::ShutDown)) {
                             break;
                         }
                         act_half.activity_task_handler(
@@ -381,15 +383,18 @@ impl Worker {
 }
 
 impl WorkflowHalf {
+    #[allow(clippy::type_complexity)]
     fn workflow_activation_handler(
         &self,
         common: &CommonWorker,
         shutdown_token: CancellationToken,
-        activation: WorkflowActivation,
+        mut activation: WorkflowActivation,
         completions_tx: &UnboundedSender<WorkflowActivationCompletion>,
     ) -> Result<
         Option<
-            WorkflowFutureHandle<impl Future<Output = Result<WorkflowResult<Payload>, JoinError>>>,
+            WorkflowFutureHandle<
+                impl Future<Output = Result<WorkflowResult<Payload>, JoinError>> + use<>,
+            >,
         >,
         anyhow::Error,
     > {
@@ -398,8 +403,8 @@ impl WorkflowHalf {
 
         // If the activation is to init a workflow, create a new workflow driver for it,
         // using the function associated with that workflow id
-        if let Some(sw) = activation.jobs.iter().find_map(|j| match j.variant {
-            Some(Variant::InitializeWorkflow(ref sw)) => Some(sw),
+        if let Some(sw) = activation.jobs.iter_mut().find_map(|j| match j.variant {
+            Some(Variant::InitializeWorkflow(ref mut sw)) => Some(sw),
             _ => None,
         }) {
             let workflow_type = &sw.workflow_type;
@@ -420,9 +425,7 @@ impl WorkflowHalf {
             let (wff, activations) = wf_function.start_workflow(
                 common.worker.get_config().namespace.clone(),
                 common.task_queue.clone(),
-                workflow_type,
-                // NOTE: Don't clone args if this gets ported to be a non-test rust worker
-                sw.arguments.clone(),
+                std::mem::take(sw),
                 completions_tx.clone(),
             );
             let jh = tokio::spawn(async move {
@@ -454,11 +457,11 @@ impl WorkflowHalf {
                 .send(activation)
                 .expect("Workflow should exist if we're sending it an activation");
         } else {
-            // When we failed to start a workflow, we never inserted it into the cache.
-            // But core sends us a `RemoveFromCache` job when we mark the StartWorkflow workflow activation
-            // as a failure, which we need to complete.
-            // Other SDKs add the workflow to the cache even when the workflow type is unknown/not found.
-            // To circumvent this, we simply mark any RemoveFromCache job for workflows that are not in the cache as complete.
+            // When we failed to start a workflow, we never inserted it into the cache. But core
+            // sends us a `RemoveFromCache` job when we mark the StartWorkflow workflow activation
+            // as a failure, which we need to complete. Other SDKs add the workflow to the cache
+            // even when the workflow type is unknown/not found. To circumvent this, we simply mark
+            // any RemoveFromCache job for workflows that are not in the cache as complete.
             if activation.jobs.len() == 1
                 && matches!(
                     activation.jobs.first().map(|j| &j.variant),
@@ -600,6 +603,8 @@ enum UnblockEvent {
     WorkflowComplete(u32, Box<ChildWorkflowResult>),
     SignalExternal(u32, Option<Failure>),
     CancelExternal(u32, Option<Failure>),
+    NexusOperationStart(u32, Box<resolve_nexus_operation_start::Status>),
+    NexusOperationComplete(u32, Box<NexusOperationResult>),
 }
 
 /// Result of awaiting on a timer
@@ -697,43 +702,106 @@ impl Unblockable for CancelExternalWfResult {
     }
 }
 
+type NexusStartResult = Result<StartedNexusOperation, Failure>;
+impl Unblockable for NexusStartResult {
+    type OtherDat = NexusUnblockData;
+    fn unblock(ue: UnblockEvent, od: Self::OtherDat) -> Self {
+        match ue {
+            UnblockEvent::NexusOperationStart(_, result) => match *result {
+                resolve_nexus_operation_start::Status::OperationId(op_id) => {
+                    Ok(StartedNexusOperation {
+                        operation_id: Some(op_id),
+                        unblock_dat: od,
+                    })
+                }
+                resolve_nexus_operation_start::Status::StartedSync(_) => {
+                    Ok(StartedNexusOperation {
+                        operation_id: None,
+                        unblock_dat: od,
+                    })
+                }
+                resolve_nexus_operation_start::Status::CancelledBeforeStart(f) => Err(f),
+            },
+            _ => panic!("Invalid unblock event for nexus operation"),
+        }
+    }
+}
+
+impl Unblockable for NexusOperationResult {
+    type OtherDat = ();
+
+    fn unblock(ue: UnblockEvent, _: Self::OtherDat) -> Self {
+        match ue {
+            UnblockEvent::NexusOperationComplete(_, result) => *result,
+            _ => panic!("Invalid unblock event for nexus operation complete"),
+        }
+    }
+}
+
 /// Identifier for cancellable operations
 #[derive(Debug, Clone)]
-pub enum CancellableID {
-    /// Timer sequence number
+pub(crate) enum CancellableID {
     Timer(u32),
-    /// Activity sequence number
     Activity(u32),
-    /// Activity sequence number
     LocalActivity(u32),
-    /// Start child sequence number
-    ChildWorkflow(u32),
-    /// Signal workflow
+    ChildWorkflow {
+        seqnum: u32,
+        reason: String,
+    },
     SignalExternalWorkflow(u32),
-    /// An external workflow identifier as may have been created by a started child workflow
     ExternalWorkflow {
-        /// Sequence number which will be used for the cancel command
         seqnum: u32,
-        /// Identifying information about the workflow to be cancelled
         execution: NamespacedWorkflowExecution,
-        /// Set to true if this workflow is a child of the issuing workflow
-        only_child: bool,
+        reason: String,
     },
+    /// A nexus operation (waiting for start)
+    NexusOp(u32),
 }
 
-impl CancellableID {
-    /// Returns the type-specific sequence number used for this command
-    pub fn seq_num(&self) -> u32 {
+/// Cancellation IDs that support a reason.
+pub(crate) trait SupportsCancelReason {
+    /// Returns a new version of this ID with the provided cancellation reason.
+    fn with_reason(self, reason: String) -> CancellableID;
+}
+#[derive(Debug, Clone)]
+pub(crate) enum CancellableIDWithReason {
+    ChildWorkflow {
+        seqnum: u32,
+    },
+    ExternalWorkflow {
+        seqnum: u32,
+        execution: NamespacedWorkflowExecution,
+    },
+}
+impl CancellableIDWithReason {
+    pub(crate) fn seq_num(&self) -> u32 {
         match self {
-            CancellableID::Timer(seq) => *seq,
-            CancellableID::Activity(seq) => *seq,
-            CancellableID::LocalActivity(seq) => *seq,
-            CancellableID::ChildWorkflow(seq) => *seq,
-            CancellableID::SignalExternalWorkflow(seq) => *seq,
-            CancellableID::ExternalWorkflow { seqnum, .. } => *seqnum,
+            CancellableIDWithReason::ChildWorkflow { seqnum } => *seqnum,
+            CancellableIDWithReason::ExternalWorkflow { seqnum, .. } => *seqnum,
         }
     }
 }
+impl SupportsCancelReason for CancellableIDWithReason {
+    fn with_reason(self, reason: String) -> CancellableID {
+        match self {
+            CancellableIDWithReason::ChildWorkflow { seqnum } => {
+                CancellableID::ChildWorkflow { seqnum, reason }
+            }
+            CancellableIDWithReason::ExternalWorkflow { seqnum, execution } => {
+                CancellableID::ExternalWorkflow {
+                    seqnum,
+                    execution,
+                    reason,
+                }
+            }
+        }
+    }
+}
+impl From<CancellableIDWithReason> for CancellableID {
+    fn from(v: CancellableIDWithReason) -> Self {
+        v.with_reason("".to_string())
+    }
+}
 
 #[derive(derive_more::From)]
 #[allow(clippy::large_enum_variant)]
@@ -746,10 +814,14 @@ enum RustWfCmd {
     SubscribeChildWorkflowCompletion(CommandSubscribeChildWorkflowCompletion),
     SubscribeSignal(String, UnboundedSender<SignalData>),
     RegisterUpdate(String, UpdateFunctions),
+    SubscribeNexusOperationCompletion {
+        seq: u32,
+        unblocker: oneshot::Sender<UnblockEvent>,
+    },
 }
 
 struct CommandCreateRequest {
-    cmd: workflow_command::Variant,
+    cmd: WorkflowCommand,
     unblocker: oneshot::Sender<UnblockEvent>,
 }