@temporalio/core-bridge 1.15.0 → 1.16.1

package/sdk-core/crates/sdk-core/src/worker/workflow/run_cache.rs

@@ -1,5 +1,5 @@
 use crate::{
-    MetricsContext,
+    MetricsContext, WorkerConfig,
     telemetry::metrics::workflow_type,
     worker::workflow::{
         HistoryUpdate, LocalActivityRequestSink, PermittedWFT, RequestEvictMsg, RunBasics,
@@ -8,12 +8,9 @@ use crate::{
 };
 use lru::LruCache;
 use std::{num::NonZeroUsize, rc::Rc, sync::Arc};
-use temporalio_common::{
-    protos::{
-        coresdk::workflow_activation::remove_from_cache::EvictionReason,
-        temporal::api::workflowservice::v1::get_system_info_response,
-    },
-    worker::WorkerConfig,
+use temporalio_common::protos::{
+    coresdk::workflow_activation::remove_from_cache::EvictionReason,
+    temporal::api::workflowservice::v1::get_system_info_response,
 };
 
 pub(super) struct RunCache {

package/sdk-core/crates/sdk-core/src/worker/workflow/wft_extraction.rs

@@ -2,6 +2,7 @@ use crate::{
     abstractions::OwnedMeteredSemPermit,
     protosext::ValidPollWFTQResponse,
     worker::{
+        WorkflowSlotKind,
         client::WorkerClient,
         workflow::{
             CacheMissFetchReq, HistoryUpdate, NextPageReq, PermittedWFT,
@@ -11,10 +12,7 @@ use crate::{
 };
 use futures_util::{FutureExt, Stream, StreamExt, stream, stream::PollNext};
 use std::{future, sync::Arc};
-use temporalio_common::{
-    protos::{TaskToken, coresdk::WorkflowSlotInfo},
-    worker::WorkflowSlotKind,
-};
+use temporalio_common::protos::{TaskToken, coresdk::WorkflowSlotInfo};
 use tracing::Span;
 
 /// Transforms incoming validated WFTs and history fetching requests into [PermittedWFT]s ready

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

@@ -1,21 +1,18 @@
 use crate::{
-    MetricsContext,
+    MetricsContext, WorkerConfig,
     abstractions::{MeteredPermitDealer, OwnedMeteredSemPermit},
     pollers::{BoxedWFPoller, LongPollBuffer, Poller, WorkflowTaskOptions, WorkflowTaskPoller},
     protosext::ValidPollWFTQResponse,
     telemetry::metrics::{workflow_poller, workflow_sticky_poller},
-    worker::{client::WorkerClient, wft_poller_behavior},
+    worker::{WorkflowSlotKind, client::WorkerClient, wft_poller_behavior},
 };
 use crossbeam_utils::atomic::AtomicCell;
 use futures_util::{Stream, stream};
 use std::{
-    sync::{Arc, OnceLock},
+    sync::{Arc, OnceLock, atomic::AtomicBool},
     time::SystemTime,
 };
-use temporalio_common::{
-    protos::temporal::api::workflowservice::v1::PollWorkflowTaskQueueResponse,
-    worker::{WorkerConfig, WorkflowSlotKind},
-};
+use temporalio_common::protos::temporal::api::workflowservice::v1::PollWorkflowTaskQueueResponse;
 use tokio::sync::watch;
 use tokio_util::sync::CancellationToken;
 
@@ -29,6 +26,7 @@ pub(crate) fn make_wft_poller(
     wft_slots: &MeteredPermitDealer<WorkflowSlotKind>,
     last_successful_poll_time: Arc<AtomicCell<Option<SystemTime>>>,
     sticky_last_successful_poll_time: Arc<AtomicCell<Option<SystemTime>>>,
+    graceful_poll_shutdown: Arc<AtomicBool>,
 ) -> impl Stream<
     Item = Result<
         (
@@ -62,6 +60,7 @@ pub(crate) fn make_wft_poller(
             wft_poller_shared: wft_poller_shared.clone(),
         },
         last_successful_poll_time,
+        graceful_poll_shutdown.clone(),
     );
     let sticky_queue_poller = sticky_queue_name.as_ref().map(|sqn| {
         let sticky_metrics = metrics.with_new_attrs([workflow_sticky_poller()]);
@@ -77,6 +76,7 @@ pub(crate) fn make_wft_poller(
             }),
             WorkflowTaskOptions { wft_poller_shared },
             sticky_last_successful_poll_time,
+            graceful_poll_shutdown,
         )
     });
     let wf_task_poll_buffer = Box::new(WorkflowTaskPoller::new(
@@ -258,11 +258,10 @@ mod tests {
     use super::*;
     use crate::{
         abstractions::tests::fixed_size_permit_dealer, pollers::MockPermittedPollBuffer,
-        test_help::mock_poller,
+        test_help::mock_poller, worker::WorkflowSlotKind,
     };
     use futures_util::{StreamExt, pin_mut};
     use std::sync::Arc;
-    use temporalio_common::worker::WorkflowSlotKind;
 
     #[tokio::test]
     async fn poll_timeouts_do_not_produce_responses() {

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

@@ -10,9 +10,7 @@ use crate::{
 };
 use futures_util::{Stream, StreamExt, stream, stream::PollNext};
 use std::{collections::VecDeque, fmt::Debug, future, sync::Arc};
-use temporalio_common::{
-    errors::PollError, protos::coresdk::workflow_activation::remove_from_cache::EvictionReason,
-};
+use temporalio_common::protos::coresdk::workflow_activation::remove_from_cache::EvictionReason;
 use tokio_util::sync::CancellationToken;
 use tracing::{Level, Span};
 

package/sdk-core/crates/sdk-core/tests/activities_procmacro.rs

@@ -0,0 +1,6 @@
+#[test]
+fn activities_procmacro_build_tests() {
+    let t = trybuild::TestCases::new();
+    t.pass("tests/activities_trybuild/*_pass.rs");
+    t.compile_fail("tests/activities_trybuild/*_fail.rs");
+}

package/sdk-core/crates/sdk-core/tests/activities_trybuild/basic_pass.rs

@@ -0,0 +1,54 @@
+use std::sync::Arc;
+use temporalio_macros::activities;
+use temporalio_sdk::activities::{ActivityContext, ActivityError};
+
+pub struct MyActivities;
+
+#[activities]
+impl MyActivities {
+    #[activity]
+    pub async fn static_activity(
+        _ctx: ActivityContext,
+        _in: String,
+    ) -> Result<String, ActivityError> {
+        Ok("Can be static".to_string())
+    }
+
+    #[activity]
+    pub async fn activity(
+        self: Arc<Self>,
+        _ctx: ActivityContext,
+        _in: bool,
+    ) -> Result<String, ActivityError> {
+        Ok("I'm done!".to_string())
+    }
+
+    #[activity]
+    pub async fn activity_arc_fully_qualified(
+        self: std::sync::Arc<Self>,
+        _ctx: ActivityContext,
+        _in: bool,
+    ) -> Result<String, ActivityError> {
+        Ok("I'm done!".to_string())
+    }
+
+    #[activity]
+    pub fn sync_activity(_ctx: ActivityContext, _in: bool) -> Result<String, ActivityError> {
+        Ok("Sync activities are supported too".to_string())
+    }
+}
+
+pub struct MyActivitiesStatic;
+
+#[activities]
+impl MyActivitiesStatic {
+    #[activity]
+    pub async fn static_activity(
+        _ctx: ActivityContext,
+        _in: String,
+    ) -> Result<String, ActivityError> {
+        Ok("Can be static".to_string())
+    }
+}
+
+fn main() {}

package/sdk-core/crates/sdk-core/tests/activities_trybuild/invalid_self_type_fail.rs

@@ -0,0 +1,18 @@
+use temporalio_macros::activities;
+
+pub struct BadActivities;
+
+#[activities]
+impl BadActivities {
+    #[activity]
+    pub async fn no_context(
+        &self,
+        _ctx: ActivityContext,
+        _in: String,
+    ) -> Result<String, ActivityError> {
+        // This should fail because the self type is invalid.
+        Ok("bad".to_string())
+    }
+}
+
+fn main() {}

package/sdk-core/crates/sdk-core/tests/activities_trybuild/invalid_self_type_fail.stderr

@@ -0,0 +1,5 @@
+error: Activity methods with instance state must use `self: Arc<Self>` as the receiver, not `self`, `&self`, or `&mut self`
+ --> tests/activities_trybuild/invalid_self_type_fail.rs:9:9
+  |
+9 |         &self,
+  |         ^^^^^

package/sdk-core/crates/sdk-core/tests/activities_trybuild/missing_context_fail.rs

@@ -0,0 +1,14 @@
+use temporalio_macros::activities;
+
+pub struct BadActivities;
+
+#[activities]
+impl BadActivities {
+    #[activity]
+    pub async fn no_context(_in: String) -> Result<String, ActivityError> {
+        // This should fail because there's no ActivityContext parameter
+        Ok("bad".to_string())
+    }
+}
+
+fn main() {}

package/sdk-core/crates/sdk-core/tests/activities_trybuild/missing_context_fail.stderr

@@ -0,0 +1,5 @@
+error: Activity functions must have an ActivityContext parameter as either the first parameter, or the second after `self: Arc<Self>`.
+ --> tests/activities_trybuild/missing_context_fail.rs:8:29
+  |
+8 |     pub async fn no_context(_in: String) -> Result<String, ActivityError> {
+  |                             ^^^

package/sdk-core/crates/sdk-core/tests/activities_trybuild/multi_arg_pass.rs

@@ -0,0 +1,48 @@
+use std::sync::Arc;
+use temporalio_macros::activities;
+use temporalio_sdk::activities::{ActivityContext, ActivityError};
+
+pub struct MultiArgActivities;
+
+#[activities]
+impl MultiArgActivities {
+    #[activity]
+    pub async fn two_args(
+        _ctx: ActivityContext,
+        _a: String,
+        _b: i32,
+    ) -> Result<String, ActivityError> {
+        Ok("done".to_string())
+    }
+
+    #[activity]
+    pub async fn three_args(
+        _ctx: ActivityContext,
+        _a: String,
+        _b: i32,
+        _c: bool,
+    ) -> Result<String, ActivityError> {
+        Ok("done".to_string())
+    }
+
+    #[activity]
+    pub async fn instance_two_args(
+        self: Arc<Self>,
+        _ctx: ActivityContext,
+        _a: String,
+        _b: i32,
+    ) -> Result<String, ActivityError> {
+        Ok("done".to_string())
+    }
+
+    #[activity]
+    pub fn sync_two_args(
+        _ctx: ActivityContext,
+        _a: String,
+        _b: i32,
+    ) -> Result<String, ActivityError> {
+        Ok("done".to_string())
+    }
+}
+
+fn main() {}

package/sdk-core/crates/sdk-core/tests/activities_trybuild/no_input_pass.rs

@@ -0,0 +1,14 @@
+use temporalio_macros::activities;
+use temporalio_sdk::activities::{ActivityContext, ActivityError};
+
+pub struct SimpleActivities;
+
+#[activities]
+impl SimpleActivities {
+    #[activity]
+    pub async fn no_input_activity(_ctx: ActivityContext) -> Result<String, ActivityError> {
+        Ok("No input needed".to_string())
+    }
+}
+
+fn main() {}

package/sdk-core/crates/sdk-core/tests/activities_trybuild/no_return_type_pass.rs

@@ -0,0 +1,19 @@
+use temporalio_macros::activities;
+use temporalio_sdk::activities::ActivityContext;
+
+pub struct VoidActivities;
+
+#[activities]
+impl VoidActivities {
+    #[activity]
+    pub async fn no_return(_ctx: ActivityContext, _in: String) {
+        println!("Doing work...");
+    }
+
+    #[activity]
+    pub fn sync_no_return(_ctx: ActivityContext) {
+        println!("Sync work...");
+    }
+}
+
+fn main() {}

package/sdk-core/crates/sdk-core/tests/cloud_tests.rs

@@ -4,14 +4,23 @@ mod common;
 mod shared_tests;
 
 use common::get_cloud_client;
-use temporalio_client::WorkflowClientTrait;
+use temporalio_client::{NamespacedClient, grpc::WorkflowService};
+use temporalio_common::protos::temporal::api::workflowservice::v1::ListWorkflowExecutionsRequest;
+use tonic::IntoRequest;
 
 #[tokio::test]
 async fn tls_test() {
-    let con = get_cloud_client().await;
-    con.list_workflow_executions(100, vec![], "".to_string())
-        .await
-        .unwrap();
+    let mut con = get_cloud_client().await;
+    con.list_workflow_executions(
+        ListWorkflowExecutionsRequest {
+            namespace: con.namespace(),
+            page_size: 100,
+            ..Default::default()
+        }
+        .into_request(),
+    )
+    .await
+    .unwrap();
 }
 
 #[tokio::test]

package/sdk-core/crates/sdk-core/tests/common/activity_functions.rs

@@ -0,0 +1,55 @@
+use std::time::Duration;
+use temporalio_common::{data_converters::RawValue, protos::DEFAULT_ACTIVITY_TYPE};
+use temporalio_macros::activities;
+use temporalio_sdk::activities::{ActivityContext, ActivityError};
+use tokio::time::sleep;
+
+pub(crate) struct StdActivities;
+
+#[activities]
+impl StdActivities {
+    #[activity]
+    pub(crate) async fn echo(_ctx: ActivityContext, e: String) -> Result<String, ActivityError> {
+        Ok(e)
+    }
+
+    /// Activity that does nothing and returns success
+    #[activity]
+    pub(crate) async fn no_op(_ctx: ActivityContext, _: ()) -> Result<(), ActivityError> {
+        Ok(())
+    }
+
+    /// Also a no-op, but uses the default name from history construction to work with
+    /// canned histories. Returns RawValue so anything in the canned history will "deserialize"
+    /// properly.
+    #[activity(name = DEFAULT_ACTIVITY_TYPE)]
+    pub(crate) async fn default(_ctx: ActivityContext, _: ()) -> Result<RawValue, ActivityError> {
+        Ok(RawValue::empty())
+    }
+
+    /// Activity that sleeps for provided duration. Name is overriden to provide compatibility with
+    /// some canned histories.
+    #[activity(name = "delay")]
+    pub(crate) async fn delay(
+        _ctx: ActivityContext,
+        duration: Duration,
+    ) -> Result<(), ActivityError> {
+        sleep(duration).await;
+        Ok(())
+    }
+
+    /// Always fails
+    #[activity]
+    pub(crate) async fn always_fail(_ctx: ActivityContext) -> Result<(), ActivityError> {
+        Err(anyhow::anyhow!("Oh no I failed!").into())
+    }
+
+    #[activity]
+    pub(crate) async fn concat(
+        _ctx: ActivityContext,
+        a: String,
+        b: String,
+    ) -> Result<String, ActivityError> {
+        Ok(format!("{a}{b}"))
+    }
+}