@temporalio/core-bridge 1.1.0 → 1.4.0

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

@@ -25,8 +25,8 @@ use crate::{
     },
     worker::{
         activities::{DispatchOrTimeoutLA, LACompleteAction, LocalActivityManager},
-        client::{should_swallow_net_error, WorkerClientBag},
-        workflow::{LocalResolution, Workflows},
+        client::WorkerClient,
+        workflow::{LocalResolution, WorkflowBasics, Workflows},
     },
     ActivityHeartbeat, CompleteActivityError, PollActivityError, PollWfError, WorkerTrait,
 };
@@ -50,14 +50,10 @@ use temporal_sdk_core_protos::{
 };
 use tokio_util::sync::CancellationToken;
 
-#[cfg(test)]
-use crate::worker::client::WorkerClient;
-use crate::worker::workflow::WorkflowBasics;
-
 /// A worker polls on a certain task queue
 pub struct Worker {
     config: WorkerConfig,
-    wf_client: Arc<WorkerClientBag>,
+    wf_client: Arc<dyn WorkerClient>,
 
     /// Manages all workflows and WFT processing
     workflows: Workflows,
@@ -156,7 +152,7 @@ impl Worker {
     pub(crate) fn new(
         config: WorkerConfig,
         sticky_queue_name: Option<String>,
-        client: Arc<WorkerClientBag>,
+        client: Arc<dyn WorkerClient>,
         metrics: MetricsContext,
     ) -> Self {
         info!(task_queue = %config.task_queue, "Initializing worker");
@@ -228,13 +224,13 @@ impl Worker {
 
     #[cfg(test)]
     pub(crate) fn new_test(config: WorkerConfig, client: impl WorkerClient + 'static) -> Self {
-        Self::new(config, None, Arc::new(client.into()), Default::default())
+        Self::new(config, None, Arc::new(client), Default::default())
     }
 
     pub(crate) fn new_with_pollers(
         config: WorkerConfig,
         sticky_queue_name: Option<String>,
-        client: Arc<WorkerClientBag>,
+        client: Arc<dyn WorkerClient>,
         wft_stream: impl Stream<Item = Result<ValidPollWFTQResponse, tonic::Status>> + Send + 'static,
         act_poller: Option<BoxedActPoller>,
         metrics: MetricsContext,
@@ -266,6 +262,8 @@ impl Worker {
                     max_outstanding_wfts: config.max_outstanding_workflow_tasks,
                     shutdown_token: shutdown_token.child_token(),
                     metrics,
+                    namespace: config.namespace.clone(),
+                    task_queue: config.task_queue.clone(),
                 },
                 sticky_queue_name.map(|sq| StickyExecutionAttributes {
                     worker_task_queue: Some(TaskQueue {
@@ -273,7 +271,10 @@ impl Worker {
                         kind: TaskQueueKind::Sticky as i32,
                     }),
                     schedule_to_start_timeout: Some(
-                        config.sticky_queue_schedule_to_start_timeout.into(),
+                        config
+                            .sticky_queue_schedule_to_start_timeout
+                            .try_into()
+                            .expect("timeout fits into proto"),
                     ),
                 }),
                 client,
@@ -422,20 +423,14 @@ impl Worker {
         }
 
         if let Some(atm) = &self.at_task_mgr {
-            match atm.complete(task_token, status, &**self.wf_client).await {
-                Err(CompleteActivityError::TonicError(e)) if should_swallow_net_error(&e) => {
-                    warn!(error=?e, "Network error while completing activity");
-                    Ok(())
-                }
-                o => o,
-            }
+            atm.complete(task_token, status, &*self.wf_client).await;
         } else {
             error!(
                 "Tried to complete activity {} on a worker that does not have an activity manager",
                 task_token
             );
-            Ok(())
         }
+        Ok(())
     }
 
     #[instrument(level = "debug", skip(self), fields(run_id))]

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

@@ -45,6 +45,9 @@ impl DrivenWorkflow {
                 .workflow_execution_timeout
                 .clone()
                 .try_into_or_none(),
+            memo: attribs.memo.clone(),
+            search_attrs: attribs.search_attributes.clone(),
+            retry_policy: attribs.retry_policy.clone(),
         };
         self.send_job(start_workflow_from_attribs(attribs, workflow_id, randomness_seed).into());
         self.started_attrs = Some(started_info);

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

@@ -1,6 +1,6 @@
 use crate::{
     replay::{HistoryInfo, TestHistoryBuilder},
-    worker::client::WorkerClientBag,
+    worker::client::WorkerClient,
 };
 use futures::{future::BoxFuture, stream, stream::BoxStream, FutureExt, Stream, StreamExt};
 use std::{
@@ -42,7 +42,7 @@ impl Debug for HistoryUpdate {
 
 pub struct HistoryPaginator {
     // Potentially this could actually be a ref w/ lifetime here
-    client: Arc<WorkerClientBag>,
+    client: Arc<dyn WorkerClient>,
     event_queue: VecDeque<HistoryEvent>,
     wf_id: String,
     run_id: String,
@@ -82,7 +82,7 @@ impl HistoryPaginator {
         wf_id: String,
         run_id: String,
         next_page_token: impl Into<NextPageToken>,
-        client: Arc<WorkerClientBag>,
+        client: Arc<dyn WorkerClient>,
     ) -> Self {
         let next_page_token = next_page_token.into();
         let (event_queue, final_events) =
@@ -397,7 +397,7 @@ pub mod tests {
                 "wfid".to_string(),
                 "runid".to_string(),
                 vec![2], // Start at page "2"
-                Arc::new(mock_client.into()),
+                Arc::new(mock_client),
             ),
             prev_started,
         );
@@ -442,7 +442,7 @@ pub mod tests {
                 "runid".to_string(),
                 // A cache miss means we'll try to fetch from start
                 NextPageToken::FetchFromStart,
-                Arc::new(mock_client.into()),
+                Arc::new(mock_client),
             ),
             1,
         );

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

@@ -7,7 +7,8 @@ use std::convert::{TryFrom, TryInto};
 use temporal_sdk_core_protos::{
     coresdk::{
         child_workflow::{
-            self as wfr, child_workflow_result::Status as ChildWorkflowStatus, ChildWorkflowResult,
+            self as wfr, child_workflow_result::Status as ChildWorkflowStatus,
+            ChildWorkflowCancellationType, ChildWorkflowResult,
         },
         workflow_activation::{
             resolve_child_workflow_execution_start, ResolveChildWorkflowExecution,
@@ -17,7 +18,7 @@ use temporal_sdk_core_protos::{
         workflow_commands::StartChildWorkflowExecution,
     },
     temporal::api::{
-        command::v1::Command,
+        command::v1::{Command, RequestCancelExternalWorkflowExecutionCommandAttributes},
         common::v1::{Payload, Payloads, WorkflowExecution, WorkflowType},
         enums::v1::{
             CommandType, EventType, RetryState, StartChildWorkflowExecutionFailedCause, TimeoutType,
@@ -26,8 +27,7 @@ use temporal_sdk_core_protos::{
         history::v1::{
             history_event, ChildWorkflowExecutionCompletedEventAttributes,
             ChildWorkflowExecutionFailedEventAttributes,
-            ChildWorkflowExecutionStartedEventAttributes,
-            ChildWorkflowExecutionTimedOutEventAttributes, HistoryEvent,
+            ChildWorkflowExecutionStartedEventAttributes, HistoryEvent,
             StartChildWorkflowExecutionFailedEventAttributes,
         },
     },
@@ -41,17 +41,32 @@ fsm! {
 
     Created --(Schedule, on_schedule) --> StartCommandCreated;
     StartCommandCreated --(CommandStartChildWorkflowExecution) --> StartCommandCreated;
-    StartCommandCreated --(StartChildWorkflowExecutionInitiated(i64), shared on_start_child_workflow_execution_initiated) --> StartEventRecorded;
+    StartCommandCreated --(StartChildWorkflowExecutionInitiated(i64),
+        shared on_start_child_workflow_execution_initiated) --> StartEventRecorded;
     StartCommandCreated --(Cancel, shared on_cancelled) --> Cancelled;
 
-    StartEventRecorded --(ChildWorkflowExecutionStarted(ChildWorkflowExecutionStartedEvent), shared on_child_workflow_execution_started) --> Started;
-    StartEventRecorded --(StartChildWorkflowExecutionFailed(StartChildWorkflowExecutionFailedCause), on_start_child_workflow_execution_failed) --> StartFailed;
-
-    Started --(ChildWorkflowExecutionCompleted(Option<Payloads>), on_child_workflow_execution_completed) --> Completed;
-    Started --(ChildWorkflowExecutionFailed(ChildWorkflowExecutionFailedEventAttributes), shared on_child_workflow_execution_failed) --> Failed;
-    Started --(ChildWorkflowExecutionTimedOut(i32), shared on_child_workflow_execution_timed_out) --> TimedOut;
-    Started --(ChildWorkflowExecutionCancelled, shared on_child_workflow_execution_cancelled) --> Cancelled;
-    Started --(ChildWorkflowExecutionTerminated, shared on_child_workflow_execution_terminated) --> Terminated;
+    StartEventRecorded --(ChildWorkflowExecutionStarted(ChildWorkflowExecutionStartedEvent),
+        shared on_child_workflow_execution_started) --> Started;
+    StartEventRecorded --(StartChildWorkflowExecutionFailed(StartChildWorkflowExecutionFailedCause),
+        on_start_child_workflow_execution_failed) --> StartFailed;
+
+    Started --(ChildWorkflowExecutionCompleted(Option<Payloads>),
+        on_child_workflow_execution_completed) --> Completed;
+    Started --(ChildWorkflowExecutionFailed(ChildWorkflowExecutionFailedEventAttributes),
+        shared on_child_workflow_execution_failed) --> Failed;
+    Started --(ChildWorkflowExecutionTimedOut(RetryState),
+        shared on_child_workflow_execution_timed_out) --> TimedOut;
+    Started --(ChildWorkflowExecutionCancelled,
+        on_child_workflow_execution_cancelled) --> Cancelled;
+    Started --(ChildWorkflowExecutionTerminated,
+        shared on_child_workflow_execution_terminated) --> Terminated;
+    // If cancelled after started, we need to issue a cancel external workflow command, and then
+    // the child workflow will resolve somehow, so we want to go back to started and wait for that
+    // resolution.
+    Started --(Cancel, shared on_cancelled) --> Started;
+    // Abandon & try cancel modes may immediately move to cancelled
+    Started --(Cancel, shared on_cancelled) --> Cancelled;
+    Started --(CommandRequestCancelExternalWorkflowExecution) --> Started;
 
     // Ignore any spurious cancellations after resolution
     Cancelled --(Cancel) --> Cancelled;
@@ -74,11 +89,13 @@ pub(super) enum ChildWorkflowCommand {
     #[display(fmt = "Fail")]
     Fail(Failure),
     #[display(fmt = "Cancel")]
-    Cancel(Failure),
+    Cancel,
     #[display(fmt = "StartFail")]
     StartFail(StartChildWorkflowExecutionFailedCause),
     #[display(fmt = "StartCancel")]
     StartCancel(Failure),
+    #[display(fmt = "CancelAfterStarted")]
+    IssueCancelAfterStarted { reason: String },
 }
 
 #[derive(Default, Clone)]
@@ -137,10 +154,7 @@ impl StartCommandCreated {
                     )),
                     ..Default::default()
                 })),
-                failure_info: failure_info_from_state(
-                    state.clone(),
-                    RetryState::NonRetryableFailure as i32,
-                ),
+                failure_info: failure_info_from_state(&state, RetryState::NonRetryableFailure),
                 ..Default::default()
             })],
             Cancelled::default(),
@@ -188,7 +202,7 @@ pub(super) struct StartFailed {}
 pub(super) struct Started {}
 
 impl Started {
-    pub(super) fn on_child_workflow_execution_completed(
+    fn on_child_workflow_execution_completed(
         self,
         result: Option<Payloads>,
     ) -> ChildWorkflowMachineTransition<Completed> {
@@ -197,7 +211,7 @@ impl Started {
             Completed::default(),
         )
     }
-    pub(super) fn on_child_workflow_execution_failed(
+    fn on_child_workflow_execution_failed(
         self,
         state: SharedState,
         attrs: ChildWorkflowExecutionFailedEventAttributes,
@@ -205,17 +219,17 @@ impl Started {
         ChildWorkflowMachineTransition::ok(
             vec![ChildWorkflowCommand::Fail(Failure {
                 message: "Child Workflow execution failed".to_owned(),
+                failure_info: failure_info_from_state(&state, attrs.retry_state()),
                 cause: attrs.failure.map(Box::new),
-                failure_info: failure_info_from_state(state, attrs.retry_state),
                 ..Default::default()
             })],
             Failed::default(),
         )
     }
-    pub(super) fn on_child_workflow_execution_timed_out(
+    fn on_child_workflow_execution_timed_out(
         self,
         state: SharedState,
-        retry_state: i32,
+        retry_state: RetryState,
     ) -> ChildWorkflowMachineTransition<TimedOut> {
         ChildWorkflowMachineTransition::ok(
             vec![ChildWorkflowCommand::Fail(Failure {
@@ -230,37 +244,16 @@ impl Started {
                     )),
                     ..Default::default()
                 })),
-                failure_info: failure_info_from_state(state, retry_state),
+                failure_info: failure_info_from_state(&state, retry_state),
                 ..Default::default()
             })],
             TimedOut::default(),
         )
     }
-    pub(super) fn on_child_workflow_execution_cancelled(
-        self,
-        state: SharedState,
-    ) -> ChildWorkflowMachineTransition<Cancelled> {
-        ChildWorkflowMachineTransition::ok(
-            vec![ChildWorkflowCommand::Cancel(Failure {
-                message: "Child Workflow execution cancelled".to_owned(),
-                cause: Some(Box::new(Failure {
-                    failure_info: Some(FailureInfo::CanceledFailureInfo(
-                        failure::CanceledFailureInfo {
-                            ..Default::default()
-                        },
-                    )),
-                    ..Default::default()
-                })),
-                failure_info: failure_info_from_state(
-                    state,
-                    RetryState::NonRetryableFailure as i32,
-                ),
-                ..Default::default()
-            })],
-            Cancelled::default(),
-        )
+    fn on_child_workflow_execution_cancelled(self) -> ChildWorkflowMachineTransition<Cancelled> {
+        ChildWorkflowMachineTransition::ok(vec![ChildWorkflowCommand::Cancel], Cancelled::default())
     }
-    pub(super) fn on_child_workflow_execution_terminated(
+    fn on_child_workflow_execution_terminated(
         self,
         state: SharedState,
     ) -> ChildWorkflowMachineTransition<Terminated> {
@@ -274,15 +267,29 @@ impl Started {
                     )),
                     ..Default::default()
                 })),
-                failure_info: failure_info_from_state(
-                    state,
-                    RetryState::NonRetryableFailure as i32,
-                ),
+                failure_info: failure_info_from_state(&state, RetryState::NonRetryableFailure),
                 ..Default::default()
             })],
             Terminated::default(),
         )
     }
+    fn on_cancelled(
+        self,
+        state: SharedState,
+    ) -> ChildWorkflowMachineTransition<StartedOrCancelled> {
+        let dest = match state.cancel_type {
+            ChildWorkflowCancellationType::Abandon | ChildWorkflowCancellationType::TryCancel => {
+                StartedOrCancelled::Cancelled(Default::default())
+            }
+            _ => StartedOrCancelled::Started(Default::default()),
+        };
+        TransitionResult::ok(
+            [ChildWorkflowCommand::IssueCancelAfterStarted {
+                reason: "Parent workflow requested cancel".to_string(),
+            }],
+            dest,
+        )
+    }
 }
 
 #[derive(Default, Clone)]
