.gitea/workflows/build.yml

@@ -9,13 +9,11 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
-env:
-  CARGO_TERM_COLOR: always
-  RUNNER_TOOL_CACHE: /toolcache
-
 jobs:
   build:
     runs-on: ubuntu-22.04
+    env:
+      RUNNER_TOOL_CACHE: /toolcache
 
     steps:
       - name: Set up Docker Buildx
@@ -44,8 +42,7 @@ jobs:
             $HOME/.cargo/registry/index/
             $HOME/.cargo/registry/cache/
             target/
-          key: ${{ runner.os }}-cargo-${{ steps.cargo-cache-key.outputs.hash }}
+          key: ${{ runner.os }}-cache-${{ steps.cargo-cache-key.outputs.hash }}
-          restore-keys: ${{ runner.os }}-cargo-
 
       - name: Login to Gitea
         uses: docker/login-action@v3
@@ -68,6 +65,7 @@ jobs:
         run: |
           rustup target add x86_64-unknown-linux-musl
           export GIT_COMMIT_HASH=${{ github.sha }} && \
+          export GIT_COMMIT_BRANCH=${{ github.ref_name }} && \
           cargo zigbuild --target x86_64-unknown-linux-musl --locked -rF production
 
       - name: Build and push image
@@ -86,7 +84,7 @@ jobs:
     needs: build
     steps:
       - name: Deploy update
-        uses: appleboy/ssh-action@v1
+        uses: appleboy/ssh-action@v1.2.0
         with:
           host: ${{ secrets.SSH_HOST }}
           username: ${{ secrets.SSH_USERNAME }}

cmds/src/dispatch.rs

@@ -1,8 +1,3 @@
-mod ilo;
-mod midi;
-mod status;
-mod uptime;
-
 use kon_libs::{
   KonData,
   KonError,
@@ -10,6 +5,13 @@ use kon_libs::{
   PoiseCtx
 };
 
+use poise::Command;
+
+mod ilo;
+mod midi;
+mod status;
+mod uptime;
+
 use {
   ilo::ilo,
   midi::midi_to_wav,
@@ -23,7 +25,7 @@ macro_rules! commands {
   }
 }
 
-pub fn register_cmds() -> Vec<poise::Command<KonData, KonError>> { commands!(deploy, ping, ilo, midi_to_wav, status, uptime) }
+pub fn register_cmds() -> Vec<Command<KonData, KonError>> { commands!(deploy, ping, midi_to_wav, status, ilo, uptime) }
 
 /// Deploy the commands globally or in a guild
 #[poise::command(prefix_command, owners_only, guild_only)]
@@ -33,7 +35,7 @@ pub async fn deploy(ctx: PoiseCtx<'_>) -> KonResult<()> {
 }
 
 /// Check if the bot is alive
-#[poise::command(slash_command, install_context = "Guild|User", interaction_context = "Guild|BotDm|PrivateChannel")]
+#[poise::command(slash_command)]
 pub async fn ping(ctx: PoiseCtx<'_>) -> KonResult<()> {
   ctx.reply(format!("Powong! `{:.2?}`", ctx.ping().await)).await?;
   Ok(())

cmds/src/dispatch/midi.rs

@@ -7,10 +7,7 @@ use {
   },
   poise::{
     CreateReply,
-    serenity_prelude::{
+    serenity_prelude::CreateAttachment
-      CreateAttachment,
-      Message
-    }
   },
   regex::Regex,
   std::{
@@ -26,12 +23,12 @@ use {
 /// Convert MIDI file to WAV
 #[poise::command(
   context_menu_command = "MIDI -> WAV",
-  install_context = "Guild|User",
+  install_context = "User",
   interaction_context = "Guild|BotDm|PrivateChannel"
 )]
 pub async fn midi_to_wav(
   ctx: super::PoiseCtx<'_>,
-  #[description = "MIDI file to be converted"] message: Message
+  #[description = "MIDI file to be converted"] message: poise::serenity_prelude::Message
 ) -> KonResult<()> {
   let re = Regex::new(r"(?i)\.mid$").unwrap();
 
@@ -90,12 +87,9 @@ pub async fn midi_to_wav(
             &*wav_path,
             format_bytes(metadata(&*wav_path).unwrap().size())
           )))
-          .await?;
+          .await
+          .unwrap();
       } else if reply.is_ok() {
-        println!(
-          "Discord[{}]: Processed file uploaded back to Discord channel",
-          ctx.command().qualified_name
-        );
         remove_file(midi_path)?;
         remove_file(&*wav_path)?;
       }
