@temporalio/core-bridge 0.16.4 → 0.18.0

package/sdk-core/src/machines/local_activity_state_machine.rs

@@ -1,117 +0,0 @@
-use rustfsm::{fsm, TransitionResult};
-
-fsm! {
-    pub(super) name LocalActivityMachine;
-    command LocalActivityCommand;
-    error LocalActivityMachineError;
-
-    Created --(CheckExecutionState, on_check_execution_state) --> Replaying;
-    Created --(CheckExecutionState, on_check_execution_state) --> Executing;
-
-    Executing --(Schedule, on_schedule) --> RequestPrepared;
-
-    MarkerCommandCreated --(CommandRecordMarker, on_command_record_marker) --> ResultNotified;
-
-    Replaying --(Schedule) --> WaitingMarkerEvent;
-
-    RequestPrepared --(MarkAsSent) --> RequestSent;
-
-    RequestSent --(NonReplayWorkflowTaskStarted) --> RequestSent;
-    RequestSent --(HandleResult, on_handle_result) --> MarkerCommandCreated;
-
-    ResultNotified --(MarkerRecorded, on_marker_recorded) --> MarkerCommandRecorded;
-
-    WaitingMarkerEvent --(MarkerRecorded, on_marker_recorded) --> MarkerCommandRecorded;
-    WaitingMarkerEvent --(NonReplayWorkflowTaskStarted, on_non_replay_workflow_task_started) --> RequestPrepared;
-}
-
-#[derive(thiserror::Error, Debug)]
-pub(super) enum LocalActivityMachineError {}
-
-pub(super) enum LocalActivityCommand {}
-
-#[derive(Default, Clone)]
-pub(super) struct Created {}
-
-impl Created {
-    pub(super) fn on_check_execution_state(
-        self,
-    ) -> LocalActivityMachineTransition<ReplayingOrExecuting> {
-        unimplemented!()
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct Executing {}
-
-impl Executing {
-    pub(super) fn on_schedule(self) -> LocalActivityMachineTransition<RequestPrepared> {
-        unimplemented!()
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct MarkerCommandCreated {}
-
-impl MarkerCommandCreated {
-    pub(super) fn on_command_record_marker(self) -> LocalActivityMachineTransition<ResultNotified> {
-        unimplemented!()
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct MarkerCommandRecorded {}
-
-#[derive(Default, Clone)]
-pub(super) struct Replaying {}
-
-#[derive(Default, Clone)]
-pub(super) struct RequestPrepared {}
-
-#[derive(Default, Clone)]
-pub(super) struct RequestSent {}
-
-impl RequestSent {
-    pub(super) fn on_handle_result(self) -> LocalActivityMachineTransition<MarkerCommandCreated> {
-        unimplemented!()
-    }
-}
-
-impl From<RequestPrepared> for RequestSent {
-    fn from(_: RequestPrepared) -> Self {
-        Self::default()
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct ResultNotified {}
-
-impl ResultNotified {
-    pub(super) fn on_marker_recorded(
-        self,
-    ) -> LocalActivityMachineTransition<MarkerCommandRecorded> {
-        unimplemented!()
-    }
-}
-
-#[derive(Default, Clone)]
-pub(super) struct WaitingMarkerEvent {}
-
-impl WaitingMarkerEvent {
-    pub(super) fn on_marker_recorded(
-        self,
-    ) -> LocalActivityMachineTransition<MarkerCommandRecorded> {
-        unimplemented!()
-    }
-    pub(super) fn on_non_replay_workflow_task_started(
-        self,
-    ) -> LocalActivityMachineTransition<RequestPrepared> {
-        unimplemented!()
-    }
-}
-
-impl From<Replaying> for WaitingMarkerEvent {
-    fn from(_: Replaying) -> Self {
-        Self::default()
-    }
-}

package/sdk-core/src/pending_activations.rs

@@ -1,249 +0,0 @@
-use parking_lot::RwLock;
-use slotmap::SlotMap;
-use std::{
-    cmp::Ordering,
-    collections::{HashMap, VecDeque},
-};
-use temporal_sdk_core_protos::coresdk::workflow_activation::{
-    wf_activation_job, WfActivation, WfActivationJob,
-};
-
-/// 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, WfActivation>,
-    by_run_id: HashMap<String, ActivationKey>,
-    // Holds the actual queue of activations
-    queue: VecDeque<ActivationKey>,
-}
-
-impl PendingActivations {
-    /// Push a pending activation
-    ///
-    /// Importantly, if there already exist activations for same workflow run in the queue, and the
-    /// new activation (or pending one) is just an eviction job, it can be merged into the existing
-    /// activation.
-    ///
-    /// Any other attempt to enqueue a pending activation while there is already one for a given
-    /// run is a violation of our logic and will cause a panic. This is because there should never
-    /// be new activations with real work in them queued up when one is already queued, because they
-    /// should not be produced until the last one is completed (only one outstanding activation at
-    /// a time rule). New work from the server similarily should not be pushed here, as it is
-    /// buffered until any oustanding workflow task is completed.
-    pub fn push(&self, v: WfActivation) {
-        let mut inner = self.inner.write();
-
-        // Check if an activation with the same ID already exists, and merge joblist if so
-        if let Some(key) = inner.by_run_id.get(&v.run_id).copied() {
-            let act = inner
-                .activations
-                .get_mut(key)
-                .expect("PA run id mapping is always in sync with slot map");
-            if v.is_only_eviction() || act.is_only_eviction() {
-                merge_joblists(&mut act.jobs, v.jobs.into_iter());
-            } else {
-                panic!(
-                    "Cannot enqueue non-eviction pending activation for run with an \
-                    existing non-eviction PA: {:?}",
-                    v
-                );
-            }
-        } else {
-            let run_id = v.run_id.clone();
-            let key = inner.activations.insert(v);
-            inner.by_run_id.insert(run_id, key);
-            inner.queue.push_back(key);
-        };
-    }
-
-    pub fn pop_first_matching(&self, predicate: impl Fn(&str) -> bool) -> Option<WfActivation> {
-        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()
-            }
-        })
-    }
-
-    pub fn pop(&self) -> Option<WfActivation> {
-        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);
-        }
-    }
-}
-
-fn merge_joblists(
-    existing_list: &mut Vec<WfActivationJob>,
-    other_jobs: impl Iterator<Item = WfActivationJob>,
-) {
-    existing_list.extend(other_jobs);
-    // Move any evictions to the end of the list
-    existing_list
-        .as_mut_slice()
-        .sort_by(evictions_always_last_compare);
-    // Drop any duplicate evictions
-    let truncate_len = existing_list
-        .iter()
-        .rev()
-        .position(|j| {
-            !matches!(
-                j.variant,
-                Some(wf_activation_job::Variant::RemoveFromCache(_))
-            )
-        })
-        .map_or(1, |last_non_evict_job| {
-            existing_list.len() - last_non_evict_job + 1
-        });
-    existing_list.truncate(truncate_len);
-}
-
-fn evictions_always_last_compare(a: &WfActivationJob, b: &WfActivationJob) -> Ordering {
-    if a == b {
-        return Ordering::Equal;
-    }
-    // Any eviction always goes last
-    if matches!(
-        a.variant,
-        Some(wf_activation_job::Variant::RemoveFromCache(_))
-    ) {
-        return Ordering::Greater;
-    }
-    if matches!(
-        b.variant,
-        Some(wf_activation_job::Variant::RemoveFromCache(_))
-    ) {
-        return Ordering::Less;
-    }
-    // All jobs should not change order except evictions
-    Ordering::Equal
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use temporal_sdk_core_protos::coresdk::workflow_activation::create_evict_activation;
-
-    #[test]
-    fn merges_same_ids_with_evictions() {
-        let pas = PendingActivations::default();
-        let rid1 = "1".to_string();
-        let rid2 = "2".to_string();
-        pas.push(WfActivation {
-            run_id: rid1.clone(),
-            ..Default::default()
-        });
-        pas.push(create_evict_activation(
-            rid1.clone(),
-            "whatever".to_string(),
-        ));
-        pas.push(create_evict_activation(
-            rid2.clone(),
-            "whatever".to_string(),
-        ));
-        pas.push(WfActivation {
-            run_id: rid2.clone(),
-            ..Default::default()
-        });
-        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]
-    #[should_panic(expected = "Cannot enqueue non-eviction")]
-    fn panics_merging_non_evict() {
-        let pas = PendingActivations::default();
-        let rid1 = "1".to_string();
-        pas.push(WfActivation {
-            run_id: rid1.clone(),
-            ..Default::default()
-        });
-        pas.push(WfActivation {
-            run_id: rid1,
-            ..Default::default()
-        });
-    }
-
-    #[test]
-    fn can_remove_all_with_id() {
-        let pas = PendingActivations::default();
-        let remove_me = "2".to_string();
-        pas.push(WfActivation {
-            run_id: "1".to_owned(),
-            ..Default::default()
-        });
-        pas.push(WfActivation {
-            run_id: remove_me.clone(),
-            ..Default::default()
-        });
-        pas.push(WfActivation {
-            run_id: "3".to_owned(),
-            ..Default::default()
-        });
-        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.push(WfActivation {
-            run_id: "1_1".to_owned(),
-            ..Default::default()
-        });
-        pas.push(WfActivation {
-            run_id: "1_2".to_owned(),
-            ..Default::default()
-        });
-        assert_eq!(
-            &pas.pop_first_matching(|rid| rid != "1_1").unwrap().run_id,
-            "1_2"
-        );
-        assert_eq!(&pas.pop().unwrap().run_id, "1_1");
-    }
-}

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

@@ -1,160 +0,0 @@
-use crate::{
-    machines::{ProtoCommand, HAS_CHANGE_MARKER_NAME},
-    task_token::TaskToken,
-    workflow::LEGACY_QUERY_ID,
-};
-use std::convert::TryFrom;
-use temporal_sdk_core_protos::{
-    coresdk::{
-        common::decode_change_marker_details,
-        workflow_activation::{wf_activation_job, QueryWorkflow, WfActivation, WfActivationJob},
-        workflow_commands::{query_result, QueryResult},
-        workflow_completion, FromPayloadsExt,
-    },
-    temporal::api::{
-        common::v1::WorkflowExecution,
-        enums::v1::EventType,
-        history::v1::{history_event, History, HistoryEvent, MarkerRecordedEventAttributes},
-        query::v1::WorkflowQuery,
-        taskqueue::v1::StickyExecutionAttributes,
-        workflowservice::v1::PollWorkflowTaskQueueResponse,
-    },
-};
-
-/// A validated version of a [PollWorkflowTaskQueueResponse]
-#[derive(Debug, Clone, PartialEq)]
-#[allow(clippy::manual_non_exhaustive)] // Clippy doesn't understand it's only for *in* this crate
-pub struct ValidPollWFTQResponse {
-    pub task_token: TaskToken,
-    pub task_queue: String,
-    pub workflow_execution: WorkflowExecution,
-    pub workflow_type: String,
-    pub history: History,
-    pub next_page_token: Vec<u8>,
-    pub attempt: u32,
-    pub previous_started_event_id: i64,
-    pub started_event_id: i64,
-    /// If this is present, `history` will be empty. This is not a very "tight" design, but it's
-    /// enforced at construction time. From the `query` field.
-    pub legacy_query: Option<WorkflowQuery>,
-    /// Query requests from the `queries` field
-    pub query_requests: Vec<QueryWorkflow>,
-
-    /// Zero-size field to prevent explicit construction
-    _cant_construct_me: (),
-}
-
-impl TryFrom<PollWorkflowTaskQueueResponse> for ValidPollWFTQResponse {
-    /// We return the poll response itself if it was invalid
-    type Error = PollWorkflowTaskQueueResponse;
-
-    fn try_from(value: PollWorkflowTaskQueueResponse) -> Result<Self, Self::Error> {
-        match value {
-            PollWorkflowTaskQueueResponse {
-                task_token,
-                workflow_execution_task_queue: Some(tq),
-                workflow_execution: Some(workflow_execution),
-                workflow_type: Some(workflow_type),
-                history: Some(history),
-                next_page_token,
-                attempt,
-                previous_started_event_id,
-                started_event_id,
-                query,
-                queries,
-                ..
-            } => {
-                let query_requests = queries
-                    .into_iter()
-                    .map(|(id, q)| QueryWorkflow {
-                        query_id: id,
-                        query_type: q.query_type,
-                        arguments: Vec::from_payloads(q.query_args),
-                    })
-                    .collect();
-
-                Ok(Self {
-                    task_token: TaskToken(task_token),
-                    task_queue: tq.name,
-                    workflow_execution,
-                    workflow_type: workflow_type.name,
-                    history,
-                    next_page_token,
-                    attempt: attempt as u32,
-                    previous_started_event_id,
-                    started_event_id,
-                    legacy_query: query,
-                    query_requests,
-                    _cant_construct_me: (),
-                })
-            }
-            _ => Err(value),
-        }
-    }
-}
-
-/// A version of [RespondWorkflowTaskCompletedRequest] that will finish being filled out by the
-/// server client
-#[derive(Debug, Clone, PartialEq)]
-pub struct WorkflowTaskCompletion {
-    /// The task token that would've been received from [crate::Core::poll_workflow_activation] API.
-    pub task_token: TaskToken,
-    /// A list of new commands to send to the server, such as starting a timer.
-    pub commands: Vec<ProtoCommand>,
-    /// If set, indicate that next task should be queued on sticky queue with given attributes.
-    pub sticky_attributes: Option<StickyExecutionAttributes>,
-    /// Responses to queries in the `queries` field of the workflow task.
-    pub query_responses: Vec<QueryResult>,
-    pub return_new_workflow_task: bool,
-    pub force_create_new_workflow_task: bool,
-}
-
-pub(crate) trait WfActivationExt {
-    /// Returns true if this activation has one and only one job to perform a legacy query
-    fn is_legacy_query(&self) -> bool;
-}
-
-impl WfActivationExt for WfActivation {
-    fn is_legacy_query(&self) -> bool {
-        matches!(&self.jobs.as_slice(), &[WfActivationJob {
-                    variant: Some(wf_activation_job::Variant::QueryWorkflow(qr))
-                }] if qr.query_id == LEGACY_QUERY_ID)
-    }
-}
-
-/// Create a legacy query failure result
-pub(crate) fn legacy_query_failure(fail: workflow_completion::Failure) -> QueryResult {
-    QueryResult {
-        query_id: LEGACY_QUERY_ID.to_string(),
-        variant: Some(query_result::Variant::Failed(
-            fail.failure.unwrap_or_default(),
-        )),
-    }
-}
-
-pub(crate) trait HistoryEventExt {
-    /// If this history event represents a `changed` marker, return the info about
-    /// it. Returns `None` if it is any other kind of event or marker.
-    fn get_changed_marker_details(&self) -> Option<(String, bool)>;
-}
-
-impl HistoryEventExt for HistoryEvent {
-    fn get_changed_marker_details(&self) -> Option<(String, bool)> {
-        if self.event_type() == EventType::MarkerRecorded {
-            match &self.attributes {
-                Some(history_event::Attributes::MarkerRecordedEventAttributes(
-                    MarkerRecordedEventAttributes {
-                        marker_name,
-                        details,
-                        ..
-                    },
-                )) if marker_name == HAS_CHANGE_MARKER_NAME => {
-                    decode_change_marker_details(details)
-                }
-                _ => None,
-            }
-        } else {
-            None
-        }
-    }
-}