@temporalio/core-bridge 1.11.2 → 1.11.4

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

@@ -4,7 +4,7 @@ use crate::{
     protosext::ValidPollWFTQResponse,
     MetricsContext,
 };
-use futures::{stream, Stream};
+use futures_util::{stream, Stream};
 use temporal_sdk_core_api::worker::WorkflowSlotKind;
 use temporal_sdk_core_protos::temporal::api::workflowservice::v1::PollWorkflowTaskQueueResponse;
 
@@ -78,7 +78,7 @@ mod tests {
         abstractions::tests::fixed_size_permit_dealer, pollers::MockPermittedPollBuffer,
         test_help::mock_poller,
     };
-    use futures::{pin_mut, StreamExt};
+    use futures_util::{pin_mut, StreamExt};
     use std::sync::Arc;
     use temporal_sdk_core_api::worker::WorkflowSlotKind;
 

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

@@ -8,7 +8,7 @@ use crate::{
     },
     MetricsContext,
 };
-use futures::{stream, stream::PollNext, Stream, StreamExt};
+use futures_util::{stream, stream::PollNext, Stream, StreamExt};
 use std::{collections::VecDeque, fmt::Debug, future, sync::Arc};
 use temporal_sdk_core_api::errors::PollWfError;
 use temporal_sdk_core_protos::coresdk::workflow_activation::remove_from_cache::EvictionReason;
