@temporalio/core-bridge 0.19.2 → 0.20.2

package/sdk-core/core/src/workflow/driven_workflow.rs

@@ -1,16 +1,18 @@
-use crate::workflow::WFCommand;
+use crate::workflow::{WFCommand, WorkflowStartedInfo};
 use std::collections::VecDeque;
 use temporal_sdk_core_protos::{
     coresdk::workflow_activation::{
-        workflow_activation_job, CancelWorkflow, SignalWorkflow, WorkflowActivationJob,
+        start_workflow_from_attribs, workflow_activation_job, CancelWorkflow, SignalWorkflow,
+        WorkflowActivationJob,
     },
     temporal::api::history::v1::WorkflowExecutionStartedEventAttributes,
+    utilities::TryIntoOrNone,
 };
 
 /// Abstracts away the concept of an actual workflow implementation, handling sending it new
 /// jobs and fetching output from it.
 pub struct DrivenWorkflow {
-    started_attrs: Option<WorkflowExecutionStartedEventAttributes>,
+    started_attrs: Option<WorkflowStartedInfo>,
     fetcher: Box<dyn WorkflowFetcher>,
     /// Outgoing activation jobs that need to be sent to the lang sdk
     outgoing_wf_activation_jobs: VecDeque<workflow_activation_job::Variant>,
@@ -31,13 +33,26 @@ where
 
 impl DrivenWorkflow {
     /// Start the workflow
-    pub fn start(&mut self, attribs: WorkflowExecutionStartedEventAttributes) {
+    pub fn start(
+        &mut self,
+        workflow_id: String,
+        randomness_seed: u64,
+        attribs: WorkflowExecutionStartedEventAttributes,
+    ) {
         debug!(run_id = %attribs.original_execution_run_id, "Driven WF start");
-        self.started_attrs = Some(attribs);
+        let started_info = WorkflowStartedInfo {
+            workflow_task_timeout: attribs.workflow_task_timeout.clone().try_into_or_none(),
+            workflow_execution_timeout: attribs
+                .workflow_execution_timeout
+                .clone()
+                .try_into_or_none(),
+        };
+        self.send_job(start_workflow_from_attribs(attribs, workflow_id, randomness_seed).into());
+        self.started_attrs = Some(started_info);
     }
 
     /// Return the attributes from the workflow execution started event if this workflow has started
-    pub fn get_started_attrs(&self) -> Option<&WorkflowExecutionStartedEventAttributes> {
+    pub fn get_started_info(&self) -> Option<&WorkflowStartedInfo> {
         self.started_attrs.as_ref()
     }
 

package/sdk-core/core/src/workflow/history_update.rs

@@ -1,6 +1,6 @@
 use crate::{
     replay::{HistoryInfo, TestHistoryBuilder},
-    ServerGatewayApis,
+    worker::client::WorkerClientBag,
 };
 use futures::{future::BoxFuture, stream, stream::BoxStream, FutureExt, Stream, StreamExt};
 use std::{
@@ -30,32 +30,84 @@ pub struct HistoryUpdate {
 }
 
 pub struct HistoryPaginator {
-    gateway: Arc<dyn ServerGatewayApis + Send + Sync>,
+    // Potentially this could actually be a ref w/ lifetime here
+    client: Arc<WorkerClientBag>,
     event_queue: VecDeque<HistoryEvent>,
     wf_id: String,
     run_id: String,
-    next_page_token: Vec<u8>,
+    next_page_token: NextPageToken,
     open_history_request:
         Option<BoxFuture<'static, Result<GetWorkflowExecutionHistoryResponse, tonic::Status>>>,
+    /// These are events that should be returned once pagination has finished. This only happens
+    /// during cache misses, where we got a partial task but need to fetch history from the start.
+    /// We use this to apply any
+    final_events: Vec<HistoryEvent>,
+}
+
+#[derive(Clone, Debug)]
+pub enum NextPageToken {
+    /// There is no page token, we need to fetch history from the beginning
+    FetchFromStart,
+    /// There is a page token
+    Next(Vec<u8>),
+    /// There is no page token, we are done fetching history
+    Done,
+}
+
+// If we're converting from a page token from the server, if it's empty, then we're done.
+impl From<Vec<u8>> for NextPageToken {
+    fn from(page_token: Vec<u8>) -> Self {
+        if page_token.is_empty() {
+            NextPageToken::Done
+        } else {
+            NextPageToken::Next(page_token)
+        }
+    }
 }
 
 impl HistoryPaginator {
-    pub fn new(
+    pub(crate) fn new(
         initial_history: History,
         wf_id: String,
         run_id: String,
-        next_page_token: Vec<u8>,
-        gateway: Arc<dyn ServerGatewayApis + Send + Sync>,
+        next_page_token: impl Into<NextPageToken>,
+        client: Arc<WorkerClientBag>,
     ) -> Self {
+        let next_page_token = next_page_token.into();
+        let (event_queue, final_events) =
+            if matches!(next_page_token, NextPageToken::FetchFromStart) {
+                (VecDeque::new(), initial_history.events)
+            } else {
+                (initial_history.events.into(), vec![])
+            };
         Self {
-            gateway,
-            event_queue: initial_history.events.into(),
+            client,
+            event_queue,
             wf_id,
             run_id,
             next_page_token,
             open_history_request: None,
+            final_events,
         }
     }
+
+    fn extend_queue_with_new_page(&mut self, resp: GetWorkflowExecutionHistoryResponse) {
+        self.next_page_token = resp.next_page_token.into();
+        self.event_queue
+            .extend(resp.history.map(|h| h.events).unwrap_or_default());
+        if matches!(&self.next_page_token, NextPageToken::Done) {
+            // If finished, we need to extend the queue with the final events, skipping any
+            // which are already present.
+            if let Some(last_event_id) = self.event_queue.back().map(|e| e.event_id) {
+                let final_events = std::mem::take(&mut self.final_events);
+                self.event_queue.extend(
+                    final_events
+                        .into_iter()
+                        .skip_while(|e2| e2.event_id <= last_event_id),
+                );
+            }
+        };
+    }
 }
 
 impl Stream for HistoryPaginator {
@@ -65,20 +117,19 @@ impl Stream for HistoryPaginator {
         if let Some(e) = self.event_queue.pop_front() {
             return Poll::Ready(Some(Ok(e)));
         }
-        if self.next_page_token.is_empty() {
-            return Poll::Ready(None);
-        }
-
         let history_req = if let Some(req) = self.open_history_request.as_mut() {
             req
         } else {
+            let npt = match std::mem::replace(&mut self.next_page_token, NextPageToken::Done) {
+                // If there's no open request and the last page token we got was empty, we're done.
+                NextPageToken::Done => return Poll::Ready(None),
+                NextPageToken::FetchFromStart => vec![],
+                NextPageToken::Next(v) => v,
+            };
             debug!(run_id=%self.run_id, "Fetching new history page");
-            // We're out of stored events and we have a page token - fetch additional history from
-            // the server. Note that server can return page tokens that point to an empty page.
-            let gw = self.gateway.clone();
+            let gw = self.client.clone();
             let wid = self.wf_id.clone();
             let rid = self.run_id.clone();
-            let npt = self.next_page_token.clone();
             let resp_fut =
                 async move { gw.get_workflow_execution_history(wid, Some(rid), npt).await };
             self.open_history_request.insert(resp_fut.boxed())
@@ -90,9 +141,7 @@ impl Stream for HistoryPaginator {
                 match resp {
                     Err(neterr) => Poll::Ready(Some(Err(neterr))),
                     Ok(resp) => {
-                        self.next_page_token = resp.next_page_token;
-                        self.event_queue
-                            .extend(resp.history.map(|h| h.events).unwrap_or_default());
+                        self.extend_queue_with_new_page(resp);
                         Poll::Ready(self.event_queue.pop_front().map(Ok))
                     }
                 }
@@ -255,8 +304,7 @@ impl TestHBExt for TestHistoryBuilder {
 #[cfg(test)]
 pub mod tests {
     use super::*;
-    use crate::test_help::canned_histories;
-    use temporal_client::mocks::mock_gateway;
+    use crate::{test_help::canned_histories, worker::client::mocks::mock_workflow_client};
 
     #[tokio::test]
     async fn consumes_standard_wft_sequence() {
@@ -312,10 +360,10 @@ pub mod tests {
         let long_hist = canned_histories::long_sequential_timers(wft_count);
         let initial_hist = long_hist.get_history_info(10).unwrap();
         let prev_started = initial_hist.previous_started_event_id();
-        let mut mock_gateway = mock_gateway();
+        let mut mock_client = mock_workflow_client();
 
         let mut npt = 2;
-        mock_gateway
+        mock_client
             .expect_get_workflow_execution_history()
             .returning(move |_, _, passed_npt| {
                 assert_eq!(passed_npt, vec![npt]);
@@ -335,7 +383,7 @@ pub mod tests {
                 "wfid".to_string(),
                 "runid".to_string(),
                 vec![2], // Start at page "2"
-                Arc::new(mock_gateway),
+                Arc::new(mock_client.into()),
             ),
             prev_started,
         );
@@ -358,4 +406,39 @@ pub mod tests {
             last_started_id += 5;
         }
     }
+
+    #[tokio::test]
+    async fn handles_cache_misses() {
+        let timer_hist = canned_histories::single_timer("t");
+        let partial_task = timer_hist.get_one_wft(2).unwrap();
+        let mut history_from_get: GetWorkflowExecutionHistoryResponse =
+            timer_hist.get_history_info(2).unwrap().into();
+        // Chop off the last event, which is WFT started, which server doesn't return in get
+        // history
+        history_from_get.history.as_mut().map(|h| h.events.pop());
+        let mut mock_client = mock_workflow_client();
+        mock_client
+            .expect_get_workflow_execution_history()
+            .returning(move |_, _, _| Ok(history_from_get.clone()));
+
+        let mut update = HistoryUpdate::new(
+            HistoryPaginator::new(
+                partial_task.into(),
+                "wfid".to_string(),
+                "runid".to_string(),
+                // A cache miss means we'll try to fetch from start
+                NextPageToken::FetchFromStart,
+                Arc::new(mock_client.into()),
+            ),
+            1,
+        );
+        // We expect if we try to take the first task sequence that the first event is the first
+        // event in the sequence.
+        let seq = update.take_next_wft_sequence(0).await.unwrap();
+        assert_eq!(seq[0].event_id, 1);
+        let seq = update.take_next_wft_sequence(3).await.unwrap();
+        // Verify anything extra (which should only ever be WFT started) was re-appended to the
+        // end of the event iteration after fetching the old history.
+        assert_eq!(seq.last().unwrap().event_id, 8);
+    }
 }

package/sdk-core/core/src/workflow/machines/activity_state_machine.rs

@@ -737,9 +737,8 @@ fn convert_payloads(
 ) -> Result<Option<Payload>, WFMachinesError> {
     result.map(TryInto::try_into).transpose().map_err(|pe| {
         WFMachinesError::Fatal(format!(
-            "Not exactly one payload in activity result ({}) for event: {}",
-            pe,
-            event_info.map(|e| e.event.clone()).unwrap_or_default()
+            "Not exactly one payload in activity result ({}) for event: {:?}",
+            pe, event_info
         ))
     })
 }

package/sdk-core/core/src/workflow/machines/child_workflow_state_machine.rs

@@ -606,9 +606,8 @@ fn convert_payloads(
 ) -> Result<Option<Payload>, WFMachinesError> {
     result.map(TryInto::try_into).transpose().map_err(|pe| {
         WFMachinesError::Fatal(format!(
-            "Not exactly one payload in child workflow result ({}) for event: {}",
-            pe,
-            event_info.map(|e| e.event.clone()).unwrap_or_default()
+            "Not exactly one payload in child workflow result ({}) for event: {:?}",
+            pe, event_info
         ))
     })
 }

package/sdk-core/core/src/workflow/machines/mod.rs

@@ -15,7 +15,6 @@ mod patch_state_machine;
 mod side_effect_state_machine;
 mod signal_external_state_machine;
 mod timer_state_machine;
-#[allow(unused)]
 mod upsert_search_attributes_state_machine;
 mod workflow_task_state_machine;
 
@@ -42,9 +41,12 @@ use std::{
     fmt::{Debug, Display},
 };
 use temporal_sdk_core_protos::temporal::api::{
-    command::v1::Command as ProtoCommand, enums::v1::CommandType, history::v1::HistoryEvent,
+    command::v1::Command as ProtoCommand,
+    enums::v1::{CommandType, EventType},
+    history::v1::HistoryEvent,
 };
 use timer_state_machine::TimerMachine;
+use upsert_search_attributes_state_machine::UpsertSearchAttributesMachine;
 use workflow_machines::MachineResponse;
 use workflow_task_state_machine::WorkflowTaskMachine;
 
@@ -65,6 +67,7 @@ enum MachineKind {
     SignalExternalWorkflow,
     CancelExternalWorkflow,
     LocalActivity,
+    UpsertSearchAttributes,
 }
 
 #[enum_dispatch::enum_dispatch]
@@ -82,6 +85,7 @@ enum Machines {
     SignalExternalMachine,
     TimerMachine,
     WorkflowTaskMachine,
+    UpsertSearchAttributesMachine,
 }
 
 /// Extends [rustfsm::StateMachine] with some functionality specific to the temporal SDK.
@@ -104,7 +108,7 @@ trait TemporalStateMachine: Send {
     /// to update the overall state of the workflow. EX: To issue outgoing WF activations.
     fn handle_event(
         &mut self,
-        event: &HistoryEvent,
+        event: HistoryEvent,
         has_next_event: bool,
     ) -> Result<Vec<MachineResponse>, WFMachinesError>;
 
@@ -168,7 +172,7 @@ where
 
     fn handle_event(
         &mut self,
-        event: &HistoryEvent,
+        event: HistoryEvent,
         has_next_event: bool,
     ) -> Result<Vec<MachineResponse>, WFMachinesError> {
         debug!(
@@ -177,22 +181,20 @@ where
             state = %self.state(),
             "handling event"
         );
-        let converted_event: <Self as StateMachine>::Event = event.clone().try_into()?;
+        let event_info = EventInfo {
+            event_id: event.event_id,
+            event_type: event.event_type(),
+            has_next_event,
+        };
+        let converted_event: <Self as StateMachine>::Event = event.try_into()?;
 
         match OnEventWrapper::on_event_mut(self, converted_event) {
-            Ok(c) => process_machine_commands(
-                self,
-                c,
-                Some(EventInfo {
-                    event,
-                    has_next_event,
-                }),
-            ),
+            Ok(c) => process_machine_commands(self, c, Some(event_info)),
             Err(MachineError::InvalidTransition) => Err(WFMachinesError::Fatal(format!(
-                "{} in state {} says the transition is invalid during event {}",
+                "{} in state {} says the transition is invalid during event {:?}",
                 self.name(),
                 self.state(),
-                event
+                event_info
             ))),
             Err(MachineError::Underlying(e)) => Err(e.into()),
         }
@@ -263,8 +265,9 @@ trait WFMachinesAdapter: StateMachine {
 }
 
 #[derive(Debug, Copy, Clone)]
-struct EventInfo<'a> {
-    event: &'a HistoryEvent,
+struct EventInfo {
+    event_id: i64,
+    event_type: EventType,
     has_next_event: bool,
 }
 

package/sdk-core/core/src/workflow/machines/signal_external_state_machine.rs

@@ -6,8 +6,11 @@ use rustfsm::{fsm, MachineError, TransitionResult};
 use std::convert::TryFrom;
 use temporal_sdk_core_protos::{
     coresdk::{
-        common::{NamespacedWorkflowExecution, Payload},
+        common::NamespacedWorkflowExecution,
         workflow_activation::ResolveSignalExternalWorkflow,
+        workflow_commands::{
+            signal_external_workflow_execution as sig_we, SignalExternalWorkflowExecution,
+        },
         IntoPayloadsExt,
     },
     temporal::api::{
@@ -62,15 +65,29 @@ pub(super) enum SignalExternalCommand {
 }
 
 pub(super) fn new_external_signal(
-    seq: u32,
-    workflow_execution: NamespacedWorkflowExecution,
-    signal_name: String,
-    payloads: impl IntoIterator<Item = Payload>,
-    only_child: bool,
-) -> NewMachineWithCommand {
+    attrs: SignalExternalWorkflowExecution,
+    this_namespace: &str,
+) -> Result<NewMachineWithCommand, WFMachinesError> {
+    let (workflow_execution, only_child) = match attrs.target {
+        None => {
+            return Err(WFMachinesError::Fatal(
+                "Signal external workflow command had empty target field".to_string(),
+            ))
+        }
+        Some(sig_we::Target::ChildWorkflowId(wfid)) => (
+            NamespacedWorkflowExecution {
+                namespace: this_namespace.to_string(),
+                workflow_id: wfid,
+                run_id: "".to_string(),
+            },
+            true,
+        ),
+        Some(sig_we::Target::WorkflowExecution(we)) => (we, false),
+    };
+
     let mut s = SignalExternalMachine {
         state: Created {}.into(),
-        shared_state: SharedState { seq },
+        shared_state: SharedState { seq: attrs.seq },
     };
     OnEventWrapper::on_event_mut(&mut s, SignalExternalMachineEvents::Schedule)
         .expect("Scheduling signal external wf command doesn't fail");
@@ -81,9 +98,13 @@ pub(super) fn new_external_signal(
                 workflow_id: workflow_execution.workflow_id,
                 run_id: workflow_execution.run_id,
             }),
-            header: None,
-            signal_name,
-            input: payloads.into_payloads(),
+            header: if attrs.headers.is_empty() {
+                None
+            } else {
+                Some(attrs.headers.into())
+            },
+            signal_name: attrs.signal_name,
+            input: attrs.args.into_payloads(),
             // Is deprecated
             control: "".to_string(),
             child_workflow_only: only_child,
@@ -93,10 +114,10 @@ pub(super) fn new_external_signal(
         command_type: CommandType::SignalExternalWorkflowExecution as i32,
         attributes: Some(cmd_attrs),
     };
-    NewMachineWithCommand {
+    Ok(NewMachineWithCommand {
         command: cmd,
         machine: s.into(),
-    }
+    })
 }
 
 #[derive(Default, Clone)]
@@ -287,7 +308,9 @@ mod tests {
     use super::*;
     use crate::{replay::TestHistoryBuilder, workflow::managed_wf::ManagedWFFunc};
     use std::mem::discriminant;
-    use temporal_sdk::{CancellableFuture, WfContext, WorkflowFunction, WorkflowResult};
+    use temporal_sdk::{
+        CancellableFuture, SignalWorkflowOptions, WfContext, WorkflowFunction, WorkflowResult,
+    };
     use temporal_sdk_core_protos::coresdk::workflow_activation::{
         workflow_activation_job, WorkflowActivationJob,
     };
@@ -295,9 +318,9 @@ mod tests {
     const SIGNAME: &str = "signame";
 
     async fn signal_sender(ctx: WfContext) -> WorkflowResult<()> {
-        let res = ctx
-            .signal_workflow("fake_wid", "fake_rid", SIGNAME, b"hi!")
-            .await;
+        let mut dat = SignalWorkflowOptions::new("fake_wid", "fake_rid", SIGNAME, [b"hi!"]);
+        dat.with_header("tupac", b"shakur");
+        let res = ctx.signal_workflow(dat).await;
         if res.is_err() {
             Err(anyhow::anyhow!("Signal fail!"))
         } else {
@@ -325,12 +348,21 @@ mod tests {
         let wff = WorkflowFunction::new(signal_sender);
         let mut wfm = ManagedWFFunc::new(t, wff, vec![]);
         wfm.get_next_activation().await.unwrap();
-        let cmds = wfm.get_server_commands().commands;
+        let mut cmds = wfm.get_server_commands().commands;
         assert_eq!(cmds.len(), 1);
         assert_eq!(
             cmds[0].command_type(),
             CommandType::SignalExternalWorkflowExecution
         );
+        assert_matches!(
+            cmds.remove(0).attributes.unwrap(),
+            command::Attributes::SignalExternalWorkflowExecutionCommandAttributes(attrs) => {
+                assert_eq!(attrs.signal_name, SIGNAME);
+                assert_eq!(attrs.input.unwrap().payloads[0],
+                           b"hi!".into());
+                assert_eq!(*attrs.header.unwrap().fields.get("tupac").unwrap(), b"shakur".into());
+            }
+        );
         wfm.get_next_activation().await.unwrap();
         let cmds = wfm.get_server_commands().commands;
         assert_eq!(cmds.len(), 1);
@@ -354,7 +386,12 @@ mod tests {
         t.add_workflow_execution_completed();
 
         let wff = WorkflowFunction::new(|ctx: WfContext| async move {
-            let sig = ctx.signal_workflow("fake_wid", "fake_rid", SIGNAME, b"hi!");
+            let sig = ctx.signal_workflow(SignalWorkflowOptions::new(
+                "fake_wid",
+                "fake_rid",
+                SIGNAME,
+                [b"hi!"],
+            ));
             sig.cancel(&ctx);
             let _res = sig.await;
             Ok(().into())

package/sdk-core/core/src/workflow/machines/transition_coverage.rs

@@ -77,6 +77,7 @@ mod machine_coverage_report {
         fail_workflow_state_machine::FailWorkflowMachine,
         local_activity_state_machine::LocalActivityMachine, patch_state_machine::PatchMachine,
         signal_external_state_machine::SignalExternalMachine, timer_state_machine::TimerMachine,
+        upsert_search_attributes_state_machine::UpsertSearchAttributesMachine,
         workflow_task_state_machine::WorkflowTaskMachine,
     };
     use rustfsm::StateMachine;
@@ -113,6 +114,7 @@ mod machine_coverage_report {
         let mut signal_ext = SignalExternalMachine::visualizer().to_owned();
         let mut cancel_ext = CancelExternalMachine::visualizer().to_owned();
         let mut la_mach = LocalActivityMachine::visualizer().to_owned();
+        let mut upsert_search_attr = UpsertSearchAttributesMachine::visualizer().to_owned();
 
         // This isn't at all efficient but doesn't need to be.
         // Replace transitions in the vizzes with green color if they are covered.
@@ -133,6 +135,9 @@ mod machine_coverage_report {
                 m @ "SignalExternalMachine" => cover_transitions(m, &mut signal_ext, coverage),
                 m @ "CancelExternalMachine" => cover_transitions(m, &mut cancel_ext, coverage),
                 m @ "LocalActivityMachine" => cover_transitions(m, &mut la_mach, coverage),
+                m @ "UpsertSearchAttributesMachine" => {
+                    cover_transitions(m, &mut upsert_search_attr, coverage)
+                }
                 m => panic!("Unknown machine {}", m),
             }
         }