@@ -301,6 +308,7 @@ pub(super) struct SharedState {
     run_id: String,
     workflow_type: String,
     cancelled_before_sent: bool,
+    cancel_type: ChildWorkflowCancellationType,
 }
 
 /// Creates a new child workflow state machine and a command to start it on the server.
@@ -322,6 +330,7 @@ impl ChildWorkflowMachine {
                 workflow_id: attribs.workflow_id.clone(),
                 workflow_type: attribs.workflow_type.clone(),
                 namespace: attribs.namespace.clone(),
+                cancel_type: attribs.cancellation_type(),
                 ..Default::default()
             },
         };
@@ -333,6 +342,33 @@ impl ChildWorkflowMachine {
         };
         (s, cmd)
     }
+
+    fn resolve_cancelled_msg(&self) -> ResolveChildWorkflowExecution {
+        let failure = Failure {
+            message: "Child Workflow execution cancelled".to_owned(),
+            cause: Some(Box::new(Failure {
+                failure_info: Some(FailureInfo::CanceledFailureInfo(
+                    failure::CanceledFailureInfo {
+                        ..Default::default()
+                    },
+                )),
+                ..Default::default()
+            })),
+            failure_info: failure_info_from_state(
+                &self.shared_state,
+                RetryState::NonRetryableFailure,
+            ),
+            ..Default::default()
+        };
+        ResolveChildWorkflowExecution {
+            seq: self.shared_state.lang_sequence_number,
+            result: Some(ChildWorkflowResult {
+                status: Some(ChildWorkflowStatus::Cancelled(wfr::Cancellation {
+                    failure: Some(failure),
+                })),
+            }),
+        }
+    }
 }
 
 impl TryFrom<HistoryEvent> for ChildWorkflowMachineEvents {
@@ -415,12 +451,10 @@ impl TryFrom<HistoryEvent> for ChildWorkflowMachineEvents {
             }
             Some(EventType::ChildWorkflowExecutionTimedOut) => {
                 if let Some(
-                    history_event::Attributes::ChildWorkflowExecutionTimedOutEventAttributes(
-                        ChildWorkflowExecutionTimedOutEventAttributes { retry_state, .. },
-                    ),
+                    history_event::Attributes::ChildWorkflowExecutionTimedOutEventAttributes(atts),
                 ) = e.attributes
                 {
-                    Self::ChildWorkflowExecutionTimedOut(retry_state)
+                    Self::ChildWorkflowExecutionTimedOut(atts.retry_state())
                 } else {
                     return Err(WFMachinesError::Fatal(
                         "ChildWorkflowExecutionTimedOut attributes were unset or malformed"
@@ -435,9 +469,10 @@ impl TryFrom<HistoryEvent> for ChildWorkflowMachineEvents {
                 Self::ChildWorkflowExecutionCancelled
             }
             _ => {
-                return Err(WFMachinesError::Fatal(
-                    "Child workflow machine does not handle this event".to_string(),
-                ))
+                return Err(WFMachinesError::Fatal(format!(
+                    "Child workflow machine does not handle this event: {:?}",
+                    e
+                )))
             }
         })
     }
@@ -505,16 +540,33 @@ impl WFMachinesAdapter for ChildWorkflowMachine {
                 }
                 .into()]
             }
