temporalio 0.1.1 → 0.2.0

data/bridge/sdk-core/test-utils/src/wf_input_saver.rs

@@ -1,50 +0,0 @@
-use anyhow::anyhow;
-use bytes::BytesMut;
-use futures::{stream::BoxStream, SinkExt, StreamExt};
-use prost::bytes::Bytes;
-use std::path::Path;
-use temporal_sdk_core_api::worker::WorkerConfig;
-use tokio::{fs::File, sync::mpsc::UnboundedReceiver};
-use tokio_util::codec::{FramedRead, FramedWrite, LengthDelimitedCodec};
-
-pub struct WFStateReplayData {
-    pub config: WorkerConfig,
-    pub inputs: BoxStream<'static, Result<BytesMut, std::io::Error>>,
-}
-
-pub async fn stream_to_file(
-    config: &WorkerConfig,
-    mut rcv: UnboundedReceiver<Vec<u8>>,
-) -> Result<(), anyhow::Error> {
-    let file = File::create("wf_inputs").await?;
-    let mut transport = FramedWrite::new(file, ldc());
-    // First write the worker config, since things like cache size affect how many evictions there
-    // will be, etc.
-    transport.send(rmp_serde::to_vec(config)?.into()).await?;
-    while let Some(v) = rcv.recv().await {
-        transport.send(Bytes::from(v)).await?;
-    }
-    Ok(())
-}
-
-pub async fn read_from_file(path: impl AsRef<Path>) -> Result<WFStateReplayData, anyhow::Error> {
-    let file = File::open(path).await?;
-    let mut framed_read = FramedRead::new(file, ldc());
-    // Deserialize the worker config first
-    let config = framed_read
-        .next()
-        .await
-        .ok_or_else(|| anyhow!("Replay data file is empty"))??;
-    let config = rmp_serde::from_slice(config.as_ref())?;
-
-    Ok(WFStateReplayData {
-        config,
-        inputs: framed_read.boxed(),
-    })
-}
-
-fn ldc() -> LengthDelimitedCodec {
-    LengthDelimitedCodec::builder()
-        .length_field_type::<u16>()
-        .new_codec()
-}

data/bridge/sdk-core/test-utils/src/workflows.rs

@@ -1,29 +0,0 @@
-use crate::prost_dur;
-use std::time::Duration;
-use temporal_sdk::{ActivityOptions, LocalActivityOptions, WfContext, WorkflowResult};
-use temporal_sdk_core_protos::{coresdk::AsJsonPayloadExt, temporal::api::common::v1::RetryPolicy};
-
-pub async fn la_problem_workflow(ctx: WfContext) -> WorkflowResult<()> {
-    ctx.local_activity(LocalActivityOptions {
-        activity_type: "delay".to_string(),
-        input: "hi".as_json_payload().expect("serializes fine"),
-        retry_policy: RetryPolicy {
-            initial_interval: Some(prost_dur!(from_micros(15))),
-            backoff_coefficient: 1_000.,
-            maximum_interval: Some(prost_dur!(from_millis(1500))),
-            maximum_attempts: 4,
-            non_retryable_error_types: vec![],
-        },
-        timer_backoff_threshold: Some(Duration::from_secs(1)),
-        ..Default::default()
-    })
-    .await;
-    ctx.activity(ActivityOptions {
-        activity_type: "delay".to_string(),
-        start_to_close_timeout: Some(Duration::from_secs(20)),
-        input: "hi!".as_json_payload().expect("serializes fine"),
-        ..Default::default()
-    })
-    .await;
-    Ok(().into())
-}

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

