@temporalio/core-bridge 0.20.2 → 0.22.0

package/sdk-core/core/src/workflow/machines/mod.rs

@@ -175,7 +175,7 @@ where
         event: HistoryEvent,
         has_next_event: bool,
     ) -> Result<Vec<MachineResponse>, WFMachinesError> {
-        debug!(
+        trace!(
             event = %event,
             machine_name = %self.name(),
             state = %self.state(),

package/sdk-core/core/src/workflow/machines/timer_state_machine.rs

@@ -336,7 +336,7 @@ mod test {
         happy_wfm.shutdown().await.unwrap();
     }
 
-    #[tokio::test(flavor = "multi_thread")]
+    #[tokio::test]
     async fn mismatched_timer_ids_errors() {
         let func = WorkflowFunction::new(|command_sink: WfContext| async move {
             command_sink.timer(Duration::from_secs(5)).await;
@@ -403,7 +403,7 @@ mod test {
         wfm.shutdown().await.unwrap();
     }
 
-    #[tokio::test(flavor = "multi_thread")]
+    #[tokio::test]
     async fn cancel_before_sent_to_server() {
         let func = WorkflowFunction::new(|ctx: WfContext| async move {
             let cancel_timer_fut = ctx.timer(Duration::from_secs(500));

package/sdk-core/core/src/workflow/machines/workflow_machines.rs

@@ -252,7 +252,11 @@ impl WorkflowMachines {
 
     /// Let this workflow know that something we've been waiting locally on has resolved, like a
     /// local activity or side effect
-    pub(crate) fn local_resolution(&mut self, resolution: LocalResolution) -> Result<()> {
+    ///
+    /// Returns true if the resolution did anything. EX: If the activity is already canceled and
+    /// used the TryCancel or Abandon modes, the resolution is uninteresting.
+    pub(crate) fn local_resolution(&mut self, resolution: LocalResolution) -> Result<bool> {
+        let mut result_important = true;
         match resolution {
             LocalResolution::LocalActivity(LocalActivityResolution {
                 seq,
@@ -268,6 +272,9 @@ impl WorkflowMachines {
                 if let Machines::LocalActivityMachine(ref mut lam) = *mach {
                     let resps =
                         lam.try_resolve(result, runtime, attempt, backoff, original_schedule_time)?;
+                    if resps.is_empty() {
+                        result_important = false;
+                    }
                     self.process_machine_responses(mk, resps)?;
                 } else {
                     return Err(WFMachinesError::Nondeterminism(format!(
@@ -279,7 +286,7 @@ impl WorkflowMachines {
                 self.local_activity_data.done_executing(seq);
             }
         }
-        Ok(())
+        Ok(result_important)
     }
 
     /// Drain all queued local activities that need executing or cancellation
@@ -456,7 +463,7 @@ impl WorkflowMachines {
         event: HistoryEvent,
         has_next_event: bool,
     ) -> Result<()> {
-        debug!(
+        trace!(
             event = %event,
             "handling non-stateful event"
         );
@@ -470,6 +477,10 @@ impl WorkflowMachines {
                     if let Some(st) = event.event_time {
                         let as_systime: SystemTime = st.try_into()?;
                         self.workflow_start_time = Some(as_systime);
+                        // Set the workflow time to be the event time of the first event, so that
+                        // if there is a query issued before first WFT started event, there is some
+                        // workflow time set.
+                        self.set_current_time(as_systime);
                     }
                     // Notify the lang sdk that it's time to kick off a workflow
                     self.drive_me.start(

package/sdk-core/core/src/workflow/mod.rs

@@ -96,7 +96,10 @@ impl WorkflowManager {
 
     /// Let this workflow know that something we've been waiting locally on has resolved, like a
     /// local activity or side effect
-    pub fn notify_of_local_result(&mut self, resolved: LocalResolution) -> Result<()> {
+    ///
+    /// Returns true if the resolution did anything. EX: If the activity is already canceled and
+    /// used the TryCancel or Abandon modes, the resolution is uninteresting.
+    pub fn notify_of_local_result(&mut self, resolved: LocalResolution) -> Result<bool> {
         self.machines.local_resolution(resolved)
     }
 
@@ -407,7 +410,7 @@ pub mod managed_wf {
             &mut self,
             seq_num: u32,
             result: ActivityExecutionResult,
-        ) -> Result<()> {
+        ) -> Result<bool> {
             self.mgr
                 .notify_of_local_result(LocalResolution::LocalActivity(LocalActivityResolution {
                     seq: seq_num,

package/sdk-core/core/src/workflow/workflow_tasks/cache_manager.rs

@@ -1,5 +1,13 @@
 use crate::{telemetry::metrics::MetricsContext, workflow::WorkflowCachingPolicy};
 use lru::LruCache;
+use std::{
+    future::Future,
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    },
+};
+use tokio::sync::Notify;
 
 /// Helps to maintain an LRU ordering in which workflow runs have been accessed so that old runs may
 /// be evicted once we reach the cap.
@@ -7,6 +15,9 @@ use lru::LruCache;
 pub(crate) struct WorkflowCacheManager {
     cache: LruCache<String, ()>,
     metrics: MetricsContext,
+    cap_notify: Arc<Notify>,
+    cache_size: Arc<AtomicUsize>,
+    cap_mutex: Arc<tokio::sync::Mutex<()>>,
 }
 
 impl WorkflowCacheManager {
@@ -20,6 +31,9 @@ impl WorkflowCacheManager {
         Self {
             cache: LruCache::new(cap),
             metrics,
+            cap_notify: Arc::new(Notify::new()),
+            cache_size: Arc::new(AtomicUsize::new(0)),
+            cap_mutex: Arc::new(tokio::sync::Mutex::new(())),
         }
     }
 
@@ -28,6 +42,30 @@ impl WorkflowCacheManager {
         Self::new(policy, Default::default())
     }
 
+    /// Resolves once there is an open slot in the cache. The passed in closure can be used to
+    /// exit the wait loop if it returns true even if the cache is not below the limit. It will be
+    /// re-evaluated every time there is an insert or remove to the cache, even if it did not change
+    /// the size.
+    pub fn wait_for_capacity<Fun>(&self, early_exit: Fun) -> Option<impl Future<Output = ()>>
+    where
+        Fun: Fn() -> bool,
+    {
+        if self.cache.cap() == 0 {
+            return None;
+        }
+
+        let size = self.cache_size.clone();
+        let notify = self.cap_notify.clone();
+        let cap = self.cache.cap();
+        let mx = self.cap_mutex.clone();
+        Some(async move {
+            let _l = mx.lock().await;
+            while !early_exit() && size.load(Ordering::Acquire) >= cap {
+                notify.notified().await;
+            }
+        })
+    }
+
     /// Inserts a record associated with the run id into the lru cache.
     /// Once cache reaches capacity, overflow records will be returned back to the caller.
     pub fn insert(&mut self, run_id: &str) -> Option<String> {
@@ -44,7 +82,7 @@ impl WorkflowCacheManager {
             not_cached.then(|| maybe_got_evicted).flatten()
         };
 
-        self.metrics.cache_size(self.cache.len() as u64);
+        self.size_changed();
 
         res
     }
@@ -56,7 +94,14 @@ impl WorkflowCacheManager {
 
     pub fn remove(&mut self, run_id: &str) {
         self.cache.pop(run_id);
-        self.metrics.cache_size(self.cache.len() as u64);
+        self.size_changed();
+    }
+
+    fn size_changed(&self) {
+        let size = self.cache.len();
+        self.metrics.cache_size(size as u64);
+        self.cache_size.store(size, Ordering::Release);
+        self.cap_notify.notify_one();
     }
 }
 

package/sdk-core/core/src/workflow/workflow_tasks/concurrency_manager.rs

@@ -154,7 +154,7 @@ impl WorkflowConcurrencyManager {
     pub fn complete_wft(
         &self,
         run_id: &str,
-        send_wft_complete_to_srv: bool,
+        sent_wft_complete_to_srv: bool,
     ) -> Option<OutstandingTask> {
         // If the WFT completion wasn't sent to the server, but we did see the final event, we still
         // want to clear the workflow task. This can really only happen in replay testing, where we
@@ -164,7 +164,7 @@ impl WorkflowConcurrencyManager {
         let saw_final = self
             .access_sync(run_id, |wfm| wfm.machines.have_seen_terminal_event)
             .unwrap_or_default();
-        if !saw_final && !send_wft_complete_to_srv {
+        if !saw_final && !sent_wft_complete_to_srv {
             return None;
         }
 
@@ -313,6 +313,7 @@ impl WorkflowConcurrencyManager {
         val.and_then(|v| v.buffered_resp.take())
     }
 
+    /// Sounds the total number of outstanding workflow tasks
     pub fn outstanding_wft(&self) -> usize {
         self.runs
             .read()
@@ -320,6 +321,19 @@ impl WorkflowConcurrencyManager {
             .filter(|(_, run)| run.wft.is_some())
             .count()
     }
+
+    /// Returns number of currently cached workflows
+    pub fn cached_workflows(&self) -> usize {
+        self.runs.read().len()
+    }
+
+    /// Returns true if any outstanding activation contains an eviction
+    pub fn are_outstanding_evictions(&self) -> bool {
+        self.runs
+            .read()
+            .values()
+            .any(|mr| mr.activation.map(|a| a.has_eviction()).unwrap_or_default())
+    }
 }
 
 #[cfg(test)]