temporalio 0.0.1 → 0.0.2

data/bridge/sdk-core/sdk/src/interceptors.rs

@@ -1,7 +1,11 @@
 //! User-definable interceptors are defined in this module
 
 use crate::Worker;
-use temporal_sdk_core_protos::coresdk::workflow_completion::WorkflowActivationCompletion;
+use anyhow::bail;
+use temporal_sdk_core_protos::coresdk::{
+    workflow_activation::{remove_from_cache::EvictionReason, WorkflowActivation},
+    workflow_completion::WorkflowActivationCompletion,
+};
 
 /// Implementors can intercept certain actions that happen within the Worker.
 ///
@@ -10,8 +14,37 @@ use temporal_sdk_core_protos::coresdk::workflow_completion::WorkflowActivationCo
 pub trait WorkerInterceptor {
     /// Called every time a workflow activation completes (just before sending the completion to
     /// core).
-    async fn on_workflow_activation_completion(&self, completion: &WorkflowActivationCompletion);
+    async fn on_workflow_activation_completion(&self, _completion: &WorkflowActivationCompletion) {}
     /// Called after the worker has initiated shutdown and the workflow/activity polling loops
     /// have exited, but just before waiting for the inner core worker shutdown
-    fn on_shutdown(&self, sdk_worker: &Worker);
+    fn on_shutdown(&self, _sdk_worker: &Worker) {}
+    /// Called every time a workflow is about to be activated
+    async fn on_workflow_activation(
+        &self,
+        _activation: &WorkflowActivation,
+    ) -> Result<(), anyhow::Error> {
+        Ok(())
+    }
+}
+
+/// An interceptor which causes the worker's run function to exit early if nondeterminism errors are
+/// encountered
+pub struct FailOnNondeterminismInterceptor {}
+#[async_trait::async_trait(?Send)]
+impl WorkerInterceptor for FailOnNondeterminismInterceptor {
+    async fn on_workflow_activation(
+        &self,
+        activation: &WorkflowActivation,
+    ) -> Result<(), anyhow::Error> {
+        if matches!(
+            activation.eviction_reason(),
+            Some(EvictionReason::Nondeterminism)
+        ) {
+            bail!(
+                "Workflow is being evicted because of nondeterminism! {}",
+                activation
+            );
+        }
+        Ok(())
+    }
 }

data/bridge/sdk-core/sdk/src/lib.rs

@@ -10,8 +10,8 @@
 //! ```no_run
 //! use std::{str::FromStr, sync::Arc};
 //! use temporal_sdk::{sdk_client_options, ActContext, Worker};
-//! use temporal_sdk_core::{init_worker, telemetry_init, TelemetryOptionsBuilder, Url};
-//! use temporal_sdk_core_api::worker::WorkerConfigBuilder;
+//! use temporal_sdk_core::{init_worker, Url, CoreRuntime};
+//! use temporal_sdk_core_api::{worker::WorkerConfigBuilder, telemetry::TelemetryOptionsBuilder};
 //!
 //! #[tokio::main]
 //! async fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -20,14 +20,14 @@
 //!     let client = server_options.connect("default", None, None).await?;
 //!
 //!     let telemetry_options = TelemetryOptionsBuilder::default().build()?;
-//!     telemetry_init(&telemetry_options)?;
+//!     let runtime = CoreRuntime::new_assume_tokio(telemetry_options)?;
 //!
 //!     let worker_config = WorkerConfigBuilder::default()
 //!         .namespace("default")
 //!         .task_queue("task_queue")
 //!         .build()?;
 //!
-//!     let core_worker = init_worker(worker_config, client);
+//!     let core_worker = init_worker(&runtime, worker_config, client)?;
 //!
 //!     let mut worker = Worker::new_from_core(Arc::new(core_worker), "task_queue");
 //!     worker.register_activity(
@@ -46,7 +46,6 @@ extern crate tracing;
 
 mod activity_context;
 mod app_data;
-mod conversions;
 pub mod interceptors;
 mod payload_converter;
 mod workflow_context;
@@ -279,6 +278,9 @@ impl Worker {
                         }
                         o => o?,
                     };
+                    if let Some(ref i) = common.worker_interceptor {
+                        i.on_workflow_activation(&activation).await?;
+                    }
                     if let Some(wf_fut) = wf_half.workflow_activation_handler(
                         common,
                         shutdown_token.clone(),

data/bridge/sdk-core/sdk/src/workflow_context.rs

@@ -34,11 +34,11 @@ use temporal_sdk_core_protos::{
         workflow_commands::{
             request_cancel_external_workflow_execution as cancel_we,
             signal_external_workflow_execution as sig_we, workflow_command,
-            RequestCancelExternalWorkflowExecution, SetPatchMarker,
+            ModifyWorkflowProperties, RequestCancelExternalWorkflowExecution, SetPatchMarker,
             SignalExternalWorkflowExecution, StartTimer, UpsertWorkflowSearchAttributes,
         },
     },
-    temporal::api::common::v1::Payload,
+    temporal::api::common::v1::{Memo, Payload},
 };
 use tokio::sync::{mpsc, oneshot, watch};
 use tokio_stream::wrappers::UnboundedReceiverStream;
