@temporalio/core-bridge 1.9.2 → 1.10.0

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

@@ -1,11 +1,15 @@
-use std::time::Duration;
-use tokio::sync::mpsc::UnboundedSender;
+use crate::{errors::WorkflowErrorType, telemetry::metrics::TemporalMeter};
+use std::{
+    any::Any,
+    collections::{HashMap, HashSet},
+    sync::Arc,
+    time::Duration,
+};
 
-const MAX_OUTSTANDING_WFT_DEFAULT: usize = 100;
 const MAX_CONCURRENT_WFT_POLLS_DEFAULT: usize = 5;
 
 /// Defines per-worker configuration options
-#[derive(Debug, Clone, derive_builder::Builder, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, derive_builder::Builder)]
 #[builder(setter(into), build_fn(validate = "Self::validate"))]
 #[non_exhaustive]
 pub struct WorkerConfig {
@@ -29,20 +33,10 @@ pub struct WorkerConfig {
     /// or failures.
     #[builder(default = "0")]
     pub max_cached_workflows: usize,
-    /// The maximum allowed number of workflow tasks that will ever be given to this worker at one
-    /// time. Note that one workflow task may require multiple activations - so the WFT counts as
-    /// "outstanding" until all activations it requires have been completed.
-    ///
-    /// Cannot be larger than `max_cached_workflows`.
-    #[builder(default = "MAX_OUTSTANDING_WFT_DEFAULT")]
-    pub max_outstanding_workflow_tasks: usize,
-    /// The maximum number of activity tasks that will ever be given to this worker concurrently
-    #[builder(default = "100")]
-    pub max_outstanding_activities: usize,
-    /// The maximum number of local activity tasks that will ever be given to this worker
-    /// concurrently
-    #[builder(default = "100")]
-    pub max_outstanding_local_activities: usize,
+    /// Set a [WorkerTuner] for this worker. Either this or at least one of the `max_outstanding_*`
+    /// fields must be set.
+    #[builder(setter(into = false, strip_option), default)]
+    pub tuner: Option<Arc<dyn WorkerTuner + Send + Sync>>,
     /// Maximum number of concurrent poll workflow task requests we will perform at a time on this
     /// worker's task queue. See also [WorkerConfig::nonsticky_to_sticky_poll_ratio]. Must be at
     /// least 1.
@@ -115,14 +109,6 @@ pub struct WorkerConfig {
     #[builder(default = "5")]
     pub fetching_concurrency: usize,
 
-    // TODO: Move this out - dependency on tokio should not exist just for this
-    /// If set, and the `save_wf_inputs` feature is enabled in core, will be sent a serialized
-    /// instance of every input to workflow state in order. This is for testing purposes, SDK
-    /// implementations never need to care about it.
-    #[builder(default)]
-    #[serde(skip)]
-    pub wf_state_inputs: Option<UnboundedSender<Vec<u8>>>,
-
     /// If set, core will issue cancels for all outstanding activities after shutdown has been
     /// initiated and this amount of time has elapsed.
     #[builder(default)]
@@ -133,6 +119,35 @@ pub struct WorkerConfig {
     /// timeout.
     #[builder(default = "Duration::from_secs(5)")]
     pub local_timeout_buffer_for_activities: Duration,
+
+    /// Any error types listed here will cause any workflow being processed by this worker to fail,
+    /// rather than simply failing the workflow task.
+    #[builder(default)]
+    pub workflow_failure_errors: HashSet<WorkflowErrorType>,
+
+    /// Like [WorkerConfig::workflow_failure_errors], but specific to certain workflow types (the
+    /// map key).
+    #[builder(default)]
+    pub workflow_types_to_failure_errors: HashMap<String, HashSet<WorkflowErrorType>>,
+
+    /// The maximum allowed number of workflow tasks that will ever be given to this worker at one
+    /// time. Note that one workflow task may require multiple activations - so the WFT counts as
+    /// "outstanding" until all activations it requires have been completed.
+    ///
+    /// Mutually exclusive with `tuner`
+    #[builder(setter(into, strip_option), default)]
+    pub max_outstanding_workflow_tasks: Option<usize>,
+    /// The maximum number of activity tasks that will ever be given to this worker concurrently
+    ///
+    /// Mutually exclusive with `tuner`
+    #[builder(setter(into, strip_option), default)]
+    pub max_outstanding_activities: Option<usize>,
+    /// The maximum number of local activity tasks that will ever be given to this worker
+    /// concurrently
+    ///
+    /// Mutually exclusive with `tuner`
+    #[builder(setter(into, strip_option), default)]
+    pub max_outstanding_local_activities: Option<usize>,
 }
 
 impl WorkerConfig {
@@ -145,9 +160,31 @@ impl WorkerConfig {
             .saturating_sub(self.max_nonsticky_polls())
             .max(1)
     }
+    /// Returns true if the configuration specifies we should fail a workflow on a certain error
+    /// type rather than failing the workflow task.
+    pub fn should_fail_workflow(
+        &self,
+        workflow_type: &str,
+        error_type: &WorkflowErrorType,
+    ) -> bool {
+        self.workflow_failure_errors.contains(error_type)
+            || self
+                .workflow_types_to_failure_errors
+                .get(workflow_type)
+                .map(|s| s.contains(error_type))
+                .unwrap_or(false)
+    }
 }
 
 impl WorkerConfigBuilder {
+    /// Unset all `max_outstanding_*` fields
+    pub fn clear_max_outstanding_opts(&mut self) -> &mut Self {
+        self.max_outstanding_workflow_tasks = None;
+        self.max_outstanding_activities = None;
+        self.max_outstanding_local_activities = None;
+        self
+    }
+
     fn validate(&self) -> Result<(), String> {
         if self.max_concurrent_wft_polls == Some(0) {
             return Err("`max_concurrent_wft_polls` must be at least 1".to_owned());
@@ -155,15 +192,7 @@ impl WorkerConfigBuilder {
         if self.max_concurrent_at_polls == Some(0) {
             return Err("`max_concurrent_at_polls` must be at least 1".to_owned());
         }
-        if self.max_cached_workflows > Some(0)
-            && self.max_outstanding_workflow_tasks > self.max_cached_workflows
-        {
-            return Err(
-                "Maximum concurrent workflow tasks cannot exceed the maximum number of cached \
-                 workflows"
-                    .to_owned(),
-            );
-        }
+
         if let Some(Some(ref x)) = self.max_worker_activities_per_second {
             if !x.is_normal() || x.is_sign_negative() {
                 return Err(
@@ -171,30 +200,28 @@ impl WorkerConfigBuilder {
                 );
             }
         }
-        if matches!(self.max_concurrent_wft_polls, Some(1))
-            && self.max_cached_workflows > Some(0)
-            && self
-                .max_outstanding_workflow_tasks
-                .unwrap_or(MAX_OUTSTANDING_WFT_DEFAULT)
-                <= 1
+
+        if self.tuner.is_some()
+            && (self.max_outstanding_workflow_tasks.is_some()
+                || self.max_outstanding_activities.is_some()
+                || self.max_outstanding_local_activities.is_some())
         {
-            return Err(
-                "`max_outstanding_workflow_tasks` must be at at least 2 when \
-                 `max_cached_workflows` is nonzero"
-                    .to_owned(),
-            );
+            return Err("max_outstanding_* fields are mutually exclusive with `tuner`".to_owned());
         }
-        if self
+
+        let max_wft_polls = self
             .max_concurrent_wft_polls
-            .unwrap_or(MAX_CONCURRENT_WFT_POLLS_DEFAULT)
-            > self
-                .max_outstanding_workflow_tasks
-                .unwrap_or(MAX_OUTSTANDING_WFT_DEFAULT)
-        {
-            return Err(
-                "`max_concurrent_wft_polls` cannot exceed `max_outstanding_workflow_tasks`"
-                    .to_owned(),
-            );
+            .unwrap_or(MAX_CONCURRENT_WFT_POLLS_DEFAULT);
+
+        // It wouldn't make any sense to have more outstanding polls than workflows we can possibly
+        // cache. If we allow this at low values it's possible for sticky pollers to reserve all
+        // available slots, crowding out the normal queue and gumming things up.
+        if let Some(max_cache) = self.max_cached_workflows {
+            if max_cache > 0 && max_wft_polls > max_cache {
+                return Err(
+                    "`max_concurrent_wft_polls` cannot exceed `max_cached_workflows`".to_owned(),
+                );
+            }
         }
 
         if self.use_worker_versioning.unwrap_or_default()
@@ -212,3 +239,132 @@ impl WorkerConfigBuilder {
         Ok(())
     }
 }
+
+/// This trait allows users to customize the performance characteristics of workers dynamically.
+/// For more, see the docstrings of the traits in the return types of its functions.
+pub trait WorkerTuner {
+    /// Return a [SlotSupplier] for workflow tasks
+    fn workflow_task_slot_supplier(
+        &self,
+    ) -> Arc<dyn SlotSupplier<SlotKind = WorkflowSlotKind> + Send + Sync>;
+
+    /// Return a [SlotSupplier] for activity tasks
+    fn activity_task_slot_supplier(
+        &self,
+    ) -> Arc<dyn SlotSupplier<SlotKind = ActivitySlotKind> + Send + Sync>;
+
+    /// Return a [SlotSupplier] for local activities
+    fn local_activity_slot_supplier(
+        &self,
+    ) -> Arc<dyn SlotSupplier<SlotKind = LocalActivitySlotKind> + Send + Sync>;
+
+    /// Core will call this at worker initialization time, allowing the implementation to hook up to
+    /// metrics if any are configured. If not, it will not be called.
+    fn attach_metrics(&self, metrics: TemporalMeter);
+}
+
+/// Implementing this trait allows users to customize how many tasks of certain kinds the worker
+/// will perform concurrently.
+///
+/// Note that, for implementations on workflow tasks ([WorkflowSlotKind]), workers that have the
+/// workflow cache enabled should be willing to hand out _at least_ two slots, to avoid the worker
+/// becoming stuck only polling on the worker's sticky queue.
+#[async_trait::async_trait]
+pub trait SlotSupplier {
+    type SlotKind: SlotKind;
+    /// 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
+    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
+    /// pollers need to reserve a slot before they have actually obtained work from server. Once
+    /// that task is obtained (and validated) then the slot can actually be used to work on the
+    /// task.
+    ///
+    /// 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<'_>);
+
+    /// Frees a slot.
+    fn release_slot(&self);
+
+    /// If this implementation knows how many slots are available at any moment, it should return
+    /// that here.
+    fn available_slots(&self) -> Option<usize> {
+        None
+    }
+}
+
+pub trait SlotReservationContext: Send + Sync {
+    /// Returns the number of currently outstanding slot permits, whether used or un-used.
+    fn num_issued_slots(&self) -> usize;
+}
+
+#[derive(Default)]
+pub struct SlotSupplierPermit {
+    user_data: Option<Box<dyn Any + Send + Sync>>,
+}
+impl SlotSupplierPermit {
+    pub fn with_user_data<T: Any + Send + Sync>(user_data: T) -> Self {
+        Self {
+            user_data: Some(Box::new(user_data)),
+        }
+    }
+    /// Attempts to downcast the inner data, if any, into the provided type and returns it.
+    /// Returns none if there is no data or the data is not of the appropriate type.
+    pub fn user_data<T: Any + Send + Sync>(&self) -> Option<&T> {
+        self.user_data.as_ref().and_then(|b| b.downcast_ref())
+    }
+    /// Attempts to downcast the inner data, if any, into the provided type and returns it mutably.
+    /// Returns none if there is no data or the data is not of the appropriate type.
+    pub fn user_data_mut<T: Any + Send + Sync>(&mut self) -> Option<&mut T> {
+        self.user_data.as_mut().and_then(|b| b.downcast_mut())
+    }
+}
+
+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)]
+pub struct WorkflowSlotKind {}
+#[derive(Debug)]
+pub struct ActivitySlotKind {}
+#[derive(Debug)]
+pub struct LocalActivitySlotKind {}
+pub trait SlotKind {
+    type Info<'a>;
+    fn kind_name() -> &'static str;
+}
+impl SlotKind for WorkflowSlotKind {
+    type Info<'a> = WorkflowSlotInfo<'a>;
+
+    fn kind_name() -> &'static str {
+        "workflow"
+    }
+}
+impl SlotKind for ActivitySlotKind {
+    type Info<'a> = ActivitySlotInfo<'a>;
+    fn kind_name() -> &'static str {
+        "activity"
+    }
+}
+impl SlotKind for LocalActivitySlotKind {
+    type Info<'a> = LocalActivitySlotInfo<'a>;
+    fn kind_name() -> &'static str {
+        "local_activity"
+    }
+}

package/sdk-core/fsm/Cargo.toml

@@ -16,3 +16,6 @@ rustfsm_trait = { version = "0.1", path = "rustfsm_trait" }
 
 [package.metadata.workspaces]
 independent = true
+
+[lints]
+workspace = true

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`
+   |     ^^^ the trait `From<Two>` is not implemented for `One`, which is required by `Two: Into<One>`
    |
    = note: required for `Two` to implement `Into<One>`
 note: required by a bound in `TransitionResult::<Sm, Ds>::from`

package/sdk-core/sdk/Cargo.toml

@@ -10,30 +10,25 @@ repository = "https://github.com/temporalio/sdk-core"
 keywords = ["temporal", "workflow"]
 categories = ["development-tools"]
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
 async-trait = "0.1"
 thiserror = "1.0"
 anyhow = "1.0"
-base64 = "0.21"
 crossbeam-channel = "0.5"
 derive_more = { workspace = true }
 futures = "0.3"
-once_cell = "1.10"
 parking_lot = { version = "0.12", features = ["send_guard"] }
-prost-types = { version = "0.4", package = "prost-wkt-types" }
-sha2 = "0.10"
+prost-types = { version = "0.5", package = "prost-wkt-types" }
 serde = "1.0"
 tokio = { version = "1.26", features = ["rt", "rt-multi-thread", "parking_lot", "time", "fs"] }
 tokio-util = { version = "0.7" }
 tokio-stream = "0.1"
-tonic = { workspace = true }
 tracing = "0.1"
 
 [dependencies.temporal-sdk-core]
 path = "../core"
 version = "0.1"
+default-features = false
 
 [dependencies.temporal-sdk-core-protos]
 path = "../sdk-core-protos"
@@ -46,3 +41,6 @@ version = "0.1"
 [dependencies.temporal-client]
 path = "../client"
 version = "0.1"
+
+[lints]
+workspace = true

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

@@ -6,20 +6,20 @@ use std::{
 
 /// A Wrapper Type for workflow and activity app data
 #[derive(Default)]
-pub struct AppData {
+pub(crate) struct AppData {
     map: HashMap<TypeId, Box<dyn Any + Send + Sync>>,
 }
 
 impl AppData {
     /// Insert an item, overwritting duplicates
-    pub fn insert<T: Send + Sync + 'static>(&mut self, val: T) -> Option<T> {
+    pub(crate) fn insert<T: Send + Sync + 'static>(&mut self, val: T) -> Option<T> {
         self.map
             .insert(TypeId::of::<T>(), Box::new(val))
             .and_then(downcast_owned)
     }
 
     /// Get a reference to a type in the map
-    pub fn get<T: 'static>(&self) -> Option<&T> {
+    pub(crate) fn get<T: 'static>(&self) -> Option<&T> {
         self.map
             .get(&TypeId::of::<T>())
             .and_then(|boxed| boxed.downcast_ref())

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

@@ -17,7 +17,7 @@
 //! async fn main() -> Result<(), Box<dyn std::error::Error>> {
 //!     let server_options = sdk_client_options(Url::from_str("http://localhost:7233")?).build()?;
 //!
-//!     let client = server_options.connect("default", None, None).await?;
+//!     let client = server_options.connect("default", None).await?;
 //!
 //!     let telemetry_options = TelemetryOptionsBuilder::default().build()?;
 //!     let runtime = CoreRuntime::new_assume_tokio(telemetry_options)?;
@@ -48,7 +48,6 @@ extern crate tracing;
 mod activity_context;
 mod app_data;
 pub mod interceptors;
-mod payload_converter;
 mod workflow_context;
 mod workflow_future;
 
@@ -521,7 +520,10 @@ impl ActivityHalf {
                 });
             }
             Some(activity_task::Variant::Cancel(_)) => {
-                if let Some(ct) = self.task_tokens_to_cancels.get(&activity.task_token.into()) {
+                if let Some(ct) = self
+                    .task_tokens_to_cancels
+                    .get(activity.task_token.as_slice())
+                {
                     ct.cancel();
                 }
             }

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

@@ -17,7 +17,7 @@ use temporal_sdk_core_protos::{
 
 // TODO: Before release, probably best to avoid using proto types entirely here. They're awkward.
 
-pub trait IntoWorkflowCommand {
+pub(crate) trait IntoWorkflowCommand {
     type WFCommandType;
 
     /// Produces a workflow command from some options

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

@@ -98,11 +98,11 @@ impl WfCtxProtectedDat {
 #[derive(Clone, Debug, Default)]
 pub(crate) struct WfContextSharedData {
     /// Maps change ids -> resolved status
-    pub changes: HashMap<String, bool>,
-    pub is_replaying: bool,
-    pub wf_time: Option<SystemTime>,
-    pub history_length: u32,
-    pub current_build_id: Option<String>,
+    pub(crate) changes: HashMap<String, bool>,
+    pub(crate) is_replaying: bool,
+    pub(crate) wf_time: Option<SystemTime>,
+    pub(crate) history_length: u32,
+    pub(crate) current_build_id: Option<String>,
 }
 
 // TODO: Dataconverter type interface to replace Payloads here. Possibly just use serde
@@ -204,7 +204,7 @@ impl WfContext {
         mut opts: ActivityOptions,
     ) -> impl CancellableFuture<ActivityResolution> {
         if opts.task_queue.is_empty() {
-            opts.task_queue = self.task_queue.clone()
+            opts.task_queue.clone_from(&self.task_queue);
         }
         let seq = self.seq_nums.write().next_activity_seq();
         let (cmd, unblocker) = CancellableWFCommandFut::new(CancellableID::Activity(seq));
@@ -573,7 +573,8 @@ impl<'a> Future for LATimerBackoffFut<'a> {
                     if let TimerResult::Fired = tr {
                         let mut opts = self.la_opts.clone();
                         opts.attempt = Some(self.next_attempt);
-                        opts.original_schedule_time = self.next_sched_time.clone();
+                        opts.original_schedule_time
+                            .clone_from(&self.next_sched_time);
                         self.current_fut = Box::pin(self.ctx.local_activity_no_timer_retry(opts));
                         Poll::Pending
                     } else {
@@ -608,7 +609,7 @@ impl<'a> Future for LATimerBackoffFut<'a> {
                 );
                 self.timer_fut = Some(Box::pin(timer_f));
                 self.next_attempt = b.attempt;
-                self.next_sched_time = b.original_schedule_time.clone();
+                self.next_sched_time.clone_from(&b.original_schedule_time);
                 return Poll::Pending;
             }
         }
@@ -631,7 +632,7 @@ pub struct ChildWorkflow {
     opts: ChildWorkflowOptions,
 }
 
-pub struct ChildWfCommon {
+pub(crate) struct ChildWfCommon {
     workflow_id: String,
     result_future: CancellableWFCommandFut<ChildWorkflowResult, ()>,
 }

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

@@ -93,7 +93,7 @@ enum SigChanOrBuffer {
     Buffer(Vec<SignalData>),
 }
 
-pub struct WorkflowFuture {
+pub(crate) struct WorkflowFuture {
     /// Future produced by calling the workflow function
     inner: BoxFuture<'static, WorkflowResult<Payload>>,
     /// Commands produced inside user's wf code

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

@@ -12,15 +12,14 @@ categories = ["development-tools"]
 
 [features]
 history_builders = ["uuid", "rand"]
-serde_serialize = []
 
 [dependencies]
 anyhow = "1.0"
-base64 = "0.21"
+base64 = "0.22"
 derive_more = { workspace = true }
-prost = "0.11"
-prost-wkt = "0.4"
-prost-wkt-types = "0.4"
+prost = { workspace = true }
+prost-wkt = "0.5"
+prost-wkt-types = "0.5"
 rand = { version = "0.8", optional = true }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
@@ -30,4 +29,7 @@ uuid = { version = "1.1", features = ["v4"], optional = true }
 
 [build-dependencies]
 tonic-build = { workspace = true }
-prost-wkt-build = "0.4"
+prost-wkt-build = "0.5"
+
+[lints]
+workspace = true

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

@@ -112,7 +112,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             ".google.protobuf.Value",
             "::prost_wkt_types::Value"
         )
-        .file_descriptor_set_path(#[allow(clippy::needless_borrow)] &descriptor_file)
+        .file_descriptor_set_path(descriptor_file)
         .compile(
             &[
                 "./protos/local/temporal/sdk/core/core_interface.proto",
@@ -129,14 +129,5 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             ],
         )?;
 
-    #[cfg(feature = "serde_serialize")]
-    {
-        use prost_wkt_build::{FileDescriptorSet, Message};
-
-        let descriptor_bytes = std::fs::read(descriptor_file)?;
-        let descriptor = FileDescriptorSet::decode(&descriptor_bytes[..])?;
-        prost_wkt_build::add_serde(out, descriptor);
-    }
-
     Ok(())
 }

package/sdk-core/sdk-core-protos/protos/api_upstream/.github/PULL_REQUEST_TEMPLATE.md

@@ -9,3 +9,6 @@
 <!-- Are there any breaking changes on binary or code level? -->
 **Breaking changes**
 
+
+<!-- If this breaks the Server, please provide the Server PR to merge right after this PR was merged. -->
+**Server PR**

package/sdk-core/sdk-core-protos/protos/api_upstream/.github/workflows/ci.yml

@@ -0,0 +1,26 @@
+name: ci
+on:
+  pull_request:
+permissions:
+  contents: read
+jobs:
+  ci:
+    name: ci
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v4
+        with:
+          go-version: '^1.21'
+      - uses: arduino/setup-protoc@v2
+      - name: 'Setup jq'
+        uses: dcarbone/install-jq-action@v2
+      - run: make ci-build
+      - name: Fail if the repo is dirty
+        run: |
+          if [[ -n $(git status --porcelain) ]]; then
+            echo "Detected uncommitted changes."
+            git status
+            git diff
+            exit 1
+          fi