temporalio 0.0.1 → 0.1.0

data/bridge/sdk-core/core/src/worker/workflow/machines/workflow_task_state_machine.rs

@@ -1,9 +1,9 @@
 #![allow(clippy::enum_variant_names)]
 
 use super::{
-    workflow_machines::MachineResponse, Cancellable, EventInfo, MachineKind, WFMachinesAdapter,
-    WFMachinesError,
+    workflow_machines::MachineResponse, Cancellable, EventInfo, WFMachinesAdapter, WFMachinesError,
 };
+use crate::worker::workflow::machines::HistEventData;
 use rustfsm::{fsm, TransitionResult};
 use std::{
     convert::{TryFrom, TryInto},
@@ -49,7 +49,7 @@ pub(super) enum WFTaskMachineCommand {
         task_started_event_id: i64,
         time: SystemTime,
     },
-    #[display(fmt = "RunIdOnWorkflowResetUpdate({})", run_id)]
+    #[display(fmt = "RunIdOnWorkflowResetUpdate({run_id})")]
     RunIdOnWorkflowResetUpdate { run_id: String },
 }
 
@@ -64,8 +64,8 @@ impl WFMachinesAdapter for WorkflowTaskMachine {
                 task_started_event_id,
                 time,
             } => {
-                let (event_id, event_type, has_next_event) = if let Some(ei) = event_info {
-                    (ei.event_id, ei.event_type, ei.has_next_event)
+                let (event_id, event_type) = if let Some(ei) = event_info {
+                    (ei.event_id, ei.event_type)
                 } else {
                     return Err(WFMachinesError::Fatal(
                         "WF Task machine should never issue a task started trigger \
@@ -75,9 +75,7 @@ impl WFMachinesAdapter for WorkflowTaskMachine {
                 };
 
                 let cur_event_past_or_at_start = event_id >= task_started_event_id;
-                if event_type == EventType::WorkflowTaskStarted
-                    && (!cur_event_past_or_at_start || has_next_event)
-                {
+                if event_type == EventType::WorkflowTaskStarted && !cur_event_past_or_at_start {
                     return Ok(vec![]);
                 }
                 Ok(vec![MachineResponse::TriggerWFTaskStarted {
@@ -101,16 +99,13 @@ impl WFMachinesAdapter for WorkflowTaskMachine {
                 | EventType::WorkflowTaskFailed
         )
     }
-
-    fn kind(&self) -> MachineKind {
-        MachineKind::WorkflowTask
-    }
 }
 
-impl TryFrom<HistoryEvent> for WorkflowTaskMachineEvents {
+impl TryFrom<HistEventData> for WorkflowTaskMachineEvents {
     type Error = WFMachinesError;
 
-    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
+    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
+        let e = e.event;
         Ok(match e.event_type() {
             EventType::WorkflowTaskScheduled => Self::WorkflowTaskScheduled,
             EventType::WorkflowTaskStarted => Self::WorkflowTaskStarted({
@@ -126,8 +121,7 @@ impl TryFrom<HistoryEvent> for WorkflowTaskMachineEvents {
                     }
                 } else {
                     return Err(WFMachinesError::Fatal(format!(
-                        "Workflow task started event must contain timestamp: {}",
-                        e
+                        "Workflow task started event must contain timestamp: {e}"
                     )));
                 };
                 WFTStartedDat {
@@ -155,15 +149,13 @@ impl TryFrom<HistoryEvent> for WorkflowTaskMachineEvents {
                     })
                 } else {
                     return Err(WFMachinesError::Fatal(format!(
-                        "Workflow task failed is missing attributes: {}",
-                        e
+                        "Workflow task failed is missing attributes: {e}"
                     )));
                 }
             }
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
-                    "Event does not apply to a wf task machine: {}",
-                    e
+                    "Event does not apply to a wf task machine: {e}"
                 )))
             }
         })

data/bridge/sdk-core/core/src/worker/workflow/managed_run/managed_wf_test.rs

@@ -4,11 +4,13 @@ use crate::{
     test_help::TEST_Q,
     worker::{
         workflow::{
-            history_update::TestHBExt, machines::WorkflowMachines, WFCommand, WorkflowFetcher,
+            history_update::tests::TestHBExt, machines::WorkflowMachines, WFCommand,
+            WorkflowFetcher,
         },
         LocalActRequest, LocalActivityResolution,
     },
 };
+use crossbeam::channel::bounded;
 use std::{convert::TryInto, time::Duration};
 use temporal_sdk::{WorkflowFunction, WorkflowResult};
 use temporal_sdk_core_protos::{
@@ -27,13 +29,12 @@ use tokio::{
 };
 
 pub(crate) struct WFFutureDriver {
-    completions_rx: UnboundedReceiver<WorkflowActivationCompletion>,
+    completions_q: crossbeam::channel::Receiver<WorkflowActivationCompletion>,
 }
 
-#[async_trait::async_trait]
 impl WorkflowFetcher for WFFutureDriver {
-    async fn fetch_workflow_iteration_output(&mut self) -> Vec<WFCommand> {
-        if let Some(completion) = self.completions_rx.recv().await {
+    fn fetch_workflow_iteration_output(&mut self) -> Vec<WFCommand> {
+        if let Ok(completion) = self.completions_q.try_recv() {
             debug!("Managed wf completion: {}", completion);
             completion
                 .status
@@ -57,6 +58,8 @@ impl WorkflowFetcher for WFFutureDriver {
 pub struct ManagedWFFunc {
     mgr: WorkflowManager,
     activation_tx: UnboundedSender<WorkflowActivation>,
+    completions_rx: UnboundedReceiver<WorkflowActivationCompletion>,
+    completions_sync_tx: crossbeam::channel::Sender<WorkflowActivationCompletion>,
     future_handle: Option<JoinHandle<WorkflowResult<()>>>,
     was_shutdown: bool,
 }
@@ -79,28 +82,36 @@ impl ManagedWFFunc {
             completions_tx,
         );
         let spawned = tokio::spawn(wff);
-        let driver = WFFutureDriver { completions_rx };
+        let (completions_sync_tx, completions_sync_rx) = bounded(1);
+        let driver = WFFutureDriver {
+            completions_q: completions_sync_rx,
+        };
         let state_machines = WorkflowMachines::new(
-            "test_namespace".to_string(),
-            "wfid".to_string(),
-            "wftype".to_string(),
-            "runid".to_string(),
-            hist,
+            RunBasics {
+                namespace: "test_namespace".to_string(),
+                workflow_id: "wfid".to_string(),
+                workflow_type: "wftype".to_string(),
+                run_id: "runid".to_string(),
+                history: hist,
+                metrics: MetricsContext::no_op(),
+                capabilities: &Default::default(),
+            },
             Box::new(driver).into(),
-            Default::default(),
         );
         let mgr = WorkflowManager::new_from_machines(state_machines);
         Self {
             mgr,
             activation_tx: activations,
+            completions_rx,
+            completions_sync_tx,
             future_handle: Some(spawned),
             was_shutdown: false,
         }
     }
 
-    #[instrument(level = "debug", skip(self))]
+    #[instrument(skip(self))]
     pub(crate) async fn get_next_activation(&mut self) -> Result<WorkflowActivation> {
-        let res = self.mgr.get_next_activation().await?;
+        let res = self.mgr.get_next_activation()?;
         debug!("Managed wf next activation: {}", &res);
         self.push_activation_to_wf(&res).await?;
         Ok(res)
@@ -116,12 +127,12 @@ impl ManagedWFFunc {
     }
 
     /// Feed new history, as if received a new poll result. Returns new activation
-    #[instrument(level = "debug", skip(self, update))]
+    #[instrument(skip(self, update))]
     pub(crate) async fn new_history(
         &mut self,
         update: HistoryUpdate,
     ) -> Result<WorkflowActivation> {
-        let res = self.mgr.feed_history_from_server(update).await?;
+        let res = self.mgr.feed_history_from_server(update)?;
         self.push_activation_to_wf(&res).await?;
         Ok(res)
     }
@@ -174,7 +185,7 @@ impl ManagedWFFunc {
         self.future_handle.take().unwrap().await.unwrap()
     }
 
-    #[instrument(level = "debug", skip(self, res))]
+    #[instrument(skip(self, res))]
     async fn push_activation_to_wf(&mut self, res: &WorkflowActivation) -> Result<()> {
         if res.jobs.is_empty() {
             // Nothing to do here
@@ -183,7 +194,11 @@ impl ManagedWFFunc {
         self.activation_tx
             .send(res.clone())
             .expect("Workflow should not be dropped if we are still sending activations");
-        self.mgr.machines.iterate_machines().await?;
+        // Move the completion response to the sync workflow bridge
+        self.completions_sync_tx
+            .send(self.completions_rx.recv().await.unwrap())
+            .unwrap();
+        self.mgr.machines.iterate_machines()?;
         Ok(())
     }
 }