Cargo.toml

@@ -7,9 +7,5 @@ edition = "2021"
 
 [dependencies]
 argh = "0.1.12"
-bincode = "1.3.3"
-crc32fast = "1.3.2"
 crossterm = "0.27.0"
-interprocess = "1.2.1"
 ratatui = "0.23.0"
-serde = "1.0.196"

src/bin/client.rs

@@ -0,0 +1,3 @@
+fn main() {
+    rmp::client::run().unwrap();
+}

src/client.rs

@@ -1,38 +1,24 @@
-use std::{
+use argh::FromArgs;
-    error::Error,
+use std::{error::Error, time::Duration};
-    sync::{Arc, Mutex},
-    time::Duration,
-};
-
-use crate::CliArgs;
-
-use self::{app::App, request_queue::request_queue_cleaner};
 
 pub mod app;
 pub mod crossterm;
-pub mod request_queue;
 pub mod ui;
 
-pub fn run(args: CliArgs) -> Result<(), Box<dyn Error>> {
+/// Demo
-    let message_queue = Arc::new(Mutex::new(vec![]));
+#[derive(Debug, FromArgs)]
-    let server_state = Arc::new(Mutex::new(None));
+struct Cli {
-    let app = App {
+    /// time in ms between two ticks.
-        title: "rmp - Rust Music Player".into(),
+    #[argh(option, default = "250")]
-        enhanced_graphics: args.enhanced_graphics,
+    tick_rate: u64,
-        should_quit: false,
+    /// whether unicode symbols are used to improve the overall look of the app
-        state: server_state.clone(),
+    #[argh(option, default = "true")]
-        message_queue: message_queue.clone(),
+    enhanced_graphics: bool,
-    };
+}
-    let thread_builder = std::thread::Builder::new().name("request_queue".into());
+
-    thread_builder
+pub fn run() -> Result<(), Box<dyn Error>> {
-        .spawn(move || {
+    let cli: Cli = argh::from_env();
-            request_queue_cleaner(
+    let tick_rate = Duration::from_millis(cli.tick_rate);
-                Duration::from_millis(args.message_rate),
+    crossterm::run(tick_rate, cli.enhanced_graphics)?;
-                message_queue.clone(),
-                server_state.clone(),
-            )
-        })
-        .unwrap();
-    crossterm::run(app, Duration::from_millis(args.tick_rate))?;
     Ok(())
 }

src/client/app.rs

@@ -1,62 +1,226 @@
-use std::{
+use std::{ops::Deref, time::Duration};
-    sync::{Arc, Mutex},
-    time::Duration,
-};
 
-use rmp::{
+const FILE_PATHS: [&str; 0] = [];
-    protocol::{Message, MessageType},
+
-    ServerState,
+#[derive(Debug, Default, Clone, Eq, PartialEq, Hash)]
-};
+pub struct ListState {
+    offset: usize,
+    selected: Option<usize>,
+}
+
+impl ListState {
+    pub fn offset(&self) -> usize {
+        self.offset
+    }
+
+    pub fn offset_mut(&mut self) -> &mut usize {
+        &mut self.offset
+    }
+
+    pub fn with_selected(mut self, selected: Option<usize>) -> Self {
+        self.selected = selected;
+        self
+    }
+
+    pub fn with_offset(mut self, offset: usize) -> Self {
+        self.offset = offset;
+        self
+    }
+
+    pub fn selected(&self) -> Option<usize> {
+        self.selected
+    }
+
+    pub fn select(&mut self, index: Option<usize>) {
+        self.selected = index;
+        if index.is_none() {
+            self.offset = 0;
+        }
+    }
+}
+
+pub struct StatefulList<T> {
+    pub state: ListState,
+    pub items: Vec<T>,
+}
+
+impl<T> StatefulList<T>
+where
+    T: Deref + Eq,
+{
+    pub fn with_items(items: Vec<T>) -> StatefulList<T> {
+        StatefulList {
+            state: ListState::default(),
+            items,
+        }
+    }
+
+    pub fn next(&mut self) {
+        let i = match self.state.selected() {
+            Some(i) => {
+                if i >= self.items.len() - 1 {
+                    0
+                } else {
+                    i + 1
+                }
+            }
+            None => 0,
+        };
+        self.state.select(Some(i));
+    }
+
+    pub fn previous(&mut self) {
+        let i = match self.state.selected() {
+            Some(i) => {
+                if i == 0 {
+                    self.items.len() - 1
+                } else {
+                    i - 1
+                }
+            }
+            None => 0,
+        };
+        self.state.select(Some(i));
+    }
+
+    pub fn index_of(&self, item: T) -> Option<usize> {
+        self.items.iter().position(|element| *element == item)
+    }
+
+    pub fn current(&self) -> Option<&T> {
+        self.state
+            .selected
+            .map_or(None, |index| self.items.get(index))
+    }
+
+    pub fn current_mut(&mut self) -> Option<&mut T> {
+        self.state
+            .selected
+            .map_or(None, |index| self.items.get_mut(index))
+    }
+}
+
+// TODO: Implement this
+#[derive(Default, Clone)]
+pub struct TrackMetadata {
+    pub duration: Option<Duration>,
+}
+
+pub struct PlayerState {
+    pub currently_playing: Option<String>,
+    pub is_playing: bool,
+    pub time_ratio: f64,
+}
+
+impl Default for PlayerState {
+    fn default() -> Self {
+        Self {
+            currently_playing: None,
+            is_playing: false,
+            time_ratio: 0.0,
+        }
+    }
+}
+
+impl PlayerState {
+    pub fn play(&mut self, path: &str) {
+        self.currently_playing = Some(path.to_string());
+        self.is_playing = true;
+        self.time_ratio = 0.0;
+        // TODO: Handle audio
+    }
+
+    pub fn toggle_pause(&mut self) {
+        self.is_playing = !self.is_playing;
+    }
+}
 
 pub struct App {
     pub title: String,
+    pub playlist: StatefulList<String>,
+    pub player_state: PlayerState,
     pub should_quit: bool,
     pub enhanced_graphics: bool,
-    pub message_queue: Arc<Mutex<Vec<Message>>>,
-    pub state: Arc<Mutex<Option<ServerState>>>,
 }
 
 impl App {
     pub fn new(title: &str, enhanced_graphics: bool) -> Self {
+        let mut playlist = StatefulList::<String> {
+            state: ListState::default(),
+            items: FILE_PATHS.iter().map(|path| path.to_string()).collect(),
+        };
+        playlist.state.selected = if playlist.items.len() > 0 {
+            Some(0)
+        } else {
+            None
+        };
         Self {
             title: title.to_string(),
+            playlist,
+            player_state: PlayerState::default(),
             should_quit: false,
             enhanced_graphics,
-            message_queue: Arc::new(Mutex::new(vec![])),
-            state: Arc::new(Mutex::new(None)),
         }
     }
 
-    fn push_message(&mut self, message: Message) {
+    pub fn play_next(&mut self) {
-        self.message_queue.lock().unwrap().push(message);
+        let current = if let Some(currently_playing) = self.player_state.currently_playing.clone() {
+            if let Some(current_index) = self
+                .playlist
+                .items
+                .iter()
+                .position(|path| *path == currently_playing)
+            {
+                current_index
+            } else {
+                return;
+            }
+        } else {
+            return;
+        };
+        let track = if current >= self.playlist.items.len() - 1 {
+            self.playlist.items[0].as_str()
+        } else {
+            self.playlist.items[current + 1].as_str()
+        };
+        self.player_state.play(track);
     }
 
-    pub fn connected(&self) -> bool {
+    pub fn play_previous(&mut self) {
-        self.state.lock().unwrap().is_some()
+        let current = if let Some(currently_playing) = self.player_state.currently_playing.clone() {
+            if let Some(current_index) = self
+                .playlist
+                .items
+                .iter()
+                .position(|path| *path == currently_playing)
+            {
+                current_index
+            } else {
+                return;
+            }
+        } else {
+            return;
+        };
+        let track = if current <= 0 {
+            self.playlist.items[self.playlist.items.len() - 1].as_str()
+        } else {
+            self.playlist.items[current - 1].as_str()
+        };
+        self.player_state.play(track);
     }
 
-    pub fn toggle_shuffle(&mut self) {
+    pub fn replay_current(&mut self) {
-        self.push_message(Message::new(MessageType::ToggleSuffle, None));
+        if let Some(current) = self.playlist.current() {
+            self.player_state.play(current)
         }
-
-    pub fn toggle_next(&mut self) {
-        self.push_message(Message::new(MessageType::ToggleNext, None));
-    }
-
-    pub fn toggle_repeat(&mut self) {
-        self.push_message(Message::new(MessageType::ToggleRepeat, None));
-    }
-
-    pub fn fetch_state(&mut self) {
-        self.push_message(Message::new(MessageType::StateFetch, None));
     }
 
     pub fn on_key(&mut self, key: char) {
         match key {
-            'S' => self.toggle_shuffle(),
+            'b' => self.play_previous(),
-            'X' => self.toggle_next(),
+            'n' => self.play_next(),
-            'R' => self.toggle_repeat(),
             'q' => self.should_quit = true,
+            ' ' => self.player_state.toggle_pause(),
             _ => (),
         }
     }
@@ -65,13 +229,33 @@ impl App {
 
     pub fn on_right(&mut self) {}
 
-    pub fn on_up(&mut self) {}
+    pub fn on_up(&mut self) {
+        if self.playlist.items.len() > 0 {
+            self.playlist.previous()
+        }
+    }
 
-    pub fn on_down(&mut self) {}
+    pub fn on_down(&mut self) {
+        if self.playlist.items.len() > 0 {
+            self.playlist.next()
+        }
+    }
 
-    pub fn on_enter(&mut self) {}
+    pub fn on_enter(&mut self) {
+        if let Some(path) = self.playlist.current() {
+            self.player_state.play(path)
+        }
+    }
 
     pub fn on_tab(&mut self) {}
 
-    pub fn on_tick(&mut self, duration: Duration) {}
+    pub fn on_tick(&mut self, duration: Duration) {
+        let time_mod = if self.player_state.is_playing {
+            0.25
+        } else {
+            0.0
+        };
+        self.player_state.time_ratio =
+            (self.player_state.time_ratio + duration.as_secs_f64() * time_mod) % 1.0
+    }
 }

src/client/crossterm.rs

@@ -13,7 +13,7 @@ use ratatui::prelude::*;
 
 use super::{app::App, ui};
 
-pub fn run(app: App, tick_rate: Duration) -> Result<(), Box<dyn Error>> {
+pub fn run(tick_rate: Duration, enhanced_graphics: bool) -> Result<(), Box<dyn Error>> {
     // setup terminal
     enable_raw_mode()?;
     let mut stdout = io::stdout();
@@ -21,6 +21,8 @@ pub fn run(app: App, tick_rate: Duration) -> Result<(), Box<dyn Error>> {
     let backend = CrosstermBackend::new(stdout);
     let mut terminal = Terminal::new(backend)?;
 
+    // create app and run it
+    let app = App::new("rmp - Rust Music Player", enhanced_graphics);
     let res = run_app(&mut terminal, app, tick_rate);
 
     // restore terminal
@@ -54,7 +56,6 @@ fn run_app<B: Backend>(
         if crossterm::event::poll(timeout)? {
             if let Event::Key(key) = event::read()? {
                 if key.kind == KeyEventKind::Press {
-                    if app.connected() {
                     match key.code {
                         KeyCode::Char(c) => app.on_key(c),
                         KeyCode::Left => app.on_left(),
@@ -65,21 +66,9 @@ fn run_app<B: Backend>(
                         KeyCode::Tab => app.on_tab(),
                         _ => {}
                     }
-                    } else {
-                        // Allow quitting while in "Not connected" screen
-                        match key.code {
-                            KeyCode::Char(c) => {
-                                if c == 'q' {
-                                    app.should_quit = true;
-                                }
-                            }
-                            _ => (),
                 }
             }
         }
-            }
-        }
-
         if last_tick.elapsed() >= tick_rate {
             app.on_tick(last_tick.elapsed());
             last_tick = Instant::now();

src/client/request_queue.rs

@@ -1,94 +0,0 @@
-use std::{
-    sync::{Arc, Mutex},
-    time::{Duration, Instant},
-};
-
-use interprocess::local_socket::LocalSocketStream;
-use rmp::{
-    protocol::{self, Message, MessageError, MessageType},
-    ServerState,
-};
-
-pub fn request_queue_cleaner(
-    message_rate: Duration,
-    queue: Arc<Mutex<Vec<Message>>>,
-    state: Arc<Mutex<Option<ServerState>>>,
-) {
-    let mut last_tick = Instant::now();
-    let mut should_connect = true;
-    let mut stream: Option<LocalSocketStream> = None;
-    loop {
-        if should_connect {
-            *state.lock().unwrap() = None;
-            stream = Some(connect());
-            should_connect = false;
-        }
-        match stream.as_mut() {
-            Some(mut stream) => {
-                for request in queue.lock().unwrap().drain(..) {
-                    if let Err(_) = protocol::send(&mut stream, &request) {
-                        should_connect = true;
-                        continue;
-                    }
-                    if let Ok(response) = protocol::receive(&mut stream) {
-                        match route_response(&response, &mut state.lock().unwrap()) {
-                            Err(error) => {
-                                eprintln!("{error:?}")
-                            }
-                            _ => {}
-                        }
-                    }
-                }
-
-                // HACK: keep updating state
-                queue
-                    .lock()
-                    .unwrap()
-                    .push(Message::new(MessageType::StateFetch, None));
-
-                let sleep_duration = message_rate
-                    .checked_sub(last_tick.elapsed())
-                    .unwrap_or_else(|| Duration::from_secs(0));
-                std::thread::sleep(sleep_duration);
-                last_tick = Instant::now();
-            }
-            None => should_connect = true,
-        }
-    }
-}
-
-/// Blocks thread until connected to socket
-fn connect() -> LocalSocketStream {
-    let path = rmp::os::get_socket_path().unwrap();
-    loop {
-        match LocalSocketStream::connect(path.clone()) {
-            Ok(stream) => return stream,
-            Err(_) => {}
-        }
-        std::thread::sleep(Duration::from_millis(100));
-    }
-}
-
-fn route_response(response: &Message, state: &mut Option<ServerState>) -> Result<(), String> {
-    match response.message_type {
-        MessageType::StateResponse => {
-            let body = response.body.as_ref().ok_or("Missing response body")?;
-            let response: ServerState =
-                bincode::deserialize(&body).map_err(|err| err.to_string())?;
-            *state = Some(response);
-        }
-        MessageType::NotImplementedAck => {
-            eprintln!("Server doesn't implement message")
-        }
-        MessageType::ProtocolError => {
-            let body = response.body.as_ref().ok_or("Missing response body")?;
-            let response: MessageError =
-                bincode::deserialize(&body).map_err(|err| err.to_string())?;
-            eprintln!("Server claims protocol error: {response:?}");
-        }
-        message_type => {
-            eprintln!("Message handling not implemented for client: {message_type:?}");
-        }
-    }
-    Ok(())
-}

src/client/ui.rs

@@ -1,47 +1,54 @@
 use ratatui::{prelude::*, widgets::*};
+use std::path::Path;
 
 use super::app::App;
 
 pub fn draw<B: Backend>(f: &mut Frame<B>, app: &mut App) {
-    if app.connected() {
     let chunks = Layout::default()
         .constraints([Constraint::Min(3), Constraint::Length(2)].as_ref())
         .split(f.size());
     draw_playlist(f, app, chunks[0]);
     draw_player(f, app, chunks[1]);
-    } else {
-        draw_no_connection(f);
-    }
 }
 
 static PRIMARY_COLOR: Color = Color::Rgb(200, 150, 70);
 static SECONDARY_COLOR: Color = Color::Rgb(200, 200, 200);
 
-fn draw_no_connection<B: Backend>(f: &mut Frame<B>) {
-    let message = "Not connected";
-    let width = message.len() as u16 + 4;
-    let height = 3;
-
-    let x = (f.size().width as i16 - width as i16).max(0) as u16 / 2;
-    let y = (f.size().height as i16 - height as i16).max(0) as u16 / 2;
-
-    let area = Rect {
-        x,
-        y,
-        width: u16::min(width, f.size().width - x),
-        height: u16::min(height, f.size().height - y),
-    };
-    f.render_widget(
-        Paragraph::new(message)
-            .fg(SECONDARY_COLOR)
-            .block(Block::default().borders(Borders::ALL).fg(PRIMARY_COLOR))
-            .alignment(Alignment::Center),
-        area,
-    );
-}
-
 fn draw_playlist<B: Backend>(f: &mut Frame<B>, app: &App, area: Rect) {
-    let playlist = List::new(vec![])
+    let tracks: Vec<_> = app
+        .playlist
+        .items
+        .iter()
+        .enumerate()
+        .map(|(index, path)| {
+            let selected = app
+                .playlist
+                .state
+                .selected()
+                .map_or(false, |selected| index == selected);
+            let playing = app
+                .player_state
+                .currently_playing
+                .clone()
+                .map_or(false, |currently_playing| currently_playing == *path);
+            let mut style = Style::default();
+            match (selected, playing) {
+                (true, false) => {
+                    style.fg = Some(Color::Black);
+                    style.bg = Some(PRIMARY_COLOR);
+                }
+                (false, true) => style.fg = Some(PRIMARY_COLOR),
+                (true, true) => {
+                    style.fg = None;
+                    style.bg = Some(PRIMARY_COLOR);
+                }
+                (_, _) => (),
+            }
+            let content = Span::from(format_track_name(path));
+            ListItem::new(content).set_style(style)
+        })
+        .collect();
+    let playlist = List::new(tracks)
         .block(
             Block::default()
                 .borders(Borders::ALL)
@@ -52,11 +59,22 @@ fn draw_playlist<B: Backend>(f: &mut Frame<B>, app: &App, area: Rect) {
 }
 
 fn draw_player<B: Backend>(f: &mut Frame<B>, app: &App, area: Rect) {
-    let title_content = vec![
+    let title_content = match app.player_state.currently_playing.as_ref() {
+        Some(playing) => {
+            let symbol = match app.player_state.is_playing {
+                true => Span::from("||").fg(PRIMARY_COLOR),
+                false => Span::from("|>").fg(Color::Black).bg(PRIMARY_COLOR),
+            };
+            vec![
                 Span::from("[ "),
-        Span::from("??").fg(PRIMARY_COLOR),
+                symbol,
+                Span::from(" "),
+                Span::from(format_track_name(playing.as_str())),
                 Span::from(" ]"),
-    ];
+            ]
+        }
+        None => vec![Span::from(" Nothing selected ")],
+    };
 
     let player = Gauge::default()
         .block(
@@ -67,8 +85,19 @@ fn draw_player<B: Backend>(f: &mut Frame<B>, app: &App, area: Rect) {
                 .title_position(block::Position::Top),
         )
         .gauge_style(Style::default().fg(PRIMARY_COLOR))
-        .ratio(0.25)
+        .ratio(app.player_state.time_ratio)
-        .label("[ PAUSED ]");
+        .label(if app.player_state.is_playing {
+            ""
+        } else {
+            "[ PAUSED ]"
+        });
 
     f.render_widget(player, area)
 }
+
+fn format_track_name(path: &str) -> String {
+    match Path::new(path).file_stem() {
+        Some(file_name) => file_name.to_string_lossy().to_string(),
+        None => path.to_string(),
+    }
+}

src/lib.rs

@@ -1,76 +1 @@
-use std::path::PathBuf;
+pub mod client;
-
-use serde::{Deserialize, Serialize};
-
-#[cfg(target_family = "unix")]
-#[path = "os_unix.rs"]
-pub mod os;
-pub mod protocol;
-
-#[derive(Serialize, Deserialize, Debug, Default)]
-pub struct ServerState {
-    pub playlist_params: PlaylistParams,
-    pub directory_playlist: Option<DirectoryPlaylist>,
-    pub queue_playlist: QueuePlaylist,
-}
-
-pub type PlaylistElement = PathBuf;
-
-pub enum PlaylistType {
-    Directory,
-    Queue,
-}
-
-#[derive(Serialize, Deserialize, Debug, Default)]
-pub struct Playlist {
-    pub items: Vec<PlaylistElement>,
-    pub current: Option<usize>,
-}
-
-impl Playlist {}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct DirectoryPlaylist {
-    pub directory: PathBuf,
-    pub playlist: Playlist,
-}
-
-#[derive(Serialize, Deserialize, Debug, Default)]
-pub struct QueuePlaylist {
-    pub playlist: Playlist,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct PlaylistParams {
-    pub shuffle: bool,
-    pub next: bool,
-    pub repeat: bool,
-}
-
-impl Default for PlaylistParams {
-    fn default() -> Self {
-        Self {
-            shuffle: false,
-            next: true,
-            repeat: true,
-        }
-    }
-}
-
-pub mod server {
-    use std::{fmt::Debug, path::PathBuf};
-
-    #[derive(Debug)]
-    pub enum ServerError {
-        Other(String),
-        Io(std::io::Error),
-        AlreadyStarted,
-        MissingRuntimeDir(PathBuf),
-    }
-
-    impl ServerError {
-        pub fn from_debuggable(err: impl Debug) -> Self {
-            Self::Other(format!("Unexpected error: {err:?}").to_string())
-        }
-    }
-}

src/main.rs

@@ -1,63 +0,0 @@
-use argh::FromArgs;
-
-pub mod client;
-pub mod server;
-
-/// rmp: Rust Music Player
-#[derive(Debug, FromArgs)]
-pub struct CliArgs {
-    /// run the server
-    #[argh(switch, short = 's')]
-    server: bool,
-
-    /// randomize next track?
-    #[argh(option, default = "false")]
-    shuffle: bool,
-
-    /// change track after the current one is finished?
-    #[argh(option, default = "true")]
-    next: bool,
-
-    /// repeat the playlist (or track if 'next' is disabled) after it's finished
-    #[argh(option, default = "true")]
-    repeat: bool,
-
-    /// kill server
-    #[argh(switch, short = 'x')]
-    exit: bool,
-
-    /// don't start server even if it's not running
-    #[argh(switch, short = 'c')]
-    client_only: bool,
-
-    /// time in ms between two ticks.
-    #[argh(option, default = "250")]
-    tick_rate: u64,
-
-    /// interval in ms for clearing the request queue.
-    #[argh(option, default = "50")]
-    message_rate: u64,
-
-    /// whether unicode symbols are used to improve the overall look of the app
-    #[argh(option, default = "true")]
-    enhanced_graphics: bool,
-}
-
-fn main() {
-    let args: CliArgs = argh::from_env();
-
-    if args.exit {
-        server::kill();
-        return;
-    }
-
-    if args.server {
-        server::run(args).unwrap();
-        return;
-    }
-
-    if !args.client_only && !server::is_running().unwrap() {
-        server::run_in_background();
-    }
-    client::run(args).unwrap();
-}

src/os_unix.rs

@@ -1,92 +0,0 @@
-use std::{
-    fs,
-    path::{Path, PathBuf},
-    process::{id, Command, Stdio},
-};
-
-use super::server::ServerError;
-
-pub fn reserve_pid() -> Result<(), ServerError> {
-    let pid_path = get_pid_path()?;
-    is_running()?;
-
-    fs::write(&pid_path, id().to_string()).map_err(|err| ServerError::Io(err))?;
-    Command::new("chmod")
-        .args(&["600", &pid_path.to_string_lossy()])
-        .output()
-        .map_err(|err| ServerError::Io(err))?;
-    Ok(())
-}
-
-pub fn is_running() -> Result<bool, ServerError> {
-    let pid_path = get_pid_path()?;
-
-    match fs::read(&pid_path) {
-        Ok(old_pid) => {
-            let old_pid =
-                String::from_utf8(old_pid).map_err(|err| ServerError::from_debuggable(err))?;
-            let old_pid = old_pid.trim();
-            Ok(Command::new("ps")
-                .args(&["-p", old_pid])
-                .stdout(Stdio::null())
-                .stderr(Stdio::null())
-                .status()
-                .map_err(|err| ServerError::Io(err))?
-                .success())
-        }
-        _ => Ok(false),
-    }
-}
-
-pub fn run_in_background() -> Result<(), ServerError> {
-    let this = std::env::args().next().unwrap();
-    Command::new(this)
-        .stdout(Stdio::null())
-        .stderr(Stdio::null())
-        .args(&["-s"])
-        .spawn()
-        .map_err(|err| ServerError::Io(err))?;
-    Ok(())
-}
-
-pub fn kill() -> Result<(), ServerError> {
-    let pid_path = get_pid_path()?;
-    let socket_path = get_socket_path()?;
-    let pid = String::from_utf8(fs::read(&pid_path).map_err(|err| ServerError::Io(err))?)
-        .map_err(|err| ServerError::from_debuggable(err))?;
-    let pid = pid.trim();
-    Command::new("kill")
-        .arg(pid)
-        .spawn()
-        .map_err(|err| ServerError::Io(err))?;
-    Command::new("rm")
-        .args(&[
-            "-f",
-            &pid_path.to_string_lossy(),
-            &socket_path.to_string_lossy(),
-        ])
-        .spawn()
-        .map_err(|err| ServerError::Io(err))?;
-    Ok(())
-}
-
-pub fn get_socket_path() -> Result<PathBuf, ServerError> {
-    Ok(get_runtime_dir()?.join("rmp.socket"))
-}
-
-fn get_runtime_dir() -> Result<PathBuf, ServerError> {
-    let uid = String::from_utf8(
-        Command::new("id")
-            .arg("-u")
-            .output()
-            .map_err(|err| ServerError::Io(err))?
-            .stdout,
-    )
-    .map_err(|err| ServerError::from_debuggable(err))?;
-    let dir = Path::new("/run/user").join(uid.trim().to_string());
-    Ok(dir)
-}
-
-fn get_pid_path() -> Result<PathBuf, ServerError> {
-    Ok(get_runtime_dir()?.join("rmp.pid"))
-}

src/protocol.rs

@@ -1,130 +0,0 @@
-use std::{
-    fmt::Display,
-    io::{Read, Write},
-};
-
-use interprocess::local_socket::LocalSocketStream;
-use serde::{Deserialize, Serialize};
-
-use crate::ServerState;
-
-/// Prefix messages with this header
-pub const HEADER_MAGIC: [u8; 4] = [0xCA, 0xFE, 0xBA, 0xBE];
-/// Maximum allowed body size
-pub const MAX_BODY_LENGTH: usize = 10 * 1024 * 1024;
-
-#[derive(Debug, Serialize, Deserialize)]
-pub enum MessageError {
-    HeaderMismatch,
-    BodySizeLimit,
-    ChecksumMismatch,
-    ReadError,
-    DeserializationError,
-}
-
-#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy, Deserialize, Serialize)]
-pub enum MessageType {
-    /// Generic acknowledge
-    Ack = 0,
-    /// client/server did not know how to handle the request
-    NotImplementedAck,
-    /// Request was invalid
-    ProtocolError,
-    StateFetch,
-    StateResponse,
-    ToggleSuffle,
-    ToggleNext,
-    ToggleRepeat,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Message {
-    pub message_type: MessageType,
-    pub body: Option<Vec<u8>>,
-}
-
-impl Message {
-    pub fn new(message_type: MessageType, body: Option<&[u8]>) -> Self {
-        Self {
-            message_type,
-            body: body.map(|b| Vec::from(b)),
-        }
-    }
-
-    /// Message format (values are in little-endian):
-    /// offset | size | explanation
-    /// -------+------+-----------
-    /// 0x00   |  u32 | HEADER_MAGIC
-    /// 0x04   |  u32 | Body checksum
-    /// 0x08   |  u32 | Body length
-    /// 0x12   |    ? | Body
-    fn as_bytes(&self) -> Vec<u8> {
-        let magic = &HEADER_MAGIC[..];
-        let body = &bincode::serialize(self).unwrap();
-        let checksum = &crc32fast::hash(&body).to_le_bytes();
-        let body_length = &(body.len() as u32).to_le_bytes();
-        [magic, checksum, body_length, body].concat()
-    }
-
-    pub fn state_response(server_state: &ServerState) -> Result<Self, String> {
-        Ok(Self {
-            message_type: MessageType::StateResponse,
-            body: Some(bincode::serialize(server_state).map_err(|err| err.to_string())?),
-        })
-    }
-}
-
-impl Display for Message {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{:?}\t{}",
-            self.message_type,
-            self.body
-                .as_ref()
-                .map_or("(no body)".into(), |body| format!("{} B", body.len()))
-        )
-    }
-}
-
-pub fn send(stream: &mut LocalSocketStream, message: &Message) -> Result<(), std::io::Error> {
-    stream.write_all(&message.as_bytes())?;
-    Ok(())
-}
-
-pub fn receive(stream: &mut LocalSocketStream) -> Result<Message, MessageError> {
-    let mut magic_buffer = vec![0; HEADER_MAGIC.len()];
-    if let Err(_) = stream.read_exact(&mut magic_buffer) {
-        return Err(MessageError::ReadError);
-    }
-    if magic_buffer != HEADER_MAGIC {
-        return Err(MessageError::HeaderMismatch);
-    }
-
-    let mut checksum_buffer = [0; 4];
-    if let Err(_) = stream.read_exact(&mut checksum_buffer) {
-        return Err(MessageError::ReadError);
-    }
-    let expected_checksum = u32::from_le_bytes(checksum_buffer);
-
-    let mut body_length_buffer = [0; 4];
-    if let Err(_) = stream.read_exact(&mut body_length_buffer) {
-        return Err(MessageError::ReadError);
-    }
-    let expected_body_length = u32::from_le_bytes(body_length_buffer) as usize;
-
-    if expected_body_length > MAX_BODY_LENGTH {
-        return Err(MessageError::BodySizeLimit);
-    }
-
-    let mut body_buffer = vec![0; expected_body_length];
-    if let Err(_) = stream.read_exact(&mut body_buffer) {
-        return Err(MessageError::ReadError);
-    }
-
-    if crc32fast::hash(&body_buffer) != expected_checksum {
-        return Err(MessageError::ChecksumMismatch);
-    }
-
-    bincode::deserialize(&body_buffer).map_err(|_| MessageError::DeserializationError)
-}

src/server.rs

@@ -1,174 +0,0 @@
-use interprocess::local_socket::{LocalSocketListener, LocalSocketStream};
-
-use rmp::{
-    os,
-    protocol::{Message, MessageType},
-    server::ServerError,
-    PlaylistParams, ServerState,
-};
-use std::{
-    fs,
-    sync::{Arc, Mutex},
-};
-
-use crate::CliArgs;
-
-pub mod audio_backend;
-
-#[derive(Debug)]
-pub struct Server {
-    pub state: ServerState,
-}
-
-impl Server {
-    pub fn from_state(state: ServerState) -> Self {
-        Self { state }
-    }
-}
-
-pub fn run(args: CliArgs) -> Result<(), ServerError> {
-    if let Err(err) = os::reserve_pid() {
-        let exit_code = handle_error(err);
-        std::process::exit(exit_code);
-    }
-    serve(ServerState {
-        playlist_params: PlaylistParams {
-            shuffle: args.shuffle,
-            next: args.next,
-            repeat: args.repeat,
-        },
-        ..Default::default()
-    })
-}
-
-pub fn kill() {
-    if let Err(err) = os::kill() {
-        let exit_code = handle_error(err);
-        std::process::exit(exit_code);
-    }
-}
-
-pub fn is_running() -> Result<bool, ServerError> {
-    match os::is_running() {
-        Ok(is_running) => Ok(is_running),
-        Err(err) => {
-            let exit_code = handle_error(err);
-            std::process::exit(exit_code);
-        }
-    }
-}
-
-pub fn run_in_background() {
-    if let Err(err) = os::run_in_background() {
-        let exit_code = handle_error(err);
-        std::process::exit(exit_code);
-    }
-}
-
-fn serve(state: ServerState) -> Result<(), ServerError> {
-    let socket_path = os::get_socket_path()?;
-    if socket_path.exists() {
-        fs::remove_file(&socket_path).map_err(|err| ServerError::Io(err))?;
-    }
-    let socket = LocalSocketListener::bind(socket_path).map_err(|err| ServerError::Io(err))?;
-    let server = Arc::new(Mutex::new(Server::from_state(state)));
-    println!("Waiting for connections...");
-    let mut session_counter = 0;
-    for message in socket.incoming() {
-        match message {
-            Ok(stream) => {
-                session_counter += 1;
-                let thread_builder =
-                    std::thread::Builder::new().name(format!("session_{session_counter}"));
-                let server = server.clone();
-                thread_builder
-                    .spawn(move || session_handler(stream, server))
-                    .unwrap();
-            }
-            Err(err) => {
-                let exit_code = handle_error(ServerError::Io(err));
-                std::process::exit(exit_code);
-            }
-        };
-    }
-    println!("Reached the end of an infinite loop?");
-    Ok(())
-}
-
-fn session_handler(mut stream: LocalSocketStream, server: Arc<Mutex<Server>>) {
-    let thread = std::thread::current();
-    let session_id = thread.name().unwrap_or("<unnamed>");
-    println!("[{session_id}] session created");
-    loop {
-        match rmp::protocol::receive(&mut stream) {
-            Ok(message) => {
-                println!("[{session_id}] rx {message}");
-                match route_request(&message, &mut server.lock().unwrap()) {
-                    Err(err) => {
-                        eprintln!("[{session_id}] rx Error: {err}");
-                    }
-                    Ok(response) => {
-                        println!("[{session_id}] tx {response}");
-                        rmp::protocol::send(&mut stream, &response).unwrap();
-                    }
-                }
-            }
-            Err(error) => match error {
-                rmp::protocol::MessageError::ReadError => {
-                    println!("[{session_id}] session terminated");
-                    return;
-                }
-                error => {
-                    eprintln!("[{session_id}] rx {error:?}");
-                    let body = bincode::serialize(&error).unwrap();
-                    let message = Message::new(MessageType::ProtocolError, Some(&body));
-                    println!("[{session_id}] tx {message}");
-                    rmp::protocol::send(&mut stream, &message).unwrap();
-                }
-            },
-        }
-    }
-}
-
-fn handle_error(err: ServerError) -> i32 {
-    match &err {
-        ServerError::Other(msg) => {
-            eprintln!("Unknown error: {msg}");
-            1
-        }
-        ServerError::Io(err) => {
-            eprintln!("IO error: {err}");
-            2
-        }
-        ServerError::AlreadyStarted => {
-            eprintln!("Server already running");
-            100
-        }
-        ServerError::MissingRuntimeDir(path) => {
-            eprintln!("Missing runtime directory: {}", path.to_string_lossy());
-            101
-        }
-    }
-}
-
-fn route_request(request: &Message, server: &mut Server) -> Result<Message, String> {
-    match request.message_type {
-        MessageType::StateFetch => {
-            return Message::state_response(&server.state);
-        }
-        MessageType::ToggleNext => {
-            server.state.playlist_params.next = !server.state.playlist_params.next;
-            return Message::state_response(&server.state);
-        }
-        MessageType::ToggleSuffle => {
-            server.state.playlist_params.shuffle = !server.state.playlist_params.shuffle;
-            return Message::state_response(&server.state);
-        }
-        MessageType::ToggleRepeat => {
-            server.state.playlist_params.repeat = !server.state.playlist_params.repeat;
-            return Message::state_response(&server.state);
-        }
-        _ => {}
-    }
-    Ok(Message::new(MessageType::NotImplementedAck, None))
-}

src/server/audio_backend.rs

@@ -1,7 +0,0 @@
-use std::{path::Path, time::Duration};
-
-pub trait AudioBackend {
-    fn seek_and_play(&mut self, file_path: &Path, seek: Duration) -> ();
-    fn pause_playback(&mut self) -> ();
-    fn continue_playback(&mut self) -> ();
-}