@temporalio/core-bridge 0.17.2 → 0.18.0

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

@@ -1,6 +1,6 @@
 #![allow(clippy::enum_variant_names)]
 
-use crate::machines::{
+use super::{
     workflow_machines::MachineResponse, Cancellable, EventInfo, MachineKind, WFMachinesAdapter,
     WFMachinesError,
 };

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

@@ -1,31 +1,29 @@
+pub(crate) mod workflow_tasks;
+
 mod bridge;
 mod driven_workflow;
 mod history_update;
-pub(crate) mod workflow_tasks;
+mod machines;
 
 pub(crate) use bridge::WorkflowBridge;
 pub(crate) use driven_workflow::{DrivenWorkflow, WorkflowFetcher};
 pub(crate) use history_update::{HistoryPaginator, HistoryUpdate};
+pub(crate) use machines::WFMachinesError;
 
 use crate::{
-    machines::{ProtoCommand, WFCommand, WFMachinesError, WorkflowMachines},
     telemetry::metrics::MetricsContext,
+    worker::{LocalActRequest, LocalActivityResolution},
+};
+use machines::WorkflowMachines;
+use std::{result, sync::mpsc::Sender};
+use temporal_sdk_core_protos::{
+    coresdk::{workflow_activation::WorkflowActivation, workflow_commands::*},
+    temporal::api::command::v1::Command as ProtoCommand,
 };
-use std::sync::mpsc::Sender;
-use temporal_sdk_core_protos::coresdk::workflow_activation::WfActivation;
 
 pub(crate) const LEGACY_QUERY_ID: &str = "legacy_query";
-type Result<T, E = WFMachinesError> = std::result::Result<T, E>;
 
-#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
-pub(crate) enum CommandID {
-    Timer(u32),
-    Activity(u32),
-    ChildWorkflowStart(u32),
-    ChildWorkflowComplete(u32),
-    SignalExternal(u32),
-    CancelExternal(u32),
-}
+type Result<T, E = WFMachinesError> = std::result::Result<T, E>;
 
 /// Manages an instance of a [WorkflowMachines], which is not thread-safe, as well as other data
 /// associated with that specific workflow run.
@@ -43,6 +41,7 @@ impl WorkflowManager {
         history: HistoryUpdate,
         namespace: String,
         workflow_id: String,
+        workflow_type: String,
         run_id: String,
         metrics: MetricsContext,
     ) -> Self {
@@ -50,6 +49,7 @@ impl WorkflowManager {
         let state_machines = WorkflowMachines::new(
             namespace,
             workflow_id,
+            workflow_type,
             run_id,
             history,
             Box::new(wfb).into(),
@@ -76,6 +76,11 @@ pub struct OutgoingServerCommands {
     pub replaying: bool,
 }
 
+#[derive(Debug)]
+pub(crate) enum LocalResolution {
+    LocalActivity(LocalActivityResolution),
+}
+
 impl WorkflowManager {
     /// Given history that was just obtained from the server, pipe it into this workflow's machines.
     ///
@@ -84,17 +89,23 @@ impl WorkflowManager {
     pub async fn feed_history_from_server(
         &mut self,
         update: HistoryUpdate,
-    ) -> Result<WfActivation> {
+    ) -> Result<WorkflowActivation> {
         self.machines.new_history_from_server(update).await?;
         self.get_next_activation().await
     }
 
+    /// Let this workflow know that something we've been waiting locally on has resolved, like a
+    /// local activity or side effect
+    pub fn notify_of_local_result(&mut self, resolved: LocalResolution) -> Result<()> {
+        self.machines.local_resolution(resolved)
+    }
+
     /// Fetch the next workflow activation for this workflow if one is required. Doing so will apply
     /// the next unapplied workflow task if such a sequence exists in history we already know about.
     ///
     /// Callers may also need to call [get_server_commands] after this to issue any pending commands
     /// to the server.
-    pub async fn get_next_activation(&mut self) -> Result<WfActivation> {
+    pub async fn get_next_activation(&mut self) -> Result<WorkflowActivation> {
         // First check if there are already some pending jobs, which can be a result of replay.
         let activation = self.machines.get_wf_activation();
         if !activation.jobs.is_empty() {
@@ -105,15 +116,43 @@ impl WorkflowManager {
         Ok(self.machines.get_wf_activation())
     }
 
+    /// If there are no pending jobs for the workflow, apply the next workflow task and check
+    /// again if there are any jobs. Importantly, does not *drain* jobs.
+    ///
+    /// Returns true if there are jobs (before or after applying the next WFT).
+    pub async fn apply_next_task_if_ready(&mut self) -> Result<bool> {
+        if self.machines.has_pending_jobs() {
+            return Ok(true);
+        }
+        loop {
+            let consumed_events = self.machines.apply_next_wft_from_history().await?;
+
+            if consumed_events == 0 || !self.machines.replaying || self.machines.has_pending_jobs()
+            {
+                // Keep applying tasks while there are events, we are still replaying, and there are
+                // no jobs
+                break;
+            }
+        }
+        Ok(self.machines.has_pending_jobs())
+    }
+
     /// Typically called after [get_next_activation], use this to retrieve commands to be sent to
-    /// the server which been generated by the machines since it was last called.
-    pub fn get_server_commands(&self) -> OutgoingServerCommands {
+    /// the server which have been generated by the machines. Does *not* drain those commands.
+    /// See [WorkflowMachines::get_commands].
+    pub fn get_server_commands(&mut self) -> OutgoingServerCommands {
         OutgoingServerCommands {
             commands: self.machines.get_commands(),
             replaying: self.machines.replaying,
         }
     }
 
+    /// Remove and return all queued local activities. Once this is called, they need to be
+    /// dispatched for execution.
+    pub fn drain_queued_local_activities(&mut self) -> Vec<LocalActRequest> {
+        self.machines.drain_queued_local_activities()
+    }
+
     /// Feed the workflow machines new commands issued by the executing workflow code, and iterate
     /// the machines.
     pub async fn push_commands(&mut self, cmds: Vec<WFCommand>) -> Result<()> {
@@ -146,20 +185,105 @@ pub(crate) enum WorkflowCachingPolicy {
     AfterEveryReply,
 }
 
+#[derive(thiserror::Error, Debug, derive_more::From)]
+#[error("Lang provided workflow command with empty variant")]
+pub struct EmptyWorkflowCommandErr;
+
+/// [DrivenWorkflow]s respond with these when called, to indicate what they want to do next.
+/// EX: Create a new timer, complete the workflow, etc.
+#[derive(Debug, derive_more::From, derive_more::Display)]
+#[allow(clippy::large_enum_variant)]
+pub enum WFCommand {
+    /// Returned when we need to wait for the lang sdk to send us something
+    NoCommandsFromLang,
+    AddActivity(ScheduleActivity),
+    AddLocalActivity(ScheduleLocalActivity),
+    RequestCancelActivity(RequestCancelActivity),
+    RequestCancelLocalActivity(RequestCancelLocalActivity),
+    AddTimer(StartTimer),
+    CancelTimer(CancelTimer),
+    CompleteWorkflow(CompleteWorkflowExecution),
+    FailWorkflow(FailWorkflowExecution),
+    QueryResponse(QueryResult),
+    ContinueAsNew(ContinueAsNewWorkflowExecution),
+    CancelWorkflow(CancelWorkflowExecution),
+    SetPatchMarker(SetPatchMarker),
+    AddChildWorkflow(StartChildWorkflowExecution),
+    CancelUnstartedChild(CancelUnstartedChildWorkflowExecution),
+    RequestCancelExternalWorkflow(RequestCancelExternalWorkflowExecution),
+    SignalExternalWorkflow(SignalExternalWorkflowExecution),
+    CancelSignalWorkflow(CancelSignalWorkflow),
+}
+
+impl TryFrom<WorkflowCommand> for WFCommand {
+    type Error = EmptyWorkflowCommandErr;
+
+    fn try_from(c: WorkflowCommand) -> result::Result<Self, Self::Error> {
+        match c.variant.ok_or(EmptyWorkflowCommandErr)? {
+            workflow_command::Variant::StartTimer(s) => Ok(Self::AddTimer(s)),
+            workflow_command::Variant::CancelTimer(s) => Ok(Self::CancelTimer(s)),
+            workflow_command::Variant::ScheduleActivity(s) => Ok(Self::AddActivity(s)),
+            workflow_command::Variant::RequestCancelActivity(s) => {
+                Ok(Self::RequestCancelActivity(s))
+            }
+            workflow_command::Variant::CompleteWorkflowExecution(c) => {
+                Ok(Self::CompleteWorkflow(c))
+            }
+            workflow_command::Variant::FailWorkflowExecution(s) => Ok(Self::FailWorkflow(s)),
+            workflow_command::Variant::RespondToQuery(s) => Ok(Self::QueryResponse(s)),
+            workflow_command::Variant::ContinueAsNewWorkflowExecution(s) => {
+                Ok(Self::ContinueAsNew(s))
+            }
+            workflow_command::Variant::CancelWorkflowExecution(s) => Ok(Self::CancelWorkflow(s)),
+            workflow_command::Variant::SetPatchMarker(s) => Ok(Self::SetPatchMarker(s)),
+            workflow_command::Variant::StartChildWorkflowExecution(s) => {
+                Ok(Self::AddChildWorkflow(s))
+            }
+            workflow_command::Variant::RequestCancelExternalWorkflowExecution(s) => {
+                Ok(Self::RequestCancelExternalWorkflow(s))
+            }
+            workflow_command::Variant::SignalExternalWorkflowExecution(s) => {
+                Ok(Self::SignalExternalWorkflow(s))
+            }
+            workflow_command::Variant::CancelSignalWorkflow(s) => Ok(Self::CancelSignalWorkflow(s)),
+            workflow_command::Variant::CancelUnstartedChildWorkflowExecution(s) => {
+                Ok(Self::CancelUnstartedChild(s))
+            }
+            workflow_command::Variant::ScheduleLocalActivity(s) => Ok(Self::AddLocalActivity(s)),
+            workflow_command::Variant::RequestCancelLocalActivity(s) => {
+                Ok(Self::RequestCancelLocalActivity(s))
+            }
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
+enum CommandID {
+    Timer(u32),
+    Activity(u32),
+    LocalActivity(u32),
+    ChildWorkflowStart(u32),
+    SignalExternal(u32),
+    CancelExternal(u32),
+}
+
 #[cfg(test)]
 pub mod managed_wf {
     use super::*;
     use crate::{
-        machines::WFCommand,
-        prototype_rust_sdk::{WorkflowFunction, WorkflowResult},
-        test_help::{TestHistoryBuilder, TEST_Q},
-        workflow::WorkflowFetcher,
+        replay::TestHistoryBuilder,
+        test_help::TEST_Q,
+        workflow::{history_update::TestHBExt, WFCommand, WorkflowFetcher},
     };
-    use std::convert::TryInto;
+    use std::{convert::TryInto, time::Duration};
+    use temporal_sdk::{WorkflowFunction, WorkflowResult};
     use temporal_sdk_core_protos::coresdk::{
+        activity_result::ActivityExecutionResult,
         common::Payload,
-        workflow_activation::create_evict_activation,
-        workflow_completion::{wf_activation_completion::Status, WfActivationCompletion},
+        workflow_activation::{create_evict_activation, remove_from_cache::EvictionReason},
+        workflow_completion::{
+            workflow_activation_completion::Status, WorkflowActivationCompletion,
+        },
     };
     use tokio::{
         sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender},
@@ -167,13 +291,14 @@ pub mod managed_wf {
     };
 
     pub(crate) struct WFFutureDriver {
-        completions_rx: UnboundedReceiver<WfActivationCompletion>,
+        completions_rx: UnboundedReceiver<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 {
+                debug!("Managed wf completion: {}", completion);
                 completion
                     .status
                     .map(|s| match s {
@@ -195,7 +320,7 @@ pub mod managed_wf {
     #[must_use]
     pub struct ManagedWFFunc {
         mgr: WorkflowManager,
-        activation_tx: UnboundedSender<WfActivation>,
+        activation_tx: UnboundedSender<WorkflowActivation>,
         future_handle: Option<JoinHandle<WorkflowResult<()>>>,
         was_shutdown: bool,
     }
@@ -222,6 +347,7 @@ pub mod managed_wf {
             let state_machines = WorkflowMachines::new(
                 "test_namespace".to_string(),
                 "wfid".to_string(),
+                "wftype".to_string(),
                 "runid".to_string(),
                 hist,
                 Box::new(driver).into(),
@@ -236,33 +362,62 @@ pub mod managed_wf {
             }
         }
 
-        pub(crate) async fn get_next_activation(&mut self) -> Result<WfActivation> {
+        #[instrument(level = "debug", skip(self))]
+        pub(crate) async fn get_next_activation(&mut self) -> Result<WorkflowActivation> {
             let res = self.mgr.get_next_activation().await?;
             debug!("Managed wf next activation: {}", &res);
-            if res.jobs.is_empty() {
-                // Nothing to do here
-                return Ok(res);
-            }
-            self.push_activation_to_wf(res.clone()).await?;
+            self.push_activation_to_wf(&res).await?;
             Ok(res)
         }
 
         /// Return outgoing server commands as of the last iteration
-        pub(crate) async fn get_server_commands(&mut self) -> OutgoingServerCommands {
+        pub(crate) fn get_server_commands(&mut self) -> OutgoingServerCommands {
             self.mgr.get_server_commands()
         }
 
+        pub(crate) fn drain_queued_local_activities(&mut self) -> Vec<LocalActRequest> {
+            self.mgr.drain_queued_local_activities()
+        }
+
         /// Feed new history, as if received a new poll result. Returns new activation
-        pub(crate) async fn new_history(&mut self, update: HistoryUpdate) -> Result<WfActivation> {
+        #[instrument(level = "debug", 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?;
-            self.push_activation_to_wf(res.clone()).await?;
+            self.push_activation_to_wf(&res).await?;
             Ok(res)
         }
 
+        /// Say a local activity completed (they always take 1 second in these tests)
+        pub(crate) fn complete_local_activity(
+            &mut self,
+            seq_num: u32,
+            result: ActivityExecutionResult,
+        ) -> Result<()> {
+            self.mgr
+                .notify_of_local_result(LocalResolution::LocalActivity(LocalActivityResolution {
+                    seq: seq_num,
+                    // We accept normal execution results and do this conversion because there
+                    // are more helpers for constructing them.
+                    result: result
+                        .status
+                        .expect("LA result must have a status")
+                        .try_into()
+                        .expect("LA execution result must be a valid LA result"),
+                    runtime: Duration::from_secs(1),
+                    attempt: 1,
+                    backoff: None,
+                    // Tests at this level don't use the LA dispatcher, so this is irrelevant
+                    original_schedule_time: None,
+                }))
+        }
+
         /// During testing it can be useful to run through all activations to simulate replay
         /// easily. Returns the last produced activation with jobs in it, or an activation with no
         /// jobs if the first call had no jobs.
-        pub(crate) async fn process_all_activations(&mut self) -> Result<WfActivation> {
+        pub(crate) async fn process_all_activations(&mut self) -> Result<WorkflowActivation> {
             let mut last_act = self.get_next_activation().await?;
             let mut next_act = self.get_next_activation().await?;
             while !next_act.jobs.is_empty() {
@@ -278,13 +433,19 @@ pub mod managed_wf {
             let _ = self.activation_tx.send(create_evict_activation(
                 "not actually important".to_string(),
                 "force shutdown".to_string(),
+                EvictionReason::Unspecified,
             ));
             self.future_handle.take().unwrap().await.unwrap()
         }
 
-        async fn push_activation_to_wf(&mut self, res: WfActivation) -> Result<()> {
+        #[instrument(level = "debug", skip(self, res))]
+        async fn push_activation_to_wf(&mut self, res: &WorkflowActivation) -> Result<()> {
+            if res.jobs.is_empty() {
+                // Nothing to do here
+                return Ok(());
+            }
             self.activation_tx
-                .send(res)
+                .send(res.clone())
                 .expect("Workflow should not be dropped if we are still sending activations");
             self.mgr.machines.iterate_machines().await?;
             Ok(())

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

@@ -1,9 +1,8 @@
 use crate::{
-    errors::WorkflowMissingError,
     protosext::ValidPollWFTQResponse,
     telemetry::metrics::{workflow_type, MetricsContext},
     workflow::{
-        workflow_tasks::{OutstandingActivation, OutstandingTask},
+        workflow_tasks::{OutstandingActivation, OutstandingTask, WorkflowMissingError},
         HistoryUpdate, Result, WFMachinesError, WorkflowManager,
     },
 };
@@ -14,7 +13,7 @@ use std::{
     fmt::Debug,
     ops::{Deref, DerefMut},
 };
-use temporal_sdk_core_protos::coresdk::workflow_activation::WfActivation;
+use temporal_sdk_core_protos::coresdk::workflow_activation::WorkflowActivation;
 
 /// Provides a thread-safe way to access workflow machines for specific workflow runs
 pub(crate) struct WorkflowConcurrencyManager {
@@ -151,7 +150,23 @@ impl WorkflowConcurrencyManager {
     }
 
     /// Indicate it's finished and remove any outstanding workflow task associated with the run
-    pub fn complete_wft(&self, run_id: &str) -> Option<OutstandingTask> {
+    pub fn complete_wft(
+        &self,
+        run_id: &str,
+        send_wft_complete_to_srv: bool,
+    ) -> Option<OutstandingTask> {
+        // If the WFT completion wasn't sent to the server, but we did see the final event, we still
+        // want to clear the workflow task. This can really only happen in replay testing, where we
+        // will generate poll responses with complete history but no attached query, and such a WFT
+        // would never really exist. The server wouldn't send a workflow task with nothing to do,
+        // but they are very useful for testing complete replay.
+        let saw_final = self
+            .access_sync(run_id, |wfm| wfm.machines.have_seen_terminal_event)
+            .unwrap_or_default();
+        if !saw_final && !send_wft_complete_to_srv {
+            return None;
+        }
+
         let retme = if let Ok(ot) = self.get_task_mut(run_id).as_deref_mut() {
             (*ot).take()
         } else {
@@ -201,7 +216,7 @@ impl WorkflowConcurrencyManager {
         namespace: &str,
         wf_type: &str,
         parent_metrics: &MetricsContext,
-    ) -> Result<WfActivation> {
+    ) -> Result<WorkflowActivation> {
         let span = debug_span!("create_or_update machines", %run_id);
 
         if self.runs.read().contains_key(run_id) {
@@ -224,6 +239,7 @@ impl WorkflowConcurrencyManager {
                 history,
                 namespace.to_owned(),
                 workflow_id.to_owned(),
+                wf_type.to_owned(),
                 run_id.to_owned(),
                 metrics.clone(),
             );
@@ -263,6 +279,23 @@ impl WorkflowConcurrencyManager {
         res
     }
 
+    pub fn access_sync<F, Fout>(
+        &self,
+        run_id: &str,
+        mutator: F,
+    ) -> Result<Fout, WorkflowMissingError>
+    where
+        F: for<'a> FnOnce(&'a mut WorkflowManager) -> Fout,
+        Fout: Send + Debug,
+    {
+        let readlock = self.runs.read();
+        let m = readlock.get(run_id).ok_or_else(|| WorkflowMissingError {
+            run_id: run_id.to_string(),
+        })?;
+        let mut wfm_mutex = m.wfm.lock();
+        Ok(mutator(&mut wfm_mutex))
+    }
+
     /// Remove the workflow with the provided run id from management
     pub fn evict(&self, run_id: &str) -> Option<ValidPollWFTQResponse> {
         let val = self.runs.write().remove(run_id);