@temporalio/core-bridge 1.8.6 → 1.9.0

package/sdk-core/{protos → sdk-core-protos/protos}/local/temporal/sdk/core/workflow_commands/workflow_commands.proto

@@ -10,6 +10,7 @@ option ruby_package = "Temporalio::Bridge::Api::WorkflowCommands";
 
 import "google/protobuf/duration.proto";
 import "google/protobuf/timestamp.proto";
+import "google/protobuf/empty.proto";
 import "temporal/api/common/v1/message.proto";
 import "temporal/api/enums/v1/workflow.proto";
 import "temporal/api/failure/v1/message.proto";
@@ -37,6 +38,7 @@ message WorkflowCommand {
         RequestCancelLocalActivity request_cancel_local_activity = 17;
         UpsertWorkflowSearchAttributes upsert_workflow_search_attributes = 18;
         ModifyWorkflowProperties modify_workflow_properties = 19;
+        UpdateResponse update_response = 20;
     }
 }
 
@@ -309,3 +311,28 @@ message ModifyWorkflowProperties {
     // used as the value for the key being deleted.
     temporal.api.common.v1.Memo upserted_memo = 1;
 }
+
+// A reply to a `DoUpdate` job - lang must run the update's validator if told to, and then
+// immediately run the handler, if the update was accepted.
+//
+// There must always be an accepted or rejected response immediately, in the same activation as
+// this job, to indicate the result of the validator. Accepted for ran and accepted or skipped, or
+// rejected for rejected.
+//
+// Then, in the same or any subsequent activation, after the update handler has completed, respond
+// with completed or rejected as appropriate for the result of the handler.
+message UpdateResponse {
+    // The protocol message instance ID
+    string protocol_instance_id = 1;
+    oneof response {
+        // Must be sent if the update's validator has passed (or lang was not asked to run it, and
+        // thus should be considered already-accepted, allowing lang to always send the same
+        // sequence on replay).
+        google.protobuf.Empty accepted = 2;
+        // Must be sent if the update's validator does not pass, or after acceptance if the update
+        // handler fails.
+        temporal.api.failure.v1.Failure rejected = 3;
+        // Must be sent once the update handler completes successfully.
+        temporal.api.common.v1.Payload completed = 4;
+    }
+}

package/sdk-core/sdk-core-protos/src/history_builder.rs

@@ -17,6 +17,8 @@ use crate::{
         failure::v1::{failure, CanceledFailureInfo, Failure},
         history::v1::{history_event::Attributes, *},
         taskqueue::v1::TaskQueue,
+        update,
+        update::v1::outcome,
     },
     HistoryInfo,
 };
@@ -433,7 +435,55 @@ impl TestHistoryBuilder {
             workflow_task_completed_event_id: self.previous_task_completed_id,
             search_attributes: Some(SearchAttributes { indexed_fields }),
         };
-        self.build_and_push_event(EventType::UpsertWorkflowSearchAttributes, attrs.into())
+        self.build_and_push_event(EventType::UpsertWorkflowSearchAttributes, attrs.into());
+    }
+
+    pub fn add_update_accepted(
+        &mut self,
+        instance_id: impl Into<String>,
+        update_name: impl Into<String>,
+    ) -> i64 {
+        let protocol_instance_id = instance_id.into();
+        let last_wft_started_id = self
+            .events
+            .iter()
+            .rev()
+            .find_map(|e| {
+                if e.event_type() == EventType::WorkflowTaskScheduled {
+                    Some(e.event_id)
+                } else {
+                    None
+                }
+            })
+            .expect("Must have wft scheduled event");
+        let attrs = WorkflowExecutionUpdateAcceptedEventAttributes {
+            accepted_request_message_id: format!("{}/request", &protocol_instance_id),
+            accepted_request_sequencing_event_id: last_wft_started_id,
+            accepted_request: Some(update::v1::Request {
+                meta: Some(update::v1::Meta {
+                    update_id: protocol_instance_id.clone(),
+                    identity: "fake".to_string(),
+                }),
+                input: Some(update::v1::Input {
+                    header: None,
+                    name: update_name.into(),
+                    args: None,
+                }),
+            }),
+            protocol_instance_id,
+        };
+        self.build_and_push_event(EventType::WorkflowExecutionUpdateAccepted, attrs.into())
+    }
+
+    pub fn add_update_completed(&mut self, accepted_event_id: i64) {
+        let attrs = WorkflowExecutionUpdateCompletedEventAttributes {
+            meta: None,
+            accepted_event_id,
+            outcome: Some(update::v1::Outcome {
+                value: Some(outcome::Value::Success(Payloads::default())),
+            }),
+        };
+        self.build_and_push_event(EventType::WorkflowExecutionUpdateCompleted, attrs.into());
     }
 
     pub fn get_orig_run_id(&self) -> &str {
@@ -478,6 +528,15 @@ impl TestHistoryBuilder {
         }
     }
 
