Added sample docker env file

.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

@@ -10,14 +10,14 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
         with:
           fetch-depth: 0 # Important for git describe --tags
 
       - name: Install Rust
         uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.97
+          toolchain: 1.95
           components: cargo
 
       - name: Extract Version from Cargo.toml

.gitea/workflows/workflow.yml

@@ -1,27 +1,24 @@
-name: songparser
+name: Rust Build
 
 on:
   push:
     branches:
       - main 
+      - devel
   pull_request:
     branches:
       - main 
-
+      - devel
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
 
 jobs:
   check:
     name: Check
     runs-on: ubuntu-24.04
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: 1.97
+          toolchain: 1.95
-      - uses: Swatinem/rust-cache@v2
       - run: |
           mkdir -p ~/.ssh
           echo "${{ secrets.MYREPO_TOKEN }}" > ~/.ssh/gitlab_deploy_key
@@ -31,16 +28,33 @@ 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@v5
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: 1.95
+      - 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
     needs: setup_ssh
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: 1.97
+          toolchain: 1.95
-      - uses: Swatinem/rust-cache@v2
       - run: rustup component add rustfmt
       - run: |
           mkdir -p ~/.ssh
@@ -56,11 +70,10 @@ jobs:
     runs-on: ubuntu-24.04
     needs: setup_ssh
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: 1.97
+          toolchain: 1.95
-      - uses: Swatinem/rust-cache@v2
       - run: rustup component add clippy
       - run: |
           mkdir -p ~/.ssh
@@ -76,11 +89,10 @@ jobs:
     runs-on: ubuntu-24.04
     needs: setup_ssh
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: 1.97
+          toolchain: 1.95
-      - uses: Swatinem/rust-cache@v2
       - run: |
           mkdir -p ~/.ssh
           echo "${{ secrets.MYREPO_TOKEN }}" > ~/.ssh/gitlab_deploy_key

Cargo.toml

@@ -1,20 +1,18 @@
 [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.2", features = ["full"] }
-futures = { version = "0.3.34" }
+futures = { version = "0.3.32" }
-reqwest = { version = "0.13.4", features = ["json", "stream", "multipart"] }
+reqwest = { version = "0.13.3", 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.149" }
-serde_json = { version = "1.0.151" }
+time = { version = "0.3.47", features = ["macros", "serde"] }
-time = { version = "0.3.55", features = ["macros", "serde"] }
+uuid = { version = "1.23.1", features = ["v4", "serde"] }
-uuid = { version = "1.24.1", features = ["v4", "serde"] }
+rand = { version = "0.10.1" }
-simeta = { git = "ssh://git@git.kundeng.us/phoenix/simeta.git", tag = "v0.6.2" }
+icarus_meta = { git = "ssh://git@git.kundeng.us/phoenix/icarus_meta.git", tag = "v0.6.0" }
-simodels = { git = "ssh://git@git.kundeng.us/phoenix/simodels.git", tag = "v0.11.4" }
+icarus_models = { git = "ssh://git@git.kundeng.us/phoenix/icarus_models.git", tag = "v0.11.1" }
-sienvy = { git = "ssh://git@git.kundeng.us/phoenix/sienvy.git", tag = "v0.8.1" }
+icarus_envy = { git = "ssh://git@git.kundeng.us/phoenix/icarus_envy.git", tag = "v0.7.0" }

Dockerfile

@@ -1,37 +1,63 @@
-FROM rust:1.97 as builder
+# Stage 1: Build the application
+# Use a specific Rust version for reproducibility. Choose one that matches your development environment.
+# Using slim variant for smaller base image
+FROM rust:1.95 as builder
 
+# Set the working directory inside the container
 WORKDIR /usr/src/app
 
+# Install build dependencies if needed (e.g., git for cloning)
 RUN apt-get update && apt-get install -y --no-install-recommends \
     pkg-config libssl3 \
     ca-certificates \
     openssh-client git \
     && rm -rf /var/lib/apt/lists/*
 
+# << --- ADD HOST KEY HERE --- >>
+# Replace 'yourgithost.com' with the actual hostname (e.g., github.com)
 RUN mkdir -p -m 0700 ~/.ssh && \
     ssh-keyscan git.kundeng.us >> ~/.ssh/known_hosts
 
+# Copy Cargo manifests
 COPY Cargo.toml Cargo.lock ./
 
+# Build *only* dependencies to leverage Docker cache
+# This dummy build caches dependencies as a separate layer
 RUN --mount=type=ssh mkdir src && \
     echo "fn main() {println!(\"if you see this, the build broke\")}" > src/main.rs && \
     cargo build --release --quiet && \
-    rm -rf src target/release/deps/songparser*
+    rm -rf src target/release/deps/songparser* # Clean up dummy build artifacts (replace songparser)
 
+# Copy the actual source code
 COPY src ./src
+# If you have other directories like `templates` or `static`, copy them too
 COPY .env ./.env
 
+# << --- SSH MOUNT ADDED HERE --- >>
+# Build *only* dependencies to leverage Docker cache
+# This dummy build caches dependencies as a separate layer
+# Mount the SSH agent socket for this command
 RUN --mount=type=ssh \
     cargo build --release --quiet
 
-FROM debian:trixie-slim
+# Stage 2: Create the final, smaller runtime image
+# Use a minimal base image like debian-slim or even distroless for security/size
+FROM ubuntu:24.04
 
+# Install runtime dependencies if needed (e.g., SSL certificates)
 RUN apt-get update && apt-get install -y ca-certificates libssl-dev libssl3 && rm -rf /var/lib/apt/lists/*
 
+# Set the working directory
 WORKDIR /usr/local/bin
 
+# Copy the compiled binary from the builder stage
+# Replace 'songparser' with the actual name of your binary (usually the crate name)
 COPY --from=builder /usr/src/app/target/release/songparser .
 
+# Copy other necessary files like .env (if used for runtime config) or static assets
+# It's generally better to configure via environment variables in Docker though
 COPY --from=builder /usr/src/app/.env .
 
+# Set the command to run your application
+# Ensure this matches the binary name copied above
 CMD ["./songparser"]

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.

docker-compose.yaml

@@ -1,11 +1,12 @@
 version: '3.8' # Use a recent version
 
 services:
+  # Your Rust Application Service
   songparser:
-    build:
+    build: # Tells docker-compose to build the Dockerfile in the current directory
       context: .
-      ssh: ["default"]
+      ssh: ["default"]  # Uses host's SSH agent
-    container_name: songparser
+    container_name: songparser # Optional: Give the container a specific name
     env_file:
       - .env
-    restart: unless-stopped
+    restart: unless-stopped # Optional: Restart policy

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().await.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,13 @@ 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()
-        auth_uri: sienvy::environment::get_soaricarus_auth_base_api_url().value,
+            .await
-        root_directory: sienvy::environment::get_root_directory().value,
+            .value,
+        auth_uri: icarus_envy::environment::get_icarus_auth_base_api_url()
+            .await
+            .value,
+        root_directory: icarus_envy::environment::get_root_directory().await.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().await.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().await.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,
 }