Authentication (#37)

* Initial authentication implementation

* Store user info in the database, improve encapsulation in profiles

* Add user list, remove unused dependencies, add spantraces

* Implement user remove, update UUID crate

* Add user set-default

* Revert submodule macro usage

* Make tracing significantly less verbose

theseus/src/api/profile.rs

@@ -1,14 +1,17 @@
 //! Theseus profile management interface
-
 pub use crate::{
     state::{JavaSettings, Profile},
     State,
 };
 use daedalus as d;
-use std::{future::Future, path::Path};
+use std::{
+    future::Future,
+    path::{Path, PathBuf},
+};
 use tokio::process::{Child, Command};
 
 /// Add a profile to the in-memory state
+#[tracing::instrument]
 pub async fn add(profile: Profile) -> crate::Result<()> {
     let state = State::get().await?;
     let mut profiles = state.profiles.write().await;
@@ -18,6 +21,7 @@ pub async fn add(profile: Profile) -> crate::Result<()> {
 }
 
 /// Add a path as a profile in-memory
+#[tracing::instrument]
 pub async fn add_path(path: &Path) -> crate::Result<()> {
     let state = State::get().await?;
     let mut profiles = state.profiles.write().await;
@@ -27,6 +31,7 @@ pub async fn add_path(path: &Path) -> crate::Result<()> {
 }
 
 /// Remove a profile
+#[tracing::instrument]
 pub async fn remove(path: &Path) -> crate::Result<()> {
     let state = State::get().await?;
     let mut profiles = state.profiles.write().await;
@@ -36,19 +41,22 @@ pub async fn remove(path: &Path) -> crate::Result<()> {
 }
 
 /// Get a profile by path,
+#[tracing::instrument]
 pub async fn get(path: &Path) -> crate::Result<Option<Profile>> {
     let state = State::get().await?;
     let profiles = state.profiles.read().await;
 
     profiles.0.get(path).map_or(Ok(None), |prof| match prof {
         Some(prof) => Ok(Some(prof.clone())),
-        None => Err(crate::Error::UnloadedProfileError(
+        None => Err(crate::ErrorKind::UnloadedProfileError(
             path.display().to_string(),
-        )),
+        )
+        .as_error()),
     })
 }
 
 /// Check if a profile is already managed by Theseus
+#[tracing::instrument]
 pub async fn is_managed(profile: &Path) -> crate::Result<bool> {
     let state = State::get().await?;
     let profiles = state.profiles.read().await;
@@ -56,6 +64,7 @@ pub async fn is_managed(profile: &Path) -> crate::Result<bool> {
 }
 
 /// Check if a profile is loaded
+#[tracing::instrument]
 pub async fn is_loaded(profile: &Path) -> crate::Result<bool> {
     let state = State::get().await?;
     let profiles = state.profiles.read().await;
@@ -75,29 +84,41 @@ pub async fn edit<Fut>(
 where
     Fut: Future<Output = crate::Result<()>>,
 {
-    let state = State::get().await.unwrap();
+    let state = State::get().await?;
     let mut profiles = state.profiles.write().await;
 
     match profiles.0.get_mut(path) {
         Some(&mut Some(ref mut profile)) => action(profile).await,
-        Some(&mut None) => Err(crate::Error::UnloadedProfileError(
+        Some(&mut None) => Err(crate::ErrorKind::UnloadedProfileError(
             path.display().to_string(),
-        )),
-        None => Err(crate::Error::UnmanagedProfileError(
+        )
+        .as_error()),
+        None => Err(crate::ErrorKind::UnmanagedProfileError(
             path.display().to_string(),
-        )),
+        )
+        .as_error()),
     }
 }
 
+/// Get a copy of the profile set
+#[tracing::instrument]
+pub async fn list(
+) -> crate::Result<std::collections::HashMap<PathBuf, Option<Profile>>> {
+    let state = State::get().await?;
+    let profiles = state.profiles.read().await;
+    Ok(profiles.0.clone())
+}
+
 /// Run Minecraft using a profile
+#[tracing::instrument(skip_all)]
 pub async fn run(
     path: &Path,
-    credentials: &crate::launcher::Credentials,
+    credentials: &crate::auth::Credentials,
 ) -> crate::Result<Child> {
     let state = State::get().await.unwrap();
     let settings = state.settings.read().await;
     let profile = get(path).await?.ok_or_else(|| {
-        crate::Error::OtherError(format!(
+        crate::ErrorKind::OtherError(format!(
             "Tried to run a nonexistent or unloaded profile at path {}!",
             path.display()
         ))
@@ -110,7 +131,7 @@ pub async fn run(
         .iter()
         .find(|it| it.id == profile.metadata.game_version.as_ref())
         .ok_or_else(|| {
-            crate::Error::LauncherError(format!(
+            crate::ErrorKind::LauncherError(format!(
                 "Invalid or unknown Minecraft version: {}",
                 profile.metadata.game_version
             ))
@@ -130,10 +151,11 @@ pub async fn run(
             .await?;
 
         if !result.success() {
-            return Err(crate::Error::LauncherError(format!(
+            return Err(crate::ErrorKind::LauncherError(format!(
                 "Non-zero exit code for pre-launch hook: {}",
                 result.code().unwrap_or(-1)
-            )));
+            ))
+            .as_error());
         }
     }
 
@@ -153,7 +175,7 @@ pub async fn run(
             settings.java_8_path.as_ref()
         }
         .ok_or_else(|| {
-            crate::Error::LauncherError(format!(
+            crate::ErrorKind::LauncherError(format!(
                 "No Java installed for version {}",
                 version_info.java_version.map_or(8, |it| it.major_version),
             ))
@@ -161,10 +183,11 @@ pub async fn run(
     };
 
     if !java_install.exists() {
-        return Err(crate::Error::LauncherError(format!(
+        return Err(crate::ErrorKind::LauncherError(format!(
             "Could not find Java install: {}",
             java_install.display()
-        )));
+        ))
+        .as_error());
     }
 
     let ref java_args = profile
@@ -195,21 +218,26 @@ pub async fn run(
     .await
 }
 
+#[tracing::instrument]
 pub async fn kill(running: &mut Child) -> crate::Result<()> {
     running.kill().await?;
     wait_for(running).await
 }
 
+#[tracing::instrument]
 pub async fn wait_for(running: &mut Child) -> crate::Result<()> {
     let result = running.wait().await.map_err(|err| {
-        crate::Error::LauncherError(format!("Error running minecraft: {err}"))
+        crate::ErrorKind::LauncherError(format!(
+            "Error running minecraft: {err}"
+        ))
     })?;
 
     match result.success() {
-        false => Err(crate::Error::LauncherError(format!(
+        false => Err(crate::ErrorKind::LauncherError(format!(
             "Minecraft exited with non-zero code {}",
             result.code().unwrap_or(-1)
-        ))),
+        ))
+        .as_error()),
         true => Ok(()),
     }
 }