+    /// Alter the input to the workflow
+    pub fn set_wf_input(&mut self, input: impl Into<Payloads>) {
+        if let Some(Attributes::WorkflowExecutionStartedEventAttributes(wes)) =
+            self.events.get_mut(0).and_then(|e| e.attributes.as_mut())
+        {
+            wes.input = Some(input.into());
+        }
+    }
+
     /// Alter some specific event. You can easily craft nonsense histories this way, use carefully.
     pub fn modify_event(&mut self, event_id: i64, modifier: impl FnOnce(&mut HistoryEvent)) {
         let he = self
@@ -497,6 +556,11 @@ impl TestHistoryBuilder {
         Self::set_flags(self.events.iter_mut().rev(), core, lang)
     }
 
+    /// Get the event ID of the most recently added event
+    pub fn current_event_id(&self) -> i64 {
+        self.current_event_id
+    }
+
     fn set_flags<'a>(
         mut events: impl Iterator<Item = &'a mut HistoryEvent>,
         core: &[u32],
@@ -518,7 +582,7 @@ impl TestHistoryBuilder {
         }
     }
 
-    fn build_and_push_event(&mut self, event_type: EventType, attribs: Attributes) {
+    fn build_and_push_event(&mut self, event_type: EventType, attribs: Attributes) -> i64 {
         self.current_event_id += 1;
         let evt = HistoryEvent {
             event_type: event_type as i32,
@@ -537,6 +601,7 @@ impl TestHistoryBuilder {
             self.original_run_id = original_execution_run_id.clone();
         };
         self.events.push(evt);
+        self.current_event_id
     }
 }
 

package/sdk-core/sdk-core-protos/src/history_info.rs

@@ -37,7 +37,7 @@ impl HistoryInfo {
         let mut workflow_task_started_event_id = 0;
         let mut wf_task_count = 0;
         let mut history = events.iter().peekable();
-        let started_attrs = match &events.get(0).unwrap().attributes {
+        let started_attrs = match &events.first().unwrap().attributes {
             Some(history_event::Attributes::WorkflowExecutionStartedEventAttributes(attrs)) => {
                 attrs.clone()
             }

package/sdk-core/sdk-core-protos/src/lib.rs

@@ -24,7 +24,11 @@ pub static ENCODING_PAYLOAD_KEY: &str = "encoding";
 pub static JSON_ENCODING_VAL: &str = "json/plain";
 pub static PATCHED_MARKER_DETAILS_KEY: &str = "patch-data";
 
-#[allow(clippy::large_enum_variant, clippy::derive_partial_eq_without_eq)]
+#[allow(
+    clippy::large_enum_variant,
+    clippy::derive_partial_eq_without_eq,
+    clippy::reserve_after_initialization
+)]
 // I'd prefer not to do this, but there are some generated things that just don't need it.
 #[allow(missing_docs)]
 pub mod coresdk {
@@ -68,6 +72,15 @@ pub mod coresdk {
                     })),
                 }
             }
+
+            pub fn is_timeout(&self) -> bool {
+                match &self.variant {
+                    Some(activity_task::Variant::Cancel(Cancel { reason })) => {
+                        *reason == ActivityCancelReason::TimedOut as i32
+                    }
+                    _ => false,
+                }
+            }
         }
 
         impl Display for ActivityTaskCompletion {
@@ -323,7 +336,7 @@ pub mod coresdk {
         ) -> Option<LocalActivityMarkerData> {
             details
                 .get("data")
-                .and_then(|p| p.payloads.get(0))
+                .and_then(|p| p.payloads.first())
                 .and_then(|p| std::str::from_utf8(&p.data).ok())
                 .and_then(|s| serde_json::from_str(s).ok())
         }
@@ -456,6 +469,7 @@ pub mod coresdk {
                 available_internal_flags: vec![],
                 history_size_bytes: 0,
                 continue_as_new_suggested: false,
+                build_id_for_current_task: "".to_string(),
             }
         }
 
