@temporalio/core-bridge 1.11.7 → 1.11.8

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

@@ -1,17 +1,17 @@
 mod options;
 
 pub use options::{
-    ActivityOptions, ChildWorkflowOptions, LocalActivityOptions, Signal, SignalData,
-    SignalWorkflowOptions,
+    ActivityOptions, ChildWorkflowOptions, LocalActivityOptions, NexusOperationOptions, Signal,
+    SignalData, SignalWorkflowOptions, TimerOptions,
 };
 
 use crate::{
-    workflow_context::options::IntoWorkflowCommand, CancelExternalWfResult, CancellableID,
-    CommandCreateRequest, CommandSubscribeChildWorkflowCompletion, IntoUpdateHandlerFunc,
-    IntoUpdateValidatorFunc, RustWfCmd, SignalExternalWfResult, TimerResult, UnblockEvent,
-    Unblockable, UpdateFunctions,
+    CancelExternalWfResult, CancellableID, CancellableIDWithReason, CommandCreateRequest,
+    CommandSubscribeChildWorkflowCompletion, IntoUpdateHandlerFunc, IntoUpdateValidatorFunc,
+    NexusStartResult, RustWfCmd, SignalExternalWfResult, SupportsCancelReason, TimerResult,
+    UnblockEvent, Unblockable, UpdateFunctions, workflow_context::options::IntoWorkflowCommand,
 };
