@temporalio/core-bridge 0.17.2 → 0.18.0

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

@@ -0,0 +1,396 @@
+use crate::{
+    worker::LocalActivityExecutionResult, workflow::LEGACY_QUERY_ID, CompleteActivityError,
+    TaskToken,
+};
+use anyhow::anyhow;
+use std::{
+    collections::HashMap,
+    convert::TryFrom,
+    fmt::{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, Payload as SDKPayload, RetryPolicy,
+        },
+        external_data::LocalActivityMarkerData,
+        workflow_activation::{
+            workflow_activation_job, QueryWorkflow, WorkflowActivation, WorkflowActivationJob,
+        },
+        workflow_commands::{
+            query_result, ActivityCancellationType, QueryResult, ScheduleLocalActivity,
+        },
+        workflow_completion, FromPayloadsExt,
+    },
+    temporal::api::{
+        common::v1::{Payload, 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(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),
+        }
+    }
+}
+
+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 = if let Some(r) = ok_res {
+                        Ok(r)
+                    } else {
+                        let fail = failure?;
+                        Err(fail)
+                    };
+                    Some(CompleteLocalActivityData {
+                        marker_dat: data,
+                        result,
+                    })
+                }
+                _ => None,
+            }
+        } else {
+            None
+        }
+    }
+}
+
+pub(crate) struct CompleteLocalActivityData {
+    pub marker_dat: LocalActivityMarkerData,
+    pub result: Result<Payload, Failure>,
+}
+
+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())
+                    .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 header_fields: HashMap<String, SDKPayload>,
+    pub arguments: Vec<SDKPayload>,
+    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
+            .ok_or(anyhow!("Retry policy must be defined!"))?;
+        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,
+            header_fields: v.header_fields,
+            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)
+    }
+}

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

