@temporalio/core-bridge 1.6.0 → 1.7.1

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

@@ -12,11 +12,18 @@ mod history_info;
 mod task_token;
 
 #[cfg(feature = "history_builders")]
-pub use history_builder::{default_wes_attribs, TestHistoryBuilder, DEFAULT_WORKFLOW_TYPE};
+pub use history_builder::{
+    default_act_sched, default_wes_attribs, TestHistoryBuilder, DEFAULT_ACTIVITY_TYPE,
+    DEFAULT_WORKFLOW_TYPE,
+};
 #[cfg(feature = "history_builders")]
 pub use history_info::HistoryInfo;
 pub use task_token::TaskToken;
 
+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)]
 // I'd prefer not to do this, but there are some generated things that just don't need it.
 #[allow(missing_docs)]
@@ -25,10 +32,14 @@ pub mod coresdk {
 
     tonic::include_proto!("coresdk");
 
-    use crate::temporal::api::{
-        common::v1::{ActivityType, Payload, Payloads, WorkflowExecution},
-        failure::v1::{failure::FailureInfo, ApplicationFailureInfo, Failure},
-        workflowservice::v1::PollActivityTaskQueueResponse,
+    use crate::{
+        temporal::api::{
+            common::v1::{Payload, Payloads, WorkflowExecution},
+            enums::v1::WorkflowTaskFailedCause,
+            failure::v1::{failure::FailureInfo, ApplicationFailureInfo, Failure},
+            workflowservice::v1::PollActivityTaskQueueResponse,
+        },
+        ENCODING_PAYLOAD_KEY, JSON_ENCODING_VAL,
     };
     use activity_task::ActivityTask;
     use serde::{Deserialize, Serialize};
@@ -82,7 +93,10 @@ pub mod coresdk {
             common::v1::Payload,
             failure::v1::{failure, CanceledFailureInfo, Failure as APIFailure},
         };
-        use crate::temporal::api::{enums::v1::TimeoutType, failure::v1::TimeoutFailureInfo};
+        use crate::{
+            coresdk::activity_result::activity_resolution::Status,
+            temporal::api::enums::v1::TimeoutType,
+        };
         use activity_execution_result as aer;
         use std::fmt::{Display, Formatter};
 
@@ -185,7 +199,7 @@ pub mod coresdk {
             pub fn unwrap_ok_payload(self) -> Payload {
                 match self.status.unwrap() {
                     activity_resolution::Status::Completed(c) => c.result.unwrap(),
-                    _ => panic!("Activity was not successful"),
+                    e => panic!("Activity was not successful: {e:?}"),
                 }
             }
 
@@ -197,7 +211,7 @@ pub mod coresdk {
                 matches!(self.status, Some(activity_resolution::Status::Failed(_)))
             }
 
-            pub fn timed_out(&self) -> Option<crate::temporal::api::enums::v1::TimeoutType> {
+            pub fn timed_out(&self) -> Option<TimeoutType> {
                 match self.status {
                     Some(activity_resolution::Status::Failed(Failure {
                         failure: Some(ref f),
@@ -211,33 +225,28 @@ pub mod coresdk {
             pub fn cancelled(&self) -> bool {
                 matches!(self.status, Some(activity_resolution::Status::Cancelled(_)))
             }
+
+            /// If this resolution is any kind of failure, return the inner failure details. Panics
+            /// if the activity succeeded, is in backoff, or this resolution is malformed.
+            pub fn unwrap_failure(self) -> APIFailure {
+                match self.status.unwrap() {
+                    Status::Failed(f) => f.failure.unwrap(),
+                    Status::Cancelled(c) => c.failure.unwrap(),
+                    _ => panic!("Actvity did not fail"),
+                }
+            }
         }
 
         impl Cancellation {
-            pub fn from_details(payload: Option<Payload>) -> Self {
+            /// Create a cancellation result from some payload. This is to be used when telling Core
+            /// that an activity completed as cancelled.
+            pub fn from_details(details: Option<Payload>) -> Self {
                 Cancellation {
                     failure: Some(APIFailure {
                         message: "Activity cancelled".to_string(),
                         failure_info: Some(failure::FailureInfo::CanceledFailureInfo(
                             CanceledFailureInfo {
-                                details: payload.map(Into::into),
-                            },
-                        )),
-                        ..Default::default()
-                    }),
-                }
-            }
-        }
-
-        impl Failure {
-            pub fn timeout(timeout_type: TimeoutType) -> Self {
-                Failure {
-                    failure: Some(APIFailure {
-                        message: "Activity timed out".to_string(),
-                        failure_info: Some(failure::FailureInfo::TimeoutFailureInfo(
-                            TimeoutFailureInfo {
-                                timeout_type: timeout_type as i32,
-                                last_heartbeat_details: None,
+                                details: details.map(Into::into),
                             },
                         )),
                         ..Default::default()
@@ -251,28 +260,43 @@ pub mod coresdk {
         tonic::include_proto!("coresdk.common");
         use super::external_data::LocalActivityMarkerData;
         use crate::{
-            coresdk::{AsJsonPayloadExt, IntoPayloadsExt},
+            coresdk::{
+                external_data::PatchedMarkerData, AsJsonPayloadExt, FromJsonPayloadExt,
+                IntoPayloadsExt,
+            },
             temporal::api::common::v1::{Payload, Payloads},
+            PATCHED_MARKER_DETAILS_KEY,
         };
         use std::collections::HashMap;
 
         pub fn build_has_change_marker_details(
-            patch_id: &str,
+            patch_id: impl Into<String>,
             deprecated: bool,
-        ) -> HashMap<String, Payloads> {
+        ) -> anyhow::Result<HashMap<String, Payloads>> {
             let mut hm = HashMap::new();
-            hm.insert("patch_id".to_string(), patch_id.as_bytes().into());
-            let deprecated = deprecated as u8;
-            hm.insert("deprecated".to_string(), (&[deprecated]).into());
-            hm
+            let encoded = PatchedMarkerData {
+                id: patch_id.into(),
+                deprecated,
+            }
+            .as_json_payload()?;
+            hm.insert(PATCHED_MARKER_DETAILS_KEY.to_string(), encoded.into());
+            Ok(hm)
         }
 
         pub fn decode_change_marker_details(
             details: &HashMap<String, Payloads>,
         ) -> Option<(String, bool)> {
-            let name =
-                std::str::from_utf8(&details.get("patch_id")?.payloads.first()?.data).ok()?;
-            let deprecated = *details.get("deprecated")?.payloads.first()?.data.first()? != 0;
+            // We used to write change markers with plain bytes, so try to decode if they are
+            // json first, then fall back to that.
+            if let Some(cd) = details.get(PATCHED_MARKER_DETAILS_KEY) {
+                let decoded = PatchedMarkerData::from_json_payload(cd.payloads.first()?).ok()?;
+                return Some((decoded.id, decoded.deprecated));
+            }
+
+            let id_entry = details.get("patch_id")?.payloads.first()?;
+            let deprecated_entry = details.get("deprecated")?.payloads.first()?;
+            let name = std::str::from_utf8(&id_entry.data).ok()?;
+            let deprecated = *deprecated_entry.data.first()? != 0;
             Some((name.to_string(), deprecated))
         }
 
@@ -396,6 +420,7 @@ pub mod coresdk {
             },
             temporal::api::{
                 common::v1::Header,
+                enums::v1::WorkflowTaskFailedCause,
                 history::v1::{
                     WorkflowExecutionCancelRequestedEventAttributes,
                     WorkflowExecutionSignaledEventAttributes,
@@ -428,6 +453,7 @@ pub mod coresdk {
                         reason: reason as i32,
                     }),
                 )],
+                available_internal_flags: vec![],
             }
         }
 
@@ -495,6 +521,17 @@ pub mod coresdk {
             }
         }
 
+        impl From<EvictionReason> for WorkflowTaskFailedCause {
+            fn from(value: EvictionReason) -> Self {
+                match value {
+                    EvictionReason::Nondeterminism => {
+                        WorkflowTaskFailedCause::NonDeterministicError
+                    }
+                    _ => WorkflowTaskFailedCause::Unspecified,
+                }
+            }
+        }
+
         impl Display for WorkflowActivation {
             fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
                 write!(f, "WorkflowActivation(")?;
@@ -640,7 +677,7 @@ pub mod coresdk {
     }
 
     pub mod workflow_completion {
-        use crate::temporal::api::failure;
+        use crate::temporal::api::{enums::v1::WorkflowTaskFailedCause, failure};
         tonic::include_proto!("coresdk.workflow_completion");
 
         impl workflow_activation_completion::Status {
@@ -654,7 +691,10 @@ pub mod coresdk {
 
         impl From<failure::v1::Failure> for Failure {
             fn from(f: failure::v1::Failure) -> Self {
-                Failure { failure: Some(f) }
+                Failure {
+                    failure: Some(f),
+                    force_cause: WorkflowTaskFailedCause::Unspecified as i32,
+                }
             }
         }
     }
@@ -853,7 +893,10 @@ pub mod coresdk {
 
     impl From<Vec<WorkflowCommand>> for workflow_completion::Success {
         fn from(v: Vec<WorkflowCommand>) -> Self {
-            Self { commands: v }
+            Self {
+                commands: v,
+                used_internal_flags: vec![],
+            }
         }
     }
 
@@ -907,6 +950,7 @@ pub mod coresdk {
                 status: Some(workflow_activation_completion::Status::Failed(
                     workflow_completion::Failure {
                         failure: Some(failure),
+                        force_cause: WorkflowTaskFailedCause::Unspecified as i32,
                     },
                 )),
             }
@@ -990,6 +1034,12 @@ pub mod coresdk {
             }
             false
         }
+
+        pub fn add_internal_flags(&mut self, patch: u32) {
+            if let Some(workflow_activation_completion::Status::Successful(s)) = &mut self.status {
+                s.used_internal_flags.push(patch);
+            }
+        }
     }
 
     /// Makes converting outgoing lang commands into [WorkflowActivationCompletion]s easier
@@ -1037,7 +1087,7 @@ pub mod coresdk {
         fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
             match self {
                 workflow_activation_completion::Status::Successful(
-                    workflow_completion::Success { commands },
+                    workflow_completion::Success { commands, .. },
                 ) => {
                     write!(f, "Success(")?;
                     let mut written = 0;
@@ -1094,18 +1144,6 @@ pub mod coresdk {
         }
     }
 
-    impl From<String> for ActivityType {
-        fn from(name: String) -> Self {
-            Self { name }
-        }
-    }
-
-    impl From<ActivityType> for String {
-        fn from(at: ActivityType) -> Self {
-            at.name
-        }
-    }
-
     impl Failure {
         pub fn is_timeout(&self) -> Option<crate::temporal::api::enums::v1::TimeoutType> {
             match &self.failure_info {
@@ -1294,7 +1332,10 @@ pub mod coresdk {
         fn as_json_payload(&self) -> anyhow::Result<Payload> {
             let as_json = serde_json::to_string(self)?;
             let mut metadata = HashMap::new();
-            metadata.insert("encoding".to_string(), b"json/plain".to_vec());
+            metadata.insert(
+                ENCODING_PAYLOAD_KEY.to_string(),
+                JSON_ENCODING_VAL.as_bytes().to_vec(),
+            );
             Ok(Payload {
                 metadata,
                 data: as_json.into_bytes(),
@@ -1310,10 +1351,7 @@ pub mod coresdk {
         T: for<'de> Deserialize<'de>,
     {
         fn from_json_payload(payload: &Payload) -> Result<Self, PayloadDeserializeErr> {
-            if !matches!(
-                payload.metadata.get("encoding").map(|v| v.as_slice()),
-                Some(b"json/plain")
-            ) {
+            if !payload.is_json_payload() {
                 return Err(PayloadDeserializeErr::DeserializerDoesNotHandle);
             }
             let payload_str = std::str::from_utf8(&payload.data).map_err(anyhow::Error::from)?;
@@ -1573,6 +1611,7 @@ pub mod temporal {
         }
         pub mod common {
             pub mod v1 {
+                use crate::{ENCODING_PAYLOAD_KEY, JSON_ENCODING_VAL};
                 use base64::{prelude::BASE64_STANDARD, Engine};
                 use std::{
                     collections::HashMap,
@@ -1588,7 +1627,7 @@ pub mod temporal {
                         // TODO: Set better encodings, whole data converter deal. Setting anything
                         //  for now at least makes it show up in the web UI.
                         let mut metadata = HashMap::new();
-                        metadata.insert("encoding".to_string(), b"binary/plain".to_vec());
+                        metadata.insert(ENCODING_PAYLOAD_KEY.to_string(), b"binary/plain".to_vec());
                         Self {
                             metadata,
                             data: v.as_ref().to_vec(),
@@ -1601,6 +1640,13 @@ pub mod temporal {
                     pub fn as_slice(&self) -> &[u8] {
                         self.data.as_slice()
                     }
+
+                    pub fn is_json_payload(&self) -> bool {
+                        self.metadata
+                            .get(ENCODING_PAYLOAD_KEY)
+                            .map(|v| v.as_slice() == JSON_ENCODING_VAL.as_bytes())
+                            .unwrap_or_default()
+                    }
                 }
 
                 impl Display for Payload {
@@ -1658,6 +1704,26 @@ pub mod temporal {
                         }
                     }
                 }
+
+                impl From<String> for ActivityType {
+                    fn from(name: String) -> Self {
+                        Self { name }
+                    }
+                }
+
+                impl From<&str> for ActivityType {
+                    fn from(name: &str) -> Self {
+                        Self {
+                            name: name.to_string(),
+                        }
+                    }
+                }
+
+                impl From<ActivityType> for String {
+                    fn from(at: ActivityType) -> Self {
+                        at.name
+                    }
+                }
             }
         }
         pub mod enums {
@@ -1723,6 +1789,7 @@ pub mod temporal {
                             | EventType::TimerCanceled
                             | EventType::TimerStarted
                             | EventType::UpsertWorkflowSearchAttributes
+                            | EventType::WorkflowPropertiesModified
                             | EventType::WorkflowExecutionCanceled
                             | EventType::WorkflowExecutionCompleted
                             | EventType::WorkflowExecutionContinuedAsNew
@@ -1781,6 +1848,15 @@ pub mod temporal {
                             _ => false,
                         }
                     }
+
+                    pub fn is_wft_closed_event(&self) -> bool {
+                        match self.event_type() {
+                            EventType::WorkflowTaskCompleted => true,
+                            EventType::WorkflowTaskFailed => true,
+                            EventType::WorkflowTaskTimedOut => true,
+                            _ => false,
+                        }
+                    }
                 }
 
                 impl Display for HistoryEvent {
@@ -1793,11 +1869,60 @@ pub mod temporal {
                         )
                     }
                 }
-            }
-        }
-        pub mod interaction {
-            pub mod v1 {
-                tonic::include_proto!("temporal.api.interaction.v1");
+
+                impl Attributes {
+                    pub fn event_type(&self) -> EventType {
+                        // I just absolutely _love_ this
+                        match self {
+                            Attributes::WorkflowExecutionStartedEventAttributes(_) => {EventType::WorkflowExecutionStarted}
+                            Attributes::WorkflowExecutionCompletedEventAttributes(_) => {EventType::WorkflowExecutionCompleted}
+                            Attributes::WorkflowExecutionFailedEventAttributes(_) => {EventType::WorkflowExecutionFailed}
+                            Attributes::WorkflowExecutionTimedOutEventAttributes(_) => {EventType::WorkflowExecutionTimedOut}
+                            Attributes::WorkflowTaskScheduledEventAttributes(_) => {EventType::WorkflowTaskScheduled}
+                            Attributes::WorkflowTaskStartedEventAttributes(_) => {EventType::WorkflowTaskStarted}
+                            Attributes::WorkflowTaskCompletedEventAttributes(_) => {EventType::WorkflowTaskCompleted}
+                            Attributes::WorkflowTaskTimedOutEventAttributes(_) => {EventType::WorkflowTaskTimedOut}
+                            Attributes::WorkflowTaskFailedEventAttributes(_) => {EventType::WorkflowTaskFailed}
+                            Attributes::ActivityTaskScheduledEventAttributes(_) => {EventType::ActivityTaskScheduled}
+                            Attributes::ActivityTaskStartedEventAttributes(_) => {EventType::ActivityTaskStarted}
+                            Attributes::ActivityTaskCompletedEventAttributes(_) => {EventType::ActivityTaskCompleted}
+                            Attributes::ActivityTaskFailedEventAttributes(_) => {EventType::ActivityTaskFailed}
+                            Attributes::ActivityTaskTimedOutEventAttributes(_) => {EventType::ActivityTaskTimedOut}
+                            Attributes::TimerStartedEventAttributes(_) => {EventType::TimerStarted}
+                            Attributes::TimerFiredEventAttributes(_) => {EventType::TimerFired}
+                            Attributes::ActivityTaskCancelRequestedEventAttributes(_) => {EventType::ActivityTaskCancelRequested}
+                            Attributes::ActivityTaskCanceledEventAttributes(_) => {EventType::ActivityTaskCanceled}
+                            Attributes::TimerCanceledEventAttributes(_) => {EventType::TimerCanceled}
+                            Attributes::MarkerRecordedEventAttributes(_) => {EventType::MarkerRecorded}
+                            Attributes::WorkflowExecutionSignaledEventAttributes(_) => {EventType::WorkflowExecutionSignaled}
+                            Attributes::WorkflowExecutionTerminatedEventAttributes(_) => {EventType::WorkflowExecutionTerminated}
+                            Attributes::WorkflowExecutionCancelRequestedEventAttributes(_) => {EventType::WorkflowExecutionCancelRequested}
+                            Attributes::WorkflowExecutionCanceledEventAttributes(_) => {EventType::WorkflowExecutionCanceled}
+                            Attributes::RequestCancelExternalWorkflowExecutionInitiatedEventAttributes(_) => {EventType::RequestCancelExternalWorkflowExecutionInitiated}
+                            Attributes::RequestCancelExternalWorkflowExecutionFailedEventAttributes(_) => {EventType::RequestCancelExternalWorkflowExecutionFailed}
+                            Attributes::ExternalWorkflowExecutionCancelRequestedEventAttributes(_) => {EventType::ExternalWorkflowExecutionCancelRequested}
+                            Attributes::WorkflowExecutionContinuedAsNewEventAttributes(_) => {EventType::WorkflowExecutionContinuedAsNew}
+                            Attributes::StartChildWorkflowExecutionInitiatedEventAttributes(_) => {EventType::StartChildWorkflowExecutionInitiated}
+                            Attributes::StartChildWorkflowExecutionFailedEventAttributes(_) => {EventType::StartChildWorkflowExecutionFailed}
+                            Attributes::ChildWorkflowExecutionStartedEventAttributes(_) => {EventType::ChildWorkflowExecutionStarted}
+                            Attributes::ChildWorkflowExecutionCompletedEventAttributes(_) => {EventType::ChildWorkflowExecutionCompleted}
+                            Attributes::ChildWorkflowExecutionFailedEventAttributes(_) => {EventType::ChildWorkflowExecutionFailed}
+                            Attributes::ChildWorkflowExecutionCanceledEventAttributes(_) => {EventType::ChildWorkflowExecutionCanceled}
+                            Attributes::ChildWorkflowExecutionTimedOutEventAttributes(_) => {EventType::ChildWorkflowExecutionTimedOut}
+                            Attributes::ChildWorkflowExecutionTerminatedEventAttributes(_) => {EventType::ChildWorkflowExecutionTerminated}
+                            Attributes::SignalExternalWorkflowExecutionInitiatedEventAttributes(_) => {EventType::SignalExternalWorkflowExecutionInitiated}
+                            Attributes::SignalExternalWorkflowExecutionFailedEventAttributes(_) => {EventType::SignalExternalWorkflowExecutionFailed}
+                            Attributes::ExternalWorkflowExecutionSignaledEventAttributes(_) => {EventType::ExternalWorkflowExecutionSignaled}
+                            Attributes::UpsertWorkflowSearchAttributesEventAttributes(_) => {EventType::UpsertWorkflowSearchAttributes}
+                            Attributes::WorkflowExecutionUpdateRejectedEventAttributes(_) => {EventType::WorkflowExecutionUpdateRejected}
+                            Attributes::WorkflowExecutionUpdateAcceptedEventAttributes(_) => {EventType::WorkflowExecutionUpdateAccepted}
+                            Attributes::WorkflowExecutionUpdateCompletedEventAttributes(_) => {EventType::WorkflowExecutionUpdateCompleted}
+                            Attributes::WorkflowPropertiesModifiedExternallyEventAttributes(_) => {EventType::WorkflowPropertiesModifiedExternally}
+                            Attributes::ActivityPropertiesModifiedExternallyEventAttributes(_) => {EventType::ActivityPropertiesModifiedExternally}
+                            Attributes::WorkflowPropertiesModifiedEventAttributes(_) => {EventType::WorkflowPropertiesModified}
+                        }
+                    }
+                }
             }
         }
         pub mod namespace {
@@ -1810,6 +1935,11 @@ pub mod temporal {
                 tonic::include_proto!("temporal.api.operatorservice.v1");
             }
         }
+        pub mod protocol {
+            pub mod v1 {
+                tonic::include_proto!("temporal.api.protocol.v1");
+            }
+        }
         pub mod query {
             pub mod v1 {
                 tonic::include_proto!("temporal.api.query.v1");
@@ -1821,10 +1951,16 @@ pub mod temporal {
             }
         }
         pub mod schedule {
+            #[allow(rustdoc::invalid_html_tags)]
             pub mod v1 {
                 tonic::include_proto!("temporal.api.schedule.v1");
             }
         }
+        pub mod sdk {
+            pub mod v1 {
+                tonic::include_proto!("temporal.api.sdk.v1");
+            }
+        }
         pub mod taskqueue {
             pub mod v1 {
                 use crate::temporal::api::enums::v1::TaskQueueKind;
@@ -1845,6 +1981,11 @@ pub mod temporal {
                 tonic::include_proto!("temporal.api.testservice.v1");
             }
         }
+        pub mod update {
+            pub mod v1 {
+                tonic::include_proto!("temporal.api.update.v1");
+            }
+        }
         pub mod version {
             pub mod v1 {
                 tonic::include_proto!("temporal.api.version.v1");