temporalio 0.1.0 → 0.2.0

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

@@ -1,223 +0,0 @@
-use assert_matches::assert_matches;
-use std::time::Duration;
-use temporal_client::{WfClientExt, WorkflowOptions};
-use temporal_sdk::{ActContext, ActivityOptions, WfContext};
-use temporal_sdk_core_protos::{
-    coresdk::{
-        activity_result::{
-            self, activity_resolution as act_res, ActivityExecutionResult, ActivityResolution,
-        },
-        activity_task::activity_task,
-        workflow_activation::{workflow_activation_job, ResolveActivity, WorkflowActivationJob},
-        workflow_commands::{ActivityCancellationType, ScheduleActivity},
-        workflow_completion::WorkflowActivationCompletion,
-        ActivityHeartbeat, ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion,
-    },
-    temporal::api::{
-        common::v1::{Payload, RetryPolicy},
-        enums::v1::TimeoutType,
-    },
-    DEFAULT_ACTIVITY_TYPE,
-};
-use temporal_sdk_core_test_utils::{
-    drain_pollers_and_shutdown, init_core_and_create_wf, schedule_activity_cmd, CoreWfStarter,
-    WorkerTestHelpers,
-};
-use tokio::time::sleep;
-
-#[tokio::test]
-async fn activity_heartbeat() {
-    let mut starter = init_core_and_create_wf("activity_heartbeat").await;
-    let core = starter.get_worker().await;
-    let task_q = starter.get_task_queue();
-    let activity_id = "act-1";
-    let task = core.poll_workflow_activation().await.unwrap();
-    // Complete workflow task and schedule activity
-    core.complete_workflow_activation(
-        schedule_activity_cmd(
-            0,
-            task_q,
-            activity_id,
-            ActivityCancellationType::TryCancel,
-            Duration::from_secs(60),
-            Duration::from_secs(1),
-        )
-        .into_completion(task.run_id),
-    )
-    .await
-    .unwrap();
-    // Poll activity and verify that it's been scheduled with correct parameters
-    let task = core.poll_activity_task().await.unwrap();
-    assert_matches!(
-        task.variant,
-        Some(activity_task::Variant::Start(start_activity)) => {
-            assert_eq!(start_activity.activity_type, DEFAULT_ACTIVITY_TYPE.to_string())
-        }
-    );
-    // Heartbeat timeout is set to 1 second, this loop is going to send heartbeat every 100ms.
-    // Activity shouldn't timeout since we are sending heartbeats regularly, however if we didn't
-    // send heartbeats activity would have timed out as it takes 2 sec to execute this loop.
-    for _ in 0u8..20 {
-        sleep(Duration::from_millis(100)).await;
-        core.record_activity_heartbeat(ActivityHeartbeat {
-            task_token: task.task_token.clone(),
-            details: vec![],
-        });
-    }
-
-    let response_payload = Payload {
-        data: b"hello ".to_vec(),
-        metadata: Default::default(),
-    };
-    // Complete activity successfully.
-    core.complete_activity_task(ActivityTaskCompletion {
-        task_token: task.task_token,
-        result: Some(ActivityExecutionResult::ok(response_payload.clone())),
-    })
-    .await
-    .unwrap();
-    // Poll workflow task and verify that activity has succeeded.
-    let task = core.poll_workflow_activation().await.unwrap();
-    assert_matches!(
-        task.jobs.as_slice(),
-        [
-            WorkflowActivationJob {
-                variant: Some(workflow_activation_job::Variant::ResolveActivity(
-                    ResolveActivity {seq, result: Some(ActivityResolution {
-                    status: Some(act_res::Status::Completed(activity_result::Success{result: Some(r)})),
-                     ..})}
-                )),
-            },
-        ] => {
-            assert_eq!(*seq, 0);
-            assert_eq!(r, &response_payload);
-        }
-    );
-    core.complete_execution(&task.run_id).await;
-}
-
-#[tokio::test]
-async fn many_act_fails_with_heartbeats() {
-    let mut starter = init_core_and_create_wf("many_act_fails_with_heartbeats").await;
-    let core = starter.get_worker().await;
-    let activity_id = "act-1";
-    let task = core.poll_workflow_activation().await.unwrap();
-    // Complete workflow task and schedule activity
-    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
-        task.run_id,
-        ScheduleActivity {
-            seq: 0,
-            activity_id: activity_id.to_string(),
-            activity_type: "test_act".to_string(),
-            task_queue: starter.get_task_queue().to_string(),
-            start_to_close_timeout: Some(prost_dur!(from_secs(30))),
-            retry_policy: Some(RetryPolicy {
-                initial_interval: Some(prost_dur!(from_millis(10))),
-                backoff_coefficient: 1.0,
-                maximum_attempts: 4,
-                ..Default::default()
-            }),
-            heartbeat_timeout: Some(prost_dur!(from_secs(1))),
-            ..Default::default()
-        }
-        .into(),
-    ))
-    .await
-    .unwrap();
-
-    // Multiple times, poll for the activity, heartbeat, and then immediately fail
-    // Poll activity and verify that it's been scheduled with correct parameters
-    for i in 0u8..=3 {
-        let task = core.poll_activity_task().await.unwrap();
-        let start_t = assert_matches!(task.variant, Some(activity_task::Variant::Start(s)) => s);
-
-        core.record_activity_heartbeat(ActivityHeartbeat {
-            task_token: task.task_token.clone(),
-            details: vec![[i].into()],
-        });
-
-        let compl = if i == 3 {
-            // Verify last hb was recorded
-            assert_eq!(start_t.heartbeat_details, [[2].into()]);
-            ActivityTaskCompletion {
-                task_token: task.task_token,
-                result: Some(ActivityExecutionResult::ok("passed".into())),
-            }
-        } else {
-            if i != 0 {
-                assert_eq!(start_t.heartbeat_details, [[i - 1].into()]);
-            }
-            ActivityTaskCompletion {
-                task_token: task.task_token,
-                result: Some(ActivityExecutionResult::fail(format!("Die on {i}").into())),
-            }
-        };
-        core.complete_activity_task(compl).await.unwrap();
-    }
-    let task = core.poll_workflow_activation().await.unwrap();
-
-    assert_matches!(
-        task.jobs.as_slice(),
-        [WorkflowActivationJob {
-            variant: Some(workflow_activation_job::Variant::ResolveActivity(
-                ResolveActivity {
-                    result: Some(ActivityResolution {
-                        status: Some(act_res::Status::Completed(activity_result::Success { .. })),
-                        ..
-                    }),
-                    ..
-                }
-            )),
-        },]
-    );
-    core.complete_execution(&task.run_id).await;
-    drain_pollers_and_shutdown(&core).await;
-}
-
-#[tokio::test]
-async fn activity_doesnt_heartbeat_hits_timeout_then_completes() {
-    let wf_name = "activity_doesnt_heartbeat_hits_timeout_then_completes";
-    let mut starter = CoreWfStarter::new(wf_name);
-    let mut worker = starter.worker().await;
-    let client = starter.get_client().await;
-    worker.register_activity(
-        "echo_activity",
-        |_ctx: ActContext, echo_me: String| async move {
-            sleep(Duration::from_secs(4)).await;
-            Ok(echo_me)
-        },
-    );
-    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
-        let res = ctx
-            .activity(ActivityOptions {
-                activity_type: "echo_activity".to_string(),
-                input: "hi!".as_json_payload().expect("serializes fine"),
-                start_to_close_timeout: Some(Duration::from_secs(10)),
-                heartbeat_timeout: Some(Duration::from_secs(2)),
-                retry_policy: Some(RetryPolicy {
-                    maximum_attempts: 1,
-                    ..Default::default()
-                }),
-                ..Default::default()
-            })
-            .await;
-        assert_eq!(res.timed_out(), Some(TimeoutType::Heartbeat));
-        Ok(().into())
-    });
-
-    let run_id = worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
-    worker.run_until_done().await.unwrap();
-    let handle = client.get_untyped_workflow_handle(wf_name, run_id);
-    handle
-        .get_workflow_result(Default::default())
-        .await
-        .unwrap();
-}

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

