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

package/sdk-core/crates/sdk-core/src/core_tests/workflow_tasks.rs

@@ -1,5 +1,5 @@
 use crate::{
-    PollWorkflowOptions, Worker, advance_fut,
+    PollError, PollWorkflowOptions, Worker, advance_fut,
     internal_flags::CoreInternalFlags,
     job_assert,
     replay::TestHistoryBuilder,
@@ -11,7 +11,8 @@ use crate::{
         poll_and_reply_clears_outstanding_evicts, single_hist_mock_sg, test_worker_cfg,
     },
     worker::{
-        TunerBuilder,
+        PollerBehavior, SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext,
+        SlotSupplier, SlotSupplierPermit, TunerBuilder, WorkflowSlotKind,
         client::mocks::{mock_manual_worker_client, mock_worker_client},
     },
 };
@@ -29,8 +30,6 @@ use std::{
 };
 use temporalio_client::MESSAGE_TOO_LARGE_KEY;
 use temporalio_common::{
-    Worker as WorkerTrait,
-    errors::PollError,
     protos::{
         canned_histories,
         coresdk::{
@@ -64,10 +63,7 @@ use temporalio_common::{
         },
         test_utils::start_timer_cmd,
     },
-    worker::{
-        PollerBehavior, SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext,
-        SlotSupplier, SlotSupplierPermit, WorkerTaskTypes, WorkflowSlotKind,
-    },
+    worker::WorkerTaskTypes,
 };
 use tokio::{
     join,
@@ -1621,6 +1617,7 @@ async fn history_byte_size_and_can_suggestion_in_activation() {
             he.attributes
         {
             attrs.suggest_continue_as_new = true;
+            attrs.suggest_continue_as_new_reasons = vec![1, 2, 3, 4]
         }
     });
 
@@ -1645,6 +1642,7 @@ async fn history_byte_size_and_can_suggestion_in_activation() {
     let activation = worker.poll_workflow_activation().await.unwrap();
     assert_eq!(activation.history_size_bytes, 70);
     assert!(activation.continue_as_new_suggested);
+    assert_eq!(activation.suggest_continue_as_new_reasons, vec![1, 2, 3, 4])
 }
 
 /// This test verifies that WFTs which come as replies to completing a WFT are properly delivered
@@ -2022,12 +2020,15 @@ async fn no_race_acquiring_permits() {
         .returning(|_| async move { Ok(Default::default()) }.boxed());
 
     let worker = Worker::new_test(
-        test_worker_cfg()
-            .max_outstanding_workflow_tasks(2_usize)
-            .max_cached_workflows(0_usize)
-            .ignore_evicts_on_shutdown(false)
-            .build()
-            .unwrap(),
+        {
+            let mut cfg = test_worker_cfg()
+                .max_outstanding_workflow_tasks(2_usize)
+                .max_cached_workflows(0_usize)
+                .build()
+                .unwrap();
+            cfg.ignore_evicts_on_shutdown = false;
+            cfg
+        },
         mock_client,
     );
 
@@ -2667,13 +2668,14 @@ async fn poller_wont_run_ahead_of_task_slots() {
         .returning(|_| Ok(Default::default()));
 
     let worker = Worker::new_test(
-        test_worker_cfg()
-            .max_cached_workflows(10_usize)
-            .max_outstanding_workflow_tasks(10_usize)
-            .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(10_usize))
-            .task_types(WorkerTaskTypes::workflow_only())
-            .build()
-            .unwrap(),
+        {
+            let mut cfg = test_worker_cfg().build().unwrap();
+            cfg.max_cached_workflows = 10_usize;
+            cfg.max_outstanding_workflow_tasks = Some(10_usize);
+            cfg.workflow_task_poller_behavior = PollerBehavior::SimpleMaximum(10_usize);
+            cfg.task_types = WorkerTaskTypes::workflow_only();
+            cfg
+        },
         mock_client,
     );
 
@@ -2730,10 +2732,11 @@ async fn poller_wont_poll_until_lang_polls() {
         });
 
     let worker = Worker::new_test(
-        test_worker_cfg()
-            .task_types(WorkerTaskTypes::workflow_only())
-            .build()
-            .unwrap(),
+        {
+            let mut cfg = test_worker_cfg().build().unwrap();
+            cfg.task_types = WorkerTaskTypes::workflow_only();
+            cfg
+        },
         mock_client,
     );
 
@@ -2868,17 +2871,18 @@ async fn slot_provider_cant_hand_out_more_permits_than_cache_size() {
     }
 
     let worker = Worker::new_test(
-        test_worker_cfg()
-            .max_cached_workflows(10_usize)
-            .tuner(Arc::new(
+        {
+            let mut cfg = test_worker_cfg().build().unwrap();
+            cfg.max_cached_workflows = 10_usize;
+            cfg.tuner = Some(Arc::new(
                 TunerBuilder::default()
                     .workflow_slot_supplier(Arc::new(EndlessSupplier {}))
                     .build(),
-            ))
-            .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(10_usize))
-            .task_types(WorkerTaskTypes::workflow_only())
-            .build()
-            .unwrap(),
+            ));
+            cfg.workflow_task_poller_behavior = PollerBehavior::SimpleMaximum(10_usize);
+            cfg.task_types = WorkerTaskTypes::workflow_only();
+            cfg
+        },
         mock_client,
     );
 