@@ -106,7 +106,7 @@ impl WFStream {
                 let maybe_act = match action {
                     WFStreamInput::NewWft(pwft) => {
                         debug!(run_id=%pwft.work.execution.run_id, "New WFT");
-                        state.instantiate_or_update(pwft)
+                        state.instantiate_or_update(*pwft)
                     }
                     WFStreamInput::Local(local_input) => {
                         let _span_g = local_input.span.enter();
@@ -124,12 +124,12 @@ impl WFStream {
                             }
                             LocalInputs::FetchedPageCompletion { paginator, update } => {
                                 activations.extend(state.process_completion(
-                                    NewOrFetchedComplete::Fetched(update, paginator),
+                                    NewOrFetchedComplete::Fetched(update, Box::new(paginator)),
                                 ));
                                 None // completions can return more than one activation
                             }
                             LocalInputs::PostActivation(report) => {
-                                state.process_post_activation(report)
+                                state.process_post_activation(*report)
                             }
                             LocalInputs::LocalResolution(res) => state.local_resolution(res),
                             LocalInputs::HeartbeatTimeout(hbt) => {
@@ -242,7 +242,7 @@ impl WFStream {
                    cache. Will fetch history");
             self.metrics.sticky_cache_miss();
             return Err(HistoryFetchReq::Full(
-                CacheMissFetchReq { original_wft: pwft },
+                Box::new(CacheMissFetchReq { original_wft: pwft }),
                 self.history_fetch_refcounter.clone(),
             ));
         }
@@ -292,7 +292,7 @@ impl WFStream {
                 ),
             },
             NewOrFetchedComplete::Fetched(update, paginator) => {
-                rh.fetched_page_completion(update, paginator)
+                rh.fetched_page_completion(update, *paginator)
             }
         }
         .into_iter()
@@ -556,7 +556,7 @@ impl WFStream {
 /// All possible inputs to the [WFStream]
 #[derive(derive_more::From, Debug)]
 enum WFStreamInput {
-    NewWft(PermittedWFT),
+    NewWft(Box<PermittedWFT>),
     Local(LocalInput),
     /// The stream given to us which represents the poller (or a mock) terminated.
     PollerDead,
@@ -595,7 +595,7 @@ pub(super) enum LocalInputs {
         update: HistoryUpdate,
     },
     LocalResolution(LocalResolutionMsg),
-    PostActivation(PostActivationMsg),
+    PostActivation(Box<PostActivationMsg>),
     RequestEviction(RequestEvictMsg),
     HeartbeatTimeout(String),
     GetStateInfo(GetStateInfoMsg),
@@ -634,10 +634,10 @@ enum ExternalPollerInputs {
 impl From<ExternalPollerInputs> for WFStreamInput {
     fn from(l: ExternalPollerInputs) -> Self {
         match l {
-            ExternalPollerInputs::NewWft(v) => WFStreamInput::NewWft(v),
+            ExternalPollerInputs::NewWft(v) => WFStreamInput::NewWft(Box::new(v)),
             ExternalPollerInputs::PollerDead => WFStreamInput::PollerDead,
             ExternalPollerInputs::PollerError(e) => WFStreamInput::PollerError(e),
-            ExternalPollerInputs::FetchedUpdate(wft) => WFStreamInput::NewWft(wft),
+            ExternalPollerInputs::FetchedUpdate(wft) => WFStreamInput::NewWft(Box::new(wft)),
             ExternalPollerInputs::FailedFetch {
                 run_id,
                 err,
@@ -692,7 +692,7 @@ impl From<Result<WFTExtractorOutput, tonic::Status>> for ExternalPollerInputs {
 #[derive(Debug)]
 enum NewOrFetchedComplete {
     New(WFActCompleteMsg),
-    Fetched(HistoryUpdate, HistoryPaginator),
+    Fetched(HistoryUpdate, Box<HistoryPaginator>),
 }
 impl NewOrFetchedComplete {
     fn run_id(&self) -> &str {

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

@@ -20,6 +20,7 @@ async-trait = "0.1"
 derive_builder = { workspace = true }
 derive_more = { workspace = true }
 opentelemetry = { workspace = true, optional = true }
+prost = { workspace = true }
 prost-types = { workspace = true }
 serde_json = "1.0"
 thiserror = "1.0"

package/sdk-core/core-api/src/worker.rs

@@ -5,6 +5,9 @@ use std::{
     sync::Arc,
     time::Duration,
 };
+use temporal_sdk_core_protos::coresdk::{
+    ActivitySlotInfo, LocalActivitySlotInfo, WorkflowSlotInfo,
+};
 
 const MAX_CONCURRENT_WFT_POLLS_DEFAULT: usize = 5;
 
@@ -275,7 +278,8 @@ pub trait SlotSupplier {
     /// Block until a slot is available, then return a permit for the slot.
     async fn reserve_slot(&self, ctx: &dyn SlotReservationContext) -> SlotSupplierPermit;
 
-    /// Try to immediately reserve a slot, returning None if one is not available
+    /// Try to immediately reserve a slot, returning None if one is not available. Implementations
+    /// must not block, or risk blocking the async event loop.
     fn try_reserve_slot(&self, ctx: &dyn SlotReservationContext) -> Option<SlotSupplierPermit>;
 
     /// Marks a slot as actually now being used. This is separate from reserving one because the
@@ -286,10 +290,10 @@ pub trait SlotSupplier {
     /// Users' implementation of this can choose to emit metrics, or otherwise leverage the
     /// information provided by the `info` parameter to be better able to make future decisions
     /// about whether a slot should be handed out.
-    fn mark_slot_used(&self, info: <Self::SlotKind as SlotKind>::Info<'_>);
+    fn mark_slot_used(&self, ctx: &dyn SlotMarkUsedContext<SlotKind = Self::SlotKind>);
 
     /// Frees a slot.
-    fn release_slot(&self);
+    fn release_slot(&self, ctx: &dyn SlotReleaseContext<SlotKind = Self::SlotKind>);
 
     /// If this implementation knows how many slots are available at any moment, it should return
     /// that here.
@@ -299,11 +303,39 @@ pub trait SlotSupplier {
 }
 
 pub trait SlotReservationContext: Send + Sync {
+    /// Returns the name of the task queue this worker is polling
+    fn task_queue(&self) -> &str;
+
+    /// Returns the identity of the worker
+    fn worker_identity(&self) -> &str;
+
+    /// Returns the build id of the worker
+    fn worker_build_id(&self) -> &str;
+
     /// Returns the number of currently outstanding slot permits, whether used or un-used.
     fn num_issued_slots(&self) -> usize;
+
+    /// Returns true iff this is a sticky poll for a workflow task
+    fn is_sticky(&self) -> bool;
+}
+
+pub trait SlotMarkUsedContext: Send + Sync {
+    type SlotKind: SlotKind;
+    /// The slot permit that is being used
+    fn permit(&self) -> &SlotSupplierPermit;
+    /// Returns the info of slot that was marked as used
+    fn info(&self) -> &<Self::SlotKind as SlotKind>::Info;
+}
+
+pub trait SlotReleaseContext: Send + Sync {
+    type SlotKind: SlotKind;
+    /// The slot permit that is being used
+    fn permit(&self) -> &SlotSupplierPermit;
+    /// Returns the info of slot that was released, if it was used
+    fn info(&self) -> Option<&<Self::SlotKind as SlotKind>::Info>;
 }
 
-#[derive(Default)]
+#[derive(Default, Debug)]
 pub struct SlotSupplierPermit {
     user_data: Option<Box<dyn Any + Send + Sync>>,
 }
@@ -325,46 +357,68 @@ impl SlotSupplierPermit {
     }
 }
 
-pub struct WorkflowSlotInfo<'a> {
-    pub workflow_type: &'a str,
-    // etc...
-}
-
-pub struct ActivitySlotInfo<'a> {
-    pub activity_type: &'a str,
-    // etc...
-}
-pub struct LocalActivitySlotInfo<'a> {
-    pub activity_type: &'a str,
-    // etc...
+#[derive(Debug, Copy, Clone, derive_more::Display, Eq, PartialEq)]
+pub enum SlotKindType {
+    Workflow,
+    Activity,
+    LocalActivity,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Copy, Clone)]
 pub struct WorkflowSlotKind {}
-#[derive(Debug)]
+#[derive(Debug, Copy, Clone)]
 pub struct ActivitySlotKind {}
-#[derive(Debug)]
+#[derive(Debug, Copy, Clone)]
 pub struct LocalActivitySlotKind {}
+
+pub enum SlotInfo<'a> {
+    Workflow(&'a WorkflowSlotInfo),
+    Activity(&'a ActivitySlotInfo),
+    LocalActivity(&'a LocalActivitySlotInfo),
+}
+
+pub trait SlotInfoTrait: prost::Message {
+    fn downcast(&self) -> SlotInfo;
+}
+impl SlotInfoTrait for WorkflowSlotInfo {
+    fn downcast(&self) -> SlotInfo {
+        SlotInfo::Workflow(self)
+    }
+}
+impl SlotInfoTrait for ActivitySlotInfo {
+    fn downcast(&self) -> SlotInfo {
+        SlotInfo::Activity(self)
+    }
+}
+impl SlotInfoTrait for LocalActivitySlotInfo {
+    fn downcast(&self) -> SlotInfo {
+        SlotInfo::LocalActivity(self)
+    }
+}
+
 pub trait SlotKind {
-    type Info<'a>;
-    fn kind_name() -> &'static str;
+    type Info: SlotInfoTrait;
+
+    fn kind() -> SlotKindType;
 }
 impl SlotKind for WorkflowSlotKind {
-    type Info<'a> = WorkflowSlotInfo<'a>;
+    type Info = WorkflowSlotInfo;
 
-    fn kind_name() -> &'static str {
-        "workflow"
+    fn kind() -> SlotKindType {
+        SlotKindType::Workflow
     }
 }
 impl SlotKind for ActivitySlotKind {
-    type Info<'a> = ActivitySlotInfo<'a>;
-    fn kind_name() -> &'static str {
-        "activity"
+    type Info = ActivitySlotInfo;
+
+    fn kind() -> SlotKindType {
+        SlotKindType::Activity
     }
 }
 impl SlotKind for LocalActivitySlotKind {
-    type Info<'a> = LocalActivitySlotInfo<'a>;
-    fn kind_name() -> &'static str {
-        "local_activity"
+    type Info = LocalActivitySlotInfo;
+
+    fn kind() -> SlotKindType {
+        SlotKindType::LocalActivity
     }
 }

package/sdk-core/sdk/Cargo.toml

@@ -14,9 +14,8 @@ categories = ["development-tools"]
 async-trait = "0.1"
 thiserror = "1.0"
 anyhow = "1.0"
-crossbeam-channel = "0.5"
 derive_more = { workspace = true }
-futures = "0.3"
+futures-util = { version = "0.3", default-features = false }
 parking_lot = { version = "0.12", features = ["send_guard"] }
 prost-types = { version = "0.6", package = "prost-wkt-types" }
 serde = "1.0"

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

@@ -63,7 +63,7 @@ pub use workflow_context::{
 use crate::{interceptors::WorkerInterceptor, workflow_context::ChildWfCommon};
 use anyhow::{anyhow, bail, Context};
 use app_data::AppData;
-use futures::{future::BoxFuture, FutureExt, StreamExt, TryFutureExt, TryStreamExt};
+use futures_util::{future::BoxFuture, FutureExt, StreamExt, TryFutureExt, TryStreamExt};
 use serde::Serialize;
 use std::{
     any::{Any, TypeId},

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

@@ -11,8 +11,7 @@ use crate::{
     IntoUpdateValidatorFunc, RustWfCmd, SignalExternalWfResult, TimerResult, UnblockEvent,
     Unblockable, UpdateFunctions,
 };
-use crossbeam_channel::{Receiver, Sender};
-use futures::{task::Context, FutureExt, Stream, StreamExt};
+use futures_util::{task::Context, FutureExt, Stream, StreamExt};
 use parking_lot::{RwLock, RwLockReadGuard};
 use std::{
     collections::HashMap,
@@ -22,6 +21,7 @@ use std::{
     pin::Pin,
     sync::{
         atomic::{AtomicBool, Ordering},
+        mpsc::{Receiver, Sender},
         Arc,
     },
     task::Poll,
@@ -71,8 +71,8 @@ impl WfContext {
         args: Vec<Payload>,
         am_cancelled: watch::Receiver<bool>,
     ) -> (Self, Receiver<RustWfCmd>) {
-        // We need to use a normal std channel since our receiving side is non-async
-        let (chan, rx) = crossbeam_channel::unbounded();
+        // The receiving side is non-async
+        let (chan, rx) = std::sync::mpsc::channel();
         (
             Self {
                 namespace,
@@ -344,6 +344,11 @@ impl WfContext {
         ))
     }
 
+    /// Buffer a command to be sent in the activation reply
+    pub(crate) fn send(&self, c: RustWfCmd) {
+        self.chan.send(c).expect("command channel intact");
+    }
+
     fn send_signal_wf(
         &self,
         target: sig_we::Target,
@@ -373,10 +378,6 @@ impl WfContext {
     fn cancel(&self, cancellable_id: CancellableID) {
         self.send(RustWfCmd::Cancel(cancellable_id));
     }
-
-    fn send(&self, c: RustWfCmd) {
-        self.chan.send(c).unwrap();
-    }
 }
 
 struct WfCtxProtectedDat {

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

@@ -4,14 +4,14 @@ use crate::{
     WorkflowResult,
 };
 use anyhow::{anyhow, bail, Context as AnyhowContext, Error};
-use crossbeam_channel::Receiver;
-use futures::{future::BoxFuture, FutureExt};
+use futures_util::{future::BoxFuture, FutureExt};
 use std::{
     collections::{hash_map::Entry, HashMap},
     future::Future,
     panic,
     panic::AssertUnwindSafe,
     pin::Pin,
+    sync::mpsc::Receiver,
     task::{Context, Poll},
 };
 use temporal_sdk_core_protos::{
@@ -397,22 +397,27 @@ impl Future for WorkflowFuture {
             // Drive update functions
             self.update_futures = std::mem::take(&mut self.update_futures)
                 .into_iter()
-                .filter_map(|(instance_id, mut update_fut)| {
-                    match update_fut.poll_unpin(cx) {
+                .filter_map(
+                    |(instance_id, mut update_fut)| match update_fut.poll_unpin(cx) {
                         Poll::Ready(v) => {
-                            activation_cmds.push(update_response(
-                                instance_id,
-                                match v {
-                                    Ok(v) => update_response::Response::Completed(v),
-                                    Err(e) => update_response::Response::Rejected(e.into()),
-                                },
-                            ));
-                            // Delete if we're done.
+                            // Push into the command channel here rather than activation_cmds
+                            // directly to avoid completing and update before any final un-awaited
+                            // commands started from within it.
+                            self.wf_ctx.send(
+                                update_response(
+                                    instance_id,
+                                    match v {
+                                        Ok(v) => update_response::Response::Completed(v),
+                                        Err(e) => update_response::Response::Rejected(e.into()),
+                                    },
+                                )
+                                .into(),
+                            );
                             None
                         }
                         Poll::Pending => Some((instance_id, update_fut)),
-                    }
-                })
+                    },
+                )
                 .collect();
 
             if self.poll_wf_future(cx, &run_id, &mut activation_cmds)? {

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

@@ -19,6 +19,7 @@ anyhow = "1.0"
 base64 = "0.22"
 derive_more = { workspace = true }
 prost = { workspace = true }
+prost-types = { workspace = true }
 prost-wkt = "0.6"
 prost-wkt-types = "0.6"
 rand = { version = "0.8", optional = true }
@@ -30,6 +31,7 @@ uuid = { version = "1.1", features = ["v4"], optional = true }
 
 [build-dependencies]
 tonic-build = { workspace = true }
+prost-build = "0.13"
 prost-wkt-build = "0.6"
 
 [lints]

package/sdk-core/sdk-core-protos/build.rs

@@ -112,8 +112,13 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             ".google.protobuf.Value",
             "::prost_wkt_types::Value"
         )
+        .extern_path(
+            ".google.protobuf.FieldMask",
+            "::prost_wkt_types::FieldMask"
+        )
         .file_descriptor_set_path(descriptor_file)
-        .compile(
+        .skip_debug("temporal.api.common.v1.Payload")
+        .compile_protos(
             &[
                 "./protos/local/temporal/sdk/core/core_interface.proto",
                 "./protos/api_upstream/temporal/api/workflowservice/v1/service.proto",

package/sdk-core/sdk-core-protos/protos/api_upstream/buf.yaml

@@ -1,6 +1,7 @@
 version: v1
 deps:
   - buf.build/grpc-ecosystem/grpc-gateway
+  - buf.build/googleapis/googleapis
 build:
   excludes:
     # Buf won't accept a local dependency on the google protos but we need them