@@ -297,6 +297,17 @@ impl WfContext {
         ))
     }
 
+    /// Add or create a set of search attributes
+    pub fn upsert_memo(&self, attr_iter: impl IntoIterator<Item = (String, Payload)>) {
+        self.send(RustWfCmd::NewNonblockingCmd(
+            workflow_command::Variant::ModifyWorkflowProperties(ModifyWorkflowProperties {
+                upserted_memo: Some(Memo {
+                    fields: HashMap::from_iter(attr_iter.into_iter()),
+                }),
+            }),
+        ))
+    }
+
     /// Return a stream that produces values when the named signal is sent to this workflow
     pub fn make_signal_channel(&self, signal_name: impl Into<String>) -> DrainableSignalStream {
         let (tx, rx) = mpsc::unbounded_channel();

data/bridge/sdk-core/sdk/src/workflow_future.rs

@@ -1,7 +1,6 @@
 use crate::{
-    conversions::anyhow_to_fail, workflow_context::WfContextSharedData, CancellableID, RustWfCmd,
-    SignalData, TimerResult, UnblockEvent, WfContext, WfExitValue, WorkflowFunction,
-    WorkflowResult,
+    workflow_context::WfContextSharedData, CancellableID, RustWfCmd, SignalData, TimerResult,
+    UnblockEvent, WfContext, WfExitValue, WorkflowFunction, WorkflowResult,
 };
 use anyhow::{anyhow, bail, Context as AnyhowContext, Error};
 use crossbeam::channel::Receiver;
@@ -132,10 +131,7 @@ impl WorkflowFuture {
     fn fail_wft(&self, run_id: String, fail: Error) {
         warn!("Workflow task failed for {}: {}", run_id, fail);
         self.outgoing_completions
-            .send(WorkflowActivationCompletion::fail(
-                run_id,
-                anyhow_to_fail(fail),
-            ))
+            .send(WorkflowActivationCompletion::fail(run_id, fail.into()))
             .expect("Completion channel intact");
     }
 

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

@@ -15,7 +15,7 @@ history_builders = ["uuid", "rand"]
 
 [dependencies]
 anyhow = "1.0"
-base64 = "0.13"
+base64 = "0.20"
 derive_more = "0.99"
 prost = "0.11"
 prost-types = "0.11"

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

@@ -91,7 +91,6 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         .compile(
             &[
                 "../protos/local/temporal/sdk/core/core_interface.proto",
-                "../protos/local/temporal/sdk/core/bridge/bridge.proto",
                 "../protos/api_upstream/temporal/api/workflowservice/v1/service.proto",
                 "../protos/api_upstream/temporal/api/operatorservice/v1/service.proto",
                 "../protos/testsrv_upstream/temporal/api/testservice/v1/service.proto",

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

@@ -10,9 +10,10 @@ use crate::{
     },
     temporal::api::{
         common::v1::{Payload, Payloads, WorkflowExecution, WorkflowType},
-        enums::v1::{EventType, WorkflowTaskFailedCause},
+        enums::v1::{EventType, TaskQueueKind, WorkflowTaskFailedCause},
         failure::v1::{failure, CanceledFailureInfo, Failure},
         history::v1::{history_event::Attributes, *},
+        taskqueue::v1::TaskQueue,
     },
     HistoryInfo,
 };
@@ -38,6 +39,27 @@ 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) {
@@ -270,22 +292,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: "some_act_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 +320,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 +330,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 +341,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 +359,7 @@ impl TestHistoryBuilder {
                 )),
                 encoded_attributes: Default::default(),
             }),
-            None,
+            |_| {},
         );
     }
 
@@ -450,6 +473,26 @@ impl TestHistoryBuilder {
             .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);
+    }
+
     fn build_and_push_event(&mut self, event_type: EventType, attribs: Attributes) {
         self.current_event_id += 1;
         let evt = HistoryEvent {
@@ -492,6 +535,10 @@ 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()
     }
 }

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,9 @@ impl HistoryInfo {
         &self.events
     }
 
-    /// Attempt to extract run id from internal events. If the first event is not workflow execution
-    /// started, it will panic.
+    /// 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 +149,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 +160,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,