@temporalio/core-bridge 0.16.4 → 0.18.0

package/sdk-core/{src/prototype_rust_sdk → sdk/src}/workflow_context.rs

@@ -1,25 +1,37 @@
-use crate::prototype_rust_sdk::{
-    CancelExternalWfResult, CancellableID, CommandCreateRequest,
-    CommandSubscribeChildWorkflowCompletion, RustWfCmd, SignalExternalWfResult, TimerResult,
-    UnblockEvent, Unblockable,
+mod options;
+
+pub use options::{ActivityOptions, ChildWorkflowOptions, LocalActivityOptions};
+
+use crate::{
+    workflow_context::options::IntoWorkflowCommand, CancelExternalWfResult, CancellableID,
+    CommandCreateRequest, CommandSubscribeChildWorkflowCompletion, RustWfCmd,
+    SignalExternalWfResult, TimerResult, UnblockEvent, Unblockable,
 };
 use crossbeam::channel::{Receiver, Sender};
 use futures::{task::Context, FutureExt, Stream};
 use parking_lot::RwLock;
 use std::{
-    collections::HashMap, future::Future, marker::PhantomData, pin::Pin, sync::Arc, task::Poll,
-    time::Duration,
+    collections::HashMap,
+    future::Future,
+    marker::PhantomData,
+    pin::Pin,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
+    task::Poll,
+    time::{Duration, SystemTime},
 };
 use temporal_sdk_core_protos::coresdk::{
-    activity_result::ActivityResult,
-    child_workflow::{ChildWorkflowCancellationType, ChildWorkflowResult},
+    activity_result::{activity_resolution, ActivityResolution},
+    child_workflow::ChildWorkflowResult,
     common::{NamespacedWorkflowExecution, Payload},
     workflow_activation::resolve_child_workflow_execution_start::Status as ChildWorkflowStartStatus,
     workflow_commands::{
         request_cancel_external_workflow_execution as cancel_we,
-        signal_external_workflow_execution as sig_we, workflow_command, ActivityCancellationType,
-        RequestCancelExternalWorkflowExecution, ScheduleActivity, SetPatchMarker,
-        SignalExternalWorkflowExecution, StartChildWorkflowExecution, StartTimer,
+        signal_external_workflow_execution as sig_we, workflow_command,
+        RequestCancelExternalWorkflowExecution, SetPatchMarker, SignalExternalWorkflowExecution,
+        StartTimer,
     },
 };
 use tokio::sync::{mpsc, oneshot, watch};
@@ -28,12 +40,17 @@ use tokio_stream::wrappers::UnboundedReceiverStream;
 /// Used within workflows to issue commands, get info, etc.
 pub struct WfContext {
     namespace: String,
+    task_queue: String,
     args: Vec<Payload>,
 
     chan: Sender<RustWfCmd>,
     am_cancelled: watch::Receiver<bool>,
     shared: Arc<RwLock<WfContextSharedData>>,
 
+    seq_nums: RwLock<WfCtxProtectedDat>,
+}
+
+struct WfCtxProtectedDat {
     next_timer_sequence_number: u32,
     next_activity_sequence_number: u32,
     next_child_workflow_sequence_number: u32,
@@ -41,11 +58,40 @@ pub struct WfContext {
     next_signal_external_wf_sequence_number: u32,
 }
 
+impl WfCtxProtectedDat {
+    fn next_timer_seq(&mut self) -> u32 {
+        let seq = self.next_timer_sequence_number;
+        self.next_timer_sequence_number += 1;
+        seq
+    }
+    fn next_activity_seq(&mut self) -> u32 {
+        let seq = self.next_activity_sequence_number;
+        self.next_activity_sequence_number += 1;
+        seq
+    }
+    fn next_child_workflow_seq(&mut self) -> u32 {
+        let seq = self.next_child_workflow_sequence_number;
+        self.next_child_workflow_sequence_number += 1;
+        seq
+    }
+    fn next_cancel_external_wf_seq(&mut self) -> u32 {
+        let seq = self.next_cancel_external_wf_sequence_number;
+        self.next_cancel_external_wf_sequence_number += 1;
+        seq
+    }
+    fn next_signal_external_wf_seq(&mut self) -> u32 {
+        let seq = self.next_signal_external_wf_sequence_number;
+        self.next_signal_external_wf_sequence_number += 1;
+        seq
+    }
+}
+
 #[derive(Clone, Debug, Default)]
 pub struct WfContextSharedData {
     /// Maps change ids -> resolved status
     pub changes: HashMap<String, bool>,
     pub is_replaying: bool,
+    pub wf_time: Option<SystemTime>,
 }
 
 // TODO: Dataconverter type interface to replace Payloads here. Possibly just use serde
@@ -55,6 +101,7 @@ impl WfContext {
     /// sent from the workflow.
     pub(super) fn new(
         namespace: String,
+        task_queue: String,
         args: Vec<Payload>,
         am_cancelled: watch::Receiver<bool>,
     ) -> (Self, Receiver<RustWfCmd>) {
@@ -63,15 +110,18 @@ impl WfContext {
         (
             Self {
                 namespace,
+                task_queue,
                 args,
                 chan,
                 am_cancelled,
                 shared: Arc::new(RwLock::new(Default::default())),
-                next_timer_sequence_number: 1,
-                next_activity_sequence_number: 1,
-                next_child_workflow_sequence_number: 1,
-                next_cancel_external_wf_sequence_number: 1,
-                next_signal_external_wf_sequence_number: 1,
+                seq_nums: RwLock::new(WfCtxProtectedDat {
+                    next_timer_sequence_number: 1,
+                    next_activity_sequence_number: 1,
+                    next_child_workflow_sequence_number: 1,
+                    next_cancel_external_wf_sequence_number: 1,
+                    next_signal_external_wf_sequence_number: 1,
+                }),
             },
             rx,
         )
@@ -87,6 +137,11 @@ impl WfContext {
         self.args.as_slice()
     }
 
+    /// Return the current time according to the workflow (which is not wall-clock time).
+    pub fn workflow_time(&self) -> Option<SystemTime> {
+        self.shared.read().wf_time
+    }
+
     pub(crate) fn get_shared_data(&self) -> Arc<RwLock<WfContextSharedData>> {
         self.shared.clone()
     }
@@ -103,9 +158,8 @@ impl WfContext {
     }
 
     /// Request to create a timer
-    pub fn timer(&mut self, duration: Duration) -> impl CancellableFuture<TimerResult> {
-        let seq = self.next_timer_sequence_number;
-        self.next_timer_sequence_number += 1;
+    pub fn timer(&self, duration: Duration) -> impl CancellableFuture<TimerResult> {
+        let seq = self.seq_nums.write().next_timer_seq();
         let (cmd, unblocker) = CancellableWFCommandFut::new(CancellableID::Timer(seq));
         self.send(
             CommandCreateRequest {
@@ -122,13 +176,18 @@ impl WfContext {
     }
 
     /// Request to run an activity
-    pub fn activity(&mut self, opts: ActivityOptions) -> impl CancellableFuture<ActivityResult> {
-        let seq = self.next_activity_sequence_number;
-        self.next_activity_sequence_number += 1;
+    pub fn activity(
+        &self,
+        mut opts: ActivityOptions,
+    ) -> impl CancellableFuture<ActivityResolution> {
+        if opts.task_queue.is_empty() {
+            opts.task_queue = self.task_queue.clone()
+        }
+        let seq = self.seq_nums.write().next_activity_seq();
         let (cmd, unblocker) = CancellableWFCommandFut::new(CancellableID::Activity(seq));
         self.send(
             CommandCreateRequest {
-                cmd: opts.to_command(seq).into(),
+                cmd: opts.into_command(seq).into(),
                 unblocker,
             }
             .into(),
@@ -136,8 +195,33 @@ impl WfContext {
         cmd
     }
 
-    /// Request to start a child workflow, Returned future resolves when the child has been started.
-    pub fn child_workflow(&mut self, opts: ChildWorkflowOptions) -> ChildWorkflow {
+    /// Request to run a local activity
+    pub fn local_activity(
+        &self,
+        opts: LocalActivityOptions,
+    ) -> impl CancellableFuture<ActivityResolution> + '_ {
+        LATimerBackoffFut::new(opts, self)
+    }
+
+    /// Request to run a local activity with no implementation of timer-backoff based retrying.
+    fn local_activity_no_timer_retry(
+        &self,
+        opts: LocalActivityOptions,
+    ) -> impl CancellableFuture<ActivityResolution> {
+        let seq = self.seq_nums.write().next_activity_seq();
+        let (cmd, unblocker) = CancellableWFCommandFut::new(CancellableID::LocalActivity(seq));
+        self.send(
+            CommandCreateRequest {
+                cmd: opts.into_command(seq).into(),
+                unblocker,
+            }
+            .into(),
+        );
+        cmd
+    }
+
+    /// Creates a child workflow stub with the provided options
+    pub fn child_workflow(&self, opts: ChildWorkflowOptions) -> ChildWorkflow {
         ChildWorkflow { opts }
     }
 
@@ -180,7 +264,7 @@ impl WfContext {
     /// Send a signal to an external workflow. May resolve as a failure if the signal didn't work
     /// or was cancelled.
     pub fn signal_workflow(
-        &mut self,
+        &self,
         workflow_id: impl Into<String>,
         run_id: impl Into<String>,
         signal_name: impl Into<String>,
@@ -196,7 +280,7 @@ impl WfContext {
 
     /// Return a stream that produces values when the named signal is sent to this workflow
     pub fn make_signal_channel(
-        &mut self,
+        &self,
         signal_name: impl Into<String>,
     ) -> impl Stream<Item = Vec<Payload>> {
         let (tx, rx) = mpsc::unbounded_channel();
@@ -211,14 +295,12 @@ impl WfContext {
 
     /// Request the cancellation of an external workflow. May resolve as a failure if the workflow
     /// was not found or the cancel was otherwise unsendable.
-    /// TODO: Own result type
     pub fn cancel_external(
-        &mut self,
+        &self,
         target: NamespacedWorkflowExecution,
     ) -> impl Future<Output = CancelExternalWfResult> {
         let target = cancel_we::Target::WorkflowExecution(target);
-        let seq = self.next_cancel_external_wf_sequence_number;
-        self.next_cancel_external_wf_sequence_number += 1;
+        let seq = self.seq_nums.write().next_cancel_external_wf_seq();
         let (cmd, unblocker) = WFCommandFut::new();
         self.send(
             CommandCreateRequest {
@@ -235,13 +317,12 @@ impl WfContext {
     }
 
     fn send_signal_wf(
-        &mut self,
+        &self,
         signal_name: impl Into<String>,
         payload: impl Into<Payload>,
         target: sig_we::Target,
     ) -> impl CancellableFuture<SignalExternalWfResult> {
-        let seq = self.next_signal_external_wf_sequence_number;
-        self.next_signal_external_wf_sequence_number += 1;
+        let seq = self.seq_nums.write().next_signal_external_wf_seq();
         let (cmd, unblocker) =
             CancellableWFCommandFut::new(CancellableID::SignalExternalWorkflow(seq));
         self.send(
@@ -261,7 +342,7 @@ impl WfContext {
     }
 
     /// Cancel any cancellable operation by ID
-    fn cancel(&mut self, cancellable_id: CancellableID) {
+    fn cancel(&self, cancellable_id: CancellableID) {
         self.send(RustWfCmd::Cancel(cancellable_id));
     }
 
@@ -274,7 +355,7 @@ impl WfContext {
 /// Used in the prototype SDK for cancelling operations like timers and activities.
 pub trait CancellableFuture<T>: Future<Output = T> {
     /// Cancel this Future
-    fn cancel(&self, cx: &mut WfContext);
+    fn cancel(&self, cx: &WfContext);
 }
 
 struct WFCommandFut<T, D> {
@@ -362,98 +443,96 @@ impl<T, D> CancellableFuture<T> for CancellableWFCommandFut<T, D>
 where
     T: Unblockable<OtherDat = D>,
 {
-    fn cancel(&self, cx: &mut WfContext) {
+    fn cancel(&self, cx: &WfContext) {
         cx.cancel(self.cancellable_id.clone());
     }
 }
 
-/// Options for scheduling an activity
-#[derive(Default, Debug)]
-pub struct ActivityOptions {
-    /// Identifier to use for tracking the activity in Workflow history.
-    /// The `activityId` can be accessed by the activity function.
-    /// Does not need to be unique.
-    ///
-    /// If `None` use the context's sequence number
-    pub activity_id: Option<String>,
-    /// Type of activity to schedule
-    pub activity_type: String,
-    /// Task queue to schedule the activity in
-    pub task_queue: String,
-    /// Time that the Activity Task can stay in the Task Queue before it is picked up by a Worker.
-    /// Do not specify this timeout unless using host specific Task Queues for Activity Tasks are
-    /// being used for routing.
-    /// `schedule_to_start_timeout` is always non-retryable.
-    /// Retrying after this timeout doesn't make sense as it would just put the Activity Task back
-    /// into the same Task Queue.
-    pub schedule_to_start_timeout: Option<Duration>,
-    /// Maximum time of a single Activity execution attempt.
-    /// Note that the Temporal Server doesn't detect Worker process failures directly.
-    /// It relies on this timeout to detect that an Activity that didn't complete on time.
-    /// So this timeout should be as short as the longest possible execution of the Activity body.
-    /// Potentially long running Activities must specify `heartbeat_timeout` and heartbeat from the
-    /// activity periodically for timely failure detection.
-    /// Either this option or `schedule_to_close_timeout` is required.
-    pub start_to_close_timeout: Option<Duration>,
-    /// Total time that a workflow is willing to wait for Activity to complete.
-    /// `schedule_to_close_timeout` limits the total time of an Activity's execution including
-    /// retries (use `start_to_close_timeout` to limit the time of a single attempt).
-    /// Either this option or `start_to_close_timeout` is required.
-    pub schedule_to_close_timeout: Option<Duration>,
-    /// Heartbeat interval. Activity must heartbeat before this interval passes after a last
-    /// heartbeat or activity start.
-    pub heartbeat_timeout: Option<Duration>,
-    /// Determines what the SDK does when the Activity is cancelled.
-    pub cancellation_type: ActivityCancellationType,
-    // Add more fields here as needed
+struct LATimerBackoffFut<'a> {
+    la_opts: LocalActivityOptions,
+    current_fut: Pin<Box<dyn CancellableFuture<ActivityResolution> + Send + Unpin + 'a>>,
+    timer_fut: Option<Pin<Box<dyn CancellableFuture<TimerResult> + Send + Unpin + 'a>>>,
+    ctx: &'a WfContext,
+    next_attempt: u32,
+    next_sched_time: Option<prost_types::Timestamp>,
+    did_cancel: AtomicBool,
 }
-
-impl ActivityOptions {
-    /// Turns an `ActivityOptions` struct to a `ScheduleActivity` struct using given `seq`
-    pub fn to_command(&self, seq: u32) -> ScheduleActivity {
-        ScheduleActivity {
-            seq,
-            activity_id: match &self.activity_id {
-                None => seq.to_string(),
-                Some(aid) => aid.clone(),
-            },
-            activity_type: self.activity_type.clone(),
-            task_queue: self.task_queue.clone(),
-            schedule_to_close_timeout: self.schedule_to_close_timeout.map(Into::into),
-            schedule_to_start_timeout: self.schedule_to_start_timeout.map(Into::into),
-            start_to_close_timeout: self.start_to_close_timeout.map(Into::into),
-            heartbeat_timeout: self.heartbeat_timeout.map(Into::into),
-            cancellation_type: self.cancellation_type as i32,
-            ..Default::default()
+impl<'a> LATimerBackoffFut<'a> {
+    pub(crate) fn new(opts: LocalActivityOptions, ctx: &'a WfContext) -> Self {
+        Self {
+            la_opts: opts.clone(),
+            current_fut: Box::pin(ctx.local_activity_no_timer_retry(opts)),
+            timer_fut: None,
+            ctx,
+            next_attempt: 1,
+            next_sched_time: None,
+            did_cancel: AtomicBool::new(false),
         }
     }
 }
+impl<'a> Unpin for LATimerBackoffFut<'a> {}
+impl<'a> Future for LATimerBackoffFut<'a> {
+    type Output = ActivityResolution;
 
-/// Options for scheduling a child workflow
-#[derive(Default, Debug, Clone)]
-pub struct ChildWorkflowOptions {
-    /// Workflow ID
-    pub workflow_id: String,
-    /// Type of workflow to schedule
-    pub workflow_type: String,
-    /// Input to send the child Workflow
-    pub input: Vec<Payload>,
-    /// Cancellation strategy for the child workflow
-    pub cancel_type: ChildWorkflowCancellationType,
-}
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        // If the timer exists, wait for it first
+        if let Some(tf) = self.timer_fut.as_mut() {
+            return match tf.poll_unpin(cx) {
+                Poll::Ready(tr) => {
+                    self.timer_fut = None;
+                    // Schedule next LA if this timer wasn't cancelled
+                    if let TimerResult::Fired = tr {
+                        let mut opts = self.la_opts.clone();
+                        opts.attempt = Some(self.next_attempt);
+                        opts.original_schedule_time = self.next_sched_time.clone();
+                        self.current_fut = Box::pin(self.ctx.local_activity_no_timer_retry(opts));
+                        Poll::Pending
+                    } else {
+                        Poll::Ready(ActivityResolution {
+                            status: Some(
+                                activity_resolution::Status::Cancelled(Default::default()),
+                            ),
+                        })
+                    }
+                }
+                Poll::Pending => Poll::Pending,
+            };
+        }
+        let poll_res = self.current_fut.poll_unpin(cx);
+        if let Poll::Ready(ref r) = poll_res {
+            // If we've already said we want to cancel, don't schedule the backoff timer. Just
+            // return cancel status. This can happen if cancel comes after the LA says it wants to
+            // back off but before we have scheduled the timer.
+            if self.did_cancel.load(Ordering::Acquire) {
+                return Poll::Ready(ActivityResolution {
+                    status: Some(activity_resolution::Status::Cancelled(Default::default())),
+                });
+            }
 
-impl ChildWorkflowOptions {
-    /// Turns a `ChildWorkflowOptions` struct to a `StartChildWorkflowExecution` struct using
-    /// given `seq`
-    pub fn into_command(self, seq: u32) -> StartChildWorkflowExecution {
-        StartChildWorkflowExecution {
-            seq,
-            workflow_id: self.workflow_id,
-            workflow_type: self.workflow_type,
-            input: self.input,
-            cancellation_type: self.cancel_type as i32,
-            ..Default::default()
+            if let Some(activity_resolution::Status::Backoff(b)) = r.status.as_ref() {
+                let timer_f = self.ctx.timer(
+                    b.backoff_duration
+                        .clone()
+                        .expect("Duration is set")
+                        .try_into()
+                        .expect("duration converts ok"),
+                );
+                self.timer_fut = Some(Box::pin(timer_f));
+                self.next_attempt = b.attempt;
+                self.next_sched_time = b.original_schedule_time.clone();
+                return Poll::Pending;
+            }
+        }
+        poll_res
+    }
+}
+impl<'a> CancellableFuture<ActivityResolution> for LATimerBackoffFut<'a> {
+    fn cancel(&self, ctx: &WfContext) {
+        self.did_cancel.store(true, Ordering::Release);
+        if let Some(tf) = self.timer_fut.as_ref() {
+            tf.cancel(ctx);
         }
+        self.current_fut.cancel(ctx);
     }
 }
 
@@ -494,14 +573,12 @@ pub struct StartedChildWorkflow {
 
 impl ChildWorkflow {
     /// Start the child workflow, the returned Future is cancellable.
-    pub fn start(self, cx: &mut WfContext) -> impl CancellableFuture<PendingChildWorkflow> {
-        let child_seq = cx.next_child_workflow_sequence_number;
-        cx.next_child_workflow_sequence_number += 1;
+    pub fn start(self, cx: &WfContext) -> impl CancellableFuture<PendingChildWorkflow> {
+        let child_seq = cx.seq_nums.write().next_child_workflow_seq();
         // Immediately create the command/future for the result, otherwise if the user does
         // not await the result until *after* we receive an activation for it, there will be nothing
         // to match when unblocking.
-        let cancel_seq = cx.next_cancel_external_wf_sequence_number;
-        cx.next_cancel_external_wf_sequence_number += 1;
+        let cancel_seq = cx.seq_nums.write().next_cancel_external_wf_seq();
         let (result_cmd, unblocker) =
             CancellableWFCommandFut::new(CancellableID::ExternalWorkflow {
                 seqnum: cancel_seq,
@@ -546,7 +623,7 @@ impl StartedChildWorkflow {
     }
 
     /// Cancel the child workflow
-    pub fn cancel(&self, cx: &mut WfContext) -> impl Future<Output = CancelExternalWfResult> {
+    pub fn cancel(&self, cx: &WfContext) -> impl Future<Output = CancelExternalWfResult> {
         let target = NamespacedWorkflowExecution {
             namespace: cx.namespace().to_string(),
             workflow_id: self.common.workflow_id.clone(),
@@ -558,7 +635,7 @@ impl StartedChildWorkflow {
     /// Signal the child workflow
     pub fn signal(
         &self,
-        cx: &mut WfContext,
+        cx: &WfContext,
         signal_name: impl Into<String>,
         payload: impl Into<Payload>,
     ) -> impl CancellableFuture<SignalExternalWfResult> {