temporalio 0.1.1 → 0.2.0

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

@@ -1,132 +0,0 @@
-use anyhow::{anyhow, bail};
-use clap::Parser;
-use std::{
-    env,
-    path::{Path, PathBuf},
-    process::Stdio,
-};
-use temporal_sdk_core::ephemeral_server::{
-    TemporalDevServerConfigBuilder, TestServerConfigBuilder,
-};
-use temporal_sdk_core_test_utils::{
-    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());
-    // 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_args_preamble.as_slice(), &["--no-run".to_string()]].concat())
-        .status()
-        .await?;
-    if !status.success() {
-        bail!("Building integration tests failed!");
-    }
-
-    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![])
-        }
-    };
-
-    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),
-        );
-    }
-    let status = cmd
-        .envs(envs)
-        .current_dir(project_root())
-        .args(
-            test_args_preamble
-                .into_iter()
-                .chain(["--".to_string()])
-                .chain(harness_args),
-        )
-        .status()
-        .await?;
-
-    if let Some(mut srv) = server {
-        srv.shutdown().await?;
-    }
-    if status.success() {
-        Ok(())
-    } else {
-        Err(anyhow!("Integ tests failed!"))
-    }
-}
-
-fn project_root() -> PathBuf {
-    Path::new(&env!("CARGO_MANIFEST_DIR"))
-        .ancestors()
-        .nth(1)
-        .unwrap()
-        .to_path_buf()
-}

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

@@ -1,32 +0,0 @@
-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,202 +0,0 @@
-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, ClientOptionsBuilderError, ConfiguredClient, RetryClient,
-    TemporalServiceClientWithMetrics, TestService, WorkflowService, ClientOptions,
-};
-use thiserror::Error;
-use tokio::runtime::Runtime;
-use tokio::select;
-use tokio_util::sync::CancellationToken;
-use tonic::metadata::{MetadataKey, MetadataValue};
-
-pub type Client = RetryClient<ConfiguredClient<TemporalServiceClientWithMetrics>>;
-
-#[derive(Error, Debug)]
-pub enum ConnectionError {
-    #[error(transparent)]
-    InvalidUrl(#[from] url::ParseError),
-
-    #[error(transparent)]
-    InvalidProtobuf(#[from] prost::DecodeError),
-
-    #[error(transparent)]
-    InvalidConnectionOptions(#[from] ClientOptionsBuilderError),
-
-    #[error("`{0}`/`{1}` RPC call is not supported by the API")]
-    InvalidRpc(String, String),
-
-    #[error(transparent)]
-    InvalidRpcMetadataKey(#[from] tonic::metadata::errors::InvalidMetadataKey),
-
-    #[error(transparent)]
-    InvalidRpcMetadataValue(#[from] tonic::metadata::errors::InvalidMetadataValue),
-
-    #[error("`{0}` Service is not supported by the API")]
-    InvalidService(String),
-
-    #[error(transparent)]
-    UnableToConnect(#[from] ClientInitError),
-
-    #[error(transparent)]
-    UnableToInitializeRuntime(#[from] std::io::Error),
-
-    #[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 {
-        req.metadata_mut().insert(
-            MetadataKey::from_str(k.as_str())?,
-            MetadataValue::try_from(v.as_str())?
-        );
-    }
-
-    if let Some(timeout_millis) = params.timeout_millis {
-        req.set_timeout(Duration::from_millis(timeout_millis));
-    }
-
-    Ok(req)
-}
-
-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, $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,
-    runtime: Arc<Runtime>
-}
-
-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(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 {
-    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(&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
-            }
-        })
-    }
-}