@temporalio/core-bridge 1.7.4 → 1.8.1

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

@@ -65,6 +65,7 @@ use crate::{
 use anyhow::{anyhow, bail, Context};
 use app_data::AppData;
 use futures::{future::BoxFuture, FutureExt, StreamExt, TryFutureExt, TryStreamExt};
+use serde::Serialize;
 use std::{
     any::{Any, TypeId},
     cell::RefCell,
@@ -147,7 +148,7 @@ struct WorkflowData {
     activation_chan: UnboundedSender<WorkflowActivation>,
 }
 
-struct WorkflowFutureHandle<F: Future<Output = Result<WorkflowResult<()>, JoinError>>> {
+struct WorkflowFutureHandle<F: Future<Output = Result<WorkflowResult<Payload>, JoinError>>> {
     join_handle: F,
     run_id: String,
 }
@@ -193,10 +194,10 @@ impl Worker {
 
     /// Register a Workflow function to invoke when the Worker is asked to run a workflow of
     /// `workflow_type`
-    pub fn register_wf<F: Into<WorkflowFunction>>(
+    pub fn register_wf(
         &mut self,
         workflow_type: impl Into<String>,
-        wf_function: F,
+        wf_function: impl Into<WorkflowFunction>,
     ) {
         self.workflow_half
             .workflow_fns
@@ -383,7 +384,9 @@ impl WorkflowHalf {
         activation: WorkflowActivation,
         completions_tx: &UnboundedSender<WorkflowActivationCompletion>,
     ) -> Result<
-        Option<WorkflowFutureHandle<impl Future<Output = Result<WorkflowResult<()>, JoinError>>>>,
+        Option<
+            WorkflowFutureHandle<impl Future<Output = Result<WorkflowResult<Payload>, JoinError>>>,
+        >,
         anyhow::Error,
     > {
         let mut res = None;
@@ -694,17 +697,21 @@ struct CommandSubscribeChildWorkflowCompletion {
     unblocker: oneshot::Sender<UnblockEvent>,
 }
 
-type WfFunc = dyn Fn(WfContext) -> BoxFuture<'static, WorkflowResult<()>> + Send + Sync + 'static;
+type WfFunc = dyn Fn(WfContext) -> BoxFuture<'static, Result<WfExitValue<Payload>, anyhow::Error>>
+    + Send
+    + Sync
+    + 'static;
 
 /// The user's async function / workflow code
 pub struct WorkflowFunction {
     wf_func: Box<WfFunc>,
 }
 
-impl<F, Fut> From<F> for WorkflowFunction
+impl<F, Fut, O> From<F> for WorkflowFunction
 where
     F: Fn(WfContext) -> Fut + Send + Sync + 'static,
-    Fut: Future<Output = WorkflowResult<()>> + Send + 'static,
+    Fut: Future<Output = Result<WfExitValue<O>, anyhow::Error>> + Send + 'static,
+    O: Serialize + Debug,
 {
     fn from(wf_func: F) -> Self {
         Self::new(wf_func)
@@ -713,13 +720,27 @@ where
 
 impl WorkflowFunction {
     /// Build a workflow function from a closure or function pointer which accepts a [WfContext]
-    pub fn new<F, Fut>(wf_func: F) -> Self
+    pub fn new<F, Fut, O>(f: F) -> Self
     where
         F: Fn(WfContext) -> Fut + Send + Sync + 'static,
-        Fut: Future<Output = WorkflowResult<()>> + Send + 'static,
+        Fut: Future<Output = Result<WfExitValue<O>, anyhow::Error>> + Send + 'static,
+        O: Serialize + Debug,
     {
         Self {
-            wf_func: Box::new(move |ctx: WfContext| wf_func(ctx).boxed()),
+            wf_func: Box::new(move |ctx: WfContext| {
+                (f)(ctx)
+                    .map(|r| {
+                        r.and_then(|r| {
+                            Ok(match r {
+                                WfExitValue::ContinueAsNew(b) => WfExitValue::ContinueAsNew(b),
+                                WfExitValue::Cancelled => WfExitValue::Cancelled,
+                                WfExitValue::Evicted => WfExitValue::Evicted,
+                                WfExitValue::Normal(o) => WfExitValue::Normal(o.as_json_payload()?),
+                            })
+                        })
+                    })
+                    .boxed()
+            }),
         }
     }
 }

package/sdk-core/sdk/src/workflow_future.rs

@@ -50,7 +50,7 @@ impl WorkflowFunction {
         args: Vec<Payload>,
         outgoing_completions: UnboundedSender<WorkflowActivationCompletion>,
     ) -> (
-        impl Future<Output = WorkflowResult<()>>,
+        impl Future<Output = WorkflowResult<Payload>>,
         UnboundedSender<WorkflowActivation>,
     ) {
         let (cancel_tx, cancel_rx) = watch::channel(false);
@@ -93,7 +93,7 @@ enum SigChanOrBuffer {
 
 pub struct WorkflowFuture {
     /// Future produced by calling the workflow function
-    inner: BoxFuture<'static, WorkflowResult<()>>,
+    inner: BoxFuture<'static, WorkflowResult<Payload>>,
     /// Commands produced inside user's wf code
     incoming_commands: Receiver<RustWfCmd>,
     /// Once blocked or the workflow has finished or errored out, the result is sent here
@@ -234,7 +234,7 @@ impl WorkflowFuture {
 }
 
 impl Future for WorkflowFuture {
-    type Output = WorkflowResult<()>;
+    type Output = WorkflowResult<Payload>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         'activations: loop {
@@ -443,10 +443,12 @@ impl Future for WorkflowFuture {
                 match res {
                     Ok(exit_val) => match exit_val {
                         // TODO: Generic values
-                        WfExitValue::Normal(_) => {
+                        WfExitValue::Normal(result) => {
                             activation_cmds.push(
                                 workflow_command::Variant::CompleteWorkflowExecution(
-                                    CompleteWorkflowExecution { result: None },
+                                    CompleteWorkflowExecution {
+                                        result: Some(result),
+                                    },
                                 ),
                             );
                         }

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

@@ -106,6 +106,7 @@ impl TestHistoryBuilder {
     pub fn add_workflow_task_started(&mut self) {
         self.final_workflow_task_started_event_id = self.add(WorkflowTaskStartedEventAttributes {
             scheduled_event_id: self.workflow_task_scheduled_event_id,
+            history_size_bytes: ((self.events.len() + 1) * 10) as i64,
             ..Default::default()
         });
     }
@@ -562,6 +563,7 @@ pub fn default_wes_attribs() -> WorkflowExecutionStartedEventAttributes {
         task_queue: Some(TaskQueue {
             name: "q".to_string(),
             kind: TaskQueueKind::Normal as i32,
+            normal_name: "".to_string(),
         }),
         ..Default::default()
     }

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

@@ -172,6 +172,7 @@ impl HistoryInfo {
                     .name
                     .clone(),
                 kind: TaskQueueKind::Normal as i32,
+                normal_name: "".to_string(),
             }),
             previous_started_event_id: self.previous_started_event_id,
             started_event_id: self.workflow_task_started_event_id,

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

@@ -454,6 +454,8 @@ pub mod coresdk {
                     }),
                 )],
                 available_internal_flags: vec![],
+                history_size_bytes: 0,
+                continue_as_new_suggested: false,
             }
         }
 
@@ -1500,53 +1502,57 @@ pub mod temporal {
                     }
                 }
 
-                impl From<workflow_commands::ScheduleActivity> for command::Attributes {
-                    fn from(s: workflow_commands::ScheduleActivity) -> Self {
-                        Self::ScheduleActivityTaskCommandAttributes(
-                            ScheduleActivityTaskCommandAttributes {
-                                activity_id: s.activity_id,
-                                activity_type: Some(ActivityType {
-                                    name: s.activity_type,
-                                }),
-                                task_queue: Some(s.task_queue.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,
-                                start_to_close_timeout: s.start_to_close_timeout,
-                                heartbeat_timeout: s.heartbeat_timeout,
-                                retry_policy: s.retry_policy.map(Into::into),
-                                request_eager_execution: !s.do_not_eagerly_execute,
-                            },
-                        )
-                    }
+                pub fn schedule_activity_cmd_to_api(
+                    s: workflow_commands::ScheduleActivity,
+                    use_compatible_version: bool,
+                ) -> command::Attributes {
+                    command::Attributes::ScheduleActivityTaskCommandAttributes(
+                        ScheduleActivityTaskCommandAttributes {
+                            activity_id: s.activity_id,
+                            activity_type: Some(ActivityType {
+                                name: s.activity_type,
+                            }),
+                            task_queue: Some(s.task_queue.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,
+                            start_to_close_timeout: s.start_to_close_timeout,
+                            heartbeat_timeout: s.heartbeat_timeout,
+                            retry_policy: s.retry_policy.map(Into::into),
+                            request_eager_execution: !s.do_not_eagerly_execute,
+                            use_compatible_version,
+                        },
+                    )
                 }
 
-                impl From<workflow_commands::StartChildWorkflowExecution> for command::Attributes {
-                    fn from(s: workflow_commands::StartChildWorkflowExecution) -> Self {
-                        Self::StartChildWorkflowExecutionCommandAttributes(
-                            StartChildWorkflowExecutionCommandAttributes {
-                                workflow_id: s.workflow_id,
-                                workflow_type: Some(WorkflowType {
-                                    name: s.workflow_type,
-                                }),
-                                control: "".into(),
-                                namespace: s.namespace,
-                                task_queue: Some(s.task_queue.into()),
-                                header: Some(s.headers.into()),
-                                memo: Some(s.memo.into()),
-                                search_attributes: Some(s.search_attributes.into()),
-                                input: s.input.into_payloads(),
-                                workflow_id_reuse_policy: s.workflow_id_reuse_policy,
-                                workflow_execution_timeout: s.workflow_execution_timeout,
-                                workflow_run_timeout: s.workflow_run_timeout,
-                                workflow_task_timeout: s.workflow_task_timeout,
-                                retry_policy: s.retry_policy.map(Into::into),
-                                cron_schedule: s.cron_schedule.clone(),
-                                parent_close_policy: s.parent_close_policy,
-                            },
-                        )
-                    }
+                pub fn start_child_workflow_cmd_to_api(
+                    s: workflow_commands::StartChildWorkflowExecution,
+                    use_compatible_version: bool,
+                ) -> command::Attributes {
+                    command::Attributes::StartChildWorkflowExecutionCommandAttributes(
+                        StartChildWorkflowExecutionCommandAttributes {
+                            workflow_id: s.workflow_id,
+                            workflow_type: Some(WorkflowType {
+                                name: s.workflow_type,
+                            }),
+                            control: "".into(),
+                            namespace: s.namespace,
+                            task_queue: Some(s.task_queue.into()),
+                            header: Some(s.headers.into()),
+                            memo: Some(s.memo.into()),
+                            search_attributes: Some(s.search_attributes.into()),
+                            input: s.input.into_payloads(),
+                            workflow_id_reuse_policy: s.workflow_id_reuse_policy,
+                            workflow_execution_timeout: s.workflow_execution_timeout,
+                            workflow_run_timeout: s.workflow_run_timeout,
+                            workflow_task_timeout: s.workflow_task_timeout,
+                            retry_policy: s.retry_policy.map(Into::into),
+                            cron_schedule: s.cron_schedule.clone(),
+                            parent_close_policy: s.parent_close_policy,
+                            use_compatible_version,
+                        },
+                    )
                 }
 
                 impl From<workflow_commands::CompleteWorkflowExecution> for command::Attributes {
@@ -1569,35 +1575,37 @@ pub mod temporal {
                     }
                 }
 
-                impl From<workflow_commands::ContinueAsNewWorkflowExecution> for command::Attributes {
-                    fn from(c: workflow_commands::ContinueAsNewWorkflowExecution) -> Self {
-                        Self::ContinueAsNewWorkflowExecutionCommandAttributes(
-                            ContinueAsNewWorkflowExecutionCommandAttributes {
-                                workflow_type: Some(c.workflow_type.into()),
-                                task_queue: Some(c.task_queue.into()),
-                                input: c.arguments.into_payloads(),
-                                workflow_run_timeout: c.workflow_run_timeout,
-                                workflow_task_timeout: c.workflow_task_timeout,
-                                memo: if c.memo.is_empty() {
-                                    None
-                                } else {
-                                    Some(c.memo.into())
-                                },
-                                header: if c.headers.is_empty() {
-                                    None
-                                } else {
-                                    Some(c.headers.into())
-                                },
-                                retry_policy: c.retry_policy,
-                                search_attributes: if c.search_attributes.is_empty() {
-                                    None
-                                } else {
-                                    Some(c.search_attributes.into())
-                                },
-                                ..Default::default()
+                pub fn continue_as_new_cmd_to_api(
+                    c: workflow_commands::ContinueAsNewWorkflowExecution,
+                    use_compatible_version: bool,
+                ) -> command::Attributes {
+                    command::Attributes::ContinueAsNewWorkflowExecutionCommandAttributes(
+                        ContinueAsNewWorkflowExecutionCommandAttributes {
+                            workflow_type: Some(c.workflow_type.into()),
+                            task_queue: Some(c.task_queue.into()),
+                            input: c.arguments.into_payloads(),
+                            workflow_run_timeout: c.workflow_run_timeout,
+                            workflow_task_timeout: c.workflow_task_timeout,
+                            memo: if c.memo.is_empty() {
+                                None
+                            } else {
+                                Some(c.memo.into())
                             },
-                        )
-                    }
+                            header: if c.headers.is_empty() {
+                                None
+                            } else {
+                                Some(c.headers.into())
+                            },
+                            retry_policy: c.retry_policy,
+                            search_attributes: if c.search_attributes.is_empty() {
+                                None
+                            } else {
+                                Some(c.search_attributes.into())
+                            },
+                            use_compatible_version,
+                            ..Default::default()
+                        },
+                    )
                 }
 
                 impl From<workflow_commands::CancelWorkflowExecution> for command::Attributes {
@@ -1971,6 +1979,7 @@ pub mod temporal {
                         Self {
                             name,
                             kind: TaskQueueKind::Normal as i32,
+                            normal_name: "".to_string(),
                         }
                     }
                 }

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

@@ -24,7 +24,7 @@ rmp-serde = "1.1"
 serde_json = "1.0"
 temporal-client = { path = "../client" }
 temporal-sdk = { path = "../sdk" }
-temporal-sdk-core = { path = "../core" }
+temporal-sdk-core = { path = "../core", features = ["ephemeral-server"] }
 temporal-sdk-core-api = { path = "../core-api" }
 thiserror = "1.0"
 tokio = "1.1"

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

@@ -33,7 +33,7 @@ use temporal_sdk_core::{
     ephemeral_server::{EphemeralExe, EphemeralExeVersion},
     init_replay_worker, init_worker,
     replay::HistoryForReplay,
-    ClientOptions, ClientOptionsBuilder, CoreRuntime, WorkerConfig, WorkerConfigBuilder,
+    ClientOptions, ClientOptionsBuilder, CoreRuntime, WorkerConfigBuilder,
 };
 use temporal_sdk_core_api::{
     errors::{PollActivityError, PollWfError},
@@ -61,6 +61,7 @@ pub const NAMESPACE: &str = "default";
 pub const TEST_Q: &str = "q";
 /// The env var used to specify where the integ tests should point
 pub const INTEG_SERVER_TARGET_ENV_VAR: &str = "TEMPORAL_SERVICE_ADDRESS";
+pub const INTEG_NAMESPACE_ENV_VAR: &str = "TEMPORAL_NAMESPACE";
 pub const INTEG_USE_TLS_ENV_VAR: &str = "TEMPORAL_USE_TLS";
 /// This env var is set (to any value) if temporal CLI dev server is in use
 pub const INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR: &str = "INTEG_TEMPORAL_DEV_SERVER_ON";
@@ -153,10 +154,11 @@ pub fn init_integ_telem() {
 pub struct CoreWfStarter {
     /// Used for both the task queue and workflow id
     task_queue_name: String,
-    pub worker_config: WorkerConfig,
+    pub worker_config: WorkerConfigBuilder,
     /// Options to use when starting workflow(s)
     pub workflow_options: WorkflowOptions,
     initted_worker: OnceCell<InitializedWorker>,
+    runtime_override: Option<CoreRuntime>,
 }
 struct InitializedWorker {
     worker: Arc<dyn CoreWorker>,
@@ -166,28 +168,36 @@ struct InitializedWorker {
 impl CoreWfStarter {
     pub fn new(test_name: &str) -> Self {
         init_integ_telem();
+        Self::_new(test_name, None)
+    }
+
+    pub fn new_with_runtime(test_name: &str, runtime: CoreRuntime) -> Self {
+        Self::_new(test_name, Some(runtime))
+    }
+
+    fn _new(test_name: &str, runtime_override: Option<CoreRuntime>) -> Self {
         let rand_bytes: Vec<u8> = rand::thread_rng().sample_iter(&Standard).take(6).collect();
         let task_q_salt = BASE64_STANDARD.encode(rand_bytes);
         let task_queue = format!("{test_name}_{task_q_salt}");
+        let mut worker_config = WorkerConfigBuilder::default();
+        worker_config
+            .namespace(env::var(INTEG_NAMESPACE_ENV_VAR).unwrap_or(NAMESPACE.to_string()))
+            .task_queue(task_queue.clone())
+            .worker_build_id("test_build_id")
+            .max_cached_workflows(1000_usize);
         Self {
-            task_queue_name: task_queue.to_owned(),
-            worker_config: WorkerConfigBuilder::default()
-                .namespace(NAMESPACE)
-                .task_queue(task_queue)
-                .worker_build_id("test_build_id")
-                .max_cached_workflows(1000_usize)
-                .build()
-                .unwrap(),
+            task_queue_name: task_queue,
+            worker_config,
             initted_worker: OnceCell::new(),
             workflow_options: Default::default(),
+            runtime_override,
         }
     }
 
     pub async fn worker(&mut self) -> TestWorker {
-        let mut w = TestWorker::new(
-            self.get_worker().await,
-            self.worker_config.task_queue.clone(),
-        );
+        let w = self.get_worker().await;
+        let tq = w.get_config().task_queue.clone();
+        let mut w = TestWorker::new(w, tq);
         w.client = Some(self.get_client().await);
 
         w
@@ -227,16 +237,14 @@ impl CoreWfStarter {
     }
 
     pub async fn start_wf_with_id(&self, workflow_id: String) -> String {
-        self.initted_worker
-            .get()
-            .expect(
-                "Worker must be initted before starting a workflow.\
+        let iw = self.initted_worker.get().expect(
+            "Worker must be initted before starting a workflow.\
                              Tests must call `get_worker` first.",
-            )
-            .client
+        );
+        iw.client
             .start_workflow(
                 vec![],
-                self.worker_config.task_queue.clone(),
+                iw.worker.get_config().task_queue.clone(),
                 workflow_id,
                 self.task_queue_name.clone(),
                 None,
@@ -273,7 +281,7 @@ impl CoreWfStarter {
     }
 
     pub fn get_task_queue(&self) -> &str {
-        &self.worker_config.task_queue
+        &self.task_queue_name
     }
 
     pub fn get_wf_id(&self) -> &str {
@@ -281,60 +289,65 @@ impl CoreWfStarter {
     }
 
     pub fn max_cached_workflows(&mut self, num: usize) -> &mut Self {
-        self.worker_config.max_cached_workflows = num;
+        self.worker_config.max_cached_workflows(num);
         self
     }
 
     pub fn max_wft(&mut self, max: usize) -> &mut Self {
-        self.worker_config.max_outstanding_workflow_tasks = max;
+        self.worker_config.max_outstanding_workflow_tasks(max);
         self
     }
 
     pub fn max_at(&mut self, max: usize) -> &mut Self {
-        self.worker_config.max_outstanding_activities = max;
+        self.worker_config.max_outstanding_activities(max);
         self
     }
 
     pub fn max_local_at(&mut self, max: usize) -> &mut Self {
-        self.worker_config.max_outstanding_local_activities = max;
+        self.worker_config.max_outstanding_local_activities(max);
         self
     }
 
     pub fn max_at_polls(&mut self, max: usize) -> &mut Self {
-        self.worker_config.max_concurrent_at_polls = max;
+        self.worker_config.max_concurrent_at_polls(max);
+
         self
     }
 
     pub fn no_remote_activities(&mut self) -> &mut Self {
-        self.worker_config.no_remote_activities = true;
+        self.worker_config.no_remote_activities(true);
         self
     }
 
     pub fn enable_wf_state_input_recording(&mut self) -> &mut Self {
         let (ser_tx, ser_rx) = unbounded_channel();
-        let worker_cfg_clone = self.worker_config.clone();
+        let worker_cfg_clone = self.worker_config.build().unwrap();
         tokio::spawn(async move {
             stream_to_file(&worker_cfg_clone, ser_rx).await.unwrap();
         });
-        self.worker_config.wf_state_inputs = Some(ser_tx);
+        self.worker_config.wf_state_inputs(Some(ser_tx));
         self
     }
 
     async fn get_or_init(&mut self) -> &InitializedWorker {
         self.initted_worker
             .get_or_init(|| async {
+                let cfg = self
+                    .worker_config
+                    .build()
+                    .expect("Worker config must be valid");
                 let client = Arc::new(
                     get_integ_server_options()
-                        .connect(self.worker_config.namespace.clone(), None, None)
+                        .connect(cfg.namespace.clone(), None, None)
                         .await
                         .expect("Must connect"),
                 );
-                let worker = init_worker(
-                    INTEG_TESTS_RT.get().unwrap(),
-                    self.worker_config.clone(),
-                    client.clone(),
-                )
-                .expect("Worker inits cleanly");
+                let rt = if let Some(ref rto) = self.runtime_override {
+                    rto
+                } else {
+                    INTEG_TESTS_RT.get().unwrap()
+                };
+                let worker = init_worker(rt, cfg, client.clone()).expect("Worker inits cleanly");
                 InitializedWorker {
                     worker: Arc::new(worker),
                     client,