refactor: into rust workspaces

src-tauri/drop-errors/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "drop-errors"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+http = "1.3.1"
+humansize = "2.1.3"
+reqwest = "0.12.23"
+reqwest-websocket = "0.5.1"
+serde = { version = "1.0.219", features = ["derive"] }
+serde_with = "3.14.0"
+tauri-plugin-opener = "2.5.0"
+url = "2.5.7"

src-tauri/drop-errors/src/application_download_error.rs

@@ -0,0 +1,49 @@
+use std::{
+    fmt::{Display, Formatter},
+    io, sync::Arc,
+};
+
+use serde_with::SerializeDisplay;
+use humansize::{format_size, BINARY};
+
+use super::remote_access_error::RemoteAccessError;
+
+// TODO: Rename / separate from downloads
+#[derive(Debug, SerializeDisplay)]
+pub enum ApplicationDownloadError {
+    NotInitialized,
+    Communication(RemoteAccessError),
+    DiskFull(u64, u64),
+    #[allow(dead_code)]
+    Checksum,
+    Lock,
+    IoError(Arc<io::Error>),
+    DownloadError,
+}
+
+impl Display for ApplicationDownloadError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ApplicationDownloadError::NotInitialized => write!(f, "Download not initalized, did something go wrong?"),
+            ApplicationDownloadError::DiskFull(required, available) => write!(
+                f,
+                "Game requires {}, {} remaining left on disk.",
+                format_size(*required, BINARY),
+                format_size(*available, BINARY),
+            ),
+            ApplicationDownloadError::Communication(error) => write!(f, "{error}"),
+            ApplicationDownloadError::Lock => write!(
+                f,
+                "failed to acquire lock. Something has gone very wrong internally. Please restart the application"
+            ),
+            ApplicationDownloadError::Checksum => {
+                write!(f, "checksum failed to validate for download")
+            }
+            ApplicationDownloadError::IoError(error) => write!(f, "io error: {error}"),
+            ApplicationDownloadError::DownloadError => write!(
+                f,
+                "Download failed. See Download Manager status for specific error"
+            ),
+        }
+    }
+}

src-tauri/drop-errors/src/download_manager_error.rs

@@ -0,0 +1,27 @@
+use std::{fmt::Display, io, sync::mpsc::SendError};
+
+use serde_with::SerializeDisplay;
+
+#[derive(SerializeDisplay)]
+pub enum DownloadManagerError<T> {
+    IOError(io::Error),
+    SignalError(SendError<T>),
+}
+impl<T> Display for DownloadManagerError<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            DownloadManagerError::IOError(error) => write!(f, "{error}"),
+            DownloadManagerError::SignalError(send_error) => write!(f, "{send_error}"),
+        }
+    }
+}
+impl<T> From<SendError<T>> for DownloadManagerError<T> {
+    fn from(value: SendError<T>) -> Self {
+        DownloadManagerError::SignalError(value)
+    }
+}
+impl<T> From<io::Error> for DownloadManagerError<T> {
+    fn from(value: io::Error) -> Self {
+        DownloadManagerError::IOError(value)
+    }
+}

src-tauri/drop-errors/src/drop_server_error.rs

@@ -0,0 +1,10 @@
+use serde::Deserialize;
+
+#[derive(Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct DropServerError {
+    pub status_code: usize,
+    pub status_message: String,
+    // pub message: String,
+    // pub url: String,
+}

src-tauri/drop-errors/src/lib.rs

@@ -0,0 +1,6 @@
+pub mod application_download_error;
+pub mod download_manager_error;
+pub mod drop_server_error;
+pub mod library_error;
+pub mod process_error;
+pub mod remote_access_error;

src-tauri/drop-errors/src/library_error.rs

@@ -0,0 +1,18 @@
+use std::fmt::Display;
+
+use serde_with::SerializeDisplay;
+
+#[derive(SerializeDisplay)]
+pub enum LibraryError {
+    MetaNotFound(String),
+}
+impl Display for LibraryError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            LibraryError::MetaNotFound(id) => write!(
+                f,
+                "Could not locate any installed version of game ID {id} in the database"
+            ),
+        }
+    }
+}

src-tauri/drop-errors/src/process_error.rs

