@temporalio/core-bridge 1.9.2 → 1.10.0

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

@@ -9,7 +9,7 @@ pub(crate) use local_activities::{
 
 use crate::{
     abstractions::{
-        ClosableMeteredSemaphore, MeteredSemaphore, OwnedMeteredSemPermit,
+        ClosableMeteredPermitDealer, MeteredPermitDealer, OwnedMeteredSemPermit,
         TrackedOwnedMeteredSemPermit, UsedMeteredSemPermit,
     },
     pollers::BoxedActPoller,
@@ -39,6 +39,7 @@ use std::{
     },
     time::{Duration, Instant},
 };
+use temporal_sdk_core_api::worker::{ActivitySlotInfo, ActivitySlotKind};
 use temporal_sdk_core_protos::{
     coresdk::{
         activity_result::{self as ar, activity_execution_result as aer},
@@ -73,7 +74,7 @@ struct PendingActivityCancel {
 }
 
 impl PendingActivityCancel {
-    pub fn new(task_token: TaskToken, reason: ActivityCancelReason) -> Self {
+    fn new(task_token: TaskToken, reason: ActivityCancelReason) -> Self {
         Self {
             task_token,
             reason,
@@ -85,36 +86,39 @@ impl PendingActivityCancel {
 /// Contains details that core wants to store while an activity is running.
 #[derive(Debug)]
 struct InFlightActInfo {
-    pub activity_type: String,
-    pub workflow_type: String,
+    activity_type: String,
+    workflow_type: String,
     /// Only kept for logging reasons
-    pub workflow_id: String,
+    workflow_id: String,
     /// Only kept for logging reasons
-    pub workflow_run_id: String,
+    workflow_run_id: String,
     start_time: Instant,
 }
 
 /// Augments [InFlightActInfo] with details specific to remote activities
 struct RemoteInFlightActInfo {
-    pub base: InFlightActInfo,
+    base: InFlightActInfo,
     /// Used to calculate aggregation delay between activity heartbeats.
-    pub heartbeat_timeout: Option<prost_types::Duration>,
+    heartbeat_timeout: Option<prost_types::Duration>,
     /// Set if we have already issued a cancellation activation to lang for this activity, with
     /// the original reason we issued the cancel.
-    pub issued_cancel_to_lang: Option<ActivityCancelReason>,
+    issued_cancel_to_lang: Option<ActivityCancelReason>,
     /// Set to true if we have already learned from the server this activity doesn't exist. EX:
     /// we have learned from heartbeating and issued a cancel task, in which case we may simply
     /// discard the reply.
-    pub known_not_found: bool,
+    known_not_found: bool,
     /// Handle to the task containing local timeout tracking, if any.
-    pub local_timeouts_task: Option<JoinHandle<()>>,
+    local_timeouts_task: Option<JoinHandle<()>>,
     /// Used to reset the local heartbeat timeout every time we record a heartbeat
     timeout_resetter: Option<Arc<Notify>>,
     /// The permit from the max concurrent semaphore
-    _permit: UsedMeteredSemPermit,
+    _permit: UsedMeteredSemPermit<ActivitySlotKind>,
 }
 impl RemoteInFlightActInfo {
-    fn new(poll_resp: &PollActivityTaskQueueResponse, permit: UsedMeteredSemPermit) -> Self {
+    fn new(
+        poll_resp: &PollActivityTaskQueueResponse,
+        permit: UsedMeteredSemPermit<ActivitySlotKind>,
+    ) -> Self {
         let wec = poll_resp.workflow_execution.clone().unwrap_or_default();
         Self {
             base: InFlightActInfo {
@@ -146,8 +150,8 @@ pub(crate) struct WorkerActivityTasks {
     outstanding_activity_tasks: OutstandingActMap,
     /// Ensures we don't exceed this worker's maximum concurrent activity limit for activities. This
     /// semaphore is used to limit eager activities but shares the same underlying
-    /// [MeteredSemaphore] that is used to limit the concurrency for non-eager activities.
-    eager_activities_semaphore: Arc<ClosableMeteredSemaphore>,
+    /// [MeteredPermitDealer] that is used to limit the concurrency for non-eager activities.
+    eager_activities_semaphore: Arc<ClosableMeteredPermitDealer<ActivitySlotKind>>,
     /// Holds activity tasks we have received in direct response to workflow task completion (a.k.a
     /// eager activities). Tasks received in this stream hold a "tracked" permit that is issued by
     /// the `eager_activities_semaphore`.
@@ -176,7 +180,7 @@ enum ActivityTaskSource {
 impl WorkerActivityTasks {
     #[allow(clippy::too_many_arguments)]
     pub(crate) fn new(
-        semaphore: Arc<MeteredSemaphore>,
+        semaphore: Arc<MeteredPermitDealer<ActivitySlotKind>>,
         poller: BoxedActPoller,
         client: Arc<dyn WorkerClient>,
         metrics: MetricsContext,
@@ -190,7 +194,7 @@ impl WorkerActivityTasks {
         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);
+        let eager_activities_semaphore = ClosableMeteredPermitDealer::new_arc(semaphore);
 
         let start_tasks_stream_complete = CancellationToken::new();
         let starts_stream = Self::merge_start_task_sources(
@@ -241,7 +245,7 @@ impl WorkerActivityTasks {
     fn merge_start_task_sources(
         non_poll_tasks_rx: UnboundedReceiver<TrackedPermittedTqResp>,
         poller_stream: impl Stream<Item = Result<PermittedTqResp, tonic::Status>>,
-        eager_activities_semaphore: Arc<ClosableMeteredSemaphore>,
+        eager_activities_semaphore: Arc<ClosableMeteredPermitDealer<ActivitySlotKind>>,
         on_complete_token: CancellationToken,
     ) -> impl Stream<Item = Result<(PermittedTqResp, bool), PollActivityError>> {
         let non_poll_stream = stream::unfold(
@@ -444,7 +448,7 @@ impl WorkerActivityTasks {
     }
 
     #[cfg(test)]
-    pub(crate) fn remaining_activity_capacity(&self) -> usize {
+    pub(crate) fn remaining_activity_capacity(&self) -> Option<usize> {
         self.eager_activities_semaphore.unused_permits()
     }
 }
@@ -512,11 +516,13 @@ where
                     }
                     ActivityTaskSource::PendingStart(res) => {
                         Some(res.map(|(task, is_eager)| {
+                            let mut activity_type_name = "";
                             if let Some(ref act_type) = task.resp.activity_type {
+                                activity_type_name = act_type.name.as_str();
                                 if let Some(ref wf_type) = task.resp.workflow_type {
                                     self.metrics
                                         .with_new_attrs([
-                                            activity_type(act_type.name.clone()),
+                                            activity_type(activity_type_name.to_owned()),
                                             workflow_type(wf_type.name.clone()),
                                             eager(is_eager),
                                         ])
@@ -533,9 +539,13 @@ where
 
                             let tt: TaskToken = task.resp.task_token.clone().into();
                             let outstanding_entry = self.outstanding_tasks.entry(tt.clone());
-                            let mut outstanding_info = outstanding_entry.insert(
-                                RemoteInFlightActInfo::new(&task.resp, task.permit.into_used()),
-                            );
+                            let mut outstanding_info =
+                                outstanding_entry.insert(RemoteInFlightActInfo::new(
+                                    &task.resp,
+                                    task.permit.into_used(ActivitySlotInfo {
+                                        activity_type: activity_type_name,
+                                    }),
+                                ));
                             // If we have already waited the grace period and issued cancels,
                             // this will have been set true, indicating anything that happened
                             // to be buffered/in-flight/etc should get an immediate cancel. This
@@ -641,14 +651,14 @@ where
 /// Provides facilities for the workflow side of things to interact with the activity manager.
 /// Allows for the handling of activities returned by WFT completions.
 pub(crate) struct ActivitiesFromWFTsHandle {
-    sem: Arc<ClosableMeteredSemaphore>,
+    sem: Arc<ClosableMeteredPermitDealer<ActivitySlotKind>>,
     tx: UnboundedSender<TrackedPermittedTqResp>,
 }
 
 impl ActivitiesFromWFTsHandle {
     /// Returns a handle that can be used to reserve an activity slot. EX: When requesting eager
     /// dispatch of an activity to this worker upon workflow task completion
-    pub(crate) fn reserve_slot(&self) -> Option<TrackedOwnedMeteredSemPermit> {
+    pub(crate) fn reserve_slot(&self) -> Option<TrackedOwnedMeteredSemPermit<ActivitySlotKind>> {
         // TODO: check if rate limit is not exceeded and count this reservation towards the rate limit
         self.sem.try_acquire_owned().ok()
     }
@@ -666,14 +676,14 @@ impl ActivitiesFromWFTsHandle {
 
 #[derive(Debug)]
 pub(crate) struct PermittedTqResp {
-    pub permit: OwnedMeteredSemPermit,
-    pub resp: PollActivityTaskQueueResponse,
+    pub(crate) permit: OwnedMeteredSemPermit<ActivitySlotKind>,
+    pub(crate) resp: PollActivityTaskQueueResponse,
 }
 
 #[derive(Debug)]
 pub(crate) struct TrackedPermittedTqResp {
-    pub permit: TrackedOwnedMeteredSemPermit,
-    pub resp: PollActivityTaskQueueResponse,
+    pub(crate) permit: TrackedOwnedMeteredSemPermit<ActivitySlotKind>,
+    pub(crate) resp: PollActivityTaskQueueResponse,
 }
 
 fn worker_shutdown_failure() -> Failure {
@@ -687,7 +697,7 @@ fn worker_shutdown_failure() -> Failure {
             ApplicationFailureInfo {
                 r#type: "WorkerShutdown".to_string(),
                 non_retryable: false,
-                details: None,
+                ..Default::default()
             },
         )),
     }
@@ -697,7 +707,8 @@ fn worker_shutdown_failure() -> Failure {
 mod tests {
     use super::*;
     use crate::{
-        pollers::new_activity_task_buffer, prost_dur, worker::client::mocks::mock_workflow_client,
+        abstractions::tests::fixed_size_permit_dealer, pollers::new_activity_task_buffer,
+        prost_dur, worker::client::mocks::mock_workflow_client,
     };
     use temporal_sdk_core_protos::coresdk::activity_result::ActivityExecutionResult;
 
@@ -729,11 +740,7 @@ mod tests {
             .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 sem = Arc::new(fixed_size_permit_dealer(10));
         let shutdown_token = CancellationToken::new();
         let ap = new_activity_task_buffer(
             mock_client.clone(),
@@ -822,11 +829,7 @@ mod tests {
                 })
             });
         let mock_client = Arc::new(mock_client);
-        let sem = Arc::new(MeteredSemaphore::new(
-            1, // Just one task at a time
-            MetricsContext::no_op(),
-            MetricsContext::available_task_slots,
-        ));
+        let sem = Arc::new(fixed_size_permit_dealer(1));
         let shutdown_token = CancellationToken::new();
         let ap = new_activity_task_buffer(
             mock_client.clone(),
@@ -897,11 +900,7 @@ mod tests {
             .times(2)
             .returning(|_, _| Ok(Default::default()));
         let mock_client = Arc::new(mock_client);
-        let sem = Arc::new(MeteredSemaphore::new(
-            1, // Just one task at a time
-            MetricsContext::no_op(),
-            MetricsContext::available_task_slots,
-        ));
+        let sem = Arc::new(fixed_size_permit_dealer(1));
         let shutdown_token = CancellationToken::new();
         let ap = new_activity_task_buffer(
             mock_client.clone(),

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

@@ -1,12 +1,11 @@
 use super::*;
 use futures::Future;
-use lazy_static::lazy_static;
+use once_cell::sync::Lazy;
 use std::sync::Arc;
 use temporal_client::SlotManager;
 
-lazy_static! {
-    pub(crate) static ref DEFAULT_WORKERS_REGISTRY: Arc<SlotManager> = Arc::new(SlotManager::new());
-}
+static DEFAULT_WORKERS_REGISTRY: Lazy<Arc<SlotManager>> =
+    Lazy::new(|| Arc::new(SlotManager::new()));
 
 pub(crate) static DEFAULT_TEST_CAPABILITIES: &Capabilities = &Capabilities {
     signal_and_query_header: true,
@@ -26,7 +25,7 @@ pub(crate) static DEFAULT_TEST_CAPABILITIES: &Capabilities = &Capabilities {
 pub(crate) fn mock_workflow_client() -> MockWorkerClient {
     let mut r = MockWorkerClient::new();
     r.expect_capabilities()
-        .returning(|| Some(DEFAULT_TEST_CAPABILITIES));
+        .returning(|| Some(DEFAULT_TEST_CAPABILITIES.clone()));
     r.expect_workers()
         .returning(|| DEFAULT_WORKERS_REGISTRY.clone());
     r.expect_is_mock().returning(|| true);
@@ -37,7 +36,7 @@ pub(crate) fn mock_workflow_client() -> MockWorkerClient {
 pub(crate) fn mock_manual_workflow_client() -> MockManualWorkerClient {
     let mut r = MockManualWorkerClient::new();
     r.expect_capabilities()
-        .returning(|| Some(DEFAULT_TEST_CAPABILITIES));
+        .returning(|| Some(DEFAULT_TEST_CAPABILITIES.clone()));
     r.expect_workers()
         .returning(|| DEFAULT_WORKERS_REGISTRY.clone());
     r.expect_is_mock().returning(|| true);
@@ -116,7 +115,9 @@ mockall::mock! {
         ) -> impl Future<Output = Result<RespondQueryTaskCompletedResponse>> + Send + 'b
             where 'a: 'b, Self: 'b;
 
-        fn capabilities(&self) -> Option<&'static get_system_info_response::Capabilities>;
+        fn replace_client(&self, new_client: RetryClient<Client>);
+
+        fn capabilities(&self) -> Option<get_system_info_response::Capabilities>;
 
         fn workers(&self) -> Arc<SlotManager>;
 

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

@@ -1,6 +1,7 @@
 //! Worker-specific client needs
 
 pub(crate) mod mocks;
+use parking_lot::RwLock;
 use std::sync::Arc;
 use temporal_client::{Client, RetryClient, SlotManager, WorkflowService};
 use temporal_sdk_core_protos::{
@@ -26,7 +27,7 @@ type Result<T, E = tonic::Status> = std::result::Result<T, E>;
 
 /// Contains everything a worker needs to interact with the server
 pub(crate) struct WorkerClientBag {
-    client: RetryClient<Client>,
+    replaceable_client: RwLock<RetryClient<Client>>,
     namespace: String,
     identity: String,
     worker_build_id: String,
@@ -34,7 +35,7 @@ pub(crate) struct WorkerClientBag {
 }
 
 impl WorkerClientBag {
-    pub fn new(
+    pub(crate) fn new(
         client: RetryClient<Client>,
         namespace: String,
         identity: String,
@@ -42,7 +43,7 @@ impl WorkerClientBag {
         use_versioning: bool,
     ) -> Self {
         Self {
-            client,
+            replaceable_client: RwLock::new(client),
             namespace,
             identity,
             worker_build_id,
@@ -50,8 +51,12 @@ impl WorkerClientBag {
         }
     }
 
+    fn cloned_client(&self) -> RetryClient<Client> {
+        self.replaceable_client.read().clone()
+    }
+
     fn default_capabilities(&self) -> Capabilities {
-        self.capabilities().cloned().unwrap_or_default()
+        self.capabilities().unwrap_or_default()
     }
 
     fn binary_checksum(&self) -> String {
@@ -77,7 +82,6 @@ impl WorkerClientBag {
         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 {
@@ -142,8 +146,8 @@ pub(crate) trait WorkerClient: Sync + Send {
         query_result: QueryResult,
     ) -> Result<RespondQueryTaskCompletedResponse>;
 
-    #[allow(clippy::needless_lifetimes)] // Clippy is wrong here
-    fn capabilities<'a>(&'a self) -> Option<&'a get_system_info_response::Capabilities>;
+    fn replace_client(&self, new_client: RetryClient<Client>);
+    fn capabilities(&self) -> Option<get_system_info_response::Capabilities>;
     fn workers(&self) -> Arc<SlotManager>;
     fn is_mock(&self) -> bool;
 }
@@ -163,8 +167,7 @@ impl WorkerClient for WorkerClientBag {
         };
 
         Ok(self
-            .client
-            .clone()
+            .cloned_client()
             .poll_workflow_task_queue(request)
             .await?
             .into_inner())
@@ -190,8 +193,7 @@ impl WorkerClient for WorkerClientBag {
         };
 
         Ok(self
-            .client
-            .clone()
+            .cloned_client()
             .poll_activity_task_queue(request)
             .await?
             .into_inner())
@@ -231,8 +233,7 @@ impl WorkerClient for WorkerClientBag {
             metering_metadata: Some(request.metering_metadata),
         };
         Ok(self
-            .client
-            .clone()
+            .cloned_client()
             .respond_workflow_task_completed(request)
             .await?
             .into_inner())
@@ -244,8 +245,7 @@ impl WorkerClient for WorkerClientBag {
         result: Option<Payloads>,
     ) -> Result<RespondActivityTaskCompletedResponse> {
         Ok(self
-            .client
-            .clone()
+            .cloned_client()
             .respond_activity_task_completed(RespondActivityTaskCompletedRequest {
                 task_token: task_token.0,
                 result,
@@ -263,8 +263,7 @@ impl WorkerClient for WorkerClientBag {
         details: Option<Payloads>,
     ) -> Result<RecordActivityTaskHeartbeatResponse> {
         Ok(self
-            .client
-            .clone()
+            .cloned_client()
             .record_activity_task_heartbeat(RecordActivityTaskHeartbeatRequest {
                 task_token: task_token.0,
                 details,
@@ -281,8 +280,7 @@ impl WorkerClient for WorkerClientBag {
         details: Option<Payloads>,
     ) -> Result<RespondActivityTaskCanceledResponse> {
         Ok(self
-            .client
-            .clone()
+            .cloned_client()
             .respond_activity_task_canceled(RespondActivityTaskCanceledRequest {
                 task_token: task_token.0,
                 details,
@@ -300,8 +298,7 @@ impl WorkerClient for WorkerClientBag {
         failure: Option<Failure>,
     ) -> Result<RespondActivityTaskFailedResponse> {
         Ok(self
-            .client
-            .clone()
+            .cloned_client()
             .respond_activity_task_failed(RespondActivityTaskFailedRequest {
                 task_token: task_token.0,
                 failure,
@@ -332,8 +329,7 @@ impl WorkerClient for WorkerClientBag {
             worker_version: self.worker_version_stamp(),
         };
         Ok(self
-            .client
-            .clone()
+            .cloned_client()
             .respond_workflow_task_failed(request)
             .await?
             .into_inner())
@@ -346,8 +342,7 @@ impl WorkerClient for WorkerClientBag {
         page_token: Vec<u8>,
     ) -> Result<GetWorkflowExecutionHistoryResponse> {
         Ok(self
-            .client
-            .clone()
+            .cloned_client()
             .get_workflow_execution_history(GetWorkflowExecutionHistoryRequest {
                 namespace: self.namespace.clone(),
                 execution: Some(WorkflowExecution {
@@ -368,8 +363,7 @@ impl WorkerClient for WorkerClientBag {
     ) -> Result<RespondQueryTaskCompletedResponse> {
         let (_, completed_type, query_result, error_message) = query_result.into_components();
         Ok(self
-            .client
-            .clone()
+            .cloned_client()
             .respond_query_task_completed(RespondQueryTaskCompletedRequest {
                 task_token: task_token.into(),
                 completed_type: completed_type as i32,
@@ -381,12 +375,19 @@ impl WorkerClient for WorkerClientBag {
             .into_inner())
     }
 
-    fn capabilities(&self) -> Option<&Capabilities> {
-        self.client.get_client().inner().capabilities()
+    fn replace_client(&self, new_client: RetryClient<Client>) {
+        let mut replaceable_client = self.replaceable_client.write();
+        *replaceable_client = new_client;
+    }
+
+    fn capabilities(&self) -> Option<Capabilities> {
+        let client = self.replaceable_client.read();
+        client.get_client().inner().capabilities().cloned()
     }
 
     fn workers(&self) -> Arc<SlotManager> {
-        self.client.get_client().inner().workers()
+        let client = self.replaceable_client.read();
+        client.get_client().inner().workers()
     }
 
     fn is_mock(&self) -> bool {
@@ -399,21 +400,21 @@ impl WorkerClient for WorkerClientBag {
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) struct WorkflowTaskCompletion {
     /// The task token that would've been received from polling for a workflow activation
-    pub task_token: TaskToken,
+    pub(crate) task_token: TaskToken,
     /// A list of new commands to send to the server, such as starting a timer.
-    pub commands: Vec<Command>,
+    pub(crate) commands: Vec<Command>,
     /// A list of protocol messages to send to the server.
-    pub messages: Vec<ProtocolMessage>,
+    pub(crate) messages: Vec<ProtocolMessage>,
     /// If set, indicate that next task should be queued on sticky queue with given attributes.
-    pub sticky_attributes: Option<StickyExecutionAttributes>,
+    pub(crate) sticky_attributes: Option<StickyExecutionAttributes>,
     /// Responses to queries in the `queries` field of the workflow task.
-    pub query_responses: Vec<QueryResult>,
+    pub(crate) query_responses: Vec<QueryResult>,
     /// Indicate that the task completion should return a new WFT if one is available
-    pub return_new_workflow_task: bool,
+    pub(crate) return_new_workflow_task: bool,
     /// Force a new WFT to be created after this completion
-    pub force_create_new_workflow_task: bool,
+    pub(crate) force_create_new_workflow_task: bool,
     /// SDK-specific metadata to send
-    pub sdk_metadata: WorkflowTaskCompletedMetadata,
+    pub(crate) sdk_metadata: WorkflowTaskCompletedMetadata,
     /// Metering info
-    pub metering_metadata: MeteringMetadata,
+    pub(crate) metering_metadata: MeteringMetadata,
 }