-            ChildWorkflowCommand::Cancel(failure) => {
-                vec![ResolveChildWorkflowExecution {
-                    seq: self.shared_state.lang_sequence_number,
-                    result: Some(ChildWorkflowResult {
-                        status: Some(ChildWorkflowStatus::Cancelled(wfr::Cancellation {
-                            failure: Some(failure),
-                        })),
-                    }),
+            ChildWorkflowCommand::Cancel => {
+                vec![self.resolve_cancelled_msg().into()]
+            }
+            ChildWorkflowCommand::IssueCancelAfterStarted { reason } => {
+                let mut resps = vec![];
+                if self.shared_state.cancel_type != ChildWorkflowCancellationType::Abandon {
+                    resps.push(MachineResponse::NewCoreOriginatedCommand(
+                        RequestCancelExternalWorkflowExecutionCommandAttributes {
+                            namespace: self.shared_state.namespace.clone(),
+                            workflow_id: self.shared_state.workflow_id.clone(),
+                            run_id: self.shared_state.run_id.clone(),
+                            child_workflow_only: true,
+                            reason,
+                            control: "".to_string(),
+                        }
+                        .into(),
+                    ))
                 }
-                .into()]
+                // Immediately resolve abandon/trycancel modes
+                if matches!(
+                    self.shared_state.cancel_type,
+                    ChildWorkflowCancellationType::Abandon
+                        | ChildWorkflowCancellationType::TryCancel
+                ) {
+                    resps.push(self.resolve_cancelled_msg().into())
+                }
+                resps
             }
         })
     }