@@ -0,0 +1,210 @@
+//! 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::{init_mock_gateway, CoreInitOptionsBuilder, CoreSDK, TelemetryOptions};
+use futures::FutureExt;
+use std::{
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
+    time::Duration,
+};
+use temporal_client::{
+    mocks::{mock_gateway, mock_manual_gateway},
+    ServerGatewayApis,
+};
+use temporal_sdk_core_api::{
+    errors::{
+        CompleteActivityError, CompleteWfError, PollActivityError, PollWfError,
+        WorkerRegistrationError,
+    },
+    worker::WorkerConfig,
+    Core, CoreLog,
+};
+use temporal_sdk_core_protos::{
+    coresdk::{
+        activity_task::ActivityTask, workflow_activation::WorkflowActivation,
+        workflow_completion::WorkflowActivationCompletion, ActivityHeartbeat,
+        ActivityTaskCompletion,
+    },
+    temporal::api::{
+        common::v1::WorkflowExecution,
+        history::v1::History,
+        workflowservice::v1::{
+            RespondWorkflowTaskCompletedResponse, RespondWorkflowTaskFailedResponse,
+            StartWorkflowExecutionResponse,
+        },
+    },
+};
+
+pub use temporal_sdk_core_protos::{
+    default_wes_attribs, HistoryInfo, TestHistoryBuilder, DEFAULT_WORKFLOW_TYPE,
+};
+
+/// Create a core instance that can be used for replay. See the [ReplayCore] trait for adding
+/// canned history.
+pub fn init_core_replay(opts: TelemetryOptions) -> ReplayCoreImpl {
+    let shared_mock_gateway = mock_gateway();
+    let init_opts = CoreInitOptionsBuilder::default()
+        .gateway_opts(shared_mock_gateway.get_options().clone())
+        .telemetry_opts(opts)
+        .build()
+        .expect("replay core options init properly");
+    let replay_core =
+        init_mock_gateway(init_opts, shared_mock_gateway).expect("init replay core works");
+    ReplayCoreImpl { inner: replay_core }
+}
+
+/// An extension of the [Core] trait to be used for testing workflows against canned histories.
+pub trait ReplayCore: Core {
+    /// Make a fake worker which will use the provided history to simulate poll responses containing
+    /// that entire history. The configuration should have a unique task queue name.
+    ///
+    /// Note that some of the worker config options do not apply, and some will be overridden.
+    /// Replay workers always are cached, have only 1 poller, and do not poll for activities.
+    fn make_replay_worker(
+        &self,
+        config: WorkerConfig,
+        history: &History,
+    ) -> Result<(), anyhow::Error>;
+}
+
+/// Implements [ReplayCore] functionality
+pub struct ReplayCoreImpl {
+    pub(crate) inner: CoreSDK,
+}
+
+impl ReplayCore for ReplayCoreImpl {
+    fn make_replay_worker(
+        &self,
+        mut config: WorkerConfig,
+        history: &History,
+    ) -> Result<(), anyhow::Error> {
+        let mock_g = mock_gateway_from_history(history, config.task_queue.clone());
+        config.max_cached_workflows = 1;
+        config.max_concurrent_wft_polls = 1;
+        config.no_remote_activities = true;
+        self.inner
+            .register_replay_worker(config, Arc::new(mock_g), history)
+    }
+}
+
+#[async_trait::async_trait]
+impl Core for ReplayCoreImpl {
+    fn register_worker(&self, _config: WorkerConfig) -> Result<(), WorkerRegistrationError> {
+        panic!("Do not use `register_worker` with a replay core instance")
+    }
+
+    async fn poll_workflow_activation(
+        &self,
+        task_queue: &str,
+    ) -> Result<WorkflowActivation, PollWfError> {
+        self.inner.poll_workflow_activation(task_queue).await
+    }
+
+    async fn poll_activity_task(
+        &self,
+        task_queue: &str,
+    ) -> Result<ActivityTask, PollActivityError> {
+        self.inner.poll_activity_task(task_queue).await
+    }
+
+    async fn complete_workflow_activation(
+        &self,
+        completion: WorkflowActivationCompletion,
+    ) -> Result<(), CompleteWfError> {
+        self.inner.complete_workflow_activation(completion).await
+    }
+
+    async fn complete_activity_task(
+        &self,
+        completion: ActivityTaskCompletion,
+    ) -> Result<(), CompleteActivityError> {
+        self.inner.complete_activity_task(completion).await
+    }
+
+    fn record_activity_heartbeat(&self, _details: ActivityHeartbeat) {
+        // do nothing
+    }
+
+    fn request_workflow_eviction(&self, task_queue: &str, run_id: &str) {
+        self.inner.request_workflow_eviction(task_queue, run_id)
+    }
+
+    fn server_gateway(&self) -> Arc<dyn ServerGatewayApis + Send + Sync> {
+        self.inner.server_gateway()
+    }
+
+    async fn shutdown(&self) {
+        self.inner.shutdown().await
+    }
+
+    async fn shutdown_worker(&self, task_queue: &str) {
+        self.inner.shutdown_worker(task_queue).await
+    }
+
+    fn fetch_buffered_logs(&self) -> Vec<CoreLog> {
+        self.inner.fetch_buffered_logs()
+    }
+}
+
+/// Create a mock gateway which can be used by a replay worker to serve up canned history.
+/// It will return the entire history in one workflow task, after that it will return default
+/// responses (with a 10s wait). If a workflow task failure is sent to the mock, it will send
+/// the complete response again.
+pub fn mock_gateway_from_history(
+    history: &History,
+    task_queue: impl Into<String>,
+) -> impl ServerGatewayApis {
+    let mut mg = mock_manual_gateway();
+
+    let hist_info = HistoryInfo::new_from_history(history, None).unwrap();
+    let wf = WorkflowExecution {
+        workflow_id: "fake_wf_id".to_string(),
+        run_id: hist_info.orig_run_id().to_string(),
+    };
+
+    let wf_clone = wf.clone();
+    mg.expect_start_workflow().returning(move |_, _, _, _, _| {
+        let wf_clone = wf_clone.clone();
+        async move {
+            Ok(StartWorkflowExecutionResponse {
+                run_id: wf_clone.run_id.clone(),
+            })
+        }
+        .boxed()
+    });
+
+    let did_send = Arc::new(AtomicBool::new(false));
+    let did_send_clone = did_send.clone();
+    let tq = task_queue.into();
+    mg.expect_poll_workflow_task().returning(move |_, _| {
+        let hist_info = hist_info.clone();
+        let wf = wf.clone();
+        let did_send_clone = did_send_clone.clone();
+        let tq = tq.clone();
+        async move {
+            if !did_send_clone.swap(true, Ordering::AcqRel) {
+                let mut resp = hist_info.as_poll_wft_response(tq);
+                resp.workflow_execution = Some(wf.clone());
+                Ok(resp)
+            } else {
+                tokio::time::sleep(Duration::from_secs(10)).await;
+                Ok(Default::default())
+            }
+        }
+        .boxed()
+    });
+
+    mg.expect_complete_workflow_task()
+        .returning(|_| async move { Ok(RespondWorkflowTaskCompletedResponse::default()) }.boxed());
+    mg.expect_fail_workflow_task().returning(move |_, _, _| {
+        // We'll need to re-send the history if WFT fails
+        did_send.store(false, Ordering::Release);
+        async move { Ok(RespondWorkflowTaskFailedResponse {}) }.boxed()
+    });
+
+    mg
+}