artifacts: implement musicbrainz tooling

src/artifacts/beets.rs

@@ -1,4 +1,4 @@
-use std::process::{Command, Stdio};
+use std::{collections::HashSet, process::{Command, Stdio}};
 
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -22,11 +22,17 @@ struct BeetsTrack {
     genres: Option<Vec<String>>,
     label: Option<String>,
     title: String,
-    year: u32
+    year: u32,
+    mb_trackid: Option<String>
 }
 
 impl Into<Artifact> for BeetsTrack {
     fn into(self) -> Artifact {
+        let sources = if let Some(mbid) = self.mb_trackid {
+            HashSet::from([SourceID::Beets, SourceID::Musicbrainz(mbid)])
+        } else {
+            HashSet::from([SourceID::Beets])
+        };
         Artifact::Track(Track {
             title: self.title,
             label: self.label,
@@ -35,7 +41,7 @@ impl Into<Artifact> for BeetsTrack {
             album: Some(self.album),
             artist: Some(self.artist),
             bpm: None,
-            sources: vec![SourceID::Beets]
+            sources
         })
     }
 }
@@ -43,25 +49,36 @@ impl Into<Artifact> for BeetsTrack {
 impl BeatsQueryArgs {
     pub fn execute(self) -> Result<Vec<Artifact>, ()> {
         let mut beets_cmd = Command::new("beet");
-        beets_cmd.args(["export", "-f", "json", "-i", "title,label,year,genres,album,artist"]);
+        beets_cmd.args(["export", "-f", "json", "-i", "title,label,year,genres,album,artist,mb_trackid"]);
+        let mut valid = false;
         if let Some(artist) = self.artist {
             beets_cmd.arg(format!("artist:{}", artist));
+            valid = true;
         }
         if let Some(genre) = self.genre {
             beets_cmd.arg(format!("genre:{}", genre));
+            valid = true;
         }
         if let Some(album) = self.album {
             beets_cmd.arg(format!("album:{}", album));
+            valid = true;
         }
         if let Some(title) = self.title {
             beets_cmd.arg(format!("title:{}", title));
+            valid = true;
         }
         if let Some(year) = self.year {
             beets_cmd.arg(format!("year:{}", year));
+            valid = true;
+        }
+
+        if !valid {
+            log::warn!("Tried to execute an empty beets query");
+            return Err(())
         }
 
         log::debug!("Executing beets: {:?}", beets_cmd);
-        if let Ok(output) = beets_cmd.stdout(Stdio::piped()).spawn().unwrap().wait_with_output() {
+        if let Ok(output) = beets_cmd.stdout(Stdio::piped()).stderr(Stdio::null()).spawn().unwrap().wait_with_output() {
             match serde_json::from_str::<Vec<BeetsTrack>>(str::from_utf8(&output.stdout).unwrap()) {
                 Ok(track) => Ok(track.into_iter().map(|t| { t.into()}).collect()),
                 Err(err) => {