@@ -103,7 +97,8 @@ pub async fn midi_to_wav(
     Err(y) => {
       ctx
         .send(CreateReply::default().content("Command didn't execute successfully, check console for more information!"))
-        .await?;
+        .await
+        .unwrap();
 
       return Err(KonError::from(format!("Midi conversion failed: {y}")))
     }

cmds/src/dispatch/status.rs

@@ -73,12 +73,7 @@ fn process_pms_statuses(servers: Vec<(String, Vec<Value>)>) -> Vec<(String, Stri
 }
 
 /// Query the server statuses
-#[poise::command(
+#[poise::command(slash_command, subcommands("wg"))]
-  slash_command,
-  install_context = "Guild|User",
-  interaction_context = "Guild|BotDm|PrivateChannel",
-  subcommands("wg")
-)]
 pub async fn status(_: super::PoiseCtx<'_>) -> KonResult<()> { Ok(()) }
 
 /// Retrieve the server statuses from Wargaming

cmds/src/dispatch/uptime.rs

@@ -46,7 +46,7 @@ fn get_os_info() -> String {
 }
 
 /// Retrieve host and bot uptimes
-#[poise::command(slash_command, install_context = "Guild|User", interaction_context = "Guild|BotDm|PrivateChannel")]
+#[poise::command(slash_command)]
 pub async fn uptime(ctx: super::PoiseCtx<'_>) -> KonResult<()> {
   let bot = ctx.http().get_current_user().await.unwrap();
   let mut sys = System::new_all();

tasks/src/rss.rs

@@ -5,13 +5,6 @@ mod github;
 mod gportal;
 mod rust;
 
-use {
-  esxi::Esxi,
-  github::GitHub,
-  gportal::GPortal,
-  rust::RustBlog
-};
-
 use super::{
   task_err,
   task_info
@@ -28,8 +21,7 @@ use {
   poise::serenity_prelude::{
     Context,
     CreateEmbed,
-    Timestamp,
+    Timestamp
-    async_trait
   },
   regex::Regex,
   reqwest::Response,
@@ -40,8 +32,6 @@ use {
   }
 };
 
-pub type RSSFeedBox = Box<dyn RSSFeed + Send + Sync>;
-
 const TASK_NAME: &str = "RSS";
 static REDIS_EXPIRY_SECS: i64 = 7200;
 static REDIS_SERVICE: OnceCell<Arc<RedisController>> = OnceCell::new();
@@ -104,7 +94,7 @@ async fn save_to_redis(
   let redis = get_redis().await;
   redis.set(key, value).await.unwrap();
   if let Err(y) = redis.expire(key, REDIS_EXPIRY_SECS).await {
-    task_err("RSS", format!("[RedisExpiry]: {y}").as_str());
+    task_err("RSS", format!("[RedisExpiry]: {}", y).as_str());
   }
   Ok(())
 }
@@ -153,23 +143,6 @@ impl IncidentColorMap {
   }
 }
 
-#[async_trait]
-pub trait RSSFeed {
-  fn name(&self) -> &str;
-  fn url(&self) -> &str;
-  async fn process(
-    &self,
-    ctx: Arc<Context>
-  ) -> KonResult<Option<RSSFeedOutput>>;
-}
-
-/// Handle feed's output type for Discord message
-pub enum RSSFeedOutput {
-  RegularEmbed(CreateEmbed),
-  IncidentEmbed(CreateEmbed),
-  Content(String)
-}
-
 pub async fn rss(ctx: Arc<Context>) -> KonResult<()> {
   #[cfg(feature = "production")]
   let mut interval = interval(Duration::from_secs(300)); // Check feeds every 5 mins
@@ -178,19 +151,6 @@ pub async fn rss(ctx: Arc<Context>) -> KonResult<()> {
   let mut first_run = true;
   task_info(TASK_NAME, "Task loaded!");
 
-  let feeds: Vec<RSSFeedBox> = vec![
-    Box::new(Esxi::new("https://esxi-patches.v-front.de/atom/ESXi-7.0.0.xml".to_string())),
-    Box::new(GitHub::new("https://www.githubstatus.com/history.atom".to_string())),
-    Box::new(GPortal::new("https://status.g-portal.com/history.atom".to_string())),
-    Box::new(RustBlog::new("https://blog.rust-lang.org/feed.xml".to_string())),
-  ];
-
-  let mut processor = processor::RSSProcessor::new();
-
-  for feed in feeds {
-    processor.add_feed(feed);
-  }
-
   loop {
     interval.tick().await;
 
@@ -198,9 +158,6 @@ pub async fn rss(ctx: Arc<Context>) -> KonResult<()> {
       task_info(&format!("{TASK_NAME}:Processor"), "Starting up!");
       first_run = false;
     }
-
+    processor::feed_processor(&ctx).await;
-    if let Err(e) = processor.process_all(ctx.clone()).await {
-      task_err(&format!("{TASK_NAME}:Processor"), &e.to_string());
-    }
   }
 }

tasks/src/rss/esxi.rs

@@ -1,115 +1,88 @@
 use super::{
-  RSSFeed,
+  super::task_err,
-  RSSFeedOutput,
+  REDIS_EXPIRY_SECS,
   fetch_feed,
   format_href_to_discord,
   get_redis,
   parse,
-  save_to_redis,
+  save_to_redis
-  task_err
 };
 
 use {
   kon_libs::KonResult,
   poise::serenity_prelude::{
-    Context,
     CreateEmbed,
     CreateEmbedAuthor,
-    Timestamp,
+    Timestamp
-    async_trait
   },
   regex::Regex,
-  std::{
+  std::io::Cursor
-    io::Cursor,
-    sync::Arc
-  }
 };
 
-pub struct Esxi {
+pub async fn esxi_embed() -> KonResult<Option<CreateEmbed>> {
-  url: String
+  let redis = get_redis().await;
-}
+  let rkey = "RSS_ESXi";
+  let url = "https://esxi-patches.v-front.de/atom/ESXi-7.0.0.xml";
 
-impl Esxi {
+  let res = fetch_feed(url).await?;
-  pub fn new(url: String) -> Self { Self { url } }
+  let data = res.text().await?;
-}
+  let cursor = Cursor::new(data);
 
-#[async_trait]
+  let feed = parse(cursor).unwrap();
-impl RSSFeed for Esxi {
+  let home_page = feed.links[0].clone().href;
-  fn name(&self) -> &str { "ESXi" }
+  let article = feed.entries[0].clone();
 
-  fn url(&self) -> &str { self.url.as_str() }
+  fn get_patch_version(input: &str) -> Option<String> {
+    let re = Regex::new(r#"(?i)Update\s+([0-9]+)([a-z]?)"#).unwrap();
 
-  async fn process(
+    if let Some(caps) = re.captures(input) {
-    &self,
+      let update_num = caps[1].to_string();
-    _ctx: Arc<Context>
+      let letter = caps.get(2).map_or("", |m| m.as_str());
-  ) -> KonResult<Option<RSSFeedOutput>> {
+      Some(format!("Update {}{}", update_num, letter))
-    let redis = get_redis().await;
-    let rkey = "RSS_ESXi";
-
-    let res = fetch_feed(self.url()).await?;
-    let data = res.text().await?;
-    let cursor = Cursor::new(data);
-
-    let feed = parse(cursor).map_err(|e| {
-      task_err("RSS:ESXi", &format!("Error parsing RSS feed: {e}"));
-      e
-    })?;
-
-    if feed.entries.is_empty() {
-      task_err("RSS:ESXi", "No entries found in the feed!");
-      return Ok(None);
-    }
-
-    let home_page = feed.links[0].clone().href;
-    let article = feed.entries[0].clone();
-
-    fn get_patch_version(input: &str) -> Option<String> {
-      let re = Regex::new(r#"(?i)Update\s+([0-9]+)([a-z]?)"#).unwrap();
-
-      if let Some(caps) = re.captures(input) {
-        let update_num = caps[1].to_string();
-        let letter = caps.get(2).map_or("", |m| m.as_str());
-        Some(format!("Update {update_num}{letter}"))
-      } else {
-        None
-      }
-    }
-
-    let cached_patch = redis.get(rkey).await.unwrap_or(None).unwrap_or_default();
-
-    if cached_patch.is_empty() {
-      save_to_redis(rkey, &article.categories[3].term).await?;
-      return Ok(None);
-    }
-
-    if let Some(patch) = get_patch_version(&article.categories[3].term) {
-      if patch == cached_patch {
-        Ok(None)
-      } else {
-        save_to_redis(rkey, &article.categories[3].term).await?;
-
-        Ok(Some(RSSFeedOutput::RegularEmbed(
-          CreateEmbed::new()
-            .color(0x4EFBCB)
-            .author(CreateEmbedAuthor::new(feed.title.unwrap().content).url(home_page))
-            .thumbnail(feed.logo.unwrap().uri)
-            .description(format!(
-              "{} {} for {} {} has been rolled out!\n{}",
-              article.categories[2].term,
-              article.categories[3].term,
-              article.categories[0].term,
-              article.categories[1].term,
-              format_href_to_discord(&article.summary.unwrap().content)
-            ))
-            .timestamp(Timestamp::from(article.updated.unwrap()))
-        )))
-      }
     } else {
-      task_err(
+      None
-        "RSS:ESXi",
-        &format!("Article term does not match the expected RegEx pattern! ({})", article.categories[3].term)
-      );
-      Ok(None)
     }
   }
+
+  let cached_patch = redis.get(rkey).await.unwrap().unwrap_or_default();
+
+  if cached_patch.is_empty() {
+    redis.set(rkey, &article.categories[3].term).await.unwrap();
+    if let Err(y) = redis.expire(rkey, REDIS_EXPIRY_SECS).await {
+      task_err("RSS", format!("[RedisExpiry]: {}", y).as_str());
+    }
+    return Ok(None);
+  }
+
+  if let Some(patch) = get_patch_version(&article.categories[3].term) {
+    if patch == cached_patch {
+      Ok(None)
+    } else {
+      save_to_redis(rkey, &article.categories[3].term).await?;
+      Ok(Some(
+        CreateEmbed::new()
+          .color(0x4EFBCB)
+          .author(CreateEmbedAuthor::new(feed.title.unwrap().content).url(home_page))
+          .thumbnail(feed.logo.unwrap().uri)
+          .description(format!(
+            "{} {} for {} {} has been rolled out!\n{}",
+            article.categories[2].term,
+            article.categories[3].term,
+            article.categories[0].term,
+            article.categories[1].term,
+            format_href_to_discord(article.summary.unwrap().content.as_str())
+          ))
+          .timestamp(Timestamp::from(article.updated.unwrap()))
+      ))
+    }
+  } else {
+    task_err(
+      "RSS:ESXi",
+      &format!(
+        "Article term does not match the expected RegEx pattern! ({})",
+        article.categories[3].term.as_str()
+      )
+    );
+    Ok(None)
+  }
 }

tasks/src/rss/github.rs

@@ -1,140 +1,111 @@
 use super::{
+  super::task_err,
   IncidentColorMap,
-  RSSFeed,
+  REDIS_EXPIRY_SECS,
-  RSSFeedOutput,
   embed,
   fetch_feed,
   format_html_to_discord,
   get_redis,
   parse,
   save_to_redis,
-  task_err,
   trim_old_content
 };
 
 use {
   kon_libs::KonResult,
   poise::serenity_prelude::{
-    Context,
+    CreateEmbed,
-    Timestamp,
+    Timestamp
-    async_trait
   },
   regex::Regex,
-  std::{
+  std::io::Cursor
-    io::Cursor,
-    sync::Arc
-  }
 };
 
-pub struct GitHub {
+pub async fn github_embed() -> KonResult<Option<CreateEmbed>> {
-  url: String
+  let redis = get_redis().await;
-}
+  let rkey = "RSS_GitHub";
+  let rkey_content = format!("{}_Content", rkey);
+  let url = "https://www.githubstatus.com/history.atom";
 
-impl GitHub {
+  let res = fetch_feed(url).await?;
-  pub fn new(url: String) -> Self { Self { url } }
+  let data = res.text().await?;
-}
+  let cursor = Cursor::new(data);
 
-#[async_trait]
+  let feed = parse(cursor).unwrap();
-impl RSSFeed for GitHub {
+  let incident_page = feed.entries[0].links[0].clone().href;
-  fn name(&self) -> &str { "GitHub" }
+  let article = feed.entries[0].clone();
 
-  fn url(&self) -> &str { self.url.as_str() }
+  fn get_incident_id(input: &str) -> Option<String> {
+    let re = Regex::new(r#"/incidents/([a-zA-Z0-9]+)$"#).unwrap();
 
-  async fn process(
+    re.captures(input).map(|caps| caps[1].to_string())
-    &self,
+  }
-    _ctx: Arc<Context>
-  ) -> KonResult<Option<RSSFeedOutput>> {
-    let redis = get_redis().await;
-    let rkey = "RSS_GitHub";
-    let rkey_content = format!("{rkey}_Content");
 
-    let res = fetch_feed(self.url()).await?;
+  let cached_incident = redis.get(rkey).await.unwrap().unwrap_or_default();
-    let data = res.text().await?;
+  let new_content = format_html_to_discord(article.content.unwrap().body.unwrap());
-    let cursor = Cursor::new(data);
 
-    let feed = parse(cursor).map_err(|e| {
+  let update_patt = Regex::new(r"(?i)\bupdate\b").unwrap();
-      task_err("RSS:GitHub", &format!("Error parsing RSS feed: {e}"));
+  let investigating_patt = Regex::new(r"(?i)\binvestigating\b").unwrap();
-      e
+  let resolved_patt = Regex::new(r"(?i)\bresolved\b").unwrap();
-    })?;
+  let date_patt = Regex::new(r"\b[A-Z][a-z]{2} \d{2}, \d{2}:\d{2} UTC\b").unwrap();
 
-    if feed.entries.is_empty() {
+  let first_entry = date_patt
-      task_err("RSS:GitHub", "No entries found in the feed!");
+    .split(&new_content)
-      return Ok(None);
+    .map(str::trim)
+    .find(|e| !e.is_empty())
+    .unwrap_or(&new_content);
+
+  let color: u32 = if update_patt.is_match(first_entry) {
+    IncidentColorMap::Update.color()
+  } else if investigating_patt.is_match(first_entry) {
+    IncidentColorMap::Investigating.color()
+  } else if resolved_patt.is_match(first_entry) {
+    IncidentColorMap::Resolved.color()
+  } else {
+    IncidentColorMap::Default.color()
+  };
+
+  if cached_incident.is_empty() {
+    redis.set(rkey, &get_incident_id(&article.links[0].href).unwrap()).await.unwrap();
+    redis.set(&rkey_content, &new_content).await.unwrap();
+    if let Err(y) = redis.expire(rkey, REDIS_EXPIRY_SECS).await {
+      task_err("RSS", format!("[RedisExpiry]: {}", y).as_str());
     }
+    return Ok(None);
+  }
 
-    let incident_page = feed.entries[0].links[0].clone().href;
+  if let Some(incident) = get_incident_id(&article.links[0].href) {
-    let article = feed.entries[0].clone();
+    if incident == cached_incident {
-
+      let cached_content: String = redis.get(&rkey_content).await.unwrap().unwrap_or_default();
-    fn get_incident_id(input: &str) -> Option<String> {
+      if cached_content == new_content {
-      let re = Regex::new(r#"/incidents/([a-zA-Z0-9]+)$"#).unwrap();
+        Ok(None)
-      re.captures(input).map(|caps| caps[1].to_string())
-    }
-
-    let cached_incident = redis.get(rkey).await.unwrap().unwrap_or_default();
-    let new_content = format_html_to_discord(article.content.unwrap().body.unwrap());
-
-    let update_patt = Regex::new(r"(?i)\bupdate\b").unwrap();
-    let investigating_patt = Regex::new(r"(?i)\binvestigating\b").unwrap();
-    let resolved_patt = Regex::new(r"(?i)\bresolved\b").unwrap();
-    let date_patt = Regex::new(r"\b[A-Z][a-z]{2} \d{2}, \d{2}:\d{2} UTC\b").unwrap();
-
-    let first_entry = date_patt
-      .split(&new_content)
-      .map(str::trim)
-      .find(|e| !e.is_empty())
-      .unwrap_or(&new_content);
-
-    let color: u32 = if update_patt.is_match(first_entry) {
-      IncidentColorMap::Update.color()
-    } else if investigating_patt.is_match(first_entry) {
-      IncidentColorMap::Investigating.color()
-    } else if resolved_patt.is_match(first_entry) {
-      IncidentColorMap::Resolved.color()
-    } else {
-      IncidentColorMap::Default.color()
-    };
-
-    if cached_incident.is_empty() {
-      save_to_redis(rkey, &get_incident_id(&article.links[0].href).unwrap()).await?;
-      save_to_redis(&rkey_content, &new_content).await?;
-      return Ok(None);
-    }
-
-    if let Some(incident) = get_incident_id(&article.links[0].href) {
-      if incident == cached_incident {
-        let cached_content = redis.get(&rkey_content).await.unwrap().unwrap_or_default();
-        if cached_content == new_content {
-          Ok(None)
-        } else {
-          redis.set(&rkey_content, &new_content).await.unwrap();
-          redis.expire(&rkey_content, 21600).await.unwrap();
-
-          Ok(Some(RSSFeedOutput::IncidentEmbed(embed(
-            color,
-            article.title.unwrap().content,
-            incident_page,
-            trim_old_content(&new_content),
-            Timestamp::from(article.updated.unwrap())
-          ))))
-        }
       } else {
-        save_to_redis(rkey, &incident).await?;
         redis.set(&rkey_content, &new_content).await.unwrap();
-
+        redis.expire(&rkey_content, 21600).await.unwrap();
-        Ok(Some(RSSFeedOutput::IncidentEmbed(embed(
+        Ok(Some(embed(
           color,
           article.title.unwrap().content,
           incident_page,
           trim_old_content(&new_content),
           Timestamp::from(article.updated.unwrap())
-        ))))
+        )))
       }
     } else {
-      task_err(
+      save_to_redis(rkey, &incident).await?;
-        "RSS:GitHub",
+      redis.set(&rkey_content, &new_content).await.unwrap();
-        &format!("Incident ID does not match the expected RegEx pattern! ({})", &article.links[0].href)
+      Ok(Some(embed(
-      );
+        color,
-      Ok(None)
+        article.title.unwrap().content,
+        incident_page,
+        trim_old_content(&new_content),
+        Timestamp::from(article.updated.unwrap())
+      )))
     }
+  } else {
+    task_err(
+      "RSS:GitHub",
+      &format!("Incident ID does not match the expected RegEx pattern! ({})", &article.links[0].href)
+    );
+    Ok(None)
   }
 }

tasks/src/rss/gportal.rs

@@ -1,143 +1,114 @@
 use super::{
+  super::task_err,
   IncidentColorMap,
-  RSSFeed,
+  REDIS_EXPIRY_SECS,
-  RSSFeedOutput,
   embed,
   fetch_feed,
   format_html_to_discord,
   get_redis,
   parse,
   save_to_redis,
-  task_err,
   trim_old_content
 };
 
 use {
   kon_libs::KonResult,
   poise::serenity_prelude::{
-    Context,
+    CreateEmbed,
-    Timestamp,
+    Timestamp
-    async_trait
   },
   regex::Regex,
-  std::{
+  std::io::Cursor
-    io::Cursor,
-    sync::Arc
-  }
 };
 
-pub struct GPortal {
+pub async fn gportal_embed() -> KonResult<Option<CreateEmbed>> {
-  url: String
+  let redis = get_redis().await;
-}
+  let rkey = "RSS_GPortal";
+  let rkey_content = format!("{}_Content", rkey);
+  let url = "https://status.g-portal.com/history.atom";
 
-impl GPortal {
+  let res = fetch_feed(url).await?;
-  pub fn new(url: String) -> Self { Self { url } }
+  let data = res.text().await?;
-}
+  let cursor = Cursor::new(data);
 
-#[async_trait]
+  let feed = parse(cursor).unwrap();
-impl RSSFeed for GPortal {
+  let incident_page = feed.links[0].clone().href;
-  fn name(&self) -> &str { "GPortal" }
+  let article = feed.entries[0].clone();
 
-  fn url(&self) -> &str { self.url.as_str() }
+  fn get_incident_id(input: &str) -> Option<String> {
+    let re = Regex::new(r#"/incidents/([a-zA-Z0-9]+)$"#).unwrap();
 
-  async fn process(
+    re.captures(input).map(|caps| caps[1].to_string())
-    &self,
+  }
-    _ctx: Arc<Context>
-  ) -> KonResult<Option<RSSFeedOutput>> {
-    let redis = get_redis().await;
-    let rkey = "RSS_GPortal";
-    let rkey_content = format!("{rkey}_Content");
 
-    let res = fetch_feed(self.url()).await?;
+  let cached_incident = redis.get(rkey).await.unwrap().unwrap_or_default();
-    let data = res.text().await?;
+  let new_content = format_html_to_discord(article.content.unwrap().body.unwrap());
-    let cursor = Cursor::new(data);
 
-    let feed = parse(cursor).map_err(|e| {
+  let update_patt = Regex::new(r"(?i)\bupdate\b").unwrap();
-      task_err("RSS:GPortal", &format!("Error parsing RSS feed: {e}"));
+  let investigating_patt = Regex::new(r"(?i)\binvestigating\b").unwrap();
-      e
+  let monitoring_patt = Regex::new(r"(?i)\bmonitoring\b").unwrap();
-    })?;
+  let resolved_patt = Regex::new(r"(?i)\bresolved\b").unwrap();
+  let date_patt = Regex::new(r"\b[A-Z][a-z]{2} \d{2}, \d{2}:\d{2} UTC\b").unwrap();
 
-    if feed.entries.is_empty() {
+  let first_entry = date_patt
-      task_err("RSS:GPortal", "No entries found in the feed!");
+    .split(&new_content)
-      return Ok(None);
+    .map(str::trim)
+    .find(|e| !e.is_empty())
+    .unwrap_or(&new_content);
+
+  let color: u32 = if update_patt.is_match(first_entry) {
+    IncidentColorMap::Update.color()
+  } else if investigating_patt.is_match(first_entry) {
+    IncidentColorMap::Investigating.color()
+  } else if monitoring_patt.is_match(first_entry) {
+    IncidentColorMap::Monitoring.color()
+  } else if resolved_patt.is_match(first_entry) {
+    IncidentColorMap::Resolved.color()
+  } else {
+    IncidentColorMap::Default.color()
+  };
+
+  if cached_incident.is_empty() {
+    redis.set(rkey, &get_incident_id(&article.links[0].href).unwrap()).await.unwrap();
+    redis.set(&rkey_content, &new_content).await.unwrap();
+    if let Err(y) = redis.expire(rkey, REDIS_EXPIRY_SECS).await {
+      task_err("RSS", format!("[RedisExpiry]: {}", y).as_str());
     }
+    return Ok(None);
+  }
 
-    let incident_page = feed.links[0].clone().href;
+  if let Some(incident) = get_incident_id(&article.links[0].href) {
-    let article = feed.entries[0].clone();
+    if incident == cached_incident {
-
+      let cached_content: String = redis.get(&rkey_content).await.unwrap().unwrap_or_default();
-    fn get_incident_id(input: &str) -> Option<String> {
+      if cached_content == new_content {
-      let re = Regex::new(r#"/incidents/([a-zA-Z0-9]+)$"#).unwrap();
+        Ok(None)
-      re.captures(input).map(|caps| caps[1].to_string())
-    }
-
-    let cached_incident = redis.get(rkey).await.unwrap().unwrap_or_default();
-    let new_content = format_html_to_discord(article.content.unwrap().body.unwrap());
-
-    let update_patt = Regex::new(r"(?i)\bupdate\b").unwrap();
-    let investigating_patt = Regex::new(r"(?i)\binvestigating\b").unwrap();
-    let monitoring_patt = Regex::new(r"(?i)\bmonitoring\b").unwrap();
-    let resolved_patt = Regex::new(r"(?i)\bresolved\b").unwrap();
-    let date_patt = Regex::new(r"\b[A-Z][a-z]{2} \d{2}, \d{2}:\d{2} UTC\b").unwrap();
-
-    let first_entry = date_patt
-      .split(&new_content)
-      .map(str::trim)
-      .find(|e| !e.is_empty())
-      .unwrap_or(&new_content);
-
-    let color: u32 = if update_patt.is_match(first_entry) {
-      IncidentColorMap::Update.color()
-    } else if investigating_patt.is_match(first_entry) {
-      IncidentColorMap::Investigating.color()
-    } else if monitoring_patt.is_match(first_entry) {
-      IncidentColorMap::Monitoring.color()
-    } else if resolved_patt.is_match(first_entry) {
-      IncidentColorMap::Resolved.color()
-    } else {
-      IncidentColorMap::Default.color()
-    };
-
-    if cached_incident.is_empty() {
-      save_to_redis(rkey, &get_incident_id(&article.links[0].href).unwrap()).await?;
-      save_to_redis(&rkey_content, &new_content).await?;
-      return Ok(None);
-    }
-
-    if let Some(incident) = get_incident_id(&article.links[0].href) {
-      if incident == cached_incident {
-        let cached_content = redis.get(&rkey_content).await.unwrap().unwrap_or_default();
-        if cached_content == new_content {
-          Ok(None)
-        } else {
-          redis.set(&rkey_content, &new_content).await.unwrap();
-          redis.expire(&rkey_content, 21600).await.unwrap();
-
-          Ok(Some(RSSFeedOutput::IncidentEmbed(embed(
-            color,
-            article.title.unwrap().content,
-            incident_page,
-            trim_old_content(&new_content),
-            Timestamp::from(article.updated.unwrap())
-          ))))
-        }
       } else {
-        save_to_redis(rkey, &incident).await?;
         redis.set(&rkey_content, &new_content).await.unwrap();
-
+        redis.expire(&rkey_content, 21600).await.unwrap();
-        Ok(Some(RSSFeedOutput::IncidentEmbed(embed(
+        Ok(Some(embed(
           color,
           article.title.unwrap().content,
           incident_page,
           trim_old_content(&new_content),
           Timestamp::from(article.updated.unwrap())
-        ))))
+        )))
       }
     } else {
-      task_err(
+      save_to_redis(rkey, &incident).await?;
-        "RSS:GPortal",
+      redis.set(&rkey_content, &new_content).await.unwrap();
-        &format!("Incident ID does not match the expected RegEx pattern! ({})", &article.links[0].href)
+      Ok(Some(embed(
-      );
+        color,
-      Ok(None)
+        article.title.unwrap().content,
+        incident_page,
+        trim_old_content(&new_content),
+        Timestamp::from(article.updated.unwrap())
+      )))
     }
+  } else {
+    task_err(
+      "RSS:GPortal",
+      &format!("Incident ID does not match the expected RegEx pattern! ({})", &article.links[0].href)
+    );
+    Ok(None)
   }
 }

tasks/src/rss/processor.rs

@@ -4,10 +4,13 @@ use kon_libs::{
 };
 
 use super::{
-  RSSFeedBox,
-  RSSFeedOutput,
   TASK_NAME,
-  get_redis
+  esxi::esxi_embed,
+  get_redis,
+  github::github_embed,
+  gportal::gportal_embed,
+  rust::rust_message,
+  task_err
 };
 
 use {
@@ -16,11 +19,9 @@ use {
     Context,
     CreateEmbed,
     CreateMessage,
-    EditMessage,
+    EditMessage
-    Http
   },
   regex::Regex,
-  std::sync::Arc,
   tokio::time::{
     Duration,
     sleep
@@ -31,52 +32,29 @@ use {
 /* std::fs::File::create("rss_name.log").unwrap();
 std::fs::write("rss_name.log", format!("{:#?}", feed))?; */
 
-async fn process_regular_embed(
+// todo; have a reusable function for feeding RSS data and building the embed out of it.
-  http: &Http,
+//       see github.rs / esxi.rs / gportal.rs for references of this idea.
-  embed: CreateEmbed,
-  redis_key: &str
-) -> KonResult<()> {
-  let redis = get_redis().await;
-  let channel = ChannelId::new(BINARY_PROPERTIES.rss_channel);
 
-  let msg_id_key: Option<String> = redis.get(redis_key).await?;
+async fn process_embed(
-
+  ctx: &Context,
-  if let Some(msg_id_key) = msg_id_key {
+  embed: Option<CreateEmbed>,
-    if let Ok(msg_id) = msg_id_key.parse::<u64>() {
-      if let Ok(mut message) = channel.message(http, msg_id).await {
-        message.edit(http, EditMessage::new().embed(embed)).await?;
-      }
-    }
-  } else {
-    let message = channel.send_message(http, CreateMessage::new().add_embed(embed)).await?;
-    redis.set(redis_key, &message.id.to_string()).await?;
-    redis.expire(redis_key, 36000).await?;
-  }
-
-  Ok(())
-}
-
-/// Cache-based embed updater for ongoing outages/incidents
-async fn process_incident_embed(
-  http: &Http,
-  embed: CreateEmbed,
   redis_key: &str,
   content_key: &str
 ) -> KonResult<()> {
-  let redis = get_redis().await;
+  if let Some(embed) = embed {
-  let channel = ChannelId::new(BINARY_PROPERTIES.rss_channel);
+    let redis = get_redis().await;
+    let channel = ChannelId::new(BINARY_PROPERTIES.rss_channel);
 
-  let msg_id_key: Option<String> = redis.get(redis_key).await?;
+    let msg_id_key: Option<String> = redis.get(redis_key).await?;
-  let cached_content: Option<String> = redis.get(content_key).await.unwrap_or(None);
+    let cached_content: Option<String> = redis.get(content_key).await.unwrap_or(None);
 
-  if let Some(msg_id_key) = msg_id_key {
+    if let Some(msg_id_key) = msg_id_key {
-    if let Ok(msg_id) = msg_id_key.parse::<u64>() {
+      if let Ok(msg_id) = msg_id_key.parse::<u64>() {
-      if let Ok(mut message) = channel.message(http, msg_id).await {
+        if let Ok(mut message) = channel.message(&ctx.http, msg_id).await {
-        if let Some(existing) = message.embeds.first() {
+          let new_description = message.embeds[0].description.clone().unwrap();
-          let new_description = existing.description.clone().unwrap();
 
           if cached_content.as_deref() != Some(&new_description) {
-            message.edit(http, EditMessage::new().embed(embed)).await?;
+            message.edit(&ctx.http, EditMessage::new().embed(embed)).await?;
           }
 
           sleep(Duration::from_secs(15)).await;
@@ -86,94 +64,81 @@ async fn process_incident_embed(
           }
         }
       }
+    } else {
+      let message = channel.send_message(&ctx.http, CreateMessage::new().add_embed(embed)).await?;
+      redis.set(redis_key, &message.id.to_string()).await?;
+      redis.expire(redis_key, 36000).await?;
     }
-  } else {
-    let message = channel.send_message(http, CreateMessage::new().add_embed(embed)).await?;
-    redis.set(redis_key, &message.id.to_string()).await?;
-    redis.expire(redis_key, 36000).await?;
   }
 
   Ok(())
 }
 
-/// Process the content string
+pub async fn feed_processor(ctx: &Context) {
-async fn process_msg_content(
+  let mut log_msgs: Vec<String> = Vec::new();
-  http: &Http,
-  content: String,
-  redis_key: &str
-) -> KonResult<()> {
-  let redis = get_redis().await;
-  let channel = ChannelId::new(BINARY_PROPERTIES.rss_channel);
 
-  let msg_id_key: Option<String> = redis.get(redis_key).await?;
+  match esxi_embed().await {
-
+    Ok(Some(embed)) => {
-  if let Some(msg_id_key) = msg_id_key {
+      ChannelId::new(BINARY_PROPERTIES.rss_channel)
-    if let Ok(msg_id) = msg_id_key.parse::<u64>() {
+        .send_message(&ctx.http, CreateMessage::new().add_embed(embed))
-      channel.edit_message(http, msg_id, EditMessage::new().content(content)).await?;
+        .await
+        .unwrap();
+    },
+    Ok(None) => (),
+    Err(y) => {
+      log_msgs.push(format!(
+        "**[{TASK_NAME}:ESXi:Error]:** Feed failed with the following error:```\n{}\n```",
+        y
+      ));
+      task_err(TASK_NAME, &y.to_string())
     }
-  } else {
-    let message = channel.send_message(http, CreateMessage::new().content(content)).await?;
-    redis.set(redis_key, &message.id.to_string()).await?;
-    redis.expire(redis_key, 36000).await?;
   }
 
-  Ok(())
+  match gportal_embed().await {
-}
+    Ok(Some(embed)) => process_embed(ctx, Some(embed), "RSS_GPortal_MsgID", "RSS_GPortal_Content").await.unwrap(),
-
+    Ok(None) => (),
-pub struct RSSProcessor {
+    Err(y) => {
-  pub feeds: Vec<RSSFeedBox>
+      log_msgs.push(format!(
-}
+        "**[{TASK_NAME}:GPortal:Error]:** Feed failed with the following error:```\n{}\n```",
-
+        y
-impl RSSProcessor {
+      ));
-  pub fn new() -> Self { Self { feeds: Vec::new() } }
+      task_err(TASK_NAME, &y.to_string())
-
+    }
-  pub fn add_feed(
-    &mut self,
-    feed: RSSFeedBox
-  ) {
-    self.feeds.push(feed);
   }
 
-  pub async fn process_all(
+  match github_embed().await {
-    &self,
+    Ok(Some(embed)) => process_embed(ctx, Some(embed), "RSS_GitHub_MsgID", "RSS_GitHub_Content").await.unwrap(),
-    ctx: Arc<Context>
+    Ok(None) => (),
-  ) -> KonResult<()> {
+    Err(y) => {
-    let mut discord_msg: Vec<String> = Vec::new();
+      log_msgs.push(format!(
-
+        "**[{TASK_NAME}:GitHub:Error]:** Feed failed with the following error:```\n{}\n```",
-    for feed in &self.feeds {
+        y
-      let feed_name = feed.name();
+      ));
-      let redis_key = format!("RSS_{feed_name}_MsgId");
+      task_err(TASK_NAME, &y.to_string())
-      let error_msg = format!("**[{TASK_NAME}:{feed_name}:Error]:** Feed failed with the following error:```\n{{ error }}\n```");
-
-      match feed.process(ctx.clone()).await {
-        Ok(Some(output)) => match output {
-          RSSFeedOutput::RegularEmbed(embed) => {
-            if let Err(e) = process_regular_embed(&ctx.http, embed, &redis_key).await {
-              discord_msg.push(error_msg.replace("{{ error }}", &e.to_string()))
-            }
-          },
-          RSSFeedOutput::IncidentEmbed(embed) => {
-            if let Err(e) = process_incident_embed(&ctx.http, embed, &redis_key, &format!("RSS_{feed_name}_Content")).await {
-              discord_msg.push(error_msg.replace("{{ error }}", &e.to_string()))
-            }
-          },
-          RSSFeedOutput::Content(content) => {
-            if let Err(e) = process_msg_content(&ctx.http, content, &redis_key).await {
-              discord_msg.push(error_msg.replace("{{ error }}", &e.to_string()))
-            }
-          },
-        },
-        Ok(None) => (),
-        Err(e) => discord_msg.push(error_msg.replace("{{ error }}", &e.to_string()))
-      }
     }
+  }
 
-    if !discord_msg.is_empty() {
+  match rust_message().await {
-      ChannelId::new(BINARY_PROPERTIES.kon_logs)
+    Ok(Some(content)) => {
-        .send_message(&ctx.http, CreateMessage::new().content(discord_msg.join("\n")))
+      ChannelId::new(BINARY_PROPERTIES.rss_channel)
-        .await?;
+        .send_message(&ctx.http, CreateMessage::new().content(content))
+        .await
+        .unwrap();
+    },
+    Ok(None) => (),
+    Err(y) => {
+      log_msgs.push(format!(
+        "**[{TASK_NAME}:RustBlog:Error]:** Feed failed with the following error:```\n{}\n```",
+        y
+      ));
+      task_err(TASK_NAME, &y.to_string())
     }
+  }
 
-    Ok(())
+  if !log_msgs.is_empty() {
+    ChannelId::new(BINARY_PROPERTIES.kon_logs)
+      .send_message(&ctx.http, CreateMessage::new().content(log_msgs.join("\n")))
+      .await
+      .unwrap();
   }
 }

tasks/src/rss/rust.rs

@@ -1,6 +1,5 @@
 use super::{
-  RSSFeed,
+  REDIS_EXPIRY_SECS,
-  RSSFeedOutput,
   fetch_feed,
   get_redis,
   parse,
@@ -10,85 +9,54 @@ use super::{
 
 use {
   kon_libs::KonResult,
-  poise::serenity_prelude::{
-    Context,
-    async_trait
-  },
   regex::Regex,
-  std::{
+  std::io::Cursor
-    io::Cursor,
-    sync::Arc
-  }
 };
 
-pub struct RustBlog {
+pub async fn rust_message() -> KonResult<Option<String>> {
-  url: String
+  let redis = get_redis().await;
-}
+  let rkey = "RSS_RustBlog";
+  let url = "https://blog.rust-lang.org/feed.xml";
 
-impl RustBlog {
+  let res = fetch_feed(url).await?;
-  pub fn new(url: String) -> Self { Self { url } }
+  let data = res.text().await?;
-}
+  let cursor = Cursor::new(data);
 
-#[async_trait]
+  let feed = parse(cursor).unwrap();
-impl RSSFeed for RustBlog {
+  let article = feed.entries[0].clone();
-  fn name(&self) -> &str { "RustBlog" }
+  let article_id = article.id.clone();
 
-  fn url(&self) -> &str { self.url.as_str() }
+  fn get_blog_title(input: String) -> Option<String> {
+    let re = Regex::new(r"https://blog\.rust-lang\.org/(\d{4}/\d{2}/\d{2}/[^/]+)").unwrap();
+    re.captures(input.as_str()).and_then(|caps| caps.get(1).map(|m| m.as_str().to_string()))
+  }
 
-  async fn process(
+  let cached_blog = redis.get(rkey).await.unwrap().unwrap_or_default();
-    &self,
-    _ctx: Arc<Context>
-  ) -> KonResult<Option<RSSFeedOutput>> {
-    let redis = get_redis().await;
-    let rkey = "RSS_RustBlog";
 
-    let res = fetch_feed(self.url()).await?;
+  if cached_blog.is_empty() {
-    let data = res.text().await?;
+    redis.set(rkey, get_blog_title(article.id).unwrap().as_str()).await.unwrap();
-    let cursor = Cursor::new(data);
+    if let Err(y) = redis.expire(rkey, REDIS_EXPIRY_SECS).await {
-
+      task_err("RSS", format!("[RedisExpiry]: {}", y).as_str());
-    let feed = parse(cursor).map_err(|e| {
-      task_err("RSS:RustBlog", &format!("Error parsing RSS feed: {e}"));
-      e
-    })?;
-
-    if feed.entries.is_empty() {
-      task_err("RSS:RustBlog", "No entries found in the feed!");
-      return Ok(None);
     }
+    return Ok(None);
+  }
 
-    let article = feed.entries[0].clone();
+  if let Some(blog) = get_blog_title(article.id) {
-    let article_id = article.id.clone();
+    if blog == cached_blog {
-
-    fn get_blog_title(input: String) -> Option<String> {
-      let re = Regex::new(r"https://blog\.rust-lang\.org/(\d{4}/\d{2}/\d{2}/[^/]+)").unwrap();
-      re.captures(input.as_str()).and_then(|caps| caps.get(1).map(|m| m.as_str().to_string()))
-    }
-
-    let cached_blog = redis.get(rkey).await.unwrap_or(None).unwrap_or_default();
-
-    if cached_blog.is_empty() {
-      save_to_redis(rkey, &get_blog_title(article.id).unwrap()).await?;
-      return Ok(None);
-    }
-
-    if let Some(blog_title) = get_blog_title(article.id) {
-      if blog_title == cached_blog {
-        Ok(None)
-      } else {
-        save_to_redis(rkey, &blog_title).await?;
-
-        Ok(Some(RSSFeedOutput::Content(format!(
-          "Rust Team has put out a new article!\n**[{}](<{}>)**",
-          article.links[0].title.clone().unwrap(),
-          article.links[0].href
-        ))))
-      }
-    } else {
-      task_err(
-        "RSS:RustBlog",
-        &format!("Article URL does not match the expected RegEx pattern! ({article_id})")
-      );
       Ok(None)
+    } else {
+      save_to_redis(rkey, &blog).await?;
+      Ok(Some(format!(
+        "Rust Team has put out a new article!\n**[{}](<{}>)**",
+        article.links[0].title.clone().unwrap(),
+        article.links[0].href
+      )))
     }
+  } else {
+    task_err(
+      "RSS:RustBlog",
+      &format!("Article URL does not match the expected RegEx pattern! ({})", article_id)
+    );
+    Ok(None)
   }
 }