temporalio 0.0.2 → 0.1.1

data/bridge/sdk-core/tests/integ_tests/workflow_tests/timers.rs

@@ -1,12 +1,13 @@
 use std::time::Duration;
-use temporal_client::WorkflowOptions;
+
 use temporal_sdk::{WfContext, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::{
     workflow_commands::{CancelTimer, CompleteWorkflowExecution, StartTimer},
     workflow_completion::WorkflowActivationCompletion,
 };
 use temporal_sdk_core_test_utils::{
-    init_core_and_create_wf, start_timer_cmd, CoreWfStarter, WorkerTestHelpers,
+    drain_pollers_and_shutdown, init_core_and_create_wf, start_timer_cmd, CoreWfStarter,
+    WorkerTestHelpers,
 };
 
 pub async fn timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
@@ -18,18 +19,11 @@ pub async fn timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
 async fn timer_workflow_workflow_driver() {
     let wf_name = "timer_wf_new";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), timer_wf);
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }
 
@@ -37,6 +31,7 @@ async fn timer_workflow_workflow_driver() {
 async fn timer_workflow_manual() {
     let mut starter = init_core_and_create_wf("timer_workflow").await;
     let core = starter.get_worker().await;
+    starter.no_remote_activities();
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task.run_id,
@@ -50,13 +45,14 @@ async fn timer_workflow_manual() {
     .unwrap();
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_execution(&task.run_id).await;
-    core.shutdown().await;
+    drain_pollers_and_shutdown(&core).await;
 }
 
 #[tokio::test]
 async fn timer_cancel_workflow() {
     let mut starter = init_core_and_create_wf("timer_cancel_workflow").await;
     let core = starter.get_worker().await;
+    starter.no_remote_activities();
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task.run_id,
@@ -115,17 +111,10 @@ async fn parallel_timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
 async fn parallel_timers() {
     let wf_name = "parallel_timers";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), parallel_timer_wf);
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }

data/bridge/sdk-core/tests/integ_tests/workflow_tests/upsert_search_attrs.rs

@@ -1,9 +1,9 @@
-use log::warn;
 use std::{collections::HashMap, env};
 use temporal_client::{WorkflowClientTrait, WorkflowOptions};
 use temporal_sdk::{WfContext, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::{AsJsonPayloadExt, FromJsonPayloadExt};
-use temporal_sdk_core_test_utils::{CoreWfStarter, INTEG_TEMPORALITE_USED_ENV_VAR};
+use temporal_sdk_core_test_utils::{CoreWfStarter, INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR};
+use tracing::warn;
 use uuid::Uuid;
 
 // These are initialized on the server as part of the autosetup container which we
@@ -24,9 +24,11 @@ async fn sends_upsert() {
     let wf_name = "sends_upsert_search_attrs";
     let wf_id = Uuid::new_v4();
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
-    if env::var(INTEG_TEMPORALITE_USED_ENV_VAR).is_ok() {
-        warn!("skipping sends_upsert -- does not work on temporalite");
+    // TODO: this should be supported in server 1.20, remove this condition when CLI is upgraded.
+    if env::var(INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR).is_ok() {
+        warn!("skipping sends_upsert -- does not work on temporal dev server");
         return;
     }
 

data/bridge/sdk-core/tests/integ_tests/workflow_tests.rs

@@ -42,8 +42,8 @@ use temporal_sdk_core_protos::{
     temporal::api::{failure::v1::Failure, history::v1::history_event},
 };
 use temporal_sdk_core_test_utils::{
-    history_from_proto_binary, init_core_and_create_wf, init_core_replay_preloaded,
-    schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers,
+    drain_pollers_and_shutdown, history_from_proto_binary, init_core_and_create_wf,
+    init_core_replay_preloaded, schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers,
 };
 use tokio::time::sleep;
 use uuid::Uuid;
@@ -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;
 
@@ -104,7 +103,7 @@ async fn parallel_workflows_same_queue() {
     for handle in handles {
         handle.await.unwrap()
     }
-    core.shutdown().await;
+    drain_pollers_and_shutdown(&core).await;
 }
 
 static RUN_CT: AtomicUsize = AtomicUsize::new(0);
@@ -118,7 +117,7 @@ pub async fn cache_evictions_wf(command_sink: WfContext) -> WorkflowResult<()> {
 async fn workflow_lru_cache_evictions() {
     let wf_type = "workflow_lru_cache_evictions";
     let mut starter = CoreWfStarter::new(wf_type);
-    starter.max_cached_workflows(1);
+    starter.no_remote_activities().max_cached_workflows(1);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_type.to_string(), cache_evictions_wf);
 
@@ -163,7 +162,7 @@ async fn shutdown_aborts_actively_blocked_poll() {
     let tcore = core.clone();
     let handle = tokio::spawn(async move {
         std::thread::sleep(Duration::from_millis(100));
-        tcore.shutdown().await;
+        drain_pollers_and_shutdown(&tcore).await;
     });
     assert_matches!(
         core.poll_workflow_activation().await.unwrap_err(),
@@ -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(),

data/bridge/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;
@@ -46,7 +36,7 @@ mod integ_tests {
         let opts = get_integ_server_options();
         let runtime = CoreRuntime::new_assume_tokio(get_integ_telem_options()).unwrap();
         let mut retrying_client = opts
-            .connect_no_namespace(runtime.metric_meter(), None)
+            .connect_no_namespace(runtime.metric_meter().as_deref(), None)
             .await
             .unwrap();
 

data/bridge/sdk-core/tests/runner.rs

@@ -1,62 +1,101 @@
 use anyhow::{anyhow, bail};
+use clap::Parser;
 use std::{
     env,
-    env::args,
     path::{Path, PathBuf},
     process::Stdio,
 };
-use temporal_sdk_core::ephemeral_server::{TemporaliteConfigBuilder, TestServerConfigBuilder};
+use temporal_sdk_core::ephemeral_server::{
+    TemporalDevServerConfigBuilder, TestServerConfigBuilder,
+};
 use temporal_sdk_core_test_utils::{
-    default_cached_download, INTEG_SERVER_TARGET_ENV_VAR, INTEG_TEMPORALITE_USED_ENV_VAR,
+    default_cached_download, INTEG_SERVER_TARGET_ENV_VAR, INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR,
     INTEG_TEST_SERVER_USED_ENV_VAR,
 };
 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 = "temporal-cli")]
+    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 Temporal-cli
+    TemporalCLI,
+    /// 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::TemporalCLI => {
+            let config = TemporalDevServerConfigBuilder::default()
+                .exe(default_cached_download())
+                .build()?;
+            println!("Using temporal CLI");
+            (
+                Some(config.start_server_with_output(Stdio::null()).await?),
+                vec![(INTEG_TEMPORAL_DEV_SERVER_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 +105,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?;

data/bridge/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(())
+}

data/bridge/src/connection.rs

@@ -1,18 +1,18 @@
+use parking_lot::RwLock;
 use std::collections::HashMap;
 use std::convert::TryFrom;
 use std::str::FromStr;
 use std::sync::Arc;
 use std::time::Duration;
 use temporal_client::{
-    ClientInitError, ClientOptionsBuilder, ClientOptionsBuilderError, WorkflowService, RetryClient,
-    ConfiguredClient, TemporalServiceClientWithMetrics
+    ClientInitError, ClientOptionsBuilderError, ConfiguredClient, RetryClient,
+    TemporalServiceClientWithMetrics, TestService, WorkflowService, ClientOptions,
 };
 use thiserror::Error;
-use tokio::{select};
-use tokio::runtime::{Runtime};
+use tokio::runtime::Runtime;
+use tokio::select;
 use tokio_util::sync::CancellationToken;
-use tonic::metadata::{MetadataKey,MetadataValue};
-use url::Url;
+use tonic::metadata::{MetadataKey, MetadataValue};
 
 pub type Client = RetryClient<ConfiguredClient<TemporalServiceClientWithMetrics>>;
 
@@ -27,8 +27,8 @@ pub enum ConnectionError {
     #[error(transparent)]
     InvalidConnectionOptions(#[from] ClientOptionsBuilderError),
 
-    #[error("`{0}` RPC call is not supported by the API")]
-    InvalidRpc(String),
+    #[error("`{0}`/`{1}` RPC call is not supported by the API")]
+    InvalidRpc(String, String),
 
     #[error(transparent)]
     InvalidRpcMetadataKey(#[from] tonic::metadata::errors::InvalidMetadataKey),
@@ -36,6 +36,9 @@ pub enum ConnectionError {
     #[error(transparent)]
     InvalidRpcMetadataValue(#[from] tonic::metadata::errors::InvalidMetadataValue),
 
+    #[error("`{0}` Service is not supported by the API")]
+    InvalidService(String),
+
     #[error(transparent)]
     UnableToConnect(#[from] ClientInitError),
 
@@ -79,7 +82,15 @@ macro_rules! rpc_call {
     };
 }
 
-async fn make_rpc_call(mut client: Client, params: RpcParams) -> RpcResult {
+async fn make_rpc_call(client: Client, params: RpcParams) -> RpcResult {
+    match params.service.as_str() {
+        "workflow_service" => make_workflow_service_rpc(client, params).await,
+        "test_service" => make_test_service_rpc(client, params).await,
+        _ => Err(ConnectionError::InvalidService(params.service.to_string()))
+    }
+}
+
+async fn make_workflow_service_rpc(mut client: Client, params: RpcParams) -> RpcResult {
     match params.rpc.as_str() {
         "register_namespace" => rpc_call!(client, register_namespace, params),
         "describe_namespace" => rpc_call!(client, describe_namespace, params),
@@ -88,7 +99,7 @@ async fn make_rpc_call(mut client: Client, params: RpcParams) -> RpcResult {
         "deprecate_namespace" => rpc_call!(client, deprecate_namespace, params),
         "start_workflow_execution" => rpc_call!(client, start_workflow_execution, params),
         "get_workflow_execution_history" => rpc_call!(client, get_workflow_execution_history, params),
-        // "get_workflow_execution_history_reverse" => rpc_call!(client, get_workflow_execution_history_reverse, params),
+        "get_workflow_execution_history_reverse" => rpc_call!(client, get_workflow_execution_history_reverse, params),
         "poll_workflow_task_queue" => rpc_call!(client, poll_workflow_task_queue, params),
         "respond_workflow_task_completed" => rpc_call!(client, respond_workflow_task_completed, params),
         "respond_workflow_task_failed" => rpc_call!(client, respond_workflow_task_failed, params),
@@ -131,12 +142,24 @@ async fn make_rpc_call(mut client: Client, params: RpcParams) -> RpcResult {
         "list_schedules" => rpc_call!(client, list_schedules, params),
         "update_worker_build_id_ordering" => rpc_call!(client, update_worker_build_id_ordering, params),
         "get_worker_build_id_ordering" => rpc_call!(client, get_worker_build_id_ordering, params),
-        "update_workflow" => rpc_call!(client, update_workflow, params),
+        "update_workflow_execution" => rpc_call!(client, update_workflow_execution, params),
         "start_batch_operation" => rpc_call!(client, start_batch_operation, params),
         "stop_batch_operation" => rpc_call!(client, stop_batch_operation, params),
         "describe_batch_operation" => rpc_call!(client, describe_batch_operation, params),
         "list_batch_operations" => rpc_call!(client, list_batch_operations, params),
-        _ => Err(ConnectionError::InvalidRpc(params.rpc.to_string()))
+        _ => Err(ConnectionError::InvalidRpc(params.service.to_string(), params.rpc.to_string()))
+    }
+}
+
+async fn make_test_service_rpc(mut client: Client, params: RpcParams) -> RpcResult {
+    match params.rpc.as_str() {
+        "lock_time_skipping" => rpc_call!(client, lock_time_skipping, params),
+        "unlock_time_skipping" => rpc_call!(client, unlock_time_skipping, params),
+        "sleep" => rpc_call!(client, sleep, params),
+        "sleep_until" => rpc_call!(client, sleep_until, params),
+        "unlock_time_skipping_with_sleep" => rpc_call!(client, unlock_time_skipping_with_sleep, params),
+        "get_current_time" => rpc_call!(client, get_current_time, params),
+        _ => Err(ConnectionError::InvalidRpc(params.service.to_string(), params.rpc.to_string()))
     }
 }
 
@@ -148,27 +171,20 @@ pub struct Connection {
 
 pub struct RpcParams {
     pub rpc: String,
+    pub service: String,
     pub request: Vec<u8>,
     pub metadata: HashMap<String, String>,
     pub timeout_millis: Option<u64>
 }
 
-async fn create_client(host: String) -> Result<Client, ConnectionError> {
-    let url = Url::try_from(&*host)?;
-    let options = ClientOptionsBuilder::default()
-        .identity("testtest".to_string())
-        .target_url(url)
-        .client_name("ruby-sdk".to_string())
-        .client_version("0.0.1".to_string())
-        .build()?;
-
-    Ok(options.connect_no_namespace(None, None).await?)
+async fn create_client(options: ClientOptions, headers: Option<HashMap<String, String>>) -> Result<Client, ConnectionError> {
+    let headers = headers.map(|h| Arc::new(RwLock::new(h)));
+    Ok(options.connect_no_namespace(None, headers).await?)
 }
 
 impl Connection {
-    // TODO: Change the interface to accept a full configuration
-    pub fn connect(runtime: Arc<Runtime>, host: String) -> Result<Self, ConnectionError> {
-        let client = runtime.block_on(create_client(host))?;
+    pub fn connect(runtime: Arc<Runtime>, options: ClientOptions, headers: Option<HashMap<String, String>>) -> Result<Self, ConnectionError> {
+        let client = runtime.block_on(create_client(options, headers))?;
 
         Ok(Connection { client, runtime })
     }