@@ -544,34 +596,30 @@ impl TryFrom<CommandType> for ChildWorkflowMachineEvents {
     fn try_from(c: CommandType) -> Result<Self, Self::Error> {
         Ok(match c {
             CommandType::StartChildWorkflowExecution => Self::CommandStartChildWorkflowExecution,
+            CommandType::RequestCancelExternalWorkflowExecution => {
+                Self::CommandRequestCancelExternalWorkflowExecution
+            }
             _ => return Err(()),
         })
     }
 }
 
-/// Cancellation through this machine is valid only when start child workflow command is not sent
-/// yet. Cancellation of an initiated child workflow is done through CancelExternal.
-/// All of the types besides ABANDON are treated differently.
 impl Cancellable for ChildWorkflowMachine {
     fn cancel(&mut self) -> Result<Vec<MachineResponse>, MachineError<Self::Error>> {
         let event = ChildWorkflowMachineEvents::Cancel;
         let vec = OnEventWrapper::on_event_mut(self, event)?;
         let res = vec
             .into_iter()
-            .flat_map(|mc| match mc {
-                ChildWorkflowCommand::StartCancel(failure) => {
-                    vec![ResolveChildWorkflowExecutionStart {
-                        seq: self.shared_state.lang_sequence_number,
-                        status: Some(resolve_child_workflow_execution_start::Status::Cancelled(
-                            ResolveChildWorkflowExecutionStartCancelled {
-                                failure: Some(failure),
-                            },
-                        )),
-                    }
-                    .into()]
+            .map(|mc| match mc {
+                c @ ChildWorkflowCommand::StartCancel(_)
+                | c @ ChildWorkflowCommand::IssueCancelAfterStarted { .. } => {
+                    self.adapt_response(c, None)
                 }
                 x => panic!("Invalid cancel event response {:?}", x),
             })
+            .collect::<Result<Vec<_>, _>>()?
+            .into_iter()
+            .flatten()
             .collect();
         Ok(res)
     }
@@ -581,7 +629,7 @@ impl Cancellable for ChildWorkflowMachine {
     }
 }
 
-fn failure_info_from_state(state: SharedState, retry_state: i32) -> Option<FailureInfo> {
+fn failure_info_from_state(state: &SharedState, retry_state: RetryState) -> Option<FailureInfo> {
     Some(FailureInfo::ChildWorkflowExecutionFailureInfo(
         failure::ChildWorkflowExecutionFailureInfo {
             namespace: state.namespace.clone(),
@@ -590,10 +638,10 @@ fn failure_info_from_state(state: SharedState, retry_state: i32) -> Option<Failu
             }),
             initiated_event_id: state.initiated_event_id,
             started_event_id: state.started_event_id,
-            retry_state,
+            retry_state: retry_state as i32,
             workflow_execution: Some(WorkflowExecution {
                 workflow_id: state.workflow_id.clone(),
-                run_id: state.run_id,
+                run_id: state.run_id.clone(),
             }),
         },
     ))

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

@@ -160,8 +160,9 @@ where
             }
         } else {
             Err(WFMachinesError::Nondeterminism(format!(
-                "Unexpected command {:?}",
-                command_type
+                "Unexpected command {:?} generated by a {:?} machine",
+                command_type,
+                self.kind()
             )))
         }
     }