temporalio 0.1.1 → 0.2.0

data/bridge/sdk-core/core/src/protosext/mod.rs

@@ -1,428 +0,0 @@
-use crate::{
-    worker::{LocalActivityExecutionResult, LEGACY_QUERY_ID},
-    CompleteActivityError, TaskToken,
-};
-use anyhow::anyhow;
-use std::{
-    collections::HashMap,
-    convert::TryFrom,
-    fmt::{Debug, Display, Formatter},
-    time::{Duration, SystemTime},
-};
-use temporal_sdk_core_protos::{
-    constants::{LOCAL_ACTIVITY_MARKER_NAME, PATCH_MARKER_NAME},
-    coresdk::{
-        activity_result::{activity_execution_result, activity_execution_result::Status},
-        common::{
-            decode_change_marker_details, extract_local_activity_marker_data,
-            extract_local_activity_marker_details,
-        },
-        external_data::LocalActivityMarkerData,
-        workflow_activation::{
-            query_to_job, workflow_activation_job, QueryWorkflow, WorkflowActivation,
-            WorkflowActivationJob,
-        },
-        workflow_commands::{
-            query_result, ActivityCancellationType, QueryResult, ScheduleLocalActivity,
-        },
-        workflow_completion,
-    },
-    temporal::api::{
-        common::v1::{Payload, RetryPolicy, WorkflowExecution},
-        enums::v1::EventType,
-        failure::v1::Failure,
-        history::v1::{history_event, History, HistoryEvent, MarkerRecordedEventAttributes},
-        query::v1::WorkflowQuery,
-        workflowservice::v1::PollWorkflowTaskQueueResponse,
-    },
-    utilities::TryIntoOrNone,
-};
-
-/// A validated version of a [PollWorkflowTaskQueueResponse]
-#[derive(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 Debug for ValidPollWFTQResponse {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "ValidWFT {{ task_token: {}, task_queue: {}, workflow_execution: {:?}, \
-             workflow_type: {}, attempt: {}, previous_started_event_id: {}, started_event_id {}, \
-             history_length: {}, first_evt_in_hist_id: {:?}, legacy_query: {:?}, queries: {:?} }}",
-            self.task_token,
-            self.task_queue,
-            self.workflow_execution,
-            self.workflow_type,
-            self.attempt,
-            self.previous_started_event_id,
-            self.started_event_id,
-            self.history.events.len(),
-            self.history.events.get(0).map(|e| e.event_id),
-            self.legacy_query,
-            self.query_requests
-        )
-    }
-}
-
-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)| query_to_job(id, q))
-                    .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),
-        }
-    }
-}
-
-pub(crate) trait WorkflowActivationExt {
-    /// Returns true if this activation has one and only one job to perform a legacy query
-    fn is_legacy_query(&self) -> bool;
-}
-
-impl WorkflowActivationExt for WorkflowActivation {
-    fn is_legacy_query(&self) -> bool {
-        matches!(&self.jobs.as_slice(), &[WorkflowActivationJob {
-                    variant: Some(workflow_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 `patched` marker, return the info about
-    /// it. Returns `None` if it is any other kind of event or marker.
-    fn get_patch_marker_details(&self) -> Option<(String, bool)>;
-    /// If this history event represents a local activity marker, return true.
-    fn is_local_activity_marker(&self) -> bool;
-    /// If this history event represents a local activity marker, return the marker id info.
-    /// Returns `None` if it is any other kind of event or marker or the data is invalid.
-    fn extract_local_activity_marker_data(&self) -> Option<LocalActivityMarkerData>;
-    /// If this history event represents a local activity marker, return all the contained data.
-    /// Returns `None` if it is any other kind of event or marker or the data is invalid.
-    fn into_local_activity_marker_details(self) -> Option<CompleteLocalActivityData>;
-}
-
-impl HistoryEventExt for HistoryEvent {
-    fn get_patch_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 == PATCH_MARKER_NAME => decode_change_marker_details(details),
-                _ => None,
-            }
-        } else {
-            None
-        }
-    }
-
-    fn is_local_activity_marker(&self) -> bool {
-        if self.event_type() == EventType::MarkerRecorded {
-            return matches!(&self.attributes,
-                Some(history_event::Attributes::MarkerRecordedEventAttributes(
-                    MarkerRecordedEventAttributes { marker_name, .. },
-                )) if marker_name == LOCAL_ACTIVITY_MARKER_NAME
-            );
-        }
-        false
-    }
-
-    fn extract_local_activity_marker_data(&self) -> Option<LocalActivityMarkerData> {
-        if self.event_type() == EventType::MarkerRecorded {
-            match &self.attributes {
-                Some(history_event::Attributes::MarkerRecordedEventAttributes(
-                    MarkerRecordedEventAttributes {
-                        marker_name,
-                        details,
-                        ..
-                    },
-                )) if marker_name == LOCAL_ACTIVITY_MARKER_NAME => {
-                    extract_local_activity_marker_data(details)
-                }
-                _ => None,
-            }
-        } else {
-            None
-        }
-    }
-
-    fn into_local_activity_marker_details(self) -> Option<CompleteLocalActivityData> {
-        if self.event_type() == EventType::MarkerRecorded {
-            match self.attributes {
-                Some(history_event::Attributes::MarkerRecordedEventAttributes(
-                    MarkerRecordedEventAttributes {
-                        marker_name,
-                        mut details,
-                        failure,
-                        ..
-                    },
-                )) if marker_name == LOCAL_ACTIVITY_MARKER_NAME => {
-                    let (data, ok_res) = extract_local_activity_marker_details(&mut details);
-                    let data = data?;
-                    let result = match (ok_res, failure) {
-                        (Some(r), None) => Ok(r),
-                        (None | Some(_), Some(f)) => Err(f),
-                        (None, None) => Ok(Default::default()),
-                    };
-                    Some(CompleteLocalActivityData {
-                        marker_dat: data,
-                        result,
-                    })
-                }
-                _ => None,
-            }
-        } else {
-            None
-        }
-    }
-}
-
-pub(crate) struct CompleteLocalActivityData {
-    pub marker_dat: LocalActivityMarkerData,
-    pub result: Result<Payload, Failure>,
-}
-
-pub(crate) fn validate_activity_completion(
-    status: &activity_execution_result::Status,
-) -> Result<(), CompleteActivityError> {
-    match status {
-        Status::Completed(c) if c.result.is_none() => {
-            Err(CompleteActivityError::MalformedActivityCompletion {
-                reason: "Activity completions must contain a `result` payload \
-                             (which may be empty)"
-                    .to_string(),
-                completion: None,
-            })
-        }
-        _ => Ok(()),
-    }
-}
-
-impl TryFrom<activity_execution_result::Status> for LocalActivityExecutionResult {
-    type Error = CompleteActivityError;
-
-    fn try_from(s: activity_execution_result::Status) -> Result<Self, Self::Error> {
-        match s {
-            Status::Completed(c) => Ok(LocalActivityExecutionResult::Completed(c)),
-            Status::Failed(f)
-                if f.failure
-                    .as_ref()
-                    .map(|fail| fail.is_timeout().is_some())
-                    .unwrap_or_default() =>
-            {
-                Ok(LocalActivityExecutionResult::TimedOut(f))
-            }
-            Status::Failed(f) => Ok(LocalActivityExecutionResult::Failed(f)),
-            Status::Cancelled(cancel) => Ok(LocalActivityExecutionResult::Cancelled(cancel)),
-            Status::WillCompleteAsync(_) => {
-                Err(CompleteActivityError::MalformedActivityCompletion {
-                    reason: "Local activities cannot be completed async".to_string(),
-                    completion: None,
-                })
-            }
-        }
-    }
-}
-
-/// Validated version of [ScheduleLocalActivity]. See it for field docs.
-/// One or both of `schedule_to_close_timeout` and `start_to_close_timeout` are guaranteed to exist.
-#[derive(Debug, Clone)]
-#[cfg_attr(test, derive(Default))]
-pub struct ValidScheduleLA {
-    pub seq: u32,
-    pub activity_id: String,
-    pub activity_type: String,
-    pub attempt: u32,
-    pub original_schedule_time: Option<SystemTime>,
-    pub headers: HashMap<String, Payload>,
-    pub arguments: Vec<Payload>,
-    pub schedule_to_start_timeout: Option<Duration>,
-    pub close_timeouts: LACloseTimeouts,
-    pub retry_policy: RetryPolicy,
-    pub local_retry_threshold: Duration,
-    pub cancellation_type: ActivityCancellationType,
-}
-
-#[derive(Debug, Clone, Copy)]
-pub enum LACloseTimeouts {
-    ScheduleOnly(Duration),
-    StartOnly(Duration),
-    Both { sched: Duration, start: Duration },
-}
-
-impl LACloseTimeouts {
-    /// Splits into (schedule_to_close, start_to_close) options, one or both of which is guaranteed
-    /// to be populated
-    pub fn into_sched_and_start(self) -> (Option<Duration>, Option<Duration>) {
-        match self {
-            LACloseTimeouts::ScheduleOnly(x) => (Some(x), None),
-            LACloseTimeouts::StartOnly(x) => (None, Some(x)),
-            LACloseTimeouts::Both { sched, start } => (Some(sched), Some(start)),
-        }
-    }
-}
-
-#[cfg(test)]
-impl Default for LACloseTimeouts {
-    fn default() -> Self {
-        LACloseTimeouts::ScheduleOnly(Duration::from_secs(100))
-    }
-}
-
-impl ValidScheduleLA {
-    pub fn from_schedule_la(
-        v: ScheduleLocalActivity,
-        wf_exe_timeout: Option<Duration>,
-    ) -> Result<Self, anyhow::Error> {
-        let original_schedule_time = v
-            .original_schedule_time
-            .map(|x| {
-                x.try_into()
-                    .map_err(|_| anyhow!("Could not convert original_schedule_time"))
-            })
-            .transpose()?;
-        let sched_to_close = v
-            .schedule_to_close_timeout
-            .map(|x| {
-                x.try_into()
-                    .map_err(|_| anyhow!("Could not convert schedule_to_close_timeout"))
-            })
-            .transpose()?
-            // Default to execution timeout if unset
-            .or(wf_exe_timeout);
-        let mut schedule_to_start_timeout = v
-            .schedule_to_start_timeout
-            .map(|x| {
-                x.try_into()
-                    .map_err(|_| anyhow!("Could not convert schedule_to_start_timeout"))
-            })
-            .transpose()?;
-        // Clamp schedule-to-start if larger than schedule-to-close
-        if let Some((sched_to_start, sched_to_close)) =
-            schedule_to_start_timeout.as_mut().zip(sched_to_close)
-        {
-            if *sched_to_start > sched_to_close {
-                *sched_to_start = sched_to_close;
-            }
-        }
-        let close_timeouts = match (
-            sched_to_close,
-            v.start_to_close_timeout
-                .map(|x| {
-                    x.try_into()
-                        .map_err(|_| anyhow!("Could not convert start_to_close_timeout"))
-                })
-                .transpose()?,
-        ) {
-            (Some(sch), None) => LACloseTimeouts::ScheduleOnly(sch),
-            (None, Some(start)) => LACloseTimeouts::StartOnly(start),
-            (Some(sched), Some(mut start)) => {
-                // Clamp start-to-close if larger than schedule-to-close
-                if start > sched {
-                    start = sched;
-                }
-                LACloseTimeouts::Both { sched, start }
-            }
-            (None, None) => {
-                return Err(anyhow!(
-                    "One of schedule_to_close or start_to_close timeouts must be set"
-                ))
-            }
-        };
-        let retry_policy = v.retry_policy.unwrap_or_default();
-        let local_retry_threshold = v
-            .local_retry_threshold
-            .clone()
-            .try_into_or_none()
-            .unwrap_or_else(|| Duration::from_secs(60));
-        let cancellation_type = ActivityCancellationType::from_i32(v.cancellation_type)
-            .unwrap_or(ActivityCancellationType::WaitCancellationCompleted);
-        Ok(ValidScheduleLA {
-            seq: v.seq,
-            activity_id: v.activity_id,
-            activity_type: v.activity_type,
-            attempt: v.attempt,
-            original_schedule_time,
-            headers: v.headers,
-            arguments: v.arguments,
-            schedule_to_start_timeout,
-            close_timeouts,
-            retry_policy,
-            local_retry_threshold,
-            cancellation_type,
-        })
-    }
-}
-
-impl Display for ValidScheduleLA {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "ValidScheduleLA({}, {})", self.seq, self.activity_type)
-    }
-}