@@ -3019,14 +3023,15 @@ async fn both_normal_and_sticky_pollers_poll_concurrently() {
         });
 
     let worker = Worker::new(
-        test_worker_cfg()
-            .max_cached_workflows(500_usize) // We need cache, but don't want to deal with evictions
-            .max_outstanding_workflow_tasks(2_usize)
-            .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(2_usize))
-            .nonsticky_to_sticky_poll_ratio(0.2)
-            .task_types(WorkerTaskTypes::workflow_only())
-            .build()
-            .unwrap(),
+        {
+            let mut cfg = test_worker_cfg().build().unwrap();
+            cfg.max_cached_workflows = 500_usize; // We need cache, but don't want to deal with evictions
+            cfg.max_outstanding_workflow_tasks = Some(2_usize);
+            cfg.workflow_task_poller_behavior = PollerBehavior::SimpleMaximum(2_usize);
+            cfg.nonsticky_to_sticky_poll_ratio = 0.2;
+            cfg.task_types = WorkerTaskTypes::workflow_only();
+            cfg
+        },
         Some("stickytq".to_string()),
         Arc::new(mock_client),
         None,

package/sdk-core/crates/sdk-core/src/ephemeral_server/mod.rs

@@ -10,7 +10,7 @@ use std::{
     io,
     path::{Path, PathBuf},
 };
