music-player/Makefile

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

music-player/client/index.html

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

music-player/client/package.json

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

music-player/client/src/main.ts

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

music-player/client/styles.css

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

music-player/client/tsconfig.json

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

music-player/server/src/bin/server.rs

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

music-player/server/src/core.rs

@@ -47,21 +47,19 @@ impl Core {
         scanner: impl MusicScanner + 'static,
     ) -> Flow<Core, FatalError, Error> {
         let (control_tx, control_rx) = channel::<ControlMsg>();
-        let db = db;
 
         let (_track_handle, _track_rx) = {
             let (track_tx, track_rx) = channel();
             let db = db.clone();
             let track_handle = thread::spawn(move || {
+                println!("tracker thread started");
                 let mut next_scan = Instant::now();
                 loop {
                     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(()),
-                            };
+                            println!("scanning {:?}", track);
+                            db.add_track(track);
                         }
                         let _ = track_tx.send(TrackMsg::UpdateComplete);
                         next_scan = Instant::now() + scan_frequency();

music-player/server/src/music_scanner.rs

@@ -1,11 +1,11 @@
 use crate::{
-    audio::{TrackId, TrackInfo},
+    audio::TrackInfo,
     core::{ControlMsg, TrackMsg},
     database::MusicIndex,
     FatalError,
 };
+use flow::{ok, return_error, return_fatal, Flow};
 use std::{
-    fs::{DirEntry, ReadDir},
     path::PathBuf,
     sync::{
         mpsc::{Receiver, RecvTimeoutError, Sender},
@@ -19,8 +19,6 @@ use thiserror::Error;
 pub enum ScannerError {
     #[error("Cannot scan {0}")]
     CannotScan(PathBuf),
-    #[error("Not found {0}")]
-    NotFound(PathBuf),
     #[error("IO error {0}")]
     IO(std::io::Error),
 }
@@ -32,101 +30,83 @@ impl From<std::io::Error> for ScannerError {
 }
 
 pub trait MusicScanner: Send {
-    fn scan<'a>(&'a self) -> Box<dyn Iterator<Item = Result<TrackInfo, ScannerError>> + 'a>;
+    fn scan<'a>(&'a self) -> Box<dyn Iterator<Item = TrackInfo> + 'a>;
 }
 
+/*
 pub struct FileScanner {
-    roots: Vec<PathBuf>,
+    db: Arc<dyn MusicIndex>,
+    tracker_tx: Sender<TrackMsg>,
+    music_directories: Vec<PathBuf>,
 }
 
 impl FileScanner {
-    pub fn new(roots: Vec<PathBuf>) -> Self {
-        Self { roots }
+    fn new(db: Arc<dyn MusicIndex>, roots: Vec<PathBuf>, tracker_tx: Sender<TrackMsg>) -> Self {
+        Self {
+            db,
+            tracker_tx,
+            music_directories: roots,
         }
     }
 
-pub struct FileIterator {
-    dirs: Vec<PathBuf>,
-    file_iter: Option<ReadDir>,
+    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(())
     }
 
-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() {
+    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) => {
-                        self.file_iter = Some(entry);
-                        self.next()
+                    let _ = return_fatal!(self.scan_file(entry.path()).or_else(|err| {
+                        println!("scan_file failed: {:?}", err);
+                        ok::<(), FatalError, ScannerError>(())
+                    }));
+                    ()
                 }
                 Err(err) => {
-                        if err.kind() == std::io::ErrorKind::NotFound {
-                            Some(Err(ScannerError::NotFound(dir)))
-                        } else {
-                            Some(Err(ScannerError::from(err)))
+                    println!("scan_dir could not read path: ({:?})", err);
                 }
             }
-                },
-                None => None,
-            },
         }
+        ok(())
+    }
+
+    fn scan_file(&self, path: PathBuf) -> Flow<(), FatalError, ScannerError> {
+        ok(())
     }
 }
 
 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,
-        })
+    fn scan<'a>(&'a self) -> Box<&'a dyn Iterator<Item = TrackInfo>> {
+        unimplemented!()
+        /*
+        loop {
+            match self.control_rx.recv_timeout(Duration::from_millis(100)) {
+                Ok(ControlMsg::Exit) => return,
+                Err(RecvTimeoutError::Timeout) => (),
+                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();
             }
         }
+        */
+    }
+}
+*/
 
 #[cfg(test)]
 pub mod factories {
@@ -182,8 +162,8 @@ pub mod factories {
     }
 
     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())))
+        fn scan<'a>(&'a self) -> Box<dyn Iterator<Item = TrackInfo> + 'a> {
+            Box::new(self.data.iter().map(|t| t.clone()))
         }
     }
 }