@temporalio/core-bridge 1.14.2-canary-release-testing.0 → 1.16.0

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

@@ -1,7 +1,7 @@
 //! Worker-specific client needs
 
 pub(crate) mod mocks;
-use crate::protosext::legacy_query_failure;
+use crate::{protosext::legacy_query_failure, worker::WorkerVersioningStrategy};
 use parking_lot::Mutex;
 use prost_types::Duration as PbDuration;
 use std::{
@@ -10,37 +10,34 @@ use std::{
     time::{Duration, SystemTime},
 };
 use temporalio_client::{
-    Client, Namespace, NamespacedClient, RetryClient, RetryOptions, SharedReplaceableClient,
-    WorkflowService,
+    Connection, Namespace, NamespacedClient, RetryOptions, SharedReplaceableClient,
+    grpc::WorkflowService,
     request_extensions::{IsWorkerTaskLongPoll, NoRetryOnMatching, RetryConfigForCall},
     worker::ClientWorkerSet,
 };
-use temporalio_common::{
-    protos::{
-        TaskToken,
-        coresdk::{workflow_commands::QueryResult, workflow_completion},
-        temporal::api::{
-            command::v1::Command,
-            common::v1::{
-                MeteringMetadata, Payloads, WorkerVersionCapabilities, WorkerVersionStamp,
-                WorkflowExecution,
-            },
-            deployment,
-            enums::v1::{
-                TaskQueueKind, VersioningBehavior, WorkerStatus, WorkerVersioningMode,
-                WorkflowTaskFailedCause,
-            },
-            failure::v1::Failure,
-            nexus,
-            protocol::v1::Message as ProtocolMessage,
-            query::v1::WorkflowQueryResult,
-            sdk::v1::WorkflowTaskCompletedMetadata,
-            taskqueue::v1::{StickyExecutionAttributes, TaskQueue, TaskQueueMetadata},
-            worker::v1::{WorkerHeartbeat, WorkerSlotsInfo},
-            workflowservice::v1::{get_system_info_response::Capabilities, *},
+use temporalio_common::protos::{
+    TaskToken,
+    coresdk::{workflow_commands::QueryResult, workflow_completion},
+    temporal::api::{
+        command::v1::Command,
+        common::v1::{
+            MeteringMetadata, Payloads, WorkerVersionCapabilities, WorkerVersionStamp,
+            WorkflowExecution,
         },
+        deployment,
+        enums::v1::{
+            TaskQueueKind, TaskQueueType, VersioningBehavior, WorkerVersioningMode,
+            WorkflowTaskFailedCause,
+        },
+        failure::v1::Failure,
+        nexus::{self, v1::NexusTaskFailure},
+        protocol::v1::Message as ProtocolMessage,
+        query::v1::WorkflowQueryResult,
+        sdk::v1::WorkflowTaskCompletedMetadata,
+        taskqueue::v1::{StickyExecutionAttributes, TaskQueue, TaskQueueMetadata},
+        worker::v1::{WorkerHeartbeat, WorkerSlotsInfo},
+        workflowservice::v1::{get_system_info_response::Capabilities, *},
     },
-    worker::WorkerVersioningStrategy,
 };
 use tonic::IntoRequest;
 use uuid::Uuid;
@@ -54,29 +51,33 @@ pub enum LegacyQueryResult {
 
 /// Contains everything a worker needs to interact with the server
 pub(crate) struct WorkerClientBag {
-    client: RetryClient<SharedReplaceableClient<Client>>,
+    connection: SharedReplaceableClient<Connection>,
     namespace: String,
-    identity: String,
     worker_versioning_strategy: WorkerVersioningStrategy,
+    worker_instance_key: Uuid,
     worker_heartbeat_map: Arc<Mutex<HashMap<String, ClientHeartbeatData>>>,
 }
 
 impl WorkerClientBag {
     pub(crate) fn new(
-        client: RetryClient<SharedReplaceableClient<Client>>,
+        connection: SharedReplaceableClient<Connection>,
         namespace: String,
-        identity: String,
         worker_versioning_strategy: WorkerVersioningStrategy,
+        worker_instance_key: Uuid,
     ) -> Self {
         Self {
-            client,
+            connection,
             namespace,
-            identity,
             worker_versioning_strategy,
+            worker_instance_key,
             worker_heartbeat_map: Arc::new(Mutex::new(HashMap::new())),
         }
     }
 
+    fn identity(&self) -> String {
+        self.connection.inner_cow().identity().to_owned()
+    }
+
     fn default_capabilities(&self) -> Capabilities {
         self.capabilities().unwrap_or_default()
     }
@@ -201,7 +202,7 @@ pub trait WorkerClient: Sync + Send {
     async fn fail_nexus_task(
         &self,
         task_token: TaskToken,
-        error: nexus::v1::HandlerError,
+        error: NexusTaskFailure,
     ) -> Result<RespondNexusTaskFailedResponse>;
     /// Get the workflow execution history
     async fn get_workflow_execution_history(
@@ -222,6 +223,8 @@ pub trait WorkerClient: Sync + Send {
     async fn shutdown_worker(
         &self,
         sticky_task_queue: String,
+        task_queue: String,
+        task_queue_types: Vec<TaskQueueType>,
         final_heartbeat: Option<WorkerHeartbeat>,
     ) -> Result<ShutdownWorkerResponse>;
     /// Record a worker heartbeat
@@ -231,8 +234,8 @@ pub trait WorkerClient: Sync + Send {
         worker_heartbeat: Vec<WorkerHeartbeat>,
     ) -> Result<RecordWorkerHeartbeatResponse>;
 
-    /// Replace the underlying client
-    fn replace_client(&self, new_client: Client);
+    /// Replace the underlying connection
+    fn replace_connection(&self, new_client: Connection);
     /// Return server capabilities
     fn capabilities(&self) -> Option<Capabilities>;
     /// Return workers using this client
@@ -245,6 +248,8 @@ pub trait WorkerClient: Sync + Send {
     fn identity(&self) -> String;
     /// Get worker grouping key
     fn worker_grouping_key(&self) -> Uuid;
+    /// Get worker instance key (unique per worker instance)
+    fn worker_instance_key(&self) -> Uuid;
     /// Sets the client-reliant fields for WorkerHeartbeat. This also updates client-level tracking
     /// of heartbeat fields, like last heartbeat timestamp.
     fn set_heartbeat_client_fields(&self, heartbeat: &mut WorkerHeartbeat);
@@ -297,11 +302,11 @@ impl WorkerClient for WorkerClientBag {
         let mut request = PollWorkflowTaskQueueRequest {
             namespace: self.namespace.clone(),
             task_queue: Some(task_queue),
-            identity: self.identity.clone(),
+            identity: self.identity(),
             binary_checksum: self.binary_checksum(),
             worker_version_capabilities: self.worker_version_capabilities(),
             deployment_options: self.deployment_options(),
-            worker_heartbeat: None,
+            worker_instance_key: self.worker_instance_key.to_string(),
         }
         .into_request();
         request.extensions_mut().insert(IsWorkerTaskLongPoll);
@@ -313,7 +318,7 @@ impl WorkerClient for WorkerClientBag {
         }
 
         Ok(self
-            .client
+            .connection
             .clone()
             .poll_workflow_task_queue(request)
             .await?
@@ -333,13 +338,13 @@ impl WorkerClient for WorkerClientBag {
                 kind: TaskQueueKind::Normal as i32,
                 normal_name: "".to_string(),
             }),
-            identity: self.identity.clone(),
+            identity: self.identity(),
             task_queue_metadata: act_options.max_tasks_per_sec.map(|tps| TaskQueueMetadata {
                 max_tasks_per_second: Some(tps),
             }),
             worker_version_capabilities: self.worker_version_capabilities(),
             deployment_options: self.deployment_options(),
-            worker_heartbeat: None,
+            worker_instance_key: self.worker_instance_key.to_string(),
         }
         .into_request();
         request.extensions_mut().insert(IsWorkerTaskLongPoll);
@@ -351,7 +356,7 @@ impl WorkerClient for WorkerClientBag {
         }
 
         Ok(self
-            .client
+            .connection
             .clone()
             .poll_activity_task_queue(request)
             .await?
@@ -371,10 +376,11 @@ impl WorkerClient for WorkerClientBag {
                 kind: TaskQueueKind::Normal as i32,
                 normal_name: "".to_string(),
             }),
-            identity: self.identity.clone(),
+            identity: self.identity(),
             worker_version_capabilities: self.worker_version_capabilities(),
             deployment_options: self.deployment_options(),
             worker_heartbeat: Vec::new(),
+            worker_instance_key: self.worker_instance_key.to_string(),
         }
         .into_request();
         request.extensions_mut().insert(IsWorkerTaskLongPoll);
@@ -386,7 +392,7 @@ impl WorkerClient for WorkerClientBag {
         }
 
         Ok(self
-            .client
+            .connection
             .clone()
             .poll_nexus_task_queue(request)
             .await?
@@ -402,7 +408,7 @@ impl WorkerClient for WorkerClientBag {
             task_token: request.task_token.into(),
             commands: request.commands,
             messages: request.messages,
-            identity: self.identity.clone(),
+            identity: self.identity(),
             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,
@@ -437,7 +443,7 @@ impl WorkerClient for WorkerClientBag {
             deployment_options: self.deployment_options(),
         };
         Ok(self
-            .client
+            .connection
             .clone()
             .respond_workflow_task_completed(request.into_request())
             .await?
@@ -450,14 +456,14 @@ impl WorkerClient for WorkerClientBag {
         result: Option<Payloads>,
     ) -> Result<RespondActivityTaskCompletedResponse> {
         Ok(self
-            .client
+            .connection
             .clone()
             .respond_activity_task_completed(
                 #[allow(deprecated)] // want to list all fields explicitly
                 RespondActivityTaskCompletedRequest {
                     task_token: task_token.0,
                     result,
-                    identity: self.identity.clone(),
+                    identity: self.identity(),
                     namespace: self.namespace.clone(),
                     worker_version: self.worker_version_stamp(),
                     // Will never be set, deprecated.
@@ -476,12 +482,12 @@ impl WorkerClient for WorkerClientBag {
         response: nexus::v1::Response,
     ) -> Result<RespondNexusTaskCompletedResponse> {
         Ok(self
-            .client
+            .connection
             .clone()
             .respond_nexus_task_completed(
                 RespondNexusTaskCompletedRequest {
                     namespace: self.namespace.clone(),
-                    identity: self.identity.clone(),
+                    identity: self.identity(),
                     task_token: task_token.0,
                     response: Some(response),
                 }
@@ -497,13 +503,13 @@ impl WorkerClient for WorkerClientBag {
         details: Option<Payloads>,
     ) -> Result<RecordActivityTaskHeartbeatResponse> {
         Ok(self
-            .client
+            .connection
             .clone()
             .record_activity_task_heartbeat(
                 RecordActivityTaskHeartbeatRequest {
                     task_token: task_token.0,
                     details,
-                    identity: self.identity.clone(),
+                    identity: self.identity(),
                     namespace: self.namespace.clone(),
                 }
                 .into_request(),
@@ -518,14 +524,14 @@ impl WorkerClient for WorkerClientBag {
         details: Option<Payloads>,
     ) -> Result<RespondActivityTaskCanceledResponse> {
         Ok(self
-            .client
+            .connection
             .clone()
             .respond_activity_task_canceled(
                 #[allow(deprecated)] // want to list all fields explicitly
                 RespondActivityTaskCanceledRequest {
                     task_token: task_token.0,
                     details,
-                    identity: self.identity.clone(),
+                    identity: self.identity(),
                     namespace: self.namespace.clone(),
                     worker_version: self.worker_version_stamp(),
                     // Will never be set, deprecated.
@@ -544,14 +550,14 @@ impl WorkerClient for WorkerClientBag {
         failure: Option<Failure>,
     ) -> Result<RespondActivityTaskFailedResponse> {
         Ok(self
-            .client
+            .connection
             .clone()
             .respond_activity_task_failed(
                 #[allow(deprecated)] // want to list all fields explicitly
                 RespondActivityTaskFailedRequest {
                     task_token: task_token.0,
                     failure,
-                    identity: self.identity.clone(),
+                    identity: self.identity(),
                     namespace: self.namespace.clone(),
                     // TODO: Implement - https://github.com/temporalio/sdk-core/issues/293
                     last_heartbeat_details: None,
@@ -577,7 +583,7 @@ impl WorkerClient for WorkerClientBag {
             task_token: task_token.0,
             cause: cause as i32,
             failure,
-            identity: self.identity.clone(),
+            identity: self.identity(),
             binary_checksum: self.binary_checksum(),
             namespace: self.namespace.clone(),
             messages: vec![],
@@ -587,7 +593,7 @@ impl WorkerClient for WorkerClientBag {
             deployment_options: self.deployment_options(),
         };
         Ok(self
-            .client
+            .connection
             .clone()
             .respond_workflow_task_failed(request.into_request())
             .await?
@@ -597,17 +603,24 @@ impl WorkerClient for WorkerClientBag {
     async fn fail_nexus_task(
         &self,
         task_token: TaskToken,
-        error: nexus::v1::HandlerError,
+        error: NexusTaskFailure,
     ) -> Result<RespondNexusTaskFailedResponse> {
+        let (error, failure) = match error {
+            NexusTaskFailure::Legacy(handler_err) => (Some(handler_err), None),
+            NexusTaskFailure::Temporal(failure) => (None, Some(failure)),
+        };
+
         Ok(self
-            .client
+            .connection
             .clone()
             .respond_nexus_task_failed(
+                #[allow(deprecated)]
                 RespondNexusTaskFailedRequest {
                     namespace: self.namespace.clone(),
-                    identity: self.identity.clone(),
+                    identity: self.identity(),
                     task_token: task_token.0,
-                    error: Some(error),
+                    failure,
+                    error,
                 }
                 .into_request(),
             )
@@ -622,7 +635,7 @@ impl WorkerClient for WorkerClientBag {
         page_token: Vec<u8>,
     ) -> Result<GetWorkflowExecutionHistoryResponse> {
         Ok(self
-            .client
+            .connection
             .clone()
             .get_workflow_execution_history(
                 GetWorkflowExecutionHistoryRequest {
@@ -658,7 +671,7 @@ impl WorkerClient for WorkerClientBag {
         let (_, completed_type, query_result, error_message) = query_result.into_components();
 
         Ok(self
-            .client
+            .connection
             .clone()
             .respond_query_task_completed(
                 RespondQueryTaskCompletedRequest {
@@ -678,7 +691,7 @@ impl WorkerClient for WorkerClientBag {
 
     async fn describe_namespace(&self) -> Result<DescribeNamespaceResponse> {
         Ok(self
-            .client
+            .connection
             .clone()
             .describe_namespace(
                 Namespace::Name(self.namespace.clone())
@@ -692,19 +705,23 @@ impl WorkerClient for WorkerClientBag {
     async fn shutdown_worker(
         &self,
         sticky_task_queue: String,
+        task_queue: String,
+        task_queue_types: Vec<TaskQueueType>,
         final_heartbeat: Option<WorkerHeartbeat>,
     ) -> Result<ShutdownWorkerResponse> {
         let mut final_heartbeat = final_heartbeat;
         if let Some(w) = final_heartbeat.as_mut() {
-            w.status = WorkerStatus::Shutdown.into();
             self.set_heartbeat_client_fields(w);
         }
         let mut request = ShutdownWorkerRequest {
             namespace: self.namespace.clone(),
-            identity: self.identity.clone(),
+            identity: self.identity(),
             sticky_task_queue,
             reason: "graceful shutdown".to_string(),
             worker_heartbeat: final_heartbeat,
+            worker_instance_key: self.worker_instance_key.to_string(),
+            task_queue,
+            task_queue_types: task_queue_types.into_iter().map(|t| t as i32).collect(),
         }
         .into_request();
         request
@@ -712,7 +729,7 @@ impl WorkerClient for WorkerClientBag {
             .insert(RetryConfigForCall(RetryOptions::no_retries()));
 
         Ok(
-            WorkflowService::shutdown_worker(&mut self.client.clone(), request)
+            WorkflowService::shutdown_worker(&mut self.connection.clone(), request)
                 .await?
                 .into_inner(),
         )
@@ -725,32 +742,27 @@ impl WorkerClient for WorkerClientBag {
     ) -> Result<RecordWorkerHeartbeatResponse> {
         let request = RecordWorkerHeartbeatRequest {
             namespace,
-            identity: self.identity.clone(),
+            identity: self.identity(),
             worker_heartbeat,
         };
         Ok(self
-            .client
+            .connection
             .clone()
             .record_worker_heartbeat(request.into_request())
             .await?
             .into_inner())
     }
 
-    fn replace_client(&self, new_client: Client) {
-        self.client.get_client().replace_client(new_client);
+    fn replace_connection(&self, new_connection: Connection) {
+        self.connection.replace_client(new_connection);
     }
 
     fn capabilities(&self) -> Option<Capabilities> {
-        self.client
-            .get_client()
-            .inner_cow()
-            .inner()
-            .capabilities()
-            .cloned()
+        self.connection.inner_cow().capabilities().cloned()
     }
 
     fn workers(&self) -> Arc<ClientWorkerSet> {
-        self.client.get_client().inner_cow().inner().workers()
+        self.connection.inner_cow().workers()
     }
 
     fn is_mock(&self) -> bool {
@@ -758,22 +770,28 @@ impl WorkerClient for WorkerClientBag {
     }
 
     fn sdk_name_and_version(&self) -> (String, String) {
-        let inner = self.client.get_client().inner_cow();
-        let opts = inner.options();
-        (opts.client_name.clone(), opts.client_version.clone())
+        let inner = self.connection.inner_cow();
+        (
+            inner.client_name().to_owned(),
+            inner.client_version().to_owned(),
+        )
     }
 
     fn identity(&self) -> String {
-        self.identity.clone()
+        self.identity()
     }
 
     fn worker_grouping_key(&self) -> Uuid {
-        self.client.get_client().inner_cow().worker_grouping_key()
+        self.connection.inner_cow().worker_grouping_key()
+    }
+
+    fn worker_instance_key(&self) -> Uuid {
+        self.worker_instance_key
     }
 
     fn set_heartbeat_client_fields(&self, heartbeat: &mut WorkerHeartbeat) {
         if let Some(host_info) = heartbeat.host_info.as_mut() {
-            host_info.process_key = self.worker_grouping_key().to_string();
+            host_info.worker_grouping_key = self.worker_grouping_key().to_string();
         }
         heartbeat.worker_identity = WorkerClient::identity(self);
         let sdk_name_and_ver = self.sdk_name_and_version();
@@ -822,7 +840,7 @@ impl NamespacedClient for WorkerClientBag {
     }
 
     fn identity(&self) -> String {
-        self.identity.clone()
+        self.identity()
     }
 }
 

package/sdk-core/crates/sdk-core/src/worker/heartbeat.rs

@@ -1,13 +1,12 @@
 use crate::{
-    WorkerClient,
-    worker::{TaskPollers, WorkerTelemetry},
+    WorkerClient, WorkerConfig,
+    worker::{PollerBehavior, TaskPollers, WorkerTelemetry, WorkerVersioningStrategy},
 };
 use parking_lot::RwLock;
 use std::{collections::HashMap, sync::Arc, time::Duration};
 use temporalio_client::worker::SharedNamespaceWorkerTrait;
 use temporalio_common::{
-    protos::temporal::api::worker::v1::WorkerHeartbeat,
-    worker::{PollerBehavior, WorkerConfigBuilder, WorkerTaskTypes, WorkerVersioningStrategy},
+    protos::temporal::api::worker::v1::WorkerHeartbeat, worker::WorkerTaskTypes,
 };
 use tokio::sync::Notify;
 use tokio_util::sync::CancellationToken;
@@ -32,7 +31,7 @@ impl SharedNamespaceWorker {
         heartbeat_interval: Duration,
         telemetry: Option<WorkerTelemetry>,
     ) -> Result<Self, anyhow::Error> {
-        let config = WorkerConfigBuilder::default()
+        let config = WorkerConfig::builder()
             .namespace(namespace.clone())
             .task_queue(format!(
                 "temporal-sys/worker-commands/{namespace}/{}",
@@ -45,7 +44,7 @@ impl SharedNamespaceWorker {
             })
             .nexus_task_poller_behavior(PollerBehavior::SimpleMaximum(1_usize))
             .build()
-            .expect("all required fields should be implemented");
+            .expect("internal shared namespace worker options are valid");
         let worker = crate::worker::Worker::new_with_pollers(
             config,
             None,
@@ -75,7 +74,7 @@ impl SharedNamespaceWorker {
                         .map(|caps| caps.worker_heartbeats)
                         != Some(true)
                     {
-                        warn!(
+                        debug!(
                             "Worker heartbeating configured for runtime, but server version does not support it."
                         );
                         worker.shutdown().await;
@@ -161,7 +160,7 @@ mod tests {
     use crate::{
         test_help::{WorkerExt, test_worker_cfg},
         worker,
-        worker::client::mocks::mock_worker_client,
+        worker::{PollerBehavior, client::mocks::mock_worker_client},
     };
     use std::{
         sync::{
@@ -170,12 +169,9 @@ mod tests {
         },
         time::Duration,
     };
-    use temporalio_common::{
-        protos::temporal::api::{
-            namespace::v1::{NamespaceInfo, namespace_info::Capabilities},
-            workflowservice::v1::{DescribeNamespaceResponse, RecordWorkerHeartbeatResponse},
-        },
-        worker::PollerBehavior,
+    use temporalio_common::protos::temporal::api::{
+        namespace::v1::{NamespaceInfo, namespace_info::Capabilities},
+        workflowservice::v1::{DescribeNamespaceResponse, RecordWorkerHeartbeatResponse},
     };
 
     #[tokio::test]