Render a file list from the filesystem (#24)

This MR scans the filesystem in the specified directory. It assembles a list of files from the scan and then presents that entire list to the UI. The UI then renders it.

Resolves: https://www.pivotaltracker.com/story/show/184466979
Co-authored-by: Savanni D'Gerinel <savanni@luminescent-dreams.com>
Reviewed-on: savanni/tools#24
This commit is contained in:
savanni 2023-02-26 03:17:00 +00:00
parent 4163ccb5c2
commit 52ca039f45
14 changed files with 547 additions and 4235 deletions

View File

@ -17,7 +17,7 @@ You should have received a copy of the GNU General Public License along with Lum
//! Where the sled.rs library uses `Result<Result<A, Error>, FatalError>`, these are a little hard to //! Where the sled.rs library uses `Result<Result<A, Error>, FatalError>`, these are a little hard to
//! work with. This library works out a set of utility functions that allow us to work with the //! work with. This library works out a set of utility functions that allow us to work with the
//! nested errors in the same way as a regular Result. //! nested errors in the same way as a regular Result.
use std::error::Error; use std::{error::Error, fmt};
/// Implement this trait for the application's fatal errors. /// Implement this trait for the application's fatal errors.
/// ///
@ -110,6 +110,37 @@ impl<A, FE, E> From<Result<A, E>> for Flow<A, FE, E> {
} }
} }
impl<A, FE, E> fmt::Debug for Flow<A, FE, E>
where
A: fmt::Debug,
FE: fmt::Debug,
E: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Flow::Ok(val) => f.write_fmt(format_args!("Flow::Ok {:?}", val)),
Flow::Err(err) => f.write_fmt(format_args!("Flow::Err {:?}", err)),
Flow::Fatal(err) => f.write_fmt(format_args!("Flow::Fatal {:?}", err)),
}
}
}
impl<A, FE, E> PartialEq for Flow<A, FE, E>
where
A: PartialEq,
FE: PartialEq,
E: PartialEq,
{
fn eq(&self, rhs: &Self) -> bool {
match (self, rhs) {
(Flow::Ok(val), Flow::Ok(rhs)) => val == rhs,
(Flow::Err(_), Flow::Err(_)) => true,
(Flow::Fatal(_), Flow::Fatal(_)) => true,
_ => false,
}
}
}
/// Convenience function to create an ok value. /// Convenience function to create an ok value.
pub fn ok<A, FE: FatalError, E: Error>(val: A) -> Flow<A, FE, E> { pub fn ok<A, FE: FatalError, E: Error>(val: A) -> Flow<A, FE, E> {
Flow::Ok(val) Flow::Ok(val)
@ -177,43 +208,25 @@ mod test {
} }
} }
impl PartialEq for Flow<i32, FatalError, Error> {
fn eq(&self, rhs: &Self) -> bool {
match (self, rhs) {
(Flow::Ok(val), Flow::Ok(rhs)) => val == rhs,
(Flow::Err(_), Flow::Err(_)) => true,
(Flow::Fatal(_), Flow::Fatal(_)) => true,
_ => false,
}
}
}
impl std::fmt::Debug for Flow<i32, FatalError, Error> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Flow::Ok(val) => f.write_fmt(format_args!("Flow::Ok {}", val)),
Flow::Err(err) => f.write_fmt(format_args!("Flow::Err {:?}", err)),
Flow::Fatal(err) => f.write_fmt(format_args!("Flow::Fatal {:?}", err)),
}
}
}
#[test] #[test]
fn it_can_map_things() { fn it_can_map_things() {
let success = ok(15); let success: Flow<i32, FatalError, Error> = ok(15);
assert_eq!(ok(16), success.map(|v| v + 1)); assert_eq!(ok(16), success.map(|v| v + 1));
} }
#[test] #[test]
fn it_can_chain_success() { fn it_can_chain_success() {
let success = ok(15); let success: Flow<i32, FatalError, Error> = ok(15);
assert_eq!(ok(16), success.and_then(|v| ok(v + 1))); assert_eq!(ok(16), success.and_then(|v| ok(v + 1)));
} }
#[test] #[test]
fn it_can_handle_an_error() { fn it_can_handle_an_error() {
let failure = error(Error::Error); let failure: Flow<i32, FatalError, Error> = error(Error::Error);
assert_eq!(ok(16), failure.or_else(|_| ok(16))); assert_eq!(
ok::<i32, FatalError, Error>(16),
failure.or_else(|_| ok(16))
);
} }
#[test] #[test]

9
music-player/Makefile Normal file
View File

@ -0,0 +1,9 @@
server-dev:
cd server && cargo watch -x run
server-test:
cd server && cargo watch -x test
client-dev:
cd client && npm run watch

View File

