fix: fix various small issues

Author: DASPRiD

debian/service

@@ -1,13 +1,15 @@
 [Unit]
 Description=BloopBox
 After=network.target
+StartLimitIntervalSec=0
 
 [Service]
 Type=simple
 User=bloop-box
 ExecStart=/usr/bin/bloop-box
 Environment="RUST_LOG=info"
 Restart=always
+RestartSec=2
 
 [Install]
 WantedBy=multi-user.target

src/etc_config.rs

@@ -1,5 +1,6 @@
-use anyhow::Result;
+use anyhow::{Context, Result};
 use serde::Deserialize;
+use std::path::Path;
 use tokio::fs::File;
 use tokio::io::AsyncReadExt;
 
@@ -39,7 +40,10 @@ pub struct EtcConfig {
 }
 
 pub async fn load_etc_config() -> Result<EtcConfig> {
-    let mut file = File::open("/etc/bloop-box.conf").await?;
+    let path = Path::new("/etc/bloop-box.conf");
+    let mut file = File::open(&path)
+        .await
+        .with_context(|| format!("Failed to open {}", path.display()))?;
     let mut toml_config = String::new();
     file.read_to_string(&mut toml_config).await?;
     let config: EtcConfig = toml::from_str(&toml_config)?;

src/subsystems/audio_player.rs

@@ -4,7 +4,7 @@ use std::thread::sleep;
 use std::time::Duration;
 
 use crate::subsystems::config_manager::ConfigCommand;
-use anyhow::{anyhow, Error, Result};
+use anyhow::{anyhow, Context, Error, Result};
 use glob::glob;
 use log::info;
 use rand::seq::SliceRandom;
@@ -63,7 +63,7 @@ impl AudioPlayer {
 
     async fn process(&mut self) -> Result<()> {
         let (soloud_tx, mut soloud_rx) = mpsc::channel(8);
-        let share_path = self.share_path.to_str().unwrap().to_owned();
+        let share_path = self.share_path.to_owned();
 
         thread::spawn(move || {
             struct PlayState {
@@ -73,26 +73,30 @@ impl AudioPlayer {
 
             let mut soloud = Soloud::default().unwrap();
             let mut play_wav = audio::Wav::default();
+            let volume_change_path = share_path.join(Path::new("volume-change.mp3"));
             let mut volume_change_wav = audio::Wav::default();
-            volume_change_wav
-                .load(format!("{}/volume-change.mp3", share_path))
-                .unwrap();
+            volume_change_wav.load(volume_change_path).unwrap();
 
             let mut handle_command = |soloud: &mut Soloud, command| {
                 use SoloudCommand::*;
 
                 match command {
                     PlayAsset { path, done } => {
+                        let path = share_path.join(path);
                         play_wav
-                            .load(format!("{}/{}", share_path, path.to_str().unwrap()))
+                            .load(&path)
+                            .with_context(|| format!("Failed to play {}", path.display()))
                             .unwrap();
                         return Some(PlayState {
                             handle: soloud.play(&play_wav),
                             done,
                         });
                     }
                     PlayFile { path, done } => {
-                        play_wav.load(path).unwrap();
+                        play_wav
+                            .load(&path)
+                            .with_context(|| format!("Failed to play {}", path.display()))
+                            .unwrap();
                         return Some(PlayState {
                             handle: soloud.play(&play_wav),
                             done,

src/subsystems/controller.rs

@@ -123,14 +123,14 @@ impl Controller {
                                         }
                                         None => continue,
                                     }
-
-                                    let (done_tx, done_rx) = oneshot::channel();
-                                    self.audio_player.send(PlayerCommand::PlayCached {
-                                        path: PathBuf::from(filename),
-                                        done: done_tx,
-                                    }).await?;
-                                    done_rx.await?;
                                 }
+
+                                let (done_tx, done_rx) = oneshot::channel();
+                                self.audio_player.send(PlayerCommand::PlayCached {
+                                    path: PathBuf::from(filename),
+                                    done: done_tx,
+                                }).await?;
+                                done_rx.await?;
                             }
                         },
                         CheckUidResponse::Error {} => {

src/subsystems/networker.rs

@@ -7,7 +7,7 @@ use std::time::Duration;
 
 use anyhow::{Error, Result};
 
-use log::info;
+use log::{debug, info};
 
 use thiserror;
 
@@ -142,12 +142,16 @@ impl Networker {
                                 CheckUid { uid, responder } => {
                                     let stream = match maybe_stream {
                                         Some(ref mut stream) => stream,
-                                        None => continue,
+                                        None => {
+                                            responder.send(CheckUidResponse::Error {}).unwrap();
+                                            continue;
+                                        },
                                     };
 
                                     match self.check_uid(stream, &uid).await {
                                         Ok(response) => responder.send(response).unwrap(),
-                                        Err(_) => {
+                                        Err(error) => {
+                                            debug!("Lost connection due to: {}", error);
                                             maybe_stream = None;
                                             self.status_tx.send(NetworkerStatus::Disconnected).await?;
                                             responder.send(CheckUidResponse::Error {}).unwrap();
@@ -157,12 +161,16 @@ impl Networker {
                                 GetAudio { id, responder } => {
                                     let stream = match maybe_stream {
                                         Some(ref mut stream) => stream,
-                                        None => continue,
+                                        None => {
+                                            responder.send(None).unwrap();
+                                            continue;
+                                        },
                                     };
 
                                     match self.get_audio(stream, &id).await {
                                         Ok(data) => responder.send(data).unwrap(),
-                                        Err(_) => {
+                                        Err(error) => {
+                                            debug!("Lost connection due to: {}", error);
                                             maybe_stream = None;
                                             self.status_tx.send(NetworkerStatus::Disconnected).await?;
                                             responder.send(None).unwrap();