@temporalio/core-bridge 1.9.2 → 1.10.0

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

@@ -364,13 +364,16 @@ pub mod coresdk {
         #[derive(Serialize, Deserialize)]
         #[serde(remote = "Timestamp")]
         struct TimestampDef {
-            pub seconds: i64,
-            pub nanos: i32,
+            seconds: i64,
+            nanos: i32,
         }
         mod opt_timestamp {
             use super::*;
 
-            pub fn serialize<S>(value: &Option<Timestamp>, serializer: S) -> Result<S::Ok, S::Error>
+            pub(super) fn serialize<S>(
+                value: &Option<Timestamp>,
+                serializer: S,
+            ) -> Result<S::Ok, S::Error>
             where
                 S: Serializer,
             {
@@ -380,7 +383,9 @@ pub mod coresdk {
                 value.as_ref().map(Helper).serialize(serializer)
             }
 
-            pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Timestamp>, D::Error>
+            pub(super) fn deserialize<'de, D>(
+                deserializer: D,
+            ) -> Result<Option<Timestamp>, D::Error>
             where
                 D: Deserializer<'de>,
             {
@@ -396,13 +401,16 @@ pub mod coresdk {
         #[derive(Serialize, Deserialize)]
         #[serde(remote = "Duration")]
         struct DurationDef {
-            pub seconds: i64,
-            pub nanos: i32,
+            seconds: i64,
+            nanos: i32,
         }
         mod opt_duration {
             use super::*;
 
-            pub fn serialize<S>(value: &Option<Duration>, serializer: S) -> Result<S::Ok, S::Error>
+            pub(super) fn serialize<S>(
+                value: &Option<Duration>,
+                serializer: S,
+            ) -> Result<S::Ok, S::Error>
             where
                 S: Serializer,
             {
@@ -412,7 +420,7 @@ pub mod coresdk {
                 value.as_ref().map(Helper).serialize(serializer)
             }
 
-            pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Duration>, D::Error>
+            pub(super) fn deserialize<'de, D>(deserializer: D) -> Result<Option<Duration>, D::Error>
             where
                 D: Deserializer<'de>,
             {
@@ -483,52 +491,28 @@ pub mod coresdk {
         }
 
         impl WorkflowActivation {
-            /// Returns the index of the eviction job if this activation contains one. If present
-            /// it should always be the last job in the list.
-            pub fn eviction_index(&self) -> Option<usize> {
-                self.jobs.iter().position(|j| {
-                    matches!(
-                        j,
-                        WorkflowActivationJob {
-                            variant: Some(workflow_activation_job::Variant::RemoveFromCache(_))
-                        }
-                    )
-                })
-            }
-
-            /// Returns true if the only job is eviction
+            /// Returns true if the only job in the activation is eviction
             pub fn is_only_eviction(&self) -> bool {
-                self.jobs.len() == 1 && self.eviction_index().is_some()
+                matches!(
+                    self.jobs.as_slice(),
+                    [WorkflowActivationJob {
+                        variant: Some(workflow_activation_job::Variant::RemoveFromCache(_))
+                    }]
+                )
             }
 
-            /// Returns eviction reason if this activation has an evict job
+            /// Returns eviction reason if this activation is an eviction
             pub fn eviction_reason(&self) -> Option<EvictionReason> {
                 self.jobs.iter().find_map(|j| {
                     if let Some(workflow_activation_job::Variant::RemoveFromCache(ref rj)) =
                         j.variant
                     {
-                        EvictionReason::from_i32(rj.reason)
+                        EvictionReason::try_from(rj.reason).ok()
                     } else {
                         None
                     }
                 })
             }
-
-            /// Append an eviction job to the joblist
-            pub fn append_evict_job(&mut self, evict_job: RemoveFromCache) {
-                if let Some(last_job) = self.jobs.last() {
-                    if matches!(
-                        last_job.variant,
-                        Some(workflow_activation_job::Variant::RemoveFromCache(_))
-                    ) {
-                        return;
-                    }
-                }
-                let evict_job = WorkflowActivationJob::from(
-                    workflow_activation_job::Variant::RemoveFromCache(evict_job),
-                );
-                self.jobs.push(evict_job);
-            }
         }
 
         impl Display for EvictionReason {
@@ -1265,6 +1249,13 @@ pub mod coresdk {
                         v.started_event_id
                     )?;
                 }
+                Some(FailureInfo::NexusOperationExecutionFailureInfo(v)) => {
+                    write!(
+                        f,
+                        "Nexus Operation Failure: scheduled_event_id: {}",
+                        v.scheduled_event_id
+                    )?;
+                }
             }
             write!(f, ")")
         }
@@ -1494,7 +1485,7 @@ pub mod temporal {
 
                 impl Display for Command {
                     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-                        let ct = CommandType::from_i32(self.command_type)
+                        let ct = CommandType::try_from(self.command_type)
                             .unwrap_or(CommandType::Unspecified);
                         write!(f, "{:?}", ct)
                     }
@@ -1539,7 +1530,7 @@ pub mod temporal {
 
                 pub fn schedule_activity_cmd_to_api(
                     s: workflow_commands::ScheduleActivity,
-                    use_compatible_version: bool,
+                    use_workflow_build_id: bool,
                 ) -> command::Attributes {
                     command::Attributes::ScheduleActivityTaskCommandAttributes(
                         ScheduleActivityTaskCommandAttributes {
@@ -1556,14 +1547,14 @@ pub mod temporal {
                             heartbeat_timeout: s.heartbeat_timeout,
                             retry_policy: s.retry_policy.map(Into::into),
                             request_eager_execution: !s.do_not_eagerly_execute,
-                            use_compatible_version,
+                            use_workflow_build_id,
                         },
                     )
                 }
 
                 pub fn start_child_workflow_cmd_to_api(
                     s: workflow_commands::StartChildWorkflowExecution,
-                    use_compatible_version: bool,
+                    inherit_build_id: bool,
                 ) -> command::Attributes {
                     command::Attributes::StartChildWorkflowExecutionCommandAttributes(
                         StartChildWorkflowExecutionCommandAttributes {
@@ -1585,7 +1576,7 @@ pub mod temporal {
                             retry_policy: s.retry_policy.map(Into::into),
                             cron_schedule: s.cron_schedule.clone(),
                             parent_close_policy: s.parent_close_policy,
-                            use_compatible_version,
+                            inherit_build_id,
                         },
                     )
                 }
@@ -1612,7 +1603,7 @@ pub mod temporal {
 
                 pub fn continue_as_new_cmd_to_api(
                     c: workflow_commands::ContinueAsNewWorkflowExecution,
-                    use_compatible_version: bool,
+                    inherit_build_id: bool,
                 ) -> command::Attributes {
                     command::Attributes::ContinueAsNewWorkflowExecutionCommandAttributes(
                         ContinueAsNewWorkflowExecutionCommandAttributes {
@@ -1637,7 +1628,7 @@ pub mod temporal {
                             } else {
                                 Some(c.search_attributes.into())
                             },
-                            use_compatible_version,
+                            inherit_build_id,
                             ..Default::default()
                         },
                     )
@@ -1830,7 +1821,7 @@ pub mod temporal {
                 impl HistoryEvent {
                     /// Returns true if this is an event created to mirror a command
                     pub fn is_command_event(&self) -> bool {
-                        EventType::from_i32(self.event_type).map_or(false, |et| match et {
+                        EventType::try_from(self.event_type).map_or(false, |et| match et {
                             EventType::ActivityTaskScheduled
                             | EventType::ActivityTaskCancelRequested
                             | EventType::MarkerRecorded
@@ -1929,7 +1920,7 @@ pub mod temporal {
                             f,
                             "HistoryEvent(id: {}, {:?})",
                             self.event_id,
-                            EventType::from_i32(self.event_type)
+                            EventType::try_from(self.event_type)
                         )
                     }
                 }
@@ -1978,13 +1969,20 @@ pub mod temporal {
                             Attributes::SignalExternalWorkflowExecutionFailedEventAttributes(_) => {EventType::SignalExternalWorkflowExecutionFailed}
                             Attributes::ExternalWorkflowExecutionSignaledEventAttributes(_) => {EventType::ExternalWorkflowExecutionSignaled}
                             Attributes::UpsertWorkflowSearchAttributesEventAttributes(_) => {EventType::UpsertWorkflowSearchAttributes}
+                            Attributes::WorkflowExecutionUpdateAdmittedEventAttributes(_) => {EventType::WorkflowExecutionUpdateAdmitted}
                             Attributes::WorkflowExecutionUpdateRejectedEventAttributes(_) => {EventType::WorkflowExecutionUpdateRejected}
                             Attributes::WorkflowExecutionUpdateAcceptedEventAttributes(_) => {EventType::WorkflowExecutionUpdateAccepted}
                             Attributes::WorkflowExecutionUpdateCompletedEventAttributes(_) => {EventType::WorkflowExecutionUpdateCompleted}
-                            Attributes::WorkflowExecutionUpdateRequestedEventAttributes(_) => {EventType::WorkflowExecutionUpdateRequested}
                             Attributes::WorkflowPropertiesModifiedExternallyEventAttributes(_) => {EventType::WorkflowPropertiesModifiedExternally}
                             Attributes::ActivityPropertiesModifiedExternallyEventAttributes(_) => {EventType::ActivityPropertiesModifiedExternally}
                             Attributes::WorkflowPropertiesModifiedEventAttributes(_) => {EventType::WorkflowPropertiesModified}
+                            Attributes::NexusOperationScheduledEventAttributes(_) => {EventType::NexusOperationScheduled}
+                            Attributes::NexusOperationStartedEventAttributes(_) => {EventType::NexusOperationStarted}
+                            Attributes::NexusOperationCompletedEventAttributes(_) => {EventType::NexusOperationCompleted}
+                            Attributes::NexusOperationFailedEventAttributes(_) => {EventType::NexusOperationFailed}
+                            Attributes::NexusOperationCanceledEventAttributes(_) => {EventType::NexusOperationCanceled}
+                            Attributes::NexusOperationTimedOutEventAttributes(_) => {EventType::NexusOperationTimedOut}
+                            Attributes::NexusOperationCancelRequestedEventAttributes(_) => {EventType::NexusOperationCancelRequested}
                         }
                     }
                 }
@@ -2079,6 +2077,11 @@ pub mod temporal {
                 tonic::include_proto!("temporal.api.workflow.v1");
             }
         }
+        pub mod nexus {
+            pub mod v1 {
+                tonic::include_proto!("temporal.api.nexus.v1");
+            }
+        }
         pub mod workflowservice {
             pub mod v1 {
                 use std::{

package/sdk-core/sdk-core-protos/src/task_token.rs

@@ -1,5 +1,8 @@
 use base64::{prelude::BASE64_STANDARD, Engine};
-use std::fmt::{Debug, Display, Formatter};
+use std::{
+    borrow::Borrow,
+    fmt::{Debug, Display, Formatter},
+};
 
 static LOCAL_ACT_TASK_TOKEN_PREFIX: &[u8] = b"local_act_";
 
@@ -43,6 +46,12 @@ impl Debug for TaskToken {
     }
 }
 
-pub fn fmt_tt(tt: &[u8]) -> String {
+impl Borrow<[u8]> for TaskToken {
+    fn borrow(&self) -> &[u8] {
+        self.0.as_slice()
+    }
+}
+
+pub(crate) fn fmt_tt(tt: &[u8]) -> String {
     BASE64_STANDARD.encode(tt)
 }

package/sdk-core/test-utils/Cargo.toml

@@ -16,14 +16,14 @@ ephemeral-server = ["temporal-sdk-core/ephemeral-server"]
 [dependencies]
 anyhow = "1.0"
 async-trait = "0.1"
-base64 = "0.21"
+base64 = "0.22"
 bytes = "1.3"
 futures = "0.3"
 log = "0.4"
-once_cell = "1.16"
+once_cell = { workspace = true }
 parking_lot = "0.12"
-prost = "0.11"
-prost-types = "0.11"
+prost = { workspace = true }
+prost-types = { workspace = true }
 rand = "0.8"
 rmp-serde = "1.1"
 serde_json = "1.0"
@@ -41,3 +41,6 @@ uuid = "1.1"
 [dependencies.temporal-sdk-core-protos]
 path = "../sdk-core-protos"
 version = "0.1"
+
+[lints]
+workspace = true

package/sdk-core/test-utils/src/histfetch.rs

@@ -11,7 +11,7 @@ use temporal_sdk_core_test_utils::get_integ_server_options;
 #[tokio::main]
 async fn main() -> Result<(), anyhow::Error> {
     let gw_opts = get_integ_server_options();
-    let client = gw_opts.connect("default", None, None).await?;
+    let client = gw_opts.connect("default", None).await?;
     let wf_id = std::env::args()
         .nth(1)
         .expect("must provide workflow id as only argument");

package/sdk-core/test-utils/src/lib.rs

@@ -6,16 +6,12 @@ extern crate tracing;
 
 pub mod canned_histories;
 pub mod interceptors;
-pub mod wf_input_saver;
 pub mod workflows;
 
-use anyhow::Context;
 pub use temporal_sdk_core::replay::HistoryForReplay;
 
-use crate::{
-    stream::{Stream, TryStreamExt},
-    wf_input_saver::stream_to_file,
-};
+use crate::stream::{Stream, TryStreamExt};
+use anyhow::{Context, Error};
 use base64::{prelude::BASE64_STANDARD, Engine};
 use futures::{future, stream, stream::FuturesUnordered, StreamExt};
 use parking_lot::Mutex;
@@ -51,6 +47,7 @@ use temporal_sdk_core_api::{
 };
 use temporal_sdk_core_protos::{
     coresdk::{
+        workflow_activation::WorkflowActivation,
         workflow_commands::{
             workflow_command, ActivityCancellationType, CompleteWorkflowExecution, QueryResult,
             QuerySuccess, ScheduleActivity, ScheduleLocalActivity, StartTimer,
@@ -63,7 +60,7 @@ use temporal_sdk_core_protos::{
     },
     DEFAULT_ACTIVITY_TYPE,
 };
-use tokio::sync::{mpsc::unbounded_channel, OnceCell};
+use tokio::sync::OnceCell;
 use url::Url;
 
 pub const NAMESPACE: &str = "default";
@@ -99,6 +96,17 @@ pub async fn init_core_and_create_wf(test_name: &str) -> CoreWfStarter {
     starter
 }
 
+pub fn integ_worker_config(tq: &str) -> WorkerConfigBuilder {
+    let mut b = WorkerConfigBuilder::default();
+    b.namespace(NAMESPACE)
+        .task_queue(tq)
+        .max_outstanding_activities(100_usize)
+        .max_outstanding_local_activities(100_usize)
+        .max_outstanding_workflow_tasks(100_usize)
+        .worker_build_id("test_build_id");
+    b
+}
+
 /// Create a worker replay instance preloaded with provided histories. Returns the worker impl.
 pub fn init_core_replay_preloaded<I>(test_name: &str, histories: I) -> Arc<dyn CoreWorker>
 where
@@ -112,10 +120,7 @@ where
     I: Stream<Item = HistoryForReplay> + Send + 'static,
 {
     init_integ_telem();
-    let worker_cfg = WorkerConfigBuilder::default()
-        .namespace(NAMESPACE)
-        .task_queue(test_name)
-        .worker_build_id("test_bin_id")
+    let worker_cfg = integ_worker_config(test_name)
         .build()
         .expect("Configuration options construct properly");
     let worker = init_replay_worker(ReplayWorkerInput::new(worker_cfg, histories))
@@ -149,7 +154,7 @@ pub async fn history_from_proto_binary(path_from_root: &str) -> Result<History,
 }
 
 static INTEG_TESTS_RT: once_cell::sync::OnceCell<CoreRuntime> = once_cell::sync::OnceCell::new();
-pub fn init_integ_telem() {
+pub fn init_integ_telem() -> &'static CoreRuntime {
     INTEG_TESTS_RT.get_or_init(|| {
         let telemetry_options = get_integ_telem_options();
         let rt =
@@ -158,7 +163,7 @@ pub fn init_integ_telem() {
             let _ = tracing::subscriber::set_global_default(sub);
         }
         rt
-    });
+    })
 }
 
 /// Implements a builder pattern to help integ tests initialize core and create workflows
@@ -169,7 +174,7 @@ pub struct CoreWfStarter {
     /// Options to use when starting workflow(s)
     pub workflow_options: WorkflowOptions,
     initted_worker: OnceCell<InitializedWorker>,
-    runtime_override: Option<CoreRuntime>,
+    runtime_override: Option<Arc<CoreRuntime>>,
 }
 struct InitializedWorker {
     worker: Arc<dyn CoreWorker>,
@@ -190,18 +195,16 @@ impl CoreWfStarter {
         let rand_bytes: Vec<u8> = rand::thread_rng().sample_iter(&Standard).take(6).collect();
         let task_q_salt = BASE64_STANDARD.encode(rand_bytes);
         let task_queue = format!("{test_name}_{task_q_salt}");
-        let mut worker_config = WorkerConfigBuilder::default();
+        let mut worker_config = integ_worker_config(&task_queue);
         worker_config
             .namespace(env::var(INTEG_NAMESPACE_ENV_VAR).unwrap_or(NAMESPACE.to_string()))
-            .task_queue(task_queue.clone())
-            .worker_build_id("test_build_id")
             .max_cached_workflows(1000_usize);
         Self {
             task_queue_name: task_queue,
             worker_config,
             initted_worker: OnceCell::new(),
             workflow_options: Default::default(),
-            runtime_override,
+            runtime_override: runtime_override.map(Arc::new),
         }
     }
 
@@ -212,7 +215,7 @@ impl CoreWfStarter {
             task_queue_name: self.task_queue_name.clone(),
             worker_config: self.worker_config.clone(),
             workflow_options: self.workflow_options.clone(),
-            runtime_override: None,
+            runtime_override: self.runtime_override.clone(),
             initted_worker: Default::default(),
         }
     }
@@ -243,6 +246,7 @@ impl CoreWfStarter {
         self.start_wf_with_id(self.task_queue_name.clone()).await
     }
 
+    /// Starts the workflow using the worker, returns run id.
     pub async fn start_with_worker(
         &self,
         wf_name: impl Into<String>,
@@ -328,47 +332,6 @@ impl CoreWfStarter {
         &self.task_queue_name
     }
 
-    pub fn max_cached_workflows(&mut self, num: usize) -> &mut Self {
-        self.worker_config.max_cached_workflows(num);
-        self
-    }
-
-    pub fn max_wft(&mut self, max: usize) -> &mut Self {
-        self.worker_config.max_outstanding_workflow_tasks(max);
-        self
-    }
-
-    pub fn max_at(&mut self, max: usize) -> &mut Self {
-        self.worker_config.max_outstanding_activities(max);
-        self
-    }
-
-    pub fn max_local_at(&mut self, max: usize) -> &mut Self {
-        self.worker_config.max_outstanding_local_activities(max);
-        self
-    }
-
-    pub fn max_at_polls(&mut self, max: usize) -> &mut Self {
-        self.worker_config.max_concurrent_at_polls(max);
-
-        self
-    }
-
-    pub fn no_remote_activities(&mut self) -> &mut Self {
-        self.worker_config.no_remote_activities(true);
-        self
-    }
-
-    pub fn enable_wf_state_input_recording(&mut self) -> &mut Self {
-        let (ser_tx, ser_rx) = unbounded_channel();
-        let worker_cfg_clone = self.worker_config.build().unwrap();
-        tokio::spawn(async move {
-            stream_to_file(&worker_cfg_clone, ser_rx).await.unwrap();
-        });
-        self.worker_config.wf_state_inputs(Some(ser_tx));
-        self
-    }
-
     async fn get_or_init(&mut self) -> &InitializedWorker {
         self.initted_worker
             .get_or_init(|| async {
@@ -378,7 +341,7 @@ impl CoreWfStarter {
                     .expect("Worker config must be valid");
                 let client = Arc::new(
                     get_integ_server_options()
-                        .connect(cfg.namespace.clone(), None, None)
+                        .connect(cfg.namespace.clone(), None)
                         .await
                         .expect("Must connect"),
                 );
@@ -510,7 +473,20 @@ impl TestWorker {
         Ok(res)
     }
 
-    /// Runs until all expected workflows have completed
+    pub fn expect_workflow_completion(&self, wf_id: impl Into<String>, run_id: Option<String>) {
+        self.started_workflows.lock().push(WorkflowExecutionInfo {
+            namespace: self
+                .client
+                .as_ref()
+                .map(|c| c.namespace())
+                .unwrap_or(NAMESPACE)
+                .to_owned(),
+            workflow_id: wf_id.into(),
+            run_id,
+        });
+    }
+
+    /// Runs until all expected workflows have completed and then shuts down the worker
     pub async fn run_until_done(&mut self) -> Result<(), anyhow::Error> {
         self.run_until_done_intercepted(Option::<TestWorkerCompletionIceptor>::None)
             .await
@@ -604,6 +580,12 @@ impl WorkerInterceptor for TestWorkerCompletionIceptor {
             n.on_shutdown(sdk_worker);
         }
     }
+    async fn on_workflow_activation(&self, a: &WorkflowActivation) -> Result<(), Error> {
+        if let Some(n) = self.next.as_ref() {
+            n.on_workflow_activation(a).await?;
+        }
+        Ok(())
+    }
 }
 
 /// Returns the client options used to connect to the server used for integration tests.

package/sdk-core/tests/fuzzy_workflow.rs

@@ -78,8 +78,11 @@ async fn fuzzy_workflow() {
     let num_workflows = 200;
     let wf_name = "fuzzy_wf";
     let mut starter = CoreWfStarter::new("fuzzy_workflow");
-    starter.max_wft(25).max_cached_workflows(25).max_at(25);
-    // .enable_wf_state_input_recording();
+    starter
+        .worker_config
+        .max_outstanding_workflow_tasks(25_usize)
+        .max_cached_workflows(25_usize)
+        .max_outstanding_activities(25_usize);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), fuzzy_wf_def);
     worker.register_activity("echo_activity", echo);