@@ -1,239 +0,0 @@
-use std::{sync::Arc, time::Duration};
-use temporal_client::{WorkflowClientTrait, WorkflowOptions, WorkflowService};
-use temporal_sdk_core::{init_worker, CoreRuntime};
-use temporal_sdk_core_api::{telemetry::MetricsExporter, worker::WorkerConfigBuilder, Worker};
-use temporal_sdk_core_protos::{
-    coresdk::{
-        activity_result::ActivityExecutionResult,
-        workflow_commands::{ScheduleActivity, ScheduleLocalActivity},
-        workflow_completion::WorkflowActivationCompletion,
-        ActivityTaskCompletion,
-    },
-    temporal::api::{enums::v1::WorkflowIdReusePolicy, workflowservice::v1::ListNamespacesRequest},
-};
-use temporal_sdk_core_test_utils::{get_integ_server_options, get_integ_telem_options, NAMESPACE};
-use tokio::sync::Barrier;
-
-static ANY_PORT: &str = "127.0.0.1:0";
-
-async fn get_text(endpoint: String) -> String {
-    reqwest::get(endpoint).await.unwrap().text().await.unwrap()
-}
-
-#[tokio::test]
-async fn prometheus_metrics_exported() {
-    let mut telemopts = get_integ_telem_options();
-    telemopts.metrics = Some(MetricsExporter::Prometheus(ANY_PORT.parse().unwrap()));
-    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
-    let addr = rt.telemetry().prom_port().unwrap();
-    let opts = get_integ_server_options();
-    let mut raw_client = opts
-        .connect_no_namespace(rt.metric_meter().as_deref(), None)
-        .await
-        .unwrap();
-    assert!(raw_client.get_client().capabilities().is_some());
-
-    let _ = raw_client
-        .list_namespaces(ListNamespacesRequest::default())
-        .await
-        .unwrap();
-
-    let body = get_text(format!("http://{addr}/metrics")).await;
-    assert!(body.contains(
-        "temporal_request_latency_count{operation=\"ListNamespaces\",service_name=\"temporal-core-sdk\"} 1"
-    ));
-    assert!(body.contains(
-        "temporal_request_latency_count{operation=\"GetSystemInfo\",service_name=\"temporal-core-sdk\"} 1"
-    ));
-}
-
-#[tokio::test]
-async fn one_slot_worker_reports_available_slot() {
-    let mut telemopts = get_integ_telem_options();
-    let tq = "one_slot_worker_tq";
-    telemopts.metrics = Some(MetricsExporter::Prometheus(ANY_PORT.parse().unwrap()));
-    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
-    let addr = rt.telemetry().prom_port().unwrap();
-
-    let worker_cfg = WorkerConfigBuilder::default()
-        .namespace(NAMESPACE)
-        .task_queue(tq)
-        .worker_build_id("test_build_id")
-        .max_cached_workflows(1_usize)
-        .max_outstanding_activities(1_usize)
-        .max_outstanding_local_activities(1_usize)
-        .max_outstanding_workflow_tasks(1_usize)
-        .build()
-        .unwrap();
-
-    let client = Arc::new(
-        get_integ_server_options()
-            .connect(worker_cfg.namespace.clone(), None, None)
-            .await
-            .expect("Must connect"),
-    );
-    let worker = init_worker(&rt, worker_cfg, client.clone()).expect("Worker inits cleanly");
-    let wf_task_barr = Barrier::new(2);
-    let act_task_barr = Barrier::new(2);
-
-    let wf_polling = async {
-        let task = worker.poll_workflow_activation().await.unwrap();
-        wf_task_barr.wait().await;
-        wf_task_barr.wait().await;
-        worker
-            .complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
-                task.run_id,
-                ScheduleActivity {
-                    seq: 1,
-                    activity_id: "1".to_string(),
-                    activity_type: "test_act".to_string(),
-                    task_queue: tq.to_string(),
-                    start_to_close_timeout: Some(prost_dur!(from_secs(30))),
-                    ..Default::default()
-                }
-                .into(),
-            ))
-            .await
-            .unwrap();
-        wf_task_barr.wait().await;
-
-        let task = worker.poll_workflow_activation().await.unwrap();
-        worker
-            .complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
-                task.run_id,
-                ScheduleLocalActivity {
-                    seq: 2,
-                    activity_id: "2".to_string(),
-                    activity_type: "test_act".to_string(),
-                    start_to_close_timeout: Some(prost_dur!(from_secs(30))),
-                    ..Default::default()
-                }
-                .into(),
-            ))
-            .await
-            .unwrap();
-    };
-
-    let act_polling = async {
-        let task = worker.poll_activity_task().await.unwrap();
-        act_task_barr.wait().await;
-        worker
-            .complete_activity_task(ActivityTaskCompletion {
-                task_token: task.task_token,
-                result: Some(ActivityExecutionResult::ok(vec![1].into())),
-            })
-            .await
-            .unwrap();
-        act_task_barr.wait().await;
-
-        let task = worker.poll_activity_task().await.unwrap();
-        act_task_barr.wait().await;
-        act_task_barr.wait().await;
-        worker
-            .complete_activity_task(ActivityTaskCompletion {
-                task_token: task.task_token,
-                result: Some(ActivityExecutionResult::ok(vec![1].into())),
-            })
-            .await
-            .unwrap();
-        act_task_barr.wait().await;
-    };
-
-    let testing = async {
-        // Wait just a beat for the poller to initiate
-        tokio::time::sleep(Duration::from_millis(50)).await;
-        let body = get_text(format!("http://{addr}/metrics")).await;
-        assert!(body.contains(&format!(
-            "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
-             service_name=\"temporal-core-sdk\",task_queue=\"one_slot_worker_tq\",\
-             worker_type=\"WorkflowWorker\"}} 1"
-        )));
-
-        // Start a workflow so that a task will get delivered
-        client
-            .start_workflow(
-                vec![],
-                tq.to_owned(),
-                "one_slot_metric_test".to_owned(),
-                "whatever".to_string(),
-                None,
-                WorkflowOptions {
-                    id_reuse_policy: WorkflowIdReusePolicy::TerminateIfRunning,
-                    execution_timeout: Some(Duration::from_secs(5)),
-                    ..Default::default()
-                },
-            )
-            .await
-            .unwrap();
-
-        wf_task_barr.wait().await;
-
-        // At this point the workflow task is outstanding, so there should be 0 slots, and
-        // the activities haven't started, so there should be 1 each.
-        let body = get_text(format!("http://{addr}/metrics")).await;
-        assert!(body.contains(&format!(
-            "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
-             service_name=\"temporal-core-sdk\",task_queue=\"one_slot_worker_tq\",\
-             worker_type=\"WorkflowWorker\"}} 0"
-        )));
-        assert!(body.contains(&format!(
-            "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
-             service_name=\"temporal-core-sdk\",task_queue=\"one_slot_worker_tq\",\
-             worker_type=\"ActivityWorker\"}} 1"
-        )));
-        assert!(body.contains(&format!(
-            "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
-             service_name=\"temporal-core-sdk\",task_queue=\"one_slot_worker_tq\",\
-             worker_type=\"LocalActivityWorker\"}} 1"
-        )));
-
-        // Now we allow the complete to proceed. Once it goes through, there should be 1 WFT slot
-        // open but 0 activity slots
-        wf_task_barr.wait().await;
-        wf_task_barr.wait().await;
-        // Sometimes the recording takes an extra bit. 🤷
-        tokio::time::sleep(Duration::from_millis(100)).await;
-        let body = get_text(format!("http://{addr}/metrics")).await;
-        assert!(body.contains(&format!(
-            "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
-             service_name=\"temporal-core-sdk\",task_queue=\"one_slot_worker_tq\",\
-             worker_type=\"WorkflowWorker\"}} 1"
-        )));
-        assert!(body.contains(&format!(
-            "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
-             service_name=\"temporal-core-sdk\",task_queue=\"one_slot_worker_tq\",\
-             worker_type=\"ActivityWorker\"}} 0"
-        )));
-
-        // Now complete the activity and watch it go up
-        act_task_barr.wait().await;
-        // Wait for completion to finish
-        act_task_barr.wait().await;
-        let body = get_text(format!("http://{addr}/metrics")).await;
-        assert!(body.contains(&format!(
-            "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
-             service_name=\"temporal-core-sdk\",task_queue=\"one_slot_worker_tq\",\
-             worker_type=\"ActivityWorker\"}} 1"
-        )));
-
-        // Proceed to local activity command
-        act_task_barr.wait().await;
-        // Ensure that, once we have the LA task, slots are 0
-        let body = get_text(format!("http://{addr}/metrics")).await;
-        assert!(body.contains(&format!(
-            "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
-             service_name=\"temporal-core-sdk\",task_queue=\"one_slot_worker_tq\",\
-             worker_type=\"LocalActivityWorker\"}} 0"
-        )));
-        // When completion is done, we have 1 again
-        act_task_barr.wait().await;
-        act_task_barr.wait().await;
-        let body = get_text(format!("http://{addr}/metrics")).await;
-        assert!(body.contains(&format!(
-            "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
-             service_name=\"temporal-core-sdk\",task_queue=\"one_slot_worker_tq\",\
-             worker_type=\"LocalActivityWorker\"}} 1"
-        )));
-    };
-    tokio::join!(wf_polling, act_polling, testing);
-}

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

