@temporalio/core-bridge 0.19.2 → 0.20.2

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

@@ -1,6 +1,9 @@
 mod options;
 
-pub use options::{ActivityOptions, ChildWorkflowOptions, LocalActivityOptions};
+pub use options::{
+    ActivityOptions, ChildWorkflowOptions, LocalActivityOptions, Signal, SignalData,
+    SignalWorkflowOptions,
+};
 
 use crate::{
     workflow_context::options::IntoWorkflowCommand, CancelExternalWfResult, CancellableID,
@@ -31,7 +34,7 @@ use temporal_sdk_core_protos::coresdk::{
         request_cancel_external_workflow_execution as cancel_we,
         signal_external_workflow_execution as sig_we, workflow_command,
         RequestCancelExternalWorkflowExecution, SetPatchMarker, SignalExternalWorkflowExecution,
-        StartTimer,
+        StartTimer, UpsertWorkflowSearchAttributes,
     },
 };
 use tokio::sync::{mpsc, oneshot, watch};
@@ -56,6 +59,7 @@ struct WfCtxProtectedDat {
     next_child_workflow_sequence_number: u32,
     next_cancel_external_wf_sequence_number: u32,
     next_signal_external_wf_sequence_number: u32,
+    next_upsert_search_attrs_sequence_number: u32,
 }
 
 impl WfCtxProtectedDat {
@@ -84,6 +88,11 @@ impl WfCtxProtectedDat {
         self.next_signal_external_wf_sequence_number += 1;
         seq
     }
+    fn next_upsert_search_attrs_wf_seq(&mut self) -> u32 {
+        let seq = self.next_upsert_search_attrs_sequence_number;
+        self.next_upsert_search_attrs_sequence_number += 1;
+        seq
+    }
 }
 
 #[derive(Clone, Debug, Default)]
@@ -121,6 +130,7 @@ impl WfContext {
                     next_child_workflow_sequence_number: 1,
                     next_cancel_external_wf_sequence_number: 1,
                     next_signal_external_wf_sequence_number: 1,
+                    next_upsert_search_attrs_sequence_number: 1,
                 }),
             },
             rx,
