Struct Dispatcher 

pub struct Dispatcher<R, Err, Key> { /* private fields */ }

The base for update dispatching.

Update grouping

Dispatcher generally processes updates concurrently. However, by default, updates from the same chat are processed sequentially. Learn more about update grouping.

See also: “Dispatching or REPLs?”

Implementations

impl<R, Err> Dispatcher<R, Err, DefaultKey>

where R: Requester + Clone + Send + Sync + 'static, Err: Send + Sync + 'static,

pub fn builder( bot: R, handler: UpdateHandler<Err>, ) -> DispatcherBuilder<R, Err, DefaultKey>

where Err: Debug,

Constructs a new DispatcherBuilder with bot and handler.

Examples found in repository

examples/purchase.rs (line 54)

async fn main() {
    pretty_env_logger::init();
    log::info!("Starting purchase bot...");

    let bot = Bot::from_env();

    Dispatcher::builder(bot, schema())
        .dependencies(dptree::deps![InMemStorage::<State>::new()])
        .enable_ctrlc_handler()
        .build()
        .dispatch()
        .await;
}

examples/buttons.rs (line 35)

async fn main() -> Result<(), Box<dyn Error>> {
    pretty_env_logger::init();
    log::info!("Starting buttons bot...");

    let bot = Bot::from_env();

    let handler = dptree::entry()
        .branch(Update::filter_message().endpoint(message_handler))
        .branch(Update::filter_callback_query().endpoint(callback_handler))
        .branch(Update::filter_inline_query().endpoint(inline_query_handler));

    Dispatcher::builder(bot, handler).enable_ctrlc_handler().build().dispatch().await;
    Ok(())
}

examples/deep_linking.rs (line 57)

async fn main() {
    pretty_env_logger::init();
    log::info!("Starting deep linking bot...");

    let bot = Bot::from_env();

    let handler = dialogue::enter::<Update, InMemStorage<State>, State, _>()
        .branch(
            Update::filter_message()
                .filter_command::<StartCommand>()
                .branch(case![StartCommand::Start(start)].endpoint(start)),
        )
        .branch(
            Update::filter_message()
                .branch(case![State::WriteToSomeone { id }].endpoint(send_message)),
        );

    Dispatcher::builder(bot, handler)
        .dependencies(deps![InMemStorage::<State>::new()])
        .enable_ctrlc_handler()
        .build()
        .dispatch()
        .await;
}

examples/dialogue.rs (lines 42-52)

async fn main() {
    pretty_env_logger::init();
    log::info!("Starting dialogue bot...");

    let bot = Bot::from_env();

    Dispatcher::builder(
        bot,
        Update::filter_message()
            .enter_dialogue::<Message, InMemStorage<State>, State>()
            .branch(dptree::case![State::Start].endpoint(start))
            .branch(dptree::case![State::ReceiveFullName].endpoint(receive_full_name))
            .branch(dptree::case![State::ReceiveAge { full_name }].endpoint(receive_age))
            .branch(
                dptree::case![State::ReceiveLocation { full_name, age }].endpoint(receive_location),
            ),
    )
    .dependencies(dptree::deps![InMemStorage::<State>::new()])
    .enable_ctrlc_handler()
    .build()
    .dispatch()
    .await;
}

examples/shared_state.rs (line 27)

async fn main() {
    pretty_env_logger::init();
    log::info!("Starting shared state bot...");

    let bot = Bot::from_env();
    let messages_total = Arc::new(AtomicU64::new(0));

    let handler = Update::filter_message().endpoint(
        |bot: Bot, messages_total: Arc<AtomicU64>, msg: Message| async move {
            let previous = messages_total.fetch_add(1, Ordering::Relaxed);
            bot.send_message(msg.chat.id, format!("I received {previous} messages in total."))
                .await?;
            respond(())
        },
    );

    Dispatcher::builder(bot, handler)
        // Pass the shared state to the handler as a dependency.
        .dependencies(dptree::deps![messages_total])
        .enable_ctrlc_handler()
        .build()
        .dispatch()
        .await;
}

examples/middlewares.rs (line 28)

async fn main() {
    pretty_env_logger::init();
    log::info!("Starting middlewares bot...");

    let bot = Bot::from_env();

    let handler = Update::filter_message()
        // Executes before the endpoint.
        .inspect(|msg: Message| println!("Before (message #{}).", msg.id))
        // Our "endpoint".
        .map_async(my_endpoint)
        // Executes after the endpoint (even if it fails).
        .inspect(|msg: Message| {
            println!("After (message #{}).", msg.id);
        })
        // Retrieve the result of the endpoint and pass it to the dispatcher.
        .endpoint(|result: HandlerResult| async move {
            // Alternatively, we could also pattern-match on this value for more
            // fine-grained behaviour.
            result
        });

    Dispatcher::builder(bot, handler).enable_ctrlc_handler().build().dispatch().await;
}

Additional examples can be found in:

• examples/db_remember.rs
• examples/middlewares_fallible.rs
• examples/chat_member_updates.rs
• examples/inline.rs
• examples/dispatching_features.rs

impl<R, Err, Key> Dispatcher<R, Err, Key>

where R: Requester + Clone + Send + Sync + 'static, Err: Send + Sync + 'static, Key: Hash + Eq + Clone + Send,

pub async fn dispatch(&mut self)

where R: Requester + Clone, <R as Requester>::GetUpdates: Send,

Starts your bot with the default parameters.

The default parameters are a long polling update listener and log all errors produced by this listener.

Each time a handler is invoked, Dispatcher adds the following dependencies (in addition to those passed to DispatcherBuilder::dependencies):