@@ -1,90 +0,0 @@
-use assert_matches::assert_matches;
-use std::time::Duration;
-use temporal_sdk_core_protos::coresdk::{
-    activity_task::activity_task as act_task,
-    workflow_activation::{workflow_activation_job, FireTimer, WorkflowActivationJob},
-    workflow_commands::{ActivityCancellationType, RequestCancelActivity, StartTimer},
-    workflow_completion::WorkflowActivationCompletion,
-    IntoCompletion,
-};
-use temporal_sdk_core_test_utils::{
-    init_core_and_create_wf, schedule_activity_cmd, WorkerTestHelpers,
-};
-use tokio::time::timeout;
-
-#[tokio::test]
-async fn out_of_order_completion_doesnt_hang() {
-    let mut starter = init_core_and_create_wf("out_of_order_completion_doesnt_hang").await;
-    let core = starter.get_worker().await;
-    let task_q = starter.get_task_queue();
-    let activity_id = "act-1";
-    let task = core.poll_workflow_activation().await.unwrap();
-    // Complete workflow task and schedule activity and a timer that fires immediately
-    core.complete_workflow_activation(
-        vec![
-            schedule_activity_cmd(
-                0,
-                task_q,
-                activity_id,
-                ActivityCancellationType::TryCancel,
-                Duration::from_secs(60),
-                Duration::from_secs(60),
-            ),
-            StartTimer {
-                seq: 1,
-                start_to_fire_timeout: Some(prost_dur!(from_millis(50))),
-            }
-            .into(),
-        ]
-        .into_completion(task.run_id),
-    )
-    .await
-    .unwrap();
-    // Poll activity and verify that it's been scheduled, we don't expect to complete it in this
-    // test as activity is try-cancelled.
-    let activity_task = core.poll_activity_task().await.unwrap();
-    assert_matches!(activity_task.variant, Some(act_task::Variant::Start(_)));
-    // Poll workflow task and verify that activity has failed.
-    let task = core.poll_workflow_activation().await.unwrap();
-    assert_matches!(
-        task.jobs.as_slice(),
-        [
-            WorkflowActivationJob {
-                variant: Some(workflow_activation_job::Variant::FireTimer(
-                    FireTimer { seq: t_seq }
-                )),
-            },
-        ] => {
-            assert_eq!(*t_seq, 1);
-        }
-    );
-
-    // Start polling again *before* we complete the WFT
-    let cc = core.clone();
-    let jh = tokio::spawn(async move {
-        // We want to fail the test if this takes too long -- we should not hit long poll timeout
-        let task = timeout(Duration::from_secs(1), cc.poll_workflow_activation())
-            .await
-            .expect("Poll should come back right away")
-            .unwrap();
-        assert_matches!(
-            task.jobs.as_slice(),
-            [WorkflowActivationJob {
-                variant: Some(workflow_activation_job::Variant::ResolveActivity(_)),
-            }]
-        );
-        cc.complete_execution(&task.run_id).await;
-    });
-
-    tokio::time::sleep(Duration::from_millis(100)).await;
-    // Then complete the (last) WFT with a request to cancel the AT, which should produce a
-    // pending activation, unblocking the (already started) poll
-    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        task.run_id,
-        vec![RequestCancelActivity { seq: 0 }.into()],
-    ))
-    .await
-    .unwrap();
-
-    jh.await.unwrap();
-}