@temporalio/core-bridge 1.7.4 → 1.8.1

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

@@ -3,9 +3,8 @@ mod activity_task_poller_stream;
 mod local_activities;
 
 pub(crate) use local_activities::{
-    DispatchOrTimeoutLA, ExecutingLAId, LACompleteAction, LocalActRequest,
-    LocalActivityExecutionResult, LocalActivityManager, LocalActivityResolution,
-    LocalInFlightActInfo, NewLocalAct,
+    ExecutingLAId, LACompleteAction, LocalActRequest, LocalActivityExecutionResult,
+    LocalActivityManager, LocalActivityResolution, NewLocalAct, NextPendingLAAction,
 };
 
 use crate::{
@@ -14,9 +13,7 @@ use crate::{
         TrackedOwnedMeteredSemPermit, UsedMeteredSemPermit,
     },
     pollers::BoxedActPoller,
-    telemetry::metrics::{
-        activity_type, activity_worker_type, eager, workflow_type, MetricsContext,
-    },
+    telemetry::metrics::{activity_type, eager, workflow_type, MetricsContext},
     worker::{
         activities::{
             activity_heartbeat_manager::ActivityHeartbeatError,
@@ -33,7 +30,6 @@ use futures::{
     stream::{BoxStream, PollNext},
     Stream, StreamExt,
 };
-use governor::{Quota, RateLimiter};
 use std::{
     convert::TryInto,
     future,
@@ -158,8 +154,7 @@ enum ActivityTaskSource {
 impl WorkerActivityTasks {
     #[allow(clippy::too_many_arguments)]
     pub(crate) fn new(
-        max_activity_tasks: usize,
-        max_worker_act_per_sec: Option<f64>,
+        semaphore: Arc<MeteredSemaphore>,
         poller: BoxedActPoller,
         client: Arc<dyn WorkerClient>,
         metrics: MetricsContext,
@@ -167,23 +162,10 @@ impl WorkerActivityTasks {
         default_heartbeat_throttle_interval: Duration,
         graceful_shutdown: Option<Duration>,
     ) -> Self {
-        let semaphore = Arc::new(MeteredSemaphore::new(
-            max_activity_tasks,
-            metrics.with_new_attrs([activity_worker_type()]),
-            MetricsContext::available_task_slots,
-        ));
         let shutdown_initiated_token = CancellationToken::new();
-        let rate_limiter = max_worker_act_per_sec.and_then(|ps| {
-            Quota::with_period(Duration::from_secs_f64(ps.recip())).map(RateLimiter::direct)
-        });
         let outstanding_activity_tasks = Arc::new(DashMap::new());
-        let server_poller_stream = new_activity_task_poller(
-            poller,
-            semaphore.clone(),
-            rate_limiter,
-            metrics.clone(),
-            shutdown_initiated_token.clone(),
-        );
+        let server_poller_stream =
+            new_activity_task_poller(poller, metrics.clone(), shutdown_initiated_token.clone());
         let (eager_activities_tx, eager_activities_rx) = unbounded_channel();
         let eager_activities_semaphore = ClosableMeteredSemaphore::new_arc(semaphore);
 
@@ -430,7 +412,7 @@ impl WorkerActivityTasks {
 
     #[cfg(test)]
     pub(crate) fn remaining_activity_capacity(&self) -> usize {
-        self.eager_activities_semaphore.available_permits()
+        self.eager_activities_semaphore.unused_permits()
     }
 }
 
@@ -625,42 +607,85 @@ fn worker_shutdown_failure() -> Failure {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
-        test_help::mock_poller_from_resps, worker::client::mocks::mock_manual_workflow_client,
-    };
+    use crate::{pollers::new_activity_task_buffer, worker::client::mocks::mock_workflow_client};
+    use temporal_sdk_core_protos::coresdk::activity_result::ActivityExecutionResult;
 
     #[tokio::test]
     async fn per_worker_ratelimit() {
-        let poller = mock_poller_from_resps([
-            PollActivityTaskQueueResponse {
-                task_token: vec![1],
-                activity_id: "act1".to_string(),
-                ..Default::default()
-            }
-            .into(),
-            PollActivityTaskQueueResponse {
-                task_token: vec![2],
-                activity_id: "act2".to_string(),
-                ..Default::default()
-            }
-            .into(),
-        ]);
-        let atm = WorkerActivityTasks::new(
+        let mut mock_client = mock_workflow_client();
+        mock_client
+            .expect_poll_activity_task()
+            .times(1)
+            .returning(move |_, _| {
+                Ok(PollActivityTaskQueueResponse {
+                    task_token: vec![1],
+                    activity_id: "act1".to_string(),
+                    ..Default::default()
+                })
+            });
+        mock_client
+            .expect_poll_activity_task()
+            .times(1)
+            .returning(move |_, _| {
+                Ok(PollActivityTaskQueueResponse {
+                    task_token: vec![2],
+                    activity_id: "act2".to_string(),
+                    ..Default::default()
+                })
+            });
+        mock_client
+            .expect_complete_activity_task()
+            .times(2)
+            .returning(|_, _| Ok(Default::default()));
+        let mock_client = Arc::new(mock_client);
+        let sem = Arc::new(MeteredSemaphore::new(
             10,
+            MetricsContext::no_op(),
+            MetricsContext::available_task_slots,
+        ));
+        let shutdown_token = CancellationToken::new();
+        let ap = new_activity_task_buffer(
+            mock_client.clone(),
+            "tq".to_string(),
+            5, // Lots of concurrent pollers, to ensure we don't poll to much when that's the case
+            sem.clone(),
+            None,
+            shutdown_token.clone(),
+            None::<fn(usize)>,
             Some(2.0),
-            poller,
-            Arc::new(mock_manual_workflow_client()),
+        );
+        let atm = WorkerActivityTasks::new(
+            sem.clone(),
+            Box::new(ap),
+            mock_client.clone(),
             MetricsContext::no_op(),
             Duration::from_secs(1),
             Duration::from_secs(1),
             None,
         );
         let start = Instant::now();
-        atm.poll().await.unwrap();
-        atm.poll().await.unwrap();
+        let t1 = atm.poll().await.unwrap();
+        let t2 = atm.poll().await.unwrap();
         // At least half a second will have elapsed since we only allow 2 tasks per second.
         // With no ratelimit, even on a slow CI server with lots of load, this would typically take
         // low single digit ms or less.
         assert!(start.elapsed() > Duration::from_secs_f64(0.5));
+        shutdown_token.cancel();
+        // Need to complete the tasks so shutdown will resolve
+        atm.complete(
+            TaskToken(t1.task_token),
+            ActivityExecutionResult::ok(vec![1].into()).status.unwrap(),
+            mock_client.as_ref(),
+        )
+        .await;
+        atm.complete(
+            TaskToken(t2.task_token),
+            ActivityExecutionResult::ok(vec![1].into()).status.unwrap(),
+            mock_client.as_ref(),
+        )
+        .await;
+        atm.initiate_shutdown();
+        assert_matches!(atm.poll().await.unwrap_err(), PollActivityError::ShutDown);
+        atm.shutdown().await;
     }
 }

package/sdk-core/core/src/worker/client/mocks.rs

@@ -37,7 +37,7 @@ mockall::mock! {
     pub(crate) ManualWorkerClient {}
     #[allow(unused)]
     impl WorkerClient for ManualWorkerClient {
-        fn poll_workflow_task<'a, 'b>(&'a self, task_queue: String, is_sticky: bool)
+        fn poll_workflow_task<'a, 'b>(&'a self, task_queue: TaskQueue)
             -> impl Future<Output = Result<PollWorkflowTaskQueueResponse>> + Send + 'b
             where 'a: 'b, Self: 'b;
 

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

@@ -48,11 +48,39 @@ impl WorkerClientBag {
             use_versioning,
         }
     }
-    fn versioning_build_id(&self) -> String {
-        if self.use_versioning {
+
+    fn default_capabilities(&self) -> Capabilities {
+        self.capabilities().cloned().unwrap_or_default()
+    }
+
+    fn binary_checksum(&self) -> String {
+        if self.default_capabilities().build_id_based_versioning {
+            "".to_string()
+        } else {
             self.worker_build_id.clone()
+        }
+    }
+
+    fn worker_version_capabilities(&self) -> Option<WorkerVersionCapabilities> {
+        if self.default_capabilities().build_id_based_versioning {
+            Some(WorkerVersionCapabilities {
+                build_id: self.worker_build_id.clone(),
+                use_versioning: self.use_versioning,
+            })
         } else {
-            "".to_string()
+            None
+        }
+    }
+
+    fn worker_version_stamp(&self) -> Option<WorkerVersionStamp> {
+        if self.default_capabilities().build_id_based_versioning {
+            Some(WorkerVersionStamp {
+                build_id: self.worker_build_id.clone(),
+                bundle_id: "".to_string(),
+                use_versioning: self.use_versioning,
+            })
+        } else {
+            None
         }
     }
 }
@@ -64,8 +92,7 @@ impl WorkerClientBag {
 pub(crate) trait WorkerClient: Sync + Send {
     async fn poll_workflow_task(
         &self,
-        task_queue: String,
-        is_sticky: bool,
+        task_queue: TaskQueue,
     ) -> Result<PollWorkflowTaskQueueResponse>;
     async fn poll_activity_task(
         &self,
@@ -122,28 +149,14 @@ pub(crate) trait WorkerClient: Sync + Send {
 impl WorkerClient for WorkerClientBag {
     async fn poll_workflow_task(
         &self,
-        task_queue: String,
-        is_sticky: bool,
+        task_queue: TaskQueue,
     ) -> Result<PollWorkflowTaskQueueResponse> {
         let request = PollWorkflowTaskQueueRequest {
             namespace: self.namespace.clone(),
-            task_queue: Some(TaskQueue {
-                name: task_queue,
-                kind: if is_sticky {
-                    TaskQueueKind::Sticky
-                } else {
-                    TaskQueueKind::Normal
-                } as i32,
-            }),
+            task_queue: Some(task_queue),
             identity: self.identity.clone(),
-            binary_checksum: if self.use_versioning {
-                "".to_string()
-            } else {
-                self.worker_build_id.clone()
-            },
-            worker_version_capabilities: Some(WorkerVersionCapabilities {
-                build_id: self.versioning_build_id(),
-            }),
+            binary_checksum: self.binary_checksum(),
+            worker_version_capabilities: self.worker_version_capabilities(),
         };
 
         Ok(self
@@ -164,14 +177,13 @@ impl WorkerClient for WorkerClientBag {
             task_queue: Some(TaskQueue {
                 name: task_queue,
                 kind: TaskQueueKind::Normal as i32,
+                normal_name: "".to_string(),
             }),
             identity: self.identity.clone(),
             task_queue_metadata: max_tasks_per_sec.map(|tps| TaskQueueMetadata {
                 max_tasks_per_second: Some(tps),
             }),
-            worker_version_capabilities: Some(WorkerVersionCapabilities {
-                build_id: self.versioning_build_id(),
-            }),
+            worker_version_capabilities: self.worker_version_capabilities(),
         };
 
         Ok(self
@@ -193,12 +205,9 @@ impl WorkerClient for WorkerClientBag {
             sticky_attributes: request.sticky_attributes,
             return_new_workflow_task: request.return_new_workflow_task,
             force_create_new_workflow_task: request.force_create_new_workflow_task,
-            worker_version_stamp: Some(WorkerVersionStamp {
-                build_id: self.versioning_build_id(),
-                bundle_id: "".to_string(),
-            }),
+            worker_version_stamp: self.worker_version_stamp(),
             messages: vec![],
-            binary_checksum: self.worker_build_id.clone(),
+            binary_checksum: self.binary_checksum(),
             query_results: request
                 .query_responses
                 .into_iter()
@@ -239,6 +248,7 @@ impl WorkerClient for WorkerClientBag {
                 result,
                 identity: self.identity.clone(),
                 namespace: self.namespace.clone(),
+                worker_version: self.worker_version_stamp(),
             })
             .await?
             .into_inner())
@@ -275,6 +285,7 @@ impl WorkerClient for WorkerClientBag {
                 details,
                 identity: self.identity.clone(),
                 namespace: self.namespace.clone(),
+                worker_version: self.worker_version_stamp(),
             })
             .await?
             .into_inner())
@@ -295,6 +306,7 @@ impl WorkerClient for WorkerClientBag {
                 namespace: self.namespace.clone(),
                 // TODO: Implement - https://github.com/temporalio/sdk-core/issues/293
                 last_heartbeat_details: None,
+                worker_version: self.worker_version_stamp(),
             })
             .await?
             .into_inner())
@@ -311,9 +323,10 @@ impl WorkerClient for WorkerClientBag {
             cause: cause as i32,
             failure,
             identity: self.identity.clone(),
-            binary_checksum: self.worker_build_id.clone(),
+            binary_checksum: self.binary_checksum(),
             namespace: self.namespace.clone(),
             messages: vec![],
+            worker_version: self.worker_version_stamp(),
         };
         Ok(self
             .client