@temporalio/core-bridge 1.8.5 → 1.9.0-rc.0

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

@@ -55,13 +55,11 @@ pub use activity_context::ActContext;
 pub use temporal_client::Namespace;
 pub use workflow_context::{
     ActivityOptions, CancellableFuture, ChildWorkflow, ChildWorkflowOptions, LocalActivityOptions,
-    Signal, SignalData, SignalWorkflowOptions, WfContext,
+    PendingChildWorkflow, Signal, SignalData, SignalWorkflowOptions, StartedChildWorkflow,
+    WfContext,
 };
 
-use crate::{
-    interceptors::WorkerInterceptor,
-    workflow_context::{ChildWfCommon, PendingChildWorkflow},
-};
+use crate::{interceptors::WorkerInterceptor, workflow_context::ChildWfCommon};
 use anyhow::{anyhow, bail, Context};
 use app_data::AppData;
 use futures::{future::BoxFuture, FutureExt, StreamExt, TryFutureExt, TryStreamExt};
@@ -342,8 +340,8 @@ impl Worker {
     }
 
     /// Set a [WorkerInterceptor]
-    pub fn set_worker_interceptor(&mut self, interceptor: Box<dyn WorkerInterceptor>) {
-        self.common.worker_interceptor = Some(interceptor);
+    pub fn set_worker_interceptor(&mut self, interceptor: impl WorkerInterceptor + 'static) {
+        self.common.worker_interceptor = Some(Box::new(interceptor));
     }
 
     /// Turns this rust worker into a new worker with all the same workflows and activities
@@ -685,6 +683,7 @@ enum RustWfCmd {
     NewNonblockingCmd(workflow_command::Variant),
     SubscribeChildWorkflowCompletion(CommandSubscribeChildWorkflowCompletion),
     SubscribeSignal(String, UnboundedSender<SignalData>),
+    RegisterUpdate(String, UpdateFunctions),
 }
 
 struct CommandCreateRequest {
@@ -861,6 +860,85 @@ where
     }
 }
 
