@temporalio/core-bridge 0.19.2 → 0.20.0

package/sdk-core/tests/load_tests.rs

@@ -1,6 +1,7 @@
 use assert_matches::assert_matches;
 use futures::future::join_all;
 use std::time::{Duration, Instant};
+use temporal_client::WorkflowOptions;
 use temporal_sdk::{ActivityOptions, WfContext};
 use temporal_sdk_core_protos::coresdk::{
     activity_result::ActivityExecutionResult, activity_task::activity_task as act_task,
@@ -19,7 +20,6 @@ async fn activity_load() {
         .max_at_polls(10)
         .max_at(CONCURRENCY);
     let mut worker = starter.worker().await;
-    let task_q = starter.get_task_queue().to_owned();
 
     let activity_id = "act-1";
     let activity_timeout = Duration::from_secs(8);
@@ -57,7 +57,12 @@ async fn activity_load() {
         let wf_id = format!("activity_load_{}", i);
         async move {
             worker
-                .submit_wf(wf_id, wf_type.to_owned(), vec![])
+                .submit_wf(
+                    wf_id,
+                    wf_type.to_owned(),
+                    vec![],
+                    WorkflowOptions::default(),
+                )
                 .await
                 .unwrap();
         }
@@ -66,15 +71,14 @@ async fn activity_load() {
     dbg!(starting.elapsed());
 
     let running = Instant::now();
-    let core = starter.get_core().await;
+    let core = starter.get_worker().await;
 
     // Poll for and complete all activities
     let c2 = core.clone();
     let all_acts = async move {
         let mut act_complete_futs = vec![];
         for _ in 0..CONCURRENCY {
-            let task_q = task_q.clone();
-            let task = c2.poll_activity_task(&task_q).await.unwrap();
+            let task = c2.poll_activity_task().await.unwrap();
             assert_matches!(
                 task.variant,
                 Some(act_task::Variant::Start(ref start_activity)) => {
@@ -86,7 +90,6 @@ async fn activity_load() {
             act_complete_futs.push(tokio::spawn(async move {
                 core.complete_activity_task(ActivityTaskCompletion {
                     task_token: task.task_token,
-                    task_queue: task_q,
                     result: Some(ActivityExecutionResult::ok(pd.into())),
                 })
                 .await

package/sdk-core/tests/main.rs

@@ -2,19 +2,53 @@
 
 #[cfg(test)]
 mod integ_tests {
-    use std::str::FromStr;
-    use temporal_sdk_core::{
-        ClientTlsConfig, ServerGatewayApis, ServerGatewayOptionsBuilder, TlsConfig,
-    };
-    use temporal_sdk_core_test_utils::NAMESPACE;
-    use url::Url;
-
     mod client_tests;
     mod heartbeat_tests;
     mod polling_tests;
     mod queries_tests;
     mod workflow_tests;
 
+    use std::str::FromStr;
+    use temporal_client::WorkflowService;
+    use temporal_sdk_core::{
+        init_worker, telemetry_init, ClientOptionsBuilder, ClientTlsConfig, TlsConfig,
+        WorkflowClientTrait,
+    };
+    use temporal_sdk_core_api::{worker::WorkerConfigBuilder, CoreTelemetry};
+    use temporal_sdk_core_protos::temporal::api::workflowservice::v1::ListNamespacesRequest;
+    use temporal_sdk_core_test_utils::{
+        get_integ_server_options, get_integ_telem_options, NAMESPACE,
+    };
+    use url::Url;
+
+    // Create a worker like a bridge would (unwraps aside)
+    #[tokio::test]
+    #[ignore] // Really a compile time check more than anything
+    async fn lang_bridge_example() {
+        let opts = get_integ_server_options();
+        let telem_d = telemetry_init(&get_integ_telem_options()).unwrap();
+        let mut retrying_client = opts
+            .connect_no_namespace(telem_d.get_metric_meter())
+            .await
+            .unwrap();
+
+        let _worker = init_worker(
+            WorkerConfigBuilder::default()
+                .namespace("default")
+                .task_queue("Wheee!")
+                .build()
+                .unwrap(),
+            // clone the client if you intend to use it later. Strip off the retry wrapper since
+            // worker will assert its own
+            retrying_client.clone(),
+        );
+
+        // Do things with worker or client
+        let _ = retrying_client
+            .list_namespaces(ListNamespacesRequest::default())
+            .await;
+    }
+
     // TODO: Currently ignored because starting up the docker image with TLS requires some hoop
     //  jumping. We should upgrade CI to be able to do that but this was manually run against
     //  https://github.com/temporalio/customization-samples/tree/master/tls/tls-simple
@@ -37,9 +71,8 @@ mod integ_tests {
         )
         .await
         .unwrap();
-        let sgo = ServerGatewayOptionsBuilder::default()
+        let sgo = ClientOptionsBuilder::default()
             .target_url(Url::from_str("https://localhost:7233").unwrap())
-            .namespace(NAMESPACE.to_string())
             .worker_binary_id("binident".to_string())
             .tls_cfg(TlsConfig {
                 server_root_ca_cert: Some(root),
@@ -51,7 +84,7 @@ mod integ_tests {
             })
             .build()
             .unwrap();
-        let con = sgo.connect(None).await.unwrap();
+        let con = sgo.connect(NAMESPACE.to_string(), None).await.unwrap();
         con.list_namespaces().await.unwrap();
     }
 }

package/src/conversions.rs

@@ -9,8 +9,8 @@ use opentelemetry::trace::{SpanContext, SpanId, TraceFlags, TraceId, TraceState}
 use std::{fmt::Display, net::SocketAddr, str::FromStr, time::Duration};
 use temporal_sdk_core::{
     api::worker::{WorkerConfig, WorkerConfigBuilder},
-    ClientTlsConfig, RetryConfig, ServerGatewayOptions, ServerGatewayOptionsBuilder,
-    TelemetryOptions, TelemetryOptionsBuilder, TlsConfig, Url,
+    ClientOptions, ClientOptionsBuilder, ClientTlsConfig, RetryConfig, TelemetryOptions,
+    TelemetryOptionsBuilder, TlsConfig, Url,
 };
 
 macro_rules! js_value_getter {
@@ -105,10 +105,7 @@ where
 
 pub(crate) trait ObjectHandleConversionsExt {
     fn as_otel_span_context(&self, ctx: &mut FunctionContext) -> NeonResult<SpanContext>;
-    fn as_server_gateway_options(
-        &self,
-        ctx: &mut FunctionContext,
-    ) -> NeonResult<ServerGatewayOptions>;
+    fn as_client_options(&self, ctx: &mut FunctionContext) -> NeonResult<ClientOptions>;
     fn as_telemetry_options(&self, cx: &mut FunctionContext) -> NeonResult<TelemetryOptions>;
     fn as_worker_config(&self, cx: &mut FunctionContext) -> NeonResult<WorkerConfig>;
 }
@@ -127,10 +124,7 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
         ))
     }
 
-    fn as_server_gateway_options(
-        &self,
-        cx: &mut FunctionContext,
-    ) -> NeonResult<ServerGatewayOptions> {
+    fn as_client_options(&self, cx: &mut FunctionContext) -> NeonResult<ClientOptions> {
         let url = match Url::parse(&js_value_getter!(cx, self, "url", JsString)) {
             Ok(url) => url,
             // Note that address is what's used in the Node side.
@@ -204,7 +198,7 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             },
         };
 
-        let mut gateway_opts = ServerGatewayOptionsBuilder::default();
+        let mut gateway_opts = ClientOptionsBuilder::default();
         if let Some(tls_cfg) = tls_cfg {
             gateway_opts.tls_cfg(tls_cfg);
         }
@@ -212,7 +206,6 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             .client_name("temporal-typescript".to_string())
             .client_version(js_value_getter!(cx, self, "sdkVersion", JsString))
             .target_url(url)
-            .namespace(js_value_getter!(cx, self, "namespace", JsString))
             .identity(js_value_getter!(cx, self, "identity", JsString))
             .worker_binary_id(js_value_getter!(cx, self, "workerBinaryId", JsString))
             .retry_config(retry_config)
@@ -255,6 +248,7 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
     }
 
     fn as_worker_config(&self, cx: &mut FunctionContext) -> NeonResult<WorkerConfig> {
+        let namespace = js_value_getter!(cx, self, "namespace", JsString);
         let task_queue = js_value_getter!(cx, self, "taskQueue", JsString);
         let max_outstanding_activities =
             js_value_getter!(cx, self, "maxConcurrentActivityTaskExecutions", JsNumber) as usize;
@@ -298,6 +292,7 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             .max_cached_workflows(max_cached_workflows)
             .nonsticky_to_sticky_poll_ratio(nonsticky_to_sticky_poll_ratio)
             .sticky_queue_schedule_to_start_timeout(sticky_queue_schedule_to_start_timeout)
+            .namespace(namespace)
             .task_queue(task_queue)
             .max_heartbeat_throttle_interval(max_heartbeat_throttle_interval)
             .default_heartbeat_throttle_interval(default_heartbeat_throttle_interval)