Is it possible to share across two threads?

[Enucatl]

I would like to have the bot watch a webpage and alert me if there is something new, as well as respond to commands, but I can't get to compile. I guess I could build another bot with the same token on the other thread on every loop, like here, but isn't there anything better?

    // Check for feed updates
    let every_30_seconds = every(30)
        .seconds()
        .perform(|| async move {check_for_updates(&teloxide_token);});
    tokio::spawn(every_30_seconds);

    let handler = dptree::entry()
        .branch(
            // Filter messages from users who are not in the DB "logged out"
            Update::filter_message()
                .filter_async(is_not_subscribed)
                .branch(
                    Update::filter_message()
                        .filter_command::<LoggedOutCommand>()
                        .endpoint(process_logged_out_command),
                )
                .branch(dptree::entry().endpoint(ask_to_subscribe)),
        )
        .branch(
            Update::filter_message()
                .filter_command::<LoggedInCommand>()
                .endpoint(process_command),
        )
        .branch(
            // Handle other messages or actions here
            dptree::filter(|msg: Message| msg.chat.is_group() || msg.chat.is_supergroup())
                .endpoint(noop),
        );

    Dispatcher::builder(bot, handler)
        .dependencies(dptree::deps![db])
        .default_handler(|upd| async move {
            log::warn!("Unhandled update: {:?}", upd);
        })
        .error_handler(LoggingErrorHandler::with_custom_text(
            "An error has occurred in the dispatcher",
        ))
        .enable_ctrlc_handler()
        .build()
        .dispatch()
        .await;
}

async fn check_for_updates(teloxide_token: &str) -> Result<(), Box<dyn Error + Send + Sync>> {
    println!("Every 30 seconds!");
    let bot = Bot::new(teloxide_token);
    let db = db_connect().await?;
    let feeds = entity::prelude::Feed::find().all(&db).await?;
    for feed in feeds {
        let content = reqwest::get(&feed.link).await?.bytes().await?;
        let channel = Channel::read_from(&content[..])?;
        for item in channel.items {
            let published_date = item.pub_date().unwrap_or_default();
            let published_date = rfc822_sanitizer::parse_from_rfc2822_with_fallback(published_date).unwrap_or_default();
            let published_date = published_date.naive_utc();
            if published_date > feed.updated_at {
                let mut message = String::new();
                message.push_str(&format!("<b>{:?}</b>\n", feed.title));
                message.push_str(&format!("<i>{:?}</i>\n", item.title));
                message.push_str(&format!("{:?}\n", item.link));
                bot.send_message(ChatId(feed.chat_id), &message);
            }
        }
    }
    Ok(())
}

[WaffleLapkin]

You can clone the bot. Something like this should work:

    let bot_clone = bot.clone();
    let every_30_seconds = every(30)
        .seconds()
        .perform(move || check_for_updates(bot_clone.clone()));

[Enucatl]

Fine on the teloxide side I suppose, but I now have a problem with perform and what kind of function it expects... now it's quite late here so I'll take a look tomorrow. Thanks for your help.

    let bot = Bot::new(teloxide_token);

    // Check for feed updates
    let every_30_seconds = every(30)
        .seconds()
        .perform(move || check_for_updates(bot.clone()));
    tokio::spawn(every_30_seconds);
//snip

async fn check_for_updates(bot: Bot) -> Result<(), Box<dyn Error + Send + Sync>> {
    println!("Every 30 seconds!");
    let db = db_connect().await?;
    let feeds = entity::prelude::Feed::find().all(&db).await?;
    for feed in feeds {
        let content = reqwest::get(&feed.link).await?.bytes().await?;
        let channel = Channel::read_from(&content[..])?;
        for item in channel.items {
            let published_date = item.pub_date().unwrap_or_default();
            let published_date = rfc822_sanitizer::parse_from_rfc2822_with_fallback(published_date).unwrap_or_default();
            let published_date = published_date.naive_utc();
            if published_date > feed.updated_at {
                let mut message = String::new();
                message.push_str(&format!("<b>{:?}</b>\n", feed.title));
                message.push_str(&format!("<i>{:?}</i>\n", item.title));
                message.push_str(&format!("{:?}\n", item.link));
                bot.send_message(ChatId(feed.chat_id), &message);
            }
        }
    }
    Ok(())
}

.052 error[E0271]: expected `impl Future<Output = Result<(), Box<dyn Error + Send + Sync>>>` to be a future that resolves to `()`, but it resolves to `Result<(), Box<dyn Error + Send + Sync>>`
1.052    --> src/main.rs:65:10
1.052     |
1.052 65  |         .perform(move || check_for_updates(bot.clone()));
1.052     |          ^^^^^^^ expected `()`, found `Result<(), Box<...>>`
1.052     |
1.052     = note: expected unit type `()`
1.052                     found enum `Result<(), Box<(dyn std::error::Error + Send + Sync + 'static)>>`
1.052 note: required by a bound in `perform`
1.052    --> /usr/local/cargo/registry/src/index.crates.io-6f17d22bba15001f/tokio_schedule-0.3.1/src/lib.rs:145:21
1.052     |
1.052 141 |     fn perform<'a, F, Fut>(self, mut func: F) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>>
1.052     |        ------- required by a bound in this associated function
1.052 ...
1.052 145 |         Fut: Future<Output = ()> + Send + 'a,
1.052     |                     ^^^^^^^^^^^ required by this bound in `Job::perform`
1.052 

[WaffleLapkin]

You need to change check_for_updates return type to ().