@ -24,6 +24,7 @@
<table> <table>
<thead> <thead>
<tr> <tr>
<th> id </th>
<th> Track # </th> <th> Track # </th>
<th> Title </th> <th> Title </th>
<th> Artist </th> <th> Artist </th>
@ -33,6 +34,7 @@
</thead> </thead>
<tbody> <tbody>
<!--
<tr class="track-list__track-row"> <tr class="track-list__track-row">
<td> 1 </td> <td> 1 </td>
<td> Underground </td> <td> Underground </td>
@ -68,12 +70,13 @@
<td> Artemis </td> <td> Artemis </td>
<td> 3:58 </td> <td> 3:58 </td>
</tr> </tr>
-->
</tbody> </tbody>
</table> </table>
</div> </div>
</div> </div>
<script src="./dist/main.js" type="module"></script> <script src="./bundle.js" type="module"></script>
</body> </body>
</html> </html>

File diff suppressed because it is too large Load Diff

View File

@ -4,7 +4,7 @@
"description": "", "description": "",
"main": "main.js", "main": "main.js",
"scripts": { "scripts": {
"build": "browserify src/main.ts -p [ tsify ] > dist/bundle.js", "build": "browserify src/main.ts -p [ tsify ] > dist/bundle.js && cp index.html styles.css dist",
"test": "echo \"Error: no test specified\" && exit 1", "test": "echo \"Error: no test specified\" && exit 1",
"watch": "exa index.html styles.css src/* | entr -s 'npm run build'" "watch": "exa index.html styles.css src/* | entr -s 'npm run build'"
}, },
@ -18,7 +18,6 @@
"@types/lodash": "^4.14.191", "@types/lodash": "^4.14.191",
"babelify": "^10.0.0", "babelify": "^10.0.0",
"browserify": "^17.0.0", "browserify": "^17.0.0",
"live-server": "^1.2.2",
"tsify": "^5.0.4", "tsify": "^5.0.4",
"typescript": "^4.9.4", "typescript": "^4.9.4",
"watchify": "^4.0.0" "watchify": "^4.0.0"

View File

@ -1,5 +1,13 @@
import * as _ from "lodash"; import * as _ from "lodash";
interface TrackInfo {
id: string;
track_number?: number;
name?: string;
album?: string;
artist?: string;
}
const replaceTitle = () => { const replaceTitle = () => {
const title = document.querySelector(".js-title"); const title = document.querySelector(".js-title");
if (title && title.innerHTML) { if (title && title.innerHTML) {
@ -7,21 +15,57 @@ const replaceTitle = () => {
} }
}; };
/* const getTracks = () => fetch("/api/v1/tracks").then((r) => r.json());
const checkWeatherService = () => {
fetch("https://api.weather.gov/") const formatTrack = (track: TrackInfo) => {
.then((r) => r.json()) let row = document.createElement("tr");
.then((js) => { row.classList.add("track-list__row");
const weather = document.querySelector('.js-weather');
weather.innerHTML = js.status; let track_id = document.createElement("td");
}); track_id.appendChild(document.createTextNode(track.id));
} track_id.classList.add("track-list__cell");
*/
let track_number = document.createElement("td");
track_number.appendChild(
document.createTextNode(track.track_number?.toString() || "")
);
track_number.classList.add("track-list__cell");
let name = document.createElement("td");
name.appendChild(document.createTextNode(track.name || ""));
name.classList.add("track-list__cell");
let album = document.createElement("td");
album.appendChild(document.createTextNode(track.album || ""));
album.classList.add("track-list__cell");
let artist = document.createElement("td");
artist.appendChild(document.createTextNode(track.artist || ""));
artist.classList.add("track-list__cell");
let length = document.createElement("td");
artist.appendChild(document.createTextNode(""));
length.classList.add("track-list__cell");
row.appendChild(track_id);
row.appendChild(track_number);
row.appendChild(name);
row.appendChild(artist);
row.appendChild(album);
row.appendChild(length);
return row;
};
const updateTrackList = (tracks: TrackInfo[]) => {
const track_list = document.querySelector(".track-list__tracks tbody");
if (track_list) {
let track_formats = _.map(tracks, formatTrack);
_.map(track_formats, (trackinfo) => track_list.appendChild(trackinfo));
}
};
const run = () => { const run = () => {
replaceTitle(); getTracks().then((tracks) => updateTrackList(tracks));
console.log(_.map([4, 8], (x) => x * x));
// checkWeatherService();
}; };
run(); run();

View File

@ -25,15 +25,18 @@ body {
list-style: none; list-style: none;
} }
.track-list__track-row { .track-list__row {
background-color: rgb(10, 10, 10); background-color: rgb(10, 10, 10);
} }
.track-list__track-row:nth-child(even) { .track-list__row:nth-child(even) {
background-color: rgb(255, 255, 255); background-color: rgb(255, 255, 255);
} }
.track-list__track-row:nth-child(odd) { .track-list__row:nth-child(odd) {
background-color: rgb(200, 200, 200); background-color: rgb(200, 200, 200);
} }
.track-list__cell {
padding: 8px;
}

View File