@@ -1,130 +0,0 @@
-use futures_util::{sink, stream::FuturesUnordered, FutureExt, StreamExt};
-use rand::{prelude::Distribution, rngs::SmallRng, Rng, SeedableRng};
-use std::{future, time::Duration};
-use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions};
-use temporal_sdk::{ActContext, ActivityOptions, LocalActivityOptions, WfContext, WorkflowResult};
-use temporal_sdk_core_protos::coresdk::{AsJsonPayloadExt, FromJsonPayloadExt, IntoPayloadsExt};
-use temporal_sdk_core_test_utils::CoreWfStarter;
-use tokio_util::sync::CancellationToken;
-
-const FUZZY_SIG: &str = "fuzzy_sig";
-
-#[derive(serde::Serialize, serde::Deserialize, Copy, Clone)]
-enum FuzzyWfAction {
-    Shutdown,
-    DoAct,
-    DoLocalAct,
-}
-
-struct FuzzyWfActionSampler;
-impl Distribution<FuzzyWfAction> for FuzzyWfActionSampler {
-    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> FuzzyWfAction {
-        let v: u8 = rng.gen_range(1..=2);
-        match v {
-            1 => FuzzyWfAction::DoAct,
-            2 => FuzzyWfAction::DoLocalAct,
-            _ => unreachable!(),
-        }
-    }
-}
-
-async fn echo(_ctx: ActContext, echo_me: String) -> Result<String, anyhow::Error> {
-    Ok(echo_me)
-}
-
-async fn fuzzy_wf_def(ctx: WfContext) -> WorkflowResult<()> {
-    let sigchan = ctx
-        .make_signal_channel(FUZZY_SIG)
-        .map(|sd| FuzzyWfAction::from_json_payload(&sd.input[0]).expect("Can deserialize signal"));
-    let done = CancellationToken::new();
-    let done_setter = done.clone();
-
-    sigchan
-        .take_until(done.cancelled())
-        .for_each_concurrent(None, |action| {
-            let fut = match action {
-                FuzzyWfAction::DoAct => ctx
-                    .activity(ActivityOptions {
-                        activity_type: "echo_activity".to_string(),
-                        start_to_close_timeout: Some(Duration::from_secs(5)),
-                        input: "hi!".as_json_payload().expect("serializes fine"),
-                        ..Default::default()
-                    })
-                    .map(|_| ())
-                    .boxed(),
-                FuzzyWfAction::DoLocalAct => ctx
-                    .local_activity(LocalActivityOptions {
-                        activity_type: "echo_activity".to_string(),
-                        start_to_close_timeout: Some(Duration::from_secs(5)),
-                        input: "hi!".as_json_payload().expect("serializes fine"),
-                        ..Default::default()
-                    })
-                    .map(|_| ())
-                    .boxed(),
-                FuzzyWfAction::Shutdown => {
-                    done_setter.cancel();
-                    future::ready(()).boxed()
-                }
-            };
-            fut
-        })
-        .await;
-
-    Ok(().into())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-async fn fuzzy_workflow() {
-    let num_workflows = 200;
-    let wf_name = "fuzzy_wf";
-    let mut starter = CoreWfStarter::new("fuzzy_workflow");
-    starter.max_wft(25).max_cached_workflows(25).max_at(25);
-    // .enable_wf_state_input_recording();
-    let mut worker = starter.worker().await;
-    worker.register_wf(wf_name.to_owned(), fuzzy_wf_def);
-    worker.register_activity("echo_activity", echo);
-    let client = starter.get_client().await;
-
-    let mut workflow_handles = vec![];
-    for i in 0..num_workflows {
-        let wfid = format!("{wf_name}_{i}");
-        let rid = worker
-            .submit_wf(
-                wfid.clone(),
-                wf_name.to_owned(),
-                vec![],
-                WorkflowOptions::default(),
-            )
-            .await
-            .unwrap();
-        workflow_handles.push(client.get_untyped_workflow_handle(wfid, rid));
-    }
-
-    let rng = SmallRng::seed_from_u64(523189);
-    let mut actions: Vec<FuzzyWfAction> = rng.sample_iter(FuzzyWfActionSampler).take(15).collect();
-    actions.push(FuzzyWfAction::Shutdown);
-
-    let sig_sender = async {
-        for action in actions {
-            let sends: FuturesUnordered<_> = (0..num_workflows)
-                .map(|i| {
-                    client.signal_workflow_execution(
-                        format!("{wf_name}_{i}"),
-                        "".to_string(),
-                        FUZZY_SIG.to_string(),
-                        [action.as_json_payload().expect("Serializes ok")].into_payloads(),
-                        None,
-                    )
-                })
-                .collect();
-            sends
-                .map(|_| Ok(()))
-                .forward(sink::drain())
-                .await
-                .expect("Sending signals works");
-            tokio::time::sleep(Duration::from_secs(1)).await;
-        }
-    };
-    let (r1, _) = tokio::join!(worker.run_until_done(), sig_sender);
-    r1.unwrap();
-}

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

@@ -1,265 +0,0 @@
-use futures::{future::join_all, sink, stream::FuturesUnordered, StreamExt};
-use std::time::{Duration, Instant};
-use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions};
-use temporal_sdk::{ActContext, ActivityOptions, WfContext, WorkflowResult};
-use temporal_sdk_core_protos::coresdk::{
-    workflow_commands::ActivityCancellationType, AsJsonPayloadExt,
-};
-use temporal_sdk_core_test_utils::{workflows::la_problem_workflow, CoreWfStarter};
-
-mod fuzzy_workflow;
-
-#[tokio::test]
-async fn activity_load() {
-    const CONCURRENCY: usize = 512;
-
-    let mut starter = CoreWfStarter::new("activity_load");
-    starter
-        .max_wft(CONCURRENCY)
-        .max_cached_workflows(CONCURRENCY)
-        .max_at_polls(10)
-        .max_at(CONCURRENCY);
-    let mut worker = starter.worker().await;
-
-    let activity_id = "act-1";
-    let activity_timeout = Duration::from_secs(8);
-    let task_queue = starter.get_task_queue().to_owned();
-
-    let wf_fn = move |ctx: WfContext| {
-        let task_queue = task_queue.clone();
-        let payload = "yo".as_json_payload().unwrap();
-        async move {
-            let activity = ActivityOptions {
-                activity_id: Some(activity_id.to_string()),
-                activity_type: "test_activity".to_string(),
-                input: payload.clone(),
-                task_queue,
-                schedule_to_start_timeout: Some(activity_timeout),
-                start_to_close_timeout: Some(activity_timeout),
-                schedule_to_close_timeout: Some(activity_timeout),
-                heartbeat_timeout: Some(activity_timeout),
-                cancellation_type: ActivityCancellationType::TryCancel,
-                ..Default::default()
-            };
-            let res = ctx.activity(activity).await.unwrap_ok_payload();
-            assert_eq!(res.data, payload.data);
-            Ok(().into())
-        }
-    };
-
-    let starting = Instant::now();
-    let wf_type = "activity_load";
-    worker.register_wf(wf_type.to_owned(), wf_fn);
-    worker.register_activity(
-        "test_activity",
-        |_ctx: ActContext, echo: String| async move { Ok(echo) },
-    );
-    join_all((0..CONCURRENCY).map(|i| {
-        let worker = &worker;
-        let wf_id = format!("activity_load_{i}");
-        async move {
-            worker
-                .submit_wf(
-                    wf_id,
-                    wf_type.to_owned(),
-                    vec![],
-                    WorkflowOptions::default(),
-                )
-                .await
-                .unwrap();
-        }
-    }))
-    .await;
-    dbg!(starting.elapsed());
-
-    let running = Instant::now();
-
-    worker.run_until_done().await.unwrap();
-    dbg!(running.elapsed());
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-async fn workflow_load() {
-    const SIGNAME: &str = "signame";
-    let num_workflows = 200;
-    let wf_name = "workflow_load";
-    let mut starter = CoreWfStarter::new("workflow_load");
-    starter
-        .max_wft(5)
-        .max_cached_workflows(5)
-        .max_at_polls(10)
-        .max_at(100);
-    let mut worker = starter.worker().await;
-    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
-        let sigchan = ctx.make_signal_channel(SIGNAME).map(Ok);
-        let drained_fut = sigchan.forward(sink::drain());
-
-        let real_stuff = async move {
-            for _ in 0..20 {
-                ctx.activity(ActivityOptions {
-                    activity_type: "echo_activity".to_string(),
-                    start_to_close_timeout: Some(Duration::from_secs(5)),
-                    input: "hi!".as_json_payload().expect("serializes fine"),
-                    ..Default::default()
-                })
-                .await;
-                ctx.timer(Duration::from_secs(1)).await;
-            }
-        };
-        tokio::select! {
-            _ = drained_fut => {}
-            _ = real_stuff => {}
-        }
-
-        Ok(().into())
-    });
-    worker.register_activity(
-        "echo_activity",
-        |_ctx: ActContext, echo_me: String| async move { Ok(echo_me) },
-    );
-    let client = starter.get_client().await;
-
-    let mut workflow_handles = vec![];
-    for i in 0..num_workflows {
-        let wfid = format!("{wf_name}_{i}");
-        let rid = worker
-            .submit_wf(
-                wfid.clone(),
-                wf_name.to_owned(),
-                vec![],
-                WorkflowOptions::default(),
-            )
-            .await
-            .unwrap();
-        workflow_handles.push(client.get_untyped_workflow_handle(wfid, rid));
-    }
-
-    let sig_sender = async {
-        loop {
-            let sends: FuturesUnordered<_> = (0..num_workflows)
-                .map(|i| {
-                    client.signal_workflow_execution(
-                        format!("{wf_name}_{i}"),
-                        "".to_string(),
-                        SIGNAME.to_string(),
-                        None,
-                        None,
-                    )
-                })
-                .collect();
-            sends
-                .map(|_| Ok(()))
-                .forward(sink::drain())
-                .await
-                .expect("Sending signals works");
-            tokio::time::sleep(Duration::from_secs(2)).await;
-        }
-    };
-    tokio::select! { r1 = worker.run_until_done() => {r1.unwrap()}, _ = sig_sender => {}}
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-async fn evict_while_la_running_no_interference() {
-    let wf_name = "evict_while_la_running_no_interference";
-    let mut starter = CoreWfStarter::new(wf_name);
-    starter.max_local_at(20);
-    starter.max_cached_workflows(20);
-    // Though it doesn't make sense to set wft higher than cached workflows, leaving this commented
-    // introduces more instability that can be useful in the test.
-    // starter.max_wft(20);
-    let mut worker = starter.worker().await;
-
-    worker.register_wf(wf_name.to_owned(), la_problem_workflow);
-    worker.register_activity("delay", |_: ActContext, _: String| async {
-        tokio::time::sleep(Duration::from_secs(15)).await;
-        Ok(())
-    });
-
-    let client = starter.get_client().await;
-    let subfs = FuturesUnordered::new();
-    for i in 1..100 {
-        let wf_id = format!("{wf_name}-{i}");
-        let run_id = worker
-            .submit_wf(
-                &wf_id,
-                wf_name.to_owned(),
-                vec![],
-                WorkflowOptions::default(),
-            )
-            .await
-            .unwrap();
-        let cw = worker.core_worker.clone();
-        let client = client.clone();
-        subfs.push(async move {
-            // Evict the workflow
-            tokio::time::sleep(Duration::from_secs(1)).await;
-            cw.request_workflow_eviction(&run_id);
-            // Wake up workflow by sending signal
-            client
-                .signal_workflow_execution(
-                    wf_id,
-                    run_id.clone(),
-                    "whaatever".to_string(),
-                    None,
-                    None,
-                )
-                .await
-                .unwrap();
-        });
-    }
-    let runf = async {
-        worker.run_until_done().await.unwrap();
-    };
-    tokio::join!(subfs.collect::<Vec<_>>(), runf);
-}
-
-pub async fn many_parallel_timers_longhist(ctx: WfContext) -> WorkflowResult<()> {
-    for _ in 0..120 {
-        let mut futs = vec![];
-        for _ in 0..100 {
-            futs.push(ctx.timer(Duration::from_millis(100)));
-        }
-        join_all(futs).await;
-    }
-    Ok(().into())
-}
-
-#[tokio::test]
-async fn can_paginate_long_history() {
-    let wf_name = "can_paginate_long_history";
-    let mut starter = CoreWfStarter::new(wf_name);
-    starter.no_remote_activities();
-    // Do not use sticky queues so we are forced to paginate once history gets long
-    starter.max_cached_workflows(0);
-
-    let mut worker = starter.worker().await;
-    worker.register_wf(wf_name.to_owned(), many_parallel_timers_longhist);
-    let run_id = worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
-    let client = starter.get_client().await;
-    tokio::spawn(async move {
-        loop {
-            for _ in 0..10 {
-                client
-                    .signal_workflow_execution(
-                        wf_name.to_owned(),
-                        run_id.clone(),
-                        "sig".to_string(),
-                        None,
-                        None,
-                    )
-                    .await
-                    .unwrap();
-            }
-            tokio::time::sleep(Duration::from_secs(3)).await;
-        }
-    });
-    worker.run_until_done().await.unwrap();
-}

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

