bump: icarus_envy

.env.docker.sample

@@ -1,4 +1,4 @@
 ROOT_DIRECTORY=/usr/local/bin
-SOARICARUS_BASE_API_URL=http://api:8000
+ICARUS_BASE_API_URL=http://api:8000
-SOARICARUS_AUTH_BASE_API_URL=http://auth_api:8001
+ICARUS_AUTH_BASE_API_URL=http://auth_api:8001
 SERVICE_PASSPHRASE=iUOo1fxshf3y1tUGn1yU8l9raPApHCdinW0VdCHdRFEjqhR3Bf02aZzsKbLtaDFH

.env.local.sample

@@ -1,4 +1,4 @@
 ROOT_DIRECTORY=/tmp
-SOARICARUS_BASE_API_URL=http://localhost:8000
+ICARUS_BASE_API_URL=http://localhost:8000
-SOARICARUS_AUTH_BASE_API_URL=http://localhost:8001
+ICARUS_AUTH_BASE_API_URL=http://localhost:8001
 SERVICE_PASSPHRASE=iUOo1fxshf3y1tUGn1yU8l9raPApHCdinW0VdCHdRFEjqhR3Bf02aZzsKbLtaDFH

.env.sample

@@ -0,0 +1,4 @@
+ROOT_DIRECTORY=/home/songparser/mydata
+ICARUS_BASE_API_URL=http://localhost:3000
+ICARUS_AUTH_BASE_API_URL=http://localhost:3001
+SERVICE_PASSPHRASE=iUOo1fxshf3y1tUGn1yU8l9raPApHCdinW0VdCHdRFEjqhR3Bf02aZzsKbLtaDFH

.gitea/workflows/tag_release.yml

@@ -17,7 +17,7 @@ jobs:
       - name: Install Rust
         uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.97
+          toolchain: 1.96.1
           components: cargo
 
       - name: Extract Version from Cargo.toml

.gitea/workflows/workflow.yml

@@ -20,7 +20,7 @@ jobs:
       - uses: actions/checkout@v6
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: 1.97
+          toolchain: 1.96.1
       - uses: Swatinem/rust-cache@v2
       - run: |
           mkdir -p ~/.ssh
@@ -31,6 +31,25 @@ jobs:
           ssh-add -v ~/.ssh/gitlab_deploy_key
           cargo check
 
+  test:
+    name: Test Suite
+    runs-on: ubuntu-24.04
+    needs: setup_ssh
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: 1.96.1
+      - uses: Swatinem/rust-cache@v2
+      - run: |
+          mkdir -p ~/.ssh
+          echo "${{ secrets.MYREPO_TOKEN }}" > ~/.ssh/gitlab_deploy_key
+          chmod 600 ~/.ssh/gitlab_deploy_key
+          ssh-keyscan ${{ vars.MYHOST }} >> ~/.ssh/known_hosts
+          eval $(ssh-agent -s)
+          ssh-add -v ~/.ssh/gitlab_deploy_key
+          cargo test
+
   fmt:
     name: Rustfmt
     runs-on: ubuntu-24.04
@@ -39,7 +58,7 @@ jobs:
       - uses: actions/checkout@v6
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: 1.97
+          toolchain: 1.96.1
       - uses: Swatinem/rust-cache@v2
       - run: rustup component add rustfmt
       - run: |
@@ -59,7 +78,7 @@ jobs:
       - uses: actions/checkout@v6
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: 1.97
+          toolchain: 1.96.1
       - uses: Swatinem/rust-cache@v2
       - run: rustup component add clippy
       - run: |
@@ -79,7 +98,7 @@ jobs:
       - uses: actions/checkout@v6
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: 1.97
+          toolchain: 1.96.1
       - uses: Swatinem/rust-cache@v2
       - run: |
           mkdir -p ~/.ssh

Cargo.toml

@@ -1,20 +1,17 @@
 [package]
 name = "songparser"
