Various rewrite of the announcer

Cargo.lock

@@ -1698,13 +1698,13 @@ dependencies = [
 
 [[package]]
 name = "serenity"
-version = "0.11.6"
+version = "0.11.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d007dc45584ecc47e791f2a9a7cf17bf98ac386728106f111159c846d624be3f"
+checksum = "7a7a89cef23483fc9d4caf2df41e6d3928e18aada84c56abd237439d929622c6"
 dependencies = [
  "async-trait",
  "async-tungstenite",
- "base64 0.13.1",
+ "base64 0.21.4",
  "bitflags 1.3.2",
  "bytes",
  "cfg-if",

youmubot-osu/src/discord/announcer.rs

@@ -77,9 +77,10 @@ impl youmubot_prelude::Announcer for Announcer {
                         .await
                     {
                         Ok(v) => {
-                            println!("scanning {} done", osu_user.id);
                             osu_user.last_update = now;
                             osu_user.pp = v.try_into().unwrap();
+                            let id = osu_user.id;
+                            println!("scanning {} done", id);
                             ctx.data
                                 .read()
                                 .await
@@ -88,6 +89,7 @@ impl youmubot_prelude::Announcer for Announcer {
                                 .save(osu_user)
                                 .await
                                 .pls_ok();
+                            println!("updating {} done", id);
                         }
                         Err(e) => {
                             eprintln!("osu: Cannot update {}: {}", osu_user.id, e);

youmubot-prelude/src/announcer.rs

@@ -19,6 +19,7 @@ use serenity::{
     CacheAndHttp,
 };
 use std::{collections::HashMap, sync::Arc};
+use tokio::time::{interval, MissedTickBehavior};
 use youmubot_db::DB;
 
 /// A list of assigned channels for an announcer.
@@ -149,30 +150,33 @@ impl AnnouncerHandler {
 
     /// Start the AnnouncerHandler, looping forever.
     ///
-    /// It will run all the announcers in sequence every *cooldown* seconds.
+    /// It will run all the announcers every *cooldown* seconds.
     pub async fn scan(self, cooldown: std::time::Duration) {
         // First we store all the keys inside the database.
         let keys = self.announcers.keys().cloned().collect::<Vec<_>>();
         self.data.write().await.insert::<Self>(keys.clone());
-        loop {
-            eprintln!("{}: announcer started scanning", chrono::Utc::now());
-            let after = tokio::time::sleep_until(tokio::time::Instant::now() + cooldown);
         join_all(self.announcers.iter().map(|(key, announcer)| {
+            let data = self.data.clone();
+            let cache = self.cache_http.clone();
+            let mut looper = interval(cooldown);
+            looper.set_missed_tick_behavior(MissedTickBehavior::Delay);
+            async move {
+                loop {
                     eprintln!(" - scanning key `{}`", key);
-                Self::announce(self.data.clone(), self.cache_http.clone(), key, announcer).map(
+                    Self::announce(data.clone(), cache.clone(), key, announcer)
-                    move |v| {
+                        .map(move |v| {
                             if let Err(e) = v {
                                 eprintln!(" - key `{}`: {:?}", *key, e)
                             } else {
                                 eprintln!(" - key `{}`: complete", *key)
                             }
-                    },
+                        })
-                )
+                        .await;
+                    looper.tick().await;
+                }
+            }
         }))
         .await;
-            eprintln!("{}: announcer finished scanning", chrono::Utc::now());
-            after.await;
-        }
     }
 }
 

youmubot/src/main.rs

@@ -148,7 +148,7 @@ async fn main() {
     #[cfg(feature = "codeforces")]
     println!("codeforces enabled.");
 
-    tokio::spawn(announcers.scan(std::time::Duration::from_secs(120)));
+    tokio::spawn(announcers.scan(std::time::Duration::from_secs(300)));
 
     println!("Starting...");
     if let Err(v) = client.start().await {