@ -6,6 +6,7 @@
"rootDir": "src", "rootDir": "src",
"outDir": "./dist", "outDir": "./dist",
"lib": ["es2016", "DOM"], "lib": ["es2016", "DOM"],
"sourceMap": true "sourceMap": true,
"strict": true
} }
} }

View File

@ -10,15 +10,8 @@ Luminescent Dreams Tools is distributed in the hope that it will be useful, but
You should have received a copy of the GNU General Public License along with Lumeto. If not, see <https://www.gnu.org/licenses/>. You should have received a copy of the GNU General Public License along with Lumeto. If not, see <https://www.gnu.org/licenses/>.
*/ */
use dbus::ffidisp::Connection;
use mpris::{FindingError, PlaybackStatus, Player, PlayerFinder, ProgressTick};
use serde::Serialize; use serde::Serialize;
use std::{ use std::time::Duration;
path::PathBuf,
sync::mpsc::{channel, Receiver, Sender, TryRecvError},
thread,
time::Duration,
};
use thiserror::Error; use thiserror::Error;
pub enum Message { pub enum Message {
@ -27,10 +20,10 @@ pub enum Message {
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub enum Event { pub enum Event {
Paused(Track, Duration), Paused(TrackId, Duration),
Playing(Track, Duration), Playing(TrackId, Duration),
Stopped, Stopped,
Position(Track, Duration), Position(TrackId, Duration),
} }
#[derive(Debug)] #[derive(Debug)]
@ -39,17 +32,6 @@ pub struct DeviceInformation {
pub name: String, pub name: String,
} }
pub fn list_devices(conn: Connection) -> Result<Vec<DeviceInformation>, FindingError> {
Ok(PlayerFinder::for_connection(conn)
.find_all()?
.into_iter()
.map(|player| DeviceInformation {
address: player.unique_name().to_owned(),
name: player.identity().to_owned(),
})
.collect())
}
#[derive(Debug, Error)] #[derive(Debug, Error)]
pub enum AudioError { pub enum AudioError {
#[error("DBus device was not found")] #[error("DBus device was not found")]
@ -113,17 +95,8 @@ impl AsRef<String> for TrackId {
} }
} }
#[derive(Clone, Debug)]
pub struct TrackInfo {
pub track_number: Option<i32>,
pub name: Option<String>,
pub album: Option<String>,
pub artist: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize)] #[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")] pub struct TrackInfo {
pub struct Track {
pub id: TrackId, pub id: TrackId,
pub track_number: Option<i32>, pub track_number: Option<i32>,
pub name: Option<String>, pub name: Option<String>,
@ -131,38 +104,20 @@ pub struct Track {
pub artist: Option<String>, pub artist: Option<String>,
} }
/*
impl From<&mpris::Metadata> for Track {
fn from(data: &mpris::Metadata) -> Self {
Self {
id: data.track_id().unwrap(),
track_number: data.track_number(),
name: data.title().map(|s| s.to_owned()),
album: data.album_name().map(|s| s.to_owned()),
artist: None,
}
}
}
impl From<mpris::Metadata> for Track {
fn from(data: mpris::Metadata) -> Self {
Self::from(&data)
}
}
*/
#[derive(Clone, Debug, Serialize)] #[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")] #[serde(rename_all = "camelCase")]
pub enum State { pub enum State {
Playing(Track), Playing(TrackInfo),
Paused(Track), Paused(TrackInfo),
Stopped, Stopped,
} }
/*
pub struct CurrentlyPlaying { pub struct CurrentlyPlaying {
track: Track, track: TrackInfo,
position: Duration, position: Duration,
} }
*/
#[derive(Clone, Debug, Serialize)] #[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")] #[serde(rename_all = "camelCase")]
@ -180,6 +135,7 @@ pub trait AudioPlayer {
fn play_pause(&self) -> Result<State, AudioError>; fn play_pause(&self) -> Result<State, AudioError>;
} }
/*
pub struct GStreamerPlayer { pub struct GStreamerPlayer {
url: url::Url, url: url::Url,
} }
@ -201,6 +157,7 @@ impl AudioPlayer for GStreamerPlayer {
unimplemented!() unimplemented!()
} }
} }
*/
/* /*
pub struct MprisDevice { pub struct MprisDevice {

View File

@ -1,72 +1,92 @@
use flow::Flow; use flow::Flow;
use std::{io::stdin, path::PathBuf, sync::Arc, thread, time::Duration}; use std::{
// use warp::Filter; net::{IpAddr, Ipv4Addr, SocketAddr},
path::PathBuf,
sync::Arc,
};
use warp::Filter;
use music_player::{core::Core, database::MemoryIndex}; use music_player::{
audio::TrackInfo,
core::Core,
database::{MemoryIndex, MusicIndex},
music_scanner::FileScanner,
};
/* fn tracks(index: &Arc<impl MusicIndex>) -> Vec<TrackInfo> {
fn tracks() -> Vec<Track> { match index.list_tracks() {
vec![ Flow::Ok(tracks) => tracks,
Track { Flow::Err(err) => panic!("error: {}", err),
track_number: Some(1), Flow::Fatal(err) => panic!("fatal: {}", err),
name: Some("Underground".to_owned()), }
album: Some("Artemis".to_owned()), }
artist: Some("Lindsey Stirling".to_owned()),
path: PathBuf::from("/mnt/music/Lindsey Stirling/Artemis/01 - Underground.ogg"), enum Bundle {
}, Index,
Track { App,
track_number: Some(2), Styles,
name: Some("Artemis".to_owned()), }
album: Some("Artemis".to_owned()),
artist: Some("Lindsey Stirling".to_owned()), impl Bundle {
path: PathBuf::from("/mnt/music/Lindsey Stirling/Artemis/02 - Artemis.ogg"), fn read(self, root: PathBuf) -> String {
}, let mut path = root;
Track { match self {
track_number: Some(3), Bundle::Index => path.push(PathBuf::from("index.html")),
name: Some("Til the Light Goes Out".to_owned()), Bundle::App => path.push(PathBuf::from("bundle.js")),
album: Some("Artemis".to_owned()), Bundle::Styles => path.push(PathBuf::from("styles.css")),
artist: Some("Lindsey Stirling".to_owned()), };
path: PathBuf::from( println!("path: {:?}", path);
"/mnt/music/Lindsey Stirling/Artemis/03 - Til the Light Goes Out.ogg", std::fs::read_to_string(path).expect("to find the file")
), }
},
Track {
track_number: Some(4),
name: Some("Between Twilight".to_owned()),
album: Some("Artemis".to_owned()),
artist: Some("Lindsey Stirling".to_owned()),
path: PathBuf::from("/mnt/music/Lindsey Stirling/Artemis/04 - Between Twilight.ogg"),
},
Track {
track_number: Some(5),
name: Some("Foreverglow".to_owned()),
album: Some("Artemis".to_owned()),
artist: Some("Lindsey Stirling".to_owned()),
path: PathBuf::from("/mnt/music/Lindsey Stirling/Artemis/05 - Foreverglow.ogg"),
},
]
} }
*/
#[tokio::main] #[tokio::main]
pub async fn main() { pub async fn main() {
match Core::new(Arc::new(MemoryIndex::new())) { let dev = std::env::var("DEV")
Flow::Ok(core) => { .ok()
let mut buf = String::new(); .and_then(|v| v.parse::<bool>().ok())
let _ = stdin().read_line(&mut buf).unwrap(); .unwrap_or(false);
core.exit(); let bundle_root = std::env::var("BUNDLE_ROOT")
} .map(|b| PathBuf::from(b))
Flow::Err(err) => println!("non-fatal error: {:?}", err), .unwrap();
Flow::Fatal(err) => println!("fatal error: {:?}", err), let music_root = std::env::var("MUSIC_ROOT")
} .map(|b| PathBuf::from(b))
.unwrap();
/* let index = Arc::new(MemoryIndex::new());
let connection = Connection::new_session().expect("to connect to dbus"); let scanner = FileScanner::new(vec![music_root.clone()]);
let _core = match Core::new(index.clone(), scanner) {
Flow::Ok(core) => core,
Flow::Err(error) => panic!("error: {}", error),
Flow::Fatal(error) => panic!("fatal: {}", error),
};
for player in list_players(connection) { println!("config: {:?} {:?} {:?}", dev, bundle_root, music_root);
println!("player found: {}", player.identity());
let root = warp::path!().and(warp::get()).map({
let bundle_root = bundle_root.clone();
move || {
warp::http::Response::builder()
.header("content-type", "text/html")
.body(Bundle::Index.read(bundle_root.clone()))
} }
*/ });
let app = warp::path!("bundle.js").and(warp::get()).map({
let bundle_root = bundle_root.clone();
move || {
warp::http::Response::builder()
.header("content-type", "text/javascript")
.body(Bundle::App.read(bundle_root.clone()))
}
});
let styles = warp::path!("styles.css").and(warp::get()).map({
let bundle_root = bundle_root.clone();
move || {
warp::http::Response::builder()
.header("content-type", "text/css")
.body(Bundle::Styles.read(bundle_root.clone()))
}
});
/* /*
let devices = warp::path!("api" / "v1" / "devices") let devices = warp::path!("api" / "v1" / "devices")
@ -75,10 +95,14 @@ pub async fn main() {
let conn = Connection::new_session().expect("to connect to dbus"); let conn = Connection::new_session().expect("to connect to dbus");
warp::reply::json(&list_devices(conn)) warp::reply::json(&list_devices(conn))
}); });
*/
let track_list = warp::path!("api" / "v1" / "tracks") let track_list = warp::path!("api" / "v1" / "tracks").and(warp::get()).map({
.and(warp::get()) let index = index.clone();
.map(|| warp::reply::json(&tracks())); move || warp::reply::json(&tracks(&index))
});
/*
let tracks_for_artist = warp::path!("api" / "v1" / "artist" / String) let tracks_for_artist = warp::path!("api" / "v1" / "artist" / String)
.and(warp::get()) .and(warp::get())
.map(|_artist: String| warp::reply::json(&tracks())); .map(|_artist: String| warp::reply::json(&tracks()));
@ -103,6 +127,8 @@ pub async fn main() {
.or(tracks_for_artist) .or(tracks_for_artist)
.or(queue) .or(queue)
.or(playing_status); .or(playing_status);
*/
let routes = root.or(app).or(styles).or(track_list);
let server = warp::serve(routes); let server = warp::serve(routes);
server server
.run(SocketAddr::new( .run(SocketAddr::new(
@ -110,5 +136,4 @@ pub async fn main() {
8002, 8002,
)) ))
.await; .await;
*/
} }