• Your bot passed to Dispatcher::builder;
• An update from Telegram;
• crate::types::Me (can be used in HandlerExt::filter_command).

Examples found in repository

examples/purchase.rs (line 58)

async fn main() {
    pretty_env_logger::init();
    log::info!("Starting purchase bot...");

    let bot = Bot::from_env();

    Dispatcher::builder(bot, schema())
        .dependencies(dptree::deps![InMemStorage::<State>::new()])
        .enable_ctrlc_handler()
        .build()
        .dispatch()
        .await;
}

examples/buttons.rs (line 35)

async fn main() -> Result<(), Box<dyn Error>> {
    pretty_env_logger::init();
    log::info!("Starting buttons bot...");

    let bot = Bot::from_env();

    let handler = dptree::entry()
        .branch(Update::filter_message().endpoint(message_handler))
        .branch(Update::filter_callback_query().endpoint(callback_handler))
        .branch(Update::filter_inline_query().endpoint(inline_query_handler));

    Dispatcher::builder(bot, handler).enable_ctrlc_handler().build().dispatch().await;
    Ok(())
}

examples/deep_linking.rs (line 61)

async fn main() {
    pretty_env_logger::init();
    log::info!("Starting deep linking bot...");

    let bot = Bot::from_env();

    let handler = dialogue::enter::<Update, InMemStorage<State>, State, _>()
        .branch(
            Update::filter_message()
                .filter_command::<StartCommand>()
                .branch(case![StartCommand::Start(start)].endpoint(start)),
        )
        .branch(
            Update::filter_message()
                .branch(case![State::WriteToSomeone { id }].endpoint(send_message)),
        );

    Dispatcher::builder(bot, handler)
        .dependencies(deps![InMemStorage::<State>::new()])
        .enable_ctrlc_handler()
        .build()
        .dispatch()
        .await;
}

examples/dialogue.rs (line 56)

async fn main() {
    pretty_env_logger::init();
    log::info!("Starting dialogue bot...");

    let bot = Bot::from_env();

    Dispatcher::builder(
        bot,
        Update::filter_message()
            .enter_dialogue::<Message, InMemStorage<State>, State>()
            .branch(dptree::case![State::Start].endpoint(start))
            .branch(dptree::case![State::ReceiveFullName].endpoint(receive_full_name))
            .branch(dptree::case![State::ReceiveAge { full_name }].endpoint(receive_age))
            .branch(
                dptree::case![State::ReceiveLocation { full_name, age }].endpoint(receive_location),
            ),
    )
    .dependencies(dptree::deps![InMemStorage::<State>::new()])
    .enable_ctrlc_handler()
    .build()
    .dispatch()
    .await;
}

examples/shared_state.rs (line 32)

async fn main() {
    pretty_env_logger::init();
    log::info!("Starting shared state bot...");

    let bot = Bot::from_env();
    let messages_total = Arc::new(AtomicU64::new(0));

    let handler = Update::filter_message().endpoint(
        |bot: Bot, messages_total: Arc<AtomicU64>, msg: Message| async move {
            let previous = messages_total.fetch_add(1, Ordering::Relaxed);
            bot.send_message(msg.chat.id, format!("I received {previous} messages in total."))
                .await?;
            respond(())
        },
    );

    Dispatcher::builder(bot, handler)
        // Pass the shared state to the handler as a dependency.
        .dependencies(dptree::deps![messages_total])
        .enable_ctrlc_handler()
        .build()
        .dispatch()
        .await;
}

examples/middlewares.rs (line 28)

async fn main() {
    pretty_env_logger::init();
    log::info!("Starting middlewares bot...");

    let bot = Bot::from_env();

    let handler = Update::filter_message()
        // Executes before the endpoint.
        .inspect(|msg: Message| println!("Before (message #{}).", msg.id))
        // Our "endpoint".
        .map_async(my_endpoint)
        // Executes after the endpoint (even if it fails).
        .inspect(|msg: Message| {
            println!("After (message #{}).", msg.id);
        })
        // Retrieve the result of the endpoint and pass it to the dispatcher.
        .endpoint(|result: HandlerResult| async move {
            // Alternatively, we could also pattern-match on this value for more
            // fine-grained behaviour.
            result
        });

    Dispatcher::builder(bot, handler).enable_ctrlc_handler().build().dispatch().await;
}

Additional examples can be found in:

• examples/db_remember.rs
• examples/middlewares_fallible.rs
• examples/chat_member_updates.rs
• examples/inline.rs
• examples/dispatching_features.rs

pub async fn dispatch_with_listener<'a, UListener, Eh>( &'a mut self, update_listener: UListener, update_listener_error_handler: Arc<Eh>, )

where UListener: UpdateListener + Send + 'a, Eh: ErrorHandler<UListener::Err> + Send + Sync + 'a, UListener::Err: Debug,

Starts your bot with custom update_listener and update_listener_error_handler.

This method adds the same dependencies as Dispatcher::dispatch.

pub async fn try_dispatch_with_listener<'a, UListener, Eh>( &'a mut self, update_listener: UListener, update_listener_error_handler: Arc<Eh>, ) -> Result<(), R::Err>

where UListener: UpdateListener + Send + 'a, Eh: ErrorHandler<UListener::Err> + Send + Sync + 'a, UListener::Err: Debug,

Same as dispatch_with_listener but returns a Err(_) instead of panicking when the initial telegram api call (get_me) fails.

Starts your bot with custom update_listener and update_listener_error_handler.

This method adds the same dependencies as Dispatcher::dispatch.

pub fn shutdown_token(&self) -> ShutdownToken

Returns a shutdown token, which can later be used to ShutdownToken::shutdown.