@temporalio/core-bridge 1.5.2 → 1.6.0

package/sdk-core/tests/integ_tests/workflow_tests.rs

@@ -58,8 +58,7 @@ async fn parallel_workflows_same_queue() {
     let num_workflows = 25usize;
 
     let run_ids: Vec<_> = future::join_all(
-        (0..num_workflows)
-            .map(|i| starter.start_wf_with_id(format!("wf-id-{}", i), WorkflowOptions::default())),
+        (0..num_workflows).map(|i| starter.start_wf_with_id(format!("wf-id-{i}"))),
     )
     .await;
 
@@ -435,8 +434,8 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
     wf_starter
         // Test needs eviction on and a short timeout
         .max_cached_workflows(0)
-        .max_wft(1)
-        .wft_timeout(Duration::from_secs(1));
+        .max_wft(1);
+    wf_starter.workflow_options.task_timeout = Some(Duration::from_secs(1));
     let core = wf_starter.get_worker().await;
     let client = wf_starter.get_client().await;
     let task_q = wf_starter.get_task_queue();
@@ -460,7 +459,7 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
         .unwrap();
         wf_task
     };
-    wf_starter.start_wf().await;
+    wf_starter.start_wf_with_id(wf_id.to_string()).await;
 
     // Poll and schedule the activity
     let wf_task = poll_sched_act().await;
