Add self-updater, better logging

.gitignore

@@ -1,4 +1,5 @@
 /target
 /.env
 /settings.json
-/Cross.toml
+/Cross.toml
+/.vscode

Cargo.lock

@@ -1514,7 +1514,7 @@ dependencies = [
 
 [[package]]
 name = "shibe-bot"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "build-time",
  "dotenvy",

Cargo.toml

@@ -3,7 +3,7 @@ name = "shibe-bot"
 description = "A Discord bot written in Rust, using Poise."
 license = "MIT"
 readme = "README.md"
-version = "0.3.2"
+version = "0.3.3"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

README.md

@@ -1,4 +1,4 @@
-# Shibe Bot 0.3.2
+# Shibe Bot 0.3.3
 
 [![Rust](https://github.com/shibedrill/shibe-bot/actions/workflows/rust.yml/badge.svg)](https://github.com/shibedrill/shibe-bot/actions/workflows/rust.yml)
 [![GitHub License](https://img.shields.io/github/license/shibedrill/shibe-bot)](LICENSE.txt)

src/command/devel.rs

@@ -1,6 +1,41 @@
+use build_time::build_time_local;
+
 use crate::Context;
 use crate::Error;
 
+/// Update the bot from anywhere, using systemd service
+#[poise::command(slash_command, owners_only, hide_in_help)]
+pub async fn update(ctx: Context<'_>) -> Result<(), Error> {
+    let command_result = std::process::Command::new("systemd")
+        .arg("--user")
+        .arg("restart")
+        .arg("shibe-bot-update.service")
+        .spawn();
+    match command_result {
+        Ok(_child) => {
+            ctx.say(format!(
+                "Initialized restart service successfully.\n\
+            Expect brief outage soon.\n\
+            Current version: {}\n\
+            Timestamp of last build: {}",
+                env!("CARGO_PKG_VERSION"),
+                build_time_local!()
+            ))
+            .await?;
+            info!("Initialized restart service successfully");
+        }
+        Err(what) => {
+            ctx.say(format!(
+                "Failed to initialize restart service. Reason: {}",
+                what
+            ))
+            .await?;
+            error!("Failed to initialize restart service: {}", what);
+        }
+    }
+    Ok(())
+}
+
 /// Shut down the bot remotely
 #[poise::command(slash_command, owners_only, hide_in_help)]
 pub async fn shutdown(ctx: Context<'_>) -> Result<(), Error> {

src/main.rs

@@ -76,23 +76,33 @@ async fn event_handler(
 // Main function for setup
 #[tokio::main]
 async fn main() {
-    // Get secure env vars from .env file
-    dotenv().ok();
-    // Get token from environment
-    let token = std::env::var("TOKEN").expect("Getting TOKEN from environment failed");
-    // Set up some non privileged intents
-    let intents = serenity::GatewayIntents::non_privileged();
-
     // Initialize logging
     pretty_env_logger::init();
+    info!("Initialized logger successfully");
+    // Get secure env vars from .env file
+    match dotenv() {
+        Ok(_) => info!("Loaded env vars from .env successfully"),
+        Err(e) => error!("Failed to get vars from .env: {}", e),
+    }
+
+    // Get token from environment
+    let token = std::env::var("TOKEN")
+        .inspect_err(|e| {
+            error!("Failed to get TOKEN from environment: {}", e);
+        })
+        .expect("Failed to get TOKEN from environment");
+    info!("Got TOKEN successfully");
+    // Set up some non privileged intents
+    let intents = serenity::GatewayIntents::non_privileged();
 
     // Configure persistent options
     let config_manager: Arc<Mutex<Manager<Settings>>> = Arc::new(Mutex::new(
         Manager::load(SETTINGS_PATH).unwrap_or(Manager::manage(SETTINGS_PATH, Settings::default())),
     ));
-    let _ = config_manager.lock().await.store().inspect_err(|e| {
+    match config_manager.lock().await.store() {
-        error!("Failed to store config: {}", e);
+        Ok(_) => info!("Stored config successfully"),
-    });
+        Err(e) => error!("Failed to store config: {}", e),
+    };
 
     // Set up framework
     let framework = poise::Framework::builder()

src/settings.rs

@@ -39,7 +39,7 @@ impl<T: Default + Serialize + for<'a> Deserialize<'a>> Manager<T> {
     pub fn store(&self) -> Result<(), std::io::Error> {
         let data = serde_json::to_string_pretty(&self.internal)?;
         let mut file = std::fs::File::create(&self.path)?;
-        let _ = file.write(data.as_bytes());
+        file.write_all(data.as_bytes())?;
         Ok(())
     }
     /// Create a new manager, passing in the path, and a structure to manage.