+/// Extra information attached to workflow updates
+#[derive(Clone)]
+pub struct UpdateInfo {
+    /// The update's id, unique within the workflow
+    pub update_id: String,
+    /// Headers attached to the update
+    pub headers: HashMap<String, Payload>,
+}
+
+/// Context for a workflow update
+pub struct UpdateContext {
+    /// The workflow context, can be used to do normal workflow things inside the update handler
+    pub wf_ctx: WfContext,
+    /// Additional update info
+    pub info: UpdateInfo,
+}
+
+struct UpdateFunctions {
+    validator: BoxUpdateValidatorFn,
+    handler: BoxUpdateHandlerFn,
+}
+
+impl UpdateFunctions {
+    pub(crate) fn new<Arg, Res>(
+        v: impl IntoUpdateValidatorFunc<Arg> + Sized,
+        h: impl IntoUpdateHandlerFunc<Arg, Res> + Sized,
+    ) -> Self {
+        Self {
+            validator: v.into_update_validator_fn(),
+            handler: h.into_update_handler_fn(),
+        }
+    }
+}
+
+type BoxUpdateValidatorFn = Box<dyn Fn(&UpdateInfo, &Payload) -> Result<(), anyhow::Error> + Send>;
+/// Closures / functions which can be turned into update validation functions implement this trait
+pub trait IntoUpdateValidatorFunc<Arg> {
+    /// Consume the closure/fn pointer and turn it into an update validator
+    fn into_update_validator_fn(self) -> BoxUpdateValidatorFn;
+}
+impl<A, F> IntoUpdateValidatorFunc<A> for F
+where
+    A: FromJsonPayloadExt + Send,
+    F: (for<'a> Fn(&'a UpdateInfo, A) -> Result<(), anyhow::Error>) + Send + 'static,
+{
+    fn into_update_validator_fn(self) -> BoxUpdateValidatorFn {
+        let wrapper = move |ctx: &UpdateInfo, input: &Payload| match A::from_json_payload(input) {
+            Ok(deser) => (self)(ctx, deser),
+            Err(e) => Err(e.into()),
+        };
+        Box::new(wrapper)
+    }
+}
+type BoxUpdateHandlerFn = Box<
+    dyn FnMut(UpdateContext, &Payload) -> BoxFuture<'static, Result<Payload, anyhow::Error>> + Send,
+>;
+/// Closures / functions which can be turned into update handler functions implement this trait
+pub trait IntoUpdateHandlerFunc<Arg, Res> {
+    /// Consume the closure/fn pointer and turn it into an update handler
+    fn into_update_handler_fn(self) -> BoxUpdateHandlerFn;
+}
+impl<A, F, Rf, R> IntoUpdateHandlerFunc<A, R> for F
+where
+    A: FromJsonPayloadExt + Send,
+    F: (FnMut(UpdateContext, A) -> Rf) + Send + 'static,
+    Rf: Future<Output = Result<R, anyhow::Error>> + Send + 'static,
+    R: AsJsonPayloadExt,
+{
+    fn into_update_handler_fn(mut self) -> BoxUpdateHandlerFn {
+        let wrapper = move |ctx: UpdateContext, input: &Payload| match A::from_json_payload(input) {
+            Ok(deser) => (self)(ctx, deser)
+                .map(|r| r.and_then(|r| r.as_json_payload()))
+                .boxed(),
+            Err(e) => async move { Err(e.into()) }.boxed(),
+        };
+        Box::new(wrapper)
+    }
+}
+
 /// Attempts to turn caught panics into something printable
 fn panic_formatter(panic: Box<dyn Any>) -> Box<dyn Display> {
     _panic_formatter::<&str>(panic)

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

@@ -107,6 +107,7 @@ pub struct LocalActivityOptions {
     /// Type of activity to schedule
     pub activity_type: String,
     /// Input to the activity
+    // TODO: Make optional
     pub input: Payload,
     /// Retry policy
     pub retry_policy: RetryPolicy,
@@ -177,6 +178,8 @@ pub struct ChildWorkflowOptions {
     pub workflow_id: String,
     /// Type of workflow to schedule
     pub workflow_type: String,
+    /// Task queue to schedule the workflow in
+    pub task_queue: String,
     /// Input to send the child Workflow
     pub input: Vec<Payload>,
     /// Cancellation strategy for the child workflow
@@ -194,6 +197,7 @@ impl IntoWorkflowCommand for ChildWorkflowOptions {
             seq,
             workflow_id: self.workflow_id,
             workflow_type: self.workflow_type,
+            task_queue: self.task_queue,
             input: self.input,
             cancellation_type: self.cancel_type as i32,
             workflow_id_reuse_policy: self.options.id_reuse_policy as i32,

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

@@ -7,8 +7,9 @@ pub use options::{
 
 use crate::{
     workflow_context::options::IntoWorkflowCommand, CancelExternalWfResult, CancellableID,
-    CommandCreateRequest, CommandSubscribeChildWorkflowCompletion, RustWfCmd,
-    SignalExternalWfResult, TimerResult, UnblockEvent, Unblockable,
+    CommandCreateRequest, CommandSubscribeChildWorkflowCompletion, IntoUpdateHandlerFunc,
+    IntoUpdateValidatorFunc, RustWfCmd, SignalExternalWfResult, TimerResult, UnblockEvent,
+    Unblockable, UpdateFunctions,
 };
 use crossbeam::channel::{Receiver, Sender};
 use futures::{task::Context, FutureExt, Stream, StreamExt};
@@ -45,16 +46,17 @@ use tokio::sync::{mpsc, oneshot, watch};
 use tokio_stream::wrappers::UnboundedReceiverStream;
 
 /// Used within workflows to issue commands, get info, etc.
+#[derive(Clone)]
 pub struct WfContext {
     namespace: String,
     task_queue: String,
-    args: Vec<Payload>,
+    args: Arc<Vec<Payload>>,
 
     chan: Sender<RustWfCmd>,
     am_cancelled: watch::Receiver<bool>,
-    shared: Arc<RwLock<WfContextSharedData>>,
+    pub(crate) shared: Arc<RwLock<WfContextSharedData>>,
 
-    seq_nums: RwLock<WfCtxProtectedDat>,
+    seq_nums: Arc<RwLock<WfCtxProtectedDat>>,
 }
 
 struct WfCtxProtectedDat {
@@ -94,12 +96,13 @@ impl WfCtxProtectedDat {
 }
 
 #[derive(Clone, Debug, Default)]
-pub struct WfContextSharedData {
+pub(crate) struct WfContextSharedData {
     /// Maps change ids -> resolved status
     pub changes: HashMap<String, bool>,
     pub is_replaying: bool,
     pub wf_time: Option<SystemTime>,
     pub history_length: u32,
+    pub current_build_id: Option<String>,
 }
 
 // TODO: Dataconverter type interface to replace Payloads here. Possibly just use serde
@@ -119,17 +122,17 @@ impl WfContext {
             Self {
                 namespace,
                 task_queue,
-                args,
+                args: Arc::new(args),
                 chan,
                 am_cancelled,
                 shared: Arc::new(RwLock::new(Default::default())),
-                seq_nums: RwLock::new(WfCtxProtectedDat {
+                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,
-                }),
+                })),
             },
             rx,
         )
@@ -155,16 +158,19 @@ impl WfContext {
         self.shared.read().history_length
     }
 
-    pub(crate) fn get_shared_data(&self) -> Arc<RwLock<WfContextSharedData>> {
-        self.shared.clone()
+    /// Return the Build ID as it was when this point in the workflow was first reached. If this
+    /// code is being executed for the first time, return this Worker's Build ID if it has one.
+    pub fn current_build_id(&self) -> Option<String> {
+        self.shared.read().current_build_id.clone()
     }
 
     /// A future that resolves if/when the workflow is cancelled
-    pub async fn cancelled(&mut self) {
+    pub async fn cancelled(&self) {
         if *self.am_cancelled.borrow() {
             return;
         }
         self.am_cancelled
+            .clone()
             .changed()
             .await
             .expect("Cancelled send half not dropped");
@@ -298,7 +304,7 @@ impl WfContext {
         self.send(RustWfCmd::NewNonblockingCmd(
             workflow_command::Variant::UpsertWorkflowSearchAttributes(
                 UpsertWorkflowSearchAttributes {
-                    search_attributes: HashMap::from_iter(attr_iter.into_iter()),
+                    search_attributes: HashMap::from_iter(attr_iter),
                 },
             ),
         ))
@@ -309,7 +315,7 @@ impl WfContext {
         self.send(RustWfCmd::NewNonblockingCmd(
             workflow_command::Variant::ModifyWorkflowProperties(ModifyWorkflowProperties {
                 upserted_memo: Some(Memo {
-                    fields: HashMap::from_iter(attr_iter.into_iter()),
+                    fields: HashMap::from_iter(attr_iter),
                 }),
             }),
         ))
@@ -350,6 +356,24 @@ impl WfContext {
         cmd
     }
 
+    /// Register an update handler by providing the handler name, a validator function, and an
+    /// update handler. The validator must not mutate workflow state and is synchronous. The handler
+    /// may mutate workflow state (though, that's annoying right now in the prototype) and is async.
+    ///
+    /// Note that if you want a validator that always passes, you will likely need to provide type
+    /// annotations to make the compiler happy, like: `|_: &_, _: T| Ok(())`
+    pub fn update_handler<Arg, Res>(
+        &self,
+        name: impl Into<String>,
+        validator: impl IntoUpdateValidatorFunc<Arg>,
+        handler: impl IntoUpdateHandlerFunc<Arg, Res>,
+    ) {
+        self.send(RustWfCmd::RegisterUpdate(
+            name.into(),
+            UpdateFunctions::new(validator, handler),
+        ))
+    }
+
     fn send_signal_wf(
         &self,
         target: sig_we::Target,
@@ -612,9 +636,11 @@ pub struct ChildWfCommon {
     result_future: CancellableWFCommandFut<ChildWorkflowResult, ()>,
 }
 
+/// Child workflow in pending state
 pub struct PendingChildWorkflow {
+    /// The status of the child workflow start
     pub status: ChildWorkflowStartStatus,
-    pub common: ChildWfCommon,
+    pub(crate) common: ChildWfCommon,
 }
 
 impl PendingChildWorkflow {
@@ -631,7 +657,9 @@ impl PendingChildWorkflow {
     }
 }
 
+/// Child workflow in started state
 pub struct StartedChildWorkflow {
+    /// Run ID of the child workflow
     pub run_id: String,
     common: ChildWfCommon,
 }