@@ -572,7 +571,7 @@ async fn slow_completes_with_small_cache() {
     for i in 0..20 {
         worker
             .submit_wf(
-                format!("{}_{}", wf_name, i),
+                format!("{wf_name}_{i}"),
                 wf_name.to_owned(),
                 vec![],
                 WorkflowOptions::default(),

package/sdk-core/tests/main.rs

@@ -1,22 +1,12 @@
 //! Integration tests
-//!
-//! Note that integ tests which want to use the server (nearly all of them) *need* to use the
-//! `#[rstest]` macro and accept the TODO fixture to support auto setup & teardown of ephemeral
-//! local servers.
 
 #[macro_use]
 extern crate rstest;
+#[macro_use]
+extern crate temporal_sdk_core_test_utils;
 
 #[cfg(test)]
 mod integ_tests {
-    #[macro_export]
-    macro_rules! prost_dur {
-        ($dur_call:ident $args:tt) => {
-            std::time::Duration::$dur_call$args
-                .try_into()
-                .expect("test duration fits")
-        };
-    }
     mod client_tests;
     mod ephemeral_server_tests;
     mod heartbeat_tests;

package/sdk-core/tests/runner.rs

@@ -1,7 +1,7 @@
 use anyhow::{anyhow, bail};
+use clap::Parser;
 use std::{
     env,
-    env::args,
     path::{Path, PathBuf},
     process::Stdio,
 };
@@ -12,51 +12,88 @@ use temporal_sdk_core_test_utils::{
 };
 use tokio::{self, process::Command};
 
+#[derive(clap::Parser)]
+#[command(author, version, about, long_about = None)]
+struct Cli {
+    /// Test harness to run. Anything defined as a `[[test]]` in core's `Cargo.toml` is valid.
+    #[arg(short, long, default_value = "integ_tests")]
+    test_name: String,
+
+    /// What kind of server to auto-launch, if any
+    #[arg(short, long, value_enum, default_value = "temporalite")]
+    server_kind: ServerKind,
+
+    /// Arguments to pass through to the `cargo test` command. Ex: `--release`
+    #[arg(short, long, allow_hyphen_values(true))]
+    cargo_test_args: Vec<String>,
+
+    /// The rest of the arguments will be passed through to the test harness
+    harness_args: Vec<String>,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, clap::ValueEnum)]
+enum ServerKind {
+    /// Use Temporalite
+    Temporalite,
+    /// Use the Java test server
+    TestServer,
+    /// Do not automatically start any server
+    External,
+}
+
 #[tokio::main]
 async fn main() -> Result<(), anyhow::Error> {
+    let Cli {
+        test_name,
+        server_kind,
+        cargo_test_args,
+        harness_args,
+    } = Cli::parse();
     let cargo = env::var("CARGO").unwrap_or_else(|_| "cargo".to_string());
-    let server_type = env::var("INTEG_SERVER_TYPE")
-        .unwrap_or_else(|_| "temporalite".to_string())
-        .to_lowercase();
     // Try building first, so that we error early on build failures & don't start server
+    let test_args_preamble = ["test", "--test", &test_name]
+        .into_iter()
+        .map(ToString::to_string)
+        .chain(cargo_test_args)
+        .collect::<Vec<_>>();
     let status = Command::new(&cargo)
-        .args(["test", "--test", "integ_tests", "--no-run"])
+        .args([test_args_preamble.as_slice(), &["--no-run".to_string()]].concat())
         .status()
         .await?;
     if !status.success() {
         bail!("Building integration tests failed!");
     }
 
-    // Move to clap if we start doing any more complicated input
-    let (server, envs) = if server_type == "test-server" {
-        let config = TestServerConfigBuilder::default()
-            .exe(default_cached_download())
-            .build()?;
-        println!("Using java test server");
-        (
-            Some(config.start_server_with_output(Stdio::null()).await?),
-            vec![(INTEG_TEST_SERVER_USED_ENV_VAR, "true")],
-        )
-    } else if server_type == "temporalite" {
-        let config = TemporaliteConfigBuilder::default()
-            .exe(default_cached_download())
-            .build()?;
-        println!("Using temporalite");
-        (
-            Some(config.start_server_with_output(Stdio::null()).await?),
-            vec![(INTEG_TEMPORALITE_USED_ENV_VAR, "true")],
-        )
-    } else {
-        println!("Not starting up a server. One should be running already.");
-        (None, vec![])
+    let (server, envs) = match server_kind {
+        ServerKind::Temporalite => {
+            let config = TemporaliteConfigBuilder::default()
+                .exe(default_cached_download())
+                .build()?;
+            println!("Using temporalite");
+            (
+                Some(config.start_server_with_output(Stdio::null()).await?),
+                vec![(INTEG_TEMPORALITE_USED_ENV_VAR, "true")],
+            )
+        }
+        ServerKind::TestServer => {
+            let config = TestServerConfigBuilder::default()
+                .exe(default_cached_download())
+                .build()?;
+            println!("Using java test server");
+            (
+                Some(config.start_server_with_output(Stdio::null()).await?),
+                vec![(INTEG_TEST_SERVER_USED_ENV_VAR, "true")],
+            )
+        }
+        ServerKind::External => {
+            println!("Not starting up a server. One should be running already.");
+            (None, vec![])
+        }
     };
 
-    // Run the integ tests, passing through arguments
-    let mut args = args();
-    // Shift off binary name
-    args.next();
     let mut cmd = Command::new(&cargo);
     if let Some(srv) = server.as_ref() {
+        println!("Running on {}", srv.target);
         cmd.env(
             INTEG_SERVER_TARGET_ENV_VAR,
             format!("http://{}", &srv.target),
@@ -66,10 +103,10 @@ async fn main() -> Result<(), anyhow::Error> {
         .envs(envs)
         .current_dir(project_root())
         .args(
-            ["test", "--test", "integ_tests"]
+            test_args_preamble
                 .into_iter()
-                .map(ToString::to_string)
-                .chain(args),
+                .chain(["--".to_string()])
+                .chain(harness_args),
         )
         .status()
         .await?;

package/sdk-core/tests/wf_input_replay.rs

@@ -0,0 +1,32 @@
+use anyhow::Context;
+use clap::Parser;
+use futures_util::StreamExt;
+use std::path::PathBuf;
+use temporal_sdk_core::replay_wf_state_inputs;
+use temporal_sdk_core_test_utils::{init_integ_telem, wf_input_saver::read_from_file};
+
+#[derive(clap::Parser)]
+#[command(author, version, about, long_about = None)]
+struct Cli {
+    /// Path to file containing the saved wf input data
+    replay_data: PathBuf,
+}
+
+#[tokio::main]
+async fn main() -> Result<(), anyhow::Error> {
+    init_integ_telem();
+    let Cli { replay_data } = Cli::parse();
+    let replay_dat = read_from_file(replay_data)
+        .await
+        .context("while reading replay data file")?;
+
+    replay_wf_state_inputs(
+        replay_dat.config,
+        replay_dat
+            .inputs
+            .map(|r| r.expect("Reading bytes from file works").to_vec()),
+    )
+    .await;
+
+    Ok(())
+}

package/sdk-core/bridge-ffi/Cargo.toml

@@ -1,24 +0,0 @@
-[package]
-name = "temporal-sdk-core-bridge-ffi"
-version = "0.1.0"
-edition = "2021"
-license-file = "LICENSE.txt"
-description = "FFI Bridge for Core"
-homepage = "https://temporal.io/"
-repository = "https://github.com/temporalio/sdk-core"
-
-[lib]
-crate-type = ["staticlib"]
-
-[dependencies]
-lazy_static = "1.4"
-libc = "0.2"
-prost = "0.11"
-temporal-sdk-core = { version = "0.1", path = "../core" }
-temporal-sdk-core-api = { version = "0.1", path = "../core-api" }
-temporal-sdk-core-protos = { version = "0.1", path = "../sdk-core-protos" }
-tokio = "1"
-tracing = "0.1"
-
-[build-dependencies]
-cbindgen = "0.24"

package/sdk-core/bridge-ffi/LICENSE.txt

@@ -1,23 +0,0 @@
-Temporal Core SDK
-
-The MIT License
-
-Copyright (c) 2022 Temporal Technologies, Inc. All Rights Reserved
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/sdk-core/bridge-ffi/build.rs

@@ -1,25 +0,0 @@
-extern crate cbindgen;
-
-use std::env;
-
-fn main() {
-    let crate_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
-
-    let changed = cbindgen::Builder::new()
-        .with_crate(crate_dir)
-        .with_pragma_once(true)
-        .with_language(cbindgen::Language::C)
-        .generate()
-        .expect("Unable to generate bindings")
-        .write_to_file("include/sdk-core-bridge.h");
-
-    // If this changed and an env var disallows change, error
-    if let Ok(env_val) = env::var("TEMPORAL_SDK_CORE_BRIDGE_FFI_DISABLE_HEADER_CHANGE") {
-        if changed && env_val == "true" {
-            println!(
-                "cargo:warning=bridge-ffi's header file changed unexpectedly from what's on disk"
-            );
-            std::process::exit(1);
-        }
-    }
-}

package/sdk-core/bridge-ffi/include/sdk-core-bridge.h

@@ -1,224 +0,0 @@
-#pragma once
-
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-/**
- * A client instance owned by Core. This must be passed to [tmprl_client_free]
- * when no longer in use which will free the resources.
- */
-typedef struct tmprl_client_t tmprl_client_t;
-
-/**
- * A runtime owned by Core. This must be passed to [tmprl_runtime_free] when no longer in use. This
- * should not be freed until every call to every [tmprl_worker_t] instance created with this
- * runtime has been shutdown. In practice, since the actual runtime is behind an [Arc], it's
- * currently OK, but that's an implementation detail.
- */
-typedef struct tmprl_runtime_t tmprl_runtime_t;
-
-/**
- * A worker instance owned by Core. This must be passed to [tmprl_worker_shutdown]
- * when no longer in use which will free the resources.
- */
-typedef struct tmprl_worker_t tmprl_worker_t;
-
-/**
- * A set of bytes owned by Core. No fields within nor any bytes references must
- * ever be mutated outside of Core. This must always be passed to
- * tmprl_bytes_free when no longer in use.
- */
-typedef struct tmprl_bytes_t {
-  const uint8_t *bytes;
-  size_t len;
-  /**
-   * For internal use only.
-   */
-  size_t cap;
-  /**
-   * For internal use only.
-   */
-  bool disable_free;
-} tmprl_bytes_t;
-
-/**
- * Callback called by [tmprl_worker_init] on completion. The first parameter of the
- * callback is user data passed into the original function. The second
- * parameter is a worker instance if the call is successful or null if not. If
- * present, the worker instance must be freed via [tmprl_worker_shutdown] when no
- * longer in use. The third parameter of the callback is a byte array for a
- * [InitResponse] protobuf message which must be freed via [tmprl_bytes_free].
- */
-typedef void (*tmprl_worker_init_callback)(void *user_data, struct tmprl_worker_t *worker, const struct tmprl_bytes_t *resp);
-
-/**
- * Callback called on function completion. The first parameter of the callback
- * is user data passed into the original function. The second parameter of the
- * callback is a never-null byte array for a response protobuf message which
- * must be freed via [tmprl_bytes_free].
- */
-typedef void (*tmprl_callback)(void *user_data, const struct tmprl_bytes_t *core);
-
-/**
- * Callback called by [tmprl_client_init] on completion. The first parameter of the
- * callback is user data passed into the original function. The second
- * parameter is a client instance if the call is successful or null if not. If
- * present, the client instance must be freed via [tmprl_client_free] when no
- * longer in use. The third parameter of the callback is a byte array for a
- * [InitResponse] protobuf message which must be freed via [tmprl_bytes_free].
- */
-typedef void (*tmprl_client_init_callback)(void *user_data, struct tmprl_client_t *client, const struct tmprl_bytes_t *resp);
-
-/**
- * Free a set of bytes. The first parameter can be null in cases where a [tmprl_worker_t] instance
- * isn't available. If the second parameter is null, this is a no-op.
- */
-void tmprl_bytes_free(struct tmprl_worker_t *worker, const struct tmprl_bytes_t *bytes);
-
-/**
- * Create a new runtime. The result is never null and must be freed via
- * tmprl_runtime_free when no longer in use.
- */
-struct tmprl_runtime_t *tmprl_runtime_new(void);
-
-/**
- * Free a previously created runtime.
- */
-void tmprl_runtime_free(struct tmprl_runtime_t *runtime);
-
-/**
- * Create a new worker instance.
- *
- * `runtime` and `client` are both required and must outlive this instance.
- * `req_proto` and `req_proto_len` represent a byte array for a [CreateWorkerRequest] protobuf
- * message.
- * The callback is invoked on completion.
- */
-void tmprl_worker_init(struct tmprl_runtime_t *runtime,
-                       struct tmprl_client_t *client,
-                       const uint8_t *req_proto,
-                       size_t req_proto_len,
-                       void *user_data,
-                       tmprl_worker_init_callback callback);
-
-/**
- * Shutdown and free a previously created worker.
- *
- * The req_proto and req_proto_len represent a byte array for a [bridge::ShutdownWorkerRequest]
- * protobuf message, which currently contains nothing and are unused, but the parameters are kept
- * for now.
- *
- * The callback is invoked on completion with a ShutdownWorkerResponse protobuf message.
- *
- * After the callback has been called, the worker struct will be freed and the pointer will no
- * longer be valid.
- */
-void tmprl_worker_shutdown(struct tmprl_worker_t *worker,
-                           const uint8_t *req_proto,
-                           size_t req_proto_len,
-                           void *user_data,
-                           tmprl_callback callback);
-
-/**
- * Initialize a client connection to the Temporal service.
- *
- * The runtime is required and must outlive this instance. The `req_proto` and `req_proto_len`
- * represent a byte array for a [CreateClientRequest] protobuf message. The callback is invoked on
- * completion.
- */
-void tmprl_client_init(struct tmprl_runtime_t *runtime,
-                       const uint8_t *req_proto,
-                       size_t req_proto_len,
-                       void *user_data,
-                       tmprl_client_init_callback callback);
-
-/**
- * Free a previously created client
- */
-void tmprl_client_free(struct tmprl_client_t *client);
-
-/**
- * Poll for a workflow activation.
- *
- * The `req_proto` and `req_proto_len` represent a byte array for a
- * [bridge::PollWorkflowActivationRequest] protobuf message, which currently contains nothing and
- * is unused, but the parameters are kept for now.
- *
- * The callback is invoked on completion with a [bridge::PollWorkflowActivationResponse] protobuf
- * message.
- */
-void tmprl_poll_workflow_activation(struct tmprl_worker_t *worker,
-                                    const uint8_t *req_proto,
-                                    size_t req_proto_len,
-                                    void *user_data,
-                                    tmprl_callback callback);
-
-/**
- * Poll for an activity task.
- *
- * The `req_proto` and `req_proto_len` represent a byte array for a
- * [bridge::PollActivityTaskRequest] protobuf message, which currently contains nothing and is
- * unused, but the parameters are kept for now.
- *
- * The callback is invoked on completion with a [bridge::PollActivityTaskResponse] protobuf
- * message.
- */
-void tmprl_poll_activity_task(struct tmprl_worker_t *worker,
-                              const uint8_t *req_proto,
-                              size_t req_proto_len,
-                              void *user_data,
-                              tmprl_callback callback);
-
-/**
- * Complete a workflow activation.
- *
- * The `req_proto` and `req_proto_len` represent a byte array for a
- * [bridge::CompleteWorkflowActivationRequest] protobuf message. The callback is invoked on
- * completion with a [bridge::CompleteWorkflowActivationResponse] protobuf message.
- */
-void tmprl_complete_workflow_activation(struct tmprl_worker_t *worker,
-                                        const uint8_t *req_proto,
-                                        size_t req_proto_len,
-                                        void *user_data,
-                                        tmprl_callback callback);
-
-/**
- * Complete an activity task.
- *
- * The `req_proto` and `req_proto_len` represent a byte array for a
- * [bridge::CompleteActivityTaskRequest] protobuf message. The callback is invoked on completion
- * with a [bridge::CompleteActivityTaskResponse] protobuf message.
- */
-void tmprl_complete_activity_task(struct tmprl_worker_t *worker,
-                                  const uint8_t *req_proto,
-                                  size_t req_proto_len,
-                                  void *user_data,
-                                  tmprl_callback callback);
-
-/**
- * Record an activity heartbeat.
- *
- * `req_proto` and `req_proto_len` represent a byte array for a
- * [bridge::RecordActivityHeartbeatRequest] protobuf message. The callback is invoked on completion
- * with a RecordActivityHeartbeatResponse protobuf message.
- */
-void tmprl_record_activity_heartbeat(struct tmprl_worker_t *worker,
-                                     const uint8_t *req_proto,
-                                     size_t req_proto_len,
-                                     void *user_data,
-                                     tmprl_callback callback);
-
-/**
- * Request a workflow eviction.
- *
- * The `req_proto` and `req_proto_len` represent a byte array for a
- * [bridge::RequestWorkflowEvictionRequest] protobuf message. The callback is invoked on completion
- * with a [bridge::RequestWorkflowEvictionResponse] protobuf message.
- */
-void tmprl_request_workflow_eviction(struct tmprl_worker_t *worker,
-                                     const uint8_t *req_proto,
-                                     size_t req_proto_len,
-                                     void *user_data,
-                                     tmprl_callback callback);