-use temporalio_client::ClientOptions;
+use temporalio_client::{Connection, ConnectionOptions};
 use tokio::{
     task::spawn_blocking,
     time::{Duration, sleep},
@@ -24,30 +24,28 @@ use std::os::unix::fs::OpenOptionsExt;
 use std::process::Stdio;
 
 /// Configuration for Temporal CLI dev server.
-#[derive(Debug, Clone, derive_builder::Builder)]
+#[derive(Debug, Clone, bon::Builder)]
+#[builder(on(String, into))]
 pub struct TemporalDevServerConfig {
     /// Required path to executable or download info.
     pub exe: EphemeralExe,
     /// Namespace to use.
-    #[builder(default = "\"default\".to_owned()")]
+    #[builder(default = "default".to_owned())]
     pub namespace: String,
     /// IP to bind to.
-    #[builder(default = "\"127.0.0.1\".to_owned()")]
+    #[builder(default = "127.0.0.1".to_owned())]
     pub ip: String,
     /// Port to use or obtains a free one if none given.
-    #[builder(default)]
     pub port: Option<u16>,
     /// Port to use for the UI server or obtains a free one if none given.
-    #[builder(default)]
     pub ui_port: Option<u16>,
     /// Sqlite DB filename if persisting or non-persistent if none.
-    #[builder(default)]
     pub db_filename: Option<String>,
     /// Whether to enable the UI. If ui_port is set, assumes true.
     #[builder(default)]
     pub ui: bool,
     /// Log format and level
-    #[builder(default = "(\"pretty\".to_owned(), \"warn\".to_owned())")]
+    #[builder(default = ("pretty".to_owned(), "warn".to_owned()))]
     pub log: (String, String),
     /// Additional arguments to Temporal dev server.
     #[builder(default)]
@@ -131,12 +129,11 @@ impl TemporalDevServerConfig {
 }
 
 /// Configuration for the test server.
-#[derive(Debug, Clone, derive_builder::Builder)]
+#[derive(Debug, Clone, bon::Builder)]
 pub struct TestServerConfig {
     /// Required path to executable or download info.
     pub exe: EphemeralExe,
     /// Port to use or obtains a free one if none given.
-    #[builder(default)]
     pub port: Option<u16>,
     /// Additional arguments to the test server.
     #[builder(default)]
@@ -221,19 +218,19 @@ impl EphemeralServer {
             child,
         });
 
-        // Try to connect every 100ms for 5s
-        // TODO(cretz): Some other way, e.g. via stdout, to know whether the
-        // server is up?
-        let client_options = ClientOptions::builder()
+        let connection_options = ConnectionOptions::new(Url::parse(&target_url)?)
             .identity("online_checker".to_owned())
-            .target_url(Url::parse(&target_url)?)
             .client_name("online-checker".to_owned())
             .client_version("0.1.0".to_owned())
             .build();
+
+        // Try to connect every 100ms for 5s
+        // TODO(cretz): Some other way, e.g. via stdout, to know whether the
+        // server is up?
         let mut last_error = None;
         for _ in 0..50 {
             sleep(Duration::from_millis(100)).await;
-            let connect_res = client_options.connect_no_namespace(None).await;
+            let connect_res = Connection::connect(connection_options.clone()).await;
             if let Err(err) = connect_res {
                 last_error = Some(err);
             } else {

package/sdk-core/crates/sdk-core/src/histfetch.rs

@@ -5,27 +5,37 @@
 //! We can use `clap` if this needs more arguments / other stuff later on.
 
 use prost::Message;
-use temporalio_client::{ClientOptions, WorkflowClientTrait};
+use temporalio_client::{
+    Client, ClientOptions, Connection, ConnectionOptions, NamespacedClient, WorkflowExecutionInfo,
+    WorkflowFetchHistoryOptions,
+};
+use temporalio_common::protos::temporal::api::history::v1::History;
 use url::Url;
 
 #[tokio::main]
 async fn main() -> Result<(), anyhow::Error> {
-    let url = Url::try_from("http://localhost:7233").unwrap();
-    let copts = ClientOptions::builder()
+    let copts = ConnectionOptions::new(Url::try_from("http://localhost:7233").unwrap())
         .client_name("histfetch")
         .client_version("0.0")
-        .target_url(url)
         .build();
-    let client = copts.connect("default", None).await?;
+    let connection = Connection::connect(copts).await?;
+    let client = Client::new(connection, ClientOptions::new("default").build())?;
     let wf_id = std::env::args()
         .nth(1)
         .expect("must provide workflow id as only argument");
-    let run_id = std::env::args().nth(2);
-    let hist = client
-        .get_workflow_execution_history(wf_id.clone(), run_id, vec![])
+    let run_id = std::env::args().nth(2).filter(|s| !s.is_empty());
+    let handle = WorkflowExecutionInfo {
+        namespace: client.namespace(),
+        workflow_id: wf_id.clone(),
+        run_id,
+        first_execution_run_id: None,
+    }
+    .bind_untyped(client);
+    let events = handle
+        .fetch_history(WorkflowFetchHistoryOptions::default())
         .await?
-        .history
-        .expect("history field must be populated");
+        .into_events();
+    let hist = History { events };
     // Serialize history to file
     let byteified = hist.encode_to_vec();
     tokio::fs::write(format!("{wf_id}_history.bin"), &byteified).await?;

package/sdk-core/crates/sdk-core/src/lib.rs

@@ -2,7 +2,9 @@
 #![allow(clippy::upper_case_acronyms)]
 
 //! This crate provides a basis for creating new Temporal SDKs without completely starting from
-//! scratch
+//! scratch. APIs provided by this crate are not considered stable and may break at any time.
+//!
+//! If you are looking for the Temporal Rust SDK, please use `temporalio-sdk`.
 
 #[cfg(test)]
 #[macro_use]
@@ -32,41 +34,38 @@ mod core_tests;
 #[macro_use]
 pub mod test_help;
 
-pub(crate) use temporalio_common::errors;
-
-pub use pollers::{
-    Client, ClientOptions, ClientTlsOptions, RetryClient, RetryOptions, TlsOptions,
-    WorkflowClientTrait,
+pub use crate::worker::client::{
+    PollActivityOptions, PollOptions, PollWorkflowOptions, WorkerClient, WorkflowTaskCompletion,
 };
+pub use pollers::{Client, ClientOptions, ClientTlsOptions, RetryOptions, TlsOptions};
 pub use temporalio_common::protos::TaskToken;
 pub use url::Url;
 pub use worker::{
-    FixedSizeSlotSupplier, ResourceBasedSlotsOptions, ResourceBasedSlotsOptionsBuilder,
-    ResourceBasedTuner, ResourceSlotOptions, SlotSupplierOptions, TunerBuilder, TunerHolder,
-    TunerHolderOptions, TunerHolderOptionsBuilder, Worker, WorkerConfig, WorkerConfigBuilder,
+    ActivitySlotKind, CompleteActivityError, CompleteNexusError, CompleteWfError,
+    FixedSizeSlotSupplier, LocalActivitySlotKind, NexusSlotKind, PollError, PollerBehavior,
+    ResourceBasedSlotsOptions, ResourceBasedSlotsOptionsBuilder, ResourceBasedTuner,
+    ResourceSlotOptions, SlotInfo, SlotInfoTrait, SlotKind, SlotKindType, SlotMarkUsedContext,
+    SlotReleaseContext, SlotReservationContext, SlotSupplier, SlotSupplierOptions,
+    SlotSupplierPermit, TunerBuilder, TunerHolder, TunerHolderOptions, TunerHolderOptionsBuilder,
+    Worker, WorkerConfig, WorkerConfigBuilder, WorkerTuner, WorkerValidationError,
+    WorkerVersioningStrategy, WorkflowErrorType, WorkflowSlotKind,
 };
 
-/// Expose [WorkerClient] symbols
-pub use crate::worker::client::{
-    PollActivityOptions, PollOptions, PollWorkflowOptions, WorkerClient, WorkflowTaskCompletion,
-};
 use crate::{
     replay::{HistoryForReplay, ReplayWorkerInput},
-    telemetry::{
-        TelemetryInstance, metrics::MetricsContext, remove_trace_subscriber_for_current_thread,
-        set_trace_subscriber_for_current_thread, telemetry_init,
-    },
+    telemetry::metrics::MetricsContext,
     worker::client::WorkerClientBag,
 };
 use anyhow::bail;
 use futures_util::Stream;
 use std::{sync::Arc, time::Duration};
-use temporalio_client::{ConfiguredClient, NamespacedClient, SharedReplaceableClient};
+use temporalio_client::{Connection, SharedReplaceableClient};
 use temporalio_common::{
-    Worker as WorkerTrait,
-    errors::{CompleteActivityError, PollError},
     protos::coresdk::ActivityHeartbeat,
-    telemetry::TelemetryOptions,
+    telemetry::{
+        TelemetryInstance, TelemetryOptions, remove_trace_subscriber_for_current_thread,
+        set_trace_subscriber_for_current_thread, telemetry_init,
+    },
 };
 
 /// Initialize a worker bound to a task queue.
@@ -75,44 +74,37 @@ use temporalio_common::{
 /// After the worker is initialized, you should use [CoreRuntime::tokio_handle] to run the worker's
 /// async functions.
 ///
-/// Lang implementations may pass in a [ConfiguredClient] directly (or a
-/// [RetryClient] wrapping one, or a handful of other variants of the same idea). When they do so,
-/// this function will always overwrite the client retry configuration, force the client to use the
-/// namespace defined in the worker config, and set the client identity appropriately. IE: Use
-/// [ClientOptions::connect_no_namespace], not [ClientOptions::connect].
-pub fn init_worker<CT>(
+/// Lang implementations must pass in a [Client] When they do so, this function will always
+/// overwrite the client retry configuration, force the client to use the namespace defined in the
+/// worker config, and set the client identity appropriately.
+pub fn init_worker(
     runtime: &CoreRuntime,
     worker_config: WorkerConfig,
-    client: CT,
-) -> Result<Worker, anyhow::Error>
-where
-    CT: Into<sealed::AnyClient>,
-{
+    mut connection: Connection,
+) -> Result<Worker, anyhow::Error> {
     let namespace = worker_config.namespace.clone();
     if namespace.is_empty() {
         bail!("Worker namespace cannot be empty");
     }
 
-    let client = RetryClient::new(
-        SharedReplaceableClient::new(init_worker_client(
-            worker_config.namespace.clone(),
-            worker_config.client_identity_override.clone(),
-            client,
-        )),
-        RetryOptions::default(),
+    *connection.retry_options_mut() = RetryOptions::default();
+    init_worker_client(
+        &mut connection,
+        worker_config.client_identity_override.clone(),
     );
-    let client_ident = client.identity();
-    let sticky_q = sticky_q_name_for_worker(&client_ident, worker_config.max_cached_workflows);
-
+    let client = SharedReplaceableClient::new(connection);
+    let client_ident = client.inner_cow().identity().to_owned();
     if client_ident.is_empty() {
         bail!("Client identity cannot be empty. Either lang or user should be setting this value");
     }
+    let sticky_q = sticky_q_name_for_worker(&client_ident, worker_config.max_cached_workflows);
 
+    let worker_instance_key = uuid::Uuid::new_v4();
     let client_bag = Arc::new(WorkerClientBag::new(
         client,
         namespace.clone(),
-        client_ident.clone(),
         worker_config.versioning_strategy.clone(),
+        worker_instance_key,
     ));
 
     Worker::new(
@@ -141,19 +133,13 @@ where
     rwi.into_core_worker()
 }
 
-pub(crate) fn init_worker_client<CT>(
-    namespace: String,
+pub(crate) fn init_worker_client(
+    connection: &mut Connection,
     client_identity_override: Option<String>,
-    client: CT,
-) -> Client
-where
-    CT: Into<sealed::AnyClient>,
-{
-    let mut client = Client::new(*client.into().into_inner(), namespace.clone());
+) {
     if let Some(ref id_override) = client_identity_override {
-        client.options_mut().identity.clone_from(id_override);
+        connection.identity_mut().clone_from(id_override);
     }
-    client
 }
 
 /// Creates a unique sticky queue name for a worker, iff the config allows for 1 or more cached
@@ -173,63 +159,6 @@ pub(crate) fn sticky_q_name_for_worker(
     }
 }
 
-mod sealed {
-    use super::*;
-    use temporalio_client::{SharedReplaceableClient, TemporalServiceClient};
-
-    /// Allows passing different kinds of clients into things that want to be flexible. Motivating
-    /// use-case was worker initialization.
-    ///
-    /// Needs to exist in this crate to avoid blanket impl conflicts.
-    pub struct AnyClient {
-        pub(crate) inner: Box<ConfiguredClient<TemporalServiceClient>>,
-    }
-    impl AnyClient {
-        pub(crate) fn into_inner(self) -> Box<ConfiguredClient<TemporalServiceClient>> {
-            self.inner
-        }
-    }
-
-    impl From<ConfiguredClient<TemporalServiceClient>> for AnyClient {
-        fn from(c: ConfiguredClient<TemporalServiceClient>) -> Self {
-            Self { inner: Box::new(c) }
-        }
-    }
-
-    impl From<Client> for AnyClient {
-        fn from(c: Client) -> Self {
-            c.into_inner().into()
-        }
-    }
-
-    impl<T> From<RetryClient<T>> for AnyClient
-    where
-        T: Into<AnyClient>,
-    {
-        fn from(c: RetryClient<T>) -> Self {
-            c.into_inner().into()
-        }
-    }
-
-    impl<T> From<SharedReplaceableClient<T>> for AnyClient
-    where
-        T: Into<AnyClient> + Clone + Send + Sync,
-    {
-        fn from(c: SharedReplaceableClient<T>) -> Self {
-            c.inner_clone().into()
-        }
-    }
-
-    impl<T> From<Arc<T>> for AnyClient
-    where
-        T: Into<AnyClient> + Clone,
-    {
-        fn from(c: Arc<T>) -> Self {
-            Arc::unwrap_or_clone(c).into()
-        }
-    }
-}
-
 /// Holds shared state/components needed to back instances of workers and clients. More than one
 /// may be instantiated, but typically only one is needed. More than one runtime instance may be
 /// useful if multiple different telemetry settings are required.
@@ -240,9 +169,10 @@ pub struct CoreRuntime {
     heartbeat_interval: Option<Duration>,
 }
 
-/// Holds telemetry options, as well as worker heartbeat_interval. Construct with [RuntimeOptionsBuilder]
-#[derive(Default, derive_builder::Builder)]
-#[builder(build_fn(validate = "Self::validate"))]
+/// Holds telemetry options, as well as worker heartbeat_interval. Construct with
+/// [RuntimeOptions::builder]
+#[derive(Default, bon::Builder)]
+#[builder(finish_fn(vis = "", name = build_internal))]
 #[non_exhaustive]
 pub struct RuntimeOptions {
     /// Telemetry configuration options.
@@ -252,21 +182,28 @@ pub struct RuntimeOptions {
     /// workers created using this runtime.
     ///
     /// Interval must be between 1s and 60s, inclusive.
-    #[builder(default = "Some(Duration::from_secs(60))")]
+    #[builder(required, default = Some(Duration::from_secs(60)))]
     heartbeat_interval: Option<Duration>,
 }
 
-impl RuntimeOptionsBuilder {
-    fn validate(&self) -> Result<(), String> {
-        if let Some(Some(interval)) = self.heartbeat_interval
-            && (interval < Duration::from_secs(1) || interval > Duration::from_secs(60))
+impl<S: runtime_options_builder::State> RuntimeOptionsBuilder<S> {
+    /// Builds the RuntimeOptions
+    ///
+    /// # Errors
+    /// Returns an error if heartbeat_interval is set but not between 1s and 60s inclusive.
+    pub fn build(self) -> Result<RuntimeOptions, String> {
+        let options = self.build_internal();
         {
-            return Err(format!(
-                "heartbeat_interval ({interval:?}) must be between 1s and 60s",
-            ));
+            if let Some(interval) = options.heartbeat_interval
+                && (interval < Duration::from_secs(1) || interval > Duration::from_secs(60))
+            {
+                return Err(format!(
+                    "heartbeat_interval ({interval:?}) must be between 1s and 60s",
+                ));
+            }
+
+            Ok(options)
         }
-
-        Ok(())
     }
 }
 

package/sdk-core/crates/sdk-core/src/pollers/mod.rs

@@ -3,23 +3,18 @@ mod poll_buffer;
 pub(crate) use poll_buffer::{
     ActivityTaskOptions, LongPollBuffer, WorkflowTaskOptions, WorkflowTaskPoller,
 };
-pub use temporalio_client::{
-    Client, ClientOptions, ClientTlsOptions, RetryClient, RetryOptions, TlsOptions,
-    WorkflowClientTrait,
-};
+pub use temporalio_client::{Client, ClientOptions, ClientTlsOptions, RetryOptions, TlsOptions};
 
 use crate::{
     abstractions::{OwnedMeteredSemPermit, TrackedOwnedMeteredSemPermit},
     telemetry::metrics::MetricsContext,
+    worker::{ActivitySlotKind, NexusSlotKind, SlotKind, WorkflowSlotKind},
 };
 use anyhow::{anyhow, bail};
 use futures_util::{Stream, stream};
 use std::{fmt::Debug, marker::PhantomData};
-use temporalio_common::{
-    protos::temporal::api::workflowservice::v1::{
-        PollActivityTaskQueueResponse, PollNexusTaskQueueResponse, PollWorkflowTaskQueueResponse,
-    },
-    worker::{ActivitySlotKind, NexusSlotKind, SlotKind, WorkflowSlotKind},
+use temporalio_common::protos::temporal::api::workflowservice::v1::{
+    PollActivityTaskQueueResponse, PollNexusTaskQueueResponse, PollWorkflowTaskQueueResponse,
 };
 use tokio::select;
 use tokio_util::sync::CancellationToken;