-use futures_util::{task::Context, FutureExt, Stream, StreamExt};
+use futures_util::{FutureExt, Stream, StreamExt, future::Shared, task::Context};
 use parking_lot::{RwLock, RwLockReadGuard};
 use std::{
     collections::HashMap,
@@ -20,28 +20,34 @@ use std::{
     ops::Deref,
     pin::Pin,
     sync::{
+        Arc,
         atomic::{AtomicBool, Ordering},
         mpsc::{Receiver, Sender},
-        Arc,
     },
     task::Poll,
     time::{Duration, SystemTime},
 };
 use temporal_sdk_core_protos::{
     coresdk::{
-        activity_result::{activity_resolution, ActivityResolution},
+        activity_result::{ActivityResolution, activity_resolution},
         child_workflow::ChildWorkflowResult,
         common::NamespacedWorkflowExecution,
-        workflow_activation::resolve_child_workflow_execution_start::Status as ChildWorkflowStartStatus,
+        nexus::NexusOperationResult,
+        workflow_activation::{
+            InitializeWorkflow,
+            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,
             CancelChildWorkflowExecution, ModifyWorkflowProperties,
             RequestCancelExternalWorkflowExecution, SetPatchMarker,
             SignalExternalWorkflowExecution, StartTimer, UpsertWorkflowSearchAttributes,
+            WorkflowCommand, signal_external_workflow_execution as sig_we, workflow_command,
         },
     },
-    temporal::api::common::v1::{Memo, Payload, SearchAttributes},
+    temporal::api::{
+        common::v1::{Memo, Payload, SearchAttributes},
+        sdk::v1::UserMetadata,
+    },
 };
 use tokio::sync::{mpsc, oneshot, watch};
 use tokio_stream::wrappers::UnboundedReceiverStream;
@@ -51,10 +57,10 @@ use tokio_stream::wrappers::UnboundedReceiverStream;
 pub struct WfContext {
     namespace: String,
     task_queue: String,
-    args: Arc<Vec<Payload>>,
+    inital_information: Arc<InitializeWorkflow>,
 
     chan: Sender<RustWfCmd>,
-    am_cancelled: watch::Receiver<bool>,
+    am_cancelled: watch::Receiver<Option<String>>,
     pub(crate) shared: Arc<RwLock<WfContextSharedData>>,
 
     seq_nums: Arc<RwLock<WfCtxProtectedDat>>,
@@ -68,8 +74,8 @@ impl WfContext {
     pub(super) fn new(
         namespace: String,
         task_queue: String,
-        args: Vec<Payload>,
-        am_cancelled: watch::Receiver<bool>,
+        init_workflow_job: InitializeWorkflow,
+        am_cancelled: watch::Receiver<Option<String>>,
     ) -> (Self, Receiver<RustWfCmd>) {
         // The receiving side is non-async
         let (chan, rx) = std::sync::mpsc::channel();
@@ -77,16 +83,24 @@ impl WfContext {
             Self {
                 namespace,
                 task_queue,
-                args: Arc::new(args),
+                shared: Arc::new(RwLock::new(WfContextSharedData {
+                    random_seed: init_workflow_job.randomness_seed,
+                    search_attributes: init_workflow_job
+                        .search_attributes
+                        .clone()
+                        .unwrap_or_default(),
+                    ..Default::default()
+                })),
+                inital_information: Arc::new(init_workflow_job),
                 chan,
                 am_cancelled,
-                shared: Arc::new(RwLock::new(Default::default())),
                 seq_nums: Arc::new(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,
+                    next_nexus_op_sequence_number: 1,
                 })),
             },
             rx,
@@ -105,7 +119,7 @@ impl WfContext {
 
     /// Get the arguments provided to the workflow upon execution start
     pub fn get_args(&self) -> &[Payload] {
-        self.args.as_slice()
+        self.inital_information.arguments.as_slice()
     }
 
     /// Return the current time according to the workflow (which is not wall-clock time).
@@ -134,33 +148,53 @@ impl WfContext {
         self.shared.read().random_seed
     }
 
-    /// A future that resolves if/when the workflow is cancelled
-    pub async fn cancelled(&self) {
-        if *self.am_cancelled.borrow() {
-            return;
+    /// Return various information that the workflow was initialized with. Will eventually become
+    /// a proper non-proto workflow info struct.
+    pub fn workflow_initial_info(&self) -> &InitializeWorkflow {
+        &self.inital_information
+    }
+
+    /// A future that resolves if/when the workflow is cancelled, with the user provided cause
+    pub async fn cancelled(&self) -> String {
+        if let Some(s) = self.am_cancelled.borrow().as_ref() {
+            return s.clone();
         }
         self.am_cancelled
             .clone()
             .changed()
             .await
             .expect("Cancelled send half not dropped");
+        self.am_cancelled
+            .borrow()
+            .as_ref()
+            .cloned()
+            .unwrap_or_default()
     }
 
     /// Request to create a timer
-    pub fn timer(&self, duration: Duration) -> impl CancellableFuture<TimerResult> {
+    pub fn timer<T: Into<TimerOptions>>(&self, opts: T) -> impl CancellableFuture<TimerResult> {
+        let opts: TimerOptions = opts.into();
         let seq = self.seq_nums.write().next_timer_seq();
         let (cmd, unblocker) = CancellableWFCommandFut::new(CancellableID::Timer(seq));
         self.send(
             CommandCreateRequest {
-                cmd: StartTimer {
-                    seq,
-                    start_to_fire_timeout: Some(
-                        duration
-                            .try_into()
-                            .expect("Durations must fit into 64 bits"),
+                cmd: WorkflowCommand {
+                    variant: Some(
+                        StartTimer {
+                            seq,
+                            start_to_fire_timeout: Some(
+                                opts.duration
+                                    .try_into()
+                                    .expect("Durations must fit into 64 bits"),
+                            ),
+                        }
+                        .into(),
                     ),
-                }
-                .into(),
+                    user_metadata: Some(UserMetadata {
+                        summary: opts.summary.map(|x| x.as_bytes().into()),
+                        details: None,
+                    }),
+                },
                 unblocker,
             }
             .into(),
@@ -180,7 +214,7 @@ impl WfContext {
         let (cmd, unblocker) = CancellableWFCommandFut::new(CancellableID::Activity(seq));
         self.send(
             CommandCreateRequest {
-                cmd: opts.into_command(seq).into(),
+                cmd: opts.into_command(seq),
                 unblocker,
             }
             .into(),
@@ -205,7 +239,7 @@ impl WfContext {
         let (cmd, unblocker) = CancellableWFCommandFut::new(CancellableID::LocalActivity(seq));
         self.send(
             CommandCreateRequest {
-                cmd: opts.into_command(seq).into(),
+                cmd: opts.into_command(seq),
                 unblocker,
             }
             .into(),
@@ -308,17 +342,23 @@ impl WfContext {
     pub fn cancel_external(
         &self,
         target: NamespacedWorkflowExecution,
+        reason: String,
     ) -> impl Future<Output = CancelExternalWfResult> {
-        let target = cancel_we::Target::WorkflowExecution(target);
         let seq = self.seq_nums.write().next_cancel_external_wf_seq();
         let (cmd, unblocker) = WFCommandFut::new();
         self.send(
             CommandCreateRequest {
-                cmd: RequestCancelExternalWorkflowExecution {
-                    seq,
-                    target: Some(target),
-                }
-                .into(),
+                cmd: WorkflowCommand {
+                    variant: Some(
+                        RequestCancelExternalWorkflowExecution {
+                            seq,
+                            workflow_execution: Some(target),
+                            reason,
+                        }
+                        .into(),
+                    ),
+                    user_metadata: None,
+                },
                 unblocker,
             }
             .into(),
@@ -344,6 +384,31 @@ impl WfContext {
         ))
     }
 
+    /// Start a nexus operation
+    pub fn start_nexus_operation(
+        &self,
+        opts: NexusOperationOptions,
+    ) -> impl CancellableFuture<NexusStartResult> {
+        let seq = self.seq_nums.write().next_nexus_op_seq();
+        let (result_future, unblocker) = WFCommandFut::new();
+        self.send(RustWfCmd::SubscribeNexusOperationCompletion { seq, unblocker });
+        let (cmd, unblocker) = CancellableWFCommandFut::new_with_dat(
+            CancellableID::NexusOp(seq),
+            NexusUnblockData {
+                result_future: result_future.shared(),
+                schedule_seq: seq,
+            },
+        );
+        self.send(
+            CommandCreateRequest {
+                cmd: opts.into_command(seq),
+                unblocker,
+            }
+            .into(),
+        );
+        cmd
+    }
+
     /// Buffer a command to be sent in the activation reply
     pub(crate) fn send(&self, c: RustWfCmd) {
         self.chan.send(c).expect("command channel intact");
@@ -359,14 +424,19 @@ impl WfContext {
             CancellableWFCommandFut::new(CancellableID::SignalExternalWorkflow(seq));
         self.send(
             CommandCreateRequest {
-                cmd: SignalExternalWorkflowExecution {
-                    seq,
-                    signal_name: signal.signal_name,
-                    args: signal.data.input,
-                    target: Some(target),
-                    headers: signal.data.headers,
-                }
-                .into(),
+                cmd: WorkflowCommand {
+                    variant: Some(
+                        SignalExternalWorkflowExecution {
+                            seq,
+                            signal_name: signal.signal_name,
+                            args: signal.data.input,
+                            target: Some(target),
+                            headers: signal.data.headers,
+                        }
+                        .into(),
+                    ),
+                    user_metadata: None,
+                },
                 unblocker,
             }
             .into(),
@@ -386,6 +456,7 @@ struct WfCtxProtectedDat {
     next_child_workflow_sequence_number: u32,
     next_cancel_external_wf_sequence_number: u32,
     next_signal_external_wf_sequence_number: u32,
+    next_nexus_op_sequence_number: u32,
 }
 
 impl WfCtxProtectedDat {
@@ -414,6 +485,11 @@ impl WfCtxProtectedDat {
         self.next_signal_external_wf_sequence_number += 1;
         seq
     }
+    fn next_nexus_op_seq(&mut self) -> u32 {
+        let seq = self.next_nexus_op_sequence_number;
+        self.next_nexus_op_sequence_number += 1;
+        seq
+    }
 }
 
 #[derive(Clone, Debug, Default)]
@@ -466,6 +542,12 @@ pub trait CancellableFuture<T>: Future<Output = T> {
     fn cancel(&self, cx: &WfContext);
 }
 
+/// A Future that can be cancelled with a reason
+pub trait CancellableFutureWithReason<T>: CancellableFuture<T> {
+    /// Cancel this Future with a reason
+    fn cancel_with_reason(&self, cx: &WfContext, reason: String);
+}
+
 struct WFCommandFut<T, D> {
     _unused: PhantomData<T>,
     result_rx: oneshot::Receiver<UnblockEvent>,
@@ -511,20 +593,17 @@ where
     }
 }
 
-struct CancellableWFCommandFut<T, D> {
+struct CancellableWFCommandFut<T, D, ID = CancellableID> {
     cmd_fut: WFCommandFut<T, D>,
-    cancellable_id: CancellableID,
+    cancellable_id: ID,
 }
-impl<T> CancellableWFCommandFut<T, ()> {
-    fn new(cancellable_id: CancellableID) -> (Self, oneshot::Sender<UnblockEvent>) {
+impl<T, ID> CancellableWFCommandFut<T, (), ID> {
+    fn new(cancellable_id: ID) -> (Self, oneshot::Sender<UnblockEvent>) {
         Self::new_with_dat(cancellable_id, ())
     }
 }
-impl<T, D> CancellableWFCommandFut<T, D> {
-    fn new_with_dat(
-        cancellable_id: CancellableID,
-        other_dat: D,
-    ) -> (Self, oneshot::Sender<UnblockEvent>) {
+impl<T, D, ID> CancellableWFCommandFut<T, D, ID> {
+    fn new_with_dat(cancellable_id: ID, other_dat: D) -> (Self, oneshot::Sender<UnblockEvent>) {
         let (cmd_fut, sender) = WFCommandFut::new_with_dat(other_dat);
         (
             Self {
@@ -535,8 +614,8 @@ impl<T, D> CancellableWFCommandFut<T, D> {
         )
     }
 }
-impl<T, D> Unpin for CancellableWFCommandFut<T, D> where T: Unblockable<OtherDat = D> {}
-impl<T, D> Future for CancellableWFCommandFut<T, D>
+impl<T, D, ID> Unpin for CancellableWFCommandFut<T, D, ID> where T: Unblockable<OtherDat = D> {}
+impl<T, D, ID> Future for CancellableWFCommandFut<T, D, ID>
 where
     T: Unblockable<OtherDat = D>,
 {
@@ -547,12 +626,22 @@ where
     }
 }
 
-impl<T, D> CancellableFuture<T> for CancellableWFCommandFut<T, D>
+impl<T, D, ID> CancellableFuture<T> for CancellableWFCommandFut<T, D, ID>
 where
     T: Unblockable<OtherDat = D>,
+    ID: Clone + Into<CancellableID>,
 {
     fn cancel(&self, cx: &WfContext) {
-        cx.cancel(self.cancellable_id.clone());
+        cx.cancel(self.cancellable_id.clone().into());
+    }
+}
+impl<T, D> CancellableFutureWithReason<T> for CancellableWFCommandFut<T, D, CancellableIDWithReason>
+where
+    T: Unblockable<OtherDat = D>,
+{
+    fn cancel_with_reason(&self, cx: &WfContext, reason: String) {
+        let new_id = self.cancellable_id.clone().with_reason(reason);
+        cx.cancel(new_id);
     }
 }
 
@@ -578,8 +667,8 @@ impl<'a> LATimerBackoffFut<'a> {
         }
     }
 }
-impl<'a> Unpin for LATimerBackoffFut<'a> {}
-impl<'a> Future for LATimerBackoffFut<'a> {
+impl Unpin for LATimerBackoffFut<'_> {}
+impl Future for LATimerBackoffFut<'_> {
     type Output = ActivityResolution;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
@@ -619,7 +708,7 @@ impl<'a> Future for LATimerBackoffFut<'a> {
                     });
                 }
 
-                let timer_f = self.ctx.timer(
+                let timer_f = self.ctx.timer::<Duration>(
                     b.backoff_duration
                         .expect("Duration is set")
                         .try_into()
@@ -634,7 +723,7 @@ impl<'a> Future for LATimerBackoffFut<'a> {
         poll_res
     }
 }
-impl<'a> CancellableFuture<ActivityResolution> for LATimerBackoffFut<'a> {
+impl CancellableFuture<ActivityResolution> for LATimerBackoffFut<'_> {
     fn cancel(&self, ctx: &WfContext) {
         self.did_cancel.store(true, Ordering::Release);
         if let Some(tf) = self.timer_fut.as_ref() {
@@ -652,7 +741,7 @@ pub struct ChildWorkflow {
 
 pub(crate) struct ChildWfCommon {
     workflow_id: String,
-    result_future: CancellableWFCommandFut<ChildWorkflowResult, ()>,
+    result_future: CancellableWFCommandFut<ChildWorkflowResult, (), CancellableIDWithReason>,
 }
 
 /// Child workflow in pending state
@@ -685,20 +774,19 @@ pub struct StartedChildWorkflow {
 
 impl ChildWorkflow {
     /// Start the child workflow, the returned Future is cancellable.
-    pub fn start(self, cx: &WfContext) -> impl CancellableFuture<PendingChildWorkflow> {
+    pub fn start(self, cx: &WfContext) -> impl CancellableFutureWithReason<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.seq_nums.write().next_cancel_external_wf_seq();
         let (result_cmd, unblocker) =
-            CancellableWFCommandFut::new(CancellableID::ExternalWorkflow {
+            CancellableWFCommandFut::new(CancellableIDWithReason::ExternalWorkflow {
                 seqnum: cancel_seq,
                 execution: NamespacedWorkflowExecution {
                     workflow_id: self.opts.workflow_id.clone(),
                     ..Default::default()
                 },
-                only_child: true,
             });
         cx.send(
             CommandSubscribeChildWorkflowCompletion {
@@ -713,11 +801,13 @@ impl ChildWorkflow {
             result_future: result_cmd,
         };
 
-        let (cmd, unblocker) =
-            CancellableWFCommandFut::new_with_dat(CancellableID::ChildWorkflow(child_seq), common);
+        let (cmd, unblocker) = CancellableWFCommandFut::new_with_dat(
+            CancellableIDWithReason::ChildWorkflow { seqnum: child_seq },
+            common,
+        );
         cx.send(
             CommandCreateRequest {
-                cmd: self.opts.into_command(child_seq).into(),
+                cmd: self.opts.into_command(child_seq),
                 unblocker,
             }
             .into(),
@@ -730,27 +820,51 @@ impl ChildWorkflow {
 impl StartedChildWorkflow {
     /// Consumes self and returns a future that will wait until completion of this child workflow
     /// execution
-    pub fn result(self) -> impl CancellableFuture<ChildWorkflowResult> {
+    pub fn result(self) -> impl CancellableFutureWithReason<ChildWorkflowResult> {
         self.common.result_future
     }
 
     /// Cancel the child workflow
-    pub fn cancel(&self, cx: &WfContext) {
+    pub fn cancel(&self, cx: &WfContext, reason: String) {
         cx.send(RustWfCmd::NewNonblockingCmd(
             CancelChildWorkflowExecution {
                 child_workflow_seq: self.common.result_future.cancellable_id.seq_num(),
+                reason,
             }
             .into(),
         ));
     }
 
     /// Signal the child workflow
-    pub fn signal(
+    pub fn signal<'a, S: Into<Signal>>(
         &self,
-        cx: &WfContext,
-        data: impl Into<Signal>,
-    ) -> impl CancellableFuture<SignalExternalWfResult> {
+        cx: &'a WfContext,
+        data: S,
+    ) -> impl CancellableFuture<SignalExternalWfResult> + use<'a, S> {
         let target = sig_we::Target::ChildWorkflowId(self.common.workflow_id.clone());
         cx.send_signal_wf(target, data.into())
     }
 }
+
+#[derive(derive_more::Debug)]
+#[debug("StartedNexusOperation{{ operation_id: {operation_id:?} }}")]
+pub struct StartedNexusOperation {
+    /// The operation id, if the operation started asynchronously
+    pub operation_id: Option<String>,
+    pub(crate) unblock_dat: NexusUnblockData,
+}
+
+pub(crate) struct NexusUnblockData {
+    result_future: Shared<WFCommandFut<NexusOperationResult, ()>>,
+    schedule_seq: u32,
+}
+
+impl StartedNexusOperation {
+    pub async fn result(&self) -> NexusOperationResult {
+        self.unblock_dat.result_future.clone().await
+    }
+
+    pub fn cancel(&self, cx: &WfContext) {
+        cx.cancel(CancellableID::NexusOp(self.unblock_dat.schedule_seq));
+    }
+}