@@ -1,36 +0,0 @@
-use std::time::Duration;
-use temporal_client::{RetryClient, WorkflowClientTrait, WorkflowService};
-use temporal_sdk_core_protos::temporal::api::workflowservice::v1::DescribeNamespaceRequest;
-use temporal_sdk_core_test_utils::{get_integ_server_options, CoreWfStarter, NAMESPACE};
-
-#[tokio::test]
-async fn can_use_retry_client() {
-    // Not terribly interesting by itself but can be useful for manually inspecting metrics etc
-    let mut core = CoreWfStarter::new("retry_client");
-    let retry_client = core.get_client().await;
-    for _ in 0..10 {
-        retry_client.list_namespaces().await.unwrap();
-        tokio::time::sleep(Duration::from_millis(10)).await;
-    }
-}
-
-#[tokio::test]
-async fn can_use_retry_raw_client() {
-    let opts = get_integ_server_options();
-    let raw_client = opts.connect_no_namespace(None, None).await.unwrap();
-    let mut retry_client = RetryClient::new(raw_client, opts.retry_config);
-    retry_client
-        .describe_namespace(DescribeNamespaceRequest {
-            namespace: NAMESPACE.to_string(),
-            ..Default::default()
-        })
-        .await
-        .unwrap();
-}
-
-#[tokio::test]
-async fn calls_get_system_info() {
-    let opts = get_integ_server_options();
-    let raw_client = opts.connect_no_namespace(None, None).await.unwrap();
-    assert!(raw_client.get_client().capabilities().is_some());
-}

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

