temporalio 0.0.1 → 0.1.0

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

@@ -6,22 +6,25 @@ use crate::{
             NamespacedWorkflowExecution,
         },
         external_data::LocalActivityMarkerData,
+        workflow_commands::ScheduleActivity,
         IntoPayloadsExt,
     },
     temporal::api::{
-        common::v1::{Payload, Payloads, WorkflowExecution, WorkflowType},
-        enums::v1::{EventType, WorkflowTaskFailedCause},
+        common::v1::{ActivityType, Payload, Payloads, WorkflowExecution, WorkflowType},
+        enums::v1::{EventType, TaskQueueKind, WorkflowTaskFailedCause},
         failure::v1::{failure, CanceledFailureInfo, Failure},
         history::v1::{history_event::Attributes, *},
+        taskqueue::v1::TaskQueue,
     },
     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>;
 
@@ -38,27 +41,41 @@ pub struct TestHistoryBuilder {
 }
 
 impl TestHistoryBuilder {
+    pub fn from_history(events: Vec<HistoryEvent>) -> Self {
+        let find_matching_id = |etype: EventType| {
+            events
+                .iter()
+                .rev()
+                .find(|e| e.event_type() == etype)
+                .map(|e| e.event_id)
+                .unwrap_or_default()
+        };
+        Self {
+            current_event_id: events.last().map(|e| e.event_id).unwrap_or_default(),
+            workflow_task_scheduled_event_id: find_matching_id(EventType::WorkflowTaskScheduled),
+            final_workflow_task_started_event_id: find_matching_id(EventType::WorkflowTaskStarted),
+            previous_task_completed_id: find_matching_id(EventType::WorkflowTaskCompleted),
+            original_run_id: extract_original_run_id_from_events(&events)
+                .expect("Run id must be discoverable")
+                .to_string(),
+            events,
+        }
+    }
+
     /// 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:
@@ -78,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;
     }
 
@@ -154,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(
@@ -186,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) {
@@ -236,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>) {
@@ -270,22 +267,21 @@ impl TestHistoryBuilder {
         activity_id: &str,
         payload: Option<Payload>,
         failure: Option<Failure>,
-        complete_time: Option<Timestamp>,
+        detail_mutator: impl FnOnce(&mut LocalActivityMarkerData),
     ) {
+        let mut lamd = LocalActivityMarkerData {
+            seq,
+            attempt: 1,
+            activity_id: activity_id.to_string(),
+            activity_type: DEFAULT_ACTIVITY_TYPE.to_string(),
+            complete_time: None,
+            backoff: None,
+            original_schedule_time: None,
+        };
+        detail_mutator(&mut lamd);
         let attrs = MarkerRecordedEventAttributes {
             marker_name: LOCAL_ACTIVITY_MARKER_NAME.to_string(),
-            details: build_local_activity_marker_details(
-                LocalActivityMarkerData {
-                    seq,
-                    attempt: 1,
-                    activity_id: activity_id.to_string(),
-                    activity_type: "some_act_type".to_string(),
-                    complete_time,
-                    backoff: None,
-                    original_schedule_time: None,
-                },
-                payload,
-            ),
+            details: build_local_activity_marker_details(lamd, payload),
             workflow_task_completed_event_id: self.previous_task_completed_id,
             failure,
             ..Default::default()
@@ -299,7 +295,7 @@ impl TestHistoryBuilder {
         activity_id: &str,
         payload: Payload,
     ) {
-        self.add_local_activity_marker(seq, activity_id, Some(payload), None, None);
+        self.add_local_activity_marker(seq, activity_id, Some(payload), None, |_| {});
     }
 
     pub fn add_local_activity_result_marker_with_time(
@@ -309,7 +305,9 @@ impl TestHistoryBuilder {
         payload: Payload,
         complete_time: Timestamp,
     ) {
-        self.add_local_activity_marker(seq, activity_id, Some(payload), None, Some(complete_time));
+        self.add_local_activity_marker(seq, activity_id, Some(payload), None, |d| {
+            d.complete_time = Some(complete_time)
+        });
     }
 
     pub fn add_local_activity_fail_marker(
@@ -318,7 +316,7 @@ impl TestHistoryBuilder {
         activity_id: &str,
         failure: Failure,
     ) {
-        self.add_local_activity_marker(seq, activity_id, None, Some(failure), None);
+        self.add_local_activity_marker(seq, activity_id, None, Some(failure), |_| {});
     }
 
     pub fn add_local_activity_cancel_marker(&mut self, seq: u32, activity_id: &str) {
@@ -336,7 +334,7 @@ impl TestHistoryBuilder {
                 )),
                 encoded_attributes: Default::default(),
             }),
-            None,
+            |_| {},
         );
     }
 
@@ -346,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(),
@@ -355,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) {
@@ -382,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()
+            },
         )
     }
 
@@ -419,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
     }
@@ -443,13 +441,64 @@ 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()
             .unwrap()
     }
 