@@ -603,6 +617,9 @@ pub mod coresdk {
                     workflow_activation_job::Variant::ResolveRequestCancelExternalWorkflow(_) => {
                         write!(f, "ResolveRequestCancelExternalWorkflow")
                     }
+                    workflow_activation_job::Variant::DoUpdate(_) => {
+                        write!(f, "DoUpdate")
+                    }
                 }
             }
         }
@@ -854,6 +871,16 @@ pub mod coresdk {
             }
         }
 
+        impl Display for UpdateResponse {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(
+                    f,
+                    "UpdateResponse(protocol_instance_id: {}, response: {:?})",
+                    self.protocol_instance_id, self.response
+                )
+            }
+        }
+
         impl QueryResult {
             /// Helper to construct the Temporal API query result types.
             pub fn into_components(self) -> (String, QueryResultType, Option<Payloads>, String) {
@@ -1452,6 +1479,14 @@ pub mod temporal {
                                 command_type: CommandType::CancelWorkflowExecution as i32,
                                 attributes: Some(a),
                             },
+                            a @ Attributes::RecordMarkerCommandAttributes(_) => Self {
+                                command_type: CommandType::RecordMarker as i32,
+                                attributes: Some(a),
+                            },
+                            a @ Attributes::ProtocolMessageCommandAttributes(_) => Self {
+                                command_type: CommandType::ProtocolMessage as i32,
+                                attributes: Some(a),
+                            },
                             _ => unimplemented!(),
                         }
                     }
@@ -1732,6 +1767,14 @@ pub mod temporal {
                         at.name
                     }
                 }
+
+                impl From<&str> for WorkflowType {
+                    fn from(v: &str) -> Self {
+                        Self {
+                            name: v.to_string(),
+                        }
+                    }
+                }
             }
         }
         pub mod enums {
@@ -1801,7 +1844,10 @@ pub mod temporal {
                             | EventType::WorkflowExecutionCanceled
                             | EventType::WorkflowExecutionCompleted
                             | EventType::WorkflowExecutionContinuedAsNew
-                            | EventType::WorkflowExecutionFailed => true,
+                            | EventType::WorkflowExecutionFailed
+                            | EventType::WorkflowExecutionUpdateAccepted
+                            | EventType::WorkflowExecutionUpdateRejected
+                            | EventType::WorkflowExecutionUpdateCompleted => true,
                             _ => false,
                         })
                     }
@@ -1844,6 +1890,16 @@ pub mod temporal {
                         })
                     }
 