-version = "0.6.2"
+version = "0.6.0"
 edition = "2024"
 rust-version = "1.95"
-license = "MIT"
-description = "Service to parse songs queued for processing"
 
 [dependencies]
-tokio = { version = "1.53.1", features = ["full"] }
+tokio = { version = "1.52.3", features = ["full"] }
-futures = { version = "0.3.34" }
+futures = { version = "0.3.32" }
 reqwest = { version = "0.13.4", features = ["json", "stream", "multipart"] }
-openssl = { version = "0.10.81", features = ["vendored"] }
+serde = { version = "1.0.228", features = ["derive"] }
-serde = { version = "1.0.229", features = ["derive"] }
+serde_json = { version = "1.0.150" }
-serde_json = { version = "1.0.151" }
+time = { version = "0.3.53", features = ["macros", "serde"] }
-time = { version = "0.3.55", features = ["macros", "serde"] }
+uuid = { version = "1.23.4", features = ["v4", "serde"] }
-uuid = { version = "1.24.1", features = ["v4", "serde"] }
+icarus_meta = { git = "ssh://git@git.kundeng.us/phoenix/icarus_meta.git", tag = "v0.6.1" }
-simeta = { git = "ssh://git@git.kundeng.us/phoenix/simeta.git", tag = "v0.6.2" }
+icarus_models = { git = "ssh://git@git.kundeng.us/phoenix/icarus_models.git", tag = "v0.11.3" }
-simodels = { git = "ssh://git@git.kundeng.us/phoenix/simodels.git", tag = "v0.11.4" }
+icarus_envy = { git = "ssh://git@git.kundeng.us/phoenix/icarus_envy.git", tag = "v0.8.0" }
-sienvy = { git = "ssh://git@git.kundeng.us/phoenix/sienvy.git", tag = "v0.8.1" }

Dockerfile

@@ -1,4 +1,4 @@
-FROM rust:1.97 as builder
+FROM rust:1.96.1 as builder
 
 WORKDIR /usr/src/app
 

LICENSE.md

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Kun Deng
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

README.md

@@ -1,4 +1,4 @@
-# songparser
+# Songparser
 A service that edits the metadata of a queued song and populates it with data.
 
 
@@ -11,10 +11,10 @@ it can be changed.
 
 The `SERVICE_PASSPHRASE` env variable should not be changed, but it could be changed. The 
 value for this variable should match the value in the `passphrase` table. This would be
-found in the `soaricarus_auth` project.
+found in the `icarus_auth` project.
 
 Ensure that the URLs for the two APIs are correctly set for the respective env variables
-`SOARICARUS_BASE_API_URL` for soaricarus API and `SOARICARUS_AUTH_BASE_API_URL` for `soaricarus_auth`.
+`ICARUS_BASE_API_URL` for Icarus API and `ICARUS_AUTH_BASE_API_URL` for `icarus_auth`.
 
 If the values are properly set, next is to build the image. The docker image should be
 built from the main icarus web API.

src/api.rs

@@ -162,7 +162,7 @@ pub mod service_token {
         #[derive(Debug, serde::Deserialize, serde::Serialize)]
         pub struct Response {
             pub message: String,
-            pub data: Vec<simodels::login_result::LoginResult>,
+            pub data: Vec<icarus_models::login_result::LoginResult>,
         }
     }
 }
@@ -172,7 +172,7 @@ pub mod refresh_token {
         #[derive(Debug, serde::Deserialize, serde::Serialize)]
         pub struct Response {
             pub message: String,
-            pub data: Vec<simodels::login_result::LoginResult>,
+            pub data: Vec<icarus_models::login_result::LoginResult>,
         }
     }
 }
@@ -253,7 +253,7 @@ pub mod create_song {
         #[derive(Debug, serde::Deserialize, serde::Serialize)]
         pub struct Response {
             pub message: String,
-            pub data: Vec<simodels::song::Song>,
+            pub data: Vec<icarus_models::song::Song>,
         }
     }
 }