@@ -265,24 +275,34 @@ impl WfContext {
     /// or was cancelled.
     pub fn signal_workflow(
         &self,
-        workflow_id: impl Into<String>,
-        run_id: impl Into<String>,
-        signal_name: impl Into<String>,
-        payload: impl Into<Payload>,
+        opts: impl Into<SignalWorkflowOptions>,
     ) -> impl CancellableFuture<SignalExternalWfResult> {
+        let options: SignalWorkflowOptions = opts.into();
         let target = sig_we::Target::WorkflowExecution(NamespacedWorkflowExecution {
             namespace: self.namespace.clone(),
-            workflow_id: workflow_id.into(),
-            run_id: run_id.into(),
+            workflow_id: options.workflow_id,
+            run_id: options.run_id.unwrap_or_default(),
         });
-        self.send_signal_wf(signal_name, payload, target)
+        self.send_signal_wf(target, options.signal)
+    }
+
+    /// Add or create a set of search attributes
+    pub fn upsert_search_attributes(&self, attr_iter: impl IntoIterator<Item = (String, Payload)>) {
+        self.send(RustWfCmd::NewNonblockingCmd(
+            workflow_command::Variant::UpsertWorkflowSearchAttributesCommandAttributes(
+                UpsertWorkflowSearchAttributes {
+                    seq: self.seq_nums.write().next_upsert_search_attrs_wf_seq(),
+                    search_attributes: HashMap::from_iter(attr_iter.into_iter()),
+                },
+            ),
+        ))
     }
 
     /// Return a stream that produces values when the named signal is sent to this workflow
     pub fn make_signal_channel(
         &self,
         signal_name: impl Into<String>,
-    ) -> impl Stream<Item = Vec<Payload>> {
+    ) -> impl Stream<Item = SignalData> {
         let (tx, rx) = mpsc::unbounded_channel();
         self.send(RustWfCmd::SubscribeSignal(signal_name.into(), tx));
         UnboundedReceiverStream::new(rx)
@@ -318,9 +338,8 @@ impl WfContext {
 
     fn send_signal_wf(
         &self,
-        signal_name: impl Into<String>,
-        payload: impl Into<Payload>,
         target: sig_we::Target,
+        signal: Signal,
     ) -> impl CancellableFuture<SignalExternalWfResult> {
         let seq = self.seq_nums.write().next_signal_external_wf_seq();
         let (cmd, unblocker) =
@@ -329,9 +348,10 @@ impl WfContext {
             CommandCreateRequest {
                 cmd: SignalExternalWorkflowExecution {
                     seq,
-                    signal_name: signal_name.into(),
-                    args: vec![payload.into()],
+                    signal_name: signal.signal_name,
+                    args: signal.data.input,
                     target: Some(target),
+                    headers: signal.data.headers,
                 }
                 .into(),
                 unblocker,
@@ -636,10 +656,9 @@ impl StartedChildWorkflow {
     pub fn signal(
         &self,
         cx: &WfContext,
-        signal_name: impl Into<String>,
-        payload: impl Into<Payload>,
+        data: impl Into<Signal>,
     ) -> impl CancellableFuture<SignalExternalWfResult> {
         let target = sig_we::Target::ChildWorkflowId(self.common.workflow_id.clone());
-        cx.send_signal_wf(signal_name, payload, target)
+        cx.send_signal_wf(target, data.into())
     }
 }

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

@@ -1,6 +1,7 @@
 use crate::{
     conversions::anyhow_to_fail, workflow_context::WfContextSharedData, CancellableID, RustWfCmd,
-    TimerResult, UnblockEvent, WfContext, WfExitValue, WorkflowFunction, WorkflowResult,
+    SignalData, TimerResult, UnblockEvent, WfContext, WfExitValue, WorkflowFunction,
+    WorkflowResult,
 };
 use anyhow::{anyhow, bail, Context as AnyhowContext, Error};
 use crossbeam::channel::Receiver;
@@ -55,12 +56,10 @@ impl WorkflowFunction {
         UnboundedSender<WorkflowActivation>,
     ) {
         let (cancel_tx, cancel_rx) = watch::channel(false);
-        let (wf_context, cmd_receiver) =
-            WfContext::new(namespace, task_queue.clone(), args, cancel_rx);
+        let (wf_context, cmd_receiver) = WfContext::new(namespace, task_queue, args, cancel_rx);
         let (tx, incoming_activations) = unbounded_channel();
         (
             WorkflowFuture {
-                task_queue,
                 ctx_shared: wf_context.get_shared_data(),
                 // We need to mark the workflow future as unconstrained, otherwise Tokio will impose
                 // an artificial limit on how many commands we can unblock in one poll round.
@@ -88,13 +87,11 @@ struct WFCommandFutInfo {
 //   production-ready SDK design, or if desired to allow dynamic signal registration, prevent this
 //   from growing unbounded if being sent lots of unhandled signals.
 enum SigChanOrBuffer {
-    Chan(UnboundedSender<Vec<Payload>>),
-    Buffer(Vec<Vec<Payload>>),
+    Chan(UnboundedSender<SignalData>),
+    Buffer(Vec<SignalData>),
 }
 
 pub struct WorkflowFuture {
-    /// What task queue this workflow belongs to
-    task_queue: String,
     /// Future produced by calling the workflow function
     inner: BoxFuture<'static, WorkflowResult<()>>,
     /// Commands produced inside user's wf code
@@ -138,7 +135,6 @@ impl WorkflowFuture {
         warn!("Workflow task failed for {}: {}", run_id, fail);
         self.outgoing_completions
             .send(WorkflowActivationCompletion::fail(
-                &self.task_queue,
                 run_id,
                 anyhow_to_fail(fail),
             ))
@@ -148,7 +144,6 @@ impl WorkflowFuture {
     fn send_completion(&self, run_id: String, activation_cmds: Vec<workflow_command::Variant>) {
         self.outgoing_completions
             .send(WorkflowActivationCompletion::from_cmds(
-                &self.task_queue,
                 run_id,
                 activation_cmds,
             ))
@@ -199,17 +194,21 @@ impl WorkflowFuture {
                         .send(true)
                         .expect("Cancel rx not dropped");
                 }
-                Variant::SignalWorkflow(sig) => match self.sig_chans.entry(sig.signal_name) {
-                    Entry::Occupied(mut o) => match o.get_mut() {
-                        SigChanOrBuffer::Chan(chan) => {
-                            let _ = chan.send(sig.input);
+                Variant::SignalWorkflow(sig) => {
+                    let mut dat = SignalData::new(sig.input);
+                    dat.headers = sig.headers;
+                    match self.sig_chans.entry(sig.signal_name) {
+                        Entry::Occupied(mut o) => match o.get_mut() {
+                            SigChanOrBuffer::Chan(chan) => {
+                                let _ = chan.send(dat);
+                            }
+                            SigChanOrBuffer::Buffer(ref mut buf) => buf.push(dat),
+                        },
+                        Entry::Vacant(v) => {
+                            v.insert(SigChanOrBuffer::Buffer(vec![dat]));
                         }
-                        SigChanOrBuffer::Buffer(ref mut buf) => buf.push(sig.input),
-                    },
-                    Entry::Vacant(v) => {
-                        v.insert(SigChanOrBuffer::Buffer(vec![sig.input]));
                     }
-                },
+                }
                 Variant::NotifyHasPatch(NotifyHasPatch { patch_id }) => {
                     self.ctx_shared.write().changes.insert(patch_id, true);
                 }
@@ -268,11 +267,7 @@ impl Future for WorkflowFuture {
             if is_only_eviction {
                 // No need to do anything with the workflow code in this case
                 self.outgoing_completions
-                    .send(WorkflowActivationCompletion::from_cmds(
-                        &self.task_queue,
-                        run_id,
-                        vec![],
-                    ))
+                    .send(WorkflowActivationCompletion::from_cmds(run_id, vec![]))
                     .expect("Completion channel intact");
                 return Ok(WfExitValue::Evicted).into();
             }
@@ -291,7 +286,6 @@ impl Future for WorkflowFuture {
                     warn!("{}", errmsg);
                     self.outgoing_completions
                         .send(WorkflowActivationCompletion::fail(
-                            &self.task_queue,
                             run_id,
                             Failure {
                                 message: errmsg,

package/sdk-core/sdk-core-protos/Cargo.toml

@@ -27,4 +27,4 @@ tonic = "0.6"
 uuid = { version = "0.8.2", features = ["v4"], optional = true }
 
 [build-dependencies]
-tonic-build = "0.5"
+tonic-build = "0.6"

package/sdk-core/sdk-core-protos/build.rs

@@ -1,4 +1,5 @@
 fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("cargo:rerun-if-changed=../protos");
     tonic_build::configure()
         // We don't actually want to build the grpc definitions - we don't need them (for now).
         // Just build the message structs.

package/sdk-core/sdk-core-protos/src/history_info.rs

@@ -3,7 +3,7 @@ use crate::temporal::api::{
     enums::v1::{EventType, TaskQueueKind},
     history::v1::{history_event, History, HistoryEvent},
     taskqueue::v1::TaskQueue,
-    workflowservice::v1::PollWorkflowTaskQueueResponse,
+    workflowservice::v1::{GetWorkflowExecutionHistoryResponse, PollWorkflowTaskQueueResponse},
 };
 use anyhow::{anyhow, bail};
 use rand::{thread_rng, Rng};
@@ -42,9 +42,9 @@ impl HistoryInfo {
                 attrs
                     .workflow_type
                     .as_ref()
-                    .ok_or(anyhow!(
-                        "No workflow type defined in execution started attributes"
-                    ))?
+                    .ok_or_else(|| {
+                        anyhow!("No workflow type defined in execution started attributes")
+                    })?
                     .name
                     .clone()
             }
@@ -117,6 +117,10 @@ impl HistoryInfo {
     /// Remove events from the beginning of this history such that it looks like what would've been
     /// delivered on a sticky queue where the previously started task was the one before the last
     /// task in this history.
+    ///
+    /// This is not *fully* accurate in that it will include commands that were part of the last
+    /// WFT completion, which the server would typically not include, but it's good enough for
+    /// testing.
     pub fn make_incremental(&mut self) {
         let last_complete_ix = self
             .events
@@ -182,6 +186,15 @@ impl From<HistoryInfo> for History {
     }
 }
 
+impl From<HistoryInfo> for GetWorkflowExecutionHistoryResponse {
+    fn from(i: HistoryInfo) -> Self {
+        Self {
+            history: Some(i.into()),
+            ..Default::default()
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::{temporal::api::enums::v1::EventType, TestHistoryBuilder};