+                    /// Return the event's associated protocol instance, if one exists.
+                    pub fn get_protocol_instance_id(&self) -> Option<&str> {
+                        self.attributes.as_ref().and_then(|a| match a {
+                            Attributes::WorkflowExecutionUpdateAcceptedEventAttributes(a) => {
+                                Some(a.protocol_instance_id.as_str())
+                            }
+                            _ => None,
+                        })
+                    }
+
                     /// Returns true if the event is one which would end a workflow
                     pub fn is_final_wf_execution_event(&self) -> bool {
                         match self.event_type() {
@@ -1945,7 +2001,14 @@ pub mod temporal {
         }
         pub mod protocol {
             pub mod v1 {
+                use std::fmt::{Display, Formatter};
                 tonic::include_proto!("temporal.api.protocol.v1");
+
+                impl Display for Message {
+                    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                        write!(f, "ProtocolMessage({})", self.id)
+                    }
+                }
             }
         }
         pub mod query {
@@ -1992,7 +2055,17 @@ pub mod temporal {
         }
         pub mod update {
             pub mod v1 {
+                use crate::temporal::api::update::v1::outcome::Value;
                 tonic::include_proto!("temporal.api.update.v1");
+
+                impl Outcome {
+                    pub fn is_success(&self) -> bool {
+                        match self.value {
+                            Some(Value::Success(_)) => true,
+                            _ => false,
+                        }
+                    }
+                }
             }
         }
         pub mod version {

package/sdk-core/sdk-core-protos/src/utilities.rs

@@ -1,3 +1,5 @@
+use prost::{EncodeError, Message};
+
 pub trait TryIntoOrNone<F, T> {
     /// Turn an option of something into an option of another thing, trying to convert along the way
     /// and returning `None` if that conversion fails
@@ -12,3 +14,15 @@ where
         self.map(TryInto::try_into).transpose().ok().flatten()
     }
 }
+
+/// Use to encode an message into a proto `Any`.
+///
+/// Delete this once `prost_wkt_types` supports `prost` `0.12.x` which has built-in any packing.
+pub fn pack_any<T: Message>(
+    type_url: String,
+    msg: &T,
+) -> Result<prost_wkt_types::Any, EncodeError> {
+    let mut value = Vec::new();
+    Message::encode(msg, &mut value)?;
+    Ok(prost_wkt_types::Any { type_url, value })
+}

package/sdk-core/test-utils/Cargo.toml

@@ -3,11 +3,16 @@ name = "temporal-sdk-core-test-utils"
 version = "0.1.0"
 authors = ["Spencer Judge <spencer@temporal.io>"]
 edition = "2021"
+license-file = { workspace = true }
 
 [[bin]]
 name = "histfetch"
 path = "src/histfetch.rs"
 
+[features]
+default = ["ephemeral-server"]
+ephemeral-server = ["temporal-sdk-core/ephemeral-server"]
+
 [dependencies]
 anyhow = "1.0"
 async-trait = "0.1"
@@ -24,7 +29,7 @@ rmp-serde = "1.1"
 serde_json = "1.0"
 temporal-client = { path = "../client" }
 temporal-sdk = { path = "../sdk" }
-temporal-sdk-core = { path = "../core", features = ["ephemeral-server"] }
+temporal-sdk-core = { path = "../core" }
 temporal-sdk-core-api = { path = "../core-api" }
 thiserror = "1.0"
 tokio = "1.1"

package/sdk-core/test-utils/src/canned_histories.rs

@@ -6,7 +6,7 @@ use temporal_sdk_core_protos::{
     coresdk::common::NamespacedWorkflowExecution,
     temporal::api::{
         common::v1::{Payload, WorkflowExecution},
-        enums::v1::{EventType, StartChildWorkflowExecutionFailedCause, WorkflowTaskFailedCause},
+        enums::v1::{EventType, WorkflowTaskFailedCause},
         failure::v1::Failure,
         history::v1::*,
     },
@@ -1110,6 +1110,7 @@ fn start_child_wf_preamble(child_wf_id: &str) -> (TestHistoryBuilder, i64, i64)
     t.add_full_wf_task();
     let initiated_event_id = t.add(StartChildWorkflowExecutionInitiatedEventAttributes {
         workflow_id: child_wf_id.to_owned(),
+        workflow_type: Some("child".into()),
         ..Default::default()
     });
     let started_event_id = t.add(ChildWorkflowExecutionStartedEventAttributes {
@@ -1145,7 +1146,6 @@ pub fn single_child_workflow(child_wf_id: &str) -> TestHistoryBuilder {
             ChildWorkflowExecutionCompletedEventAttributes {
                 initiated_event_id,
                 started_event_id,
-                // todo add the result payload
                 ..Default::default()
             },
         ),
@@ -1299,35 +1299,6 @@ pub fn single_child_workflow_try_cancelled(child_wf_id: &str) -> TestHistoryBuil
     t
 }
 
-///  1: EVENT_TYPE_WORKFLOW_EXECUTION_STARTED
-///  2: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
-///  3: EVENT_TYPE_WORKFLOW_TASK_STARTED
-///  4: EVENT_TYPE_WORKFLOW_TASK_COMPLETED
-///  5: EVENT_TYPE_START_CHILD_WORKFLOW_EXECUTION_INITIATED
-///  5: EVENT_TYPE_START_CHILD_WORKFLOW_EXECUTION_FAILED
-///  6: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
-///  7: EVENT_TYPE_WORKFLOW_TASK_STARTED
-///  8: EVENT_TYPE_WORKFLOW_TASK_COMPLETED
-///  9: EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED
-pub fn single_child_workflow_start_fail(child_wf_id: &str) -> TestHistoryBuilder {
-    let mut t = TestHistoryBuilder::default();
-    t.add_by_type(EventType::WorkflowExecutionStarted);
-    t.add_full_wf_task();
-    let initiated_event_id = t.add(StartChildWorkflowExecutionInitiatedEventAttributes {
-        workflow_id: child_wf_id.to_owned(),
-        ..Default::default()
-    });
-    t.add(StartChildWorkflowExecutionFailedEventAttributes {
-        workflow_id: child_wf_id.to_owned(),
-        initiated_event_id,
-        cause: StartChildWorkflowExecutionFailedCause::WorkflowAlreadyExists as i32,
-        ..Default::default()
-    });
-    t.add_full_wf_task();
-    t.add_workflow_execution_completed();
-    t
-}
-
 ///  1: EVENT_TYPE_WORKFLOW_EXECUTION_STARTED
 ///  2: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
 ///  3: EVENT_TYPE_WORKFLOW_TASK_STARTED
@@ -1346,32 +1317,7 @@ pub fn two_local_activities_one_wft(parallel: bool) -> TestHistoryBuilder {
         start_time.seconds += 1;
     }
     t.add_local_activity_result_marker_with_time(2, "2", b"hi2".into(), start_time);
-    t.add_workflow_execution_completed();
-    t
-}
-
-///  1: EVENT_TYPE_WORKFLOW_EXECUTION_STARTED
-///  2: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
-///  3: EVENT_TYPE_WORKFLOW_TASK_STARTED
-///  4: EVENT_TYPE_WORKFLOW_TASK_COMPLETED
-///  5: EVENT_TYPE_MARKER_RECORDED (la result)
-///  6: EVENT_TYPE_TIMER_STARTED
-///  7: EVENT_TYPE_TIMER_FIRED
-///  8: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
-///  9: EVENT_TYPE_WORKFLOW_TASK_STARTED
-/// 10: EVENT_TYPE_WORKFLOW_TASK_COMPLETED
-/// 11: EVENT_TYPE_MARKER_RECORDED (la result)
-/// 12: EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED
-pub fn two_local_activities_separated_by_timer() -> TestHistoryBuilder {
-    let mut t = TestHistoryBuilder::default();
-    t.add_by_type(EventType::WorkflowExecutionStarted);
-    t.add_full_wf_task();
-    t.add_local_activity_result_marker(1, "1", b"hi".into());
-    let timer_started_event_id = t.add_by_type(EventType::TimerStarted);
-    t.add_timer_fired(timer_started_event_id, "1".to_string());
-    t.add_full_wf_task();
-    t.add_local_activity_result_marker(2, "2", b"hi2".into());
-    t.add_workflow_execution_completed();
+    t.add_workflow_task_scheduled_and_started();
     t
 }
 

package/sdk-core/test-utils/src/interceptors.rs

@@ -0,0 +1,46 @@
+use anyhow::Error;
+use parking_lot::Mutex;
+use std::{
+    collections::VecDeque,
+    sync::atomic::{AtomicBool, Ordering},
+};
+use temporal_sdk::interceptors::WorkerInterceptor;
+use temporal_sdk_core_protos::coresdk::workflow_activation::WorkflowActivation;
+
+#[derive(Default)]
+pub struct ActivationAssertionsInterceptor {
+    #[allow(clippy::type_complexity)]
+    assertions: Mutex<VecDeque<Box<dyn FnOnce(&WorkflowActivation)>>>,
+    used: AtomicBool,
+}
+
+impl ActivationAssertionsInterceptor {
+    pub fn skip_one(&mut self) -> &mut Self {
+        self.assertions.lock().push_back(Box::new(|_| {}));
+        self
+    }
+
+    pub fn then(&mut self, assert: impl FnOnce(&WorkflowActivation) + 'static) -> &mut Self {
+        self.assertions.lock().push_back(Box::new(assert));
+        self
+    }
+}
+
+#[async_trait::async_trait(?Send)]
+impl WorkerInterceptor for ActivationAssertionsInterceptor {
+    async fn on_workflow_activation(&self, act: &WorkflowActivation) -> Result<(), Error> {
+        self.used.store(true, Ordering::Relaxed);
+        if let Some(fun) = self.assertions.lock().pop_front() {
+            fun(act);
+        }
+        Ok(())
+    }
+}
+
+impl Drop for ActivationAssertionsInterceptor {
+    fn drop(&mut self) {
+        if !self.used.load(Ordering::Relaxed) {
+            panic!("Activation assertions interceptor was never used!")
+        }
+    }
+}