@temporalio/core-bridge 1.12.0 → 1.12.2

package/sdk-core/tests/integ_tests/workflow_tests/nexus.rs

@@ -16,7 +16,7 @@ use temporal_sdk_core_protos::{
     temporal::api::{
         common::v1::{Callback, callback},
         enums::v1::NexusHandlerErrorRetryBehavior,
-        failure::v1::failure::FailureInfo,
+        failure::v1::{Failure, failure::FailureInfo},
         nexus,
         nexus::v1::{
             CancelOperationResponse, HandlerError, StartOperationResponse, request,
@@ -55,7 +55,7 @@ async fn nexus_basic(
     worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| {
         let endpoint = endpoint.clone();
         async move {
-            let started = ctx
+            match ctx
                 .start_nexus_operation(NexusOperationOptions {
                     endpoint,
                     service: "svc".to_string(),
@@ -64,10 +64,14 @@ async fn nexus_basic(
                     ..Default::default()
                 })
                 .await
-                .unwrap();
-            assert_eq!(started.operation_token, None);
-            let res = started.result().await;
-            Ok(res.into())
+            {
+                Ok(started) => {
+                    assert_eq!(started.operation_token, None);
+                    let res = started.result().await;
+                    Ok(Ok(res).into())
+                }
+                Err(failure) => Ok(Err(failure).into()),
+            }
         }
     });
     let wf_handle = starter.start_with_worker(wf_name, &mut worker).await;
@@ -140,29 +144,30 @@ async fn nexus_basic(
         .get_workflow_result(Default::default())
         .await
         .unwrap();
-    let res = NexusOperationResult::from_json_payload(&res.unwrap_success()[0]).unwrap();
+    let res = Result::<NexusOperationResult, Failure>::from_json_payload(&res.unwrap_success()[0])
+        .unwrap();
     match outcome {
         Outcome::Succeed => {
             let p = assert_matches!(
-                res.status,
+                res.unwrap().status,
                 Some(nexus_operation_result::Status::Completed(p)) => p
             );
             assert_eq!(p.data, b"yay");
         }
         Outcome::Fail => {
-            let f = assert_matches!(
-                res.status,
-                Some(nexus_operation_result::Status::Failed(f)) => f
-            );
+            let f = res.unwrap_err();
             assert_eq!(f.message, "nexus operation completed unsuccessfully");
         }
         Outcome::Timeout => {
-            let f = assert_matches!(
-                res.status,
-                Some(nexus_operation_result::Status::TimedOut(f)) => f
-            );
+            let f = res.unwrap_err();
             assert_eq!(f.message, "nexus operation completed unsuccessfully");
-            assert_eq!(f.cause.unwrap().message, "operation timed out");
+            let cause = f.cause.unwrap();
+            assert_eq!(cause.message, "operation timed out");
+            assert_matches!(
+                f.failure_info,
+                Some(FailureInfo::NexusOperationExecutionFailureInfo(_))
+            );
+            assert_matches!(cause.failure_info, Some(FailureInfo::TimeoutFailureInfo(_)));
         }
         _ => unreachable!(),
     }
@@ -303,6 +308,7 @@ async fn nexus_async(
                         variant: Some(nexus::v1::response::Variant::StartOperation(
                             StartOperationResponse {
                                 variant: Some(start_operation_response::Variant::AsyncSuccess(
+                                    #[allow(deprecated)]
                                     start_operation_response::Async {
                                         operation_id: "op-1".to_string(),
                                         links: vec![],
@@ -644,6 +650,7 @@ async fn nexus_cancellation_types(
                         variant: Some(nexus::v1::response::Variant::StartOperation(
                             StartOperationResponse {
                                 variant: Some(start_operation_response::Variant::AsyncSuccess(
+                                    #[allow(deprecated)]
                                     start_operation_response::Async {
                                         operation_id: "op-1".to_string(),
                                         links: vec![],

package/src/client.rs

@@ -272,6 +272,9 @@ async fn client_invoke(mut retry_client: CoreClient, call: RpcCall) -> BridgeRes
         "ListWorkerDeployments" => {
             rpc_call!(retry_client, call, list_worker_deployments)
         }
+        "ListWorkers" => {
+            rpc_call!(retry_client, call, list_workers)
+        }
         "ListWorkflowExecutions" => {
             rpc_call!(retry_client, call, list_workflow_executions)
         }
@@ -301,6 +304,9 @@ async fn client_invoke(mut retry_client: CoreClient, call: RpcCall) -> BridgeRes
         "RecordActivityTaskHeartbeatById" => {
             rpc_call!(retry_client, call, record_activity_task_heartbeat_by_id)
         }
+        "RecordWorkerHeartbeat" => {
+            rpc_call!(retry_client, call, record_worker_heartbeat)
+        }
         "RegisterNamespace" => rpc_call!(retry_client, call, register_namespace),
         "RequestCancelWorkflowExecution" => {
             rpc_call!(retry_client, call, request_cancel_workflow_execution)

package/src/metrics.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, sync::Arc};
+use std::collections::HashMap;
 
 use anyhow::Context as _;
 use neon::prelude::*;
@@ -44,32 +44,32 @@ pub fn init(cx: &mut neon::prelude::ModuleContext) -> neon::prelude::NeonResult<
 
 pub struct Counter {
     pub(crate) meter: TemporalMeter,
-    pub(crate) counter: Arc<dyn CoreCounter>,
+    pub(crate) counter: CoreCounter,
 }
 
 impl MutableFinalize for Counter {}
 
 pub struct Histogram {
     pub(crate) meter: TemporalMeter,
-    pub(crate) histogram: Arc<dyn CoreHistogram>,
+    pub(crate) histogram: CoreHistogram,
 }
 impl MutableFinalize for Histogram {}
 
 pub struct HistogramF64 {
     pub(crate) meter: TemporalMeter,
-    pub(crate) histogram: Arc<dyn CoreHistogramF64>,
+    pub(crate) histogram: CoreHistogramF64,
 }
 impl MutableFinalize for HistogramF64 {}
 
 pub struct Gauge {
     pub(crate) meter: TemporalMeter,
-    pub(crate) gauge: Arc<dyn CoreGauge>,
+    pub(crate) gauge: CoreGauge,
 }
 impl MutableFinalize for Gauge {}
 
 pub struct GaugeF64 {
     pub(crate) meter: TemporalMeter,
-    pub(crate) gauge: Arc<dyn CoreGaugeF64>,
+    pub(crate) gauge: CoreGaugeF64,
 }
 impl MutableFinalize for GaugeF64 {}