temporalio 0.0.2 → 0.1.1

data/bridge/sdk-core/sdk-core-protos/Cargo.toml

@@ -12,13 +12,15 @@ categories = ["development-tools"]
 
 [features]
 history_builders = ["uuid", "rand"]
+serde_serialize = []
 
 [dependencies]
 anyhow = "1.0"
-base64 = "0.20"
+base64 = "0.21"
 derive_more = "0.99"
 prost = "0.11"
-prost-types = "0.11"
+prost-wkt = "0.4"
+prost-wkt-types = "0.4"
 rand = { version = "0.8", optional = true }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
@@ -28,3 +30,4 @@ uuid = { version = "1.1", features = ["v4"], optional = true }
 
 [build-dependencies]
 tonic-build = "0.8"
+prost-wkt-build = "0.4"

data/bridge/sdk-core/sdk-core-protos/build.rs

@@ -1,5 +1,9 @@
+use std::{env, path::PathBuf};
+
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("cargo:rerun-if-changed=../protos");
+    let out = PathBuf::from(env::var("OUT_DIR").unwrap());
+    let descriptor_file = out.join("descriptors.bin");
     tonic_build::configure()
         // We don't actually want to build the grpc definitions - we don't need them (for now).
         // Just build the message structs.
@@ -74,7 +78,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         // All external data is useful to be able to JSON serialize, so it can render in web UI
         .type_attribute(
             ".coresdk.external_data",
-            "#[derive(::serde::Serialize, ::serde::Deserialize)]",
+            "#[cfg_attr(not(feature = \"serde_serialize\"), derive(::serde::Serialize, ::serde::Deserialize))]",
+        )
+        .type_attribute(
+            ".",
+            "#[cfg_attr(feature = \"serde_serialize\", derive(::serde::Serialize, ::serde::Deserialize))]",
         )
         .field_attribute(
             "coresdk.external_data.LocalActivityMarkerData.complete_time",
@@ -88,6 +96,23 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             "coresdk.external_data.LocalActivityMarkerData.backoff",
             "#[serde(with = \"opt_duration\")]",
         )
+        .extern_path(
+            ".google.protobuf.Any",
+            "::prost_wkt_types::Any"
+        )
+        .extern_path(
+            ".google.protobuf.Timestamp",
+            "::prost_wkt_types::Timestamp"
+        )
+        .extern_path(
+            ".google.protobuf.Duration",
+            "::prost_wkt_types::Duration"
+        )
+        .extern_path(
+            ".google.protobuf.Value",
+            "::prost_wkt_types::Value"
+        )
+        .file_descriptor_set_path(#[allow(clippy::needless_borrow)] &descriptor_file)
         .compile(
             &[
                 "../protos/local/temporal/sdk/core/core_interface.proto",
@@ -103,5 +128,15 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                 "../protos/grpc",
             ],
         )?;
+
+    #[cfg(feature = "serde_serialize")]
+    {
+        use prost_wkt_build::{FileDescriptorSet, Message};
+
+        let descriptor_bytes = std::fs::read(descriptor_file)?;
+        let descriptor = FileDescriptorSet::decode(&descriptor_bytes[..])?;
+        prost_wkt_build::add_serde(out, descriptor);
+    }
+
     Ok(())
 }

data/bridge/sdk-core/sdk-core-protos/src/history_builder.rs

@@ -6,10 +6,11 @@ use crate::{
             NamespacedWorkflowExecution,
         },
         external_data::LocalActivityMarkerData,
