@temporalio/core-bridge 0.19.2 → 0.20.2

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

@@ -45,6 +45,8 @@ pub mod coresdk {
 
     #[allow(clippy::module_inception)]
     pub mod activity_task {
+        use crate::{coresdk::ActivityTaskCompletion, task_token::fmt_tt};
+        use std::fmt::{Display, Formatter};
         tonic::include_proto!("coresdk.activity_task");
 
         impl ActivityTask {
@@ -57,6 +59,22 @@ pub mod coresdk {
                 }
             }
         }
+
+        impl Display for ActivityTaskCompletion {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(
+                    f,
+                    "ActivityTaskCompletion(token: {}",
+                    fmt_tt(&self.task_token),
+                )?;
+                if let Some(r) = self.result.as_ref() {
+                    write!(f, ", {}", r)?;
+                } else {
+                    write!(f, ", missing result")?;
+                }
+                write!(f, ")")
+            }
+        }
     }
     #[allow(clippy::module_inception)]
     pub mod activity_result {
@@ -70,6 +88,7 @@ pub mod coresdk {
         };
         use crate::temporal::api::{enums::v1::TimeoutType, failure::v1::TimeoutFailureInfo};
         use activity_execution_result as aer;
+        use std::fmt::{Display, Formatter};
 
         impl ActivityExecutionResult {
             pub const fn ok(result: Payload) -> Self {
@@ -105,6 +124,57 @@ pub mod coresdk {
             }
         }
 
+        impl Display for ActivityExecutionResult {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "ActivityExecutionResult(")?;
+                match self.status.as_ref() {
+                    None => write!(f, "missing result)"),
+                    Some(aer::Status::Completed(v)) => {
+                        write!(f, "{})", v)
+                    }
+                    Some(aer::Status::Failed(v)) => {
+                        write!(f, "{})", v)
+                    }
+                    Some(aer::Status::Cancelled(v)) => {
+                        write!(f, "{})", v)
+                    }
+                    Some(aer::Status::WillCompleteAsync(_)) => {
+                        write!(f, "Will complete async)")
+                    }
+                }
+            }
+        }
+
+        impl Display for Success {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "Success(")?;
+                if let Some(ref v) = self.result {
+                    write!(f, "{}", v)?;
+                }
+                write!(f, ")")
+            }
+        }
+
+        impl Display for Failure {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "Failure(")?;
+                if let Some(ref v) = self.failure {
+                    write!(f, "{}", v)?;
+                }
+                write!(f, ")")
+            }
+        }
+
+        impl Display for Cancellation {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "Cancellation(")?;
+                if let Some(ref v) = self.failure {
+                    write!(f, "{}", v)?;
+                }
+                write!(f, ")")
+            }
+        }
+
         impl From<Result<APIPayload, APIFailure>> for ActivityExecutionResult {
             fn from(r: Result<APIPayload, APIFailure>) -> Self {
                 Self {
@@ -190,15 +260,22 @@ pub mod coresdk {
             coresdk::{AsJsonPayloadExt, IntoPayloadsExt},
             temporal::api::common::v1::{Payload as ApiPayload, Payloads},
         };
-        use std::collections::HashMap;
+        use std::{
+            collections::HashMap,
+            fmt::{Display, Formatter},
+        };
 
         impl<T> From<T> for Payload
         where
             T: AsRef<[u8]>,
         {
             fn from(v: T) -> Self {
+                // 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());
                 Self {
-                    metadata: Default::default(),
+                    metadata,
                     data: v.as_ref().to_vec(),
                 }
             }
@@ -211,6 +288,22 @@ pub mod coresdk {
             }
         }
 
+        impl Display for Payload {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                if self.data.len() > 64 {
+                    let mut windows = self.data.as_slice().windows(32);
+                    write!(
+                        f,
+                        "[{}..{}]",
+                        base64::encode(windows.next().unwrap_or_default()),
+                        base64::encode(windows.next_back().unwrap_or_default())
+                    )
+                } else {
+                    write!(f, "[{}]", base64::encode(&self.data))
+                }
+            }
+        }
+
         pub fn build_has_change_marker_details(
             patch_id: &str,
             deprecated: bool,
@@ -344,13 +437,25 @@ pub mod coresdk {
 
     pub mod workflow_activation {
         use crate::{
-            coresdk::{workflow_activation::remove_from_cache::EvictionReason, FromPayloadsExt},
-            temporal::api::history::v1::{
-                WorkflowExecutionCancelRequestedEventAttributes,
-                WorkflowExecutionSignaledEventAttributes,
+            coresdk::{
+                common::{NamespacedWorkflowExecution, Payload},
+                workflow_activation::remove_from_cache::EvictionReason,
+                FromPayloadsExt,
+            },
+            temporal::api::{
+                common::v1::Header,
+                history::v1::{
+                    WorkflowExecutionCancelRequestedEventAttributes,
+                    WorkflowExecutionSignaledEventAttributes,
+                    WorkflowExecutionStartedEventAttributes,
+                },
+                query::v1::WorkflowQuery,
             },
         };
-        use std::fmt::{Display, Formatter};
+        use std::{
+            collections::HashMap,
+            fmt::{Display, Formatter},
+        };
 
         tonic::include_proto!("coresdk.workflow_activation");
 
@@ -387,6 +492,15 @@ pub mod coresdk {
             }
         }
 
+        pub fn query_to_job(id: String, q: WorkflowQuery) -> QueryWorkflow {
+            QueryWorkflow {
+                query_id: id,
+                query_type: q.query_type,
+                arguments: Vec::from_payloads(q.query_args),
+                headers: q.header.map(|h| h.into()).unwrap_or_default(),
+            }
+        }
+
         impl WorkflowActivation {
             /// Returns the index of the eviction job if this activation contains one. If present
             /// it should always be the last job in the list.
@@ -515,12 +629,23 @@ pub mod coresdk {
             }
         }
 
+        impl Display for QueryWorkflow {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(
+                    f,
+                    "QueryWorkflow(id: {}, type: {})",
+                    self.query_id, self.query_type
+                )
+            }
+        }
+
         impl From<WorkflowExecutionSignaledEventAttributes> for SignalWorkflow {
             fn from(a: WorkflowExecutionSignaledEventAttributes) -> Self {
                 Self {
                     signal_name: a.signal_name,
                     input: Vec::from_payloads(a.input),
                     identity: a.identity,
+                    headers: a.header.map(Into::into).unwrap_or_default(),
                 }
             }
         }
@@ -530,6 +655,50 @@ pub mod coresdk {
                 Self { details: vec![] }
             }
         }
+
+        /// Create a [StartWorkflow] job from corresponding event attributes
+        pub fn start_workflow_from_attribs(
+            attrs: WorkflowExecutionStartedEventAttributes,
+            workflow_id: String,
+            randomness_seed: u64,
+        ) -> StartWorkflow {
+            StartWorkflow {
+                workflow_type: attrs.workflow_type.map(|wt| wt.name).unwrap_or_default(),
+                workflow_id,
+                arguments: Vec::from_payloads(attrs.input),
+                randomness_seed,
+                headers: match attrs.header {
+                    None => HashMap::new(),
+                    Some(Header { fields }) => fields
+                        .into_iter()
+                        .map(|(k, v)| (k, Payload::from(v)))
+                        .collect(),
+                },
+                identity: attrs.identity,
+                parent_workflow_info: attrs.parent_workflow_execution.map(|pe| {
+                    NamespacedWorkflowExecution {
+                        namespace: attrs.parent_workflow_namespace,
+                        run_id: pe.run_id,
+                        workflow_id: pe.workflow_id,
+                    }
+                }),
+                workflow_execution_timeout: attrs.workflow_execution_timeout,
+                workflow_run_timeout: attrs.workflow_run_timeout,
+                workflow_task_timeout: attrs.workflow_task_timeout,
+                continued_from_execution_run_id: attrs.continued_execution_run_id,
+                continued_initiator: attrs.initiator,
+                continued_failure: attrs.continued_failure,
+                last_completion_result: attrs.last_completion_result,
+                first_execution_run_id: attrs.first_execution_run_id,
+                retry_policy: attrs.retry_policy,
+                attempt: attrs.attempt,
+                cron_schedule: attrs.cron_schedule,
+                workflow_execution_expiration_time: attrs.workflow_execution_expiration_time,
+                cron_schedule_to_schedule_interval: attrs.first_workflow_task_backoff,
+                memo: attrs.memo,
+                search_attributes: attrs.search_attributes,
+            }
+        }
     }
 
     pub mod workflow_completion {
@@ -663,6 +832,12 @@ pub mod coresdk {
             }
         }
 
+        impl Display for UpsertWorkflowSearchAttributes {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "UpsertWorkflowSearchAttributes({})", self.seq) // todo: customize this better
+            }
+        }
+
         impl Display for SignalExternalWorkflowExecution {
             fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
                 write!(f, "SignalExternalWorkflowExecution({})", self.seq)
@@ -748,51 +923,35 @@ pub mod coresdk {
 
     impl WorkflowActivationCompletion {
         /// Create a successful activation with no commands in it
-        pub fn empty(task_queue: impl Into<String>, run_id: impl Into<String>) -> Self {
+        pub fn empty(run_id: impl Into<String>) -> Self {
             let success = workflow_completion::Success::from_variants(vec![]);
             Self {
                 run_id: run_id.into(),
-                task_queue: task_queue.into(),
                 status: Some(workflow_activation_completion::Status::Successful(success)),
             }
         }
 
         /// Create a successful activation from a list of commands
-        pub fn from_cmds(
-            task_q: impl Into<String>,
-            run_id: impl Into<String>,
-            cmds: Vec<workflow_command::Variant>,
-        ) -> Self {
+        pub fn from_cmds(run_id: impl Into<String>, cmds: Vec<workflow_command::Variant>) -> Self {
             let success = workflow_completion::Success::from_variants(cmds);
             Self {
                 run_id: run_id.into(),
-                task_queue: task_q.into(),
                 status: Some(workflow_activation_completion::Status::Successful(success)),
             }
         }
 
         /// Create a successful activation from just one command
-        pub fn from_cmd(
-            task_q: impl Into<String>,
-            run_id: impl Into<String>,
-            cmd: workflow_command::Variant,
-        ) -> Self {
+        pub fn from_cmd(run_id: impl Into<String>, cmd: workflow_command::Variant) -> Self {
             let success = workflow_completion::Success::from_variants(vec![cmd]);
             Self {
                 run_id: run_id.into(),
-                task_queue: task_q.into(),
                 status: Some(workflow_activation_completion::Status::Successful(success)),
             }
         }
 
-        pub fn fail(
-            task_q: impl Into<String>,
-            run_id: impl Into<String>,
-            failure: Failure,
-        ) -> Self {
+        pub fn fail(run_id: impl Into<String>, failure: Failure) -> Self {
             Self {
                 run_id: run_id.into(),
-                task_queue: task_q.into(),
                 status: Some(workflow_activation_completion::Status::Failed(
                     workflow_completion::Failure {
                         failure: Some(failure),
@@ -876,20 +1035,12 @@ pub mod coresdk {
     /// Makes converting outgoing lang commands into [WorkflowActivationCompletion]s easier
     pub trait IntoCompletion {
         /// The conversion function
-        fn into_completion(
-            self,
-            task_queue: String,
-            run_id: String,
-        ) -> WorkflowActivationCompletion;
+        fn into_completion(self, run_id: String) -> WorkflowActivationCompletion;
     }
 
     impl IntoCompletion for workflow_command::Variant {
-        fn into_completion(
-            self,
-            task_queue: String,
-            run_id: String,
-        ) -> WorkflowActivationCompletion {
-            WorkflowActivationCompletion::from_cmd(task_queue, run_id, self)
+        fn into_completion(self, run_id: String) -> WorkflowActivationCompletion {
+            WorkflowActivationCompletion::from_cmd(run_id, self)
         }
     }
 
@@ -898,15 +1049,10 @@ pub mod coresdk {
         I: IntoIterator<Item = V>,
         V: Into<WorkflowCommand>,
     {
-        fn into_completion(
-            self,
-            task_queue: String,
-            run_id: String,
-        ) -> WorkflowActivationCompletion {
+        fn into_completion(self, run_id: String) -> WorkflowActivationCompletion {
             let success = self.into_iter().map(Into::into).collect::<Vec<_>>().into();
             WorkflowActivationCompletion {
                 run_id,
-                task_queue,
                 status: Some(workflow_activation_completion::Status::Successful(success)),
             }
         }
@@ -1028,12 +1174,60 @@ pub mod coresdk {
         }
     }
 
+    impl Display for Failure {
+        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+            write!(f, "Failure({}, ", self.message)?;
+            match self.failure_info.as_ref() {
+                None => write!(f, "missing info")?,
+                Some(FailureInfo::TimeoutFailureInfo(v)) => {
+                    write!(f, "Timeout: {:?}", v.timeout_type())?;
+                }
+                Some(FailureInfo::ApplicationFailureInfo(v)) => {
+                    write!(f, "Application Failure: {}", v.r#type)?;
+                }
+                Some(FailureInfo::CanceledFailureInfo(_)) => {
+                    write!(f, "Cancelled")?;
+                }
+                Some(FailureInfo::TerminatedFailureInfo(_)) => {
+                    write!(f, "Terminated")?;
+                }
+                Some(FailureInfo::ServerFailureInfo(_)) => {
+                    write!(f, "Server Failure")?;
+                }
+                Some(FailureInfo::ResetWorkflowFailureInfo(_)) => {
+                    write!(f, "Reset Workflow")?;
+                }
+                Some(FailureInfo::ActivityFailureInfo(v)) => {
+                    write!(
+                        f,
+                        "Activity Failure: scheduled_event_id: {}",
+                        v.scheduled_event_id
+                    )?;
+                }
+                Some(FailureInfo::ChildWorkflowExecutionFailureInfo(v)) => {
+                    write!(
+                        f,
+                        "Child Workflow: started_event_id: {}",
+                        v.started_event_id
+                    )?;
+                }
+            }
+            write!(f, ")")
+        }
+    }
+
     impl From<&str> for Failure {
         fn from(v: &str) -> Self {
             Failure::application_failure(v.to_string(), false)
         }
     }
 
+    impl From<String> for Failure {
+        fn from(v: String) -> Self {
+            Failure::application_failure(v, false)
+        }
+    }
+
     impl From<anyhow::Error> for Failure {
         fn from(ae: anyhow::Error) -> Self {
             Failure::application_failure(ae.to_string(), false)
@@ -1284,6 +1478,16 @@ pub mod temporal {
                     }
                 }
 
+                impl From<workflow_commands::UpsertWorkflowSearchAttributes> for command::Attributes {
+                    fn from(s: workflow_commands::UpsertWorkflowSearchAttributes) -> Self {
+                        Self::UpsertWorkflowSearchAttributesCommandAttributes(
+                            UpsertWorkflowSearchAttributesCommandAttributes {
+                                search_attributes: Some(s.search_attributes.into()),
+                            },
+                        )
+                    }
+                }
+
                 impl From<workflow_commands::CancelTimer> for command::Attributes {
                     fn from(s: workflow_commands::CancelTimer) -> Self {
                         Self::CancelTimerCommandAttributes(CancelTimerCommandAttributes {
@@ -1302,7 +1506,7 @@ pub mod temporal {
                                 }),
                                 namespace: s.namespace,
                                 task_queue: Some(s.task_queue.into()),
-                                header: Some(s.header_fields.into()),
+                                header: Some(s.headers.into()),
                                 input: s.arguments.into_payloads(),
                                 schedule_to_close_timeout: s.schedule_to_close_timeout,
                                 schedule_to_start_timeout: s.schedule_to_start_timeout,
@@ -1325,7 +1529,7 @@ pub mod temporal {
                                 control: "".into(),
                                 namespace: s.namespace,
                                 task_queue: Some(s.task_queue.into()),
-                                header: Some(s.header.into()),
+                                header: Some(s.headers.into()),
                                 memo: Some(s.memo.into()),
                                 search_attributes: Some(s.search_attributes.into()),
                                 input: s.input.into_payloads(),
@@ -1371,7 +1575,7 @@ pub mod temporal {
                                 workflow_run_timeout: c.workflow_run_timeout,
                                 workflow_task_timeout: c.workflow_task_timeout,
                                 memo: Some(c.memo.into()),
-                                header: Some(c.header.into()),
+                                header: Some(c.headers.into()),
                                 search_attributes: Some(c.search_attributes.into()),
                                 ..Default::default()
                             },

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

@@ -18,12 +18,14 @@ prost = "0.9"
 prost-types = "0.9"
 rand = "0.8"
 serde_json = "1.0"
-temporal-client = { path = "../client", features = ["mocks"] }
+temporal-client = { path = "../client" }
 temporal-sdk = { path = "../sdk" }
 temporal-sdk-core = { path = "../core" }
 temporal-sdk-core-api = { path = "../core-api" }
 thiserror = "1.0"
 tokio = "1.1"
+tokio-util = { version = "0.7" }
+tracing = "0.1"
 url = "2.2"
 uuid = "0.8"
 

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

@@ -1,3 +1,4 @@
+use rand::RngCore;
 use temporal_sdk_core::replay::TestHistoryBuilder;
 use temporal_sdk_core_protos::{
     coresdk::common::NamespacedWorkflowExecution,
@@ -855,6 +856,32 @@ pub fn long_sequential_timers(num_tasks: usize) -> TestHistoryBuilder {
     t
 }
 
+/// Sends 5 large signals per workflow task
+pub fn lots_of_big_signals(num_tasks: usize) -> TestHistoryBuilder {
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+
+    let mut rng = rand::thread_rng();
+    for _ in 1..=num_tasks {
+        let mut dat = [0_u8; 1024 * 1000];
+        for _ in 1..=5 {
+            rng.fill_bytes(&mut dat);
+            t.add_we_signaled(
+                "bigsig",
+                vec![Payload {
+                    metadata: Default::default(),
+                    data: dat.into(),
+                }],
+            );
+        }
+        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

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

@@ -5,18 +5,18 @@
 //! We can use `clap` if this needs more arguments / other stuff later on.
 
 use prost::Message;
-use temporal_client::ServerGatewayApis;
+use temporal_client::WorkflowClientTrait;
 use temporal_sdk_core_test_utils::get_integ_server_options;
 
 #[tokio::main]
 async fn main() -> Result<(), anyhow::Error> {
     let gw_opts = get_integ_server_options();
-    let gateway = gw_opts.connect(None).await?;
+    let client = gw_opts.connect("default", None).await?;
     let wf_id = std::env::args()
         .nth(1)
         .expect("must provide workflow id as only argument");
     let run_id = std::env::args().nth(2);
-    let hist = gateway
+    let hist = client
         .get_workflow_execution_history(wf_id.clone(), run_id, vec![])
         .await?
         .history