temporalio 0.0.1 → 0.1.0

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,16 +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::runtime::{Runtime};
-use tonic::metadata::{MetadataKey,MetadataValue};
-use url::Url;
+use tokio::runtime::Runtime;
+use tokio::select;
+use tokio_util::sync::CancellationToken;
+use tonic::metadata::{MetadataKey, MetadataValue};
 
 pub type Client = RetryClient<ConfiguredClient<TemporalServiceClientWithMetrics>>;
 
@@ -25,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),
@@ -34,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),
 
@@ -42,13 +47,18 @@ pub enum ConnectionError {
 
     #[error(transparent)]
     RequestError(#[from] tonic::Status),
+
+    #[error("RPC call was cancelled")]
+    RequestCancelled,
 }
 
+pub type RpcResult = Result<Vec<u8>, ConnectionError>;
+
 fn rpc_req<P: prost::Message + Default>(params: RpcParams) -> Result<tonic::Request<P>, ConnectionError> {
     let proto = P::decode(&*params.request)?;
     let mut req = tonic::Request::new(proto);
 
-    for (k, v) in params.metadata {
+    for (k, v) in &params.metadata {
         req.metadata_mut().insert(
             MetadataKey::from_str(k.as_str())?,
             MetadataValue::try_from(v.as_str())?
@@ -62,16 +72,97 @@ fn rpc_req<P: prost::Message + Default>(params: RpcParams) -> Result<tonic::Requ
     Ok(req)
 }
 
-fn rpc_resp<P: prost::Message + Default>(res: Result<tonic::Response<P>, tonic::Status>) -> Result<Vec<u8>, ConnectionError> {
+fn rpc_resp<P: prost::Message + Default>(res: Result<tonic::Response<P>, tonic::Status>) -> RpcResult {
     Ok(res?.get_ref().encode_to_vec())
 }
 
 macro_rules! rpc_call {
-    ($client:expr, $runtime:expr, $rpc:ident, $params:expr) => {
-        rpc_resp($runtime.block_on($client.$rpc(rpc_req($params)?)))
+    ($client:expr, $rpc:ident, $params:expr) => {
+        rpc_resp($client.$rpc(rpc_req($params)?).await)
     };
 }
 
+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),
+        "list_namespaces" => rpc_call!(client, list_namespaces, params),
+        "update_namespace" => rpc_call!(client, update_namespace, params),
+        "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),
+        "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),
+        "poll_activity_task_queue" => rpc_call!(client, poll_activity_task_queue, params),
+        "record_activity_task_heartbeat" => rpc_call!(client, record_activity_task_heartbeat, params),
+        "record_activity_task_heartbeat_by_id" => rpc_call!(client, record_activity_task_heartbeat_by_id, params),
+        "respond_activity_task_completed" => rpc_call!(client, respond_activity_task_completed, params),
+        "respond_activity_task_completed_by_id" => rpc_call!(client, respond_activity_task_completed_by_id, params),
+        "respond_activity_task_failed" => rpc_call!(client, respond_activity_task_failed, params),
+        "respond_activity_task_failed_by_id" => rpc_call!(client, respond_activity_task_failed_by_id, params),
+        "respond_activity_task_canceled" => rpc_call!(client, respond_activity_task_canceled, params),
+        "respond_activity_task_canceled_by_id" => rpc_call!(client, respond_activity_task_canceled_by_id, params),
+        "request_cancel_workflow_execution" => rpc_call!(client, request_cancel_workflow_execution, params),
+        "signal_workflow_execution" => rpc_call!(client, signal_workflow_execution, params),
+        "signal_with_start_workflow_execution" => rpc_call!(client, signal_with_start_workflow_execution, params),
+        "reset_workflow_execution" => rpc_call!(client, reset_workflow_execution, params),
+        "terminate_workflow_execution" => rpc_call!(client, terminate_workflow_execution, params),
+        "delete_workflow_execution" => rpc_call!(client, delete_workflow_execution, params),
+        "list_open_workflow_executions" => rpc_call!(client, list_open_workflow_executions, params),
+        "list_closed_workflow_executions" => rpc_call!(client, list_closed_workflow_executions, params),
+        "list_workflow_executions" => rpc_call!(client, list_workflow_executions, params),
+        "list_archived_workflow_executions" => rpc_call!(client, list_archived_workflow_executions, params),
+        "scan_workflow_executions" => rpc_call!(client, scan_workflow_executions, params),
+        "count_workflow_executions" => rpc_call!(client, count_workflow_executions, params),
+        "get_search_attributes" => rpc_call!(client, get_search_attributes, params),
+        "respond_query_task_completed" => rpc_call!(client, respond_query_task_completed, params),
+        "reset_sticky_task_queue" => rpc_call!(client, reset_sticky_task_queue, params),
+        "query_workflow" => rpc_call!(client, query_workflow, params),
+        "describe_workflow_execution" => rpc_call!(client, describe_workflow_execution, params),
+        "describe_task_queue" => rpc_call!(client, describe_task_queue, params),
+        "get_cluster_info" => rpc_call!(client, get_cluster_info, params),
+        "get_system_info" => rpc_call!(client, get_system_info, params),
+        "list_task_queue_partitions" => rpc_call!(client, list_task_queue_partitions, params),
+        "create_schedule" => rpc_call!(client, create_schedule, params),
+        "describe_schedule" => rpc_call!(client, describe_schedule, params),
+        "update_schedule" => rpc_call!(client, update_schedule, params),
+        "patch_schedule" => rpc_call!(client, patch_schedule, params),
+        "list_schedule_matching_times" => rpc_call!(client, list_schedule_matching_times, params),
+        "delete_schedule" => rpc_call!(client, delete_schedule, params),
+        "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_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.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()))
+    }
+}
+
 // A Connection is a Client wrapper for making RPC calls
 pub struct Connection {
     pub client: Client,
@@ -80,88 +171,32 @@ 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 })
     }
 
-    pub fn call(&mut self, params: RpcParams) -> Result<Vec<u8>, ConnectionError> {
-        match params.rpc.as_str() {
-            "register_namespace" => rpc_call!(self.client, self.runtime, register_namespace, params),
-            "describe_namespace" => rpc_call!(self.client, self.runtime, describe_namespace, params),
-            "list_namespaces" => rpc_call!(self.client, self.runtime, list_namespaces, params),
-            "update_namespace" => rpc_call!(self.client, self.runtime, update_namespace, params),
-            "deprecate_namespace" => rpc_call!(self.client, self.runtime, deprecate_namespace, params),
-            "start_workflow_execution" => rpc_call!(self.client, self.runtime, start_workflow_execution, params),
-            "get_workflow_execution_history" => rpc_call!(self.client, self.runtime, get_workflow_execution_history, params),
-            // "get_workflow_execution_history_reverse" => rpc_call!(self.client, self.runtime, get_workflow_execution_history_reverse, params),
-            "poll_workflow_task_queue" => rpc_call!(self.client, self.runtime, poll_workflow_task_queue, params),
-            "respond_workflow_task_completed" => rpc_call!(self.client, self.runtime, respond_workflow_task_completed, params),
-            "respond_workflow_task_failed" => rpc_call!(self.client, self.runtime, respond_workflow_task_failed, params),
-            "poll_activity_task_queue" => rpc_call!(self.client, self.runtime, poll_activity_task_queue, params),
-            "record_activity_task_heartbeat" => rpc_call!(self.client, self.runtime, record_activity_task_heartbeat, params),
-            "record_activity_task_heartbeat_by_id" => rpc_call!(self.client, self.runtime, record_activity_task_heartbeat_by_id, params),
-            "respond_activity_task_completed" => rpc_call!(self.client, self.runtime, respond_activity_task_completed, params),
-            "respond_activity_task_completed_by_id" => rpc_call!(self.client, self.runtime, respond_activity_task_completed_by_id, params),
-            "respond_activity_task_failed" => rpc_call!(self.client, self.runtime, respond_activity_task_failed, params),
-            "respond_activity_task_failed_by_id" => rpc_call!(self.client, self.runtime, respond_activity_task_failed_by_id, params),
-            "respond_activity_task_canceled" => rpc_call!(self.client, self.runtime, respond_activity_task_canceled, params),
-            "respond_activity_task_canceled_by_id" => rpc_call!(self.client, self.runtime, respond_activity_task_canceled_by_id, params),
-            "request_cancel_workflow_execution" => rpc_call!(self.client, self.runtime, request_cancel_workflow_execution, params),
-            "signal_workflow_execution" => rpc_call!(self.client, self.runtime, signal_workflow_execution, params),
-            "signal_with_start_workflow_execution" => rpc_call!(self.client, self.runtime, signal_with_start_workflow_execution, params),
-            "reset_workflow_execution" => rpc_call!(self.client, self.runtime, reset_workflow_execution, params),
-            "terminate_workflow_execution" => rpc_call!(self.client, self.runtime, terminate_workflow_execution, params),
-            "list_open_workflow_executions" => rpc_call!(self.client, self.runtime, list_open_workflow_executions, params),
-            "list_closed_workflow_executions" => rpc_call!(self.client, self.runtime, list_closed_workflow_executions, params),
-            "list_workflow_executions" => rpc_call!(self.client, self.runtime, list_workflow_executions, params),
-            "list_archived_workflow_executions" => rpc_call!(self.client, self.runtime, list_archived_workflow_executions, params),
-            "scan_workflow_executions" => rpc_call!(self.client, self.runtime, scan_workflow_executions, params),
-            "count_workflow_executions" => rpc_call!(self.client, self.runtime, count_workflow_executions, params),
-            "get_search_attributes" => rpc_call!(self.client, self.runtime, get_search_attributes, params),
-            "respond_query_task_completed" => rpc_call!(self.client, self.runtime, respond_query_task_completed, params),
-            "reset_sticky_task_queue" => rpc_call!(self.client, self.runtime, reset_sticky_task_queue, params),
-            "query_workflow" => rpc_call!(self.client, self.runtime, query_workflow, params),
-            "describe_workflow_execution" => rpc_call!(self.client, self.runtime, describe_workflow_execution, params),
-            "describe_task_queue" => rpc_call!(self.client, self.runtime, describe_task_queue, params),
-            "get_cluster_info" => rpc_call!(self.client, self.runtime, get_cluster_info, params),
-            "get_system_info" => rpc_call!(self.client, self.runtime, get_system_info, params),
-            "list_task_queue_partitions" => rpc_call!(self.client, self.runtime, list_task_queue_partitions, params),
-            "create_schedule" => rpc_call!(self.client, self.runtime, create_schedule, params),
-            "describe_schedule" => rpc_call!(self.client, self.runtime, describe_schedule, params),
-            "update_schedule" => rpc_call!(self.client, self.runtime, update_schedule, params),
-            "patch_schedule" => rpc_call!(self.client, self.runtime, patch_schedule, params),
-            "list_schedule_matching_times" => rpc_call!(self.client, self.runtime, list_schedule_matching_times, params),
-            "delete_schedule" => rpc_call!(self.client, self.runtime, delete_schedule, params),
-            "list_schedules" => rpc_call!(self.client, self.runtime, list_schedules, params),
-            "update_worker_build_id_ordering" => rpc_call!(self.client, self.runtime, update_worker_build_id_ordering, params),
-            "get_worker_build_id_ordering" => rpc_call!(self.client, self.runtime, get_worker_build_id_ordering, params),
-            "update_workflow" => rpc_call!(self.client, self.runtime, update_workflow, params),
-            "start_batch_operation" => rpc_call!(self.client, self.runtime, start_batch_operation, params),
-            "stop_batch_operation" => rpc_call!(self.client, self.runtime, stop_batch_operation, params),
-            "describe_batch_operation" => rpc_call!(self.client, self.runtime, describe_batch_operation, params),
-            "list_batch_operations" => rpc_call!(self.client, self.runtime, list_batch_operations, params),
-            _ => Err(ConnectionError::InvalidRpc(params.rpc.to_string()))
-        }
+    pub fn call(&self, params: RpcParams, cancel_token: CancellationToken) -> RpcResult {
+        let core_client = self.client.clone();
+
+        self.runtime.block_on(async move {
+            select! {
+                _ = cancel_token.cancelled() => Err(ConnectionError::RequestCancelled),
+                result = make_rpc_call(core_client, params) => result
+            }
+        })
     }
 }