+    /// Alter the workflow type of the history
+    pub fn set_wf_type(&mut self, name: &str) {
+        if let Some(Attributes::WorkflowExecutionStartedEventAttributes(wes)) =
+            self.events.get_mut(0).and_then(|e| e.attributes.as_mut())
+        {
+            wes.workflow_type = Some(WorkflowType {
+                name: name.to_string(),
+            })
+        }
+    }
+
+    /// 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
+            .events
+            .get_mut((event_id - 1) as usize)
+            .expect("Event must be present");
+        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 {
@@ -492,6 +541,17 @@ pub fn default_wes_attribs() -> WorkflowExecutionStartedEventAttributes {
                 .try_into()
                 .expect("5 secs is a valid duration"),
         ),
+        task_queue: Some(TaskQueue {
+            name: "q".to_string(),
+            kind: TaskQueueKind::Normal as i32,
+        }),
+        ..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

@@ -1,7 +1,7 @@
 use crate::temporal::api::{
     common::v1::WorkflowType,
     enums::v1::{EventType, TaskQueueKind},
-    history::v1::{history_event, History, HistoryEvent},
+    history::v1::{history_event, History, HistoryEvent, WorkflowExecutionStartedEventAttributes},
     taskqueue::v1::TaskQueue,
     workflowservice::v1::{GetWorkflowExecutionHistoryResponse, PollWorkflowTaskQueueResponse},
 };
@@ -18,6 +18,7 @@ pub struct HistoryInfo {
     events: Vec<HistoryEvent>,
     wf_task_count: usize,
     wf_type: String,
+    wf_exe_started_attrs: WorkflowExecutionStartedEventAttributes,
 }
 
 type Result<T, E = anyhow::Error> = std::result::Result<T, E>;
@@ -36,20 +37,18 @@ impl HistoryInfo {
         let mut workflow_task_started_event_id = 0;
         let mut wf_task_count = 0;
         let mut history = events.iter().peekable();
-
-        let wf_type = match &events.get(0).unwrap().attributes {
+        let started_attrs = match &events.get(0).unwrap().attributes {
             Some(history_event::Attributes::WorkflowExecutionStartedEventAttributes(attrs)) => {
-                attrs
-                    .workflow_type
-                    .as_ref()
-                    .ok_or_else(|| {
-                        anyhow!("No workflow type defined in execution started attributes")
-                    })?
-                    .name
-                    .clone()
+                attrs.clone()
             }
             _ => bail!("First event in history was not workflow execution started!"),
         };
+        let wf_type = started_attrs
+            .workflow_type
+            .as_ref()
+            .ok_or_else(|| anyhow!("No workflow type defined in execution started attributes"))?
+            .name
+            .clone();
 
         let mut events = vec![];
         while let Some(event) = history.next() {
@@ -87,6 +86,7 @@ impl HistoryInfo {
                             events,
                             wf_task_count,
                             wf_type,
+                            wf_exe_started_attrs: started_attrs,
                         });
                     }
                 } else if next_event.is_some() && !next_is_failed_or_timeout_or_term {
@@ -108,6 +108,7 @@ impl HistoryInfo {
                         events,
                         wf_task_count,
                         wf_type,
+                        wf_exe_started_attrs: started_attrs,
                     });
                 }
                 // No more events
@@ -135,16 +136,13 @@ impl HistoryInfo {
         &self.events
     }
 
-    /// Attempt to extract run id from internal events. If the first event is not workflow execution
-    /// started, it will panic.
+    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 {
-        if let Some(history_event::Attributes::WorkflowExecutionStartedEventAttributes(wes)) =
-            &self.events[0].attributes
-        {
-            &wes.original_execution_run_id
-        } else {
-            panic!("First event is wrong type")
-        }
+        &self.wf_exe_started_attrs.original_execution_run_id
     }
 
     /// Return total workflow task count in this history
@@ -155,7 +153,7 @@ impl HistoryInfo {
     /// Create a workflow task polling response containing all the events in this history and a
     /// randomly generated task token. Caller should attach a meaningful `workflow_execution` if
     /// needed.
-    pub fn as_poll_wft_response(&self, task_q: impl Into<String>) -> PollWorkflowTaskQueueResponse {
+    pub fn as_poll_wft_response(&self) -> PollWorkflowTaskQueueResponse {
         let task_token: [u8; 16] = thread_rng().gen();
         PollWorkflowTaskQueueResponse {
             history: Some(History {
@@ -166,7 +164,13 @@ impl HistoryInfo {
                 name: self.wf_type.clone(),
             }),
             workflow_execution_task_queue: Some(TaskQueue {
-                name: task_q.into(),
+                name: self
+                    .wf_exe_started_attrs
+                    .task_queue
+                    .as_ref()
+                    .unwrap()
+                    .name
+                    .clone(),
                 kind: TaskQueueKind::Normal as i32,
             }),
             previous_started_event_id: self.previous_started_event_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