From a3cd3fa8df9a52ef291d4266d721f1e04df4310d Mon Sep 17 00:00:00 2001 From: Spencer Judge Date: Fri, 21 Feb 2025 11:34:42 -0800 Subject: [PATCH] Rust / Packages upgrade (#880) --- .github/workflows/per-pr.yml | 8 +- Cargo.toml | 2 +- client/Cargo.toml | 3 +- client/src/lib.rs | 12 +- client/src/metrics.rs | 4 +- client/src/proxy.rs | 2 +- client/src/raw.rs | 28 +-- client/src/retry.rs | 4 +- client/src/worker_registry/mod.rs | 2 +- core-api/Cargo.toml | 3 +- core-api/src/lib.rs | 2 +- core-api/src/telemetry/metrics.rs | 2 +- core/Cargo.toml | 12 +- core/benches/workflow_replay.rs | 2 +- core/src/abstractions.rs | 2 +- core/src/core_tests/activity_tasks.rs | 69 +++---- core/src/core_tests/child_workflows.rs | 8 +- core/src/core_tests/determinism.rs | 4 +- core/src/core_tests/local_activities.rs | 24 +-- core/src/core_tests/mod.rs | 4 +- core/src/core_tests/queries.rs | 22 +-- core/src/core_tests/replay_flag.rs | 10 +- core/src/core_tests/updates.rs | 12 +- core/src/core_tests/workers.rs | 15 +- core/src/core_tests/workflow_cancels.rs | 6 +- core/src/core_tests/workflow_tasks.rs | 173 ++++++++++-------- core/src/ephemeral_server/mod.rs | 2 +- core/src/lib.rs | 6 +- core/src/pollers/mod.rs | 4 +- core/src/pollers/poll_buffer.rs | 11 +- core/src/protosext/mod.rs | 14 +- core/src/protosext/protocol_messages.rs | 4 +- core/src/replay/mod.rs | 17 +- core/src/retry_logic.rs | 14 +- core/src/telemetry/log_export.rs | 6 +- core/src/telemetry/metrics.rs | 2 +- core/src/telemetry/mod.rs | 12 +- core/src/telemetry/otel.rs | 17 +- core/src/telemetry/prometheus_server.rs | 2 +- core/src/test_help/mod.rs | 24 +-- core/src/worker/activities.rs | 21 +-- .../activities/activity_heartbeat_manager.rs | 12 +- .../src/worker/activities/local_activities.rs | 18 +- core/src/worker/client.rs | 2 +- core/src/worker/mod.rs | 40 ++-- core/src/worker/nexus.rs | 17 +- core/src/worker/tuner/resource_based.rs | 4 +- core/src/worker/workflow/driven_workflow.rs | 2 +- core/src/worker/workflow/history_update.rs | 13 +- .../machines/activity_state_machine.rs | 75 ++++---- .../machines/cancel_external_state_machine.rs | 54 +++--- .../machines/cancel_workflow_state_machine.rs | 12 +- .../machines/child_workflow_state_machine.rs | 132 +++++++------ .../complete_workflow_state_machine.rs | 8 +- .../continue_as_new_workflow_state_machine.rs | 6 +- .../machines/fail_workflow_state_machine.rs | 8 +- .../machines/local_activity_state_machine.rs | 20 +- ...odify_workflow_properties_state_machine.rs | 12 +- .../machines/nexus_operation_state_machine.rs | 108 ++++++----- .../workflow/machines/patch_state_machine.rs | 27 ++- .../machines/signal_external_state_machine.rs | 92 +++++----- .../workflow/machines/timer_state_machine.rs | 28 +-- .../workflow/machines/transition_coverage.rs | 4 +- .../workflow/machines/update_state_machine.rs | 14 +- .../upsert_search_attributes_state_machine.rs | 34 ++-- .../workflow/machines/workflow_machines.rs | 43 +++-- .../machines/workflow_task_state_machine.rs | 8 +- core/src/worker/workflow/managed_run.rs | 22 +-- core/src/worker/workflow/mod.rs | 36 ++-- core/src/worker/workflow/run_cache.rs | 4 +- core/src/worker/workflow/wft_extraction.rs | 8 +- core/src/worker/workflow/wft_poller.rs | 6 +- core/src/worker/workflow/workflow_stream.rs | 4 +- fsm/Cargo.toml | 2 +- fsm/rustfsm_procmacro/Cargo.toml | 2 +- fsm/rustfsm_procmacro/src/lib.rs | 7 +- fsm/rustfsm_trait/Cargo.toml | 2 +- sdk-core-protos/Cargo.toml | 5 +- sdk-core-protos/src/history_builder.rs | 10 +- sdk-core-protos/src/history_info.rs | 4 +- sdk-core-protos/src/lib.rs | 40 ++-- sdk-core-protos/src/task_token.rs | 2 +- sdk/Cargo.toml | 3 +- sdk/src/activity_context.rs | 2 +- sdk/src/interceptors.rs | 2 +- sdk/src/lib.rs | 29 +-- sdk/src/workflow_context.rs | 26 ++- sdk/src/workflow_future.rs | 35 ++-- test-utils/Cargo.toml | 12 +- test-utils/src/canned_histories.rs | 2 +- test-utils/src/lib.rs | 42 +++-- tests/fuzzy_workflow.rs | 6 +- tests/heavy_tests.rs | 6 +- tests/integ_tests/client_tests.rs | 12 +- tests/integ_tests/ephemeral_server_tests.rs | 4 +- tests/integ_tests/heartbeat_tests.rs | 12 +- tests/integ_tests/metrics_tests.rs | 47 ++--- tests/integ_tests/polling_tests.rs | 10 +- tests/integ_tests/queries_tests.rs | 14 +- tests/integ_tests/update_tests.rs | 26 +-- tests/integ_tests/visibility_tests.rs | 6 +- tests/integ_tests/worker_tests.rs | 10 +- tests/integ_tests/workflow_tests.rs | 48 ++--- .../integ_tests/workflow_tests/activities.rs | 28 +-- .../workflow_tests/cancel_external.rs | 2 +- .../workflow_tests/child_workflows.rs | 2 +- tests/integ_tests/workflow_tests/eager.rs | 2 +- .../workflow_tests/local_activities.rs | 16 +- tests/integ_tests/workflow_tests/nexus.rs | 14 +- tests/integ_tests/workflow_tests/patches.rs | 2 +- tests/integ_tests/workflow_tests/replay.rs | 52 +++--- tests/integ_tests/workflow_tests/resets.rs | 2 +- tests/integ_tests/workflow_tests/timers.rs | 16 +- tests/main.rs | 8 +- tests/runner.rs | 4 +- 115 files changed, 1058 insertions(+), 982 deletions(-) diff --git a/.github/workflows/per-pr.yml b/.github/workflows/per-pr.yml index 8d05f6ff7..05e1f4346 100644 --- a/.github/workflows/per-pr.yml +++ b/.github/workflows/per-pr.yml @@ -21,7 +21,7 @@ jobs: submodules: recursive - uses: dtolnay/rust-toolchain@stable with: - toolchain: 1.84.0 + toolchain: 1.85.0 - name: Install protoc uses: arduino/setup-protoc@v3 with: @@ -56,7 +56,7 @@ jobs: - uses: actions/checkout@v4 - uses: dtolnay/rust-toolchain@stable with: - toolchain: 1.84.0 + toolchain: 1.85.0 - name: Install protoc uses: arduino/setup-protoc@v3 with: @@ -100,7 +100,7 @@ jobs: - uses: actions/checkout@v4 - uses: dtolnay/rust-toolchain@stable with: - toolchain: 1.84.0 + toolchain: 1.85.0 - name: Install protoc uses: arduino/setup-protoc@v3 with: @@ -125,7 +125,7 @@ jobs: - uses: actions/checkout@v4 - uses: dtolnay/rust-toolchain@stable with: - toolchain: 1.84.0 + toolchain: 1.85.0 - name: Install protoc uses: arduino/setup-protoc@v3 with: diff --git a/Cargo.toml b/Cargo.toml index 583f59f78..4ada4bf3d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,7 +8,7 @@ license-file = "LICENSE.txt" [workspace.dependencies] derive_builder = "0.20" -derive_more = { version = "1.0", features = ["constructor", "display", "from", "into", "debug"] } +derive_more = { version = "2.0", features = ["constructor", "display", "from", "into", "debug"] } thiserror = "2" tonic = "0.12" tonic-build = "0.12" diff --git a/client/Cargo.toml b/client/Cargo.toml index 3c8f94031..d48732c88 100644 --- a/client/Cargo.toml +++ b/client/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "temporal-client" version = "0.1.0" -edition = "2021" +edition = "2024" authors = ["Spencer Judge "] license-file = { workspace = true } description = "Clients for interacting with Temporal Clusters" @@ -28,7 +28,6 @@ hyper = { version = "1.4.1" } hyper-util = "0.1.6" opentelemetry = { workspace = true, features = ["metrics"], optional = true } parking_lot = "0.12" -prost-types = { workspace = true } slotmap = "1.0" thiserror = { workspace = true } tokio = "1.1" diff --git a/client/src/lib.rs b/client/src/lib.rs index 8a0c40294..5e34d5b77 100644 --- a/client/src/lib.rs +++ b/client/src/lib.rs @@ -16,7 +16,7 @@ mod workflow_handle; pub use crate::{ proxy::HttpConnectProxyOptions, - retry::{CallType, RetryClient, RETRYABLE_ERROR_CODES}, + retry::{CallType, RETRYABLE_ERROR_CODES, RetryClient}, }; pub use metrics::{LONG_REQUEST_LATENCY_HISTOGRAM_NAME, REQUEST_LATENCY_HISTOGRAM_NAME}; pub use raw::{CloudService, HealthService, OperatorService, TestService, WorkflowService}; @@ -36,12 +36,12 @@ pub use workflow_handle::{ use crate::{ metrics::{GrpcMetricSvc, MetricsContext}, - raw::{sealed::RawClientLike, AttachMetricLabels}, + raw::{AttachMetricLabels, sealed::RawClientLike}, sealed::WfHandleClient, workflow_handle::UntypedWorkflowHandle, }; -use backoff::{exponential, ExponentialBackoff, SystemClock}; -use http::{uri::InvalidUri, Uri}; +use backoff::{ExponentialBackoff, SystemClock, exponential}; +use http::{Uri, uri::InvalidUri}; use parking_lot::RwLock; use std::{ collections::HashMap, @@ -53,6 +53,7 @@ use std::{ }; use temporal_sdk_core_api::telemetry::metrics::TemporalMeter; use temporal_sdk_core_protos::{ + TaskToken, coresdk::IntoPayloadsExt, grpc::health::v1::health_client::HealthClient, temporal::api::{ @@ -68,16 +69,15 @@ use temporal_sdk_core_protos::{ update, workflowservice::v1::{workflow_service_client::WorkflowServiceClient, *}, }, - TaskToken, }; use tonic::{ + Code, Status, body::BoxBody, client::GrpcService, codegen::InterceptedService, metadata::{MetadataKey, MetadataMap, MetadataValue}, service::Interceptor, transport::{Certificate, Channel, Endpoint, Identity}, - Code, Status, }; use tower::ServiceBuilder; use url::Url; diff --git a/client/src/metrics.rs b/client/src/metrics.rs index 0f0f354e9..935b461c2 100644 --- a/client/src/metrics.rs +++ b/client/src/metrics.rs @@ -1,5 +1,5 @@ use crate::{AttachMetricLabels, CallType}; -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use std::{ sync::Arc, task::{Context, Poll}, @@ -9,7 +9,7 @@ use temporal_sdk_core_api::telemetry::metrics::{ CoreMeter, Counter, HistogramDuration, MetricAttributes, MetricKeyValue, MetricParameters, TemporalMeter, }; -use tonic::{body::BoxBody, transport::Channel, Code}; +use tonic::{Code, body::BoxBody, transport::Channel}; use tower::Service; /// The string name (which may be prefixed) for this metric diff --git a/client/src/proxy.rs b/client/src/proxy.rs index 83a0a5c62..05ea33d83 100644 --- a/client/src/proxy.rs +++ b/client/src/proxy.rs @@ -12,7 +12,7 @@ use std::{ }; use tokio::net::TcpStream; use tonic::transport::{Channel, Endpoint}; -use tower::{service_fn, Service}; +use tower::{Service, service_fn}; /// Options for HTTP CONNECT proxy. #[derive(Clone, Debug)] diff --git a/client/src/raw.rs b/client/src/raw.rs index 8fe70408d..5ede8c14f 100644 --- a/client/src/raw.rs +++ b/client/src/raw.rs @@ -3,13 +3,13 @@ //! happen. use crate::{ + Client, ConfiguredClient, InterceptedMetricsSvc, LONG_POLL_TIMEOUT, RequestExt, RetryClient, + TEMPORAL_NAMESPACE_HEADER_KEY, TemporalServiceClient, metrics::{namespace_kv, task_queue_kv}, raw::sealed::RawClientLike, worker_registry::{Slot, SlotManager}, - Client, ConfiguredClient, InterceptedMetricsSvc, RequestExt, RetryClient, - TemporalServiceClient, LONG_POLL_TIMEOUT, TEMPORAL_NAMESPACE_HEADER_KEY, }; -use futures_util::{future::BoxFuture, FutureExt, TryFutureExt}; +use futures_util::{FutureExt, TryFutureExt, future::BoxFuture}; use std::sync::Arc; use temporal_sdk_core_api::telemetry::metrics::MetricKeyValue; use temporal_sdk_core_protos::{ @@ -23,10 +23,10 @@ use temporal_sdk_core_protos::{ }, }; use tonic::{ + Request, Response, Status, body::BoxBody, client::GrpcService, metadata::{AsciiMetadataValue, KeyAndValueRef}, - Request, Response, Status, }; pub(super) mod sealed { @@ -1411,29 +1411,33 @@ mod tests { #[test] fn verify_all_workflow_service_methods_implemented() { // This is less work than trying to hook into the codegen process - let proto_def = - include_str!("../../sdk-core-protos/protos/api_upstream/temporal/api/workflowservice/v1/service.proto"); + let proto_def = include_str!( + "../../sdk-core-protos/protos/api_upstream/temporal/api/workflowservice/v1/service.proto" + ); verify_methods(proto_def, ALL_IMPLEMENTED_WORKFLOW_SERVICE_RPCS); } #[test] fn verify_all_operator_service_methods_implemented() { - let proto_def = - include_str!("../../sdk-core-protos/protos/api_upstream/temporal/api/operatorservice/v1/service.proto"); + let proto_def = include_str!( + "../../sdk-core-protos/protos/api_upstream/temporal/api/operatorservice/v1/service.proto" + ); verify_methods(proto_def, ALL_IMPLEMENTED_OPERATOR_SERVICE_RPCS); } #[test] fn verify_all_cloud_service_methods_implemented() { - let proto_def = - include_str!("../../sdk-core-protos/protos/api_cloud_upstream/temporal/api/cloud/cloudservice/v1/service.proto"); + let proto_def = include_str!( + "../../sdk-core-protos/protos/api_cloud_upstream/temporal/api/cloud/cloudservice/v1/service.proto" + ); verify_methods(proto_def, ALL_IMPLEMENTED_CLOUD_SERVICE_RPCS); } #[test] fn verify_all_test_service_methods_implemented() { - let proto_def = - include_str!("../../sdk-core-protos/protos/testsrv_upstream/temporal/api/testservice/v1/service.proto"); + let proto_def = include_str!( + "../../sdk-core-protos/protos/testsrv_upstream/temporal/api/testservice/v1/service.proto" + ); verify_methods(proto_def, ALL_IMPLEMENTED_TEST_SERVICE_RPCS); } diff --git a/client/src/retry.rs b/client/src/retry.rs index 5bdd81ea0..5cc3444f2 100644 --- a/client/src/retry.rs +++ b/client/src/retry.rs @@ -1,7 +1,7 @@ use crate::{ - raw::IsUserLongPoll, Client, IsWorkerTaskLongPoll, NamespacedClient, Result, RetryConfig, + Client, IsWorkerTaskLongPoll, NamespacedClient, Result, RetryConfig, raw::IsUserLongPoll, }; -use backoff::{backoff::Backoff, exponential::ExponentialBackoff, Clock, SystemClock}; +use backoff::{Clock, SystemClock, backoff::Backoff, exponential::ExponentialBackoff}; use futures_retry::{ErrorHandler, FutureRetry, RetryPolicy}; use std::{error::Error, fmt::Debug, future::Future, sync::Arc, time::Duration}; use tonic::{Code, Request}; diff --git a/client/src/worker_registry/mod.rs b/client/src/worker_registry/mod.rs index 647da0345..1d4c5ddea 100644 --- a/client/src/worker_registry/mod.rs +++ b/client/src/worker_registry/mod.rs @@ -4,7 +4,7 @@ use parking_lot::RwLock; use slotmap::SlotMap; -use std::collections::{hash_map::Entry::Vacant, HashMap}; +use std::collections::{HashMap, hash_map::Entry::Vacant}; use temporal_sdk_core_protos::temporal::api::workflowservice::v1::PollWorkflowTaskQueueResponse; diff --git a/core-api/Cargo.toml b/core-api/Cargo.toml index 63e903f7f..4a7bd6d67 100644 --- a/core-api/Cargo.toml +++ b/core-api/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "temporal-sdk-core-api" version = "0.1.0" -edition = "2021" +edition = "2024" authors = ["Spencer Judge "] license-file = { workspace = true } description = "Interface definitions for the Temporal Core SDK" @@ -21,7 +21,6 @@ derive_builder = { workspace = true } derive_more = { workspace = true } opentelemetry = { workspace = true, optional = true } prost = { workspace = true } -prost-types = { workspace = true } serde_json = "1.0" thiserror = { workspace = true } tonic = { workspace = true } diff --git a/core-api/src/lib.rs b/core-api/src/lib.rs index c66418d7f..2e2e6c1f0 100644 --- a/core-api/src/lib.rs +++ b/core-api/src/lib.rs @@ -10,11 +10,11 @@ use crate::{ worker::WorkerConfig, }; use temporal_sdk_core_protos::coresdk::{ + ActivityHeartbeat, ActivityTaskCompletion, activity_task::ActivityTask, nexus::{NexusTask, NexusTaskCompletion}, workflow_activation::WorkflowActivation, workflow_completion::WorkflowActivationCompletion, - ActivityHeartbeat, ActivityTaskCompletion, }; /// This trait is the primary way by which language specific SDKs interact with the core SDK. diff --git a/core-api/src/telemetry/metrics.rs b/core-api/src/telemetry/metrics.rs index 5a8de90e9..47858982e 100644 --- a/core-api/src/telemetry/metrics.rs +++ b/core-api/src/telemetry/metrics.rs @@ -345,7 +345,7 @@ impl CustomMetricAttributes for NoOpAttributes { #[cfg(feature = "otel_impls")] mod otel_impls { use super::*; - use opentelemetry::{metrics, KeyValue}; + use opentelemetry::{KeyValue, metrics}; impl From for KeyValue { fn from(kv: MetricKeyValue) -> Self { diff --git a/core/Cargo.toml b/core/Cargo.toml index d77fc9bce..0a5f0cc3f 100644 --- a/core/Cargo.toml +++ b/core/Cargo.toml @@ -2,7 +2,7 @@ name = "temporal-sdk-core" version = "0.1.0" authors = ["Spencer Judge ", "Vitaly Arbuzov "] -edition = "2021" +edition = "2024" license-file = { workspace = true } description = "Library for building new Temporal SDKs" homepage = "https://temporal.io/" @@ -35,12 +35,12 @@ enum-iterator = "2" flate2 = { version = "1.0", optional = true } futures-util = { version = "0.3", default-features = false } futures-channel = { version = "0.3", default-features = false, features = ["std"] } -governor = "0.7" +governor = "0.8" http-body-util = { version = "0.1", optional = true } hyper = { version = "1.2", optional = true } hyper-util = { version = "0.1", features = ["server", "http1", "http2", "tokio"], optional = true } -itertools = "0.13" -lru = "0.12" +itertools = "0.14" +lru = "0.13" mockall = "0.13" opentelemetry = { workspace = true, features = ["metrics"], optional = true } opentelemetry_sdk = { version = "0.26", features = ["rt-tokio", "metrics"], optional = true } @@ -52,14 +52,14 @@ pin-project = "1.0" prometheus = "0.13" prost = { workspace = true } prost-types = { version = "0.6", package = "prost-wkt-types" } -rand = "0.8.3" +rand = "0.9" reqwest = { version = "0.12", features = ["json", "stream", "rustls-tls-native-roots"], default-features = false, optional = true } ringbuf = "0.4" serde = "1.0" serde_json = "1.0" siphasher = "1.0" slotmap = "1.0" -sysinfo = { version = "0.32", default-features = false, features = ["system"] } +sysinfo = { version = "0.33", default-features = false, features = ["system"] } tar = { version = "0.4", optional = true } thiserror = { workspace = true } tokio = { version = "1.37", features = ["rt", "rt-multi-thread", "parking_lot", "time", "fs", "process"] } diff --git a/core/benches/workflow_replay.rs b/core/benches/workflow_replay.rs index 8c46fad8b..244d73e17 100644 --- a/core/benches/workflow_replay.rs +++ b/core/benches/workflow_replay.rs @@ -1,4 +1,4 @@ -use criterion::{criterion_group, criterion_main, Criterion}; +use criterion::{Criterion, criterion_group, criterion_main}; use futures_util::StreamExt; use std::time::Duration; use temporal_sdk::{WfContext, WorkflowFunction}; diff --git a/core/src/abstractions.rs b/core/src/abstractions.rs index 58e15c5af..176024b06 100644 --- a/core/src/abstractions.rs +++ b/core/src/abstractions.rs @@ -6,8 +6,8 @@ use crate::MetricsContext; use std::{ fmt::{Debug, Formatter}, sync::{ - atomic::{AtomicBool, AtomicUsize, Ordering}, Arc, + atomic::{AtomicBool, AtomicUsize, Ordering}, }, }; use temporal_sdk_core_api::worker::{ diff --git a/core/src/core_tests/activity_tasks.rs b/core/src/core_tests/activity_tasks.rs index cd48bf590..8d1a79f10 100644 --- a/core/src/core_tests/activity_tasks.rs +++ b/core/src/core_tests/activity_tasks.rs @@ -1,53 +1,53 @@ use crate::{ - advance_fut, job_assert, prost_dur, + ActivityHeartbeat, Worker, advance_fut, job_assert, prost_dur, test_help::{ - build_fake_worker, build_mock_pollers, canned_histories, gen_assert_and_reply, - mock_manual_poller, mock_poller, mock_poller_from_resps, mock_sdk_cfg, mock_worker, - poll_and_reply, single_hist_mock_sg, test_worker_cfg, MockPollCfg, MockWorkerInputs, - MocksHolder, QueueResponse, ResponseType, WorkerExt, WorkflowCachingPolicy, TEST_Q, + MockPollCfg, MockWorkerInputs, MocksHolder, QueueResponse, ResponseType, TEST_Q, WorkerExt, + WorkflowCachingPolicy, build_fake_worker, build_mock_pollers, canned_histories, + gen_assert_and_reply, mock_manual_poller, mock_poller, mock_poller_from_resps, + mock_sdk_cfg, mock_worker, poll_and_reply, single_hist_mock_sg, test_worker_cfg, }, worker::client::mocks::{mock_manual_workflow_client, mock_workflow_client}, - ActivityHeartbeat, Worker, }; use futures_util::FutureExt; use itertools::Itertools; use std::{ cell::RefCell, - collections::{hash_map::Entry, HashMap, HashSet, VecDeque}, + collections::{HashMap, HashSet, VecDeque, hash_map::Entry}, future, rc::Rc, sync::{ - atomic::{AtomicBool, AtomicUsize, Ordering}, Arc, + atomic::{AtomicBool, AtomicUsize, Ordering}, }, time::Duration, }; use temporal_client::WorkflowOptions; use temporal_sdk::{ActivityOptions, WfContext}; use temporal_sdk_core_api::{ - errors::{CompleteActivityError, PollError}, Worker as WorkerTrait, + errors::{CompleteActivityError, PollError}, }; use temporal_sdk_core_protos::{ + DEFAULT_ACTIVITY_TYPE, DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder, coresdk::{ + ActivityTaskCompletion, activity_result::{ - activity_execution_result, activity_resolution, ActivityExecutionResult, - ActivityResolution, Success, + ActivityExecutionResult, ActivityResolution, Success, activity_execution_result, + activity_resolution, }, - activity_task::{activity_task, ActivityCancelReason, ActivityTask, Cancel}, - workflow_activation::{workflow_activation_job, ResolveActivity, WorkflowActivationJob}, + activity_task::{ActivityCancelReason, ActivityTask, Cancel, activity_task}, + workflow_activation::{ResolveActivity, WorkflowActivationJob, workflow_activation_job}, workflow_commands::{ ActivityCancellationType, CompleteWorkflowExecution, RequestCancelActivity, ScheduleActivity, }, workflow_completion::WorkflowActivationCompletion, - ActivityTaskCompletion, }, temporal::api::{ - command::v1::{command::Attributes, ScheduleActivityTaskCommandAttributes}, + command::v1::{ScheduleActivityTaskCommandAttributes, command::Attributes}, enums::v1::{CommandType, EventType}, history::v1::{ - history_event::Attributes as EventAttributes, ActivityTaskScheduledEventAttributes, + ActivityTaskScheduledEventAttributes, history_event::Attributes as EventAttributes, }, sdk::v1::UserMetadata, workflowservice::v1::{ @@ -56,9 +56,8 @@ use temporal_sdk_core_protos::{ RespondActivityTaskFailedResponse, RespondWorkflowTaskCompletedResponse, }, }, - TestHistoryBuilder, DEFAULT_ACTIVITY_TYPE, DEFAULT_WORKFLOW_TYPE, }; -use temporal_sdk_core_test_utils::{fanout_tasks, start_timer_cmd, TestWorker}; +use temporal_sdk_core_test_utils::{TestWorker, fanout_tasks, start_timer_cmd}; use tokio::{join, sync::Barrier, time::sleep}; use tokio_util::sync::CancellationToken; @@ -468,13 +467,15 @@ async fn activity_timeout_no_double_resolve() { &[ gen_assert_and_reply( &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)), - vec![ScheduleActivity { - seq: activity_id, - activity_id: activity_id.to_string(), - cancellation_type: ActivityCancellationType::TryCancel as i32, - ..Default::default() - } - .into()], + vec![ + ScheduleActivity { + seq: activity_id, + activity_id: activity_id.to_string(), + cancellation_type: ActivityCancellationType::TryCancel as i32, + ..Default::default() + } + .into(), + ], ), gen_assert_and_reply( &job_assert!(workflow_activation_job::Variant::SignalWorkflow(_)), @@ -689,14 +690,16 @@ async fn no_eager_activities_requested_when_worker_options_disable_it( // Test start let wf_task = core.poll_workflow_activation().await.unwrap(); - let cmds = vec![ScheduleActivity { - seq: 1, - activity_id: "act_id".to_string(), - task_queue: TEST_Q.to_string(), - cancellation_type: ActivityCancellationType::TryCancel as i32, - ..Default::default() - } - .into()]; + let cmds = vec![ + ScheduleActivity { + seq: 1, + activity_id: "act_id".to_string(), + task_queue: TEST_Q.to_string(), + cancellation_type: ActivityCancellationType::TryCancel as i32, + ..Default::default() + } + .into(), + ]; core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds( wf_task.run_id, diff --git a/core/src/core_tests/child_workflows.rs b/core/src/core_tests/child_workflows.rs index 947cb4bf1..c1bf6a923 100644 --- a/core/src/core_tests/child_workflows.rs +++ b/core/src/core_tests/child_workflows.rs @@ -1,8 +1,8 @@ use crate::{ replay::DEFAULT_WORKFLOW_TYPE, test_help::{ - build_fake_sdk, canned_histories, mock_sdk, mock_sdk_cfg, mock_worker, single_hist_mock_sg, - MockPollCfg, ResponseType, + MockPollCfg, ResponseType, build_fake_sdk, canned_histories, mock_sdk, mock_sdk_cfg, + mock_worker, single_hist_mock_sg, }, worker::client::mocks::mock_workflow_client, }; @@ -11,8 +11,8 @@ use temporal_sdk::{ChildWorkflowOptions, Signal, WfContext, WorkflowResult}; use temporal_sdk_core_api::Worker; use temporal_sdk_core_protos::{ coresdk::{ - child_workflow::{child_workflow_result, ChildWorkflowCancellationType}, - workflow_activation::{workflow_activation_job, WorkflowActivationJob}, + child_workflow::{ChildWorkflowCancellationType, child_workflow_result}, + workflow_activation::{WorkflowActivationJob, workflow_activation_job}, workflow_commands::{ CancelChildWorkflowExecution, CompleteWorkflowExecution, StartChildWorkflowExecution, }, diff --git a/core/src/core_tests/determinism.rs b/core/src/core_tests/determinism.rs index d7b2f3a94..3e552e0bc 100644 --- a/core/src/core_tests/determinism.rs +++ b/core/src/core_tests/determinism.rs @@ -1,7 +1,7 @@ use crate::{ internal_flags::CoreInternalFlags, replay::DEFAULT_WORKFLOW_TYPE, - test_help::{canned_histories, mock_sdk, mock_sdk_cfg, MockPollCfg, ResponseType}, + test_help::{MockPollCfg, ResponseType, canned_histories, mock_sdk, mock_sdk_cfg}, worker::client::mocks::mock_workflow_client, }; use std::{ @@ -13,11 +13,11 @@ use temporal_sdk::{ ActivityOptions, ChildWorkflowOptions, LocalActivityOptions, WfContext, WorkflowResult, }; use temporal_sdk_core_protos::{ + DEFAULT_ACTIVITY_TYPE, TestHistoryBuilder, temporal::api::{ enums::v1::{EventType, WorkflowTaskFailedCause}, failure::v1::Failure, }, - TestHistoryBuilder, DEFAULT_ACTIVITY_TYPE, }; static DID_FAIL: AtomicBool = AtomicBool::new(false); diff --git a/core/src/core_tests/local_activities.rs b/core/src/core_tests/local_activities.rs index b16eddd63..327eb81bd 100644 --- a/core/src/core_tests/local_activities.rs +++ b/core/src/core_tests/local_activities.rs @@ -1,21 +1,21 @@ use crate::{ prost_dur, - replay::{default_wes_attribs, TestHistoryBuilder, DEFAULT_WORKFLOW_TYPE}, + replay::{DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder, default_wes_attribs}, test_help::{ - build_mock_pollers, hist_to_poll_resp, mock_sdk, mock_sdk_cfg, mock_worker, - single_hist_mock_sg, MockPollCfg, ResponseType, WorkerExt, + MockPollCfg, ResponseType, WorkerExt, build_mock_pollers, hist_to_poll_resp, mock_sdk, + mock_sdk_cfg, mock_worker, single_hist_mock_sg, }, - worker::{client::mocks::mock_workflow_client, LEGACY_QUERY_ID}, + worker::{LEGACY_QUERY_ID, client::mocks::mock_workflow_client}, }; use anyhow::anyhow; use crossbeam_queue::SegQueue; -use futures_util::{future::join_all, FutureExt}; +use futures_util::{FutureExt, future::join_all}; use std::{ collections::HashMap, ops::Sub, sync::{ - atomic::{AtomicUsize, Ordering}, Arc, + atomic::{AtomicUsize, Ordering}, }, time::{Duration, Instant, SystemTime}, }; @@ -23,25 +23,25 @@ use temporal_client::WorkflowOptions; use temporal_sdk::{ ActContext, ActivityError, LocalActivityOptions, WfContext, WorkflowFunction, WorkflowResult, }; -use temporal_sdk_core_api::{errors::PollError, Worker}; +use temporal_sdk_core_api::{Worker, errors::PollError}; use temporal_sdk_core_protos::{ + DEFAULT_ACTIVITY_TYPE, coresdk::{ + ActivityTaskCompletion, AsJsonPayloadExt, activity_result::ActivityExecutionResult, - workflow_activation::{workflow_activation_job, WorkflowActivationJob}, + workflow_activation::{WorkflowActivationJob, workflow_activation_job}, workflow_commands::{ActivityCancellationType, ScheduleLocalActivity}, workflow_completion::WorkflowActivationCompletion, - ActivityTaskCompletion, AsJsonPayloadExt, }, temporal::api::{ common::v1::RetryPolicy, enums::v1::{CommandType, EventType, TimeoutType, WorkflowTaskFailedCause}, - failure::v1::{failure::FailureInfo, Failure}, + failure::v1::{Failure, failure::FailureInfo}, query::v1::WorkflowQuery, }, - DEFAULT_ACTIVITY_TYPE, }; use temporal_sdk_core_test_utils::{ - query_ok, schedule_local_activity_cmd, start_timer_cmd, WorkerTestHelpers, + WorkerTestHelpers, query_ok, schedule_local_activity_cmd, start_timer_cmd, }; use tokio::{join, select, sync::Barrier}; diff --git a/core/src/core_tests/mod.rs b/core/src/core_tests/mod.rs index 3ea41bec2..d1f9dc5f3 100644 --- a/core/src/core_tests/mod.rs +++ b/core/src/core_tests/mod.rs @@ -10,10 +10,10 @@ mod workflow_cancels; mod workflow_tasks; use crate::{ + Worker, errors::PollError, - test_help::{build_mock_pollers, canned_histories, mock_worker, test_worker_cfg, MockPollCfg}, + test_help::{MockPollCfg, build_mock_pollers, canned_histories, mock_worker, test_worker_cfg}, worker::client::mocks::{mock_manual_workflow_client, mock_workflow_client}, - Worker, }; use futures_util::FutureExt; use std::{sync::LazyLock, time::Duration}; diff --git a/core/src/core_tests/queries.rs b/core/src/core_tests/queries.rs index d9ee8096c..2bcfc761e 100644 --- a/core/src/core_tests/queries.rs +++ b/core/src/core_tests/queries.rs @@ -1,9 +1,9 @@ use crate::{ test_help::{ - build_mock_pollers, canned_histories, hist_to_poll_resp, mock_worker, single_hist_mock_sg, - MockPollCfg, MocksHolder, ResponseType, WorkerExt, + MockPollCfg, MocksHolder, ResponseType, WorkerExt, build_mock_pollers, canned_histories, + hist_to_poll_resp, mock_worker, single_hist_mock_sg, }, - worker::{client::mocks::mock_workflow_client, LEGACY_QUERY_ID}, + worker::{LEGACY_QUERY_ID, client::mocks::mock_workflow_client}, }; use futures_util::stream; use std::{ @@ -12,13 +12,14 @@ use std::{ }; use temporal_sdk_core_api::Worker as WorkerTrait; use temporal_sdk_core_protos::{ + TestHistoryBuilder, coresdk::{ workflow_activation::{ - remove_from_cache::EvictionReason, workflow_activation_job, WorkflowActivationJob, + WorkflowActivationJob, remove_from_cache::EvictionReason, workflow_activation_job, }, workflow_commands::{ - query_result, ActivityCancellationType, CompleteWorkflowExecution, - ContinueAsNewWorkflowExecution, QueryResult, RequestCancelActivity, + ActivityCancellationType, CompleteWorkflowExecution, ContinueAsNewWorkflowExecution, + QueryResult, RequestCancelActivity, query_result, }, workflow_completion::WorkflowActivationCompletion, }, @@ -26,16 +27,15 @@ use temporal_sdk_core_protos::{ common::v1::Payload, enums::v1::{CommandType, EventType}, failure::v1::Failure, - history::v1::{history_event, ActivityTaskCancelRequestedEventAttributes, History}, + history::v1::{ActivityTaskCancelRequestedEventAttributes, History, history_event}, query::v1::WorkflowQuery, workflowservice::v1::{ GetWorkflowExecutionHistoryResponse, RespondWorkflowTaskCompletedResponse, }, }, - TestHistoryBuilder, }; use temporal_sdk_core_test_utils::{ - query_ok, schedule_activity_cmd, start_timer_cmd, WorkerTestHelpers, + WorkerTestHelpers, query_ok, schedule_activity_cmd, start_timer_cmd, }; #[rstest::rstest] @@ -826,7 +826,7 @@ async fn legacy_query_combined_with_timer_fire_repro() { assert_matches!( task.jobs.as_slice(), [WorkflowActivationJob { - variant: Some(workflow_activation_job::Variant::QueryWorkflow(ref q)), + variant: Some(workflow_activation_job::Variant::QueryWorkflow(q)), }] if q.query_id == "the-query" ); @@ -844,7 +844,7 @@ async fn legacy_query_combined_with_timer_fire_repro() { assert_matches!( task.jobs.as_slice(), [WorkflowActivationJob { - variant: Some(workflow_activation_job::Variant::QueryWorkflow(ref q)), + variant: Some(workflow_activation_job::Variant::QueryWorkflow(q)), }] if q.query_id == LEGACY_QUERY_ID ); diff --git a/core/src/core_tests/replay_flag.rs b/core/src/core_tests/replay_flag.rs index b31d1537f..db4599f32 100644 --- a/core/src/core_tests/replay_flag.rs +++ b/core/src/core_tests/replay_flag.rs @@ -1,21 +1,21 @@ use crate::{ test_help::{ - build_fake_sdk, build_mock_pollers, canned_histories, hist_to_poll_resp, mock_worker, - MockPollCfg, ResponseType, + MockPollCfg, ResponseType, build_fake_sdk, build_mock_pollers, canned_histories, + hist_to_poll_resp, mock_worker, }, - worker::{client::mocks::mock_workflow_client, LEGACY_QUERY_ID}, + worker::{LEGACY_QUERY_ID, client::mocks::mock_workflow_client}, }; use rstest::{fixture, rstest}; use std::{collections::VecDeque, time::Duration}; use temporal_sdk::{WfContext, Worker, WorkflowFunction}; use temporal_sdk_core_api::Worker as CoreWorker; use temporal_sdk_core_protos::{ + DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder, coresdk::{ - workflow_activation::{workflow_activation_job, WorkflowActivationJob}, + workflow_activation::{WorkflowActivationJob, workflow_activation_job}, workflow_completion::WorkflowActivationCompletion, }, temporal::api::{enums::v1::EventType, query::v1::WorkflowQuery}, - TestHistoryBuilder, DEFAULT_WORKFLOW_TYPE, }; use temporal_sdk_core_test_utils::{ interceptors::ActivationAssertionsInterceptor, query_ok, start_timer_cmd, diff --git a/core/src/core_tests/updates.rs b/core/src/core_tests/updates.rs index 2c565525b..854d85d4a 100644 --- a/core/src/core_tests/updates.rs +++ b/core/src/core_tests/updates.rs @@ -1,18 +1,19 @@ use crate::{ prost_dur, test_help::{ - build_mock_pollers, hist_to_poll_resp, mock_worker, MockPollCfg, PollWFTRespExt, - ResponseType, + MockPollCfg, PollWFTRespExt, ResponseType, build_mock_pollers, hist_to_poll_resp, + mock_worker, }, worker::client::mocks::mock_workflow_client, }; use temporal_sdk_core_api::Worker; use temporal_sdk_core_protos::{ + DEFAULT_ACTIVITY_TYPE, TestHistoryBuilder, coresdk::{ - workflow_activation::{workflow_activation_job, WorkflowActivationJob}, + workflow_activation::{WorkflowActivationJob, workflow_activation_job}, workflow_commands::{ - update_response::Response, CompleteWorkflowExecution, ScheduleActivity, StartTimer, - UpdateResponse, + CompleteWorkflowExecution, ScheduleActivity, StartTimer, UpdateResponse, + update_response::Response, }, workflow_completion::WorkflowActivationCompletion, }, @@ -22,7 +23,6 @@ use temporal_sdk_core_protos::{ update::v1::{Acceptance, Rejection}, workflowservice::v1::RespondWorkflowTaskCompletedResponse, }, - TestHistoryBuilder, DEFAULT_ACTIVITY_TYPE, }; use temporal_sdk_core_test_utils::WorkerTestHelpers; diff --git a/core/src/core_tests/workers.rs b/core/src/core_tests/workers.rs index 9076b80f1..bc80bf68a 100644 --- a/core/src/core_tests/workers.rs +++ b/core/src/core_tests/workers.rs @@ -1,17 +1,16 @@ use crate::{ - prost_dur, + PollError, prost_dur, test_help::{ - build_fake_worker, build_mock_pollers, canned_histories, mock_worker, test_worker_cfg, - MockPollCfg, MockWorkerInputs, MocksHolder, ResponseType, WorkerExt, + MockPollCfg, MockWorkerInputs, MocksHolder, ResponseType, WorkerExt, build_fake_worker, + build_mock_pollers, canned_histories, mock_worker, test_worker_cfg, }, worker::{ self, client::{ - mocks::{mock_workflow_client, DEFAULT_TEST_CAPABILITIES, DEFAULT_WORKERS_REGISTRY}, MockWorkerClient, + mocks::{DEFAULT_TEST_CAPABILITIES, DEFAULT_WORKERS_REGISTRY, mock_workflow_client}, }, }, - PollError, }; use futures_util::{stream, stream::StreamExt}; use std::{cell::RefCell, time::Duration}; @@ -19,15 +18,15 @@ use temporal_sdk_core_api::Worker; use temporal_sdk_core_protos::{ coresdk::{ workflow_activation::workflow_activation_job, - workflow_commands::{workflow_command, CompleteWorkflowExecution, StartTimer}, + workflow_commands::{CompleteWorkflowExecution, StartTimer, workflow_command}, workflow_completion::WorkflowActivationCompletion, }, temporal::api::workflowservice::v1::{ PollWorkflowTaskQueueResponse, RespondWorkflowTaskCompletedResponse, ShutdownWorkerResponse, }, }; -use temporal_sdk_core_test_utils::{start_timer_cmd, WorkerTestHelpers}; -use tokio::sync::{watch, Barrier}; +use temporal_sdk_core_test_utils::{WorkerTestHelpers, start_timer_cmd}; +use tokio::sync::{Barrier, watch}; #[tokio::test] async fn after_shutdown_of_worker_get_shutdown_err() { diff --git a/core/src/core_tests/workflow_cancels.rs b/core/src/core_tests/workflow_cancels.rs index b88e28498..3b7d09b03 100644 --- a/core/src/core_tests/workflow_cancels.rs +++ b/core/src/core_tests/workflow_cancels.rs @@ -1,14 +1,14 @@ use crate::{ job_assert, test_help::{ - build_fake_worker, canned_histories, gen_assert_and_reply, poll_and_reply, ResponseType, - WorkflowCachingPolicy::NonSticky, + ResponseType, WorkflowCachingPolicy::NonSticky, build_fake_worker, canned_histories, + gen_assert_and_reply, poll_and_reply, }, }; use rstest::rstest; use std::time::Duration; use temporal_sdk_core_protos::coresdk::{ - workflow_activation::{workflow_activation_job, WorkflowActivationJob}, + workflow_activation::{WorkflowActivationJob, workflow_activation_job}, workflow_commands::{ CancelWorkflowExecution, CompleteWorkflowExecution, FailWorkflowExecution, }, diff --git a/core/src/core_tests/workflow_tasks.rs b/core/src/core_tests/workflow_tasks.rs index 42fa25b4f..9a9f8b5b4 100644 --- a/core/src/core_tests/workflow_tasks.rs +++ b/core/src/core_tests/workflow_tasks.rs @@ -1,56 +1,57 @@ use crate::{ - advance_fut, + Worker, advance_fut, internal_flags::CoreInternalFlags, job_assert, replay::TestHistoryBuilder, test_help::{ + FakeWfResponses, MockPollCfg, MocksHolder, ResponseType, WorkerExt, + WorkflowCachingPolicy::{self, AfterEveryReply, NonSticky}, build_fake_worker, build_mock_pollers, build_multihist_mock_sg, canned_histories, gen_assert_and_fail, gen_assert_and_reply, hist_to_poll_resp, mock_sdk, mock_sdk_cfg, mock_worker, poll_and_reply, poll_and_reply_clears_outstanding_evicts, single_hist_mock_sg, - test_worker_cfg, FakeWfResponses, MockPollCfg, MocksHolder, ResponseType, WorkerExt, - WorkflowCachingPolicy::{self, AfterEveryReply, NonSticky}, + test_worker_cfg, }, worker::{ - client::mocks::{mock_manual_workflow_client, mock_workflow_client}, TunerBuilder, + client::mocks::{mock_manual_workflow_client, mock_workflow_client}, }, - Worker, }; -use futures_util::{stream, FutureExt}; +use futures_util::{FutureExt, stream}; use mockall::TimesRange; use rstest::{fixture, rstest}; use std::{ collections::{HashMap, HashSet, VecDeque}, sync::{ + Arc, atomic::{AtomicU64, AtomicUsize, Ordering}, mpsc::sync_channel, - Arc, }, time::Duration, }; use temporal_client::WorkflowOptions; use temporal_sdk::{ActivityOptions, CancellableFuture, TimerOptions, WfContext}; use temporal_sdk_core_api::{ + Worker as WorkerTrait, errors::PollError, worker::{ SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext, SlotSupplier, SlotSupplierPermit, WorkflowSlotKind, }, - Worker as WorkerTrait, }; use temporal_sdk_core_protos::{ + DEFAULT_ACTIVITY_TYPE, DEFAULT_WORKFLOW_TYPE, coresdk::{ - activity_result::{self as ar, activity_resolution, ActivityResolution}, + activity_result::{self as ar, ActivityResolution, activity_resolution}, common::VersioningIntent, workflow_activation::{ - remove_from_cache::EvictionReason, workflow_activation_job, FireTimer, - InitializeWorkflow, ResolveActivity, UpdateRandomSeed, WorkflowActivationJob, + FireTimer, InitializeWorkflow, ResolveActivity, UpdateRandomSeed, + WorkflowActivationJob, remove_from_cache::EvictionReason, workflow_activation_job, }, workflow_commands::{ - update_response::Response, workflow_command, ActivityCancellationType, CancelTimer, - CompleteWorkflowExecution, ContinueAsNewWorkflowExecution, FailWorkflowExecution, - RequestCancelActivity, ScheduleActivity, SetPatchMarker, StartChildWorkflowExecution, - UpdateResponse, + ActivityCancellationType, CancelTimer, CompleteWorkflowExecution, + ContinueAsNewWorkflowExecution, FailWorkflowExecution, RequestCancelActivity, + ScheduleActivity, SetPatchMarker, StartChildWorkflowExecution, UpdateResponse, + update_response::Response, workflow_command, }, workflow_completion::WorkflowActivationCompletion, }, @@ -61,17 +62,16 @@ use temporal_sdk_core_protos::{ enums::v1::{CommandType, EventType, WorkflowTaskFailedCause}, failure::v1::Failure, history::v1::{ - history_event, TimerFiredEventAttributes, - WorkflowPropertiesModifiedExternallyEventAttributes, + TimerFiredEventAttributes, WorkflowPropertiesModifiedExternallyEventAttributes, + history_event, }, sdk::v1::UserMetadata, workflowservice::v1::{ GetWorkflowExecutionHistoryResponse, RespondWorkflowTaskCompletedResponse, }, }, - DEFAULT_ACTIVITY_TYPE, DEFAULT_WORKFLOW_TYPE, }; -use temporal_sdk_core_test_utils::{fanout_tasks, start_timer_cmd, WorkerTestHelpers}; +use temporal_sdk_core_test_utils::{WorkerTestHelpers, fanout_tasks, start_timer_cmd}; use tokio::{ join, sync::{Barrier, Semaphore}, @@ -140,11 +140,13 @@ async fn single_activity_completion(worker: Worker) { &[ gen_assert_and_reply( &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)), - vec![ScheduleActivity { - activity_id: "fake_activity".to_string(), - ..default_act_sched() - } - .into()], + vec![ + ScheduleActivity { + activity_id: "fake_activity".to_string(), + ..default_act_sched() + } + .into(), + ], ), gen_assert_and_reply( &job_assert!(workflow_activation_job::Variant::ResolveActivity(_)), @@ -263,13 +265,15 @@ async fn scheduled_activity_cancellation_try_cancel(hist_batches: &'static [usiz &[ gen_assert_and_reply( &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)), - vec![ScheduleActivity { - seq: activity_seq, - activity_id: activity_id.to_string(), - cancellation_type: ActivityCancellationType::TryCancel as i32, - ..default_act_sched() - } - .into()], + vec![ + ScheduleActivity { + seq: activity_seq, + activity_id: activity_id.to_string(), + cancellation_type: ActivityCancellationType::TryCancel as i32, + ..default_act_sched() + } + .into(), + ], ), gen_assert_and_reply( &job_assert!(workflow_activation_job::Variant::SignalWorkflow(_)), @@ -408,12 +412,14 @@ async fn cancelled_activity_timeout(hist_batches: &'static [usize]) { &[ gen_assert_and_reply( &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)), - vec![ScheduleActivity { - seq: activity_seq, - activity_id: activity_id.to_string(), - ..default_act_sched() - } - .into()], + vec![ + ScheduleActivity { + seq: activity_seq, + activity_id: activity_id.to_string(), + ..default_act_sched() + } + .into(), + ], ), gen_assert_and_reply( &job_assert!(workflow_activation_job::Variant::SignalWorkflow(_)), @@ -560,13 +566,15 @@ async fn verify_activity_cancellation( &[ gen_assert_and_reply( &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)), - vec![ScheduleActivity { - seq: activity_seq, - activity_id: activity_seq.to_string(), - cancellation_type: cancel_type as i32, - ..default_act_sched() - } - .into()], + vec![ + ScheduleActivity { + seq: activity_seq, + activity_id: activity_seq.to_string(), + cancellation_type: cancel_type as i32, + ..default_act_sched() + } + .into(), + ], ), gen_assert_and_reply( &job_assert!(workflow_activation_job::Variant::SignalWorkflow(_)), @@ -628,13 +636,16 @@ async fn verify_activity_cancellation_wait_for_cancellation(activity_id: u32, wo &[ gen_assert_and_reply( &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)), - vec![ScheduleActivity { - seq: activity_id, - activity_id: activity_id.to_string(), - cancellation_type: ActivityCancellationType::WaitCancellationCompleted as i32, - ..default_act_sched() - } - .into()], + vec![ + ScheduleActivity { + seq: activity_id, + activity_id: activity_id.to_string(), + cancellation_type: ActivityCancellationType::WaitCancellationCompleted + as i32, + ..default_act_sched() + } + .into(), + ], ), gen_assert_and_reply( &job_assert!(workflow_activation_job::Variant::SignalWorkflow(_)), @@ -811,13 +822,15 @@ async fn simple_timer_fail_wf_execution(hist_batches: &'static [usize]) { ), gen_assert_and_reply( &job_assert!(workflow_activation_job::Variant::FireTimer(_)), - vec![FailWorkflowExecution { - failure: Some(Failure { - message: "I'm ded".to_string(), - ..Default::default() - }), - } - .into()], + vec![ + FailWorkflowExecution { + failure: Some(Failure { + message: "I'm ded".to_string(), + ..Default::default() + }), + } + .into(), + ], ), ], ) @@ -1008,13 +1021,15 @@ async fn activity_not_canceled_when_also_completed_repro(hist_batches: &'static &[ gen_assert_and_reply( &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)), - vec![ScheduleActivity { - seq: activity_id, - activity_id: "act-1".to_string(), - cancellation_type: ActivityCancellationType::TryCancel as i32, - ..default_act_sched() - } - .into()], + vec![ + ScheduleActivity { + seq: activity_id, + activity_id: "act-1".to_string(), + cancellation_type: ActivityCancellationType::TryCancel as i32, + ..default_act_sched() + } + .into(), + ], ), gen_assert_and_reply( &job_assert!(workflow_activation_job::Variant::SignalWorkflow(_)), @@ -1109,13 +1124,15 @@ async fn wft_timeout_repro(hist_batches: &'static [usize]) { &[ gen_assert_and_reply( &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)), - vec![ScheduleActivity { - seq: activity_id, - activity_id: activity_id.to_string(), - cancellation_type: ActivityCancellationType::TryCancel as i32, - ..default_act_sched() - } - .into()], + vec![ + ScheduleActivity { + seq: activity_id, + activity_id: activity_id.to_string(), + cancellation_type: ActivityCancellationType::TryCancel as i32, + ..default_act_sched() + } + .into(), + ], ), gen_assert_and_reply( &job_assert!( @@ -1321,11 +1338,13 @@ async fn fail_wft_then_recover() { // Start an activity instead of a timer, triggering nondeterminism error core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds( act.run_id.clone(), - vec![ScheduleActivity { - activity_id: "fake_activity".to_string(), - ..default_act_sched() - } - .into()], + vec![ + ScheduleActivity { + activity_id: "fake_activity".to_string(), + ..default_act_sched() + } + .into(), + ], )) .await .unwrap(); diff --git a/core/src/ephemeral_server/mod.rs b/core/src/ephemeral_server/mod.rs index fdf4de376..29526aba9 100644 --- a/core/src/ephemeral_server/mod.rs +++ b/core/src/ephemeral_server/mod.rs @@ -13,7 +13,7 @@ use std::{ use temporal_client::ClientOptionsBuilder; use tokio::{ task::spawn_blocking, - time::{sleep, Duration}, + time::{Duration, sleep}, }; use tokio_util::io::{StreamReader, SyncIoBridge}; use url::Url; diff --git a/core/src/lib.rs b/core/src/lib.rs index c9e055938..404b47ab4 100644 --- a/core/src/lib.rs +++ b/core/src/lib.rs @@ -50,8 +50,8 @@ pub use worker::{ use crate::{ replay::{HistoryForReplay, ReplayWorkerInput}, telemetry::{ - metrics::MetricsContext, remove_trace_subscriber_for_current_thread, - set_trace_subscriber_for_current_thread, telemetry_init, TelemetryInstance, + TelemetryInstance, metrics::MetricsContext, remove_trace_subscriber_for_current_thread, + set_trace_subscriber_for_current_thread, telemetry_init, }, worker::client::WorkerClientBag, }; @@ -60,9 +60,9 @@ use futures_util::Stream; use std::sync::Arc; use temporal_client::{ConfiguredClient, NamespacedClient, TemporalServiceClientWithMetrics}; use temporal_sdk_core_api::{ + Worker as WorkerTrait, errors::{CompleteActivityError, PollError}, telemetry::TelemetryOptions, - Worker as WorkerTrait, }; use temporal_sdk_core_protos::coresdk::ActivityHeartbeat; diff --git a/core/src/pollers/mod.rs b/core/src/pollers/mod.rs index 4b2578b30..b8f428180 100644 --- a/core/src/pollers/mod.rs +++ b/core/src/pollers/mod.rs @@ -1,7 +1,7 @@ mod poll_buffer; pub(crate) use poll_buffer::{ - new_activity_task_buffer, new_nexus_task_buffer, new_workflow_task_buffer, WorkflowTaskPoller, + WorkflowTaskPoller, new_activity_task_buffer, new_nexus_task_buffer, new_workflow_task_buffer, }; pub use temporal_client::{ Client, ClientOptions, ClientOptionsBuilder, ClientTlsConfig, RetryClient, RetryConfig, @@ -13,7 +13,7 @@ use crate::{ telemetry::metrics::MetricsContext, }; use anyhow::{anyhow, bail}; -use futures_util::{stream, Stream}; +use futures_util::{Stream, stream}; use std::{fmt::Debug, marker::PhantomData}; use temporal_sdk_core_api::worker::{ActivitySlotKind, NexusSlotKind, SlotKind, WorkflowSlotKind}; use temporal_sdk_core_protos::temporal::api::workflowservice::v1::{ diff --git a/core/src/pollers/poll_buffer.rs b/core/src/pollers/poll_buffer.rs index 6b21ec50b..73b3dda72 100644 --- a/core/src/pollers/poll_buffer.rs +++ b/core/src/pollers/poll_buffer.rs @@ -1,16 +1,16 @@ use crate::{ - abstractions::{dbg_panic, MeteredPermitDealer, OwnedMeteredSemPermit}, + abstractions::{MeteredPermitDealer, OwnedMeteredSemPermit, dbg_panic}, pollers::{self, Poller}, worker::client::WorkerClient, }; -use futures_util::{future::BoxFuture, stream::FuturesUnordered, FutureExt, StreamExt}; +use futures_util::{FutureExt, StreamExt, future::BoxFuture, stream::FuturesUnordered}; use governor::{Quota, RateLimiter}; use std::{ fmt::Debug, future::Future, sync::{ - atomic::{AtomicBool, AtomicUsize, Ordering}, Arc, + atomic::{AtomicBool, AtomicUsize, Ordering}, }, time::Duration, }; @@ -23,9 +23,8 @@ use temporal_sdk_core_protos::temporal::api::{ }; use tokio::{ sync::{ - broadcast, - mpsc::{unbounded_channel, UnboundedReceiver}, - Mutex, + Mutex, broadcast, + mpsc::{UnboundedReceiver, unbounded_channel}, }, task::JoinHandle, }; diff --git a/core/src/protosext/mod.rs b/core/src/protosext/mod.rs index 55d8b4e21..2f4d10166 100644 --- a/core/src/protosext/mod.rs +++ b/core/src/protosext/mod.rs @@ -1,9 +1,9 @@ pub(crate) mod protocol_messages; use crate::{ - protosext::protocol_messages::IncomingProtocolMessage, - worker::{LocalActivityExecutionResult, LEGACY_QUERY_ID}, CompleteActivityError, TaskToken, + protosext::protocol_messages::IncomingProtocolMessage, + worker::{LEGACY_QUERY_ID, LocalActivityExecutionResult}, }; use anyhow::anyhow; use itertools::Itertools; @@ -23,11 +23,11 @@ use temporal_sdk_core_protos::{ }, external_data::LocalActivityMarkerData, workflow_activation::{ - query_to_job, workflow_activation_job, QueryWorkflow, WorkflowActivation, - WorkflowActivationJob, + QueryWorkflow, WorkflowActivation, WorkflowActivationJob, query_to_job, + workflow_activation_job, }, workflow_commands::{ - query_result, ActivityCancellationType, QueryResult, ScheduleLocalActivity, + ActivityCancellationType, QueryResult, ScheduleLocalActivity, query_result, }, workflow_completion, }, @@ -35,7 +35,7 @@ use temporal_sdk_core_protos::{ common::v1::{Payload, RetryPolicy, WorkflowExecution}, enums::v1::EventType, failure::v1::Failure, - history::v1::{history_event, History, HistoryEvent, MarkerRecordedEventAttributes}, + history::v1::{History, HistoryEvent, MarkerRecordedEventAttributes, history_event}, query::v1::WorkflowQuery, workflowservice::v1::PollWorkflowTaskQueueResponse, }, @@ -400,7 +400,7 @@ impl ValidScheduleLA { return Err(anyhow!( "One or both of schedule_to_close or start_to_close timeouts must be set for \ local activities" - )) + )); } }; let retry_policy = v.retry_policy.unwrap_or_default(); diff --git a/core/src/protosext/protocol_messages.rs b/core/src/protosext/protocol_messages.rs index 1e79a6fe1..3962edec5 100644 --- a/core/src/protosext/protocol_messages.rs +++ b/core/src/protosext/protocol_messages.rs @@ -2,8 +2,8 @@ use anyhow::{anyhow, bail}; use std::collections::HashMap; use temporal_sdk_core_protos::temporal::api::{ common::v1::Payload, - history::v1::{history_event, HistoryEvent}, - protocol::v1::{message::SequencingId, Message}, + history::v1::{HistoryEvent, history_event}, + protocol::v1::{Message, message::SequencingId}, update, }; diff --git a/core/src/replay/mod.rs b/core/src/replay/mod.rs index e42f48c31..f17b69308 100644 --- a/core/src/replay/mod.rs +++ b/core/src/replay/mod.rs @@ -3,21 +3,23 @@ //! users during testing. use crate::{ + Worker, worker::{ - client::mocks::{mock_manual_workflow_client, MockManualWorkerClient}, PostActivateHookData, + client::mocks::{MockManualWorkerClient, mock_manual_workflow_client}, }, - Worker, }; use futures_util::{FutureExt, Stream, StreamExt}; use parking_lot::Mutex; -use std::sync::OnceLock; use std::{ pin::Pin, - sync::Arc, + sync::{Arc, OnceLock}, task::{Context, Poll}, }; use temporal_sdk_core_api::worker::WorkerConfig; +pub use temporal_sdk_core_protos::{ + DEFAULT_WORKFLOW_TYPE, HistoryInfo, TestHistoryBuilder, default_wes_attribs, +}; use temporal_sdk_core_protos::{ coresdk::workflow_activation::remove_from_cache::EvictionReason, temporal::api::{ @@ -28,10 +30,7 @@ use temporal_sdk_core_protos::{ }, }, }; -pub use temporal_sdk_core_protos::{ - default_wes_attribs, HistoryInfo, TestHistoryBuilder, DEFAULT_WORKFLOW_TYPE, -}; -use tokio::sync::{mpsc, mpsc::UnboundedSender, Mutex as TokioMutex}; +use tokio::sync::{Mutex as TokioMutex, mpsc, mpsc::UnboundedSender}; use tokio_stream::wrappers::UnboundedReceiverStream; use tokio_util::sync::CancellationToken; @@ -202,7 +201,7 @@ impl Historator { /// we're ready to replay the next history, or whatever else. pub(crate) fn get_post_activate_hook( &self, - ) -> impl Fn(&Worker, PostActivateHookData) + Send + Sync { + ) -> impl Fn(&Worker, PostActivateHookData) + Send + Sync + use<> { let done_tx = self.replay_done_tx.clone(); move |worker, data| { if !data.replaying { diff --git a/core/src/retry_logic.rs b/core/src/retry_logic.rs index 9b0782245..c8f025c40 100644 --- a/core/src/retry_logic.rs +++ b/core/src/retry_logic.rs @@ -169,8 +169,8 @@ mod tests { maximum_attempts: 10, non_retryable_error_types: vec!["no retry".to_string()], }; - assert!(rp - .should_retry( + assert!( + rp.should_retry( 1, Some(&ApplicationFailureInfo { r#type: "no retry".to_string(), @@ -178,7 +178,8 @@ mod tests { ..Default::default() }) ) - .is_none()); + .is_none() + ); } #[test] @@ -190,8 +191,8 @@ mod tests { maximum_attempts: 10, non_retryable_error_types: vec![], }; - assert!(rp - .should_retry( + assert!( + rp.should_retry( 1, Some(&ApplicationFailureInfo { r#type: "".to_string(), @@ -199,7 +200,8 @@ mod tests { ..Default::default() }) ) - .is_none()); + .is_none() + ); } #[test] diff --git a/core/src/telemetry/log_export.rs b/core/src/telemetry/log_export.rs index d4e2afd0f..b98ce7dfa 100644 --- a/core/src/telemetry/log_export.rs +++ b/core/src/telemetry/log_export.rs @@ -1,6 +1,6 @@ -use futures_channel::mpsc::{channel, Receiver, Sender}; +use futures_channel::mpsc::{Receiver, Sender, channel}; use parking_lot::Mutex; -use ringbuf::{consumer::Consumer, producer::Producer, traits::Split, HeapRb}; +use ringbuf::{HeapRb, consumer::Consumer, producer::Producer, traits::Split}; use std::{collections::HashMap, fmt, sync::Arc, time::SystemTime}; use temporal_sdk_core_api::telemetry::{CoreLog, CoreLogConsumer}; use tracing_subscriber::Layer; @@ -216,7 +216,7 @@ impl tracing::field::Visit for JsonVisitor<'_> { #[cfg(test)] mod tests { use crate::{ - telemetry::{construct_filter_string, CoreLogStreamConsumer}, + telemetry::{CoreLogStreamConsumer, construct_filter_string}, telemetry_init, }; use futures_util::stream::StreamExt; diff --git a/core/src/telemetry/metrics.rs b/core/src/telemetry/metrics.rs index 447da9c9a..1f15f19c3 100644 --- a/core/src/telemetry/metrics.rs +++ b/core/src/telemetry/metrics.rs @@ -904,8 +904,8 @@ mod tests { use super::*; use std::any::Any; use temporal_sdk_core_api::telemetry::{ - metrics::{BufferInstrumentRef, CustomMetricAttributes}, METRIC_PREFIX, + metrics::{BufferInstrumentRef, CustomMetricAttributes}, }; use tracing::subscriber::NoSubscriber; diff --git a/core/src/telemetry/mod.rs b/core/src/telemetry/mod.rs index b6c432422..1854b54a2 100644 --- a/core/src/telemetry/mod.rs +++ b/core/src/telemetry/mod.rs @@ -10,10 +10,10 @@ mod prometheus_server; #[cfg(feature = "otel")] pub use metrics::{ - default_buckets_for, MetricsCallBuffer, ACTIVITY_EXEC_LATENCY_HISTOGRAM_NAME, - ACTIVITY_SCHED_TO_START_LATENCY_HISTOGRAM_NAME, WORKFLOW_E2E_LATENCY_HISTOGRAM_NAME, + ACTIVITY_EXEC_LATENCY_HISTOGRAM_NAME, ACTIVITY_SCHED_TO_START_LATENCY_HISTOGRAM_NAME, + MetricsCallBuffer, WORKFLOW_E2E_LATENCY_HISTOGRAM_NAME, WORKFLOW_TASK_EXECUTION_LATENCY_HISTOGRAM_NAME, WORKFLOW_TASK_REPLAY_LATENCY_HISTOGRAM_NAME, - WORKFLOW_TASK_SCHED_TO_START_LATENCY_HISTOGRAM_NAME, + WORKFLOW_TASK_SCHED_TO_START_LATENCY_HISTOGRAM_NAME, default_buckets_for, }; #[cfg(feature = "otel")] pub use otel::{build_otlp_metric_exporter, start_prometheus_metric_exporter}; @@ -28,16 +28,16 @@ use std::{ collections::VecDeque, env, sync::{ - atomic::{AtomicBool, Ordering}, Arc, + atomic::{AtomicBool, Ordering}, }, }; use temporal_sdk_core_api::telemetry::{ - metrics::{CoreMeter, MetricKeyValue, NewAttributes, TemporalMeter}, CoreLog, CoreTelemetry, Logger, TelemetryOptions, + metrics::{CoreMeter, MetricKeyValue, NewAttributes, TemporalMeter}, }; use tracing::{Level, Subscriber}; -use tracing_subscriber::{layer::SubscriberExt, EnvFilter, Layer}; +use tracing_subscriber::{EnvFilter, Layer, layer::SubscriberExt}; const TELEM_SERVICE_NAME: &str = "temporal-core-sdk"; diff --git a/core/src/telemetry/otel.rs b/core/src/telemetry/otel.rs index 85d2d5b2c..932687ee6 100644 --- a/core/src/telemetry/otel.rs +++ b/core/src/telemetry/otel.rs @@ -1,5 +1,5 @@ use super::{ - default_buckets_for, + TELEM_SERVICE_NAME, default_buckets_for, metrics::{ ACTIVITY_EXEC_LATENCY_HISTOGRAM_NAME, ACTIVITY_SCHED_TO_START_LATENCY_HISTOGRAM_NAME, DEFAULT_MS_BUCKETS, WORKFLOW_E2E_LATENCY_HISTOGRAM_NAME, @@ -8,30 +8,29 @@ use super::{ WORKFLOW_TASK_SCHED_TO_START_LATENCY_HISTOGRAM_NAME, }, prometheus_server::PromServer, - TELEM_SERVICE_NAME, }; use crate::{abstractions::dbg_panic, telemetry::metrics::DEFAULT_S_BUCKETS}; use opentelemetry::{ - self, global, + self, Key, KeyValue, Value, global, metrics::{Meter, MeterProvider as MeterProviderT}, - Key, KeyValue, Value, }; use opentelemetry_otlp::WithExportConfig; use opentelemetry_sdk::{ + Resource, metrics::{ - data::Temporality, new_view, reader::TemporalitySelector, Aggregation, Instrument, - InstrumentKind, MeterProviderBuilder, PeriodicReader, SdkMeterProvider, View, + Aggregation, Instrument, InstrumentKind, MeterProviderBuilder, PeriodicReader, + SdkMeterProvider, View, data::Temporality, new_view, reader::TemporalitySelector, }, - runtime, Resource, + runtime, }; use std::{collections::HashMap, net::SocketAddr, sync::Arc, time::Duration}; use temporal_sdk_core_api::telemetry::{ + HistogramBucketOverrides, MetricTemporality, OtelCollectorOptions, OtlpProtocol, + PrometheusExporterOptions, metrics::{ CoreMeter, Counter, Gauge, GaugeF64, Histogram, HistogramDuration, HistogramF64, MetricAttributes, MetricParameters, NewAttributes, }, - HistogramBucketOverrides, MetricTemporality, OtelCollectorOptions, OtlpProtocol, - PrometheusExporterOptions, }; use tokio::task::AbortHandle; use tonic::{metadata::MetadataMap, transport::ClientTlsConfig}; diff --git a/core/src/telemetry/prometheus_server.rs b/core/src/telemetry/prometheus_server.rs index e49ddf9a1..46a732378 100644 --- a/core/src/telemetry/prometheus_server.rs +++ b/core/src/telemetry/prometheus_server.rs @@ -1,5 +1,5 @@ use http_body_util::Full; -use hyper::{body::Bytes, header::CONTENT_TYPE, service::service_fn, Method, Request, Response}; +use hyper::{Method, Request, Response, body::Bytes, header::CONTENT_TYPE, service::service_fn}; use hyper_util::{ rt::{TokioExecutor, TokioIo}, server::conn::auto, diff --git a/core/src/test_help/mod.rs b/core/src/test_help/mod.rs index 14cbc8193..665517c8c 100644 --- a/core/src/test_help/mod.rs +++ b/core/src/test_help/mod.rs @@ -1,21 +1,21 @@ pub(crate) use temporal_sdk_core_test_utils::canned_histories; use crate::{ + TaskToken, Worker, WorkerConfig, WorkerConfigBuilder, pollers::{BoxedPoller, MockManualPoller, MockPoller}, protosext::ValidPollWFTQResponse, replay::TestHistoryBuilder, sticky_q_name_for_worker, worker::{ + TaskPollers, client::{ - mocks::mock_workflow_client, MockWorkerClient, WorkerClient, WorkflowTaskCompletion, + MockWorkerClient, WorkerClient, WorkflowTaskCompletion, mocks::mock_workflow_client, }, - TaskPollers, }, - TaskToken, Worker, WorkerConfig, WorkerConfigBuilder, }; use async_trait::async_trait; use bimap::BiMap; -use futures_util::{future::BoxFuture, stream, stream::BoxStream, FutureExt, Stream, StreamExt}; +use futures_util::{FutureExt, Stream, StreamExt, future::BoxFuture, stream, stream::BoxStream}; use mockall::TimesRange; use parking_lot::RwLock; use std::{ @@ -24,19 +24,19 @@ use std::{ ops::{Deref, DerefMut}, pin::Pin, sync::{ - atomic::{AtomicBool, Ordering}, Arc, + atomic::{AtomicBool, Ordering}, }, task::{Context, Poll}, time::Duration, }; use temporal_sdk::interceptors::FailOnNondeterminismInterceptor; -use temporal_sdk_core_api::{errors::PollError, Worker as WorkerTrait}; +use temporal_sdk_core_api::{Worker as WorkerTrait, errors::PollError}; use temporal_sdk_core_protos::{ coresdk::{ - workflow_activation::{workflow_activation_job, WorkflowActivation}, + workflow_activation::{WorkflowActivation, workflow_activation_job}, workflow_commands::workflow_command, - workflow_completion::{self, workflow_activation_completion, WorkflowActivationCompletion}, + workflow_completion::{self, WorkflowActivationCompletion, workflow_activation_completion}, }, temporal::api::{ common::v1::WorkflowExecution, @@ -52,8 +52,8 @@ use temporal_sdk_core_protos::{ }, utilities::pack_any, }; -use temporal_sdk_core_test_utils::{TestWorker, NAMESPACE}; -use tokio::sync::{mpsc::unbounded_channel, Notify}; +use temporal_sdk_core_test_utils::{NAMESPACE, TestWorker}; +use tokio::sync::{Notify, mpsc::unbounded_channel}; use tokio_stream::wrappers::UnboundedReceiverStream; pub(crate) const TEST_Q: &str = "q"; @@ -825,7 +825,7 @@ pub(crate) fn hist_to_poll_resp( return QueueResponse { resp: r, delay_until: None, - } + }; } ResponseType::UntilResolved(fut, tn) => { delay_until = Some(fut); @@ -835,7 +835,7 @@ pub(crate) fn hist_to_poll_resp( return QueueResponse { resp: r, delay_until: Some(fut), - } + }; } }; let mut resp = hist_info.as_poll_wft_response(); diff --git a/core/src/worker/activities.rs b/core/src/worker/activities.rs index 28c4b6207..d8f75b6b3 100644 --- a/core/src/worker/activities.rs +++ b/core/src/worker/activities.rs @@ -7,50 +7,49 @@ pub(crate) use local_activities::{ }; use crate::{ + PollError, TaskToken, abstractions::{ ClosableMeteredPermitDealer, MeteredPermitDealer, TrackedOwnedMeteredSemPermit, UsedMeteredSemPermit, }, - pollers::{new_activity_task_poller, BoxedActPoller, PermittedTqResp, TrackedPermittedTqResp}, - telemetry::metrics::{activity_type, eager, workflow_type, MetricsContext}, + pollers::{BoxedActPoller, PermittedTqResp, TrackedPermittedTqResp, new_activity_task_poller}, + telemetry::metrics::{MetricsContext, activity_type, eager, workflow_type}, worker::{ activities::activity_heartbeat_manager::ActivityHeartbeatError, client::WorkerClient, }, - PollError, TaskToken, }; use activity_heartbeat_manager::ActivityHeartbeatManager; use dashmap::DashMap; use futures_util::{ - stream, + Stream, StreamExt, stream, stream::{BoxStream, PollNext}, - Stream, StreamExt, }; use std::{ convert::TryInto, future, sync::{ - atomic::{AtomicBool, Ordering}, Arc, + atomic::{AtomicBool, Ordering}, }, time::{Duration, Instant, SystemTime}, }; use temporal_sdk_core_api::worker::ActivitySlotKind; use temporal_sdk_core_protos::{ coresdk::{ + ActivityHeartbeat, ActivitySlotInfo, activity_result::{self as ar, activity_execution_result as aer}, activity_task::{ActivityCancelReason, ActivityTask}, - ActivityHeartbeat, ActivitySlotInfo, }, temporal::api::{ - failure::v1::{failure::FailureInfo, ApplicationFailureInfo, CanceledFailureInfo, Failure}, + failure::v1::{ApplicationFailureInfo, CanceledFailureInfo, Failure, failure::FailureInfo}, workflowservice::v1::PollActivityTaskQueueResponse, }, }; use tokio::{ join, sync::{ - mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender}, Mutex, Notify, + mpsc::{UnboundedReceiver, UnboundedSender, unbounded_channel}, }, task::JoinHandle, }; @@ -352,7 +351,7 @@ impl WorkerActivityTasks { aer::Status::Failed(ar::Failure { failure }) => { act_metrics.act_execution_failed(); client - .fail_activity_task(task_token.clone(), failure.map(Into::into)) + .fail_activity_task(task_token.clone(), failure) .await .err() } @@ -387,7 +386,7 @@ impl WorkerActivityTasks { None }; client - .cancel_activity_task(task_token.clone(), details.map(Into::into)) + .cancel_activity_task(task_token.clone(), details) .await .err() } diff --git a/core/src/worker/activities/activity_heartbeat_manager.rs b/core/src/worker/activities/activity_heartbeat_manager.rs index cc09607bf..0bd928a12 100644 --- a/core/src/worker/activities/activity_heartbeat_manager.rs +++ b/core/src/worker/activities/activity_heartbeat_manager.rs @@ -1,24 +1,24 @@ use crate::{ + TaskToken, abstractions::take_cell::TakeCell, worker::{activities::PendingActivityCancel, client::WorkerClient}, - TaskToken, }; use futures_util::StreamExt; use std::{ - collections::{hash_map::Entry, HashMap}, + collections::{HashMap, hash_map::Entry}, sync::Arc, time::{Duration, Instant}, }; use temporal_sdk_core_protos::{ - coresdk::{activity_task::ActivityCancelReason, ActivityHeartbeat, IntoPayloadsExt}, + coresdk::{ActivityHeartbeat, IntoPayloadsExt, activity_task::ActivityCancelReason}, temporal::api::{ common::v1::Payload, workflowservice::v1::RecordActivityTaskHeartbeatResponse, }, }; use tokio::{ sync::{ - mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender}, Notify, + mpsc::{UnboundedReceiver, UnboundedSender, unbounded_channel}, }, task::JoinHandle, }; @@ -67,7 +67,9 @@ enum HeartbeatExecutorAction { #[derive(thiserror::Error, Debug)] pub(crate) enum ActivityHeartbeatError { /// Heartbeat referenced an activity that we don't think exists. It may have completed already. - #[error("Heartbeat has been sent for activity that either completed or never started on this worker.")] + #[error( + "Heartbeat has been sent for activity that either completed or never started on this worker." + )] UnknownActivity, /// There was a set heartbeat timeout, but it was not parseable. A valid timeout is requried /// to heartbeat. diff --git a/core/src/worker/activities/local_activities.rs b/core/src/worker/activities/local_activities.rs index f908bc6ef..a2a38c89e 100644 --- a/core/src/worker/activities/local_activities.rs +++ b/core/src/worker/activities/local_activities.rs @@ -1,17 +1,17 @@ use crate::{ - abstractions::{dbg_panic, MeteredPermitDealer, OwnedMeteredSemPermit, UsedMeteredSemPermit}, + MetricsContext, TaskToken, + abstractions::{MeteredPermitDealer, OwnedMeteredSemPermit, UsedMeteredSemPermit, dbg_panic}, protosext::ValidScheduleLA, retry_logic::RetryPolicyExt, telemetry::metrics::{activity_type, workflow_type}, worker::workflow::HeartbeatTimeoutMsg, - MetricsContext, TaskToken, }; use futures_util::{ - future, future::AbortRegistration, stream, stream::BoxStream, Stream, StreamExt, + Stream, StreamExt, future, future::AbortRegistration, stream, stream::BoxStream, }; use parking_lot::{Mutex, MutexGuard}; use std::{ - collections::{hash_map::Entry, HashMap}, + collections::{HashMap, hash_map::Entry}, fmt::{Debug, Formatter}, pin::Pin, task::{Context, Poll}, @@ -20,20 +20,20 @@ use std::{ use temporal_sdk_core_api::worker::LocalActivitySlotKind; use temporal_sdk_core_protos::{ coresdk::{ - activity_result::{Cancellation, Failure as ActFail, Success}, - activity_task::{activity_task, ActivityCancelReason, ActivityTask, Cancel, Start}, LocalActivitySlotInfo, + activity_result::{Cancellation, Failure as ActFail, Success}, + activity_task::{ActivityCancelReason, ActivityTask, Cancel, Start, activity_task}, }, temporal::api::{ common::v1::WorkflowExecution, enums::v1::TimeoutType, - failure::v1::{failure, Failure as APIFailure, TimeoutFailureInfo}, + failure::v1::{Failure as APIFailure, TimeoutFailureInfo, failure}, }, }; use tokio::{ sync::{ - mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender}, Notify, + mpsc::{UnboundedReceiver, UnboundedSender, unbounded_channel}, }, task::JoinHandle, time::sleep, @@ -973,7 +973,7 @@ mod tests { use futures_util::FutureExt; use temporal_sdk_core_protos::temporal::api::{ common::v1::RetryPolicy, - failure::v1::{failure::FailureInfo, ApplicationFailureInfo, Failure}, + failure::v1::{ApplicationFailureInfo, Failure, failure::FailureInfo}, }; use tokio::task::yield_now; diff --git a/core/src/worker/client.rs b/core/src/worker/client.rs index 186c00395..6df97a1a9 100644 --- a/core/src/worker/client.rs +++ b/core/src/worker/client.rs @@ -8,6 +8,7 @@ use temporal_client::{ WorkflowService, }; use temporal_sdk_core_protos::{ + TaskToken, coresdk::workflow_commands::QueryResult, temporal::api::{ command::v1::Command, @@ -24,7 +25,6 @@ use temporal_sdk_core_protos::{ taskqueue::v1::{StickyExecutionAttributes, TaskQueue, TaskQueueMetadata}, workflowservice::v1::{get_system_info_response::Capabilities, *}, }, - TaskToken, }; use tonic::IntoRequest; diff --git a/core/src/worker/mod.rs b/core/src/worker/mod.rs index 63ffd2a1a..204f7c1d9 100644 --- a/core/src/worker/mod.rs +++ b/core/src/worker/mod.rs @@ -16,23 +16,24 @@ pub(crate) use activities::{ ExecutingLAId, LocalActRequest, LocalActivityExecutionResult, LocalActivityResolution, NewLocalAct, }; -pub(crate) use workflow::{wft_poller::new_wft_poller, LEGACY_QUERY_ID}; +pub(crate) use workflow::{LEGACY_QUERY_ID, wft_poller::new_wft_poller}; use crate::{ - abstractions::{dbg_panic, MeteredPermitDealer, PermitDealerContextData}, + ActivityHeartbeat, CompleteActivityError, PollError, WorkerTrait, + abstractions::{MeteredPermitDealer, PermitDealerContextData, dbg_panic}, errors::CompleteWfError, pollers::{ - new_activity_task_buffer, new_nexus_task_buffer, new_workflow_task_buffer, BoxedActPoller, - BoxedNexusPoller, WorkflowTaskPoller, + BoxedActPoller, BoxedNexusPoller, WorkflowTaskPoller, new_activity_task_buffer, + new_nexus_task_buffer, new_workflow_task_buffer, }, protosext::validate_activity_completion, telemetry::{ + TelemetryInstance, metrics::{ - activity_poller, activity_worker_type, local_activity_worker_type, nexus_poller, - nexus_worker_type, workflow_poller, workflow_sticky_poller, workflow_worker_type, - MetricsContext, + MetricsContext, activity_poller, activity_worker_type, local_activity_worker_type, + nexus_poller, nexus_worker_type, workflow_poller, workflow_sticky_poller, + workflow_worker_type, }, - TelemetryInstance, }, worker::{ activities::{LACompleteAction, LocalActivityManager, NextPendingLAAction}, @@ -40,43 +41,42 @@ use crate::{ nexus::NexusManager, workflow::{LAReqSink, LocalResolution, WorkflowBasics, Workflows}, }, - ActivityHeartbeat, CompleteActivityError, PollError, WorkerTrait, }; use activities::WorkerActivityTasks; -use futures_util::{stream, StreamExt}; +use futures_util::{StreamExt, stream}; use parking_lot::Mutex; use slot_provider::SlotProvider; use std::{ convert::TryInto, future, sync::{ - atomic::{AtomicBool, Ordering}, Arc, + atomic::{AtomicBool, Ordering}, }, time::Duration, }; use temporal_client::{ConfiguredClient, TemporalServiceClientWithMetrics, WorkerKey}; use temporal_sdk_core_api::errors::{CompleteNexusError, WorkerValidationError}; use temporal_sdk_core_protos::{ + TaskToken, coresdk::{ + ActivityTaskCompletion, activity_result::activity_execution_result, activity_task::ActivityTask, - workflow_activation::{remove_from_cache::EvictionReason, WorkflowActivation}, + workflow_activation::{WorkflowActivation, remove_from_cache::EvictionReason}, workflow_completion::WorkflowActivationCompletion, - ActivityTaskCompletion, }, temporal::api::{ enums::v1::TaskQueueKind, taskqueue::v1::{StickyExecutionAttributes, TaskQueue}, }, - TaskToken, }; use tokio::sync::{mpsc::unbounded_channel, watch}; use tokio_stream::wrappers::UnboundedReceiverStream; use tokio_util::sync::CancellationToken; use temporal_sdk_core_protos::coresdk::nexus::{ - nexus_task_completion, NexusTask, NexusTaskCompletion, + NexusTask, NexusTaskCompletion, nexus_task_completion, }; #[cfg(test)] @@ -941,9 +941,11 @@ mod tests { #[test] fn max_polls_zero_is_err() { - assert!(test_worker_cfg() - .max_concurrent_wft_polls(0_usize) - .build() - .is_err()); + assert!( + test_worker_cfg() + .max_concurrent_wft_polls(0_usize) + .build() + .is_err() + ); } } diff --git a/core/src/worker/nexus.rs b/core/src/worker/nexus.rs index 57832b953..188746847 100644 --- a/core/src/worker/nexus.rs +++ b/core/src/worker/nexus.rs @@ -1,6 +1,6 @@ use crate::{ abstractions::UsedMeteredSemPermit, - pollers::{new_nexus_task_poller, BoxedNexusPoller, NexusPollItem}, + pollers::{BoxedNexusPoller, NexusPollItem, new_nexus_task_poller}, telemetry::{ metrics, metrics::{FailureReason, MetricsContext}, @@ -9,15 +9,14 @@ use crate::{ }; use anyhow::anyhow; use futures_util::{ - stream, + Stream, StreamExt, stream, stream::{BoxStream, PollNext}, - Stream, StreamExt, }; use std::{ collections::HashMap, sync::{ - atomic::{AtomicBool, Ordering}, Arc, + atomic::{AtomicBool, Ordering}, }, time::{Duration, Instant, SystemTime}, }; @@ -26,18 +25,18 @@ use temporal_sdk_core_api::{ worker::NexusSlotKind, }; use temporal_sdk_core_protos::{ + TaskToken, coresdk::{ + NexusSlotInfo, nexus::{ - nexus_task, nexus_task_completion, CancelNexusTask, NexusTask, NexusTaskCancelReason, + CancelNexusTask, NexusTask, NexusTaskCancelReason, nexus_task, nexus_task_completion, }, - NexusSlotInfo, }, temporal::api::nexus::v1::{request::Variant, response, start_operation_response}, - TaskToken, }; use tokio::{ join, - sync::{mpsc::UnboundedSender, Mutex, Notify}, + sync::{Mutex, Notify, mpsc::UnboundedSender}, task::JoinHandle, }; use tokio_stream::wrappers::UnboundedReceiverStream; @@ -154,7 +153,7 @@ impl NexusManager { return Err(CompleteNexusError::MalformedNexusCompletion { reason: "Nexus completion must contain a status variant " .to_string(), - }) + }); } } (true, client.complete_nexus_task(tt, c).await.err()) diff --git a/core/src/worker/tuner/resource_based.rs b/core/src/worker/tuner/resource_based.rs index 792411f4d..8623d5523 100644 --- a/core/src/worker/tuner/resource_based.rs +++ b/core/src/worker/tuner/resource_based.rs @@ -3,8 +3,8 @@ use parking_lot::Mutex; use std::{ marker::PhantomData, sync::{ - atomic::{AtomicU64, AtomicUsize, Ordering}, Arc, OnceLock, + atomic::{AtomicU64, AtomicUsize, Ordering}, }, time::{Duration, Instant}, }; @@ -546,8 +546,8 @@ mod tests { use super::*; use crate::{abstractions::MeteredPermitDealer, telemetry::metrics::MetricsContext}; use std::sync::{ - atomic::{AtomicU64, Ordering}, Arc, + atomic::{AtomicU64, Ordering}, }; use temporal_sdk_core_api::worker::WorkflowSlotKind; diff --git a/core/src/worker/workflow/driven_workflow.rs b/core/src/worker/workflow/driven_workflow.rs index 48f7a40f1..d5bf14e25 100644 --- a/core/src/worker/workflow/driven_workflow.rs +++ b/core/src/worker/workflow/driven_workflow.rs @@ -8,7 +8,7 @@ use std::{ sync::mpsc::{self, Receiver, Sender}, }; use temporal_sdk_core_protos::{ - coresdk::workflow_activation::{start_workflow_from_attribs, WorkflowActivationJob}, + coresdk::workflow_activation::{WorkflowActivationJob, start_workflow_from_attribs}, temporal::api::{common::v1::Payload, history::v1::WorkflowExecutionStartedEventAttributes}, utilities::TryIntoOrNone, }; diff --git a/core/src/worker/workflow/history_update.rs b/core/src/worker/workflow/history_update.rs index 4ac4f02b9..693e0a322 100644 --- a/core/src/worker/workflow/history_update.rs +++ b/core/src/worker/workflow/history_update.rs @@ -5,7 +5,7 @@ use crate::{ workflow::{CacheMissFetchReq, PermittedWFT, PreparedWFT}, }, }; -use futures_util::{future::BoxFuture, FutureExt, Stream, TryFutureExt}; +use futures_util::{FutureExt, Stream, TryFutureExt, future::BoxFuture}; use itertools::Itertools; use std::{ collections::VecDeque, @@ -20,8 +20,7 @@ use std::{ use temporal_sdk_core_protos::temporal::api::{ enums::v1::EventType, history::v1::{ - history_event, history_event::Attributes, History, HistoryEvent, - WorkflowTaskCompletedEventAttributes, + History, HistoryEvent, WorkflowTaskCompletedEventAttributes, history_event::Attributes, }, }; use tracing::Instrument; @@ -651,9 +650,7 @@ impl HistoryUpdate { .iter() .skip_while(|e| e.event_id < from_id) .find_map(|e| match &e.attributes { - Some(history_event::Attributes::WorkflowTaskCompletedEventAttributes(ref a)) => { - Some(a) - } + Some(Attributes::WorkflowTaskCompletedEventAttributes(a)) => Some(a), _ => None, }) } @@ -794,7 +791,7 @@ mod tests { use super::*; use crate::{ replay::{HistoryInfo, TestHistoryBuilder}, - test_help::{canned_histories, hist_to_poll_resp, mock_sdk_cfg, MockPollCfg, ResponseType}, + test_help::{MockPollCfg, ResponseType, canned_histories, hist_to_poll_resp, mock_sdk_cfg}, worker::client::mocks::mock_workflow_client, }; use futures_util::{StreamExt, TryStreamExt}; @@ -802,11 +799,11 @@ mod tests { use temporal_client::WorkflowOptions; use temporal_sdk::WfContext; use temporal_sdk_core_protos::{ + DEFAULT_WORKFLOW_TYPE, temporal::api::{ common::v1::WorkflowExecution, enums::v1::WorkflowTaskFailedCause, workflowservice::v1::GetWorkflowExecutionHistoryResponse, }, - DEFAULT_WORKFLOW_TYPE, }; impl From for HistoryUpdate { diff --git a/core/src/worker/workflow/machines/activity_state_machine.rs b/core/src/worker/workflow/machines/activity_state_machine.rs index 388af1484..84e78ff7b 100644 --- a/core/src/worker/workflow/machines/activity_state_machine.rs +++ b/core/src/worker/workflow/machines/activity_state_machine.rs @@ -1,34 +1,33 @@ #![allow(clippy::large_enum_variant)] use super::{ - workflow_machines::MachineResponse, EventInfo, NewMachineWithCommand, OnEventWrapper, - WFMachinesAdapter, WFMachinesError, + EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError, + workflow_machines::MachineResponse, }; use crate::{ abstractions::dbg_panic, internal_flags::CoreInternalFlags, - worker::workflow::{machines::HistEventData, InternalFlagsRef}, + worker::workflow::{InternalFlagsRef, machines::HistEventData}, }; -use rustfsm::{fsm, MachineError, StateMachine, TransitionResult}; +use rustfsm::{MachineError, StateMachine, TransitionResult, fsm}; use std::convert::{TryFrom, TryInto}; use temporal_sdk_core_protos::{ coresdk::{ - activity_result::{self as ar, activity_resolution, ActivityResolution, Cancellation}, + activity_result::{self as ar, ActivityResolution, Cancellation, activity_resolution}, workflow_activation::ResolveActivity, workflow_commands::{ActivityCancellationType, ScheduleActivity}, }, temporal::api::{ command::v1::{ - command, schedule_activity_cmd_to_api, Command, - RequestCancelActivityTaskCommandAttributes, + Command, RequestCancelActivityTaskCommandAttributes, command, + schedule_activity_cmd_to_api, }, common::v1::{ActivityType, Payload, Payloads}, enums::v1::{CommandType, EventType, RetryState}, - failure::v1::{failure::FailureInfo, ActivityFailureInfo, CanceledFailureInfo, Failure}, + failure::v1::{ActivityFailureInfo, CanceledFailureInfo, Failure, failure::FailureInfo}, history::v1::{ - history_event, ActivityTaskCanceledEventAttributes, - ActivityTaskCompletedEventAttributes, ActivityTaskFailedEventAttributes, - ActivityTaskTimedOutEventAttributes, + ActivityTaskCanceledEventAttributes, ActivityTaskCompletedEventAttributes, + ActivityTaskFailedEventAttributes, ActivityTaskTimedOutEventAttributes, history_event, }, }, }; @@ -279,7 +278,7 @@ impl TryFrom for ActivityMachineEvents { _ => { return Err(WFMachinesError::Nondeterminism(format!( "Activity machine does not handle this event: {e}" - ))) + ))); } }) } @@ -293,28 +292,32 @@ impl WFMachinesAdapter for ActivityMachine { ) -> Result, WFMachinesError> { Ok(match my_command { ActivityMachineCommand::Complete(result) => { - vec![ResolveActivity { - seq: self.shared_state.attrs.seq, - result: Some(ActivityResolution { - status: Some(activity_resolution::Status::Completed(ar::Success { - result: convert_payloads(event_info, result)?, - })), - }), - is_local: false, - } - .into()] + vec![ + ResolveActivity { + seq: self.shared_state.attrs.seq, + result: Some(ActivityResolution { + status: Some(activity_resolution::Status::Completed(ar::Success { + result: convert_payloads(event_info, result)?, + })), + }), + is_local: false, + } + .into(), + ] } ActivityMachineCommand::Fail(failure) => { - vec![ResolveActivity { - seq: self.shared_state.attrs.seq, - result: Some(ActivityResolution { - status: Some(activity_resolution::Status::Failed(ar::Failure { - failure: Some(failure), - })), - }), - is_local: false, - } - .into()] + vec![ + ResolveActivity { + seq: self.shared_state.attrs.seq, + result: Some(ActivityResolution { + status: Some(activity_resolution::Status::Failed(ar::Failure { + failure: Some(failure), + })), + }), + is_local: false, + } + .into(), + ] } ActivityMachineCommand::RequestCancellation(c) => { self.machine_responses_from_cancel_request(c) @@ -750,7 +753,7 @@ fn new_cancel_failure(dat: &SharedState, attrs: ActivityTaskCanceledEventAttribu message: "Activity cancelled".to_string(), cause: Some(Box::from(Failure { failure_info: Some(FailureInfo::CanceledFailureInfo(CanceledFailureInfo { - details: attrs.details.map(Into::into), + details: attrs.details, })), ..Default::default() })), @@ -801,14 +804,14 @@ mod test { use crate::{ internal_flags::InternalFlags, replay::TestHistoryBuilder, - test_help::{build_fake_sdk, MockPollCfg, ResponseType}, - worker::workflow::{machines::Machines, OutgoingJob}, + test_help::{MockPollCfg, ResponseType, build_fake_sdk}, + worker::workflow::{OutgoingJob, machines::Machines}, }; use std::{cell::RefCell, mem::discriminant, rc::Rc}; use temporal_sdk::{ActivityOptions, CancellableFuture, WfContext, WorkflowFunction}; use temporal_sdk_core_protos::{ - coresdk::workflow_activation::{workflow_activation_job, WorkflowActivationJob}, DEFAULT_WORKFLOW_TYPE, + coresdk::workflow_activation::{WorkflowActivationJob, workflow_activation_job}, }; use temporal_sdk_core_test_utils::interceptors::ActivationAssertionsInterceptor; diff --git a/core/src/worker/workflow/machines/cancel_external_state_machine.rs b/core/src/worker/workflow/machines/cancel_external_state_machine.rs index 3128740bc..2f389472d 100644 --- a/core/src/worker/workflow/machines/cancel_external_state_machine.rs +++ b/core/src/worker/workflow/machines/cancel_external_state_machine.rs @@ -1,9 +1,9 @@ use super::{ - workflow_machines::MachineResponse, EventInfo, NewMachineWithCommand, OnEventWrapper, - WFMachinesAdapter, WFMachinesError, + EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError, + workflow_machines::MachineResponse, }; use crate::worker::workflow::machines::HistEventData; -use rustfsm::{fsm, StateMachine, TransitionResult}; +use rustfsm::{StateMachine, TransitionResult, fsm}; use std::convert::TryFrom; use temporal_sdk_core_protos::{ coresdk::{ @@ -11,9 +11,9 @@ use temporal_sdk_core_protos::{ workflow_activation::ResolveRequestCancelExternalWorkflow, }, temporal::api::{ - command::v1::{command, RequestCancelExternalWorkflowExecutionCommandAttributes}, + command::v1::{RequestCancelExternalWorkflowExecutionCommandAttributes, command}, enums::v1::{CancelExternalWorkflowExecutionFailedCause, CommandType, EventType}, - failure::v1::{failure::FailureInfo, ApplicationFailureInfo, Failure}, + failure::v1::{ApplicationFailureInfo, Failure, failure::FailureInfo}, history::v1::history_event, }, }; @@ -177,11 +177,13 @@ impl WFMachinesAdapter for CancelExternalMachine { ) -> Result, WFMachinesError> { Ok(match my_command { CancelExternalCommand::Requested => { - vec![ResolveRequestCancelExternalWorkflow { - seq: self.shared_state.seq, - failure: None, - } - .into()] + vec![ + ResolveRequestCancelExternalWorkflow { + seq: self.shared_state.seq, + failure: None, + } + .into(), + ] } CancelExternalCommand::Failed(f) => { let reason = match f { @@ -189,20 +191,22 @@ impl WFMachinesAdapter for CancelExternalMachine { CancelExternalWorkflowExecutionFailedCause::ExternalWorkflowExecutionNotFound | CancelExternalWorkflowExecutionFailedCause::NamespaceNotFound => "not found" }; - vec![ResolveRequestCancelExternalWorkflow { - seq: self.shared_state.seq, - failure: Some(Failure { - message: format!("Unable to cancel external workflow because {reason}"), - failure_info: Some(FailureInfo::ApplicationFailureInfo( - ApplicationFailureInfo { - r#type: f.to_string(), - ..Default::default() - }, - )), - ..Default::default() - }), - } - .into()] + vec![ + ResolveRequestCancelExternalWorkflow { + seq: self.shared_state.seq, + failure: Some(Failure { + message: format!("Unable to cancel external workflow because {reason}"), + failure_info: Some(FailureInfo::ApplicationFailureInfo( + ApplicationFailureInfo { + r#type: f.to_string(), + ..Default::default() + }, + )), + ..Default::default() + }), + } + .into(), + ] } }) } @@ -213,7 +217,7 @@ mod tests { use super::*; use crate::{ replay::TestHistoryBuilder, - test_help::{build_fake_sdk, MockPollCfg}, + test_help::{MockPollCfg, build_fake_sdk}, }; use temporal_sdk::{WfContext, WorkflowResult}; use temporal_sdk_core_protos::DEFAULT_WORKFLOW_TYPE; diff --git a/core/src/worker/workflow/machines/cancel_workflow_state_machine.rs b/core/src/worker/workflow/machines/cancel_workflow_state_machine.rs index 91b7e5625..2d08eb290 100644 --- a/core/src/worker/workflow/machines/cancel_workflow_state_machine.rs +++ b/core/src/worker/workflow/machines/cancel_workflow_state_machine.rs @@ -1,9 +1,9 @@ use super::{ - workflow_machines::MachineResponse, EventInfo, NewMachineWithCommand, OnEventWrapper, - WFMachinesAdapter, WFMachinesError, + EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError, + workflow_machines::MachineResponse, }; use crate::worker::workflow::machines::HistEventData; -use rustfsm::{fsm, StateMachine, TransitionResult}; +use rustfsm::{StateMachine, TransitionResult, fsm}; use std::convert::TryFrom; use temporal_sdk_core_protos::{ coresdk::workflow_commands::CancelWorkflowExecution, @@ -70,7 +70,7 @@ impl TryFrom for CancelWorkflowMachineEvents { _ => { return Err(WFMachinesError::Nondeterminism(format!( "Cancel workflow machine does not handle this event: {e}" - ))) + ))); } }) } @@ -100,12 +100,12 @@ impl WFMachinesAdapter for CancelWorkflowMachine { #[cfg(test)] mod tests { use super::*; - use crate::test_help::{build_fake_sdk, canned_histories, MockPollCfg}; + use crate::test_help::{MockPollCfg, build_fake_sdk, canned_histories}; use std::time::Duration; use temporal_sdk::{WfContext, WfExitValue, WorkflowResult}; use temporal_sdk_core_protos::{ - coresdk::workflow_activation::{workflow_activation_job, WorkflowActivationJob}, DEFAULT_WORKFLOW_TYPE, + coresdk::workflow_activation::{WorkflowActivationJob, workflow_activation_job}, }; use temporal_sdk_core_test_utils::interceptors::ActivationAssertionsInterceptor; diff --git a/core/src/worker/workflow/machines/child_workflow_state_machine.rs b/core/src/worker/workflow/machines/child_workflow_state_machine.rs index c44d805ac..f794cdd30 100644 --- a/core/src/worker/workflow/machines/child_workflow_state_machine.rs +++ b/core/src/worker/workflow/machines/child_workflow_state_machine.rs @@ -1,13 +1,13 @@ use super::{ - workflow_machines::MachineResponse, EventInfo, NewMachineWithCommand, OnEventWrapper, - WFMachinesAdapter, WFMachinesError, + EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError, + workflow_machines::MachineResponse, }; use crate::{ internal_flags::CoreInternalFlags, - worker::workflow::{machines::HistEventData, InternalFlagsRef}, + worker::workflow::{InternalFlagsRef, machines::HistEventData}, }; use itertools::Itertools; -use rustfsm::{fsm, MachineError, StateMachine, TransitionResult}; +use rustfsm::{MachineError, StateMachine, TransitionResult, fsm}; use std::{ convert::{TryFrom, TryInto}, string::ToString, @@ -15,31 +15,31 @@ use std::{ use temporal_sdk_core_protos::{ coresdk::{ child_workflow::{ - self as wfr, child_workflow_result::Status as ChildWorkflowStatus, - ChildWorkflowCancellationType, ChildWorkflowResult, + self as wfr, ChildWorkflowCancellationType, ChildWorkflowResult, + child_workflow_result::Status as ChildWorkflowStatus, }, workflow_activation::{ - resolve_child_workflow_execution_start, ResolveChildWorkflowExecution, - ResolveChildWorkflowExecutionStart, ResolveChildWorkflowExecutionStartCancelled, - ResolveChildWorkflowExecutionStartFailure, ResolveChildWorkflowExecutionStartSuccess, + ResolveChildWorkflowExecution, ResolveChildWorkflowExecutionStart, + ResolveChildWorkflowExecutionStartCancelled, ResolveChildWorkflowExecutionStartFailure, + ResolveChildWorkflowExecutionStartSuccess, resolve_child_workflow_execution_start, }, workflow_commands::StartChildWorkflowExecution, }, temporal::api::{ command::v1::{ - start_child_workflow_cmd_to_api, RequestCancelExternalWorkflowExecutionCommandAttributes, + start_child_workflow_cmd_to_api, }, common::v1::{Payload, Payloads, WorkflowExecution, WorkflowType}, enums::v1::{ CommandType, EventType, RetryState, StartChildWorkflowExecutionFailedCause, TimeoutType, }, - failure::v1::{self as failure, failure::FailureInfo, Failure}, + failure::v1::{self as failure, Failure, failure::FailureInfo}, history::v1::{ - history_event, ChildWorkflowExecutionCompletedEventAttributes, + ChildWorkflowExecutionCompletedEventAttributes, ChildWorkflowExecutionFailedEventAttributes, ChildWorkflowExecutionStartedEventAttributes, - StartChildWorkflowExecutionFailedEventAttributes, + StartChildWorkflowExecutionFailedEventAttributes, history_event, }, }, }; @@ -626,7 +626,7 @@ impl TryFrom for ChildWorkflowMachineEvents { _ => { return Err(WFMachinesError::Nondeterminism(format!( "Child workflow machine does not handle this event: {e:?}" - ))) + ))); } }) } @@ -640,59 +640,69 @@ impl WFMachinesAdapter for ChildWorkflowMachine { ) -> Result, WFMachinesError> { Ok(match my_command { ChildWorkflowCommand::Start(we) => { - vec![ResolveChildWorkflowExecutionStart { - seq: self.shared_state.lang_sequence_number, - status: Some(resolve_child_workflow_execution_start::Status::Succeeded( - ResolveChildWorkflowExecutionStartSuccess { run_id: we.run_id }, - )), - } - .into()] + vec![ + ResolveChildWorkflowExecutionStart { + seq: self.shared_state.lang_sequence_number, + status: Some(resolve_child_workflow_execution_start::Status::Succeeded( + ResolveChildWorkflowExecutionStartSuccess { run_id: we.run_id }, + )), + } + .into(), + ] } ChildWorkflowCommand::StartFail(cause) => { - vec![ResolveChildWorkflowExecutionStart { - seq: self.shared_state.lang_sequence_number, - status: Some(resolve_child_workflow_execution_start::Status::Failed( - ResolveChildWorkflowExecutionStartFailure { - workflow_id: self.shared_state.workflow_id.clone(), - workflow_type: self.shared_state.workflow_type.clone(), - cause: cause as i32, - }, - )), - } - .into()] + vec![ + ResolveChildWorkflowExecutionStart { + seq: self.shared_state.lang_sequence_number, + status: Some(resolve_child_workflow_execution_start::Status::Failed( + ResolveChildWorkflowExecutionStartFailure { + workflow_id: self.shared_state.workflow_id.clone(), + workflow_type: self.shared_state.workflow_type.clone(), + cause: cause as i32, + }, + )), + } + .into(), + ] } ChildWorkflowCommand::StartCancel(failure) => { - vec![ResolveChildWorkflowExecutionStart { - seq: self.shared_state.lang_sequence_number, - status: Some(resolve_child_workflow_execution_start::Status::Cancelled( - ResolveChildWorkflowExecutionStartCancelled { - failure: Some(failure), - }, - )), - } - .into()] + vec![ + ResolveChildWorkflowExecutionStart { + seq: self.shared_state.lang_sequence_number, + status: Some(resolve_child_workflow_execution_start::Status::Cancelled( + ResolveChildWorkflowExecutionStartCancelled { + failure: Some(failure), + }, + )), + } + .into(), + ] } ChildWorkflowCommand::Complete(result) => { - vec![ResolveChildWorkflowExecution { - seq: self.shared_state.lang_sequence_number, - result: Some(ChildWorkflowResult { - status: Some(ChildWorkflowStatus::Completed(wfr::Success { - result: convert_payloads(event_info, result)?, - })), - }), - } - .into()] + vec![ + ResolveChildWorkflowExecution { + seq: self.shared_state.lang_sequence_number, + result: Some(ChildWorkflowResult { + status: Some(ChildWorkflowStatus::Completed(wfr::Success { + result: convert_payloads(event_info, result)?, + })), + }), + } + .into(), + ] } ChildWorkflowCommand::Fail(failure) => { - vec![ResolveChildWorkflowExecution { - seq: self.shared_state.lang_sequence_number, - result: Some(ChildWorkflowResult { - status: Some(ChildWorkflowStatus::Failed(wfr::Failure { - failure: Some(failure), - })), - }), - } - .into()] + vec![ + ResolveChildWorkflowExecution { + seq: self.shared_state.lang_sequence_number, + result: Some(ChildWorkflowResult { + status: Some(ChildWorkflowStatus::Failed(wfr::Failure { + failure: Some(failure), + })), + }), + } + .into(), + ] } ChildWorkflowCommand::Cancel => { vec![self.resolve_cancelled_msg().into()] @@ -775,19 +785,19 @@ mod test { use crate::{ internal_flags::InternalFlags, replay::TestHistoryBuilder, - test_help::{build_fake_sdk, canned_histories, MockPollCfg}, + test_help::{MockPollCfg, build_fake_sdk, canned_histories}, }; use anyhow::anyhow; use rstest::{fixture, rstest}; use std::{cell::RefCell, mem::discriminant, rc::Rc}; use temporal_sdk::{CancellableFuture, ChildWorkflowOptions, WfContext, WorkflowResult}; use temporal_sdk_core_protos::{ + DEFAULT_WORKFLOW_TYPE, coresdk::{ child_workflow::child_workflow_result, workflow_activation::resolve_child_workflow_execution_start::Status as StartStatus, }, temporal::api::history::v1::StartChildWorkflowExecutionInitiatedEventAttributes, - DEFAULT_WORKFLOW_TYPE, }; #[derive(Clone, Copy)] diff --git a/core/src/worker/workflow/machines/complete_workflow_state_machine.rs b/core/src/worker/workflow/machines/complete_workflow_state_machine.rs index 319911333..073117349 100644 --- a/core/src/worker/workflow/machines/complete_workflow_state_machine.rs +++ b/core/src/worker/workflow/machines/complete_workflow_state_machine.rs @@ -1,9 +1,9 @@ use super::{ - workflow_machines::MachineResponse, EventInfo, NewMachineWithCommand, OnEventWrapper, - WFMachinesAdapter, WFMachinesError, + EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError, + workflow_machines::MachineResponse, }; use crate::worker::workflow::machines::HistEventData; -use rustfsm::{fsm, StateMachine, TransitionResult}; +use rustfsm::{StateMachine, TransitionResult, fsm}; use std::convert::TryFrom; use temporal_sdk_core_protos::{ coresdk::workflow_commands::CompleteWorkflowExecution, @@ -60,7 +60,7 @@ impl TryFrom for CompleteWorkflowMachineEvents { _ => { return Err(WFMachinesError::Nondeterminism(format!( "Complete workflow machine does not handle this event: {e}" - ))) + ))); } }) } diff --git a/core/src/worker/workflow/machines/continue_as_new_workflow_state_machine.rs b/core/src/worker/workflow/machines/continue_as_new_workflow_state_machine.rs index a218815e4..a7792b741 100644 --- a/core/src/worker/workflow/machines/continue_as_new_workflow_state_machine.rs +++ b/core/src/worker/workflow/machines/continue_as_new_workflow_state_machine.rs @@ -3,7 +3,7 @@ use super::{ WFMachinesError, }; use crate::worker::workflow::machines::HistEventData; -use rustfsm::{fsm, StateMachine, TransitionResult}; +use rustfsm::{StateMachine, TransitionResult, fsm}; use std::convert::TryFrom; use temporal_sdk_core_protos::{ coresdk::workflow_commands::ContinueAsNewWorkflowExecution, @@ -76,7 +76,7 @@ impl TryFrom for ContinueAsNewWorkflowMachineEvents { _ => { return Err(WFMachinesError::Nondeterminism(format!( "Continue as new workflow machine does not handle this event: {e}" - ))) + ))); } }) } @@ -108,7 +108,7 @@ impl WFMachinesAdapter for ContinueAsNewWorkflowMachine { #[cfg(test)] mod tests { use super::*; - use crate::test_help::{build_fake_sdk, canned_histories, MockPollCfg}; + use crate::test_help::{MockPollCfg, build_fake_sdk, canned_histories}; use std::time::Duration; use temporal_sdk::{WfContext, WfExitValue, WorkflowResult}; use temporal_sdk_core_protos::DEFAULT_WORKFLOW_TYPE; diff --git a/core/src/worker/workflow/machines/fail_workflow_state_machine.rs b/core/src/worker/workflow/machines/fail_workflow_state_machine.rs index 2ffaae6ff..a8e58c30e 100644 --- a/core/src/worker/workflow/machines/fail_workflow_state_machine.rs +++ b/core/src/worker/workflow/machines/fail_workflow_state_machine.rs @@ -1,9 +1,9 @@ use super::{ - workflow_machines::MachineResponse, EventInfo, NewMachineWithCommand, OnEventWrapper, - WFMachinesAdapter, WFMachinesError, + EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError, + workflow_machines::MachineResponse, }; use crate::worker::workflow::machines::HistEventData; -use rustfsm::{fsm, StateMachine, TransitionResult}; +use rustfsm::{StateMachine, TransitionResult, fsm}; use std::convert::TryFrom; use temporal_sdk_core_protos::{ coresdk::workflow_commands::FailWorkflowExecution, @@ -87,7 +87,7 @@ impl TryFrom for FailWorkflowMachineEvents { _ => { return Err(WFMachinesError::Nondeterminism(format!( "Fail workflow machine does not handle this event: {e}" - ))) + ))); } }) } diff --git a/core/src/worker/workflow/machines/local_activity_state_machine.rs b/core/src/worker/workflow/machines/local_activity_state_machine.rs index 378194470..924fe47ae 100644 --- a/core/src/worker/workflow/machines/local_activity_state_machine.rs +++ b/core/src/worker/workflow/machines/local_activity_state_machine.rs @@ -1,20 +1,20 @@ use super::{ - workflow_machines::MachineResponse, EventInfo, OnEventWrapper, WFMachinesAdapter, - WFMachinesError, + EventInfo, OnEventWrapper, WFMachinesAdapter, WFMachinesError, + workflow_machines::MachineResponse, }; use crate::{ internal_flags::CoreInternalFlags, protosext::{CompleteLocalActivityData, HistoryEventExt, ValidScheduleLA}, worker::{ + LocalActivityExecutionResult, workflow::{ - machines::{activity_state_machine::activity_fail_info, HistEventData}, InternalFlagsRef, + machines::{HistEventData, activity_state_machine::activity_fail_info}, }, - LocalActivityExecutionResult, }, }; use itertools::Itertools; -use rustfsm::{fsm, MachineError, StateMachine, TransitionResult}; +use rustfsm::{MachineError, StateMachine, TransitionResult, fsm}; use std::{ convert::TryFrom, time::{Duration, SystemTime}, @@ -31,9 +31,9 @@ use temporal_sdk_core_protos::{ workflow_commands::ActivityCancellationType, }, temporal::api::{ - command::v1::{command, RecordMarkerCommandAttributes}, + command::v1::{RecordMarkerCommandAttributes, command}, enums::v1::{CommandType, EventType, RetryState}, - failure::v1::{failure::FailureInfo, Failure}, + failure::v1::{Failure, failure::FailureInfo}, }, utilities::TryIntoOrNone, }; @@ -866,7 +866,7 @@ mod tests { use super::*; use crate::{ replay::TestHistoryBuilder, - test_help::{build_fake_sdk, canned_histories, MockPollCfg, ResponseType}, + test_help::{MockPollCfg, ResponseType, build_fake_sdk, canned_histories}, }; use anyhow::anyhow; use rstest::rstest; @@ -879,14 +879,14 @@ mod tests { WorkflowResult, }; use temporal_sdk_core_protos::{ + DEFAULT_ACTIVITY_TYPE, DEFAULT_WORKFLOW_TYPE, coresdk::{ - workflow_activation::{workflow_activation_job, WorkflowActivationJob}, AsJsonPayloadExt, + workflow_activation::{WorkflowActivationJob, workflow_activation_job}, }, temporal::api::{ common::v1::RetryPolicy, enums::v1::WorkflowTaskFailedCause, failure::v1::Failure, }, - DEFAULT_ACTIVITY_TYPE, DEFAULT_WORKFLOW_TYPE, }; use temporal_sdk_core_test_utils::interceptors::ActivationAssertionsInterceptor; use tokio_util::sync::CancellationToken; diff --git a/core/src/worker/workflow/machines/modify_workflow_properties_state_machine.rs b/core/src/worker/workflow/machines/modify_workflow_properties_state_machine.rs index 781d21ae0..301558f74 100644 --- a/core/src/worker/workflow/machines/modify_workflow_properties_state_machine.rs +++ b/core/src/worker/workflow/machines/modify_workflow_properties_state_machine.rs @@ -1,9 +1,9 @@ -use super::{workflow_machines::MachineResponse, NewMachineWithCommand}; +use super::{NewMachineWithCommand, workflow_machines::MachineResponse}; use crate::worker::workflow::{ - machines::{EventInfo, HistEventData, WFMachinesAdapter}, WFMachinesError, + machines::{EventInfo, HistEventData, WFMachinesAdapter}, }; -use rustfsm::{fsm, StateMachine, TransitionResult}; +use rustfsm::{StateMachine, TransitionResult, fsm}; use temporal_sdk_core_protos::{ coresdk::workflow_commands::ModifyWorkflowProperties, temporal::api::enums::v1::{CommandType, EventType}, @@ -105,15 +105,15 @@ mod tests { use super::*; use crate::{ replay::TestHistoryBuilder, - test_help::{build_fake_sdk, MockPollCfg}, + test_help::{MockPollCfg, build_fake_sdk}, }; use temporal_sdk::WfContext; use temporal_sdk_core_protos::{ + DEFAULT_WORKFLOW_TYPE, temporal::api::{ - command::v1::{command, Command}, + command::v1::{Command, command}, common::v1::Payload, }, - DEFAULT_WORKFLOW_TYPE, }; #[tokio::test] diff --git a/core/src/worker/workflow/machines/nexus_operation_state_machine.rs b/core/src/worker/workflow/machines/nexus_operation_state_machine.rs index 5ab888657..3373b2a99 100644 --- a/core/src/worker/workflow/machines/nexus_operation_state_machine.rs +++ b/core/src/worker/workflow/machines/nexus_operation_state_machine.rs @@ -1,29 +1,29 @@ use crate::worker::workflow::{ + WFMachinesError, machines::{ - workflow_machines::MachineResponse, EventInfo, HistEventData, NewMachineWithCommand, - OnEventWrapper, WFMachinesAdapter, + EventInfo, HistEventData, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, + workflow_machines::MachineResponse, }, - WFMachinesError, }; use itertools::Itertools; -use rustfsm::{fsm, MachineError, StateMachine, TransitionResult}; +use rustfsm::{MachineError, StateMachine, TransitionResult, fsm}; use temporal_sdk_core_protos::{ coresdk::{ - nexus::{nexus_operation_result, NexusOperationResult}, + nexus::{NexusOperationResult, nexus_operation_result}, workflow_activation::{ - resolve_nexus_operation_start, ResolveNexusOperation, ResolveNexusOperationStart, + ResolveNexusOperation, ResolveNexusOperationStart, resolve_nexus_operation_start, }, workflow_commands::ScheduleNexusOperation, }, temporal::api::{ - command::v1::{command, RequestCancelNexusOperationCommandAttributes}, + command::v1::{RequestCancelNexusOperationCommandAttributes, command}, common::v1::Payload, enums::v1::{CommandType, EventType}, - failure::v1::{self as failure, failure::FailureInfo, Failure}, + failure::v1::{self as failure, Failure, failure::FailureInfo}, history::v1::{ - history_event, NexusOperationCanceledEventAttributes, - NexusOperationCompletedEventAttributes, NexusOperationFailedEventAttributes, - NexusOperationStartedEventAttributes, NexusOperationTimedOutEventAttributes, + NexusOperationCanceledEventAttributes, NexusOperationCompletedEventAttributes, + NexusOperationFailedEventAttributes, NexusOperationStartedEventAttributes, + NexusOperationTimedOutEventAttributes, history_event, }, }, }; @@ -399,7 +399,7 @@ impl TryFrom for NexusOperationMachineEvents { _ => { return Err(WFMachinesError::Nondeterminism(format!( "Nexus operation machine does not handle this event: {e:?}" - ))) + ))); } }) } @@ -413,13 +413,15 @@ impl WFMachinesAdapter for NexusOperationMachine { ) -> Result, WFMachinesError> { Ok(match my_command { NexusOperationCommand::Start { operation_id } => { - vec![ResolveNexusOperationStart { - seq: self.shared_state.lang_seq_num, - status: Some(resolve_nexus_operation_start::Status::OperationId( - operation_id, - )), - } - .into()] + vec![ + ResolveNexusOperationStart { + seq: self.shared_state.lang_seq_num, + status: Some(resolve_nexus_operation_start::Status::OperationId( + operation_id, + )), + } + .into(), + ] } NexusOperationCommand::CancelBeforeStart => { vec![ @@ -446,42 +448,50 @@ impl WFMachinesAdapter for NexusOperationMachine { ] } NexusOperationCommand::Complete(c) => { - vec![ResolveNexusOperation { - seq: self.shared_state.lang_seq_num, - result: Some(NexusOperationResult { - status: Some(nexus_operation_result::Status::Completed( - c.unwrap_or_default(), - )), - }), - } - .into()] + vec![ + ResolveNexusOperation { + seq: self.shared_state.lang_seq_num, + result: Some(NexusOperationResult { + status: Some(nexus_operation_result::Status::Completed( + c.unwrap_or_default(), + )), + }), + } + .into(), + ] } NexusOperationCommand::Fail(f) => { - vec![ResolveNexusOperation { - seq: self.shared_state.lang_seq_num, - result: Some(NexusOperationResult { - status: Some(nexus_operation_result::Status::Failed(f)), - }), - } - .into()] + vec![ + ResolveNexusOperation { + seq: self.shared_state.lang_seq_num, + result: Some(NexusOperationResult { + status: Some(nexus_operation_result::Status::Failed(f)), + }), + } + .into(), + ] } NexusOperationCommand::Cancel(f) => { - vec![ResolveNexusOperation { - seq: self.shared_state.lang_seq_num, - result: Some(NexusOperationResult { - status: Some(nexus_operation_result::Status::Cancelled(f)), - }), - } - .into()] + vec![ + ResolveNexusOperation { + seq: self.shared_state.lang_seq_num, + result: Some(NexusOperationResult { + status: Some(nexus_operation_result::Status::Cancelled(f)), + }), + } + .into(), + ] } NexusOperationCommand::TimedOut(f) => { - vec![ResolveNexusOperation { - seq: self.shared_state.lang_seq_num, - result: Some(NexusOperationResult { - status: Some(nexus_operation_result::Status::TimedOut(f)), - }), - } - .into()] + vec![ + ResolveNexusOperation { + seq: self.shared_state.lang_seq_num, + result: Some(NexusOperationResult { + status: Some(nexus_operation_result::Status::TimedOut(f)), + }), + } + .into(), + ] } NexusOperationCommand::IssueCancel => { vec![MachineResponse::IssueNewCommand( diff --git a/core/src/worker/workflow/machines/patch_state_machine.rs b/core/src/worker/workflow/machines/patch_state_machine.rs index b3e5c6f9b..bb361d3f3 100644 --- a/core/src/worker/workflow/machines/patch_state_machine.rs +++ b/core/src/worker/workflow/machines/patch_state_machine.rs @@ -18,28 +18,28 @@ //! | replaying, no marker | deprecate_patch | Call allowed | use super::{ - workflow_machines::MachineResponse, EventInfo, NewMachineWithCommand, OnEventWrapper, - WFMachinesAdapter, WFMachinesError, + EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError, + workflow_machines::MachineResponse, }; use crate::{ internal_flags::CoreInternalFlags, protosext::HistoryEventExt, worker::workflow::{ + InternalFlagsRef, machines::{ - upsert_search_attributes_state_machine::MAX_SEARCH_ATTR_PAYLOAD_SIZE, HistEventData, + HistEventData, upsert_search_attributes_state_machine::MAX_SEARCH_ATTR_PAYLOAD_SIZE, }, - InternalFlagsRef, }, }; use anyhow::Context; -use rustfsm::{fsm, StateMachine, TransitionResult}; +use rustfsm::{StateMachine, TransitionResult, fsm}; use std::{ collections::{BTreeSet, HashMap}, convert::TryFrom, }; use temporal_sdk_core_protos::{ constants::PATCH_MARKER_NAME, - coresdk::{common::build_has_change_marker_details, AsJsonPayloadExt}, + coresdk::{AsJsonPayloadExt, common::build_has_change_marker_details}, temporal::api::{ command::v1::{ RecordMarkerCommandAttributes, UpsertWorkflowSearchAttributesCommandAttributes, @@ -270,27 +270,27 @@ mod tests { use crate::{ internal_flags::CoreInternalFlags, replay::TestHistoryBuilder, - test_help::{build_fake_sdk, MockPollCfg, ResponseType}, + test_help::{MockPollCfg, ResponseType, build_fake_sdk}, worker::workflow::machines::patch_state_machine::VERSION_SEARCH_ATTR_KEY, }; use rstest::rstest; use std::{ - collections::{hash_map::RandomState, HashSet, VecDeque}, + collections::{HashSet, VecDeque, hash_map::RandomState}, time::Duration, }; use temporal_sdk::{ActivityOptions, WfContext}; use temporal_sdk_core_protos::{ + DEFAULT_WORKFLOW_TYPE, constants::PATCH_MARKER_NAME, coresdk::{ - common::decode_change_marker_details, - workflow_activation::{workflow_activation_job, NotifyHasPatch, WorkflowActivationJob}, AsJsonPayloadExt, FromJsonPayloadExt, + common::decode_change_marker_details, + workflow_activation::{NotifyHasPatch, WorkflowActivationJob, workflow_activation_job}, }, temporal::api::{ command::v1::{ - command::Attributes, RecordMarkerCommandAttributes, - ScheduleActivityTaskCommandAttributes, - UpsertWorkflowSearchAttributesCommandAttributes, + RecordMarkerCommandAttributes, ScheduleActivityTaskCommandAttributes, + UpsertWorkflowSearchAttributesCommandAttributes, command::Attributes, }, common::v1::ActivityType, enums::v1::{CommandType, EventType}, @@ -299,7 +299,6 @@ mod tests { ActivityTaskStartedEventAttributes, TimerFiredEventAttributes, }, }, - DEFAULT_WORKFLOW_TYPE, }; use temporal_sdk_core_test_utils::interceptors::ActivationAssertionsInterceptor; diff --git a/core/src/worker/workflow/machines/signal_external_state_machine.rs b/core/src/worker/workflow/machines/signal_external_state_machine.rs index 9ab1ae75d..08e084c5f 100644 --- a/core/src/worker/workflow/machines/signal_external_state_machine.rs +++ b/core/src/worker/workflow/machines/signal_external_state_machine.rs @@ -1,24 +1,24 @@ use super::{ - workflow_machines::MachineResponse, EventInfo, NewMachineWithCommand, OnEventWrapper, - WFMachinesAdapter, WFMachinesError, + EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError, + workflow_machines::MachineResponse, }; use crate::worker::workflow::machines::HistEventData; -use rustfsm::{fsm, MachineError, StateMachine, TransitionResult}; +use rustfsm::{MachineError, StateMachine, TransitionResult, fsm}; use std::convert::TryFrom; use temporal_sdk_core_protos::{ coresdk::{ + IntoPayloadsExt, common::NamespacedWorkflowExecution, workflow_activation::ResolveSignalExternalWorkflow, workflow_commands::{ - signal_external_workflow_execution as sig_we, SignalExternalWorkflowExecution, + SignalExternalWorkflowExecution, signal_external_workflow_execution as sig_we, }, - IntoPayloadsExt, }, temporal::api::{ - command::v1::{command, SignalExternalWorkflowExecutionCommandAttributes}, + command::v1::{SignalExternalWorkflowExecutionCommandAttributes, command}, common::v1::WorkflowExecution as UpstreamWE, enums::v1::{CommandType, EventType, SignalExternalWorkflowExecutionFailedCause}, - failure::v1::{failure::FailureInfo, ApplicationFailureInfo, CanceledFailureInfo, Failure}, + failure::v1::{ApplicationFailureInfo, CanceledFailureInfo, Failure, failure::FailureInfo}, history::v1::history_event, }, }; @@ -73,7 +73,7 @@ pub(super) fn new_external_signal( None => { return Err(WFMachinesError::Fatal( "Signal external workflow command had empty target field".to_string(), - )) + )); } Some(sig_we::Target::ChildWorkflowId(wfid)) => ( NamespacedWorkflowExecution { @@ -205,7 +205,7 @@ impl TryFrom for SignalExternalMachineEvents { _ => { return Err(WFMachinesError::Nondeterminism(format!( "Signal external WF machine does not handle this event: {e}" - ))) + ))); } }) } @@ -219,11 +219,13 @@ impl WFMachinesAdapter for SignalExternalMachine { ) -> Result, WFMachinesError> { Ok(match my_command { SignalExternalCommand::Signaled => { - vec![ResolveSignalExternalWorkflow { - seq: self.shared_state.seq, - failure: None, - } - .into()] + vec![ + ResolveSignalExternalWorkflow { + seq: self.shared_state.seq, + failure: None, + } + .into(), + ] } SignalExternalCommand::Failed(f) => { let reason = match f { @@ -235,21 +237,23 @@ impl WFMachinesAdapter for SignalExternalMachine { "The per-workflow signal limit was exceeded" } }; - vec![ResolveSignalExternalWorkflow { - seq: self.shared_state.seq, - // TODO: Create new failure type upstream for this - failure: Some(Failure { - message: format!("Unable to signal external workflow because {reason}"), - failure_info: Some(FailureInfo::ApplicationFailureInfo( - ApplicationFailureInfo { - r#type: f.to_string(), - ..Default::default() - }, - )), - ..Default::default() - }), - } - .into()] + vec![ + ResolveSignalExternalWorkflow { + seq: self.shared_state.seq, + // TODO: Create new failure type upstream for this + failure: Some(Failure { + message: format!("Unable to signal external workflow because {reason}"), + failure_info: Some(FailureInfo::ApplicationFailureInfo( + ApplicationFailureInfo { + r#type: f.to_string(), + ..Default::default() + }, + )), + ..Default::default() + }), + } + .into(), + ] } SignalExternalCommand::Cancelled => { panic!("Cancelled command not expected as part of non-cancel transition") @@ -264,17 +268,19 @@ impl SignalExternalMachine { let mut ret = vec![]; match res.first() { Some(SignalExternalCommand::Cancelled) => { - ret = vec![ResolveSignalExternalWorkflow { - seq: self.shared_state.seq, - failure: Some(Failure { - message: SIG_CANCEL_MSG.to_string(), - failure_info: Some(FailureInfo::CanceledFailureInfo(CanceledFailureInfo { - details: None, - })), - ..Default::default() - }), - } - .into()]; + ret = vec![ + ResolveSignalExternalWorkflow { + seq: self.shared_state.seq, + failure: Some(Failure { + message: SIG_CANCEL_MSG.to_string(), + failure_info: Some(FailureInfo::CanceledFailureInfo( + CanceledFailureInfo { details: None }, + )), + ..Default::default() + }), + } + .into(), + ]; } Some(_) => panic!("Signal external machine cancel produced unexpected result"), None => (), @@ -294,14 +300,14 @@ mod tests { use super::*; use crate::{ replay::TestHistoryBuilder, - test_help::{build_fake_sdk, MockPollCfg}, + test_help::{MockPollCfg, build_fake_sdk}, }; use std::mem::discriminant; use temporal_sdk::{CancellableFuture, SignalWorkflowOptions, WfContext, WorkflowResult}; use temporal_sdk_core_protos::{ - coresdk::workflow_activation::{workflow_activation_job, WorkflowActivationJob}, - temporal::api::command::v1::Command, DEFAULT_WORKFLOW_TYPE, + coresdk::workflow_activation::{WorkflowActivationJob, workflow_activation_job}, + temporal::api::command::v1::Command, }; use temporal_sdk_core_test_utils::interceptors::ActivationAssertionsInterceptor; diff --git a/core/src/worker/workflow/machines/timer_state_machine.rs b/core/src/worker/workflow/machines/timer_state_machine.rs index 658af51f0..27777813a 100644 --- a/core/src/worker/workflow/machines/timer_state_machine.rs +++ b/core/src/worker/workflow/machines/timer_state_machine.rs @@ -1,22 +1,22 @@ #![allow(clippy::large_enum_variant)] use super::{ - workflow_machines::MachineResponse, EventInfo, NewMachineWithCommand, OnEventWrapper, - WFMachinesAdapter, + EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, + workflow_machines::MachineResponse, }; -use crate::worker::workflow::{machines::HistEventData, WFMachinesError}; -use rustfsm::{fsm, MachineError, StateMachine, TransitionResult}; +use crate::worker::workflow::{WFMachinesError, machines::HistEventData}; +use rustfsm::{MachineError, StateMachine, TransitionResult, fsm}; use std::convert::TryFrom; use temporal_sdk_core_protos::{ coresdk::{ + HistoryEventId, workflow_activation::FireTimer, workflow_commands::{CancelTimer, StartTimer}, - HistoryEventId, }, temporal::api::{ command::v1::command, enums::v1::{CommandType, EventType}, - history::v1::{history_event, TimerFiredEventAttributes}, + history::v1::{TimerFiredEventAttributes, history_event}, }, }; @@ -129,7 +129,7 @@ impl TryFrom for TimerMachineEvents { _ => { return Err(WFMachinesError::Nondeterminism(format!( "Timer machine does not handle this event: {e}" - ))) + ))); } }) } @@ -237,10 +237,12 @@ impl WFMachinesAdapter for TimerMachine { ) -> Result, WFMachinesError> { Ok(match my_command { // Fire the completion - TimerMachineCommand::Complete => vec![FireTimer { - seq: self.shared_state.attrs.seq, - } - .into()], + TimerMachineCommand::Complete => vec![ + FireTimer { + seq: self.shared_state.attrs.seq, + } + .into(), + ], TimerMachineCommand::IssueCancelCmd(c) => { vec![MachineResponse::IssueNewCommand(c.into())] } @@ -253,13 +255,13 @@ mod test { use super::*; use crate::{ replay::TestHistoryBuilder, - test_help::{build_fake_sdk, canned_histories, MockPollCfg}, + test_help::{MockPollCfg, build_fake_sdk, canned_histories}, }; use std::{mem::discriminant, time::Duration}; use temporal_sdk::{CancellableFuture, WfContext, WorkflowResult}; use temporal_sdk_core_protos::{ - temporal::api::{enums::v1::WorkflowTaskFailedCause, failure::v1::Failure}, DEFAULT_WORKFLOW_TYPE, + temporal::api::{enums::v1::WorkflowTaskFailedCause, failure::v1::Failure}, }; async fn happy_timer(ctx: WfContext) -> WorkflowResult<()> { diff --git a/core/src/worker/workflow/machines/transition_coverage.rs b/core/src/worker/workflow/machines/transition_coverage.rs index a40ebd2f2..52900ed72 100644 --- a/core/src/worker/workflow/machines/transition_coverage.rs +++ b/core/src/worker/workflow/machines/transition_coverage.rs @@ -3,13 +3,13 @@ //! in stable Rust. Don't do the things in here. They're bad. This is test only code, and should //! never ever be removed from behind `#[cfg(test)]` compilation. -use dashmap::{mapref::entry::Entry, DashMap, DashSet}; +use dashmap::{DashMap, DashSet, mapref::entry::Entry}; use std::sync::LazyLock; use std::{ path::PathBuf, sync::{ - mpsc::{sync_channel, SyncSender}, Mutex, + mpsc::{SyncSender, sync_channel}, }, thread::JoinHandle, time::Duration, diff --git a/core/src/worker/workflow/machines/update_state_machine.rs b/core/src/worker/workflow/machines/update_state_machine.rs index 61ec8d2ca..9c8a5382c 100644 --- a/core/src/worker/workflow/machines/update_state_machine.rs +++ b/core/src/worker/workflow/machines/update_state_machine.rs @@ -1,25 +1,25 @@ -use super::{workflow_machines::MachineResponse, EventInfo, WFMachinesAdapter, WFMachinesError}; +use super::{EventInfo, WFMachinesAdapter, WFMachinesError, workflow_machines::MachineResponse}; use crate::{ protosext::protocol_messages::UpdateRequest, worker::workflow::machines::{HistEventData, NewMachineWithResponse}, }; use itertools::Itertools; use prost::EncodeError; -use rustfsm::{fsm, MachineError, StateMachine, TransitionResult}; +use rustfsm::{MachineError, StateMachine, TransitionResult, fsm}; use std::convert::TryFrom; use temporal_sdk_core_protos::{ coresdk::{ workflow_activation::DoUpdate, - workflow_commands::{update_response, UpdateResponse}, + workflow_commands::{UpdateResponse, update_response}, }, temporal::api::{ - command::v1::{command, ProtocolMessageCommandAttributes}, + command::v1::{ProtocolMessageCommandAttributes, command}, common::v1::Payload, enums::v1::{CommandType, EventType}, failure::v1::Failure, protocol::v1::Message as ProtocolMessage, update, - update::v1::{outcome, Acceptance, Outcome, Rejection, Response}, + update::v1::{Acceptance, Outcome, Rejection, Response, outcome}, }, utilities::pack_any, }; @@ -122,7 +122,7 @@ impl UpdateMachine { return Err(WFMachinesError::Fatal(format!( "Update response for update {} had an empty result, this is a lang layer bug.", &self.shared_state.meta.update_id - ))) + ))); } Some(update_response::Response::Accepted(_)) => { self.on_event(UpdateMachineEvents::Accept) @@ -223,7 +223,7 @@ impl TryFrom for UpdateMachineEvents { _ => { return Err(WFMachinesError::Nondeterminism(format!( "Update machine does not handle this event: {e}" - ))) + ))); } }) } diff --git a/core/src/worker/workflow/machines/upsert_search_attributes_state_machine.rs b/core/src/worker/workflow/machines/upsert_search_attributes_state_machine.rs index 840ea0de0..5d3309e06 100644 --- a/core/src/worker/workflow/machines/upsert_search_attributes_state_machine.rs +++ b/core/src/worker/workflow/machines/upsert_search_attributes_state_machine.rs @@ -1,19 +1,19 @@ -use super::{workflow_machines::MachineResponse, NewMachineWithCommand}; +use super::{NewMachineWithCommand, workflow_machines::MachineResponse}; use crate::{ internal_flags::CoreInternalFlags, worker::workflow::{ + InternalFlagsRef, WFMachinesError, machines::{ - patch_state_machine::VERSION_SEARCH_ATTR_KEY, EventInfo, HistEventData, - WFMachinesAdapter, + EventInfo, HistEventData, WFMachinesAdapter, + patch_state_machine::VERSION_SEARCH_ATTR_KEY, }, - InternalFlagsRef, WFMachinesError, }, }; -use rustfsm::{fsm, StateMachine, TransitionResult}; +use rustfsm::{StateMachine, TransitionResult, fsm}; use temporal_sdk_core_protos::{ coresdk::workflow_commands::UpsertWorkflowSearchAttributes, temporal::api::{ - command::v1::{command, UpsertWorkflowSearchAttributesCommandAttributes}, + command::v1::{UpsertWorkflowSearchAttributesCommandAttributes, command}, common::v1::SearchAttributes, enums::v1::CommandType, history::v1::history_event, @@ -181,7 +181,7 @@ mod tests { use super::{super::OnEventWrapper, *}; use crate::{ replay::TestHistoryBuilder, - test_help::{build_fake_sdk, build_mock_pollers, mock_worker, MockPollCfg, ResponseType}, + test_help::{MockPollCfg, ResponseType, build_fake_sdk, build_mock_pollers, mock_worker}, worker::{ client::mocks::mock_workflow_client, workflow::machines::patch_state_machine::VERSION_SEARCH_ATTR_KEY, @@ -192,19 +192,19 @@ mod tests { use temporal_sdk::WfContext; use temporal_sdk_core_api::Worker; use temporal_sdk_core_protos::{ + DEFAULT_WORKFLOW_TYPE, coresdk::{ - workflow_activation::{workflow_activation_job, WorkflowActivationJob}, + AsJsonPayloadExt, + workflow_activation::{WorkflowActivationJob, workflow_activation_job}, workflow_commands::SetPatchMarker, workflow_completion::WorkflowActivationCompletion, - AsJsonPayloadExt, }, temporal::api::{ - command::v1::{command::Attributes, Command}, + command::v1::{Command, command::Attributes}, common::v1::Payload, enums::v1::EventType, history::v1::{HistoryEvent, UpsertWorkflowSearchAttributesEventAttributes}, }, - DEFAULT_WORKFLOW_TYPE, }; use temporal_sdk_core_test_utils::WorkerTestHelpers; @@ -361,11 +361,13 @@ mod tests { ); let act = core.poll_workflow_activation().await.unwrap(); let mut cmds = if with_patched_cmd { - vec![SetPatchMarker { - patch_id, - deprecated: false, - } - .into()] + vec![ + SetPatchMarker { + patch_id, + deprecated: false, + } + .into(), + ] } else { vec![] }; diff --git a/core/src/worker/workflow/machines/workflow_machines.rs b/core/src/worker/workflow/machines/workflow_machines.rs index ca2fbf71b..a06132cd5 100644 --- a/core/src/worker/workflow/machines/workflow_machines.rs +++ b/core/src/worker/workflow/machines/workflow_machines.rs @@ -1,6 +1,7 @@ mod local_acts; use super::{ + Machines, NewMachineWithCommand, TemporalStateMachine, cancel_external_state_machine::new_external_cancel, cancel_workflow_state_machine::cancel_workflow, complete_workflow_state_machine::complete_workflow, @@ -9,34 +10,32 @@ use super::{ patch_state_machine::has_change, signal_external_state_machine::new_external_signal, timer_state_machine::new_timer, upsert_search_attributes_state_machine::upsert_search_attrs, workflow_machines::local_acts::LocalActivityData, - workflow_task_state_machine::WorkflowTaskMachine, Machines, NewMachineWithCommand, - TemporalStateMachine, + workflow_task_state_machine::WorkflowTaskMachine, }; use crate::{ abstractions::dbg_panic, internal_flags::{CoreInternalFlags, InternalFlags}, protosext::{ - protocol_messages::{IncomingProtocolMessage, IncomingProtocolMessageBody}, CompleteLocalActivityData, HistoryEventExt, ValidScheduleLA, + protocol_messages::{IncomingProtocolMessage, IncomingProtocolMessageBody}, }, - telemetry::{metrics::MetricsContext, VecDisplayer}, + telemetry::{VecDisplayer, metrics::MetricsContext}, worker::{ + ExecutingLAId, LocalActRequest, LocalActivityExecutionResult, LocalActivityResolution, workflow::{ + CommandID, DrivenWorkflow, HistoryUpdate, InternalFlagsRef, LocalResolution, + OutgoingJob, RunBasics, WFCommand, WFCommandVariant, WFMachinesError, + WorkflowStartedInfo, history_update::NextWFT, machines::{ - activity_state_machine::ActivityMachine, + HistEventData, activity_state_machine::ActivityMachine, child_workflow_state_machine::ChildWorkflowMachine, modify_workflow_properties_state_machine::modify_workflow_properties, nexus_operation_state_machine::NexusOperationMachine, patch_state_machine::VERSION_SEARCH_ATTR_KEY, update_state_machine::UpdateMachine, upsert_search_attributes_state_machine::upsert_search_attrs_internal, - HistEventData, }, - CommandID, DrivenWorkflow, HistoryUpdate, InternalFlagsRef, LocalResolution, - OutgoingJob, RunBasics, WFCommand, WFCommandVariant, WFMachinesError, - WorkflowStartedInfo, }, - ExecutingLAId, LocalActRequest, LocalActivityExecutionResult, LocalActivityResolution, }, }; use anyhow::Context; @@ -58,17 +57,17 @@ use temporal_sdk_core_protos::{ common::{NamespacedWorkflowExecution, VersioningIntent}, workflow_activation, workflow_activation::{ - workflow_activation_job, NotifyHasPatch, UpdateRandomSeed, WorkflowActivation, + NotifyHasPatch, UpdateRandomSeed, WorkflowActivation, workflow_activation_job, }, workflow_commands::ContinueAsNewWorkflowExecution, }, temporal::api::{ command::v1::{ - command::Attributes as ProtoCmdAttrs, Command as ProtoCommand, CommandAttributesExt, + Command as ProtoCommand, CommandAttributesExt, command::Attributes as ProtoCmdAttrs, }, enums::v1::EventType, - history::v1::{history_event, HistoryEvent}, - protocol::v1::{message::SequencingId, Message as ProtocolMessage}, + history::v1::{HistoryEvent, history_event}, + protocol::v1::{Message as ProtocolMessage, message::SequencingId}, sdk::v1::{UserMetadata, WorkflowTaskCompletedMetadata}, }, }; @@ -241,7 +240,7 @@ where macro_rules! cancel_machine { ($self:expr, $cmd_id:expr, $machine_variant:ident, $cancel_method:ident $(, $args:expr )* $(,)?) => {{ let m_key = $self.get_machine_key($cmd_id)?; - let machine = if let Machines::$machine_variant(ref mut m) = $self.machine_mut(m_key) { + let machine = if let Machines::$machine_variant(m) = $self.machine_mut(m_key) { m } else { return Err(WFMachinesError::Nondeterminism(format!( @@ -1029,7 +1028,7 @@ impl WorkflowMachines { } fn set_current_time(&mut self, time: SystemTime) -> SystemTime { - if self.current_wf_time.map_or(true, |t| t < time) { + if self.current_wf_time.is_none_or(|t| t < time) { self.current_wf_time = Some(time); } self.current_wf_time @@ -1190,8 +1189,8 @@ impl WorkflowMachines { } c => { return Err(WFMachinesError::Fatal(format!( - "A machine requested to create a new command of an unsupported type: {c:?}" - ))) + "A machine requested to create a new command of an unsupported type: {c:?}" + ))); } }, MachineResponse::IssueFakeLocalActivityMarker(seq) => { @@ -1213,7 +1212,9 @@ impl WorkflowMachines { let more_responses = lam.try_resolve_with_dat(preres)?; self.process_machine_responses(smk, more_responses)?; } else { - panic!("A non local-activity machine returned a request cancel LA response"); + panic!( + "A non local-activity machine returned a request cancel LA response" + ); } } // If it's in the request queue, just rip it out. @@ -1231,7 +1232,9 @@ impl WorkflowMachines { )?; self.process_machine_responses(smk, more_responses)?; } else { - panic!("A non local-activity machine returned a request cancel LA response"); + panic!( + "A non local-activity machine returned a request cancel LA response" + ); } } else { // Finally, if we know about the LA at all, it's currently running, so diff --git a/core/src/worker/workflow/machines/workflow_task_state_machine.rs b/core/src/worker/workflow/machines/workflow_task_state_machine.rs index 7e6c4933d..08eb92612 100644 --- a/core/src/worker/workflow/machines/workflow_task_state_machine.rs +++ b/core/src/worker/workflow/machines/workflow_task_state_machine.rs @@ -1,8 +1,8 @@ #![allow(clippy::enum_variant_names)] -use super::{workflow_machines::MachineResponse, EventInfo, WFMachinesAdapter, WFMachinesError}; +use super::{EventInfo, WFMachinesAdapter, WFMachinesError, workflow_machines::MachineResponse}; use crate::worker::workflow::machines::HistEventData; -use rustfsm::{fsm, StateMachine, TransitionResult}; +use rustfsm::{StateMachine, TransitionResult, fsm}; use std::{ convert::{TryFrom, TryInto}, time::SystemTime, @@ -103,7 +103,7 @@ impl TryFrom for WorkflowTaskMachineEvents { return Err(WFMachinesError::Fatal( "Workflow task started event timestamp was inconvertible" .to_string(), - )) + )); } } } else { @@ -143,7 +143,7 @@ impl TryFrom for WorkflowTaskMachineEvents { _ => { return Err(WFMachinesError::Nondeterminism(format!( "Event does not apply to a wf task machine: {e}" - ))) + ))); } }) } diff --git a/core/src/worker/workflow/managed_run.rs b/core/src/worker/workflow/managed_run.rs index 4b4f87010..dd6a550fe 100644 --- a/core/src/worker/workflow/managed_run.rs +++ b/core/src/worker/workflow/managed_run.rs @@ -1,23 +1,23 @@ use crate::{ + MetricsContext, abstractions::dbg_panic, internal_flags::CoreInternalFlags, - protosext::{protocol_messages::IncomingProtocolMessage, WorkflowActivationExt}, + protosext::{WorkflowActivationExt, protocol_messages::IncomingProtocolMessage}, telemetry::metrics, worker::{ + LEGACY_QUERY_ID, LocalActRequest, workflow::{ - history_update::HistoryPaginator, - machines::{MachinesWFTResponseContent, WorkflowMachines}, ActivationAction, ActivationCompleteOutcome, ActivationCompleteResult, ActivationOrAuto, BufferedTasks, DrivenWorkflow, EvictionRequestResult, FailedActivationWFTReport, HeartbeatTimeoutMsg, HistoryUpdate, LocalActivityRequestSink, LocalResolution, NextPageReq, OutstandingActivation, OutstandingTask, PermittedWFT, RequestEvictMsg, RunBasics, ServerCommandsWithWorkflowInfo, WFCommand, WFCommandVariant, WFMachinesError, - WFTReportStatus, WorkflowTaskInfo, WFT_HEARTBEAT_TIMEOUT_FRACTION, + WFT_HEARTBEAT_TIMEOUT_FRACTION, WFTReportStatus, WorkflowTaskInfo, + history_update::HistoryPaginator, + machines::{MachinesWFTResponseContent, WorkflowMachines}, }, - LocalActRequest, LEGACY_QUERY_ID, }, - MetricsContext, }; use futures_util::future::AbortHandle; use std::{ @@ -25,15 +25,16 @@ use std::{ mem, ops::Add, rc::Rc, - sync::{mpsc::Sender, Arc}, + sync::{Arc, mpsc::Sender}, time::{Duration, Instant}, }; use temporal_sdk_core_api::{errors::WorkflowErrorType, worker::WorkerConfig}; use temporal_sdk_core_protos::{ + TaskToken, coresdk::{ workflow_activation::{ - create_evict_activation, query_to_job, remove_from_cache::EvictionReason, - workflow_activation_job, WorkflowActivation, + WorkflowActivation, create_evict_activation, query_to_job, + remove_from_cache::EvictionReason, workflow_activation_job, }, workflow_commands::{FailWorkflowExecution, QueryResult}, workflow_completion, @@ -42,7 +43,6 @@ use temporal_sdk_core_protos::{ command::v1::command::Attributes as CmdAttribs, enums::v1::WorkflowTaskFailedCause, failure::v1::Failure, }, - TaskToken, }; use tokio::sync::oneshot; use tracing::Span; @@ -1507,7 +1507,7 @@ impl From for RunUpdateErr { #[cfg(test)] mod tests { use crate::worker::workflow::{WFCommand, WFCommandVariant}; - use std::mem::{discriminant, Discriminant}; + use std::mem::{Discriminant, discriminant}; use command_utils::*; diff --git a/core/src/worker/workflow/mod.rs b/core/src/worker/workflow/mod.rs index 10c6c0a98..d82189503 100644 --- a/core/src/worker/workflow/mod.rs +++ b/core/src/worker/workflow/mod.rs @@ -15,15 +15,18 @@ pub(crate) use driven_workflow::DrivenWorkflow; pub(crate) use history_update::HistoryUpdate; use crate::{ + MetricsContext, abstractions::{ - dbg_panic, take_cell::TakeCell, MeteredPermitDealer, TrackedOwnedMeteredSemPermit, - UsedMeteredSemPermit, + MeteredPermitDealer, TrackedOwnedMeteredSemPermit, UsedMeteredSemPermit, dbg_panic, + take_cell::TakeCell, }, internal_flags::InternalFlags, pollers::TrackedPermittedTqResp, protosext::{legacy_query_failure, protocol_messages::IncomingProtocolMessage}, - telemetry::{set_trace_subscriber_for_current_thread, TelemetryInstance, VecDisplayer}, + telemetry::{TelemetryInstance, VecDisplayer, set_trace_subscriber_for_current_thread}, worker::{ + LocalActRequest, LocalActivityExecutionResult, LocalActivityResolution, + PostActivateHookData, activities::{ActivitiesFromWFTsHandle, LocalActivityManager}, client::{WorkerClient, WorkflowTaskCompletion}, workflow::{ @@ -33,13 +36,10 @@ use crate::{ wft_poller::validate_wft, workflow_stream::{LocalInput, LocalInputs, WFStream}, }, - LocalActRequest, LocalActivityExecutionResult, LocalActivityResolution, - PostActivateHookData, }, - MetricsContext, }; use anyhow::anyhow; -use futures_util::{future::abortable, stream, stream::BoxStream, Stream, StreamExt}; +use futures_util::{Stream, StreamExt, future::abortable, stream, stream::BoxStream}; use itertools::Itertools; use prost_types::TimestampError; use rustfsm::MachineError; @@ -52,7 +52,7 @@ use std::{ ops::DerefMut, rc::Rc, result, - sync::{atomic, atomic::AtomicBool, Arc}, + sync::{Arc, atomic, atomic::AtomicBool}, thread, time::{Duration, Instant}, }; @@ -61,35 +61,35 @@ use temporal_sdk_core_api::{ worker::{ActivitySlotKind, WorkerConfig, WorkflowSlotKind}, }; use temporal_sdk_core_protos::{ + TaskToken, coresdk::{ workflow_activation::{ - remove_from_cache::EvictionReason, workflow_activation_job, QueryWorkflow, - WorkflowActivation, WorkflowActivationJob, + QueryWorkflow, WorkflowActivation, WorkflowActivationJob, + remove_from_cache::EvictionReason, workflow_activation_job, }, workflow_commands::*, workflow_completion, workflow_completion::{ - workflow_activation_completion, Failure, WorkflowActivationCompletion, + Failure, WorkflowActivationCompletion, workflow_activation_completion, }, }, temporal::api::{ - command::v1::{command::Attributes, Command as ProtoCommand, Command}, + command::v1::{Command as ProtoCommand, Command, command::Attributes}, common::v1::{Memo, MeteringMetadata, RetryPolicy, SearchAttributes, WorkflowExecution}, enums::v1::WorkflowTaskFailedCause, protocol::v1::Message as ProtocolMessage, query::v1::WorkflowQuery, sdk::v1::{UserMetadata, WorkflowTaskCompletedMetadata}, taskqueue::v1::StickyExecutionAttributes, - workflowservice::v1::{get_system_info_response, PollActivityTaskQueueResponse}, + workflowservice::v1::{PollActivityTaskQueueResponse, get_system_info_response}, }, - TaskToken, }; use tokio::{ sync::{ - mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender}, + mpsc::{UnboundedReceiver, UnboundedSender, unbounded_channel}, oneshot, }, - task::{spawn_blocking, LocalSet}, + task::{LocalSet, spawn_blocking}, }; use tokio_stream::wrappers::UnboundedReceiverStream; use tokio_util::sync::CancellationToken; @@ -259,7 +259,7 @@ impl Workflows { loop { let al = { let mut lock = self.activation_stream.lock().await; - let (ref mut stream, ref mut beginner) = lock.deref_mut(); + let (stream, beginner) = lock.deref_mut(); if let Some(beginner) = beginner.take() { let _ = beginner.send(()); } @@ -429,7 +429,7 @@ impl Workflows { warn!(run_id=%run_id, failure=?failure, "Failing workflow task"); self.handle_wft_reporting_errs(&run_id, || async { self.client - .fail_workflow_task(tt, cause, failure.failure.map(Into::into)) + .fail_workflow_task(tt, cause, failure.failure) .await }) .await; diff --git a/core/src/worker/workflow/run_cache.rs b/core/src/worker/workflow/run_cache.rs index dc173ebb8..19b4ee998 100644 --- a/core/src/worker/workflow/run_cache.rs +++ b/core/src/worker/workflow/run_cache.rs @@ -1,10 +1,10 @@ use crate::{ + MetricsContext, telemetry::metrics::workflow_type, worker::workflow::{ - managed_run::{ManagedRun, RunUpdateAct}, HistoryUpdate, LocalActivityRequestSink, PermittedWFT, RequestEvictMsg, RunBasics, + managed_run::{ManagedRun, RunUpdateAct}, }, - MetricsContext, }; use lru::LruCache; use std::{num::NonZeroUsize, rc::Rc, sync::Arc}; diff --git a/core/src/worker/workflow/wft_extraction.rs b/core/src/worker/workflow/wft_extraction.rs index bd3e62b1b..74e5ab17a 100644 --- a/core/src/worker/workflow/wft_extraction.rs +++ b/core/src/worker/workflow/wft_extraction.rs @@ -4,15 +4,15 @@ use crate::{ worker::{ client::WorkerClient, workflow::{ - history_update::HistoryPaginator, CacheMissFetchReq, HistoryUpdate, NextPageReq, - PermittedWFT, + CacheMissFetchReq, HistoryUpdate, NextPageReq, PermittedWFT, + history_update::HistoryPaginator, }, }, }; -use futures_util::{stream, stream::PollNext, FutureExt, Stream, StreamExt}; +use futures_util::{FutureExt, Stream, StreamExt, stream, stream::PollNext}; use std::{future, sync::Arc}; use temporal_sdk_core_api::worker::WorkflowSlotKind; -use temporal_sdk_core_protos::{coresdk::WorkflowSlotInfo, TaskToken}; +use temporal_sdk_core_protos::{TaskToken, coresdk::WorkflowSlotInfo}; use tracing::Span; /// Transforms incoming validated WFTs and history fetching requests into [PermittedWFT]s ready diff --git a/core/src/worker/workflow/wft_poller.rs b/core/src/worker/workflow/wft_poller.rs index d9d54e909..6cc4c7ce2 100644 --- a/core/src/worker/workflow/wft_poller.rs +++ b/core/src/worker/workflow/wft_poller.rs @@ -1,10 +1,10 @@ use crate::{ + MetricsContext, abstractions::OwnedMeteredSemPermit, pollers::{BoxedWFPoller, Poller}, protosext::ValidPollWFTQResponse, - MetricsContext, }; -use futures_util::{stream, Stream}; +use futures_util::{Stream, stream}; use temporal_sdk_core_api::worker::WorkflowSlotKind; use temporal_sdk_core_protos::temporal::api::workflowservice::v1::PollWorkflowTaskQueueResponse; @@ -78,7 +78,7 @@ mod tests { abstractions::tests::fixed_size_permit_dealer, pollers::MockPermittedPollBuffer, test_help::mock_poller, }; - use futures_util::{pin_mut, StreamExt}; + use futures_util::{StreamExt, pin_mut}; use std::sync::Arc; use temporal_sdk_core_api::worker::WorkflowSlotKind; diff --git a/core/src/worker/workflow/workflow_stream.rs b/core/src/worker/workflow/workflow_stream.rs index 1e4e7e928..4af7b1cd0 100644 --- a/core/src/worker/workflow/workflow_stream.rs +++ b/core/src/worker/workflow/workflow_stream.rs @@ -1,4 +1,5 @@ use crate::{ + MetricsContext, abstractions::dbg_panic, worker::workflow::{ managed_run::RunUpdateAct, @@ -6,9 +7,8 @@ use crate::{ wft_extraction::{HistfetchRC, HistoryFetchReq, WFTExtractorOutput}, *, }, - MetricsContext, }; -use futures_util::{stream, stream::PollNext, Stream, StreamExt}; +use futures_util::{Stream, StreamExt, stream, stream::PollNext}; use std::{collections::VecDeque, fmt::Debug, future, sync::Arc}; use temporal_sdk_core_api::errors::PollError; use temporal_sdk_core_protos::coresdk::workflow_activation::remove_from_cache::EvictionReason; diff --git a/fsm/Cargo.toml b/fsm/Cargo.toml index 5e9e1c918..8760724ea 100644 --- a/fsm/Cargo.toml +++ b/fsm/Cargo.toml @@ -2,7 +2,7 @@ name = "rustfsm" version = "0.1.0" authors = ["Spencer Judge "] -edition = "2021" +edition = "2024" license-file = "LICENSE.txt" description = "Define state machines that can accept events and produce commands" homepage = "https://temporal.io/" diff --git a/fsm/rustfsm_procmacro/Cargo.toml b/fsm/rustfsm_procmacro/Cargo.toml index 9981722c5..ea49df00c 100644 --- a/fsm/rustfsm_procmacro/Cargo.toml +++ b/fsm/rustfsm_procmacro/Cargo.toml @@ -2,7 +2,7 @@ name = "rustfsm_procmacro" version = "0.1.0" authors = ["Spencer Judge "] -edition = "2021" +edition = "2024" license-file = "LICENSE.txt" description = "Procmacro sub-crate of the `rustfsm` crate" diff --git a/fsm/rustfsm_procmacro/src/lib.rs b/fsm/rustfsm_procmacro/src/lib.rs index eaad93ebf..c216a607b 100644 --- a/fsm/rustfsm_procmacro/src/lib.rs +++ b/fsm/rustfsm_procmacro/src/lib.rs @@ -1,12 +1,11 @@ use proc_macro::TokenStream; use quote::{quote, quote_spanned}; -use std::collections::{hash_map::Entry, HashMap, HashSet}; +use std::collections::{HashMap, HashSet, hash_map::Entry}; use syn::{ - parenthesized, + Error, Fields, Ident, Token, Type, Variant, Visibility, parenthesized, parse::{Parse, ParseStream, Result}, parse_macro_input, spanned::Spanned, - Error, Fields, Ident, Token, Type, Variant, Visibility, }; /// Parses a DSL for defining finite state machines, and produces code implementing the @@ -287,7 +286,7 @@ impl Parse for Transition { return Err(Error::new( event.span(), "Struct variants are not supported for events", - )) + )); } Fields::Unnamed(uf) => { if uf.unnamed.len() != 1 { diff --git a/fsm/rustfsm_trait/Cargo.toml b/fsm/rustfsm_trait/Cargo.toml index c0543ae8e..6f66b2ff4 100644 --- a/fsm/rustfsm_trait/Cargo.toml +++ b/fsm/rustfsm_trait/Cargo.toml @@ -2,7 +2,7 @@ name = "rustfsm_trait" version = "0.1.0" authors = ["Spencer Judge "] -edition = "2021" +edition = "2024" license-file = "LICENSE.txt" description = "Trait sub-crate of the `rustfsm` crate" diff --git a/sdk-core-protos/Cargo.toml b/sdk-core-protos/Cargo.toml index 477a980d9..561894c9f 100644 --- a/sdk-core-protos/Cargo.toml +++ b/sdk-core-protos/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "temporal-sdk-core-protos" version = "0.1.0" -edition = "2021" +edition = "2024" authors = ["Spencer Judge "] license-file = { workspace = true } description = "Protobuf definitions for Temporal SDKs Core/Lang interface" @@ -19,10 +19,9 @@ anyhow = "1.0" base64 = "0.22" derive_more = { workspace = true } prost = { workspace = true } -prost-types = { workspace = true } prost-wkt = "0.6" prost-wkt-types = "0.6" -rand = { version = "0.8", optional = true } +rand = { version = "0.9", optional = true } serde = { version = "1.0", features = ["derive"] } serde_json = "1.0" thiserror = { workspace = true } diff --git a/sdk-core-protos/src/history_builder.rs b/sdk-core-protos/src/history_builder.rs index fff3fc2ad..653cc1d6e 100644 --- a/sdk-core-protos/src/history_builder.rs +++ b/sdk-core-protos/src/history_builder.rs @@ -1,26 +1,26 @@ use crate::{ + HistoryInfo, constants::{LOCAL_ACTIVITY_MARKER_NAME, PATCH_MARKER_NAME}, coresdk::{ + AsJsonPayloadExt, IntoPayloadsExt, common::{ - build_has_change_marker_details, build_local_activity_marker_details, - NamespacedWorkflowExecution, + NamespacedWorkflowExecution, build_has_change_marker_details, + build_local_activity_marker_details, }, external_data::LocalActivityMarkerData, workflow_commands::ScheduleActivity, - AsJsonPayloadExt, IntoPayloadsExt, }, temporal::api::{ common::v1::{ ActivityType, Payload, Payloads, SearchAttributes, WorkflowExecution, WorkflowType, }, enums::v1::{EventType, TaskQueueKind, WorkflowTaskFailedCause}, - failure::v1::{failure, CanceledFailureInfo, Failure}, + failure::v1::{CanceledFailureInfo, Failure, failure}, history::v1::{history_event::Attributes, *}, taskqueue::v1::TaskQueue, update, update::v1::outcome, }, - HistoryInfo, }; use anyhow::bail; use prost_wkt_types::Timestamp; diff --git a/sdk-core-protos/src/history_info.rs b/sdk-core-protos/src/history_info.rs index cd849bf2c..5058c3f18 100644 --- a/sdk-core-protos/src/history_info.rs +++ b/sdk-core-protos/src/history_info.rs @@ -1,7 +1,7 @@ use crate::temporal::api::{ common::v1::WorkflowType, enums::v1::{EventType, TaskQueueKind}, - history::v1::{history_event, History, HistoryEvent, WorkflowExecutionStartedEventAttributes}, + history::v1::{History, HistoryEvent, WorkflowExecutionStartedEventAttributes, history_event}, taskqueue::v1::TaskQueue, workflowservice::v1::{GetWorkflowExecutionHistoryResponse, PollWorkflowTaskQueueResponse}, }; @@ -207,7 +207,7 @@ impl From for GetWorkflowExecutionHistoryResponse { #[cfg(test)] mod tests { - use crate::{temporal::api::enums::v1::EventType, TestHistoryBuilder}; + use crate::{TestHistoryBuilder, temporal::api::enums::v1::EventType}; fn single_timer(timer_id: &str) -> TestHistoryBuilder { let mut t = TestHistoryBuilder::default(); diff --git a/sdk-core-protos/src/lib.rs b/sdk-core-protos/src/lib.rs index 8802f542b..37acb32e4 100644 --- a/sdk-core-protos/src/lib.rs +++ b/sdk-core-protos/src/lib.rs @@ -13,8 +13,8 @@ mod task_token; #[cfg(feature = "history_builders")] pub use history_builder::{ - default_act_sched, default_wes_attribs, TestHistoryBuilder, DEFAULT_ACTIVITY_TYPE, - DEFAULT_WORKFLOW_TYPE, + DEFAULT_ACTIVITY_TYPE, DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder, default_act_sched, + default_wes_attribs, }; #[cfg(feature = "history_builders")] pub use history_info::HistoryInfo; @@ -37,16 +37,16 @@ pub mod coresdk { tonic::include_proto!("coresdk"); use crate::{ + ENCODING_PAYLOAD_KEY, JSON_ENCODING_VAL, temporal::api::{ common::v1::{Payload, Payloads, WorkflowExecution}, enums::v1::{TimeoutType, WorkflowTaskFailedCause}, failure::v1::{ - failure::FailureInfo, ActivityFailureInfo, ApplicationFailureInfo, Failure, - TimeoutFailureInfo, + ActivityFailureInfo, ApplicationFailureInfo, Failure, TimeoutFailureInfo, + failure::FailureInfo, }, workflowservice::v1::PollActivityTaskQueueResponse, }, - ENCODING_PAYLOAD_KEY, JSON_ENCODING_VAL, }; use activity_task::ActivityTask; use serde::{Deserialize, Serialize}; @@ -56,9 +56,9 @@ pub mod coresdk { fmt::{Display, Formatter}, iter::FromIterator, }; - use workflow_activation::{workflow_activation_job, WorkflowActivationJob}; - use workflow_commands::{workflow_command, workflow_command::Variant, WorkflowCommand}; - use workflow_completion::{workflow_activation_completion, WorkflowActivationCompletion}; + use workflow_activation::{WorkflowActivationJob, workflow_activation_job}; + use workflow_commands::{WorkflowCommand, workflow_command, workflow_command::Variant}; + use workflow_completion::{WorkflowActivationCompletion, workflow_activation_completion}; #[allow(clippy::module_inception)] pub mod activity_task { @@ -107,7 +107,7 @@ pub mod coresdk { tonic::include_proto!("coresdk.activity_result"); use super::super::temporal::api::{ common::v1::Payload, - failure::v1::{failure, CanceledFailureInfo, Failure as APIFailure}, + failure::v1::{CanceledFailureInfo, Failure as APIFailure, failure}, }; use crate::{ coresdk::activity_result::activity_resolution::Status, @@ -287,12 +287,12 @@ pub mod coresdk { tonic::include_proto!("coresdk.common"); use super::external_data::LocalActivityMarkerData; use crate::{ + PATCHED_MARKER_DETAILS_KEY, coresdk::{ - external_data::PatchedMarkerData, AsJsonPayloadExt, FromJsonPayloadExt, - IntoPayloadsExt, + AsJsonPayloadExt, FromJsonPayloadExt, IntoPayloadsExt, + external_data::PatchedMarkerData, }, temporal::api::common::v1::{Payload, Payloads}, - PATCHED_MARKER_DETAILS_KEY, }; use std::collections::HashMap; @@ -450,10 +450,10 @@ pub mod coresdk { pub mod workflow_activation { use crate::{ coresdk::{ - activity_result::{activity_resolution, ActivityResolution}, + FromPayloadsExt, + activity_result::{ActivityResolution, activity_resolution}, common::NamespacedWorkflowExecution, workflow_activation::remove_from_cache::EvictionReason, - FromPayloadsExt, }, temporal::api::{ enums::v1::WorkflowTaskFailedCause, @@ -1263,7 +1263,7 @@ pub mod coresdk { schedule_to_close_timeout: r.schedule_to_close_timeout, start_to_close_timeout: r.start_to_close_timeout, heartbeat_timeout: r.heartbeat_timeout, - retry_policy: r.retry_policy.map(Into::into), + retry_policy: r.retry_policy, is_local: false, }, )), @@ -1424,7 +1424,7 @@ pub mod coresdk { fn from_payloads(p: Option) -> Self { match p { None => std::iter::empty().collect(), - Some(p) => p.payloads.into_iter().map(Into::into).collect(), + Some(p) => p.payloads.into_iter().collect(), } } } @@ -1442,7 +1442,7 @@ pub mod coresdk { None } else { Some(Payloads { - payloads: iterd.map(Into::into).collect(), + payloads: iterd.collect(), }) } } @@ -1563,7 +1563,7 @@ pub mod temporal { tonic::include_proto!("temporal.api.command.v1"); use crate::{ - coresdk::{workflow_commands, IntoPayloadsExt}, + coresdk::{IntoPayloadsExt, workflow_commands}, temporal::api::{ common::v1::{ActivityType, WorkflowType}, enums::v1::CommandType, @@ -1934,7 +1934,7 @@ pub mod temporal { pub mod common { pub mod v1 { use crate::{ENCODING_PAYLOAD_KEY, JSON_ENCODING_VAL}; - use base64::{prelude::BASE64_STANDARD, Engine}; + use base64::{Engine, prelude::BASE64_STANDARD}; use std::{ collections::HashMap, fmt::{Display, Formatter}, @@ -2401,7 +2401,7 @@ pub mod temporal { pub mod v1 { use crate::temporal::api::{ common, - common::v1::link::{workflow_event, WorkflowEvent}, + common::v1::link::{WorkflowEvent, workflow_event}, enums::v1::EventType, }; use anyhow::{anyhow, bail}; diff --git a/sdk-core-protos/src/task_token.rs b/sdk-core-protos/src/task_token.rs index cad2be7f0..d9126a37d 100644 --- a/sdk-core-protos/src/task_token.rs +++ b/sdk-core-protos/src/task_token.rs @@ -1,4 +1,4 @@ -use base64::{prelude::BASE64_STANDARD, Engine}; +use base64::{Engine, prelude::BASE64_STANDARD}; use std::{ borrow::Borrow, fmt::{Debug, Display, Formatter}, diff --git a/sdk/Cargo.toml b/sdk/Cargo.toml index 0a05059f2..b265a6872 100644 --- a/sdk/Cargo.toml +++ b/sdk/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "temporal-sdk" version = "0.1.0-alpha.1" -edition = "2021" +edition = "2024" authors = ["Spencer Judge "] license-file = { workspace = true } description = "Temporal Rust SDK" @@ -12,7 +12,6 @@ categories = ["development-tools"] [dependencies] async-trait = "0.1" -thiserror = { workspace = true } anyhow = "1.0" derive_more = { workspace = true } futures-util = { version = "0.3", default-features = false } diff --git a/sdk/src/activity_context.rs b/sdk/src/activity_context.rs index 8854d0583..018c9a69c 100644 --- a/sdk/src/activity_context.rs +++ b/sdk/src/activity_context.rs @@ -8,7 +8,7 @@ use std::{ }; use temporal_sdk_core_api::Worker; use temporal_sdk_core_protos::{ - coresdk::{activity_task, ActivityHeartbeat}, + coresdk::{ActivityHeartbeat, activity_task}, temporal::api::common::v1::{Payload, RetryPolicy, WorkflowExecution}, utilities::TryIntoOrNone, }; diff --git a/sdk/src/interceptors.rs b/sdk/src/interceptors.rs index 5aeb84805..2536cc756 100644 --- a/sdk/src/interceptors.rs +++ b/sdk/src/interceptors.rs @@ -3,7 +3,7 @@ use crate::Worker; use anyhow::bail; use temporal_sdk_core_protos::coresdk::{ - workflow_activation::{remove_from_cache::EvictionReason, WorkflowActivation}, + workflow_activation::{WorkflowActivation, remove_from_cache::EvictionReason}, workflow_completion::WorkflowActivationCompletion, }; diff --git a/sdk/src/lib.rs b/sdk/src/lib.rs index 848a34333..df2f2f9e7 100644 --- a/sdk/src/lib.rs +++ b/sdk/src/lib.rs @@ -53,7 +53,7 @@ mod workflow_future; pub use activity_context::ActContext; pub use temporal_client::Namespace; -use tracing::{field, Instrument, Span}; +use tracing::{Instrument, Span, field}; pub use workflow_context::{ ActivityOptions, CancellableFuture, ChildWorkflow, ChildWorkflowOptions, LocalActivityOptions, NexusOperationOptions, PendingChildWorkflow, Signal, SignalData, SignalWorkflowOptions, @@ -64,9 +64,9 @@ use crate::{ interceptors::WorkerInterceptor, workflow_context::{ChildWfCommon, NexusUnblockData, StartedNexusOperation}, }; -use anyhow::{anyhow, bail, Context}; +use anyhow::{Context, anyhow, bail}; use app_data::AppData; -use futures_util::{future::BoxFuture, FutureExt, StreamExt, TryFutureExt, TryStreamExt}; +use futures_util::{FutureExt, StreamExt, TryFutureExt, TryStreamExt, future::BoxFuture}; use serde::Serialize; use std::{ any::{Any, TypeId}, @@ -80,32 +80,33 @@ use std::{ }; use temporal_client::ClientOptionsBuilder; use temporal_sdk_core::Url; -use temporal_sdk_core_api::{errors::PollError, Worker as CoreWorker}; +use temporal_sdk_core_api::{Worker as CoreWorker, errors::PollError}; use temporal_sdk_core_protos::{ + TaskToken, coresdk::{ + ActivityTaskCompletion, AsJsonPayloadExt, FromJsonPayloadExt, activity_result::{ActivityExecutionResult, ActivityResolution}, - activity_task::{activity_task, ActivityTask}, + activity_task::{ActivityTask, activity_task}, child_workflow::ChildWorkflowResult, common::NamespacedWorkflowExecution, nexus::NexusOperationResult, workflow_activation::{ + WorkflowActivation, resolve_child_workflow_execution_start::Status as ChildWorkflowStartStatus, - resolve_nexus_operation_start, workflow_activation_job::Variant, WorkflowActivation, + resolve_nexus_operation_start, workflow_activation_job::Variant, }, - workflow_commands::{workflow_command, ContinueAsNewWorkflowExecution, WorkflowCommand}, + workflow_commands::{ContinueAsNewWorkflowExecution, WorkflowCommand, workflow_command}, workflow_completion::WorkflowActivationCompletion, - ActivityTaskCompletion, AsJsonPayloadExt, FromJsonPayloadExt, }, temporal::api::{ common::v1::Payload, enums::v1::WorkflowTaskFailedCause, - failure::v1::{failure, Failure}, + failure::v1::{Failure, failure}, }, - TaskToken, }; use tokio::{ sync::{ - mpsc::{unbounded_channel, UnboundedSender}, + mpsc::{UnboundedSender, unbounded_channel}, oneshot, }, task::JoinError, @@ -192,7 +193,7 @@ impl Worker { /// Return a handle that can be used to initiate shutdown. /// TODO: Doc better after shutdown changes - pub fn shutdown_handle(&self) -> impl Fn() { + pub fn shutdown_handle(&self) -> impl Fn() + use<> { let w = self.common.worker.clone(); move || w.initiate_shutdown() } @@ -391,7 +392,9 @@ impl WorkflowHalf { completions_tx: &UnboundedSender, ) -> Result< Option< - WorkflowFutureHandle, JoinError>>>, + WorkflowFutureHandle< + impl Future, JoinError>> + use<>, + >, >, anyhow::Error, > { diff --git a/sdk/src/workflow_context.rs b/sdk/src/workflow_context.rs index 05dd969ad..f0afc56f8 100644 --- a/sdk/src/workflow_context.rs +++ b/sdk/src/workflow_context.rs @@ -6,13 +6,12 @@ pub use options::{ }; use crate::{ - workflow_context::options::IntoWorkflowCommand, CancelExternalWfResult, CancellableID, - CancellableIDWithReason, CommandCreateRequest, CommandSubscribeChildWorkflowCompletion, - IntoUpdateHandlerFunc, IntoUpdateValidatorFunc, NexusStartResult, RustWfCmd, - SignalExternalWfResult, SupportsCancelReason, TimerResult, UnblockEvent, Unblockable, - UpdateFunctions, + CancelExternalWfResult, CancellableID, CancellableIDWithReason, CommandCreateRequest, + CommandSubscribeChildWorkflowCompletion, IntoUpdateHandlerFunc, IntoUpdateValidatorFunc, + NexusStartResult, RustWfCmd, SignalExternalWfResult, SupportsCancelReason, TimerResult, + UnblockEvent, Unblockable, UpdateFunctions, workflow_context::options::IntoWorkflowCommand, }; -use futures_util::{future::Shared, task::Context, FutureExt, Stream, StreamExt}; +use futures_util::{FutureExt, Stream, StreamExt, future::Shared, task::Context}; use parking_lot::{RwLock, RwLockReadGuard}; use std::{ collections::HashMap, @@ -21,26 +20,25 @@ use std::{ ops::Deref, pin::Pin, sync::{ + Arc, atomic::{AtomicBool, Ordering}, mpsc::{Receiver, Sender}, - Arc, }, task::Poll, time::{Duration, SystemTime}, }; use temporal_sdk_core_protos::{ coresdk::{ - activity_result::{activity_resolution, ActivityResolution}, + activity_result::{ActivityResolution, activity_resolution}, child_workflow::ChildWorkflowResult, common::NamespacedWorkflowExecution, nexus::NexusOperationResult, workflow_activation::resolve_child_workflow_execution_start::Status as ChildWorkflowStartStatus, workflow_commands::{ - signal_external_workflow_execution as sig_we, workflow_command, CancelChildWorkflowExecution, ModifyWorkflowProperties, RequestCancelExternalWorkflowExecution, SetPatchMarker, SignalExternalWorkflowExecution, StartTimer, UpsertWorkflowSearchAttributes, - WorkflowCommand, + WorkflowCommand, signal_external_workflow_execution as sig_we, workflow_command, }, }, temporal::api::{ @@ -822,11 +820,11 @@ impl StartedChildWorkflow { } /// Signal the child workflow - pub fn signal( + pub fn signal<'a, S: Into>( &self, - cx: &WfContext, - data: impl Into, - ) -> impl CancellableFuture { + cx: &'a WfContext, + data: S, + ) -> impl CancellableFuture + use<'a, S> { let target = sig_we::Target::ChildWorkflowId(self.common.workflow_id.clone()); cx.send_signal_wf(target, data.into()) } diff --git a/sdk/src/workflow_future.rs b/sdk/src/workflow_future.rs index 3c7b2fe63..d35937396 100644 --- a/sdk/src/workflow_future.rs +++ b/sdk/src/workflow_future.rs @@ -1,12 +1,12 @@ use crate::{ - panic_formatter, CancellableID, RustWfCmd, SignalData, TimerResult, UnblockEvent, - UpdateContext, UpdateFunctions, UpdateInfo, WfContext, WfExitValue, WorkflowFunction, - WorkflowResult, + CancellableID, RustWfCmd, SignalData, TimerResult, UnblockEvent, UpdateContext, + UpdateFunctions, UpdateInfo, WfContext, WfExitValue, WorkflowFunction, WorkflowResult, + panic_formatter, }; -use anyhow::{anyhow, bail, Context as AnyhowContext, Error}; -use futures_util::{future::BoxFuture, FutureExt}; +use anyhow::{Context as AnyhowContext, Error, anyhow, bail}; +use futures_util::{FutureExt, future::BoxFuture}; use std::{ - collections::{hash_map::Entry, HashMap}, + collections::{HashMap, hash_map::Entry}, future::Future, panic, panic::AssertUnwindSafe, @@ -17,25 +17,26 @@ use std::{ use temporal_sdk_core_protos::{ coresdk::{ workflow_activation::{ - workflow_activation_job::Variant, FireTimer, NotifyHasPatch, ResolveActivity, - ResolveChildWorkflowExecution, ResolveChildWorkflowExecutionStart, WorkflowActivation, - WorkflowActivationJob, + FireTimer, NotifyHasPatch, ResolveActivity, ResolveChildWorkflowExecution, + ResolveChildWorkflowExecutionStart, WorkflowActivation, WorkflowActivationJob, + workflow_activation_job::Variant, }, workflow_commands::{ - update_response, workflow_command, CancelChildWorkflowExecution, CancelSignalWorkflow, - CancelTimer, CancelWorkflowExecution, CompleteWorkflowExecution, FailWorkflowExecution, + CancelChildWorkflowExecution, CancelSignalWorkflow, CancelTimer, + CancelWorkflowExecution, CompleteWorkflowExecution, FailWorkflowExecution, RequestCancelActivity, RequestCancelExternalWorkflowExecution, RequestCancelLocalActivity, RequestCancelNexusOperation, ScheduleActivity, - ScheduleLocalActivity, StartTimer, UpdateResponse, WorkflowCommand, + ScheduleLocalActivity, StartTimer, UpdateResponse, WorkflowCommand, update_response, + workflow_command, }, workflow_completion, - workflow_completion::{workflow_activation_completion, WorkflowActivationCompletion}, + workflow_completion::{WorkflowActivationCompletion, workflow_activation_completion}, }, temporal::api::{common::v1::Payload, failure::v1::Failure}, utilities::TryIntoOrNone, }; use tokio::sync::{ - mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender}, + mpsc::{UnboundedReceiver, UnboundedSender, unbounded_channel}, oneshot, watch, }; use tracing::Instrument; @@ -52,7 +53,7 @@ impl WorkflowFunction { args: Vec, outgoing_completions: UnboundedSender, ) -> ( - impl Future>, + impl Future> + use<>, UnboundedSender, ) { let (cancel_tx, cancel_rx) = watch::channel(None); @@ -228,7 +229,7 @@ impl WorkflowFuture { SigChanOrBuffer::Chan(chan) => { let _ = chan.send(dat); } - SigChanOrBuffer::Buffer(ref mut buf) => buf.push(dat), + SigChanOrBuffer::Buffer(buf) => buf.push(dat), }, Entry::Vacant(v) => { v.insert(SigChanOrBuffer::Buffer(vec![dat])); @@ -351,7 +352,7 @@ impl Future for WorkflowFuture { None => { return Poll::Ready(Err(anyhow!( "Workflow future's activation channel was lost!" - ))) + ))); } }, Poll::Pending => return Poll::Pending, diff --git a/test-utils/Cargo.toml b/test-utils/Cargo.toml index 2ba294a65..2f307aaf1 100644 --- a/test-utils/Cargo.toml +++ b/test-utils/Cargo.toml @@ -2,7 +2,7 @@ name = "temporal-sdk-core-test-utils" version = "0.1.0" authors = ["Spencer Judge "] -edition = "2021" +edition = "2024" license-file = { workspace = true } [[bin]] @@ -17,25 +17,17 @@ ephemeral-server = ["temporal-sdk-core/ephemeral-server"] anyhow = "1.0" assert_matches = "1" async-trait = "0.1" -base64 = "0.22" -bytes = "1.3" futures-util = { version = "0.3", default-features = false } parking_lot = "0.12" prost = { workspace = true } -prost-types = { workspace = true } -rand = "0.8" -rmp-serde = "1.1" -serde_json = "1.0" +rand = "0.9" temporal-client = { path = "../client" } temporal-sdk = { path = "../sdk" } temporal-sdk-core = { path = "../core" } temporal-sdk-core-api = { path = "../core-api" } -thiserror = { workspace = true } tokio = "1.1" -tokio-util = { version = "0.7" } tracing = "0.1" url = "2.2" -uuid = "1.1" [dependencies.temporal-sdk-core-protos] path = "../sdk-core-protos" diff --git a/test-utils/src/canned_histories.rs b/test-utils/src/canned_histories.rs index 84a07773a..0cbe1712e 100644 --- a/test-utils/src/canned_histories.rs +++ b/test-utils/src/canned_histories.rs @@ -767,7 +767,7 @@ pub fn lots_of_big_signals(num_tasks: usize) -> TestHistoryBuilder { t.add_by_type(EventType::WorkflowExecutionStarted); t.add_full_wf_task(); - let mut rng = rand::thread_rng(); + let mut rng = rand::rng(); for _ in 1..=num_tasks { let mut dat = [0_u8; 1024 * 1000]; for _ in 1..=5 { diff --git a/test-utils/src/lib.rs b/test-utils/src/lib.rs index 47195b673..b9a9786ba 100644 --- a/test-utils/src/lib.rs +++ b/test-utils/src/lib.rs @@ -13,10 +13,10 @@ pub use temporal_sdk_core::replay::HistoryForReplay; use crate::stream::{Stream, TryStreamExt}; use anyhow::Context; use assert_matches::assert_matches; -use futures_util::{future, stream, stream::FuturesUnordered, StreamExt}; +use futures_util::{StreamExt, future, stream, stream::FuturesUnordered}; use parking_lot::Mutex; use prost::Message; -use rand::{distributions, Rng}; +use rand::Rng; use std::{ convert::TryFrom, env, future::Future, net::SocketAddr, path::PathBuf, sync::Arc, time::Duration, @@ -26,40 +26,40 @@ use temporal_client::{ WorkflowClientTrait, WorkflowExecutionInfo, WorkflowHandle, WorkflowOptions, }; use temporal_sdk::{ - interceptors::{FailOnNondeterminismInterceptor, WorkerInterceptor}, IntoActivityFunc, Worker, WorkflowFunction, + interceptors::{FailOnNondeterminismInterceptor, WorkerInterceptor}, }; #[cfg(feature = "ephemeral-server")] use temporal_sdk_core::ephemeral_server::{EphemeralExe, EphemeralExeVersion}; use temporal_sdk_core::{ - init_replay_worker, init_worker, + ClientOptions, ClientOptionsBuilder, CoreRuntime, WorkerConfigBuilder, init_replay_worker, + init_worker, replay::ReplayWorkerInput, telemetry::{build_otlp_metric_exporter, start_prometheus_metric_exporter}, - ClientOptions, ClientOptionsBuilder, CoreRuntime, WorkerConfigBuilder, }; use temporal_sdk_core_api::{ + Worker as CoreWorker, errors::PollError, telemetry::{ - metrics::CoreMeter, Logger, OtelCollectorOptionsBuilder, PrometheusExporterOptionsBuilder, - TelemetryOptions, TelemetryOptionsBuilder, + Logger, OtelCollectorOptionsBuilder, PrometheusExporterOptionsBuilder, TelemetryOptions, + TelemetryOptionsBuilder, metrics::CoreMeter, }, - Worker as CoreWorker, }; use temporal_sdk_core_protos::{ + DEFAULT_ACTIVITY_TYPE, coresdk::{ - workflow_activation::{workflow_activation_job, WorkflowActivation, WorkflowActivationJob}, + FromPayloadsExt, + workflow_activation::{WorkflowActivation, WorkflowActivationJob, workflow_activation_job}, workflow_commands::{ - workflow_command, ActivityCancellationType, CompleteWorkflowExecution, QueryResult, - QuerySuccess, ScheduleActivity, ScheduleLocalActivity, StartTimer, + ActivityCancellationType, CompleteWorkflowExecution, QueryResult, QuerySuccess, + ScheduleActivity, ScheduleLocalActivity, StartTimer, workflow_command, }, workflow_completion::WorkflowActivationCompletion, - FromPayloadsExt, }, temporal::api::{ common::v1::Payload, history::v1::History, workflowservice::v1::StartWorkflowExecutionResponse, }, - DEFAULT_ACTIVITY_TYPE, }; use tokio::sync::OnceCell; use url::Url; @@ -799,11 +799,13 @@ where async fn complete_timer(&self, run_id: &str, seq: u32, duration: Duration) { self.complete_workflow_activation(WorkflowActivationCompletion::from_cmds( run_id.to_string(), - vec![StartTimer { - seq, - start_to_fire_timeout: Some(duration.try_into().expect("duration fits")), - } - .into()], + vec![ + StartTimer { + seq, + start_to_fire_timeout: Some(duration.try_into().expect("duration fits")), + } + .into(), + ], )) .await .unwrap(); @@ -872,8 +874,8 @@ pub async fn drain_pollers_and_shutdown(worker: &Arc) { } pub fn rand_6_chars() -> String { - rand::thread_rng() - .sample_iter(&distributions::Alphanumeric) + rand::rng() + .sample_iter(&rand::distr::Alphanumeric) .take(6) .map(char::from) .collect() diff --git a/tests/fuzzy_workflow.rs b/tests/fuzzy_workflow.rs index 5747ecf5a..c6c9cc8b8 100644 --- a/tests/fuzzy_workflow.rs +++ b/tests/fuzzy_workflow.rs @@ -1,5 +1,5 @@ -use futures_util::{sink, stream::FuturesUnordered, FutureExt, StreamExt}; -use rand::{prelude::Distribution, rngs::SmallRng, Rng, SeedableRng}; +use futures_util::{FutureExt, StreamExt, sink, stream::FuturesUnordered}; +use rand::{Rng, SeedableRng, prelude::Distribution, rngs::SmallRng}; use std::{future, time::Duration}; use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions}; use temporal_sdk::{ @@ -21,7 +21,7 @@ enum FuzzyWfAction { struct FuzzyWfActionSampler; impl Distribution for FuzzyWfActionSampler { fn sample(&self, rng: &mut R) -> FuzzyWfAction { - let v: u8 = rng.gen_range(1..=2); + let v: u8 = rng.random_range(1..=2); match v { 1 => FuzzyWfAction::DoAct, 2 => FuzzyWfAction::DoLocalAct, diff --git a/tests/heavy_tests.rs b/tests/heavy_tests.rs index 7dbb0620b..37d6726fc 100644 --- a/tests/heavy_tests.rs +++ b/tests/heavy_tests.rs @@ -1,4 +1,4 @@ -use futures_util::{future::join_all, sink, stream::FuturesUnordered, StreamExt}; +use futures_util::{StreamExt, future::join_all, sink, stream::FuturesUnordered}; use std::{ sync::Arc, time::{Duration, Instant}, @@ -7,10 +7,10 @@ use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions}; use temporal_sdk::{ActContext, ActivityOptions, WfContext, WorkflowResult}; use temporal_sdk_core::{ResourceBasedTuner, ResourceSlotOptions}; use temporal_sdk_core_protos::{ - coresdk::{workflow_commands::ActivityCancellationType, AsJsonPayloadExt}, + coresdk::{AsJsonPayloadExt, workflow_commands::ActivityCancellationType}, temporal::api::enums::v1::WorkflowIdReusePolicy, }; -use temporal_sdk_core_test_utils::{workflows::la_problem_workflow, CoreWfStarter}; +use temporal_sdk_core_test_utils::{CoreWfStarter, workflows::la_problem_workflow}; mod fuzzy_workflow; diff --git a/tests/integ_tests/client_tests.rs b/tests/integ_tests/client_tests.rs index 082d9d9fa..aa959644e 100644 --- a/tests/integ_tests/client_tests.rs +++ b/tests/integ_tests/client_tests.rs @@ -1,5 +1,5 @@ use assert_matches::assert_matches; -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use http_body_util::BodyExt; use prost::Message; use std::{ @@ -7,14 +7,14 @@ use std::{ convert::Infallible, env, sync::{ - atomic::{AtomicUsize, Ordering}, Arc, + atomic::{AtomicUsize, Ordering}, }, task::{Context, Poll}, time::Duration, }; use temporal_client::{ - Namespace, RetryConfig, WorkflowClientTrait, WorkflowService, RETRYABLE_ERROR_CODES, + Namespace, RETRYABLE_ERROR_CODES, RetryConfig, WorkflowClientTrait, WorkflowService, }; use temporal_sdk_core_protos::temporal::api::{ cloud::cloudservice::v1::GetNamespaceRequest, @@ -23,17 +23,17 @@ use temporal_sdk_core_protos::temporal::api::{ RespondActivityTaskCanceledResponse, }, }; -use temporal_sdk_core_test_utils::{get_integ_server_options, CoreWfStarter, NAMESPACE}; +use temporal_sdk_core_test_utils::{CoreWfStarter, NAMESPACE, get_integ_server_options}; use tokio::{ net::TcpListener, sync::{mpsc::UnboundedSender, oneshot}, }; use tonic::{ + Code, Request, Status, body::BoxBody, - codegen::{http::Response, Service}, + codegen::{Service, http::Response}, server::NamedService, transport::Server, - Code, Request, Status, }; use tracing::info; diff --git a/tests/integ_tests/ephemeral_server_tests.rs b/tests/integ_tests/ephemeral_server_tests.rs index b35520392..453b00c34 100644 --- a/tests/integ_tests/ephemeral_server_tests.rs +++ b/tests/integ_tests/ephemeral_server_tests.rs @@ -1,4 +1,4 @@ -use futures_util::{stream, TryStreamExt}; +use futures_util::{TryStreamExt, stream}; use std::time::{SystemTime, UNIX_EPOCH}; use temporal_client::{ClientOptionsBuilder, TestService, WorkflowService}; use temporal_sdk_core::ephemeral_server::{ @@ -6,7 +6,7 @@ use temporal_sdk_core::ephemeral_server::{ TestServerConfigBuilder, }; use temporal_sdk_core_protos::temporal::api::workflowservice::v1::DescribeNamespaceRequest; -use temporal_sdk_core_test_utils::{default_cached_download, NAMESPACE}; +use temporal_sdk_core_test_utils::{NAMESPACE, default_cached_download}; use url::Url; #[tokio::test] diff --git a/tests/integ_tests/heartbeat_tests.rs b/tests/integ_tests/heartbeat_tests.rs index 7d1fe1e5f..2cd6994ef 100644 --- a/tests/integ_tests/heartbeat_tests.rs +++ b/tests/integ_tests/heartbeat_tests.rs @@ -3,25 +3,25 @@ use std::time::Duration; use temporal_client::{WfClientExt, WorkflowOptions}; use temporal_sdk::{ActContext, ActivityOptions, WfContext}; use temporal_sdk_core_protos::{ + DEFAULT_ACTIVITY_TYPE, coresdk::{ + ActivityHeartbeat, ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion, activity_result::{ - self, activity_resolution as act_res, ActivityExecutionResult, ActivityResolution, + self, ActivityExecutionResult, ActivityResolution, activity_resolution as act_res, }, activity_task::activity_task, - workflow_activation::{workflow_activation_job, ResolveActivity, WorkflowActivationJob}, + workflow_activation::{ResolveActivity, WorkflowActivationJob, workflow_activation_job}, 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, + CoreWfStarter, WorkerTestHelpers, drain_pollers_and_shutdown, init_core_and_create_wf, + schedule_activity_cmd, }; use tokio::time::sleep; diff --git a/tests/integ_tests/metrics_tests.rs b/tests/integ_tests/metrics_tests.rs index ffe539ed6..16bb9568b 100644 --- a/tests/integ_tests/metrics_tests.rs +++ b/tests/integ_tests/metrics_tests.rs @@ -10,40 +10,39 @@ use std::{ time::Duration, }; use temporal_client::{ - WorkflowClientTrait, WorkflowOptions, WorkflowService, REQUEST_LATENCY_HISTOGRAM_NAME, + REQUEST_LATENCY_HISTOGRAM_NAME, WorkflowClientTrait, WorkflowOptions, WorkflowService, }; use temporal_sdk::{ ActContext, ActivityError, ActivityOptions, CancellableFuture, LocalActivityOptions, NexusOperationOptions, WfContext, }; use temporal_sdk_core::{ - init_worker, + CoreRuntime, TokioRuntimeBuilder, init_worker, telemetry::{build_otlp_metric_exporter, start_prometheus_metric_exporter}, - CoreRuntime, TokioRuntimeBuilder, }; use temporal_sdk_core_api::{ + Worker, errors::PollError, telemetry::{ - metrics::{CoreMeter, MetricAttributes, MetricParameters}, HistogramBucketOverrides, OtelCollectorOptionsBuilder, OtlpProtocol, PrometheusExporterOptions, PrometheusExporterOptionsBuilder, TelemetryOptions, TelemetryOptionsBuilder, + metrics::{CoreMeter, MetricAttributes, MetricParameters}, }, worker::WorkerConfigBuilder, - Worker, }; use temporal_sdk_core_protos::{ coresdk::{ + ActivityTaskCompletion, AsJsonPayloadExt, activity_result::ActivityExecutionResult, - nexus::{nexus_task, nexus_task_completion, NexusTaskCompletion}, - workflow_activation::{workflow_activation_job, WorkflowActivationJob}, + nexus::{NexusTaskCompletion, nexus_task, nexus_task_completion}, + workflow_activation::{WorkflowActivationJob, workflow_activation_job}, workflow_commands::{ - workflow_command, CancelWorkflowExecution, CompleteWorkflowExecution, - ContinueAsNewWorkflowExecution, FailWorkflowExecution, QueryResult, QuerySuccess, - ScheduleActivity, ScheduleLocalActivity, + CancelWorkflowExecution, CompleteWorkflowExecution, ContinueAsNewWorkflowExecution, + FailWorkflowExecution, QueryResult, QuerySuccess, ScheduleActivity, + ScheduleLocalActivity, workflow_command, }, workflow_completion::WorkflowActivationCompletion, - ActivityTaskCompletion, AsJsonPayloadExt, }, temporal::api::{ common::v1::RetryPolicy, @@ -51,16 +50,16 @@ use temporal_sdk_core_protos::{ failure::v1::Failure, nexus, nexus::v1::{ - request::Variant, start_operation_response, HandlerError, StartOperationResponse, - UnsuccessfulOperationError, + HandlerError, StartOperationResponse, UnsuccessfulOperationError, request::Variant, + start_operation_response, }, query::v1::WorkflowQuery, workflowservice::v1::{DescribeNamespaceRequest, ListNamespacesRequest}, }, }; use temporal_sdk_core_test_utils::{ - get_integ_server_options, get_integ_telem_options, CoreWfStarter, NAMESPACE, OTEL_URL_ENV_VAR, - PROMETHEUS_QUERY_API, + CoreWfStarter, NAMESPACE, OTEL_URL_ENV_VAR, PROMETHEUS_QUERY_API, get_integ_server_options, + get_integ_telem_options, }; use tokio::{join, sync::Barrier, task::AbortHandle}; use tracing_subscriber::fmt::MakeWriter; @@ -627,9 +626,11 @@ async fn latency_metrics( .filter(|l| l.starts_with("temporal_long_request_latency")) .collect::>(); assert!(matching_lines.len() > 1); - assert!(matching_lines - .iter() - .any(|l| l.contains("PollWorkflowTaskQueue"))); + assert!( + matching_lines + .iter() + .any(|l| l.contains("PollWorkflowTaskQueue")) + ); } #[tokio::test] @@ -769,10 +770,12 @@ async fn docker_metrics_with_prometheus( assert!(!data.is_empty(), "No metrics found for query: {test_uid}"); assert_eq!(data[0]["metric"]["exported_job"], "temporal-core-sdk"); assert_eq!(data[0]["metric"]["job"], "otel-collector"); - assert!(data[0]["metric"]["task_queue"] - .as_str() - .unwrap() - .starts_with(test_name)); + assert!( + data[0]["metric"]["task_queue"] + .as_str() + .unwrap() + .starts_with(test_name) + ); } else { panic!("Invalid Prometheus response: {:?}", response); } diff --git a/tests/integ_tests/polling_tests.rs b/tests/integ_tests/polling_tests.rs index e40cf5afa..c3e6ea6d5 100644 --- a/tests/integ_tests/polling_tests.rs +++ b/tests/integ_tests/polling_tests.rs @@ -2,19 +2,19 @@ use assert_matches::assert_matches; use std::{sync::Arc, time::Duration}; use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions}; use temporal_sdk_core::{ - ephemeral_server::TemporalDevServerConfigBuilder, init_worker, ClientOptionsBuilder, + ClientOptionsBuilder, ephemeral_server::TemporalDevServerConfigBuilder, init_worker, }; use temporal_sdk_core_api::Worker; use temporal_sdk_core_protos::coresdk::{ + IntoCompletion, activity_task::activity_task as act_task, - workflow_activation::{workflow_activation_job, FireTimer, WorkflowActivationJob}, + workflow_activation::{FireTimer, WorkflowActivationJob, workflow_activation_job}, workflow_commands::{ActivityCancellationType, RequestCancelActivity, StartTimer}, workflow_completion::WorkflowActivationCompletion, - IntoCompletion, }; use temporal_sdk_core_test_utils::{ - default_cached_download, drain_pollers_and_shutdown, init_core_and_create_wf, init_integ_telem, - integ_worker_config, schedule_activity_cmd, WorkerTestHelpers, + WorkerTestHelpers, default_cached_download, drain_pollers_and_shutdown, + init_core_and_create_wf, init_integ_telem, integ_worker_config, schedule_activity_cmd, }; use tokio::time::timeout; use tracing::info; diff --git a/tests/integ_tests/queries_tests.rs b/tests/integ_tests/queries_tests.rs index eeb3daa20..e88135af2 100644 --- a/tests/integ_tests/queries_tests.rs +++ b/tests/integ_tests/queries_tests.rs @@ -1,17 +1,17 @@ use assert_matches::assert_matches; -use futures_util::{future::join_all, stream::FuturesUnordered, FutureExt, StreamExt}; +use futures_util::{FutureExt, StreamExt, future::join_all, stream::FuturesUnordered}; use std::time::{Duration, Instant}; use temporal_client::WorkflowClientTrait; use temporal_sdk_core_protos::{ coresdk::{ - workflow_activation::{workflow_activation_job, WorkflowActivationJob}, + workflow_activation::{WorkflowActivationJob, workflow_activation_job}, workflow_commands::{QueryResult, QuerySuccess, StartTimer}, workflow_completion::WorkflowActivationCompletion, }, temporal::api::{failure::v1::Failure, query::v1::WorkflowQuery}, }; use temporal_sdk_core_test_utils::{ - drain_pollers_and_shutdown, init_core_and_create_wf, CoreWfStarter, WorkerTestHelpers, + CoreWfStarter, WorkerTestHelpers, drain_pollers_and_shutdown, init_core_and_create_wf, }; use tokio::join; @@ -125,9 +125,11 @@ async fn query_after_execution_complete(#[case] do_evict: bool) { // When we see the query, handle it. if go_until_query { - if let [WorkflowActivationJob { - variant: Some(workflow_activation_job::Variant::QueryWorkflow(query)), - }] = task.jobs.as_slice() + if let [ + WorkflowActivationJob { + variant: Some(workflow_activation_job::Variant::QueryWorkflow(query)), + }, + ] = task.jobs.as_slice() { core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd( task.run_id, diff --git a/tests/integ_tests/update_tests.rs b/tests/integ_tests/update_tests.rs index c729f8643..1baffbad8 100644 --- a/tests/integ_tests/update_tests.rs +++ b/tests/integ_tests/update_tests.rs @@ -1,10 +1,10 @@ use anyhow::anyhow; use assert_matches::assert_matches; -use futures_util::{future, future::join_all, StreamExt}; +use futures_util::{StreamExt, future, future::join_all}; use std::{ sync::{ - atomic::{AtomicBool, AtomicUsize, Ordering}, Arc, LazyLock, + atomic::{AtomicBool, AtomicUsize, Ordering}, }, time::Duration, }; @@ -16,15 +16,15 @@ use temporal_sdk_core::replay::HistoryForReplay; use temporal_sdk_core_api::Worker; use temporal_sdk_core_protos::{ coresdk::{ + ActivityTaskCompletion, AsJsonPayloadExt, IntoPayloadsExt, activity_result::ActivityExecutionResult, workflow_activation::{ - remove_from_cache::EvictionReason, workflow_activation_job, WorkflowActivationJob, + WorkflowActivationJob, remove_from_cache::EvictionReason, workflow_activation_job, }, workflow_commands::{ - update_response, CompleteWorkflowExecution, ScheduleLocalActivity, UpdateResponse, + CompleteWorkflowExecution, ScheduleLocalActivity, UpdateResponse, update_response, }, workflow_completion::WorkflowActivationCompletion, - ActivityTaskCompletion, AsJsonPayloadExt, IntoPayloadsExt, }, temporal::api::{ common::v1::WorkflowExecution, @@ -34,8 +34,8 @@ use temporal_sdk_core_protos::{ }, }; use temporal_sdk_core_test_utils::{ - drain_pollers_and_shutdown, init_core_and_create_wf, init_core_replay_preloaded, - start_timer_cmd, CoreWfStarter, WorkerTestHelpers, WorkflowHandleExt, + CoreWfStarter, WorkerTestHelpers, WorkflowHandleExt, drain_pollers_and_shutdown, + init_core_and_create_wf, init_core_replay_preloaded, start_timer_cmd, }; use tokio::{join, sync::Barrier}; use uuid::Uuid; @@ -614,11 +614,13 @@ async fn update_speculative_wft() { // Reject the update core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds( res.run_id, - vec![UpdateResponse { - protocol_instance_id: pid.to_string(), - response: Some(update_response::Response::Rejected("nope!".into())), - } - .into()], + vec![ + UpdateResponse { + protocol_instance_id: pid.to_string(), + response: Some(update_response::Response::Rejected("nope!".into())), + } + .into(), + ], )) .await .unwrap(); diff --git a/tests/integ_tests/visibility_tests.rs b/tests/integ_tests/visibility_tests.rs index 086dab157..5b9f75e89 100644 --- a/tests/integ_tests/visibility_tests.rs +++ b/tests/integ_tests/visibility_tests.rs @@ -5,11 +5,11 @@ use temporal_client::{ WorkflowClientTrait, WorkflowExecutionFilter, }; use temporal_sdk_core_protos::coresdk::workflow_activation::{ - workflow_activation_job, WorkflowActivationJob, + WorkflowActivationJob, workflow_activation_job, }; use temporal_sdk_core_test_utils::{ - drain_pollers_and_shutdown, get_integ_server_options, CoreWfStarter, WorkerTestHelpers, - NAMESPACE, + CoreWfStarter, NAMESPACE, WorkerTestHelpers, drain_pollers_and_shutdown, + get_integ_server_options, }; use tokio::time::sleep; diff --git a/tests/integ_tests/worker_tests.rs b/tests/integ_tests/worker_tests.rs index 87f304b6d..82508f9e0 100644 --- a/tests/integ_tests/worker_tests.rs +++ b/tests/integ_tests/worker_tests.rs @@ -1,17 +1,17 @@ use assert_matches::assert_matches; use std::{cell::Cell, sync::Arc, time::Duration}; use temporal_client::WorkflowOptions; -use temporal_sdk::{interceptors::WorkerInterceptor, WfContext}; -use temporal_sdk_core::{init_worker, CoreRuntime, ResourceBasedTuner, ResourceSlotOptions}; -use temporal_sdk_core_api::{errors::WorkerValidationError, worker::WorkerConfigBuilder, Worker}; +use temporal_sdk::{WfContext, interceptors::WorkerInterceptor}; +use temporal_sdk_core::{CoreRuntime, ResourceBasedTuner, ResourceSlotOptions, init_worker}; +use temporal_sdk_core_api::{Worker, errors::WorkerValidationError, worker::WorkerConfigBuilder}; use temporal_sdk_core_protos::{ coresdk::workflow_completion::{ - workflow_activation_completion::Status, Failure, WorkflowActivationCompletion, + Failure, WorkflowActivationCompletion, workflow_activation_completion::Status, }, temporal::api::failure::v1::Failure as InnerFailure, }; use temporal_sdk_core_test_utils::{ - drain_pollers_and_shutdown, get_integ_server_options, get_integ_telem_options, CoreWfStarter, + CoreWfStarter, drain_pollers_and_shutdown, get_integ_server_options, get_integ_telem_options, }; use tokio::sync::Notify; use uuid::Uuid; diff --git a/tests/integ_tests/workflow_tests.rs b/tests/integ_tests/workflow_tests.rs index 31aeed9b5..7e705c957 100644 --- a/tests/integ_tests/workflow_tests.rs +++ b/tests/integ_tests/workflow_tests.rs @@ -26,20 +26,20 @@ use std::{ }; use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowExecutionResult, WorkflowOptions}; use temporal_sdk::{ - interceptors::WorkerInterceptor, ActivityOptions, LocalActivityOptions, WfContext, - WorkflowResult, + ActivityOptions, LocalActivityOptions, WfContext, WorkflowResult, + interceptors::WorkerInterceptor, }; -use temporal_sdk_core::{replay::HistoryForReplay, CoreRuntime}; +use temporal_sdk_core::{CoreRuntime, replay::HistoryForReplay}; use temporal_sdk_core_api::errors::{PollError, WorkflowErrorType}; use temporal_sdk_core_protos::{ coresdk::{ + ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion, activity_result::ActivityExecutionResult, - workflow_activation::{workflow_activation_job, WorkflowActivationJob}, + workflow_activation::{WorkflowActivationJob, workflow_activation_job}, workflow_commands::{ ActivityCancellationType, FailWorkflowExecution, QueryResult, QuerySuccess, StartTimer, }, workflow_completion::WorkflowActivationCompletion, - ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion, }, temporal::api::{ enums::v1::EventType, failure::v1::Failure, history::v1::history_event, @@ -47,8 +47,8 @@ use temporal_sdk_core_protos::{ }, }; use temporal_sdk_core_test_utils::{ - drain_pollers_and_shutdown, history_from_proto_binary, init_core_and_create_wf, - init_core_replay_preloaded, schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers, + CoreWfStarter, WorkerTestHelpers, drain_pollers_and_shutdown, history_from_proto_binary, + init_core_and_create_wf, init_core_replay_preloaded, schedule_activity_cmd, }; use tokio::{join, sync::Notify, time::sleep}; use uuid::Uuid; @@ -200,11 +200,13 @@ async fn fail_wf_task(#[values(true, false)] replay: bool) { let task = core.poll_workflow_activation().await.unwrap(); core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds( task.run_id, - vec![StartTimer { - seq: 0, - start_to_fire_timeout: Some(prost_dur!(from_millis(200))), - } - .into()], + vec![ + StartTimer { + seq: 0, + start_to_fire_timeout: Some(prost_dur!(from_millis(200))), + } + .into(), + ], )) .await .unwrap(); @@ -224,10 +226,12 @@ async fn fail_workflow_execution() { let task = core.poll_workflow_activation().await.unwrap(); core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds( task.run_id, - vec![FailWorkflowExecution { - failure: Some(Failure::application_failure("I'm ded".to_string(), false)), - } - .into()], + vec![ + FailWorkflowExecution { + failure: Some(Failure::application_failure("I'm ded".to_string(), false)), + } + .into(), + ], )) .await .unwrap(); @@ -324,11 +328,13 @@ async fn signal_workflow_signal_not_handled_on_workflow_completion() { // Task is completed with a timer core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds( res.run_id, - vec![StartTimer { - seq: 0, - start_to_fire_timeout: Some(prost_dur!(from_millis(10))), - } - .into()], + vec![ + StartTimer { + seq: 0, + start_to_fire_timeout: Some(prost_dur!(from_millis(10))), + } + .into(), + ], )) .await .unwrap(); diff --git a/tests/integ_tests/workflow_tests/activities.rs b/tests/integ_tests/workflow_tests/activities.rs index 10c9a32f4..d2f419a31 100644 --- a/tests/integ_tests/workflow_tests/activities.rs +++ b/tests/integ_tests/workflow_tests/activities.rs @@ -12,31 +12,31 @@ use temporal_sdk::{ WfExitValue, WorkflowResult, }; use temporal_sdk_core_protos::{ + DEFAULT_ACTIVITY_TYPE, TaskToken, coresdk::{ + ActivityHeartbeat, ActivityTaskCompletion, AsJsonPayloadExt, FromJsonPayloadExt, + IntoCompletion, activity_result::{ - self, activity_resolution as act_res, ActivityExecutionResult, ActivityResolution, + self, ActivityExecutionResult, ActivityResolution, activity_resolution as act_res, }, activity_task::activity_task as act_task, workflow_activation::{ - workflow_activation_job, FireTimer, ResolveActivity, WorkflowActivationJob, + FireTimer, ResolveActivity, WorkflowActivationJob, workflow_activation_job, }, workflow_commands::{ ActivityCancellationType, RequestCancelActivity, ScheduleActivity, StartTimer, }, workflow_completion::WorkflowActivationCompletion, - ActivityHeartbeat, ActivityTaskCompletion, AsJsonPayloadExt, FromJsonPayloadExt, - IntoCompletion, }, temporal::api::{ common::v1::{ActivityType, Payload, Payloads, RetryPolicy}, enums::v1::RetryState, - failure::v1::{failure::FailureInfo, ActivityFailureInfo, Failure}, + failure::v1::{ActivityFailureInfo, Failure, failure::FailureInfo}, }, - TaskToken, DEFAULT_ACTIVITY_TYPE, }; use temporal_sdk_core_test_utils::{ - drain_pollers_and_shutdown, init_core_and_create_wf, schedule_activity_cmd, CoreWfStarter, - WorkerTestHelpers, + CoreWfStarter, WorkerTestHelpers, drain_pollers_and_shutdown, init_core_and_create_wf, + schedule_activity_cmd, }; use tokio::{join, sync::Semaphore, time::sleep}; @@ -458,11 +458,13 @@ async fn activity_cancellation_plus_complete_doesnt_double_resolve() { // another short timer core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds( task.run_id, - vec![StartTimer { - seq: 2, - start_to_fire_timeout: Some(prost_dur!(from_millis(100))), - } - .into()], + vec![ + StartTimer { + seq: 2, + start_to_fire_timeout: Some(prost_dur!(from_millis(100))), + } + .into(), + ], )) .await .unwrap(); diff --git a/tests/integ_tests/workflow_tests/cancel_external.rs b/tests/integ_tests/workflow_tests/cancel_external.rs index c46cfe657..4fe994dd1 100644 --- a/tests/integ_tests/workflow_tests/cancel_external.rs +++ b/tests/integ_tests/workflow_tests/cancel_external.rs @@ -1,6 +1,6 @@ use temporal_client::{GetWorkflowResultOpts, WfClientExt, WorkflowOptions}; use temporal_sdk::{WfContext, WorkflowResult}; -use temporal_sdk_core_protos::coresdk::{common::NamespacedWorkflowExecution, FromJsonPayloadExt}; +use temporal_sdk_core_protos::coresdk::{FromJsonPayloadExt, common::NamespacedWorkflowExecution}; use temporal_sdk_core_test_utils::CoreWfStarter; const RECEIVER_WFID: &str = "sends-cancel-receiver"; diff --git a/tests/integ_tests/workflow_tests/child_workflows.rs b/tests/integ_tests/workflow_tests/child_workflows.rs index 668f4fe32..0535800f8 100644 --- a/tests/integ_tests/workflow_tests/child_workflows.rs +++ b/tests/integ_tests/workflow_tests/child_workflows.rs @@ -5,8 +5,8 @@ use temporal_client::{WorkflowClientTrait, WorkflowOptions}; use temporal_sdk::{ChildWorkflowOptions, WfContext, WfExitValue, WorkflowResult}; use temporal_sdk_core_protos::{ coresdk::{ - child_workflow::{child_workflow_result, ChildWorkflowCancellationType, Success}, AsJsonPayloadExt, + child_workflow::{ChildWorkflowCancellationType, Success, child_workflow_result}, }, temporal::api::enums::v1::ParentClosePolicy, }; diff --git a/tests/integ_tests/workflow_tests/eager.rs b/tests/integ_tests/workflow_tests/eager.rs index d75041781..bdb921d7d 100644 --- a/tests/integ_tests/workflow_tests/eager.rs +++ b/tests/integ_tests/workflow_tests/eager.rs @@ -1,7 +1,7 @@ use std::time::Duration; use temporal_client::WorkflowClientTrait; use temporal_sdk::{WfContext, WorkflowResult}; -use temporal_sdk_core_test_utils::{get_integ_server_options, CoreWfStarter, NAMESPACE}; +use temporal_sdk_core_test_utils::{CoreWfStarter, NAMESPACE, get_integ_server_options}; pub(crate) async fn eager_wf(_context: WfContext) -> WorkflowResult<()> { Ok(().into()) diff --git a/tests/integ_tests/workflow_tests/local_activities.rs b/tests/integ_tests/workflow_tests/local_activities.rs index dc90620ee..23c3973a8 100644 --- a/tests/integ_tests/workflow_tests/local_activities.rs +++ b/tests/integ_tests/workflow_tests/local_activities.rs @@ -7,23 +7,23 @@ use std::{ }; use temporal_client::{WfClientExt, WorkflowOptions}; use temporal_sdk::{ - interceptors::WorkerInterceptor, ActContext, ActivityError, ActivityOptions, CancellableFuture, - LocalActivityOptions, WfContext, WorkflowResult, + ActContext, ActivityError, ActivityOptions, CancellableFuture, LocalActivityOptions, WfContext, + WorkflowResult, interceptors::WorkerInterceptor, }; use temporal_sdk_core::replay::HistoryForReplay; use temporal_sdk_core_protos::{ + TestHistoryBuilder, coresdk::{ - workflow_commands::{workflow_command::Variant, ActivityCancellationType}, - workflow_completion, - workflow_completion::{workflow_activation_completion, WorkflowActivationCompletion}, AsJsonPayloadExt, + workflow_commands::{ActivityCancellationType, workflow_command::Variant}, + workflow_completion, + workflow_completion::{WorkflowActivationCompletion, workflow_activation_completion}, }, temporal::api::{common::v1::RetryPolicy, enums::v1::TimeoutType}, - TestHistoryBuilder, }; use temporal_sdk_core_test_utils::{ - history_from_proto_binary, replay_sdk_worker, workflows::la_problem_workflow, CoreWfStarter, - WorkflowHandleExt, + CoreWfStarter, WorkflowHandleExt, history_from_proto_binary, replay_sdk_worker, + workflows::la_problem_workflow, }; use tokio_util::sync::CancellationToken; diff --git a/tests/integ_tests/workflow_tests/nexus.rs b/tests/integ_tests/workflow_tests/nexus.rs index 74d77ad94..7881458fc 100644 --- a/tests/integ_tests/workflow_tests/nexus.rs +++ b/tests/integ_tests/workflow_tests/nexus.rs @@ -7,23 +7,23 @@ use temporal_sdk::{CancellableFuture, NexusOperationOptions, WfContext, WfExitVa use temporal_sdk_core_api::errors::PollError; use temporal_sdk_core_protos::{ coresdk::{ + FromJsonPayloadExt, nexus::{ - nexus_operation_result, nexus_task, nexus_task_completion, NexusOperationResult, - NexusTaskCancelReason, NexusTaskCompletion, + NexusOperationResult, NexusTaskCancelReason, NexusTaskCompletion, + nexus_operation_result, nexus_task, nexus_task_completion, }, - FromJsonPayloadExt, }, temporal::api::{ - common::v1::{callback, Callback}, + common::v1::{Callback, callback}, failure::v1::failure::FailureInfo, nexus, nexus::v1::{ - request, start_operation_response, workflow_event_link_from_nexus, - CancelOperationResponse, HandlerError, StartOperationResponse, + CancelOperationResponse, HandlerError, StartOperationResponse, request, + start_operation_response, workflow_event_link_from_nexus, }, }, }; -use temporal_sdk_core_test_utils::{rand_6_chars, CoreWfStarter}; +use temporal_sdk_core_test_utils::{CoreWfStarter, rand_6_chars}; use tokio::{join, sync::mpsc}; #[derive(Debug, PartialEq, Eq, Clone, Copy)] diff --git a/tests/integ_tests/workflow_tests/patches.rs b/tests/integ_tests/workflow_tests/patches.rs index 326938a18..da42d2017 100644 --- a/tests/integ_tests/workflow_tests/patches.rs +++ b/tests/integ_tests/workflow_tests/patches.rs @@ -1,7 +1,7 @@ use std::{ sync::{ - atomic::{AtomicBool, Ordering}, Arc, + atomic::{AtomicBool, Ordering}, }, time::Duration, }; diff --git a/tests/integ_tests/workflow_tests/replay.rs b/tests/integ_tests/workflow_tests/replay.rs index 4a58d8542..18eeffbc3 100644 --- a/tests/integ_tests/workflow_tests/replay.rs +++ b/tests/integ_tests/workflow_tests/replay.rs @@ -2,21 +2,21 @@ use crate::integ_tests::workflow_tests::patches::changes_wf; use assert_matches::assert_matches; use parking_lot::Mutex; use std::{collections::HashSet, sync::Arc, time::Duration}; -use temporal_sdk::{interceptors::WorkerInterceptor, WfContext, Worker, WorkflowFunction}; +use temporal_sdk::{WfContext, Worker, WorkflowFunction, interceptors::WorkerInterceptor}; use temporal_sdk_core::replay::{HistoryFeeder, HistoryForReplay}; use temporal_sdk_core_api::errors::PollError; use temporal_sdk_core_protos::{ + DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder, coresdk::{ workflow_activation::remove_from_cache::EvictionReason, workflow_commands::{ScheduleActivity, StartTimer}, workflow_completion::WorkflowActivationCompletion, }, temporal::api::enums::v1::EventType, - TestHistoryBuilder, DEFAULT_WORKFLOW_TYPE, }; use temporal_sdk_core_test_utils::{ - canned_histories, history_from_proto_binary, init_core_replay_preloaded, replay_sdk_worker, - replay_sdk_worker_stream, WorkerTestHelpers, + WorkerTestHelpers, canned_histories, history_from_proto_binary, init_core_replay_preloaded, + replay_sdk_worker, replay_sdk_worker_stream, }; use tokio::join; @@ -39,11 +39,13 @@ async fn timer_workflow_replay() { let task = core.poll_workflow_activation().await.unwrap(); core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds( task.run_id, - vec![StartTimer { - seq: 0, - start_to_fire_timeout: Some(prost_dur!(from_secs(1))), - } - .into()], + vec![ + StartTimer { + seq: 0, + start_to_fire_timeout: Some(prost_dur!(from_secs(1))), + } + .into(), + ], )) .await .unwrap(); @@ -94,13 +96,15 @@ async fn workflow_nondeterministic_replay() { let task = core.poll_workflow_activation().await.unwrap(); core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds( task.run_id, - vec![ScheduleActivity { - seq: 0, - activity_id: "0".to_string(), - activity_type: "fake_act".to_string(), - ..Default::default() - } - .into()], + vec![ + ScheduleActivity { + seq: 0, + activity_id: "0".to_string(), + activity_type: "fake_act".to_string(), + ..Default::default() + } + .into(), + ], )) .await .unwrap(); @@ -261,13 +265,15 @@ async fn replay_ends_with_empty_wft() { let task = core.poll_workflow_activation().await.unwrap(); core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds( task.run_id, - vec![ScheduleActivity { - seq: 1, - activity_id: "1".to_string(), - activity_type: "say_hello".to_string(), - ..Default::default() - } - .into()], + vec![ + ScheduleActivity { + seq: 1, + activity_id: "1".to_string(), + activity_type: "say_hello".to_string(), + ..Default::default() + } + .into(), + ], )) .await .unwrap(); diff --git a/tests/integ_tests/workflow_tests/resets.rs b/tests/integ_tests/workflow_tests/resets.rs index 9d4bbf73f..6a4cfac71 100644 --- a/tests/integ_tests/workflow_tests/resets.rs +++ b/tests/integ_tests/workflow_tests/resets.rs @@ -2,8 +2,8 @@ use crate::integ_tests::activity_functions::echo; use futures_util::StreamExt; use std::{ sync::{ - atomic::{AtomicBool, AtomicU64, Ordering}, Arc, + atomic::{AtomicBool, AtomicU64, Ordering}, }, time::Duration, }; diff --git a/tests/integ_tests/workflow_tests/timers.rs b/tests/integ_tests/workflow_tests/timers.rs index dc521def1..97c0f2263 100644 --- a/tests/integ_tests/workflow_tests/timers.rs +++ b/tests/integ_tests/workflow_tests/timers.rs @@ -6,8 +6,8 @@ use temporal_sdk_core_protos::coresdk::{ workflow_completion::WorkflowActivationCompletion, }; use temporal_sdk_core_test_utils::{ - drain_pollers_and_shutdown, init_core_and_create_wf, start_timer_cmd, CoreWfStarter, - WorkerTestHelpers, + CoreWfStarter, WorkerTestHelpers, drain_pollers_and_shutdown, init_core_and_create_wf, + start_timer_cmd, }; pub(crate) async fn timer_wf(command_sink: WfContext) -> WorkflowResult<()> { @@ -35,11 +35,13 @@ async fn timer_workflow_manual() { let task = core.poll_workflow_activation().await.unwrap(); core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds( task.run_id, - vec![StartTimer { - seq: 0, - start_to_fire_timeout: Some(prost_dur!(from_secs(1))), - } - .into()], + vec![ + StartTimer { + seq: 0, + start_to_fire_timeout: Some(prost_dur!(from_secs(1))), + } + .into(), + ], )) .await .unwrap(); diff --git a/tests/main.rs b/tests/main.rs index 5995224c8..84a8f2bc6 100644 --- a/tests/main.rs +++ b/tests/main.rs @@ -22,17 +22,17 @@ mod integ_tests { use std::{env, str::FromStr, time::Duration}; use temporal_client::{NamespacedClient, WorkflowService}; use temporal_sdk_core::{ - init_worker, ClientOptionsBuilder, ClientTlsConfig, CoreRuntime, TlsConfig, - WorkflowClientTrait, + ClientOptionsBuilder, ClientTlsConfig, CoreRuntime, TlsConfig, WorkflowClientTrait, + init_worker, }; use temporal_sdk_core_api::worker::WorkerConfigBuilder; use temporal_sdk_core_protos::temporal::api::{ - nexus::v1::{endpoint_target, EndpointSpec, EndpointTarget}, + nexus::v1::{EndpointSpec, EndpointTarget, endpoint_target}, operatorservice::v1::CreateNexusEndpointRequest, workflowservice::v1::ListNamespacesRequest, }; use temporal_sdk_core_test_utils::{ - get_integ_server_options, get_integ_telem_options, rand_6_chars, CoreWfStarter, + CoreWfStarter, get_integ_server_options, get_integ_telem_options, rand_6_chars, }; use url::Url; diff --git a/tests/runner.rs b/tests/runner.rs index 0b529d3c3..dc49f0a77 100644 --- a/tests/runner.rs +++ b/tests/runner.rs @@ -9,8 +9,8 @@ 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, SEARCH_ATTR_INT, SEARCH_ATTR_TXT, + INTEG_SERVER_TARGET_ENV_VAR, INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR, + INTEG_TEST_SERVER_USED_ENV_VAR, SEARCH_ATTR_INT, SEARCH_ATTR_TXT, default_cached_download, }; use tokio::{self, process::Command};