@temporalio/core-bridge 1.13.2 → 1.14.0

package/sdk-core/{fsm/rustfsm_procmacro/tests/trybuild → crates/sdk-core/tests/fsm_trybuild}/tuple_zero_item_event_variant_fail.rs

@@ -1,6 +1,4 @@
-extern crate rustfsm_trait as rustfsm;
-
-use rustfsm_procmacro::fsm;
+use temporalio_macros::fsm;
 
 fsm! {
     name Simple; command SimpleCmd; error Infallible;

package/sdk-core/crates/sdk-core/tests/fsm_trybuild/tuple_zero_item_event_variant_fail.stderr

@@ -0,0 +1,5 @@
+error: Only tuple variants with exactly one item are supported for events
+ --> tests/fsm_trybuild/tuple_zero_item_event_variant_fail.rs:6:12
+  |
+6 |     One --(A(), on_a)--> Two
+  |            ^

package/sdk-core/{tests → crates/sdk-core/tests}/global_metric_tests.rs

@@ -2,16 +2,17 @@
 #[allow(dead_code)]
 mod common;
 
+use crate::common::get_integ_runtime_options;
 use common::CoreWfStarter;
 use parking_lot::Mutex;
 use std::{sync::Arc, time::Duration};
-use temporal_sdk_core::{
+use temporalio_common::telemetry::{
+    Logger, OtelCollectorOptionsBuilder, TelemetryOptionsBuilder, metrics::CoreMeter,
+};
+use temporalio_sdk_core::{
     CoreRuntime,
     telemetry::{build_otlp_metric_exporter, construct_filter_string, telemetry_init_global},
 };
-use temporal_sdk_core_api::telemetry::{
-    Logger, OtelCollectorOptionsBuilder, TelemetryOptionsBuilder, metrics::CoreMeter,
-};
 use tracing::Level;
 use tracing_subscriber::fmt::MakeWriter;
 
@@ -71,18 +72,16 @@ async fn otel_errors_logged_as_errors() {
             .unwrap(),
     )
     .unwrap();
+    let telemopts = TelemetryOptionsBuilder::default()
+        .metrics(Arc::new(exporter) as Arc<dyn CoreMeter>)
+        // Importantly, _not_ using subscriber override, is using console.
+        .logging(Logger::Console {
+            filter: construct_filter_string(Level::INFO, Level::WARN),
+        })
+        .build()
+        .unwrap();
 
-    let rt = CoreRuntime::new_assume_tokio(
-        TelemetryOptionsBuilder::default()
-            .metrics(Arc::new(exporter) as Arc<dyn CoreMeter>)
-            // Importantly, _not_ using subscriber override, is using console.
-            .logging(Logger::Console {
-                filter: construct_filter_string(Level::INFO, Level::WARN),
-            })
-            .build()
-            .unwrap(),
-    )
-    .unwrap();
+    let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let mut starter = CoreWfStarter::new_with_runtime("otel_errors_logged_as_errors", rt);
     let _worker = starter.get_worker().await;
 

package/sdk-core/{tests → crates/sdk-core/tests/heavy_tests}/fuzzy_workflow.rs

@@ -2,11 +2,11 @@ use crate::common::CoreWfStarter;
 use futures_util::{FutureExt, StreamExt, sink, stream::FuturesUnordered};
 use rand::{Rng, SeedableRng, prelude::Distribution, rngs::SmallRng};
 use std::{future, time::Duration};
-use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions};
-use temporal_sdk::{
+use temporalio_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions};
+use temporalio_common::protos::coresdk::{AsJsonPayloadExt, FromJsonPayloadExt, IntoPayloadsExt};
+use temporalio_sdk::{
     ActContext, ActivityError, ActivityOptions, LocalActivityOptions, WfContext, WorkflowResult,
 };
-use temporal_sdk_core_protos::coresdk::{AsJsonPayloadExt, FromJsonPayloadExt, IntoPayloadsExt};
 use tokio_util::sync::CancellationToken;
 
 const FUZZY_SIG: &str = "fuzzy_sig";

package/sdk-core/{tests → crates/sdk-core/tests}/heavy_tests.rs

@@ -1,7 +1,11 @@
 // All non-main.rs tests ignore dead common code so that the linter doesn't complain about about it.
 #[allow(dead_code)]
-mod common;
+pub(crate) mod common;
+// This prevents cargo from auto-picking up this file as its own test binary. Odd but functional.
+#[path = "heavy_tests/fuzzy_workflow.rs"]
+mod fuzzy_workflow;
 
+use crate::common::get_integ_runtime_options;
 use common::{
     CoreWfStarter, init_integ_telem, prom_metrics, rand_6_chars, workflows::la_problem_workflow,
 };
@@ -17,16 +21,19 @@ use std::{
     sync::Arc,
     time::{Duration, Instant},
 };
-use temporal_client::{GetWorkflowResultOpts, WfClientExt, WorkflowClientTrait, WorkflowOptions};
-use temporal_sdk::{ActContext, ActivityOptions, WfContext, WorkflowResult};
-use temporal_sdk_core::{CoreRuntime, ResourceBasedTuner, ResourceSlotOptions};
-use temporal_sdk_core_api::worker::PollerBehavior;
-use temporal_sdk_core_protos::{
-    coresdk::{AsJsonPayloadExt, workflow_commands::ActivityCancellationType},
-    temporal::api::enums::v1::WorkflowIdReusePolicy,
+use temporalio_client::{
+    GetWorkflowResultOptions, WfClientExt, WorkflowClientTrait, WorkflowOptions,
 };
 
-mod fuzzy_workflow;
+use temporalio_common::{
+    protos::{
+        coresdk::{AsJsonPayloadExt, workflow_commands::ActivityCancellationType},
+        temporal::api::enums::v1::WorkflowIdReusePolicy,
+    },
+    worker::{PollerBehavior, WorkerTaskTypes},
+};
+use temporalio_sdk::{ActContext, ActivityOptions, WfContext, WorkflowResult};
+use temporalio_sdk_core::{CoreRuntime, ResourceBasedTuner, ResourceSlotOptions};
 
 #[tokio::test]
 async fn activity_load() {
@@ -194,7 +201,7 @@ async fn workflow_load() {
     // cause us to encounter the tracing span drop bug
     telemopts.logging = None;
     init_integ_telem();
-    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let mut starter = CoreWfStarter::new_with_runtime("workflow_load", rt);
     starter
         .worker_config
@@ -345,7 +352,7 @@ async fn can_paginate_long_history() {
     let mut starter = CoreWfStarter::new(wf_name);
     starter
         .worker_config
-        .no_remote_activities(true)
+        .task_types(WorkerTaskTypes::workflow_only())
         // Do not use sticky queues so we are forced to paginate once history gets long
         .max_cached_workflows(0_usize);
 
@@ -457,7 +464,7 @@ async fn poller_autoscaling_basic_loadtest() {
         stream::iter(mem::take(&mut workflow_handles))
             .for_each_concurrent(25, |handle| async move {
                 let _ = handle
-                    .get_workflow_result(GetWorkflowResultOpts::default())
+                    .get_workflow_result(GetWorkflowResultOptions::default())
                     .await;
             })
             .await;

package/sdk-core/{tests → crates/sdk-core/tests}/integ_tests/activity_functions.rs

@@ -1,4 +1,4 @@
-use temporal_sdk::{ActContext, ActivityError};
+use temporalio_sdk::{ActContext, ActivityError};
 
 pub(crate) async fn echo(_ctx: ActContext, e: String) -> Result<String, ActivityError> {
     Ok(e)

package/sdk-core/{tests → crates/sdk-core/tests}/integ_tests/client_tests.rs

@@ -1,24 +1,27 @@
-use crate::common::{CoreWfStarter, NAMESPACE, get_integ_server_options, http_proxy::HttpProxy};
+use crate::common::{
+    CoreWfStarter, NAMESPACE,
+    fake_grpc_server::{GenericService, fake_server},
+    get_integ_server_options,
+    http_proxy::HttpProxy,
+};
 use assert_matches::assert_matches;
-use futures_util::{FutureExt, future::BoxFuture};
+use futures_util::FutureExt;
 use http_body_util::Full;
 use prost::Message;
 use std::{
     collections::HashMap,
-    convert::Infallible,
     env,
     sync::{
         Arc,
         atomic::{AtomicUsize, Ordering},
     },
-    task::{Context, Poll},
     time::Duration,
 };
-use temporal_client::{
-    HttpConnectProxyOptions, Namespace, RETRYABLE_ERROR_CODES, RetryConfig, WorkflowClientTrait,
-    WorkflowService,
+use temporalio_client::{
+    Namespace, RETRYABLE_ERROR_CODES, RetryOptions, WorkflowClientTrait, WorkflowService,
+    proxy::HttpConnectProxyOptions,
 };
-use temporal_sdk_core_protos::temporal::api::{
+use temporalio_common::protos::temporal::api::{
     cloud::cloudservice::v1::GetNamespaceRequest,
     workflowservice::v1::{
         DescribeNamespaceRequest, GetWorkflowExecutionHistoryRequest,
@@ -27,16 +30,9 @@ use temporal_sdk_core_protos::temporal::api::{
 };
 #[cfg(unix)]
 use tokio::net::UnixListener;
-use tokio::{
-    net::TcpListener,
-    sync::{mpsc::UnboundedSender, oneshot},
-};
+use tokio::{net::TcpListener, sync::oneshot};
 use tonic::{
-    Code, IntoRequest, Request, Status,
-    body::Body,
-    codegen::{Service, http::Response},
-    server::NamedService,
-    transport::Server,
+    Code, IntoRequest, Request, Status, body::Body, codegen::http::Response, transport::Server,
 };
 use tracing::info;
 
@@ -111,97 +107,6 @@ async fn per_call_timeout_respected_one_call() {
     );
 }
 
-#[derive(Clone)]
-struct GenericService<F> {
-    header_to_parse: &'static str,
-    header_tx: UnboundedSender<String>,
-    response_maker: F,
-}
-impl<F> Service<tonic::codegen::http::Request<Body>> for GenericService<F>
-where
-    F: FnMut(tonic::codegen::http::Request<Body>) -> BoxFuture<'static, Response<Body>>,
-{
-    type Response = Response<Body>;
-    type Error = Infallible;
-    type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
-
-    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&mut self, req: tonic::codegen::http::Request<Body>) -> Self::Future {
-        self.header_tx
-            .send(
-                String::from_utf8_lossy(
-                    req.headers()
-                        .get(self.header_to_parse)
-                        .map(|hv| hv.as_bytes())
-                        .unwrap_or_default(),
-                )
-                .to_string(),
-            )
-            .unwrap();
-        let r = (self.response_maker)(req);
-        async move { Ok(r.await) }.boxed()
-    }
-}
-impl<F> NamedService for GenericService<F> {
-    const NAME: &'static str = "temporal.api.workflowservice.v1.WorkflowService";
-}
-
-struct FakeServer {
-    addr: std::net::SocketAddr,
-    shutdown_tx: oneshot::Sender<()>,
-    header_rx: tokio::sync::mpsc::UnboundedReceiver<String>,
-    pub server_handle: tokio::task::JoinHandle<()>,
-}
-
-async fn fake_server<F>(response_maker: F) -> FakeServer
-where
-    F: FnMut(tonic::codegen::http::Request<Body>) -> BoxFuture<'static, Response<Body>>
-        + Clone
-        + Send
-        + Sync
-        + 'static,
-{
-    let (shutdown_tx, shutdown_rx) = oneshot::channel::<()>();
-    let (header_tx, header_rx) = tokio::sync::mpsc::unbounded_channel();
-
-    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
-    let addr = listener.local_addr().unwrap();
-
-    let server_handle = tokio::spawn(async move {
-        Server::builder()
-            .add_service(GenericService {
-                header_to_parse: "grpc-timeout",
-                header_tx,
-                response_maker,
-            })
-            .serve_with_incoming_shutdown(
-                tokio_stream::wrappers::TcpListenerStream::new(listener),
-                async {
-                    shutdown_rx.await.ok();
-                },
-            )
-            .await
-            .unwrap();
-    });
-
-    FakeServer {
-        addr,
-        shutdown_tx,
-        header_rx,
-        server_handle,
-    }
-}
-
-impl FakeServer {
-    async fn shutdown(self) {
-        self.shutdown_tx.send(()).unwrap();
-        self.server_handle.await.unwrap();
-    }
-}
-
 #[tokio::test]
 async fn timeouts_respected_one_call_fake_server() {
     let mut fs = fake_server(|_| async { Response::new(Body::empty()) }.boxed()).await;
@@ -213,7 +118,7 @@ async fn timeouts_respected_one_call_fake_server() {
         .unwrap();
     opts.target_url = uri;
     opts.skip_get_system_info = true;
-    opts.retry_config = RetryConfig::no_retries();
+    opts.retry_options = RetryOptions::no_retries();
 
     let mut client = opts.connect_no_namespace(None).await.unwrap();
 
@@ -368,7 +273,7 @@ async fn namespace_header_attached_to_relevant_calls() {
     let uri = format!("http://localhost:{}", addr.port()).parse().unwrap();
     opts.target_url = uri;
     opts.skip_get_system_info = true;
-    opts.retry_config = RetryConfig::no_retries();
+    opts.retry_options = RetryOptions::no_retries();
 
     let namespace = "namespace";
     let client = opts.connect(namespace, None).await.unwrap();
@@ -447,7 +352,7 @@ async fn http_proxy() {
 
     // General client options
     let mut opts = get_integ_server_options();
-    opts.retry_config = RetryConfig::no_retries();
+    opts.retry_options = RetryOptions::no_retries();
     opts.skip_get_system_info = true;
 
     // Connect client with no proxy and make call and confirm reached

package/sdk-core/{tests → crates/sdk-core/tests}/integ_tests/ephemeral_server_tests.rs

@@ -1,12 +1,12 @@
 use crate::common::{INTEG_CLIENT_IDENTITY, INTEG_CLIENT_NAME, INTEG_CLIENT_VERSION, NAMESPACE};
 use futures_util::{TryStreamExt, stream};
 use std::time::{SystemTime, UNIX_EPOCH};
-use temporal_client::{ClientOptionsBuilder, TestService, WorkflowService};
-use temporal_sdk_core::ephemeral_server::{
+use temporalio_client::{ClientOptions, TestService, WorkflowService};
+use temporalio_common::protos::temporal::api::workflowservice::v1::DescribeNamespaceRequest;
+use temporalio_sdk_core::ephemeral_server::{
     EphemeralExe, EphemeralExeVersion, EphemeralServer, TemporalDevServerConfigBuilder,
     default_cached_download,
 };
-use temporal_sdk_core_protos::temporal::api::workflowservice::v1::DescribeNamespaceRequest;
 use tonic::IntoRequest;
 use url::Url;
 
@@ -85,7 +85,7 @@ async fn temporal_cli_concurrent_starts() -> Result<(), Box<dyn std::error::Erro
 #[cfg(not(all(target_os = "linux", any(target_arch = "arm", target_arch = "aarch64"))))]
 mod test_server {
     use super::*;
-    use temporal_sdk_core::ephemeral_server::TestServerConfigBuilder;
+    use temporalio_sdk_core::ephemeral_server::TestServerConfigBuilder;
 
     #[tokio::test]
     async fn test_server_default() {
@@ -137,13 +137,12 @@ fn fixed_cached_download(version: &str) -> EphemeralExe {
 
 async fn assert_ephemeral_server(server: &EphemeralServer) {
     // Connect and describe namespace
-    let mut client = ClientOptionsBuilder::default()
+    let mut client = ClientOptions::builder()
         .identity(INTEG_CLIENT_IDENTITY.to_string())
         .target_url(Url::try_from(&*format!("http://{}", server.target)).unwrap())
         .client_name(INTEG_CLIENT_NAME.to_string())
         .client_version(INTEG_CLIENT_VERSION.to_string())
         .build()
-        .unwrap()
         .connect_no_namespace(None)
         .await
         .unwrap();

package/sdk-core/{tests → crates/sdk-core/tests}/integ_tests/heartbeat_tests.rs

@@ -1,28 +1,32 @@
 use crate::common::{CoreWfStarter, init_core_and_create_wf};
 use assert_matches::assert_matches;
 use std::time::Duration;
-use temporal_client::{WfClientExt, WorkflowOptions};
-use temporal_sdk::{ActContext, ActivityOptions, WfContext};
-use temporal_sdk_core::test_help::{WorkerTestHelpers, drain_pollers_and_shutdown};
-use temporal_sdk_core_protos::{
-    DEFAULT_ACTIVITY_TYPE,
-    coresdk::{
-        ActivityHeartbeat, ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion,
-        activity_result::{
-            self, ActivityExecutionResult, ActivityResolution, activity_resolution as act_res,
-        },
-        activity_task::activity_task,
-        workflow_activation::{ResolveActivity, WorkflowActivationJob, workflow_activation_job},
-        workflow_commands::{ActivityCancellationType, ScheduleActivity},
-        workflow_completion::WorkflowActivationCompletion,
-    },
+use temporalio_client::{WfClientExt, WorkflowOptions};
+use temporalio_common::{
     prost_dur,
-    temporal::api::{
-        common::v1::{Payload, RetryPolicy},
-        enums::v1::TimeoutType,
+    protos::{
+        DEFAULT_ACTIVITY_TYPE,
+        coresdk::{
+            ActivityHeartbeat, ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion,
+            activity_result::{
+                self, ActivityExecutionResult, ActivityResolution, activity_resolution as act_res,
+            },
+            activity_task::activity_task,
+            workflow_activation::{
+                ResolveActivity, WorkflowActivationJob, workflow_activation_job,
+            },
+            workflow_commands::{ActivityCancellationType, ScheduleActivity},
+            workflow_completion::WorkflowActivationCompletion,
+        },
+        temporal::api::{
+            common::v1::{Payload, RetryPolicy},
+            enums::v1::TimeoutType,
+        },
+        test_utils::schedule_activity_cmd,
     },
-    test_utils::schedule_activity_cmd,
 };
+use temporalio_sdk::{ActContext, ActivityOptions, WfContext};
+use temporalio_sdk_core::test_help::{WorkerTestHelpers, drain_pollers_and_shutdown};
 use tokio::time::sleep;
 
 #[tokio::test]