data/bridge/sdk-core/core/src/replay/mod.rs

@@ -1,215 +0,0 @@
-//! This module implements support for creating special core instances and workers which can be used
-//! to replay canned histories. It should be used by Lang SDKs to provide replay capabilities to
-//! users during testing.
-
-use crate::{
-    worker::client::{mocks::mock_manual_workflow_client, WorkerClient},
-    Worker,
-};
-use futures::{FutureExt, Stream, StreamExt};
-use once_cell::sync::OnceCell;
-use parking_lot::Mutex;
-use std::{
-    collections::HashMap,
-    pin::Pin,
-    sync::Arc,
-    task::{Context, Poll},
-};
-use temporal_sdk_core_protos::{
-    coresdk::workflow_activation::remove_from_cache::EvictionReason,
-    temporal::api::{
-        common::v1::WorkflowExecution,
-        history::v1::History,
-        workflowservice::v1::{
-            RespondWorkflowTaskCompletedResponse, RespondWorkflowTaskFailedResponse,
-        },
-    },
-};
-pub use temporal_sdk_core_protos::{
-    default_wes_attribs, HistoryInfo, TestHistoryBuilder, DEFAULT_WORKFLOW_TYPE,
-};
-use tokio::sync::{mpsc, mpsc::UnboundedSender, Mutex as TokioMutex};
-use tokio_stream::wrappers::UnboundedReceiverStream;
-use tokio_util::sync::CancellationToken;
-
-/// A history which will be used during replay verification. Since histories do not include the
-/// workflow id, it must be manually attached.
-#[derive(Debug, Clone, derive_more::Constructor)]
-pub struct HistoryForReplay {
-    hist: History,
-    workflow_id: String,
-}
-
-/// Allows lang to feed histories into the replayer one at a time. Simply drop the feeder to signal
-/// to the worker that you're done and it should initiate shutdown.
-pub struct HistoryFeeder {
-    tx: mpsc::Sender<HistoryForReplay>,
-}
-/// The stream half of a [HistoryFeeder]
-pub struct HistoryFeederStream {
-    rcvr: mpsc::Receiver<HistoryForReplay>,
-}
-
-impl HistoryFeeder {
-    /// Make a new history feeder, which will store at most `buffer_size` histories before `feed`
-    /// blocks.
-    ///
-    /// Returns a feeder which will be used to feed in histories, and a stream you can pass to
-    /// one of the replay worker init functions.
-    pub fn new(buffer_size: usize) -> (Self, HistoryFeederStream) {
-        let (tx, rcvr) = mpsc::channel(buffer_size);
-        (Self { tx }, HistoryFeederStream { rcvr })
-    }
-    /// Feed a new history into the replayer, blocking if there is not room to accept another
-    /// history.
-    pub async fn feed(&self, history: HistoryForReplay) -> anyhow::Result<()> {
-        self.tx.send(history).await?;
-        Ok(())
-    }
-}
-
-impl Stream for HistoryFeederStream {
-    type Item = HistoryForReplay;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        self.rcvr.poll_recv(cx)
-    }
-}
-
-/// Create a mock client which can be used by a replay worker to serve up canned histories. It will
-/// return the entire history in one workflow task. If a workflow task failure is sent to the mock,
-/// it will send the complete response again.
-///
-/// Once it runs out of histories to return, it will serve up default responses after a 10s delay
-pub(crate) fn mock_client_from_histories(historator: Historator) -> impl WorkerClient {
-    let mut mg = mock_manual_workflow_client();
-
-    let hist_allow_tx = historator.replay_done_tx.clone();
-    let historator = Arc::new(TokioMutex::new(historator));
-
-    mg.expect_poll_workflow_task().returning(move |_, _| {
-        let historator = historator.clone();
-        async move {
-            let mut hlock = historator.lock().await;
-            // Always wait for permission before dispatching the next task
-            let _ = hlock.allow_stream.next().await;
-
-            if let Some(history) = hlock.next().await {
-                let hist_info = HistoryInfo::new_from_history(&history.hist, None).unwrap();
-                let mut resp = hist_info.as_poll_wft_response();
-                resp.workflow_execution = Some(WorkflowExecution {
-                    workflow_id: history.workflow_id,
-                    run_id: hist_info.orig_run_id().to_string(),
-                });
-                Ok(resp)
-            } else {
-                if let Some(wc) = hlock.worker_closer.get() {
-                    wc.cancel();
-                }
-                Ok(Default::default())
-            }
-        }
-        .boxed()
-    });
-
-    mg.expect_complete_workflow_task().returning(move |_| {
-        async move { Ok(RespondWorkflowTaskCompletedResponse::default()) }.boxed()
-    });
-    mg.expect_fail_workflow_task().returning(move |_, _, _| {
-        hist_allow_tx.send("Failed".to_string()).unwrap();
-        async move { Ok(RespondWorkflowTaskFailedResponse::default()) }.boxed()
-    });
-
-    mg
-}
-
-pub(crate) struct Historator {
-    iter: Pin<Box<dyn Stream<Item = HistoryForReplay> + Send>>,
-    allow_stream: UnboundedReceiverStream<String>,
-    worker_closer: Arc<OnceCell<CancellationToken>>,
-    dat: Arc<Mutex<HistoratorDat>>,
-    replay_done_tx: UnboundedSender<String>,
-}
-impl Historator {
-    pub(crate) fn new(histories: impl Stream<Item = HistoryForReplay> + Send + 'static) -> Self {
-        let dat = Arc::new(Mutex::new(HistoratorDat::default()));
-        let (replay_done_tx, replay_done_rx) = mpsc::unbounded_channel();
-        // Need to allow the first history item
-        replay_done_tx.send("fake".to_string()).unwrap();
-        Self {
-            iter: Box::pin(histories.fuse()),
-            allow_stream: UnboundedReceiverStream::new(replay_done_rx),
-            worker_closer: Arc::new(OnceCell::new()),
-            dat,
-            replay_done_tx,
-        }
-    }
-
-    /// Returns a callback that can be used as the post-activation hook for a worker to indicate
-    /// we're ready to replay the next history, or whatever else.
-    pub(crate) fn get_post_activate_hook(&self) -> impl Fn(&Worker, &str, usize) + Send + Sync {
-        let dat = self.dat.clone();
-        let done_tx = self.replay_done_tx.clone();
-        move |worker, activated_run_id, last_processed_event| {
-            // We can't hold the lock while evaluating the hook, or we'd deadlock.
-            let last_event_in_hist = dat
-                .lock()
-                .run_id_to_last_event_num
-                .get(activated_run_id)
-                .cloned();
-            if let Some(le) = last_event_in_hist {
-                if last_processed_event >= le {
-                    worker.request_wf_eviction(
-                        activated_run_id,
-                        "Always evict workflows after replay",
-                        EvictionReason::LangRequested,
-                    );
-                    done_tx.send(activated_run_id.to_string()).unwrap();
-                }
-            }
-        }
-    }
-
-    pub(crate) fn get_shutdown_setter(&self) -> impl FnOnce(CancellationToken) + 'static {
-        let wc = self.worker_closer.clone();
-        move |ct| {
-            wc.set(ct).expect("Shutdown token must only be set once");
-        }
-    }
-}
-
-impl Stream for Historator {
-    type Item = HistoryForReplay;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        match self.iter.poll_next_unpin(cx) {
-            Poll::Ready(Some(history)) => {
-                let run_id = history
-                    .hist
-                    .extract_run_id_from_start()
-                    .expect(
-                        "Histories provided for replay must contain run ids in their workflow \
-                                 execution started events",
-                    )
-                    .to_string();
-                let last_event = history.hist.last_event_id();
-                self.dat
-                    .lock()
-                    .run_id_to_last_event_num
-                    .insert(run_id, last_event as usize);
-                Poll::Ready(Some(history))
-            }
-            Poll::Ready(None) => {
-                self.dat.lock().all_dispatched = true;
-                Poll::Ready(None)
-            }
-            o => o,
-        }
-    }
-}
-
-#[derive(Default)]
-struct HistoratorDat {
-    run_id_to_last_event_num: HashMap<String, usize>,
-    all_dispatched: bool,
-}