@temporalio/core-bridge 0.14.0 → 0.16.4

package/sdk-core/fsm/rustfsm_procmacro/src/lib.rs

@@ -1,5 +1,3 @@
-extern crate proc_macro;
-
 use proc_macro::TokenStream;
 use quote::{quote, quote_spanned};
 use std::collections::{hash_map::Entry, HashMap, HashSet};
@@ -82,7 +80,7 @@ use syn::{
 ///                     ReadingCard { card_data: data.clone() }.into(),
 ///                     SharedState { last_id: Some(data) }
 ///                 )
-///             }   
+///             }
 ///         }
 ///     }
 /// }
@@ -200,7 +198,7 @@ impl Parse for StateMachineDefinition {
         // Parse visibility if present
         let visibility = input.parse()?;
         // parse the state machine name, command type, and error type
-        let (name, command_type, error_type, shared_state_type) = parse_machine_types(&input)
+        let (name, command_type, error_type, shared_state_type) = parse_machine_types(input)
             .map_err(|mut e| {
                 e.combine(Error::new(
                     e.span(),
@@ -235,7 +233,7 @@ impl Parse for StateMachineDefinition {
     }
 }
 
-fn parse_machine_types(input: &ParseStream) -> Result<(Ident, Ident, Ident, Option<Type>)> {
+fn parse_machine_types(input: ParseStream) -> Result<(Ident, Ident, Ident, Option<Type>)> {
     let _: kw::name = input.parse()?;
     let name: Ident = input.parse()?;
     input.parse::<Token![;]>()?;
@@ -443,7 +441,7 @@ impl StateMachineDefinition {
                                         },
                             multi_dests => {
                                 let string_dests: Vec<_> = multi_dests.iter()
-                                    .map(|i| i.to_string()).collect();
+                                    .map(ToString::to_string).collect();
                                 let enum_ident = Ident::new(&string_dests.join("Or"),
                                                             multi_dests[0].span());
                                 let multi_dest_enum = quote! {
@@ -558,6 +556,7 @@ impl StateMachineDefinition {
                 fn state(&self) -> &Self::State {
                     &self.state
                 }
+
                 fn set_state(&mut self, new: Self::State) {
                     self.state = new
                 }
@@ -590,7 +589,7 @@ impl StateMachineDefinition {
             #trait_impl
         };
 
-        output.into()
+        TokenStream::from(output)
     }
 
     fn all_states(&self) -> HashSet<Ident> {
@@ -628,7 +627,7 @@ impl StateMachineDefinition {
 /// Merge transition's dest state lists for those with the same from state & handler
 fn merge_transition_dests(transitions: Vec<Transition>) -> Vec<Transition> {
     let mut map = HashMap::<_, Transition>::new();
-    transitions.into_iter().for_each(|t| {
+    for t in transitions {
         // We want to use the transition sans-destinations as the key
         let without_dests = {
             let mut wd = t.clone();
@@ -643,6 +642,6 @@ fn merge_transition_dests(transitions: Vec<Transition>) -> Vec<Transition> {
                 v.insert(t);
             }
         }
-    });
+    }
     map.into_iter().map(|(_, v)| v).collect()
 }

package/sdk-core/fsm/rustfsm_procmacro/tests/trybuild/no_handle_conversions_require_into_fail.stderr

@@ -1,8 +1,14 @@
 error[E0277]: the trait bound `One: From<Two>` is not satisfied
-  --> $DIR/no_handle_conversions_require_into_fail.rs:11:18
-   |
-11 |     Two --(B)--> One;
-   |                  ^^^ the trait `From<Two>` is not implemented for `One`
-   |
-   = note: required because of the requirements on the impl of `Into<One>` for `Two`
-   = note: required by `TransitionResult::<Sm, Ds>::from`
+   --> tests/trybuild/no_handle_conversions_require_into_fail.rs:11:18
+    |
+11  |     Two --(B)--> One;
+    |                  ^^^ the trait `From<Two>` is not implemented for `One`
+    |
+    = note: required because of the requirements on the impl of `Into<One>` for `Two`
+note: required by `TransitionResult::<Sm, Ds>::from`
+   --> $WORKSPACE/fsm/rustfsm_trait/src/lib.rs
+    |
+    | /     pub fn from<CurrentState>(current_state: CurrentState) -> Self
+    | |     where
+    | |         CurrentState: Into<Ds>,
+    | |_______________________________^

package/sdk-core/fsm/rustfsm_trait/Cargo.toml

@@ -2,7 +2,7 @@
 name = "rustfsm_trait"
 version = "0.1.0"
 authors = ["Spencer Judge <spencer@temporal.io>"]
-edition = "2018"
+edition = "2021"
 license-file = "LICENSE.txt"
 description = "Trait sub-crate of the `rustfsm` crate"
 
@@ -11,4 +11,4 @@ description = "Trait sub-crate of the `rustfsm` crate"
 [dependencies]
 
 [package.metadata.workspaces]
-independent = true
+independent = true

package/sdk-core/fsm/rustfsm_trait/src/lib.rs

@@ -112,7 +112,7 @@ where
     pub fn unwrap(self) -> Vec<M::Command> {
         match self {
             Self::Ok { commands } => commands,
-            _ => panic!("Transition was not successful!"),
+            Self::InvalidTransition => panic!("Transition was not successful!"),
         }
     }
 }

package/sdk-core/protos/local/workflow_activation.proto

@@ -59,9 +59,8 @@ message WFActivationJob {
         /// after performing the activation.
         ///
         /// If other job variant are present in the list, this variant will be the last job in the
-        /// job list. The boolean value is irrelevant, since the variant type is what matters. It
-        /// will be set to true if this is the variant.
-        bool remove_from_cache = 50;
+        /// job list. The string value is a reason for eviction.
+        RemoveFromCache remove_from_cache = 50;
     }
 }
 
@@ -187,3 +186,7 @@ message ResolveRequestCancelExternalWorkflow {
     /// type / info.
     temporal.api.failure.v1.Failure failure = 2;
 }
+
+message RemoveFromCache {
+    string reason = 1;
+}

package/sdk-core/sdk-core-protos/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "temporal-sdk-core-protos"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"
 authors = ["Spencer Judge <spencer@temporal.io>"]
 license-file = "LICENSE.txt"
 description = "Protobuf definitions for Temporal SDKs Core/Lang interface"
@@ -12,9 +12,9 @@ categories = ["development-tools"]
 
 [dependencies]
 derive_more = "0.99"
-prost = "0.8"
-prost-types = "0.8"
-tonic = "0.5"
+prost = "0.9"
+prost-types = "0.9"
+tonic = "0.6"
 
 [build-dependencies]
 tonic-build = "0.5"

package/sdk-core/sdk-core-protos/src/lib.rs

@@ -38,7 +38,7 @@ pub mod coresdk {
                 activity_id: String,
                 reason: ActivityCancelReason,
             ) -> Self {
-                ActivityTask {
+                Self {
                     task_token,
                     activity_id,
                     variant: Some(activity_task::Variant::Cancel(Cancel {
@@ -75,7 +75,7 @@ pub mod coresdk {
                     })),
                 }
             }
-            pub fn will_complete_async() -> Self {
+            pub const fn will_complete_async() -> Self {
                 Self {
                     status: Some(activity_result::Status::WillCompleteAsync(
                         WillCompleteAsync {},
@@ -139,13 +139,13 @@ pub mod coresdk {
         use std::fmt::{Display, Formatter};
 
         tonic::include_proto!("coresdk.workflow_activation");
-        pub fn create_evict_activation(run_id: String) -> WfActivation {
+        pub fn create_evict_activation(run_id: String, reason: String) -> WfActivation {
             WfActivation {
                 timestamp: None,
                 run_id,
                 is_replaying: false,
                 jobs: vec![WfActivationJob::from(
-                    wf_activation_job::Variant::RemoveFromCache(true),
+                    wf_activation_job::Variant::RemoveFromCache(RemoveFromCache { reason }),
                 )],
             }
         }
@@ -195,7 +195,7 @@ pub mod coresdk {
                     "jobs: {})",
                     self.jobs
                         .iter()
-                        .map(|j| j.to_string())
+                        .map(ToString::to_string)
                         .collect::<Vec<_>>()
                         .as_slice()
                         .join(", ")
@@ -264,18 +264,18 @@ pub mod coresdk {
     }
 
     pub mod workflow_completion {
-        use crate::coresdk::workflow_completion::wf_activation_completion::Status;
         tonic::include_proto!("coresdk.workflow_completion");
 
         impl wf_activation_completion::Status {
-            pub fn is_success(&self) -> bool {
+            pub const fn is_success(&self) -> bool {
                 match &self {
-                    Status::Successful(_) => true,
-                    Status::Failed(_) => false,
+                    Self::Successful(_) => true,
+                    Self::Failed(_) => false,
                 }
             }
         }
     }
+
     pub mod child_workflow {
         tonic::include_proto!("coresdk.child_workflow");
     }
@@ -370,7 +370,7 @@ pub mod coresdk {
 
     impl From<wf_activation_job::Variant> for WfActivationJob {
         fn from(a: wf_activation_job::Variant) -> Self {
-            WfActivationJob { variant: Some(a) }
+            Self { variant: Some(a) }
         }
     }
 
@@ -382,7 +382,7 @@ pub mod coresdk {
 
     impl From<workflow_command::Variant> for WorkflowCommand {
         fn from(v: workflow_command::Variant) -> Self {
-            WorkflowCommand { variant: Some(v) }
+            Self { variant: Some(v) }
         }
     }
 
@@ -591,7 +591,7 @@ pub mod coresdk {
     }
 
     impl ActivityResult {
-        pub fn ok(result: Payload) -> Self {
+        pub const fn ok(result: Payload) -> Self {
             Self {
                 status: Some(activity_result::activity_result::Status::Completed(
                     activity_result::Success {
@@ -615,24 +615,18 @@ pub mod coresdk {
                 .workflow_execution
                 .map(|we| (we.workflow_id, we.run_id))
                 .unwrap_or_default();
-            ActivityTask {
+            Self {
                 task_token: r.task_token,
                 activity_id: r.activity_id,
                 variant: Some(activity_task::activity_task::Variant::Start(
                     activity_task::Start {
                         workflow_namespace: r.workflow_namespace,
-                        workflow_type: r
-                            .workflow_type
-                            .map(|wt| wt.name)
-                            .unwrap_or_else(|| "".to_string()),
+                        workflow_type: r.workflow_type.map_or_else(|| "".to_string(), |wt| wt.name),
                         workflow_execution: Some(common::WorkflowExecution {
                             workflow_id,
                             run_id,
                         }),
-                        activity_type: r
-                            .activity_type
-                            .map(|at| at.name)
-                            .unwrap_or_else(|| "".to_string()),
+                        activity_type: r.activity_type.map_or_else(|| "".to_string(), |at| at.name),
                         header_fields: r.header.map(Into::into).unwrap_or_default(),
                         input: Vec::from_payloads(r.input),
                         heartbeat_details: Vec::from_payloads(r.heartbeat_details),
@@ -664,7 +658,7 @@ pub mod coresdk {
 
     impl From<common::WorkflowExecution> for WorkflowExecution {
         fn from(exc: common::WorkflowExecution) -> Self {
-            WorkflowExecution {
+            Self {
                 workflow_id: exc.workflow_id,
                 run_id: exc.run_id,
             }
@@ -767,7 +761,7 @@ pub mod coresdk {
         T: AsRef<[u8]>,
     {
         fn from(v: T) -> Self {
-            Payloads {
+            Self {
                 payloads: vec![v.into()],
             }
         }
@@ -786,10 +780,10 @@ pub mod coresdk {
             match v.payloads.pop() {
                 None => Err(PayloadsToPayloadError::NoPayload),
                 Some(p) => {
-                    if !v.payloads.is_empty() {
-                        Err(PayloadsToPayloadError::MoreThanOnePayload)
-                    } else {
+                    if v.payloads.is_empty() {
                         Ok(p.into())
+                    } else {
+                        Err(PayloadsToPayloadError::MoreThanOnePayload)
                     }
                 }
             }
@@ -1091,26 +1085,22 @@ pub mod temporal {
                 impl HistoryEvent {
                     /// Returns true if this is an event created to mirror a command
                     pub fn is_command_event(&self) -> bool {
-                        if let Some(et) = EventType::from_i32(self.event_type) {
-                            match et {
-                                EventType::ActivityTaskScheduled
-                                | EventType::ActivityTaskCancelRequested
-                                | EventType::MarkerRecorded
-                                | EventType::RequestCancelExternalWorkflowExecutionInitiated
-                                | EventType::SignalExternalWorkflowExecutionInitiated
-                                | EventType::StartChildWorkflowExecutionInitiated
-                                | EventType::TimerCanceled
-                                | EventType::TimerStarted
-                                | EventType::UpsertWorkflowSearchAttributes
-                                | EventType::WorkflowExecutionCanceled
-                                | EventType::WorkflowExecutionCompleted
-                                | EventType::WorkflowExecutionContinuedAsNew
-                                | EventType::WorkflowExecutionFailed => true,
-                                _ => false,
-                            }
-                        } else {
-                            false
-                        }
+                        EventType::from_i32(self.event_type).map_or(false, |et| match et {
+                            EventType::ActivityTaskScheduled
+                            | EventType::ActivityTaskCancelRequested
+                            | EventType::MarkerRecorded
+                            | EventType::RequestCancelExternalWorkflowExecutionInitiated
+                            | EventType::SignalExternalWorkflowExecutionInitiated
+                            | EventType::StartChildWorkflowExecutionInitiated
+                            | EventType::TimerCanceled
+                            | EventType::TimerStarted
+                            | EventType::UpsertWorkflowSearchAttributes
+                            | EventType::WorkflowExecutionCanceled
+                            | EventType::WorkflowExecutionCompleted
+                            | EventType::WorkflowExecutionContinuedAsNew
+                            | EventType::WorkflowExecutionFailed => true,
+                            _ => false,
+                        })
                     }
 
                     /// Returns the command's initiating event id, if present. This is the id of the
@@ -1262,16 +1252,14 @@ pub mod temporal {
                         let last_event = self
                             .history
                             .as_ref()
-                            .map(|h| h.events.last().map(|he| he.event_id))
-                            .flatten()
+                            .and_then(|h| h.events.last().map(|he| he.event_id))
                             .unwrap_or(0);
                         write!(
                             f,
                             "PollWFTQResp(run_id: {}, attempt: {}, last_event: {})",
                             self.workflow_execution
                                 .as_ref()
-                                .map(|we| we.run_id.as_str())
-                                .unwrap_or(""),
+                                .map_or("", |we| we.run_id.as_str()),
                             self.attempt,
                             last_event
                         )

package/sdk-core/src/core_tests/activity_tasks.rs

@@ -76,7 +76,7 @@ async fn max_activities_respected() {
     core.register_worker(
         WorkerConfigBuilder::default()
             .task_queue(TEST_Q)
-            .max_outstanding_activities(2usize)
+            .max_outstanding_activities(2_usize)
             .build()
             .unwrap(),
     )
@@ -163,7 +163,7 @@ async fn heartbeats_report_cancels_only_once() {
     core.record_activity_heartbeat(ActivityHeartbeat {
         task_token: act.task_token.clone(),
         task_queue: TEST_Q.to_string(),
-        details: vec![vec![1u8, 2, 3].into()],
+        details: vec![vec![1_u8, 2, 3].into()],
     });
     // We have to wait a beat for the heartbeat to be processed
     sleep(Duration::from_millis(10)).await;
@@ -183,7 +183,7 @@ async fn heartbeats_report_cancels_only_once() {
     core.record_activity_heartbeat(ActivityHeartbeat {
         task_token: act.task_token,
         task_queue: TEST_Q.to_string(),
-        details: vec![vec![1u8, 2, 3].into()],
+        details: vec![vec![1_u8, 2, 3].into()],
     });
     sleep(Duration::from_millis(10)).await;
     // Since cancels always come before new tasks, if we get a new non-cancel task, we did not
@@ -251,7 +251,7 @@ async fn activity_cancel_interrupts_poll() {
             core.record_activity_heartbeat(ActivityHeartbeat {
                 task_token: act.task_token,
                 task_queue: TEST_Q.to_string(),
-                details: vec![vec![1u8, 2, 3].into()],
+                details: vec![vec![1_u8, 2, 3].into()],
             });
             last_finisher.store(1, Ordering::SeqCst);
         },
@@ -358,7 +358,7 @@ async fn many_concurrent_heartbeat_cancels() {
             .task_queue(TEST_Q)
             .max_outstanding_activities(CONCURRENCY_NUM)
             // Only 1 poll at a time to avoid over-polling and running out of responses
-            .max_concurrent_at_polls(1usize)
+            .max_concurrent_at_polls(1_usize)
             .build()
             .unwrap(),
     )

package/sdk-core/src/core_tests/child_workflows.rs

@@ -1,8 +1,15 @@
 use crate::{
-    prototype_rust_sdk::{ChildWorkflowOptions, WfContext, WorkflowFunction, WorkflowResult},
-    test_help::canned_histories,
+    pollers::MockServerGatewayApis,
+    prototype_rust_sdk::{
+        ChildWorkflowOptions, TestRustWorker, WfContext, WorkflowFunction, WorkflowResult,
+    },
+    test_help::{
+        build_mock_pollers, canned_histories, mock_core, MockPollCfg, ResponseType,
+        DEFAULT_WORKFLOW_TYPE, TEST_Q,
+    },
     workflow::managed_wf::ManagedWFFunc,
 };
+use std::sync::Arc;
 use temporal_sdk_core_protos::coresdk::child_workflow::{
     child_workflow_result, ChildWorkflowCancellationType,
 };
@@ -10,33 +17,52 @@ use tokio::join;
 
 const SIGNAME: &str = "SIGNAME";
 
-async fn parent_wf(mut ctx: WfContext) -> WorkflowResult<()> {
-    let child = ctx.child_workflow(ChildWorkflowOptions {
-        workflow_id: "child-id-1".to_string(),
-        workflow_type: "child".to_string(),
-        ..Default::default()
-    });
-
-    let start_res = child
-        .start(&mut ctx)
-        .await
-        .as_started()
-        .expect("Child should get started");
-    let sigfut = start_res.signal(&mut ctx, SIGNAME, b"Hi!");
-    let resfut = start_res.result(&mut ctx);
-    let (sigres, res) = join!(sigfut, resfut);
-    sigres.expect("signal result is ok");
-    res.status.expect("child wf result is ok");
-    Ok(().into())
-}
-
+#[rstest::rstest]
+#[case::signal_then_result(true)]
+#[case::signal_and_result_concurrent(false)]
 #[tokio::test]
-async fn signal_child_workflow() {
-    let func = WorkflowFunction::new(parent_wf);
+async fn signal_child_workflow(#[case] serial: bool) {
+    let wf_id = "fakeid";
+    let wf_type = DEFAULT_WORKFLOW_TYPE;
     let t = canned_histories::single_child_workflow_signaled("child-id-1", SIGNAME);
-    let mut wfm = ManagedWFFunc::new(t, func, vec![]);
-    wfm.process_all_activations().await.unwrap();
-    wfm.shutdown().await.unwrap();
+    let mock = MockServerGatewayApis::new();
+    let mh = MockPollCfg::from_resp_batches(wf_id, t, [ResponseType::AllHistory], mock);
+    let mock = build_mock_pollers(mh);
+    let core = mock_core(mock);
+    let mut worker = TestRustWorker::new(Arc::new(core), TEST_Q.to_string(), None);
+
+    let wf = move |mut ctx: WfContext| async move {
+        let child = ctx.child_workflow(ChildWorkflowOptions {
+            workflow_id: "child-id-1".to_string(),
+            workflow_type: "child".to_string(),
+            ..Default::default()
+        });
+
+        let start_res = child
+            .start(&mut ctx)
+            .await
+            .into_started()
+            .expect("Child should get started");
+        let (sigres, res) = if serial {
+            let sigres = start_res.signal(&mut ctx, SIGNAME, b"Hi!").await;
+            let res = start_res.result().await;
+            (sigres, res)
+        } else {
+            let sigfut = start_res.signal(&mut ctx, SIGNAME, b"Hi!");
+            let resfut = start_res.result();
+            join!(sigfut, resfut)
+        };
+        sigres.expect("signal result is ok");
+        res.status.expect("child wf result is ok");
+        Ok(().into())
+    };
+
+    worker.register_wf(wf_type.to_owned(), wf);
+    worker
+        .submit_wf(wf_id.to_owned(), wf_type.to_owned(), vec![])
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
 }
 
 async fn parent_cancels_child_wf(mut ctx: WfContext) -> WorkflowResult<()> {
@@ -50,10 +76,10 @@ async fn parent_cancels_child_wf(mut ctx: WfContext) -> WorkflowResult<()> {
     let start_res = child
         .start(&mut ctx)
         .await
-        .as_started()
+        .into_started()
         .expect("Child should get started");
     let cancel_fut = start_res.cancel(&mut ctx);
-    let resfut = start_res.result(&mut ctx);
+    let resfut = start_res.result();
     let (cancel_res, res) = join!(cancel_fut, resfut);
     cancel_res.expect("cancel result is ok");
     let stat = res.status.expect("child wf result is ok");

package/sdk-core/src/core_tests/determinism.rs

@@ -8,7 +8,7 @@ use crate::{
 };
 use std::{
     sync::{
-        atomic::{AtomicBool, Ordering},
+        atomic::{AtomicBool, AtomicUsize, Ordering},
         Arc,
     },
     time::Duration,
@@ -64,7 +64,13 @@ async fn test_wf_task_rejected_properly_due_to_nondeterminism(#[case] use_cache:
     let wf_type = DEFAULT_WORKFLOW_TYPE;
     let t = canned_histories::single_timer_wf_completes("1");
     let mock = MockServerGatewayApis::new();
-    let mut mh = MockPollCfg::from_resp_batches(wf_id, t, [ResponseType::AllHistory], mock);
+    let mut mh = MockPollCfg::from_resp_batches(
+        wf_id,
+        t,
+        // Two polls are needed, since the first will fail
+        [ResponseType::AllHistory, ResponseType::AllHistory],
+        mock,
+    );
     // We should see one wft failure which has nondeterminism cause
     mh.num_expected_fails = Some(1);
     mh.expect_fail_wft_matcher =
@@ -78,10 +84,13 @@ async fn test_wf_task_rejected_properly_due_to_nondeterminism(#[case] use_cache:
     let core = mock_core(mock);
     let mut worker = TestRustWorker::new(Arc::new(core), TEST_Q.to_string(), None);
 
-    // The workflow is replaying all of history, so the when it schedules an extra timer it should
-    // not have, it causes a nondeterminism error.
-    worker.register_wf(wf_type.to_owned(), |mut ctx: WfContext| async move {
-        ctx.timer(Duration::from_secs(1)).await;
+    let started_count: &'static _ = Box::leak(Box::new(AtomicUsize::new(0)));
+    worker.register_wf(wf_type.to_owned(), move |mut ctx: WfContext| async move {
+        // The workflow is replaying all of history, so the when it schedules an extra timer it
+        // should not have, it causes a nondeterminism error.
+        if started_count.fetch_add(1, Ordering::Relaxed) == 0 {
+            ctx.timer(Duration::from_secs(1)).await;
+        }
         ctx.timer(Duration::from_secs(1)).await;
         Ok(().into())
     });
@@ -90,7 +99,8 @@ async fn test_wf_task_rejected_properly_due_to_nondeterminism(#[case] use_cache:
         .submit_wf(wf_id.to_owned(), wf_type.to_owned(), vec![])
         .await
         .unwrap();
-    // TODO: Shouldn't return error, should just queue eviction per
-    //  https://github.com/temporalio/sdk-core/issues/171
-    assert!(worker.run_until_done().await.is_err());
+    worker.run_until_done().await.unwrap();
+    // Started count is two since we start, restart once due to error, then we unblock the real
+    // timer and proceed without restarting
+    assert_eq!(2, started_count.load(Ordering::Relaxed));
 }

package/sdk-core/src/core_tests/mod.rs

@@ -65,7 +65,7 @@ async fn shutdown_interrupts_both_polls() {
     mock_gateway
         .expect_poll_workflow_task()
         .times(1)
-        .returning(move |_| {
+        .returning(move |_, _| {
             async move {
                 BARR.wait().await;
                 sleep(Duration::from_secs(1)).await;
@@ -91,8 +91,8 @@ async fn shutdown_interrupts_both_polls() {
         WorkerConfigBuilder::default()
             .task_queue(TEST_Q)
             // Need only 1 concurrent pollers for mock expectations to work here
-            .max_concurrent_wft_polls(1usize)
-            .max_concurrent_at_polls(1usize)
+            .max_concurrent_wft_polls(1_usize)
+            .max_concurrent_at_polls(1_usize)
             .build()
             .unwrap(),
     )