0.6.4

0.6.4

Author: c-git

.sqlx/query-2c2b2e7ab1850b7c4bf786be23c54398267a395e700f4af69d5f396e208f07d5.json

@@ -1,6 +1,6 @@
 [package]
 name = "bazooka-bot"
-version = "0.6.3"
+version = "0.6.4"
 edition = "2024"
 publish = false
 

.sqlx/query-f79d485f20e22f0b3abf69d0f8bdf6e566cd81c6270a1d51988c19a4b205bdc7.json

@@ -8,7 +8,7 @@ This is the rust replacement for the bot [originally](https://github.com/fone-gi
 
 <!-- Leave completed items as a feature list / what is being considered for implementation -->
 
-Note: Some checked off items my not be complete only started but at the time of writing (2024-04-07) all are completed.
+Note: Some checked off items my not be complete only started but at the time of writing (2025-08-13) all are completed.
 If they are not there will be TODO's in the code itself.
 The check off only denotes the start of the feature as then the TODOs are moved into the code as maintaining two places is not sustainable.
 
@@ -53,12 +53,11 @@ It should be scheduled manually each season by an officer.
 
 # Nice to have
 
-- [ ] Add ability for owner to download the data files to facilitate testing before uploading a version
-- [ ] Setup deploy from CI - https://github.com/shuttle-hq/deploy-action
-- [ ] Setup test deployment on shuttle (idle time of about 15 minutes should be good)
-  - [ ] [Naming](https://docs.shuttle.rs/configuration/project-name)
-  - [ ] From release notes from 0.40.0
-    - Added a --secrets arg to the run and deploy commands that allows you to use a different secrets file than the default
+- [x] Track how long the bot has been up or down
+- [ ] Keep history of downtime
+- [ ] Add ability for owner to download the data
+- [ ] Add ability for owner to replace the data (intended to be from something downloaded previously)
+- [x] Setup deploy from CI - https://github.com/shuttle-hq/deploy-action
 - [ ] Add message ID to the trace at ingress
 - [x] Sanitize input for markdown like `**` for example rn causes problems with bolding the ideas
 - [ ] Add web page (with info and to wake up bot, would help for test bot that would go to sleep) https://docs.shuttle.rs/templates/tutorials/custom-service

Cargo.lock

@@ -43,13 +43,13 @@ async fn call_to_parent_command(ctx: Context<'_>) -> anyhow::Result<()> {
 
 pub fn commands_list() -> Vec<poise::Command<Data, anyhow::Error>> {
     vec![
-        ping(),
-        help(),
         general::version(),
-        uptime(),
-        unranked(),
-        schedule(),
+        help(),
+        ping(),
         register(),
+        schedule(),
+        unranked(),
+        uptime(),
     ]
 }
 

Cargo.toml

@@ -3,7 +3,7 @@ use std::{collections::HashSet, fmt::Debug, time::Instant};
 use anyhow::Context as _;
 use poise::serenity_prelude::{ChannelId, GuildId, RoleId, UserId};
 use shuttle_runtime::{SecretStore, tokio};
-use tracing::{error, info};
+use tracing::error;
 
 use crate::secrets::KeyName;
 
@@ -72,33 +72,7 @@ impl SharedConfig {
         let key = key.to_string();
         let value = serde_json::to_string(value).context("failed to convert to json")?;
         tokio::spawn(async move {
-            let query = sqlx::query!(
-                "\
-                INSERT INTO kv_store (id, content)
-                VALUES ($1, $2)
-                ON CONFLICT(id)
-                DO UPDATE SET
-                content = EXCLUDED.content;",
-                key,
-                value
-            );
-            match query.execute(&pool).await {
-                Ok(query_result) => {
-                    if query_result.rows_affected() == 1 {
-                        info!("Save completed for key: {key}");
-                    } else {
-                        error!(
-                            ?key,
-                            "Expected 1 row to be affected by save but got: {}",
-                            query_result.rows_affected()
-                        )
-                    }
-                }
-                Err(err_msg) => error!(
-                    ?err_msg,
-                    "Failed to save content for key: {key} to kv store"
-                ),
-            }
+            crate::db::save_kv(&pool, &key, value).await;
         });
         Ok(())
     }
@@ -107,27 +81,17 @@ impl SharedConfig {
         &self,
         key: &str,
     ) -> T {
-        let record_opt = match sqlx::query!("SELECT content FROM kv_store where id = $1", key)
-            .fetch_optional(&self.db_pool)
-            .await
-        {
-            Ok(content) => content,
-            Err(err_msg) => {
-                error!(?err_msg, "Failed to get content for key: {key}");
-                None
-            }
+        let Some(content) = crate::db::load_kv(&self.db_pool, key).await else {
+            return T::default();
         };
-        let record = match record_opt {
-            Some(record) => record,
-            None => {
-                info!("No content found in DB for key: {key}");
-                return T::default();
-            }
-        };
-        match serde_json::from_str(&record.content) {
+        match serde_json::from_str(&content) {
             Ok(x) => x,
             Err(err_msg) => {
-                error!(?err_msg, ?record.content, "Failed to convert content extracted from the database");
+                error!(
+                    ?err_msg,
+                    ?content,
+                    "Failed to convert content extracted from the database"
+                );
                 T::default()
             }
         }

README.md

@@ -0,0 +1,48 @@
+use tracing::{debug, error, info};
+
+pub async fn save_kv(pool: &sqlx::PgPool, key: &str, value: String) {
+    let query = sqlx::query!(
+        "\
+INSERT INTO kv_store (id, content)
+    VALUES ($1, $2)
+    ON CONFLICT(id)
+    DO UPDATE SET
+    content = EXCLUDED.content;",
+        key,
+        value
+    );
+    match query.execute(pool).await {
+        Ok(query_result) => {
+            if query_result.rows_affected() == 1 {
+                debug!("Save completed for key: {key}");
+            } else {
+                error!(
+                    ?key,
+                    "Expected 1 row to be affected by save but got: {}",
+                    query_result.rows_affected()
+                )
+            }
+        }
+        Err(err_msg) => error!(
+            ?err_msg,
+            "Failed to save content for key: {key} to kv store"
+        ),
+    }
+}
+
+pub async fn load_kv(pool: &sqlx::PgPool, key: &str) -> Option<String> {
+    match sqlx::query!("SELECT content FROM kv_store where id = $1", key)
+        .fetch_optional(pool)
+        .await
+    {
+        Ok(Some(record)) => Some(record.content),
+        Ok(None) => {
+            info!("No content found in DB for key: {key}");
+            None
+        }
+        Err(err_msg) => {
+            error!(?err_msg, "Failed to get content for key: {key}");
+            None
+        }
+    }
+}

src/commands.rs

@@ -0,0 +1,64 @@
+use std::time::Duration;
+
+use crate::{
+    db::{load_kv, save_kv},
+    model::schedule::UnixTimestamp,
+};
+use human_time::ToHumanTimeString;
+use tracing::{error, info};
+
+const KEY: &str = "HEARTBEAT";
+
+pub fn start_heartbeat(db_pool: sqlx::PgPool) {
+    shuttle_runtime::tokio::spawn(async move {
+        info!("Heartbeat started");
+        loop {
+            let timestamp = match UnixTimestamp::now() {
+                Ok(x) => x,
+                Err(err) => {
+                    error!(?err, "failed to get timestamp heartbeat stopping");
+                    break;
+                }
+            };
+            save_kv(&db_pool, KEY, timestamp.to_db_fmt()).await;
+            shuttle_runtime::tokio::time::sleep(std::time::Duration::from_secs(60)).await;
+        }
+    });
+}
+
+pub async fn last_heartbeat_info(db_pool: sqlx::PgPool) -> String {
+    match load_kv(&db_pool, KEY).await {
+        Some(db_value) => match UnixTimestamp::from_db_fmt(&db_value) {
+            Ok(last_heartbeat) => {
+                let Ok(now) = UnixTimestamp::now() else {
+                    return format!(
+                        "Last Heartbeat: {last_heartbeat} but Failed to get current timestamp"
+                    );
+                };
+                let seconds_since_last_heartbeat = now.0 - last_heartbeat.0;
+                if seconds_since_last_heartbeat < 0 {
+                    return format!(
+                        "Last heartbeat in the future?! Last heartbeat: {last_heartbeat}, Now: {now}"
+                    );
+                }
+                let Ok(seconds_since_last_heartbeat) = seconds_since_last_heartbeat.try_into()
+                else {
+                    // Invalid u64
+                    return format!(
+                        "Invalid u64!!! Seconds since heartbeat: {seconds_since_last_heartbeat},  Last heartbeat: {last_heartbeat}, Now: {now}"
+                    );
+                };
+                let downtime = Duration::from_secs(seconds_since_last_heartbeat);
+                format!(
+                    "Downtime: {}\nLast Heartbeat: {last_heartbeat}\nNow: {now}",
+                    downtime.to_human_time_string()
+                )
+            }
+            Err(err) => {
+                error!(?err);
+                "Error Loading Last Heartbeat".to_string()
+            }
+        },
+        None => "First run".to_string(),
+    }
+}

src/config.rs

@@ -21,6 +21,8 @@ pub use self::{
 
 mod commands;
 mod config;
+mod db;
+pub mod heartbeat;
 mod model;
 mod secrets;