@temporalio/core-bridge 0.23.0 → 1.0.0

package/sdk-core/core/src/pending_activations.rs

@@ -1,173 +0,0 @@
-use parking_lot::RwLock;
-use slotmap::SlotMap;
-use std::collections::{HashMap, VecDeque};
-use temporal_sdk_core_protos::coresdk::workflow_activation::{
-    remove_from_cache::EvictionReason, RemoveFromCache,
-};
-
-/// Tracks pending activations using an internal queue, while also allowing lookup and removal of
-/// any pending activations by run ID.
-#[derive(Default)]
-pub struct PendingActivations {
-    inner: RwLock<PaInner>,
-}
-
-slotmap::new_key_type! { struct ActivationKey; }
-
-#[derive(Default)]
-struct PaInner {
-    activations: SlotMap<ActivationKey, PendingActInfo>,
-    by_run_id: HashMap<String, ActivationKey>,
-    // Holds the actual queue of activations
-    queue: VecDeque<ActivationKey>,
-}
-
-#[derive(Debug)]
-pub struct PendingActInfo {
-    pub needs_eviction: Option<RemoveFromCache>,
-    pub run_id: String,
-}
-
-impl PendingActivations {
-    /// Indicate that a run needs to be activated
-    pub fn notify_needs_activation(&self, run_id: &str) {
-        let mut inner = self.inner.write();
-
-        if inner.by_run_id.get(run_id).is_none() {
-            let key = inner.activations.insert(PendingActInfo {
-                needs_eviction: None,
-                run_id: run_id.to_string(),
-            });
-            inner.by_run_id.insert(run_id.to_string(), key);
-            inner.queue.push_back(key);
-        };
-    }
-
-    pub fn notify_needs_eviction(&self, run_id: &str, message: String, reason: EvictionReason) {
-        let mut inner = self.inner.write();
-
-        let evictjob = RemoveFromCache {
-            message,
-            reason: reason as i32,
-        };
-
-        if let Some(key) = inner.by_run_id.get(run_id).copied() {
-            let act = inner
-                .activations
-                .get_mut(key)
-                .expect("PA run id mapping is always in sync with slot map");
-            act.needs_eviction = Some(evictjob);
-        } else {
-            let key = inner.activations.insert(PendingActInfo {
-                needs_eviction: Some(evictjob),
-                run_id: run_id.to_string(),
-            });
-            inner.by_run_id.insert(run_id.to_string(), key);
-            inner.queue.push_back(key);
-        };
-    }
-
-    pub fn pop_first_matching(&self, predicate: impl Fn(&str) -> bool) -> Option<PendingActInfo> {
-        let mut inner = self.inner.write();
-        let mut key_queue = inner.queue.iter().copied();
-        let maybe_key = key_queue.position(|k| {
-            inner
-                .activations
-                .get(k)
-                .map_or(false, |activation| predicate(&activation.run_id))
-        });
-
-        let maybe_key = maybe_key.map(|pos| inner.queue.remove(pos).unwrap());
-        maybe_key.and_then(|key| {
-            if let Some(pa) = inner.activations.remove(key) {
-                inner.by_run_id.remove(&pa.run_id);
-                Some(pa)
-            } else {
-                // Keys no longer in the slot map are ignored, since they may have been removed
-                // by run id or anything else. Try to pop the next thing from the queue. Recurse
-                // to avoid double mutable borrow.
-                drop(inner); // Will deadlock when we recurse w/o this
-                self.pop_first_matching(predicate)
-            }
-        })
-    }
-
-    #[cfg(test)]
-    pub fn pop(&self) -> Option<PendingActInfo> {
-        self.pop_first_matching(|_| true)
-    }
-
-    pub fn has_pending(&self, run_id: &str) -> bool {
-        self.inner.read().by_run_id.contains_key(run_id)
-    }
-
-    pub fn remove_all_with_run_id(&self, run_id: &str) {
-        let mut inner = self.inner.write();
-
-        if let Some(k) = inner.by_run_id.remove(run_id) {
-            inner.activations.remove(k);
-        }
-    }
-
-    /// Returns true if any pending activation contains an eviction
-    pub fn is_some_eviction(&self) -> bool {
-        self.inner
-            .read()
-            .activations
-            .values()
-            .any(|act| act.needs_eviction.is_some())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn merges_same_ids_with_evictions() {
-        let pas = PendingActivations::default();
-        let rid1 = "1";
-        let rid2 = "2";
-        pas.notify_needs_activation(rid1);
-        pas.notify_needs_eviction(rid1, "whatever".to_string(), EvictionReason::Unspecified);
-        pas.notify_needs_eviction(rid2, "whatever".to_string(), EvictionReason::Unspecified);
-        pas.notify_needs_activation(rid2);
-        assert!(pas.has_pending(rid1));
-        assert!(pas.has_pending(rid2));
-        let last = pas.pop().unwrap();
-        assert_eq!(&last.run_id, &rid1);
-        assert!(!pas.has_pending(rid1));
-        assert!(pas.has_pending(rid2));
-        // Should only be one id 2, they are all merged
-        let last = pas.pop().unwrap();
-        assert_eq!(&last.run_id, &rid2);
-        assert!(!pas.has_pending(rid2));
-        assert!(pas.pop().is_none());
-    }
-
-    #[test]
-    fn can_remove_all_with_id() {
-        let pas = PendingActivations::default();
-        let remove_me = "2";
-        pas.notify_needs_activation("1");
-        pas.notify_needs_activation(remove_me);
-        pas.notify_needs_activation("3");
-        pas.remove_all_with_run_id(remove_me);
-        assert!(!pas.has_pending(remove_me));
-        assert_eq!(&pas.pop().unwrap().run_id, "1");
-        assert_eq!(&pas.pop().unwrap().run_id, "3");
-        assert!(pas.pop().is_none());
-    }
-
-    #[test]
-    fn can_ignore_specific_runs() {
-        let pas = PendingActivations::default();
-        pas.notify_needs_activation("1");
-        pas.notify_needs_activation("2");
-        assert_eq!(
-            &pas.pop_first_matching(|rid| rid != "1").unwrap().run_id,
-            "2"
-        );
-        assert_eq!(&pas.pop().unwrap().run_id, "1");
-    }
-}

package/sdk-core/core/src/worker/wft_delivery.rs

@@ -1,81 +0,0 @@
-use crate::{pollers, pollers::BoxedWFPoller};
-use crossbeam::queue::SegQueue;
-use temporal_sdk_core_protos::temporal::api::workflowservice::v1::PollWorkflowTaskQueueResponse;
-use tokio::sync::Notify;
-
-/// Workflow tasks typically come from polling, but may also come as a response to task completion.
-/// This struct allows fetching WFTs to be centralized while prioritizing tasks from completes.
-pub(crate) struct WFTSource {
-    from_completions: SegQueue<PollWorkflowTaskQueueResponse>,
-    poll_buffer: BoxedWFPoller,
-    task_taken_notifier: Notify,
-}
-
-impl WFTSource {
-    pub fn new(poller: BoxedWFPoller) -> Self {
-        Self {
-            from_completions: SegQueue::new(),
-            poll_buffer: poller,
-            task_taken_notifier: Notify::new(),
-        }
-    }
-
-    /// Returns the next available WFT if one is already stored from a completion, otherwise
-    /// forwards to the poller.
-    pub async fn next_wft(&self) -> Option<pollers::Result<PollWorkflowTaskQueueResponse>> {
-        if let Some(wft) = self.from_completions.pop() {
-            self.task_taken_notifier.notify_one();
-            return Some(Ok(wft));
-        }
-        self.poll_buffer.poll().await
-    }
-
-    /// Add a WFT received from the completion of another WFT
-    pub fn add_wft_from_completion(&self, wft: PollWorkflowTaskQueueResponse) {
-        self.from_completions.push(wft);
-    }
-
-    /// Notifies the pollers to stop polling
-    pub fn stop_pollers(&self) {
-        self.poll_buffer.notify_shutdown();
-    }
-
-    /// Returns true if there are tasks from completion buffered which need to be handled
-    pub fn has_tasks_from_complete(&self) -> bool {
-        !self.from_completions.is_empty()
-    }
-
-    /// Returns a future which resolves when all tasks from completions have been taken
-    pub async fn wait_for_tasks_from_complete_to_drain(&self) {
-        while !self.from_completions.is_empty() {
-            self.task_taken_notifier.notified().await;
-        }
-    }
-
-    /// Wait for poll shutdown to complete
-    pub async fn shutdown(self) {
-        self.poll_buffer.shutdown_box().await;
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::test_help::mock_poller;
-
-    #[tokio::test]
-    async fn drains_from_completes_on_shutdown() {
-        let mp = mock_poller();
-        let wftsrc = WFTSource::new(Box::new(mp));
-        let fake_wft = PollWorkflowTaskQueueResponse {
-            started_event_id: 1,
-            ..Default::default()
-        };
-        wftsrc.add_wft_from_completion(fake_wft);
-        let fake_wft = PollWorkflowTaskQueueResponse {
-            started_event_id: 2,
-            ..Default::default()
-        };
-        wftsrc.add_wft_from_completion(fake_wft);
-    }
-}