@temporalio/core-bridge 0.16.4 → 0.18.0

package/sdk-core/core/src/worker/wft_delivery.rs

@@ -0,0 +1,81 @@
+use crate::{pollers, pollers::BoxedWFPoller};
+use crossbeam::queue::SegQueue;
+use temporal_sdk_core_protos::temporal::api::workflowservice::v1::PollWorkflowTaskQueueResponse;
+use tokio::sync::Notify;
+
+/// Workflow tasks typically come from polling, but may also come as a response to task completion.
+/// This struct allows fetching WFTs to be centralized while prioritizing tasks from completes.
+pub(crate) struct WFTSource {
+    from_completions: SegQueue<PollWorkflowTaskQueueResponse>,
+    poll_buffer: BoxedWFPoller,
+    task_taken_notifier: Notify,
+}
+
+impl WFTSource {
+    pub fn new(poller: BoxedWFPoller) -> Self {
+        Self {
+            from_completions: SegQueue::new(),
+            poll_buffer: poller,
+            task_taken_notifier: Notify::new(),
+        }
+    }
+
+    /// Returns the next available WFT if one is already stored from a completion, otherwise
+    /// forwards to the poller.
+    pub async fn next_wft(&self) -> Option<pollers::Result<PollWorkflowTaskQueueResponse>> {
+        if let Some(wft) = self.from_completions.pop() {
+            self.task_taken_notifier.notify_one();
+            return Some(Ok(wft));
+        }
+        self.poll_buffer.poll().await
+    }
+
+    /// Add a WFT received from the completion of another WFT
+    pub fn add_wft_from_completion(&self, wft: PollWorkflowTaskQueueResponse) {
+        self.from_completions.push(wft);
+    }
+
+    /// Notifies the pollers to stop polling
+    pub fn stop_pollers(&self) {
+        self.poll_buffer.notify_shutdown();
+    }
+
+    /// Returns true if there are tasks from completion buffered which need to be handled
+    pub fn has_tasks_from_complete(&self) -> bool {
+        !self.from_completions.is_empty()
+    }
+
+    /// Returns a future which resolves when all tasks from completions have been taken
+    pub async fn wait_for_tasks_from_complete_to_drain(&self) {
+        while !self.from_completions.is_empty() {
+            self.task_taken_notifier.notified().await;
+        }
+    }
+
+    /// Wait for poll shutdown to complete
+    pub async fn shutdown(self) {
+        self.poll_buffer.shutdown_box().await;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_help::mock_poller;
+
+    #[tokio::test]
+    async fn drains_from_completes_on_shutdown() {
+        let mp = mock_poller();
+        let wftsrc = WFTSource::new(Box::new(mp));
+        let fake_wft = PollWorkflowTaskQueueResponse {
+            started_event_id: 1,
+            ..Default::default()
+        };
+        wftsrc.add_wft_from_completion(fake_wft);
+        let fake_wft = PollWorkflowTaskQueueResponse {
+            started_event_id: 2,
+            ..Default::default()
+        };
+        wftsrc.add_wft_from_completion(fake_wft);
+    }
+}

package/sdk-core/{src → core/src}/workflow/bridge.rs

@@ -1,4 +1,7 @@
-use crate::{machines::WFCommand, workflow::WorkflowFetcher};
+use crate::{
+    telemetry::VecDisplayer,
+    workflow::{WFCommand, WorkflowFetcher},
+};
 use std::sync::mpsc::{self, Receiver, Sender};
 
 /// The [DrivenWorkflow] trait expects to be called to make progress, but the [CoreSDKService]
@@ -28,7 +31,7 @@ impl WorkflowFetcher for WorkflowBridge {
         let in_cmds = self.incoming_commands.try_recv();
 
         let in_cmds = in_cmds.unwrap_or_else(|_| vec![WFCommand::NoCommandsFromLang]);
-        debug!(in_cmds = ?in_cmds, "wf bridge iteration fetch");
+        debug!(in_cmds = %in_cmds.display(), "wf bridge iteration fetch");
         in_cmds
     }
 }

package/sdk-core/{src → core/src}/workflow/driven_workflow.rs

@@ -1,8 +1,8 @@
-use crate::machines::WFCommand;
+use crate::workflow::WFCommand;
 use std::collections::VecDeque;
 use temporal_sdk_core_protos::{
     coresdk::workflow_activation::{
-        wf_activation_job, CancelWorkflow, SignalWorkflow, WfActivationJob,
+        workflow_activation_job, CancelWorkflow, SignalWorkflow, WorkflowActivationJob,
     },
     temporal::api::history::v1::WorkflowExecutionStartedEventAttributes,
 };