@@ -0,0 +1,31 @@
+use std::{fmt::Display, io::Error};
+
+use serde_with::SerializeDisplay;
+
+#[derive(SerializeDisplay)]
+pub enum ProcessError {
+    NotInstalled,
+    AlreadyRunning,
+    InvalidID,
+    InvalidVersion,
+    IOError(Error),
+    FormatError(String), // String errors supremacy
+    InvalidPlatform,
+    OpenerError(tauri_plugin_opener::Error)
+}
+
+impl Display for ProcessError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let s = match self {
+            ProcessError::NotInstalled => "Game not installed",
+            ProcessError::AlreadyRunning => "Game already running",
+            ProcessError::InvalidID => "Invalid game ID",
+            ProcessError::InvalidVersion => "Invalid game version",
+            ProcessError::IOError(error) => &error.to_string(),
+            ProcessError::InvalidPlatform => "This game cannot be played on the current platform",
+            ProcessError::FormatError(e) => &format!("Failed to format template: {e}"),
+            ProcessError::OpenerError(error) => &format!("Failed to open directory: {error}"),
+                    };
+        write!(f, "{s}")
+    }
+}

src-tauri/drop-errors/src/remote_access_error.rs

@@ -0,0 +1,108 @@
+use std::{
+    error::Error,
+    fmt::{Display, Formatter},
+    sync::Arc,
+};
+
+use http::StatusCode;
+use serde_with::SerializeDisplay;
+use url::ParseError;
+
+use super::drop_server_error::DropServerError;
+
+#[derive(Debug, SerializeDisplay)]
+pub enum RemoteAccessError {
+    FetchError(Arc<reqwest::Error>),
+    FetchErrorWS(Arc<reqwest_websocket::Error>),
+    ParsingError(ParseError),
+    InvalidEndpoint,
+    HandshakeFailed(String),
+    GameNotFound(String),
+    InvalidResponse(DropServerError),
+    UnparseableResponse(String),
+    ManifestDownloadFailed(StatusCode, String),
+    OutOfSync,
+    Cache(std::io::Error),
+    CorruptedState,
+}
+
+impl Display for RemoteAccessError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            RemoteAccessError::FetchError(error) => {
+                if error.is_connect() {
+                    return write!(
+                        f,
+                        "Failed to connect to Drop server. Check if you access Drop through a browser, and then try again."
+                    );
+                }
+
+                write!(
+                    f,
+                    "{}: {}",
+                    error,
+                    error
+                        .source()
+                        .map(std::string::ToString::to_string)
+                        .or_else(|| Some("Unknown error".to_string()))
+                        .unwrap()
+                )
+            }
+            RemoteAccessError::FetchErrorWS(error) => write!(
+                f,
+                "{}: {}",
+                error,
+                error
+                    .source()
+                    .map(|e| e.to_string())
+                    .or_else(|| Some("Unknown error".to_string()))
+                    .unwrap()
+            ),
+            RemoteAccessError::ParsingError(parse_error) => {
+                write!(f, "{parse_error}")
+            }
+            RemoteAccessError::InvalidEndpoint => write!(f, "invalid drop endpoint"),
+            RemoteAccessError::HandshakeFailed(message) => {
+                write!(f, "failed to complete handshake: {message}")
+            }
+            RemoteAccessError::GameNotFound(id) => write!(f, "could not find game on server: {id}"),
+            RemoteAccessError::InvalidResponse(error) => write!(
+                f,
+                "server returned an invalid response: {}, {}",
+                error.status_code, error.status_message
+            ),
+            RemoteAccessError::UnparseableResponse(error) => {
+                write!(f, "server returned an invalid response: {error}")
+            }
+            RemoteAccessError::ManifestDownloadFailed(status, response) => {
+                write!(f, "failed to download game manifest: {status} {response}")
+            }
+            RemoteAccessError::OutOfSync => write!(
+                f,
+                "server's and client's time are out of sync. Please ensure they are within at least 30 seconds of each other"
+            ),
+            RemoteAccessError::Cache(error) => write!(f, "Cache Error: {error}"),
+            RemoteAccessError::CorruptedState => write!(
+                f,
+                "Drop encountered a corrupted internal state. Please report this to the developers, with details of reproduction."
+            ),
+        }
+    }
+}
+
+impl From<reqwest::Error> for RemoteAccessError {
+    fn from(err: reqwest::Error) -> Self {
+        RemoteAccessError::FetchError(Arc::new(err))
+    }
+}
+impl From<reqwest_websocket::Error> for RemoteAccessError {
+    fn from(err: reqwest_websocket::Error) -> Self {
+        RemoteAccessError::FetchErrorWS(Arc::new(err))
+    }
+}
+impl From<ParseError> for RemoteAccessError {
+    fn from(err: ParseError) -> Self {
+        RemoteAccessError::ParsingError(err)
+    }
+}
+impl std::error::Error for RemoteAccessError {}