@temporalio/core-bridge 1.14.2-canary-release-testing.0 → 1.16.0

package/sdk-core/crates/sdk-core/tests/runner.rs

@@ -11,7 +11,7 @@ use std::{
     path::{Path, PathBuf},
     process::Stdio,
 };
-use temporalio_sdk_core::ephemeral_server::{TestServerConfigBuilder, default_cached_download};
+use temporalio_sdk_core::ephemeral_server::{TestServerConfig, default_cached_download};
 use tokio::{self, process::Command};
 
 /// This env var is set (to any value) if temporal CLI dev server is in use
@@ -95,9 +95,7 @@ async fn main() -> Result<(), anyhow::Error> {
     let (server, envs) = match server_kind {
         ServerKind::TemporalCLI => {
             let config =
-                integ_dev_server_config(vec!["--http-port".to_string(), "7243".to_string()])
-                    .ui(true)
-                    .build()?;
+                integ_dev_server_config(vec!["--http-port".to_string(), "7243".to_string()], true);
             println!("Using temporal CLI: {config:?}");
             (
                 Some(
@@ -109,9 +107,9 @@ async fn main() -> Result<(), anyhow::Error> {
             )
         }
         ServerKind::TestServer => {
-            let config = TestServerConfigBuilder::default()
+            let config = TestServerConfig::builder()
                 .exe(default_cached_download())
-                .build()?;
+                .build();
             println!("Using java test server");
             (
                 Some(

package/sdk-core/crates/sdk-core/tests/shared_tests/mod.rs

@@ -1,48 +1,94 @@
 //! Shared tests that are meant to be run against both local dev server and cloud
 
 use crate::common::CoreWfStarter;
-use std::sync::atomic::{AtomicBool, Ordering::Relaxed};
+use std::sync::{
+    Arc,
+    atomic::{AtomicBool, Ordering::Relaxed},
+};
 use temporalio_common::{
     protos::temporal::api::{
         enums::v1::{EventType, WorkflowTaskFailedCause::GrpcMessageTooLarge},
-        history::v1::history_event::Attributes::WorkflowTaskFailedEventAttributes,
+        history::v1::history_event::Attributes::{
+            WorkflowExecutionTerminatedEventAttributes, WorkflowTaskFailedEventAttributes,
+        },
     },
     worker::WorkerTaskTypes,
 };
-use temporalio_sdk::WfContext;
+use temporalio_macros::{workflow, workflow_methods};
+use temporalio_sdk::{WorkflowContext, WorkflowResult};
 
 pub(crate) mod priority;
 
+#[workflow]
+struct OversizeGrpcMessageWf {
+    run_flag: Arc<AtomicBool>,
+}
+
+#[workflow_methods(factory_only)]
+impl OversizeGrpcMessageWf {
+    #[run]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<Vec<u8>> {
+        if ctx.state(|wf| wf.run_flag.load(Relaxed)) {
+            Ok(vec![])
+        } else {
+            ctx.state(|wf| wf.run_flag.store(true, Relaxed));
+            let result: Vec<u8> = vec![0; 5000000];
+            Ok(result)
+        }
+    }
+}
+
 pub(crate) async fn grpc_message_too_large() {
+    let run_flag = Arc::new(AtomicBool::new(false));
+    let run_flag_clone = run_flag.clone();
+
     let wf_name = "oversize_grpc_message";
     let mut starter = CoreWfStarter::new_cloud_or_local(wf_name, "")
         .await
         .unwrap();
+    starter.sdk_config.task_types = WorkerTaskTypes::workflow_only();
     starter
-        .worker_config
-        .task_types(WorkerTaskTypes::workflow_only());
-    let mut core = starter.worker().await;
-
-    static OVERSIZE_GRPC_MESSAGE_RUN: AtomicBool = AtomicBool::new(false);
-    core.register_wf(wf_name.to_owned(), |_ctx: WfContext| async move {
-        if OVERSIZE_GRPC_MESSAGE_RUN.load(Relaxed) {
-            Ok(vec![].into())
+        .sdk_config
+        .register_workflow_with_factory(move || OversizeGrpcMessageWf {
+            run_flag: run_flag_clone.clone(),
+        });
+
+    let mut sdk = starter.worker().await;
+    sdk.submit_workflow(
+        OversizeGrpcMessageWf::run,
+        (),
+        starter.workflow_options.clone(),
+    )
+    .await
+    .unwrap();
+    sdk.run_until_done().await.unwrap();
+
+    let events = starter.get_history().await.events;
+    // Depending on the version of server, it may terminate the workflow, or simply be a task
+    // failure
+    assert!(
+        events.iter().any(is_oversize_grpc_event),
+        "Expected workflow task failure or termination b/c grpc message too large: {events:?}",
+    );
+}
+
+pub(crate) fn is_oversize_grpc_event(
+    e: &temporalio_common::protos::temporal::api::history::v1::HistoryEvent,
+) -> bool {
+    // Task failure
+    e.event_type == EventType::WorkflowTaskFailed as i32
+        && if let WorkflowTaskFailedEventAttributes(attr) = e.attributes.as_ref().unwrap() {
+            attr.cause == GrpcMessageTooLarge as i32
+                && attr.failure.as_ref().unwrap().message == "GRPC Message too large"
         } else {
-            OVERSIZE_GRPC_MESSAGE_RUN.store(true, Relaxed);
-            let result: Vec<u8> = vec![0; 5000000];
-            Ok(result.into())
+            false
+        }
+    // Workflow terminated
+    ||
+    e.event_type == EventType::WorkflowExecutionTerminated as i32
+        && if let WorkflowExecutionTerminatedEventAttributes(attr) = e.attributes.as_ref().unwrap() {
+            attr.reason == "GrpcMessageTooLarge"
+        } else {
+            false
         }
-    });
-    starter.start_with_worker(wf_name, &mut core).await;
-    core.run_until_done().await.unwrap();
-
-    assert!(starter.get_history().await.events.iter().any(|e| {
-        e.event_type == EventType::WorkflowTaskFailed as i32
-            && if let WorkflowTaskFailedEventAttributes(attr) = e.attributes.as_ref().unwrap() {
-                attr.cause == GrpcMessageTooLarge as i32
-                    && attr.failure.as_ref().unwrap().message == "GRPC Message too large"
-            } else {
-                false
-            }
-    }))
 }

package/sdk-core/crates/sdk-core/tests/shared_tests/priority.rs

@@ -1,13 +1,12 @@
 use crate::common::CoreWfStarter;
 use std::time::Duration;
-use temporalio_client::{
-    GetWorkflowResultOptions, Priority, WfClientExt, WorkflowClientTrait, WorkflowOptions,
+use temporalio_client::{Priority, UntypedWorkflow, WorkflowGetResultOptions};
+use temporalio_common::protos::temporal::api::{common, history::v1::history_event::Attributes};
+use temporalio_macros::{activities, workflow, workflow_methods};
+use temporalio_sdk::{
+    ActivityOptions, ChildWorkflowOptions, WorkflowContext, WorkflowResult,
+    activities::{ActivityContext, ActivityError},
 };
-use temporalio_common::protos::{
-    coresdk::AsJsonPayloadExt,
-    temporal::api::{common, history::v1::history_event::Attributes},
-};
-use temporalio_sdk::{ActContext, ActivityOptions, ChildWorkflowOptions, WfContext};
 
 pub(crate) async fn priority_values_sent_to_server() {
     let mut starter = if let Some(wfs) =
@@ -17,95 +16,121 @@ pub(crate) async fn priority_values_sent_to_server() {
     } else {
         return;
     };
-    starter.workflow_options.priority = Some(Priority {
-        priority_key: 1,
-        fairness_key: "fair-wf".to_string(),
-        fairness_weight: 4.2,
-    });
+    starter.workflow_options.priority = Priority {
+        priority_key: Some(1),
+        fairness_key: Some("fair-wf".to_string()),
+        fairness_weight: Some(4.2),
+    };
     let mut worker = starter.worker().await;
     let child_type = "child-wf";
 
-    worker.register_wf(starter.get_task_queue(), move |ctx: WfContext| async move {
-        let child = ctx.child_workflow(ChildWorkflowOptions {
-            workflow_id: format!("{}-child", ctx.task_queue()),
-            workflow_type: child_type.to_owned(),
-            options: WorkflowOptions {
+    struct PriorityActivities;
+    #[activities]
+    impl PriorityActivities {
+        #[activity]
+        async fn echo(ctx: ActivityContext, echo_me: String) -> Result<String, ActivityError> {
+            assert_eq!(
+                ctx.info().priority,
+                Priority {
+                    priority_key: Some(5),
+                    fairness_key: Some("fair-act".to_string()),
+                    fairness_weight: Some(1.1)
+                }
+            );
+            Ok(echo_me)
+        }
+    }
+
+    #[workflow]
+    #[derive(Default)]
+    struct ParentWf {
+        child_type: String,
+    }
+
+    #[workflow_methods]
+    impl ParentWf {
+        #[run]
+        async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+            let child = ctx.child_workflow(ChildWorkflowOptions {
+                workflow_id: format!("{}-child", ctx.task_queue()),
+                workflow_type: ctx.state(|wf| wf.child_type.clone()),
                 priority: Some(Priority {
-                    priority_key: 4,
-                    fairness_key: "fair-child".to_string(),
-                    fairness_weight: 1.23,
+                    priority_key: Some(4),
+                    fairness_key: Some("fair-child".to_string()),
+                    fairness_weight: Some(1.23),
                 }),
                 ..Default::default()
-            },
-            ..Default::default()
-        });
+            });
 
-        let started = child
-            .start(&ctx)
-            .await
-            .into_started()
-            .expect("Child should start OK");
-        let activity = ctx.activity(ActivityOptions {
-            activity_type: "echo".to_owned(),
-            input: "hello".as_json_payload().unwrap(),
-            start_to_close_timeout: Some(Duration::from_secs(5)),
-            priority: Some(Priority {
-                priority_key: 5,
-                fairness_key: "fair-act".to_string(),
-                fairness_weight: 1.1,
-            }),
-            // Currently no priority info attached to eagerly run activities
-            do_not_eagerly_execute: true,
-            ..Default::default()
-        });
-        started.result().await;
-        activity.await.unwrap_ok_payload();
-        Ok(().into())
-    });
-    worker.register_wf(child_type.to_owned(), |ctx: WfContext| async move {
-        assert_eq!(
-            ctx.workflow_initial_info().priority,
-            Some(common::v1::Priority {
-                priority_key: 4,
-                fairness_key: "fair-child".to_string(),
-                fairness_weight: 1.23
-            })
-        );
-        Ok(().into())
-    });
-    worker.register_activity("echo", |ctx: ActContext, echo_me: String| async move {
-        assert_eq!(
-            ctx.get_info().priority,
-            Priority {
-                priority_key: 5,
-                fairness_key: "fair-act".to_string(),
-                fairness_weight: 1.1
-            }
-        );
-        Ok(echo_me)
+            let started = child
+                .start()
+                .await
+                .into_started()
+                .expect("Child should start OK");
+            let activity = ctx.start_activity(
+                PriorityActivities::echo,
+                "hello".to_string(),
+                ActivityOptions {
+                    start_to_close_timeout: Some(Duration::from_secs(5)),
+                    priority: Some(Priority {
+                        priority_key: Some(5),
+                        fairness_key: Some("fair-act".to_string()),
+                        fairness_weight: Some(1.1),
+                    }),
+                    do_not_eagerly_execute: true,
+                    ..Default::default()
+                },
+            );
+            started.result().await;
+            let _ = activity.await;
+            Ok(())
+        }
+    }
+
+    #[workflow]
+    #[derive(Default)]
+    struct ChildWf;
+
+    #[workflow_methods]
+    impl ChildWf {
+        #[run(name = "child-wf")]
+        async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+            assert_eq!(
+                ctx.workflow_initial_info().priority,
+                Some(common::v1::Priority {
+                    priority_key: 4,
+                    fairness_key: "fair-child".to_string(),
+                    fairness_weight: 1.23
+                })
+            );
+            Ok(())
+        }
+    }
+
+    worker.register_activities(PriorityActivities);
+    worker.register_workflow_with_factory::<ParentWf, _>(move || ParentWf {
+        child_type: child_type.to_owned(),
     });
+    worker.register_workflow::<ChildWf>();
 
-    starter
-        .start_with_worker(starter.get_task_queue(), &mut worker)
-        .await;
+    worker
+        .submit_workflow(ParentWf::run, (), starter.workflow_options.clone())
+        .await
+        .unwrap();
     worker.run_until_done().await.unwrap();
 
     let client = starter.get_client().await;
-    let handle = client.get_untyped_workflow_handle(starter.get_task_queue(), "");
-    let res = handle
-        .get_workflow_result(GetWorkflowResultOptions::default())
+    let handle = client.get_workflow_handle::<UntypedWorkflow>(starter.get_task_queue());
+    handle
+        .get_result(WorkflowGetResultOptions::default())
         .await
         .unwrap();
-    // Expect workflow success
-    res.unwrap_success();
-    let history = client
-        .get_workflow_execution_history(starter.get_task_queue().to_owned(), None, vec![])
+    let events = handle
+        .fetch_history(Default::default())
         .await
         .unwrap()
-        .history
-        .unwrap();
-    let workflow_init_event = history
-        .events
+        .into_events();
+    let workflow_init_event = events
         .iter()
         .find_map(|e| {
             if let Attributes::WorkflowExecutionStartedEventAttributes(e) =
@@ -121,8 +146,7 @@ pub(crate) async fn priority_values_sent_to_server() {
         workflow_init_event.priority.as_ref().unwrap().priority_key,
         1
     );
-    let child_init_event = history
-        .events
+    let child_init_event = events
         .iter()
         .find_map(|e| {
             if let Attributes::StartChildWorkflowExecutionInitiatedEventAttributes(e) =
@@ -135,8 +159,7 @@ pub(crate) async fn priority_values_sent_to_server() {
         })
         .unwrap();
     assert_eq!(child_init_event.priority.as_ref().unwrap().priority_key, 4);
-    let activity_sched_event = history
-        .events
+    let activity_sched_event = events
         .iter()
         .find_map(|e| {
             if let Attributes::ActivityTaskScheduledEventAttributes(e) =

package/sdk-core/crates/sdk-core/tests/workflows_procmacro.rs

@@ -0,0 +1,6 @@
+#[test]
+fn workflows_procmacro_build_tests() {
+    let t = trybuild::TestCases::new();
+    t.pass("tests/workflows_trybuild/*_pass.rs");
+    t.compile_fail("tests/workflows_trybuild/*_fail.rs");
+}

package/sdk-core/crates/sdk-core/tests/workflows_trybuild/async_query_fail.rs

@@ -0,0 +1,26 @@
+use temporalio_macros::{workflow, workflow_methods};
+
+#[workflow]
+pub struct BadWorkflow;
+
+#[workflow_methods]
+impl BadWorkflow {
+    #[run]
+    pub async fn run(_ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        Ok(())
+    }
+
+    // This should fail - queries must not be async
+    #[query]
+    pub async fn get_value(&self, _ctx: &WorkflowContextView) -> u32 {
+        42
+    }
+}
+
+impl Default for BadWorkflow {
+    fn default() -> Self {
+        Self
+    }
+}
+
+fn main() {}

package/sdk-core/crates/sdk-core/tests/workflows_trybuild/async_query_fail.stderr

@@ -0,0 +1,5 @@
+error: #[query] methods must not be async (queries are synchronous)
+  --> tests/workflows_trybuild/async_query_fail.rs:15:9
+   |
+15 |     pub async fn get_value(&self, _ctx: &WorkflowContextView) -> u32 {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

package/sdk-core/crates/sdk-core/tests/workflows_trybuild/basic_pass.rs

@@ -0,0 +1,49 @@
+use temporalio_macros::{workflow, workflow_methods};
+use temporalio_sdk::{SyncWorkflowContext, WorkflowContext, WorkflowContextView, WorkflowResult};
+
+#[workflow]
+pub struct MyWorkflow {
+    counter: u32,
+}
+
+#[workflow_methods]
+impl MyWorkflow {
+    #[init]
+    pub fn new(_ctx: &WorkflowContextView, _input: String) -> Self {
+        Self { counter: 0 }
+    }
+
+    // Async run uses &self
+    #[run]
+    pub async fn run(_ctx: &mut WorkflowContext<Self>) -> WorkflowResult<String> {
+        Ok("hi".to_owned())
+    }
+
+    // Sync signal uses &mut self
+    #[signal(name = "increment")]
+    pub fn increment_counter(&mut self, _ctx: &mut SyncWorkflowContext<Self>, amount: u32) {
+        self.counter += amount;
+    }
+
+    #[signal]
+    pub async fn async_signal(_ctx: &mut WorkflowContext<Self>) {}
+
+    // Query uses &self with read-only context
+    #[query]
+    pub fn get_counter(&self, _ctx: &WorkflowContextView) -> u32 {
+        self.counter
+    }
+
+    #[update(name = "double")]
+    pub fn double_counter(&mut self, _ctx: &mut SyncWorkflowContext<Self>) -> u32 {
+        self.counter *= 2;
+        self.counter
+    }
+
+    #[update]
+    pub async fn async_update(_ctx: &mut WorkflowContext<Self>, val: i32) -> i32 {
+        val * 2
+    }
+}
+
+fn main() {}

package/sdk-core/crates/sdk-core/tests/workflows_trybuild/minimal_pass.rs

@@ -0,0 +1,21 @@
+use temporalio_macros::{workflow, workflow_methods};
+use temporalio_sdk::{WorkflowContext, WorkflowResult};
+
+#[workflow]
+pub struct MinimalWorkflow;
+
+#[workflow_methods]
+impl MinimalWorkflow {
+    #[run]
+    pub async fn run(_ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        Ok(())
+    }
+}
+
+impl Default for MinimalWorkflow {
+    fn default() -> Self {
+        Self
+    }
+}
+
+fn main() {}

package/sdk-core/crates/sdk-core/tests/workflows_trybuild/mut_query_fail.rs

@@ -0,0 +1,26 @@
+use temporalio_macros::{workflow, workflow_methods};
+
+#[workflow]
+pub struct BadWorkflow;
+
+#[workflow_methods]
+impl BadWorkflow {
+    #[run]
+    pub async fn run(_ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        Ok(())
+    }
+
+    // This should fail - queries must use &self, not &mut self
+    #[query]
+    pub fn get_value(&mut self, _ctx: &WorkflowContextView) -> u32 {
+        42
+    }
+}
+
+impl Default for BadWorkflow {
+    fn default() -> Self {
+        Self
+    }
+}
+
+fn main() {}

package/sdk-core/crates/sdk-core/tests/workflows_trybuild/mut_query_fail.stderr

@@ -0,0 +1,5 @@
+error: #[query] methods must use `&self` as the receiver (not `&mut self`) - queries are read-only
+  --> tests/workflows_trybuild/mut_query_fail.rs:15:22
+   |
+15 |     pub fn get_value(&mut self, _ctx: &WorkflowContextView) -> u32 {
+   |                      ^^^^^^^^^

package/sdk-core/crates/sdk-core/tests/workflows_trybuild/sync_run_fail.rs

@@ -0,0 +1,21 @@
+use temporalio_macros::{workflow, workflow_methods};
+
+#[workflow]
+pub struct BadWorkflow;
+
+#[workflow_methods]
+impl BadWorkflow {
+    // This should fail - run must be async
+    #[run]
+    pub fn run(&self, _ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        Ok(())
+    }
+}
+
+impl Default for BadWorkflow {
+    fn default() -> Self {
+        Self
+    }
+}
+
+fn main() {}

package/sdk-core/crates/sdk-core/tests/workflows_trybuild/sync_run_fail.stderr

@@ -0,0 +1,5 @@
+error: #[run] methods must be async
+  --> tests/workflows_trybuild/sync_run_fail.rs:10:9
+   |
+10 |     pub fn run(&self, _ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

package/sdk-core/crates/sdk-core-c-bridge/Cargo.toml

@@ -7,6 +7,9 @@ license-file = { workspace = true }
 description = "C bridge for Temporal Core SDK"
 homepage = "https://temporal.io/"
 repository = "https://github.com/temporalio/sdk-core"
+keywords = ["temporal", "workflow"]
+categories = ["development-tools"]
+publish = false
 
 [lib]
 name = "temporalio_sdk_core_c_bridge"
@@ -38,16 +41,20 @@ xz2 = { version = "0.1" }
 
 [dependencies.temporalio-client]
 path = "../client"
+version = "0.1"
 
 [dependencies.temporalio-sdk-core]
 path = "../sdk-core"
+version = "0.1"
 features = ["ephemeral-server"]
 
 [dependencies.temporalio-common]
 path = "../common"
-features = ["envconfig"]
+version = "0.1"
+features = ["core-based-sdk"]
 
 [dev-dependencies]
+base64 = "0.21.0"
 futures-util = "0.3"
 thiserror = { workspace = true }