@@ -1,150 +0,0 @@
-use std::time::{SystemTime, UNIX_EPOCH};
-use temporal_client::{ClientOptionsBuilder, TestService, WorkflowService};
-use temporal_sdk_core::ephemeral_server::{
-    EphemeralExe, EphemeralExeVersion, EphemeralServer, TemporalDevServerConfigBuilder,
-    TemporaliteConfigBuilder, TestServerConfigBuilder,
-};
-use temporal_sdk_core_protos::temporal::api::workflowservice::v1::DescribeNamespaceRequest;
-use temporal_sdk_core_test_utils::{default_cached_download, NAMESPACE};
-use url::Url;
-
-#[tokio::test]
-async fn temporal_cli_default() {
-    let config = TemporalDevServerConfigBuilder::default()
-        .exe(default_cached_download())
-        .build()
-        .unwrap();
-    let mut server = config.start_server().await.unwrap();
-    assert_ephemeral_server(&server).await;
-    server.shutdown().await.unwrap();
-}
-
-#[tokio::test]
-async fn temporal_cli_fixed() {
-    let config = TemporalDevServerConfigBuilder::default()
-        .exe(fixed_cached_download("v0.4.0"))
-        .build()
-        .unwrap();
-    let mut server = config.start_server().await.unwrap();
-    assert_ephemeral_server(&server).await;
-    server.shutdown().await.unwrap();
-}
-
-#[tokio::test]
-async fn temporalite_default() {
-    let config = TemporaliteConfigBuilder::default()
-        .exe(default_cached_download())
-        .build()
-        .unwrap();
-    let mut server = config.start_server().await.unwrap();
-    assert_ephemeral_server(&server).await;
-    server.shutdown().await.unwrap();
-}
-
-#[tokio::test]
-async fn temporalite_fixed() {
-    let config = TemporaliteConfigBuilder::default()
-        .exe(fixed_cached_download("v0.2.0"))
-        .build()
-        .unwrap();
-    let mut server = config.start_server().await.unwrap();
-    assert_ephemeral_server(&server).await;
-    server.shutdown().await.unwrap();
-}
-
-#[tokio::test]
-async fn temporalite_shutdown_port_reuse() {
-    // Start, test shutdown, do again immediately on same port to ensure we can
-    // reuse after shutdown
-    let config = TemporaliteConfigBuilder::default()
-        .exe(default_cached_download())
-        .port(Some(10123))
-        .build()
-        .unwrap();
-    let mut server = config.start_server().await.unwrap();
-    assert_ephemeral_server(&server).await;
-    server.shutdown().await.unwrap();
-    let mut server = config.start_server().await.unwrap();
-    assert_ephemeral_server(&server).await;
-    server.shutdown().await.unwrap();
-}
-
-#[tokio::test]
-async fn test_server_default() {
-    let config = TestServerConfigBuilder::default()
-        .exe(default_cached_download())
-        .build()
-        .unwrap();
-    let mut server = config.start_server().await.unwrap();
-    assert_ephemeral_server(&server).await;
-    server.shutdown().await.unwrap();
-}
-
-#[tokio::test]
-async fn test_server_fixed() {
-    let config = TestServerConfigBuilder::default()
-        .exe(fixed_cached_download("v1.16.0"))
-        .build()
-        .unwrap();
-    let mut server = config.start_server().await.unwrap();
-    assert_ephemeral_server(&server).await;
-    server.shutdown().await.unwrap();
-}
-
-#[tokio::test]
-async fn test_server_shutdown_port_reuse() {
-    // Start, test shutdown, do again immediately on same port to ensure we can
-    // reuse after shutdown
-    let config = TestServerConfigBuilder::default()
-        .exe(default_cached_download())
-        .port(Some(10124))
-        .build()
-        .unwrap();
-    let mut server = config.start_server().await.unwrap();
-    assert_ephemeral_server(&server).await;
-    server.shutdown().await.unwrap();
-    let mut server = config.start_server().await.unwrap();
-    assert_ephemeral_server(&server).await;
-    server.shutdown().await.unwrap();
-}
-
-fn fixed_cached_download(version: &str) -> EphemeralExe {
-    EphemeralExe::CachedDownload {
-        version: EphemeralExeVersion::Fixed(version.to_string()),
-        dest_dir: None,
-    }
-}
-
-async fn assert_ephemeral_server(server: &EphemeralServer) {
-    // Connect and describe namespace
-    let mut client = ClientOptionsBuilder::default()
-        .identity("integ_tester".to_string())
-        .target_url(Url::try_from(&*format!("http://{}", server.target)).unwrap())
-        .client_name("temporal-core".to_string())
-        .client_version("0.1.0".to_string())
-        .build()
-        .unwrap()
-        .connect_no_namespace(None, None)
-        .await
-        .unwrap();
-    let resp = client
-        .describe_namespace(DescribeNamespaceRequest {
-            namespace: NAMESPACE.to_string(),
-            ..Default::default()
-        })
-        .await
-        .unwrap();
-    assert!(resp.into_inner().namespace_info.unwrap().name == "default");
-
-    // If it has test service, make sure we can use it too
-    if server.has_test_service {
-        let resp = client.get_current_time(()).await.unwrap();
-        // Make sure it's within 5 mins of now
-        let resp_seconds = resp.get_ref().time.as_ref().unwrap().seconds as u64;
-        let curr_seconds = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .unwrap()
-            .as_secs();
-        assert!(curr_seconds - 300 < resp_seconds && curr_seconds + 300 > resp_seconds);
-    }
-}