View File

@ -1,10 +1,8 @@
use crate::{ use crate::{
database::{Database, MemoryIndex, MusicIndex}, audio::TrackInfo, database::MusicIndex, music_scanner::MusicScanner, Error, FatalError,
Error, FatalError,
}; };
use flow::{error, fatal, ok, return_error, return_fatal, Flow}; use flow::{ok, Flow};
use std::{ use std::{
path::{Path, PathBuf},
sync::{ sync::{
mpsc::{channel, Receiver, RecvTimeoutError, Sender}, mpsc::{channel, Receiver, RecvTimeoutError, Sender},
Arc, Arc,
@ -14,18 +12,8 @@ use std::{
time::{Duration, Instant}, time::{Duration, Instant},
}; };
#[derive(Debug, Error)] fn scan_frequency() -> Duration {
pub enum ScannerError { Duration::from_secs(60)
#[error("Cannot scan {0}")]
CannotScan(PathBuf),
#[error("IO error {0}")]
IO(std::io::Error),
}
impl From<std::io::Error> for ScannerError {
fn from(err: std::io::Error) -> Self {
Self::IO(err)
}
} }
pub enum ControlMsg { pub enum ControlMsg {
@ -33,7 +21,8 @@ pub enum ControlMsg {
} }
pub enum TrackMsg { pub enum TrackMsg {
DbUpdate, UpdateInProgress,
UpdateComplete,
} }
pub enum PlaybackMsg { pub enum PlaybackMsg {
@ -45,129 +34,68 @@ pub enum PlaybackMsg {
pub struct Core { pub struct Core {
db: Arc<dyn MusicIndex>, db: Arc<dyn MusicIndex>,
track_handle: JoinHandle<()>, _track_handle: JoinHandle<()>,
track_rx: Receiver<TrackMsg>, _track_rx: Receiver<TrackMsg>,
playback_handle: JoinHandle<()>, _playback_handle: JoinHandle<()>,
playback_rx: Receiver<PlaybackMsg>, _playback_rx: Receiver<PlaybackMsg>,
control_tx: Sender<ControlMsg>, control_tx: Sender<ControlMsg>,
} }
fn scan_frequency() -> Duration { impl Core {
Duration::from_secs(60) pub fn new(
}
pub struct FileScanner {
db: Arc<dyn MusicIndex>, db: Arc<dyn MusicIndex>,
control_rx: Receiver<ControlMsg>, scanner: impl MusicScanner + 'static,
tracker_tx: Sender<TrackMsg>, ) -> Flow<Core, FatalError, Error> {
next_scan: Instant, let (control_tx, control_rx) = channel::<ControlMsg>();
music_directories: Vec<PathBuf>, let db = db;
}
impl FileScanner { let (_track_handle, _track_rx) = {
fn new( let (track_tx, track_rx) = channel();
db: Arc<dyn MusicIndex>, let db = db.clone();
roots: Vec<PathBuf>, let track_handle = thread::spawn(move || {
control_rx: Receiver<ControlMsg>, let mut next_scan = Instant::now();
tracker_tx: Sender<TrackMsg>,
) -> Self {
Self {
db,
control_rx,
tracker_tx,
next_scan: Instant::now(),
music_directories: roots,
}
}
fn scan(&mut self) {
loop { loop {
match self.control_rx.recv_timeout(Duration::from_millis(100)) { if Instant::now() >= next_scan {
let _ = track_tx.send(TrackMsg::UpdateInProgress);
for track in scanner.scan() {
match track {
Ok(track) => db.add_track(track),
Err(_) => ok(()),
};
}
let _ = track_tx.send(TrackMsg::UpdateComplete);
next_scan = Instant::now() + scan_frequency();
}
match control_rx.recv_timeout(Duration::from_millis(1000)) {
Ok(ControlMsg::Exit) => return, Ok(ControlMsg::Exit) => return,
Err(RecvTimeoutError::Timeout) => (), Err(RecvTimeoutError::Timeout) => (),
Err(RecvTimeoutError::Disconnected) => return, Err(RecvTimeoutError::Disconnected) => return,
} }
if Instant::now() >= self.next_scan {
for root in self.music_directories.iter() {
self.scan_dir(vec![root.clone()]);
} }
self.next_scan = Instant::now() + scan_frequency();
}
}
}
fn scan_dir(&self, mut paths: Vec<PathBuf>) -> Flow<(), FatalError, ScannerError> {
while let Some(dir) = paths.pop() {
println!("scanning {:?}", dir);
return_error!(self.scan_dir_(&mut paths, dir));
}
ok(())
}
fn scan_dir_(
&self,
paths: &mut Vec<PathBuf>,
dir: PathBuf,
) -> Flow<(), FatalError, ScannerError> {
let dir_iter = return_error!(Flow::from(dir.read_dir().map_err(ScannerError::from)));
for entry in dir_iter {
match entry {
Ok(entry) if entry.path().is_dir() => paths.push(entry.path()),
Ok(entry) => {
let _ = return_fatal!(self.scan_file(entry.path()).or_else(|err| {
println!("scan_file failed: {:?}", err);
ok::<(), FatalError, ScannerError>(())
}));
()
}
Err(err) => {
println!("scan_dir could not read path: ({:?})", err);
}
}
}
ok(())
}
fn scan_file(&self, path: PathBuf) -> Flow<(), FatalError, ScannerError> {
ok(())
}
}
impl Core {
pub fn new(db: Arc<dyn MusicIndex>) -> Flow<Core, FatalError, Error> {
let (control_tx, control_rx) = channel::<ControlMsg>();
let (track_handle, track_rx) = {
let (track_tx, track_rx) = channel();
let db = db.clone();
let track_handle = thread::spawn(move || {
FileScanner::new(
db,
vec![PathBuf::from("/home/savanni/Music/")],
control_rx,
track_tx,
)
.scan();
}); });
(track_handle, track_rx) (track_handle, track_rx)
}; };
let (playback_handle, playback_rx) = { let (_playback_handle, _playback_rx) = {
let (playback_tx, playback_rx) = channel(); let (_playback_tx, playback_rx) = channel();
let playback_handle = thread::spawn(move || {}); let playback_handle = thread::spawn(move || {});
(playback_handle, playback_rx) (playback_handle, playback_rx)
}; };
ok(Core { ok(Core {
db, db,
track_handle, _track_handle,
track_rx, _track_rx,
playback_handle, _playback_handle,
playback_rx, _playback_rx,
control_tx, control_tx,
}) })
} }
pub fn list_tracks<'a>(&'a self) -> Flow<Vec<TrackInfo>, FatalError, Error> {
self.db.list_tracks().map_err(Error::DatabaseError)
}
pub fn exit(&self) { pub fn exit(&self) {
let _ = self.control_tx.send(ControlMsg::Exit); let _ = self.control_tx.send(ControlMsg::Exit);
/* /*
@ -178,4 +106,49 @@ impl Core {
} }
#[cfg(test)] #[cfg(test)]
mod test {} mod test {
use super::*;
use crate::{audio::TrackId, database::MemoryIndex, music_scanner::factories::MockScanner};
use std::collections::HashSet;
fn with_example_index<F>(f: F)
where
F: Fn(Core),
{
let index = MemoryIndex::new();
let scanner = MockScanner::new();
match Core::new(Arc::new(index), scanner) {
Flow::Ok(core) => {
thread::sleep(Duration::from_millis(10));
f(core)
}
Flow::Err(error) => panic!("{:?}", error),
Flow::Fatal(error) => panic!("{:?}", error),
}
}
#[test]
fn it_lists_tracks() {
with_example_index(|core| match core.list_tracks() {
Flow::Ok(tracks) => {
let track_ids = tracks
.iter()
.map(|t| t.id.clone())
.collect::<HashSet<TrackId>>();
assert_eq!(track_ids.len(), 5);
assert_eq!(
track_ids,
HashSet::from([
TrackId::from("/home/savanni/Track 1.mp3".to_owned()),
TrackId::from("/home/savanni/Track 2.mp3".to_owned()),
TrackId::from("/home/savanni/Track 3.mp3".to_owned()),
TrackId::from("/home/savanni/Track 4.mp3".to_owned()),
TrackId::from("/home/savanni/Track 5.mp3".to_owned()),
])
);
}
Flow::Fatal(err) => panic!("fatal error: {:?}", err),
Flow::Err(err) => panic!("error: {:?}", err),
})
}
}

View File

@ -1,5 +1,5 @@
use crate::{ use crate::{
audio::{Track, TrackId, TrackInfo}, audio::{TrackId, TrackInfo},
FatalError, FatalError,
}; };
use flow::{error, ok, Flow}; use flow::{error, ok, Flow};
@ -11,7 +11,7 @@ use std::{
}; };
use thiserror::Error; use thiserror::Error;
#[derive(Debug, Error)] #[derive(Debug, Error, PartialEq)]
pub enum DatabaseError { pub enum DatabaseError {
#[error("database is unreadable")] #[error("database is unreadable")]
DatabaseUnreadable, DatabaseUnreadable,
@ -20,13 +20,14 @@ pub enum DatabaseError {
} }
pub trait MusicIndex: Sync + Send { pub trait MusicIndex: Sync + Send {
fn add_track(&mut self, track: &TrackInfo) -> Flow<Track, FatalError, DatabaseError>; fn add_track(&self, track: TrackInfo) -> Flow<(), FatalError, DatabaseError>;
fn remove_track(&mut self, id: &TrackId) -> Flow<(), FatalError, DatabaseError>; fn remove_track(&self, id: &TrackId) -> Flow<(), FatalError, DatabaseError>;
fn get_track_info(&self, id: &TrackId) -> Flow<Option<Track>, FatalError, DatabaseError>; fn get_track_info(&self, id: &TrackId) -> Flow<Option<TrackInfo>, FatalError, DatabaseError>;
fn list_tracks<'a>(&'a self) -> Flow<Vec<TrackInfo>, FatalError, DatabaseError>;
} }
pub struct MemoryIndex { pub struct MemoryIndex {
tracks: RwLock<HashMap<TrackId, Track>>, tracks: RwLock<HashMap<TrackId, TrackInfo>>,
} }
impl MemoryIndex { impl MemoryIndex {
@ -38,21 +39,13 @@ impl MemoryIndex {
} }
impl MusicIndex for MemoryIndex { impl MusicIndex for MemoryIndex {
fn add_track(&mut self, info: &TrackInfo) -> Flow<Track, FatalError, DatabaseError> { fn add_track(&self, info: TrackInfo) -> Flow<(), FatalError, DatabaseError> {
let id = TrackId::default();
let track = Track {
id: id.clone(),
track_number: info.track_number,
name: info.name.clone(),
album: info.album.clone(),
artist: info.artist.clone(),
};
let mut tracks = self.tracks.write().unwrap(); let mut tracks = self.tracks.write().unwrap();
tracks.insert(id, track.clone()); tracks.insert(info.id.clone(), info);
ok(track) ok(())
} }
fn remove_track(&mut self, id: &TrackId) -> Flow<(), FatalError, DatabaseError> { fn remove_track(&self, id: &TrackId) -> Flow<(), FatalError, DatabaseError> {
let mut tracks = self.tracks.write().unwrap(); let mut tracks = self.tracks.write().unwrap();
tracks.remove(&id); tracks.remove(&id);
ok(()) ok(())
@ -61,13 +54,23 @@ impl MusicIndex for MemoryIndex {
fn get_track_info<'a>( fn get_track_info<'a>(
&'a self, &'a self,
id: &TrackId, id: &TrackId,
) -> Flow<Option<Track>, FatalError, DatabaseError> { ) -> Flow<Option<TrackInfo>, FatalError, DatabaseError> {
let track = { let track = {
let tracks = self.tracks.read().unwrap(); let tracks = self.tracks.read().unwrap();
tracks.get(&id).cloned() tracks.get(&id).cloned()
}; };
ok(track) ok(track)
} }
fn list_tracks<'a>(&'a self) -> Flow<Vec<TrackInfo>, FatalError, DatabaseError> {
ok(self
.tracks
.read()
.unwrap()
.values()
.cloned()
.collect::<Vec<TrackInfo>>())
}
} }
pub struct ManagedConnection<'a> { pub struct ManagedConnection<'a> {
@ -104,3 +107,35 @@ impl Database {
pool.push(conn); pool.push(conn);
} }
} }
#[cfg(test)]
mod test {
use super::*;
fn with_memory_index<F>(f: F)
where
F: Fn(&dyn MusicIndex),
{
let index = MemoryIndex::new();
f(&index)
}
#[test]
fn it_saves_and_loads_data() {
with_memory_index(|index| {
let info = TrackInfo {
id: TrackId::from("track_1".to_owned()),
track_number: None,
name: None,
album: None,
artist: None,
};
index.add_track(info.clone());
assert_eq!(
Flow::Ok(Some(info)),
index.get_track_info(&TrackId::from("track_1".to_owned()))
);
});
}
}

View File

@ -1,10 +1,11 @@
pub mod audio; pub mod audio;
pub mod core; pub mod core;
pub mod database; pub mod database;
pub mod music_scanner;
use database::DatabaseError; use database::DatabaseError;
use thiserror::Error; use thiserror::Error;
#[derive(Debug, Error)] #[derive(Debug, Error, PartialEq)]
pub enum Error { pub enum Error {
#[error("Database error: {0}")] #[error("Database error: {0}")]
DatabaseError(DatabaseError), DatabaseError(DatabaseError),
@ -16,7 +17,7 @@ impl From<DatabaseError> for Error {
} }
} }
#[derive(Debug, Error)] #[derive(Debug, Error, PartialEq)]
pub enum FatalError { pub enum FatalError {
#[error("Unexpected error")] #[error("Unexpected error")]
UnexpectedError, UnexpectedError,

View File

@ -0,0 +1,179 @@
use crate::audio::{TrackId, TrackInfo};
use std::{
fs::{DirEntry, ReadDir},
path::PathBuf,
};
use thiserror::Error;
#[derive(Debug, Error)]
pub enum ScannerError {
#[error("Cannot scan {0}")]
CannotScan(PathBuf),
#[error("Not found {0}")]
NotFound(PathBuf),
#[error("IO error {0}")]
IO(std::io::Error),
}
impl From<std::io::Error> for ScannerError {
fn from(err: std::io::Error) -> Self {
Self::IO(err)
}
}
pub trait MusicScanner: Send {
fn scan<'a>(&'a self) -> Box<dyn Iterator<Item = Result<TrackInfo, ScannerError>> + 'a>;
}
pub struct FileScanner {
roots: Vec<PathBuf>,
}
impl FileScanner {
pub fn new(roots: Vec<PathBuf>) -> Self {
Self { roots }
}
}
pub struct FileIterator {
dirs: Vec<PathBuf>,
file_iter: Option<ReadDir>,
}
impl FileIterator {
fn scan_file(&self, path: PathBuf) -> Result<TrackInfo, ScannerError> {
Ok(TrackInfo {
id: TrackId::from(path.to_str().unwrap().to_owned()),
album: None,
artist: None,
name: None,
track_number: None,
})
}
}
enum EntryInfo {
Dir(PathBuf),
File(PathBuf),
}
impl Iterator for FileIterator {
type Item = Result<TrackInfo, ScannerError>;
fn next(&mut self) -> Option<Self::Item> {
fn process_entry(entry: DirEntry) -> Result<EntryInfo, ScannerError> {
entry
.metadata()
.map_err(ScannerError::from)
.map(|metadata| {
if metadata.is_dir() {
EntryInfo::Dir(entry.path())
} else {
EntryInfo::File(entry.path())
}
})
}
let next_file = match &mut self.file_iter {
Some(iter) => iter.next(),
None => None,
};
match next_file {
Some(Ok(entry)) => match process_entry(entry) {
Ok(EntryInfo::Dir(path)) => {
self.dirs.push(path);
self.next()
}
Ok(EntryInfo::File(path)) => Some(self.scan_file(path)),
Err(err) => Some(Err(err)),
},
Some(Err(err)) => Some(Err(ScannerError::from(err))),
None => match self.dirs.pop() {
Some(dir) => match dir.read_dir() {
Ok(entry) => {
self.file_iter = Some(entry);
self.next()
}
Err(err) => {
if err.kind() == std::io::ErrorKind::NotFound {
Some(Err(ScannerError::NotFound(dir)))
} else {
Some(Err(ScannerError::from(err)))
}
}
},
None => None,
},
}
}
}
impl MusicScanner for FileScanner {
fn scan<'a>(&'a self) -> Box<dyn Iterator<Item = Result<TrackInfo, ScannerError>> + 'a> {
Box::new(FileIterator {
dirs: self.roots.clone(),
file_iter: None,
})
}
}
#[cfg(test)]
pub mod factories {
use super::*;
use crate::audio::TrackId;
pub struct MockScanner {
data: Vec<TrackInfo>,
}
impl MockScanner {
pub fn new() -> Self {
Self {
data: vec![
TrackInfo {
id: TrackId::from("/home/savanni/Track 1.mp3".to_owned()),
track_number: Some(1),
name: Some("Track 1".to_owned()),
album: Some("Savanni's Demo".to_owned()),
artist: Some("Savanni".to_owned()),
},
TrackInfo {
id: TrackId::from("/home/savanni/Track 2.mp3".to_owned()),
track_number: Some(2),
name: Some("Track 2".to_owned()),
album: Some("Savanni's Demo".to_owned()),
artist: Some("Savanni".to_owned()),
},
TrackInfo {
id: TrackId::from("/home/savanni/Track 3.mp3".to_owned()),
track_number: Some(3),
name: Some("Track 3".to_owned()),
album: Some("Savanni's Demo".to_owned()),
artist: Some("Savanni".to_owned()),
},
TrackInfo {
id: TrackId::from("/home/savanni/Track 4.mp3".to_owned()),
track_number: Some(4),
name: Some("Track 4".to_owned()),
album: Some("Savanni's Demo".to_owned()),
artist: Some("Savanni".to_owned()),
},
TrackInfo {
id: TrackId::from("/home/savanni/Track 5.mp3".to_owned()),
track_number: Some(5),
name: Some("Track 5".to_owned()),
album: Some("Savanni's Demo".to_owned()),
artist: Some("Savanni".to_owned()),
},
],
}
}
}
impl MusicScanner for MockScanner {
fn scan<'a>(&'a self) -> Box<dyn Iterator<Item = Result<TrackInfo, ScannerError>> + 'a> {
Box::new(self.data.iter().map(|t| Ok(t.clone())))
}
}
}