@@ -261,7 +261,7 @@ pub mod create_song {
 pub mod create_coverart {
     pub async fn create(
         app: &crate::config::App,
-        song: &simodels::song::Song,
+        song: &icarus_models::song::Song,
         queued_coverart: &crate::queued_item::QueuedCoverArt,
     ) -> Result<reqwest::Response, reqwest::Error> {
         let client = reqwest::Client::builder().build()?;
@@ -284,7 +284,7 @@ pub mod create_coverart {
         #[derive(Debug, serde::Deserialize, serde::Serialize)]
         pub struct Response {
             pub message: String,
-            pub data: Vec<simodels::coverart::CoverArt>,
+            pub data: Vec<icarus_models::coverart::CoverArt>,
         }
     }
 }

src/auth/mod.rs

@@ -1,12 +1,12 @@
 pub async fn get_token(
     app: &crate::config::App,
-) -> Result<simodels::login_result::LoginResult, std::io::Error> {
+) -> Result<icarus_models::login_result::LoginResult, std::io::Error> {
     let client = reqwest::Client::new();
     let endpoint = String::from("api/v2/service/login");
     let api_url = format!("{}/{endpoint}", app.auth_uri);
 
     let payload = serde_json::json!({
-        "passphrase": sienvy::environment::get_service_passphrase().value,
+        "passphrase": icarus_envy::environment::get_service_passphrase().value,
     });
 
     match client.post(api_url).json(&payload).send().await {
@@ -29,7 +29,7 @@ pub async fn get_token(
 
 pub async fn get_refresh_token(
     app: &crate::config::App,
-) -> Result<simodels::login_result::LoginResult, std::io::Error> {
+) -> Result<icarus_models::login_result::LoginResult, std::io::Error> {
     let client = reqwest::Client::new();
     let endpoint = String::from("api/v2/token/refresh");
     let api_url = format!("{}/{endpoint}", app.auth_uri);

src/config.rs

@@ -2,7 +2,7 @@
 pub struct App {
     pub uri: String,
     pub auth_uri: String,
-    pub token: simodels::login_result::LoginResult,
+    pub token: icarus_models::login_result::LoginResult,
     pub root_directory: String,
 }
 
@@ -15,9 +15,9 @@ impl App {
 
 pub async fn initialize_app_config() -> App {
     App {
-        uri: sienvy::environment::get_soaricarus_base_api_url().value,
+        uri: icarus_envy::environment::get_icarus_base_api_url().value,
-        auth_uri: sienvy::environment::get_soaricarus_auth_base_api_url().value,
+        auth_uri: icarus_envy::environment::get_icarus_auth_base_api_url().value,
-        root_directory: sienvy::environment::get_root_directory().value,
+        root_directory: icarus_envy::environment::get_root_directory().value,
         ..Default::default()
     }
 }

src/metadata/mod.rs

@@ -5,96 +5,101 @@ pub async fn apply_metadata(
     metadata: &crate::api::get_metadata_queue::response::Metadata,
 ) -> Result<bool, std::io::Error> {
     // Apply metadata fields
-    let types = simeta::types::all_metadata_types();
+    let types = icarus_meta::types::all_metadata_types();
 
     for t in types {
         match t {
-            simeta::types::Type::Album => {
+            icarus_meta::types::Type::Album => {
-                let meta_type = simeta::types::MetadataType::from_string(metadata.album.clone());
-                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
-                    Ok(_) => {}
-                    Err(_err) => {
-                        return Err(_err);
-                    }
-                }
-            }
-            simeta::types::Type::AlbumArtist => {
                 let meta_type =
-                    simeta::types::MetadataType::from_string(metadata.album_artist.clone());
+                    icarus_meta::types::MetadataType::from_string(metadata.album.clone());
-                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            simeta::types::Type::Artist => {
+            icarus_meta::types::Type::AlbumArtist => {
-                let meta_type = simeta::types::MetadataType::from_string(metadata.artist.clone());
+                let meta_type =
-                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+                    icarus_meta::types::MetadataType::from_string(metadata.album_artist.clone());
+                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            simeta::types::Type::Date => {
+            icarus_meta::types::Type::Artist => {
+                let meta_type =
+                    icarus_meta::types::MetadataType::from_string(metadata.artist.clone());
+                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+                    Ok(_) => {}
+                    Err(_err) => {
+                        return Err(_err);
+                    }
+                }
+            }
+            icarus_meta::types::Type::Date => {
                 // TODO: Do something about this discrepancy
-                let meta_type = simeta::types::MetadataType::from_string(metadata.year.to_string());
+                let meta_type =
-                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+                    icarus_meta::types::MetadataType::from_string(metadata.year.to_string());
+                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            simeta::types::Type::Disc => {
+            icarus_meta::types::Type::Disc => {
-                let meta_type = simeta::types::MetadataType::from_int(metadata.disc);
+                let meta_type = icarus_meta::types::MetadataType::from_int(metadata.disc);
-                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            simeta::types::Type::Genre => {
+            icarus_meta::types::Type::Genre => {
-                let meta_type = simeta::types::MetadataType::from_string(metadata.genre.clone());
+                let meta_type =
-                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+                    icarus_meta::types::MetadataType::from_string(metadata.genre.clone());
+                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            simeta::types::Type::Title => {
+            icarus_meta::types::Type::Title => {
-                let meta_type = simeta::types::MetadataType::from_string(metadata.title.clone());
+                let meta_type =
-                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+                    icarus_meta::types::MetadataType::from_string(metadata.title.clone());
+                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            simeta::types::Type::Track => {
+            icarus_meta::types::Type::Track => {
-                let meta_type = simeta::types::MetadataType::from_int(metadata.track);
+                let meta_type = icarus_meta::types::MetadataType::from_int(metadata.track);
-                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            simeta::types::Type::TrackCount => {
+            icarus_meta::types::Type::TrackCount => {
-                let meta_type = simeta::types::MetadataType::from_int(metadata.track_count);
+                let meta_type = icarus_meta::types::MetadataType::from_int(metadata.track_count);
-                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            simeta::types::Type::DiscCount => {
+            icarus_meta::types::Type::DiscCount => {
-                let meta_type = simeta::types::MetadataType::from_int(metadata.disc_count);
+                let meta_type = icarus_meta::types::MetadataType::from_int(metadata.disc_count);
-                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
@@ -105,11 +110,11 @@ pub async fn apply_metadata(
     }
 
     // Apply coverart
-    match simeta::meta::coverart::contains_coverart(&queued_song.path) {
+    match icarus_meta::meta::coverart::contains_coverart(&queued_song.path) {
         Ok((exists, size)) => {
             if exists {
                 println!("Coverart exists: {size:?} size");
-                match simeta::meta::coverart::remove_coverart(&queued_song.path) {
+                match icarus_meta::meta::coverart::remove_coverart(&queued_song.path) {
                     Ok(_data) => {}
                     Err(err) => {
                         return Err(err);
@@ -117,7 +122,10 @@ pub async fn apply_metadata(
                 }
             }
 
-            match simeta::meta::coverart::set_coverart(&queued_song.path, &queued_coverart.path) {
+            match icarus_meta::meta::coverart::set_coverart(
+                &queued_song.path,
+                &queued_coverart.path,
+            ) {
                 Ok(_data) => {
                     if _data.is_empty() {
                         println!("There was an issue");

src/parser/mod.rs

@@ -4,8 +4,8 @@ pub async fn some_work(
     user_id: &uuid::Uuid,
 ) -> Result<
     (
-        simodels::song::Song,
+        icarus_models::song::Song,
-        simodels::coverart::CoverArt,
+        icarus_models::coverart::CoverArt,
         crate::api::get_metadata_queue::response::Metadata,
         crate::queued_item::QueuedSong,
         crate::queued_item::QueuedCoverArt,
@@ -30,8 +30,9 @@ pub async fn some_work(
                                     println!("Updated queued song");
                                     println!("Response: {_inner_response:?}");
 
-                                    let song_type =
+                                    let song_type = String::from(
-                                        String::from(simeta::detection::song::constants::FLAC_TYPE);
+                                        icarus_meta::detection::song::constants::FLAC_TYPE,
+                                    );
 
                                     match crate::api::create_song::create(
                                         app, &metadata, user_id, &song_type,
@@ -103,10 +104,10 @@ pub async fn prep_song(
             // Process data here...
             match crate::api::parsing::parse_response_into_bytes(response).await {
                 Ok(song_bytes) => {
-                    let song = simodels::song::Song {
+                    let song = icarus_models::song::Song {
-                        directory: sienvy::environment::get_root_directory().value,
+                        directory: icarus_envy::environment::get_root_directory().value,
-                        filename: simodels::song::generate_filename(
+                        filename: icarus_models::song::generate_filename(
-                            simodels::types::MusicType::FlacExtension,
+                            icarus_models::types::MusicType::FlacExtension,
                             true,
                         )
                         .unwrap(),
@@ -222,18 +223,18 @@ async fn init_queued_coverart(
     bytes: Vec<u8>,
 ) -> crate::queued_item::QueuedCoverArt {
     // TODO: Consider separating song and coverart when saving to the filesystem
-    let covart_type = if file_type == simeta::detection::coverart::constants::PNG_TYPE {
+    let covart_type = if file_type == icarus_meta::detection::coverart::constants::PNG_TYPE {
-        simodels::types::CoverArtType::PngExtension
+        icarus_models::types::CoverArtType::PngExtension
-    } else if file_type == simeta::detection::coverart::constants::JPEG_TYPE {
+    } else if file_type == icarus_meta::detection::coverart::constants::JPEG_TYPE {
-        simodels::types::CoverArtType::JpegExtension
+        icarus_models::types::CoverArtType::JpegExtension
-    } else if file_type == simeta::detection::coverart::constants::JPG_TYPE {
+    } else if file_type == icarus_meta::detection::coverart::constants::JPG_TYPE {
-        simodels::types::CoverArtType::JpgExtension
+        icarus_models::types::CoverArtType::JpgExtension
     } else {
-        simodels::types::CoverArtType::None
+        icarus_models::types::CoverArtType::None
     };
-    let coverart = simodels::coverart::CoverArt {
+    let coverart = icarus_models::coverart::CoverArt {
-        directory: sienvy::environment::get_root_directory().value,
+        directory: icarus_envy::environment::get_root_directory().value,
-        filename: match simodels::coverart::generate_filename(covart_type, true) {
+        filename: match icarus_models::coverart::generate_filename(covart_type, true) {
             Ok(filename) => filename,
             Err(err) => {
                 eprintln!("Error generating CoverArt filename: {err:?}");
@@ -254,8 +255,8 @@ async fn init_queued_coverart(
 }
 
 pub async fn cleanup(
-    song: &simodels::song::Song,
+    song: &icarus_models::song::Song,
-    coverart: &simodels::coverart::CoverArt,
+    coverart: &icarus_models::coverart::CoverArt,
 ) -> Result<(), std::io::Error> {
     match song.remove_from_filesystem() {
         Ok(_) => {}

src/queued_item.rs

@@ -1,13 +1,13 @@
 #[derive(Clone, Debug, Default)]
 pub struct QueuedSong {
     pub id: uuid::Uuid,
-    pub song: simodels::song::Song,
+    pub song: icarus_models::song::Song,
     pub path: String,
 }
 
 #[derive(Clone, Debug, Default)]
 pub struct QueuedCoverArt {
     pub id: uuid::Uuid,
-    pub coverart: simodels::coverart::CoverArt,
+    pub coverart: icarus_models::coverart::CoverArt,
     pub path: String,
 }