+        workflow_commands::ScheduleActivity,
         IntoPayloadsExt,
     },
     temporal::api::{
-        common::v1::{Payload, Payloads, WorkflowExecution, WorkflowType},
+        common::v1::{ActivityType, Payload, Payloads, WorkflowExecution, WorkflowType},
         enums::v1::{EventType, TaskQueueKind, WorkflowTaskFailedCause},
         failure::v1::{failure, CanceledFailureInfo, Failure},
         history::v1::{history_event::Attributes, *},
@@ -18,11 +19,12 @@ use crate::{
     HistoryInfo,
 };
 use anyhow::bail;
-use prost_types::Timestamp;
+use prost_wkt_types::Timestamp;
 use std::time::{Duration, SystemTime};
 use uuid::Uuid;
 
 pub static DEFAULT_WORKFLOW_TYPE: &str = "default_wf_type";
+pub static DEFAULT_ACTIVITY_TYPE: &str = "default_act_type";
 
 type Result<T, E = anyhow::Error> = std::result::Result<T, E>;
 
@@ -61,26 +63,19 @@ impl TestHistoryBuilder {
     }
 
     /// Add an event by type with attributes. Bundles both into a [HistoryEvent] with an id that is
-    /// incremented on each call to add.
-    pub fn add(&mut self, event_type: EventType, attribs: Attributes) {
-        self.build_and_push_event(event_type, attribs);
+    /// incremented on each call to add. Returns the id of the new event.
+    pub fn add(&mut self, attribs: impl Into<Attributes>) -> i64 {
+        let attribs: Attributes = attribs.into();
+        self.build_and_push_event(attribs.event_type(), attribs);
+        self.current_event_id
     }
 
-    /// Adds an event to the history by type, with default attributes.
-    pub fn add_by_type(&mut self, event_type: EventType) {
+    /// Adds an event to the history by type, with default attributes. Returns the id of the new
+    /// event.
+    pub fn add_by_type(&mut self, event_type: EventType) -> i64 {
         let attribs =
             default_attribs(event_type).expect("Couldn't make default attributes in test builder");
-        self.build_and_push_event(event_type, attribs);
-    }
-
-    /// Adds an event, returning the ID that was assigned to it
-    pub fn add_get_event_id(&mut self, event_type: EventType, attrs: Option<Attributes>) -> i64 {
-        if let Some(a) = attrs {
-            self.build_and_push_event(event_type, a);
-        } else {
-            self.add_by_type(event_type);
-        }
-        self.current_event_id
+        self.add(attribs)
     }
 
     /// Adds the following events:
@@ -100,25 +95,21 @@ impl TestHistoryBuilder {
     }
 
     pub fn add_workflow_task_scheduled(&mut self) {
-        self.workflow_task_scheduled_event_id =
-            self.add_get_event_id(EventType::WorkflowTaskScheduled, None);
+        self.workflow_task_scheduled_event_id = self.add_by_type(EventType::WorkflowTaskScheduled);
     }
 
     pub fn add_workflow_task_started(&mut self) {
-        let attrs = WorkflowTaskStartedEventAttributes {
+        self.final_workflow_task_started_event_id = self.add(WorkflowTaskStartedEventAttributes {
             scheduled_event_id: self.workflow_task_scheduled_event_id,
             ..Default::default()
-        };
-        self.final_workflow_task_started_event_id =
-            self.add_get_event_id(EventType::WorkflowTaskStarted, Some(attrs.into()));
+        });
     }
 
     pub fn add_workflow_task_completed(&mut self) {
-        let attrs = WorkflowTaskCompletedEventAttributes {
+        let id = self.add(WorkflowTaskCompletedEventAttributes {
             scheduled_event_id: self.workflow_task_scheduled_event_id,
             ..Default::default()
-        };
-        let id = self.add_get_event_id(EventType::WorkflowTaskCompleted, Some(attrs.into()));
+        });
         self.previous_task_completed_id = id;
     }
 
@@ -176,30 +167,22 @@ impl TestHistoryBuilder {
     }
 
     pub fn add_activity_task_scheduled(&mut self, activity_id: impl Into<String>) -> i64 {
-        self.add_get_event_id(
-            EventType::ActivityTaskScheduled,
-            Some(
-                history_event::Attributes::ActivityTaskScheduledEventAttributes(
-                    ActivityTaskScheduledEventAttributes {
-                        activity_id: activity_id.into(),
-                        ..Default::default()
-                    },
-                ),
-            ),
-        )
+        self.add(ActivityTaskScheduledEventAttributes {
+            activity_id: activity_id.into(),
+            activity_type: Some(ActivityType {
+                name: DEFAULT_ACTIVITY_TYPE.to_string(),
+            }),
+            ..Default::default()
+        })
     }
+
     pub fn add_activity_task_started(&mut self, scheduled_event_id: i64) -> i64 {
-        self.add_get_event_id(
-            EventType::ActivityTaskStarted,
-            Some(
-                history_event::Attributes::ActivityTaskStartedEventAttributes(
-                    ActivityTaskStartedEventAttributes {
-                        scheduled_event_id,
-                        ..Default::default()
-                    },
-                ),
-            ),
-        )
+        self.add(Attributes::ActivityTaskStartedEventAttributes(
+            ActivityTaskStartedEventAttributes {
+                scheduled_event_id,
+                ..Default::default()
+            },
+        ))
     }
 
     pub fn add_activity_task_completed(
@@ -208,17 +191,12 @@ impl TestHistoryBuilder {
         started_event_id: i64,
         payload: Payload,
     ) {
-        self.add(
-            EventType::ActivityTaskCompleted,
-            history_event::Attributes::ActivityTaskCompletedEventAttributes(
-                ActivityTaskCompletedEventAttributes {
-                    scheduled_event_id,
-                    started_event_id,
-                    result: vec![payload].into_payloads(),
-                    ..Default::default()
-                },
-            ),
-        );
+        self.add(ActivityTaskCompletedEventAttributes {
+            scheduled_event_id,
+            started_event_id,
+            result: vec![payload].into_payloads(),
+            ..Default::default()
+        });
     }
 
     pub fn add_activity_task_cancel_requested(&mut self, scheduled_event_id: i64) {
@@ -258,13 +236,10 @@ impl TestHistoryBuilder {
     }
 
     pub fn add_timer_fired(&mut self, timer_started_evt_id: i64, timer_id: String) {
-        self.add(
-            EventType::TimerFired,
-            history_event::Attributes::TimerFiredEventAttributes(TimerFiredEventAttributes {
-                started_event_id: timer_started_evt_id,
-                timer_id,
-            }),
-        );
+        self.add(TimerFiredEventAttributes {
+            started_event_id: timer_started_evt_id,
+            timer_id,
+        });
     }
 
     pub fn add_we_signaled(&mut self, signal_name: &str, payloads: Vec<Payload>) {
@@ -298,7 +273,7 @@ impl TestHistoryBuilder {
             seq,
             attempt: 1,
             activity_id: activity_id.to_string(),
-            activity_type: "some_act_type".to_string(),
+            activity_type: DEFAULT_ACTIVITY_TYPE.to_string(),
             complete_time: None,
             backoff: None,
             original_schedule_time: None,
@@ -369,7 +344,7 @@ impl TestHistoryBuilder {
         workflow_id: impl Into<String>,
         run_id: impl Into<String>,
     ) -> i64 {
-        let attrs = SignalExternalWorkflowExecutionInitiatedEventAttributes {
+        self.add(SignalExternalWorkflowExecutionInitiatedEventAttributes {
             workflow_task_completed_event_id: self.previous_task_completed_id,
             workflow_execution: Some(WorkflowExecution {
                 workflow_id: workflow_id.into(),
@@ -378,11 +353,7 @@ impl TestHistoryBuilder {
             signal_name: signal_name.into(),
             control: "".to_string(),
             ..Default::default()
-        };
-        self.add_get_event_id(
-            EventType::SignalExternalWorkflowExecutionInitiated,
-            Some(attrs.into()),
-        )
+        })
     }
 
     pub fn add_external_signal_completed(&mut self, initiated_id: i64) {
@@ -405,18 +376,16 @@ impl TestHistoryBuilder {
     }
 
     pub fn add_cancel_external_wf(&mut self, execution: NamespacedWorkflowExecution) -> i64 {
-        let attrs = RequestCancelExternalWorkflowExecutionInitiatedEventAttributes {
-            workflow_task_completed_event_id: self.previous_task_completed_id,
-            namespace: execution.namespace,
-            workflow_execution: Some(WorkflowExecution {
-                workflow_id: execution.workflow_id,
-                run_id: execution.run_id,
-            }),
-            ..Default::default()
-        };
-        self.add_get_event_id(
-            EventType::RequestCancelExternalWorkflowExecutionInitiated,
-            Some(attrs.into()),
+        self.add(
+            RequestCancelExternalWorkflowExecutionInitiatedEventAttributes {
+                workflow_task_completed_event_id: self.previous_task_completed_id,
+                namespace: execution.namespace,
+                workflow_execution: Some(WorkflowExecution {
+                    workflow_id: execution.workflow_id,
+                    run_id: execution.run_id,
+                }),
+                ..Default::default()
+            },
         )
     }
 
@@ -442,6 +411,12 @@ impl TestHistoryBuilder {
         );
     }
 
+    pub fn add_wfe_started_with_wft_timeout(&mut self, dur: Duration) {
+        let mut wesattrs = default_wes_attribs();
+        wesattrs.workflow_task_timeout = Some(dur.try_into().unwrap());
+        self.add(wesattrs);
+    }
+
     pub fn get_orig_run_id(&self) -> &str {
         &self.original_run_id
     }
@@ -466,7 +441,7 @@ impl TestHistoryBuilder {
     }
 
     /// Return most recent wft start time or panic if unset
-    pub fn wft_start_time(&self) -> prost_types::Timestamp {
+    pub fn wft_start_time(&self) -> Timestamp {
         self.events[(self.workflow_task_scheduled_event_id + 1) as usize]
             .event_time
             .clone()
@@ -493,6 +468,37 @@ impl TestHistoryBuilder {
         modifier(he);
     }
 
+    /// Sets internal patches which should appear in the first WFT complete event
+    pub fn set_flags_first_wft(&mut self, core: &[u32], lang: &[u32]) {
+        Self::set_flags(self.events.iter_mut(), core, lang)
+    }
+
+    /// Sets internal patches which should appear in the most recent complete event
+    pub fn set_flags_last_wft(&mut self, core: &[u32], lang: &[u32]) {
+        Self::set_flags(self.events.iter_mut().rev(), core, lang)
+    }
+
+    fn set_flags<'a>(
+        mut events: impl Iterator<Item = &'a mut HistoryEvent>,
+        core: &[u32],
+        lang: &[u32],
+    ) {
+        if let Some(first_attrs) = events.find_map(|e| {
+            if let Some(Attributes::WorkflowTaskCompletedEventAttributes(a)) = e.attributes.as_mut()
+            {
+                Some(a)
+            } else {
+                None
+            }
+        }) {
+            let sdk_dat = first_attrs
+                .sdk_metadata
+                .get_or_insert_with(Default::default);
+            sdk_dat.core_used_flags = core.to_vec();
+            sdk_dat.lang_used_flags = lang.to_vec();
+        }
+    }
+
     fn build_and_push_event(&mut self, event_type: EventType, attribs: Attributes) {
         self.current_event_id += 1;
         let evt = HistoryEvent {
@@ -542,3 +548,10 @@ pub fn default_wes_attribs() -> WorkflowExecutionStartedEventAttributes {
         ..Default::default()
     }
 }
+
+pub fn default_act_sched() -> ScheduleActivity {
+    ScheduleActivity {
+        activity_type: DEFAULT_ACTIVITY_TYPE.to_string(),
+        ..Default::default()
+    }
+}

data/bridge/sdk-core/sdk-core-protos/src/history_info.rs

@@ -136,6 +136,10 @@ impl HistoryInfo {
         &self.events
     }
 
+    pub fn into_events(self) -> Vec<HistoryEvent> {
+        self.events
+    }
+
     /// Extract run id from the workflow execution started attributes.
     pub fn orig_run_id(&self) -> &str {
         &self.wf_exe_started_attrs.original_execution_run_id
@@ -204,7 +208,7 @@ mod tests {
         let mut t = TestHistoryBuilder::default();
         t.add_by_type(EventType::WorkflowExecutionStarted);
         t.add_full_wf_task();
-        let timer_started_event_id = t.add_get_event_id(EventType::TimerStarted, None);
+        let timer_started_event_id = t.add_by_type(EventType::TimerStarted);
         t.add_timer_fired(timer_started_event_id, timer_id.to_string());
         t.add_workflow_task_scheduled_and_started();
         t