@@ -13,7 +13,7 @@ pub struct DrivenWorkflow {
     started_attrs: Option<WorkflowExecutionStartedEventAttributes>,
     fetcher: Box<dyn WorkflowFetcher>,
     /// Outgoing activation jobs that need to be sent to the lang sdk
-    outgoing_wf_activation_jobs: VecDeque<wf_activation_job::Variant>,
+    outgoing_wf_activation_jobs: VecDeque<workflow_activation_job::Variant>,
 }
 
 impl<WF> From<Box<WF>> for DrivenWorkflow
@@ -36,13 +36,23 @@ impl DrivenWorkflow {
         self.started_attrs = Some(attribs);
     }
 
+    /// Return the attributes from the workflow execution started event if this workflow has started
+    pub fn get_started_attrs(&self) -> Option<&WorkflowExecutionStartedEventAttributes> {
+        self.started_attrs.as_ref()
+    }
+
     /// Enqueue a new job to be sent to the driven workflow
-    pub fn send_job(&mut self, job: wf_activation_job::Variant) {
+    pub fn send_job(&mut self, job: workflow_activation_job::Variant) {
         self.outgoing_wf_activation_jobs.push_back(job);
     }
 
+    /// Check if there are pending jobs
+    pub fn has_pending_jobs(&self) -> bool {
+        !self.outgoing_wf_activation_jobs.is_empty()
+    }
+
     /// Drain all pending jobs, so that they may be sent to the driven workflow
-    pub fn drain_jobs(&mut self) -> Vec<WfActivationJob> {
+    pub fn drain_jobs(&mut self) -> Vec<WorkflowActivationJob> {
         self.outgoing_wf_activation_jobs
             .drain(..)
             .map(Into::into)
@@ -51,12 +61,12 @@ impl DrivenWorkflow {
 
     /// Signal the workflow
     pub fn signal(&mut self, signal: SignalWorkflow) {
-        self.send_job(wf_activation_job::Variant::SignalWorkflow(signal));
+        self.send_job(workflow_activation_job::Variant::SignalWorkflow(signal));
     }
 
     /// Cancel the workflow
     pub fn cancel(&mut self, attribs: CancelWorkflow) {
-        self.send_job(wf_activation_job::Variant::CancelWorkflow(attribs));
+        self.send_job(workflow_activation_job::Variant::CancelWorkflow(attribs));
     }
 }
 

package/sdk-core/{src → core/src}/workflow/history_update.rs

@@ -1,4 +1,7 @@
-use crate::ServerGatewayApis;
+use crate::{
+    replay::{HistoryInfo, TestHistoryBuilder},
+    ServerGatewayApis,
+};
 use futures::{future::BoxFuture, stream, stream::BoxStream, FutureExt, Stream, StreamExt};
 use std::{
     collections::VecDeque,
@@ -108,8 +111,14 @@ impl HistoryUpdate {
         }
     }
 
-    #[cfg(test)]
-    pub fn new_from_events(events: Vec<HistoryEvent>, previous_wft_started_id: i64) -> Self {
+    /// Create an instance of an update directly from events - should only be used for replaying.
+    pub fn new_from_events<I: IntoIterator<Item = HistoryEvent>>(
+        events: I,
+        previous_wft_started_id: i64,
+    ) -> Self
+    where
+        <I as IntoIterator>::IntoIter: Send + 'static,
+    {
         Self {
             events: stream::iter(events.into_iter().map(Ok)).boxed(),
             buffered: VecDeque::new(),
@@ -227,10 +236,27 @@ impl HistoryUpdate {
     }
 }
 
+impl From<HistoryInfo> for HistoryUpdate {
+    fn from(v: HistoryInfo) -> Self {
+        Self::new_from_events(v.events().to_vec(), v.previous_started_event_id())
+    }
+}
+
+pub trait TestHBExt {
+    fn as_history_update(&self) -> HistoryUpdate;
+}
+
+impl TestHBExt for TestHistoryBuilder {
+    fn as_history_update(&self) -> HistoryUpdate {
+        self.get_full_history_info().unwrap().into()
+    }
+}
+
 #[cfg(test)]
-mod tests {
+pub mod tests {
     use super::*;
-    use crate::{pollers::MockServerGatewayApis, test_help::canned_histories};
+    use crate::test_help::canned_histories;
+    use temporal_client::mocks::mock_gateway;
 
     #[tokio::test]
     async fn consumes_standard_wft_sequence() {
@@ -285,8 +311,8 @@ mod tests {
         let wft_count = 500;
         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 = MockServerGatewayApis::new();
+        let prev_started = initial_hist.previous_started_event_id();
+        let mut mock_gateway = mock_gateway();
 
         let mut npt = 2;
         mock_gateway

package/sdk-core/{src → core/src/workflow}/machines/activity_state_machine.rs

@@ -1,6 +1,6 @@
 #![allow(clippy::large_enum_variant)]
 
-use crate::machines::{
+use super::{
     workflow_machines::MachineResponse, Cancellable, EventInfo, MachineKind, NewMachineWithCommand,
     OnEventWrapper, WFMachinesAdapter, WFMachinesError,
 };
@@ -8,7 +8,7 @@ use rustfsm::{fsm, MachineError, StateMachine, TransitionResult};
 use std::convert::{TryFrom, TryInto};
 use temporal_sdk_core_protos::{
     coresdk::{
-        activity_result::{self as ar, activity_result, ActivityResult, Cancellation},
+        activity_result::{self as ar, activity_resolution, ActivityResolution, Cancellation},
         common::Payload,
         workflow_activation::ResolveActivity,
         workflow_commands::{ActivityCancellationType, ScheduleActivity},
@@ -92,11 +92,11 @@ pub(super) enum ActivityMachineCommand {
 }
 
 /// Creates a new activity state machine and a command to schedule it on the server.
-pub(super) fn new_activity(attribs: ScheduleActivity) -> NewMachineWithCommand<ActivityMachine> {
+pub(super) fn new_activity(attribs: ScheduleActivity) -> NewMachineWithCommand {
     let (activity, add_cmd) = ActivityMachine::new_scheduled(attribs);
     NewMachineWithCommand {
         command: add_cmd,
-        machine: activity,
+        machine: activity.into(),
     }
 }
 
@@ -136,8 +136,8 @@ impl ActivityMachine {
     fn create_cancelation_resolve(&self, details: Option<Payload>) -> ResolveActivity {
         ResolveActivity {
             seq: self.shared_state.attrs.seq,
-            result: Some(ActivityResult {
-                status: Some(activity_result::Status::Cancelled(Cancellation {
+            result: Some(ActivityResolution {
+                status: Some(activity_resolution::Status::Cancelled(Cancellation {
                     failure: Some(Failure {
                         message: "Activity cancelled".to_string(),
                         cause: Some(Box::from(Failure {
@@ -243,8 +243,8 @@ impl WFMachinesAdapter for ActivityMachine {
             ActivityMachineCommand::Complete(result) => {
                 vec![ResolveActivity {
                     seq: self.shared_state.attrs.seq,
-                    result: Some(ActivityResult {
-                        status: Some(activity_result::Status::Completed(ar::Success {
+                    result: Some(ActivityResolution {
+                        status: Some(activity_resolution::Status::Completed(ar::Success {
                             result: convert_payloads(event_info, result)?,
                         })),
                     }),
@@ -254,8 +254,8 @@ impl WFMachinesAdapter for ActivityMachine {
             ActivityMachineCommand::Fail(failure) => {
                 vec![ResolveActivity {
                     seq: self.shared_state.attrs.seq,
-                    result: Some(ActivityResult {
-                        status: Some(activity_result::Status::Failed(ar::Failure {
+                    result: Some(ActivityResolution {
+                        status: Some(activity_resolution::Status::Failed(ar::Failure {
                             failure: Some(failure),
                         })),
                     }),
@@ -748,16 +748,16 @@ fn convert_payloads(
 mod test {
     use super::*;
     use crate::{
-        prototype_rust_sdk::{
-            ActivityOptions, CancellableFuture, WfContext, WorkflowFunction, WorkflowResult,
-        },
-        test_help::{canned_histories, TestHistoryBuilder},
+        replay::TestHistoryBuilder, test_help::canned_histories,
         workflow::managed_wf::ManagedWFFunc,
     };
     use rstest::{fixture, rstest};
     use std::mem::discriminant;
+    use temporal_sdk::{
+        ActivityOptions, CancellableFuture, WfContext, WorkflowFunction, WorkflowResult,
+    };
     use temporal_sdk_core_protos::coresdk::workflow_activation::{
-        wf_activation_job, WfActivationJob,
+        workflow_activation_job, WorkflowActivationJob,
     };
 
     #[fixture]
@@ -776,7 +776,7 @@ mod test {
         ManagedWFFunc::new(t, func, vec![])
     }
 
-    async fn activity_wf(mut command_sink: WfContext) -> WorkflowResult<()> {
+    async fn activity_wf(command_sink: WfContext) -> WorkflowResult<()> {
         command_sink.activity(ActivityOptions::default()).await;
         Ok(().into())
     }
@@ -789,7 +789,7 @@ mod test {
     #[tokio::test]
     async fn single_activity_inc(mut wfm: ManagedWFFunc) {
         wfm.get_next_activation().await.unwrap();
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 1);
         assert_eq!(
             commands[0].command_type,
@@ -797,7 +797,7 @@ mod test {
         );
 
         wfm.get_next_activation().await.unwrap();
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 1);
         assert_eq!(
             commands[0].command_type,
@@ -814,7 +814,7 @@ mod test {
     #[tokio::test]
     async fn single_activity_full(mut wfm: ManagedWFFunc) {
         wfm.process_all_activations().await.unwrap();
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 1);
         assert_eq!(
             commands[0].command_type,
@@ -825,10 +825,10 @@ mod test {
 
     #[tokio::test]
     async fn immediate_activity_cancelation() {
-        let func = WorkflowFunction::new(|mut ctx: WfContext| async move {
+        let func = WorkflowFunction::new(|ctx: WfContext| async move {
             let cancel_activity_future = ctx.activity(ActivityOptions::default());
             // Immediately cancel the activity
-            cancel_activity_future.cancel(&mut ctx);
+            cancel_activity_future.cancel(&ctx);
             cancel_activity_future.await;
             Ok(().into())
         });
@@ -840,14 +840,14 @@ mod test {
         let mut wfm = ManagedWFFunc::new(t, func, vec![]);
 
         let activation = wfm.process_all_activations().await.unwrap();
-        wfm.get_server_commands().await;
+        wfm.get_server_commands();
         assert_matches!(
             activation.jobs.as_slice(),
-            [WfActivationJob {
-                variant: Some(wf_activation_job::Variant::ResolveActivity(
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::ResolveActivity(
                     ResolveActivity {
-                        result: Some(ActivityResult {
-                            status: Some(activity_result::Status::Cancelled(_))
+                        result: Some(ActivityResolution {
+                            status: Some(activity_resolution::Status::Cancelled(_))
                         }),
                         ..
                     }

package/sdk-core/{src → core/src/workflow}/machines/cancel_external_state_machine.rs

@@ -1,4 +1,4 @@
-use crate::machines::{
+use super::{
     workflow_machines::MachineResponse, Cancellable, EventInfo, MachineKind, NewMachineWithCommand,
     OnEventWrapper, WFMachinesAdapter, WFMachinesError,
 };
@@ -58,7 +58,7 @@ pub(super) fn new_external_cancel(
     seq: u32,
     workflow_execution: NamespacedWorkflowExecution,
     only_child: bool,
-) -> NewMachineWithCommand<CancelExternalMachine> {
+) -> NewMachineWithCommand {
     let mut s = CancelExternalMachine {
         state: Created {}.into(),
         shared_state: SharedState { seq },
@@ -81,7 +81,7 @@ pub(super) fn new_external_cancel(
     };
     NewMachineWithCommand {
         command: cmd,
-        machine: s,
+        machine: s.into(),
     }
 }
 
@@ -230,13 +230,10 @@ impl Cancellable for CancelExternalMachine {}
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
-        prototype_rust_sdk::{WfContext, WorkflowFunction, WorkflowResult},
-        test_help::TestHistoryBuilder,
-        workflow::managed_wf::ManagedWFFunc,
-    };
+    use crate::{replay::TestHistoryBuilder, workflow::managed_wf::ManagedWFFunc};
+    use temporal_sdk::{WfContext, WorkflowFunction, WorkflowResult};
 
-    async fn cancel_sender(mut ctx: WfContext) -> WorkflowResult<()> {
+    async fn cancel_sender(ctx: WfContext) -> WorkflowResult<()> {
         let res = ctx
             .cancel_external(NamespacedWorkflowExecution {
                 namespace: "some_namespace".to_string(),
@@ -275,14 +272,14 @@ mod tests {
         let wff = WorkflowFunction::new(cancel_sender);
         let mut wfm = ManagedWFFunc::new(t, wff, vec![]);
         wfm.get_next_activation().await.unwrap();
-        let cmds = wfm.get_server_commands().await.commands;
+        let cmds = wfm.get_server_commands().commands;
         assert_eq!(cmds.len(), 1);
         assert_eq!(
             cmds[0].command_type(),
             CommandType::RequestCancelExternalWorkflowExecution
         );
         wfm.get_next_activation().await.unwrap();
-        let cmds = wfm.get_server_commands().await.commands;
+        let cmds = wfm.get_server_commands().commands;
         assert_eq!(cmds.len(), 1);
         if fails {
             assert_eq!(cmds[0].command_type(), CommandType::FailWorkflowExecution);

package/sdk-core/{src → core/src/workflow}/machines/cancel_workflow_state_machine.rs

@@ -1,6 +1,6 @@
-use crate::machines::{
-    Cancellable, EventInfo, HistoryEvent, MachineKind, MachineResponse, NewMachineWithCommand,
-    OnEventWrapper, WFMachinesAdapter, WFMachinesError,
+use super::{
+    workflow_machines::MachineResponse, Cancellable, EventInfo, HistoryEvent, MachineKind,
+    NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError,
 };
 use rustfsm::{fsm, TransitionResult};
 use std::convert::TryFrom;
@@ -32,9 +32,7 @@ pub(super) enum CancelWorkflowMachineError {}
 #[derive(Debug, derive_more::Display)]
 pub(super) enum CancelWorkflowCommand {}
 
-pub(super) fn cancel_workflow(
-    attribs: CancelWorkflowExecution,
-) -> NewMachineWithCommand<CancelWorkflowMachine> {
+pub(super) fn cancel_workflow(attribs: CancelWorkflowExecution) -> NewMachineWithCommand {
     let mut machine = CancelWorkflowMachine {
         state: Created {}.into(),
         shared_state: (),
@@ -45,7 +43,10 @@ pub(super) fn cancel_workflow(
         command_type: CommandType::CancelWorkflowExecution as i32,
         attributes: Some(attribs.into()),
     };
-    NewMachineWithCommand { command, machine }
+    NewMachineWithCommand {
+        command,
+        machine: machine.into(),
+    }
 }
 
 #[derive(Default, Clone)]
@@ -121,17 +122,14 @@ impl Cancellable for CancelWorkflowMachine {}
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
-        prototype_rust_sdk::{WfContext, WfExitValue, WorkflowFunction, WorkflowResult},
-        test_help::canned_histories,
-        workflow::managed_wf::ManagedWFFunc,
-    };
+    use crate::{test_help::canned_histories, workflow::managed_wf::ManagedWFFunc};
     use std::time::Duration;
+    use temporal_sdk::{WfContext, WfExitValue, WorkflowFunction, WorkflowResult};
     use temporal_sdk_core_protos::coresdk::workflow_activation::{
-        wf_activation_job, WfActivationJob,
+        workflow_activation_job, WorkflowActivationJob,
     };
 
-    async fn wf_with_timer(mut ctx: WfContext) -> WorkflowResult<()> {
+    async fn wf_with_timer(ctx: WfContext) -> WorkflowResult<()> {
         ctx.timer(Duration::from_millis(500)).await;
         Ok(WfExitValue::Cancelled)
     }
@@ -142,7 +140,7 @@ mod tests {
         let t = canned_histories::timer_wf_cancel_req_cancelled("1");
         let mut wfm = ManagedWFFunc::new(t, func, vec![]);
         wfm.get_next_activation().await.unwrap();
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 1);
         assert_eq!(commands[0].command_type, CommandType::StartTimer as i32);
 
@@ -150,15 +148,15 @@ mod tests {
         assert_matches!(
             act.jobs.as_slice(),
             [
-                WfActivationJob {
-                    variant: Some(wf_activation_job::Variant::FireTimer(_)),
+                WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::FireTimer(_)),
                 },
-                WfActivationJob {
-                    variant: Some(wf_activation_job::Variant::CancelWorkflow(_)),
+                WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::CancelWorkflow(_)),
                 }
             ]
         );
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 1);
         assert_eq!(
             commands[0].command_type,
@@ -166,7 +164,7 @@ mod tests {
         );
 
         assert!(wfm.get_next_activation().await.unwrap().jobs.is_empty());
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 0);
         wfm.shutdown().await.unwrap();
     }