Struct PollerBuilder

pub struct PollerBuilder<Params, Resp> { /* private fields */ }

A poller task builder.

This builder is used to create a poller task that repeatedly polls a method on a client and sends the responses to a channel. By default, this is done every 10 seconds, with a channel size of 16, and no limit on the number of successful polls. This is all configurable.

The builder is consumed using the spawn method, which returns a channel to receive the responses. The task will continue to poll until either the client or the channel is dropped.

The channel can be converted into a stream using the into_stream method.

Alternatively, into_stream can be used to directly return a stream of responses on the current thread. This is currently equivalent to spawn().into_stream(), but this may change in the future.

Examples

Poll eth_blockNumber every 5 seconds:

use alloy_primitives::U64;
use alloy_rpc_client::PollerBuilder;
use futures_util::StreamExt;

let poller: PollerBuilder<alloy_rpc_client::NoParams, U64> = client
    .prepare_static_poller("eth_blockNumber", [])
    .with_poll_interval(std::time::Duration::from_secs(5));
let mut stream = poller.into_stream();
while let Some(block_number) = stream.next().await {
   println!("polled block number: {block_number}");
}

Implementations

impl<Params, Resp> PollerBuilder<Params, Resp>

where Params: RpcSend + 'static, Resp: RpcRecv + Clone,

pub fn new( client: WeakClient, method: impl Into<Cow<'static, str>>, params: Params, ) -> Self

Create a new poller task.

pub const fn channel_size(&self) -> usize

Returns the channel size for the poller task.

pub fn set_channel_size(&mut self, channel_size: usize)

Sets the channel size for the poller task.

pub fn with_channel_size(self, channel_size: usize) -> Self

Sets the channel size for the poller task.

pub const fn limit(&self) -> usize

Returns the limit on the number of successful polls.

pub fn set_limit(&mut self, limit: Option<usize>)

Sets a limit on the number of successful polls.

pub fn with_limit(self, limit: Option<usize>) -> Self

Sets a limit on the number of successful polls.

pub const fn poll_interval(&self) -> Duration

Returns the duration between polls.

pub fn set_poll_interval(&mut self, poll_interval: Duration)

Sets the duration between polls.

pub fn with_poll_interval(self, poll_interval: Duration) -> Self

Sets the duration between polls.

pub fn spawn(self) -> PollChannel<Resp>

Starts the poller in a new task, returning a channel to receive the responses on.

pub fn into_stream(self) -> impl Stream<Item = Resp> + Unpin

Starts the poller and returns the stream of responses.

Note that this does not spawn the poller on a separate task, thus all responses will be polled on the current thread once this stream is polled.

Trait Implementations

impl<Params: Debug, Resp: Debug> Debug for PollerBuilder<Params, Resp>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.