Ryan/drop-app
1
0
Fork 0
mirror of https://github.com/Drop-OSS/drop-app.git synced 2025-11-10 12:32:14 +10:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'error-handling'

Browse Source 
Makes the Drop app more resistent to errors during start-up
This commit is contained in:
DecDuck
2024-11-04 18:06:51 +11:00
parent 50ed84115b eb3311a0c4
commit 15204718cf
10 changed files with 360 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
app.vue
View File

@ -10,7 +10,7 @@ import { invoke } from "@tauri-apps/api/core";
import { AppStatus, type AppState } from "./types.d.ts"; import { AppStatus, type AppState } from "./types.d.ts";
import { listen } from "@tauri-apps/api/event"; import { listen } from "@tauri-apps/api/event";
import { useAppState } from "./composables/app-state.js"; import { useAppState } from "./composables/app-state.js";
import {useRouter} from "#vue-router"; import { useRouter } from "#vue-router";
const router = useRouter(); const router = useRouter();
@ -23,7 +23,9 @@ router.beforeEach(async () => {
switch (state.value.status) { switch (state.value.status) {
case AppStatus.NotConfigured: case AppStatus.NotConfigured:
router.push({ path: "/setup" }).then(() => {console.log("Pushed Setup")}); router.push({ path: "/setup" }).then(() => {
console.log("Pushed Setup");
});
break; break;
case AppStatus.SignedOut: case AppStatus.SignedOut:
router.push("/auth"); router.push("/auth");
@ -31,6 +33,9 @@ switch (state.value.status) {
case AppStatus.SignedInNeedsReauth: case AppStatus.SignedInNeedsReauth:
router.push("/auth/signedout"); router.push("/auth/signedout");
break; break;
case AppStatus.ServerUnavailable:
router.push("/error/serverunavailable");
break;
default: default:
router.push("/store"); router.push("/store");
} }
@ -48,6 +53,6 @@ listen("auth/finished", () => {
}); });
useHead({ useHead({
title: "Drop" title: "Drop",
}) });
</script> </script>

25
components/InitiateAuthModule.vue
View File

@ -40,23 +40,20 @@
<span v-else> <span v-else>
Sign in with your browser <span aria-hidden="true">&rarr;</span> Sign in with your browser <span aria-hidden="true">&rarr;</span>
</span> </span>
</button>
<div v-if="error" class="mt-5 rounded-md bg-red-600/10 p-4"> <div v-if="error" class="mt-5 rounded-md bg-red-600/10 p-4">
<div class="flex"> <div class="flex">
<div class="flex-shrink-0"> <div class="flex-shrink-0">
<XCircleIcon <XCircleIcon class="h-5 w-5 text-red-600" aria-hidden="true" />
class="h-5 w-5 text-red-600" </div>
aria-hidden="true" <div class="ml-3">
/> <h3 class="text-sm font-medium text-red-600">
</div> {{ error }}
<div class="ml-3"> </h3>
<h3 class="text-sm font-medium text-red-600">
{{ error }}
</h3>
</div>
</div> </div>
</div> </div>
</button> </div>
</div> </div>
</div> </div>
</main> </main>

66
pages/error.vue Normal file
View File

@ -0,0 +1,66 @@
<template>
<div
class="grid min-h-full grid-cols-1 grid-rows-[1fr,auto,1fr] lg:grid-cols-[max(50%,36rem),1fr]"
>
<header
class="mx-auto w-full max-w-7xl px-6 pt-6 sm:pt-10 lg:col-span-2 lg:col-start-1 lg:row-start-1 lg:px-8"
>
<Logo class="h-10 w-auto sm:h-12" />
</header>
<main
class="mx-auto w-full max-w-7xl px-6 py-24 sm:py-32 lg:col-span-2 lg:col-start-1 lg:row-start-2 lg:px-8"
>
<div class="max-w-lg">
<h1
class="mt-4 text-3xl font-bold font-display tracking-tight text-zinc-100 sm:text-5xl"
>
Unrecoverable error
</h1>
<p class="mt-6 text-base leading-7 text-zinc-400">
Drop encountered an error that it couldn't handle. Please restart the
application and file a bug report.
</p>
</div>
</main>
<footer class="self-end lg:col-span-2 lg:col-start-1 lg:row-start-3">
<div class="border-t border-blue-600 bg-zinc-900 py-10">
<nav
class="mx-auto flex w-full max-w-7xl items-center gap-x-4 px-6 text-sm leading-7 text-zinc-400 lg:px-8"
>
<a href="#">Documentation</a>
<svg
viewBox="0 0 2 2"
aria-hidden="true"
class="h-0.5 w-0.5 fill-zinc-700"
>
<circle cx="1" cy="1" r="1" />
</svg>
<a href="#">Troubleshooting</a>
<svg
viewBox="0 0 2 2"
aria-hidden="true"
class="h-0.5 w-0.5 fill-zinc-700"
>
<circle cx="1" cy="1" r="1" />
</svg>
<NuxtLink to="/setup/server">Switch instance</NuxtLink>
</nav>
</div>
</footer>
<div
class="hidden lg:relative lg:col-start-2 lg:row-start-1 lg:row-end-4 lg:block"
>
<img
src="@/assets/wallpaper.jpg"
alt=""
class="absolute inset-0 h-full w-full object-cover"
/>
</div>
</div>
</template>
<script setup lang="ts">
definePageMeta({
layout: "mini",
});
</script>

74
pages/error/serverunavailable.vue Normal file
View File

@ -0,0 +1,74 @@
<template>
<div
class="grid min-h-full grid-cols-1 grid-rows-[1fr,auto,1fr] lg:grid-cols-[max(50%,36rem),1fr]"
>
<header
class="mx-auto w-full max-w-7xl px-6 pt-6 sm:pt-10 lg:col-span-2 lg:col-start-1 lg:row-start-1 lg:px-8"
>
<Logo class="h-10 w-auto sm:h-12" />
</header>
<main
class="mx-auto w-full max-w-7xl px-6 py-24 sm:py-32 lg:col-span-2 lg:col-start-1 lg:row-start-2 lg:px-8"
>
<div class="max-w-lg">
<h1
class="mt-4 text-3xl font-bold font-display tracking-tight text-zinc-100 sm:text-5xl"
>
Server is unavailable
</h1>
<p class="mt-6 text-base leading-7 text-zinc-400">
We were unable to contact your Drop instance. See if you can open it
in your web browser, or contact your server admin for help.
</p>
<div class="mt-10">
<NuxtLink
to="/setup"
class="text-sm text-left font-semibold leading-7 text-blue-600"
>
Connect to different instance <span aria-hidden="true">&rarr;</span>
</NuxtLink>
</div>
</div>
</main>
<footer class="self-end lg:col-span-2 lg:col-start-1 lg:row-start-3">
<div class="border-t border-blue-600 bg-zinc-900 py-10">
<nav
class="mx-auto flex w-full max-w-7xl items-center gap-x-4 px-6 text-sm leading-7 text-zinc-400 lg:px-8"
>
<a href="#">Documentation</a>
<svg
viewBox="0 0 2 2"
aria-hidden="true"
class="h-0.5 w-0.5 fill-zinc-700"
>
<circle cx="1" cy="1" r="1" />
</svg>
<a href="#">Troubleshooting</a>
<svg
viewBox="0 0 2 2"
aria-hidden="true"
class="h-0.5 w-0.5 fill-zinc-700"
>
<circle cx="1" cy="1" r="1" />
</svg>
<NuxtLink to="/setup/server">Switch instance</NuxtLink>
</nav>
</div>
</footer>
<div
class="hidden lg:relative lg:col-start-2 lg:row-start-1 lg:row-end-4 lg:block"
>
<img
src="@/assets/wallpaper.jpg"
alt=""
class="absolute inset-0 h-full w-full object-cover"
/>
</div>
</div>
</template>
<script setup lang="ts">
definePageMeta({
layout: "mini",
});
</script>

11
plugins/global-error-handler.ts Normal file
View File

@ -0,0 +1,11 @@
export default defineNuxtPlugin((nuxtApp) => {
nuxtApp.vueApp.config.errorHandler = (error, instance, info) => {
// handle error, e.g. report to a service
};
// Also possible
nuxtApp.hook("vue:error", (error, instance, info) => {
const router = useRouter();
router.replace("/error");
});
});

122
src-tauri/src/auth.rs
View File

@ -1,55 +1,44 @@
use std::{ use std::{
env, env,
sync::Mutex, time::{SystemTime, UNIX_EPOCH}, fmt::{Display, Formatter},
sync::Mutex,
time::{SystemTime, UNIX_EPOCH},
}; };
use log::{info, warn}; use log::{info, warn};
use openssl::{ use openssl::{ec::EcKey, hash::MessageDigest, pkey::PKey, sign::Signer};
ec::EcKey,
hash::MessageDigest,
pkey::PKey,
sign::{Signer},
};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use tauri::{AppHandle, Emitter, Manager}; use tauri::{AppHandle, Emitter, Manager};
use url::Url; use url::{ParseError, Url};
use crate::{db::{DatabaseAuth, DatabaseImpls}, AppState, AppStatus, User, DB}; use crate::{
db::{DatabaseAuth, DatabaseImpls},
remote::RemoteAccessError,
AppState, AppStatus, User, DB,
};
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all="camelCase")] #[serde(rename_all = "camelCase")]
struct InitiateRequestBody { struct InitiateRequestBody {
name: String, name: String,
platform: String, platform: String,
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all="camelCase")] #[serde(rename_all = "camelCase")]
struct HandshakeRequestBody { struct HandshakeRequestBody {
client_id: String, client_id: String,
token: String, token: String,
} }
#[derive(Deserialize)] #[derive(Deserialize)]
#[serde(rename_all="camelCase")] #[serde(rename_all = "camelCase")]
struct HandshakeResponse { struct HandshakeResponse {
private: String, private: String,
certificate: String, certificate: String,
id: String, id: String,
} }
macro_rules! unwrap_or_return {
( $e:expr, $app:expr ) => {
match $e {
Ok(x) => x,
Err(_) => {
$app.emit("auth/failed", ()).unwrap();
return;
}
}
};
}
pub fn sign_nonce(private_key: String, nonce: String) -> Result<String, ()> { pub fn sign_nonce(private_key: String, nonce: String) -> Result<String, ()> {
let client_private_key = EcKey::private_key_from_pem(private_key.as_bytes()).unwrap(); let client_private_key = EcKey::private_key_from_pem(private_key.as_bytes()).unwrap();
let pkey_private_key = PKey::from_ec_key(client_private_key).unwrap(); let pkey_private_key = PKey::from_ec_key(client_private_key).unwrap();
@ -80,42 +69,39 @@ pub fn generate_authorization_header() -> String {
format!("Nonce {} {} {}", certs.client_id, nonce, signature) format!("Nonce {} {} {}", certs.client_id, nonce, signature)
} }
pub fn fetch_user() -> Result<User, ()> { pub fn fetch_user() -> Result<User, RemoteAccessError> {
let base_url = DB.fetch_base_url(); let base_url = DB.fetch_base_url();
let endpoint = base_url.join("/api/v1/client/user").unwrap(); let endpoint = base_url.join("/api/v1/client/user")?;
let header = generate_authorization_header(); let header = generate_authorization_header();
let client = reqwest::blocking::Client::new(); let client = reqwest::blocking::Client::new();
let response = client let response = client
.get(endpoint.to_string()) .get(endpoint.to_string())
.header("Authorization", header) .header("Authorization", header)
.send() .send()?;
.unwrap();
if response.status() != 200 { if response.status() != 200 {
warn!("Failed to fetch user: {}", response.status()); return Err(response.status().as_u16().into());
return Err(());
} }
let user = response.json::<User>().unwrap(); let user = response.json::<User>()?;
Ok(user) Ok(user)
} }
pub fn recieve_handshake(app: AppHandle, path: String) { fn recieve_handshake_logic(app: &AppHandle, path: String) -> Result<(), RemoteAccessError> {
// Tell the app we're processing
app.emit("auth/processing", ()).unwrap();
let path_chunks: Vec<&str> = path.split("/").collect(); let path_chunks: Vec<&str> = path.split("/").collect();
if path_chunks.len() != 3 { if path_chunks.len() != 3 {
app.emit("auth/failed", ()).unwrap(); app.emit("auth/failed", ()).unwrap();
return; return Err(RemoteAccessError::GenericErrror(
"Invalid number of handshake chunks".to_string().into(),
));
} }
let base_url = { let base_url = {
let handle = DB.borrow_data().unwrap(); let handle = DB.borrow_data().unwrap();
Url::parse(handle.base_url.as_str()).unwrap() Url::parse(handle.base_url.as_str())?
}; };
let client_id = path_chunks.get(1).unwrap(); let client_id = path_chunks.get(1).unwrap();
@ -125,11 +111,11 @@ pub fn recieve_handshake(app: AppHandle, path: String) {
token: token.to_string(), token: token.to_string(),
}; };
let endpoint = unwrap_or_return!(base_url.join("/api/v1/client/auth/handshake"), app); let endpoint = base_url.join("/api/v1/client/auth/handshake")?;
let client = reqwest::blocking::Client::new(); let client = reqwest::blocking::Client::new();
let response = unwrap_or_return!(client.post(endpoint).json(&body).send(), app); let response = client.post(endpoint).json(&body).send()?;
info!("server responded with {}", response.status()); info!("server responded with {}", response.status());
let response_struct = unwrap_or_return!(response.json::<HandshakeResponse>(), app); let response_struct = response.json::<HandshakeResponse>()?;
{ {
let mut handle = DB.borrow_data_mut().unwrap(); let mut handle = DB.borrow_data_mut().unwrap();
@ -146,43 +132,62 @@ pub fn recieve_handshake(app: AppHandle, path: String) {
let app_state = app.state::<Mutex<AppState>>(); let app_state = app.state::<Mutex<AppState>>();
let mut app_state_handle = app_state.lock().unwrap(); let mut app_state_handle = app_state.lock().unwrap();
app_state_handle.status = AppStatus::SignedIn; app_state_handle.status = AppStatus::SignedIn;
app_state_handle.user = Some(fetch_user().unwrap()); app_state_handle.user = Some(fetch_user()?);
}
return Ok(());
}
pub fn recieve_handshake(app: AppHandle, path: String) {
// Tell the app we're processing
app.emit("auth/processing", ()).unwrap();
let handshake_result = recieve_handshake_logic(&app, path);
if handshake_result.is_err() {
app.emit("auth/failed", ()).unwrap();
return;
} }
app.emit("auth/finished", ()).unwrap(); app.emit("auth/finished", ()).unwrap();
} }
#[tauri::command] async fn auth_initiate_wrapper() -> Result<(), RemoteAccessError> {
pub async fn auth_initiate<'a>() -> Result<(), String> {
let base_url = { let base_url = {
let db_lock = DB.borrow_data().unwrap(); let db_lock = DB.borrow_data().unwrap();
Url::parse(&db_lock.base_url.clone()).unwrap() Url::parse(&db_lock.base_url.clone())?
}; };
let endpoint = base_url.join("/api/v1/client/auth/initiate").unwrap(); let endpoint = base_url.join("/api/v1/client/auth/initiate")?;
let body = InitiateRequestBody { let body = InitiateRequestBody {
name: "Drop Desktop Client".to_string(), name: "Drop Desktop Client".to_string(),
platform: env::consts::OS.to_string(), platform: env::consts::OS.to_string(),
}; };
let client = reqwest::Client::new(); let client = reqwest::Client::new();
let response = client let response = client.post(endpoint.to_string()).json(&body).send().await?;
.post(endpoint.to_string())
.json(&body)
.send()
.await
.unwrap();
if response.status() != 200 { if response.status() != 200 {
return Err("Failed to create redirect URL. Please try again later.".to_string()); return Err("Failed to create redirect URL. Please try again later."
.to_string()
.into());
} }
let redir_url = response.text().await.unwrap(); let redir_url = response.text().await?;
let complete_redir_url = base_url.join(&redir_url).unwrap(); let complete_redir_url = base_url.join(&redir_url)?;
info!("opening web browser to continue authentication"); info!("opening web browser to continue authentication");
webbrowser::open(complete_redir_url.as_ref()).unwrap(); webbrowser::open(complete_redir_url.as_ref()).unwrap();
return Ok(());
}
#[tauri::command]
pub async fn auth_initiate<'a>() -> Result<(), String> {
let result = auth_initiate_wrapper().await;
if result.is_err() {
return Err(result.err().unwrap().to_string());
}
Ok(()) Ok(())
} }
@ -193,7 +198,14 @@ pub fn setup() -> Result<(AppStatus, Option<User>), ()> {
if data.auth.is_some() { if data.auth.is_some() {
let user_result = fetch_user(); let user_result = fetch_user();
if user_result.is_err() { if user_result.is_err() {
return Ok((AppStatus::SignedInNeedsReauth, None)); let error = user_result.err().unwrap();
warn!("auth setup failed with: {}", error);
match error {
RemoteAccessError::FetchError(_) => {
return Ok((AppStatus::ServerUnavailable, None))
}
_ => return Ok((AppStatus::SignedInNeedsReauth, None)),
}
} }
return Ok((AppStatus::SignedIn, Some(user_result.unwrap()))); return Ok((AppStatus::SignedIn, Some(user_result.unwrap())));
} }

20
src-tauri/src/lib.rs
View File

@ -6,6 +6,7 @@ mod downloads;
#[cfg(test)] #[cfg(test)]
mod tests; mod tests;
use crate::db::DatabaseImpls;
use auth::{auth_initiate, generate_authorization_header, recieve_handshake}; use auth::{auth_initiate, generate_authorization_header, recieve_handshake};
use db::{DatabaseInterface, DATA_ROOT_DIR}; use db::{DatabaseInterface, DATA_ROOT_DIR};
use downloads::download_commands::{queue_game_download, start_game_downloads, stop_specific_game_download}; use downloads::download_commands::{queue_game_download, start_game_downloads, stop_specific_game_download};
@ -16,7 +17,8 @@ use log::info;
use remote::{gen_drop_url, use_remote}; use remote::{gen_drop_url, use_remote};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use std::{ use std::{
collections::HashMap, sync::{LazyLock, Mutex} collections::HashMap,
sync::{LazyLock, Mutex},
}; };
use std::sync::Arc; use std::sync::Arc;
use tauri_plugin_deep_link::DeepLinkExt; use tauri_plugin_deep_link::DeepLinkExt;
@ -26,12 +28,14 @@ use crate::downloads::download_agent::{GameDownloadAgent};
#[derive(Clone, Copy, Serialize)] #[derive(Clone, Copy, Serialize)]
pub enum AppStatus { pub enum AppStatus {
NotConfigured, NotConfigured,
ServerError,
SignedOut, SignedOut,
SignedIn, SignedIn,
SignedInNeedsReauth, SignedInNeedsReauth,
ServerUnavailable,
} }
#[derive(Clone, Serialize, Deserialize)] #[derive(Clone, Serialize, Deserialize)]
#[serde(rename_all="camelCase")] #[serde(rename_all = "camelCase")]
pub struct User { pub struct User {
id: String, id: String,
username: String, username: String,
@ -41,7 +45,7 @@ pub struct User {
} }
#[derive(Clone, Serialize)] #[derive(Clone, Serialize)]
#[serde(rename_all="camelCase")] #[serde(rename_all = "camelCase")]
pub struct AppState { pub struct AppState {
status: AppStatus, status: AppStatus,
user: Option<User>, user: Option<User>,
@ -72,10 +76,10 @@ fn setup() -> AppState {
}; };
} }
let auth_result = auth::setup().unwrap(); let (app_status, user) = auth::setup().unwrap();
AppState { AppState {
status: auth_result.0, status: app_status,
user: auth_result.1, user: user,
games: HashMap::new(), games: HashMap::new(),
game_downloads: HashMap::new(), game_downloads: HashMap::new(),
} }
@ -144,7 +148,9 @@ pub fn run() {
info!("handling drop:// url"); info!("handling drop:// url");
let binding = event.urls(); let binding = event.urls();
let url = binding.first().unwrap(); let url = binding.first().unwrap();
if url.host_str().unwrap() == "handshake" { recieve_handshake(handle.clone(), url.path().to_string()) } if url.host_str().unwrap() == "handshake" {
recieve_handshake(handle.clone(), url.path().to_string())
}
}); });
Ok(()) Ok(())

55
src-tauri/src/library.rs
View File

@ -4,9 +4,10 @@ use serde::{Deserialize, Serialize};
use serde_json::json; use serde_json::json;
use tauri::{AppHandle, Manager}; use tauri::{AppHandle, Manager};
use crate::{auth::generate_authorization_header, AppState, DB};
use crate::db::DatabaseImpls;
use crate::db::DatabaseGameStatus; use crate::db::DatabaseGameStatus;
use crate::db::DatabaseImpls;
use crate::remote::RemoteAccessError;
use crate::{auth::generate_authorization_header, AppState, DB};
#[derive(serde::Serialize)] #[derive(serde::Serialize)]
struct FetchGameStruct { struct FetchGameStruct {
@ -29,10 +30,9 @@ pub struct Game {
m_image_library: Vec<String>, m_image_library: Vec<String>,
} }
#[tauri::command] fn fetch_library_logic(app: AppHandle) -> Result<String, RemoteAccessError> {
pub fn fetch_library(app: AppHandle) -> Result<String, String> {
let base_url = DB.fetch_base_url(); let base_url = DB.fetch_base_url();
let library_url = base_url.join("/api/v1/client/user/library").unwrap(); let library_url = base_url.join("/api/v1/client/user/library")?;
let header = generate_authorization_header(); let header = generate_authorization_header();
@ -40,18 +40,13 @@ pub fn fetch_library(app: AppHandle) -> Result<String, String> {
let response = client let response = client
.get(library_url.to_string()) .get(library_url.to_string())
.header("Authorization", header) .header("Authorization", header)
.send() .send()?;
.unwrap();
if response.status() != 200 { if response.status() != 200 {
return Err(format!( return Err(response.status().as_u16().into());
"Library fetch request failed with {}",
response.status()
));
} }
// Keep as string let games = response.json::<Vec<Game>>()?;
let games = response.json::<Vec<Game>>().unwrap();
let state = app.state::<Mutex<AppState>>(); let state = app.state::<Mutex<AppState>>();
let mut handle = state.lock().unwrap(); let mut handle = state.lock().unwrap();
@ -74,20 +69,48 @@ pub fn fetch_library(app: AppHandle) -> Result<String, String> {
} }
#[tauri::command] #[tauri::command]
pub fn fetch_game(id: String, app: tauri::AppHandle) -> Result<String, String> { pub fn fetch_library(app: AppHandle) -> Result<String, String> {
let result = fetch_library_logic(app);
if result.is_err() {
return Err(result.err().unwrap().to_string());
}
return Ok(result.unwrap());
}
fn fetch_game_logic(id: String, app: tauri::AppHandle) -> Result<String, RemoteAccessError> {
let state = app.state::<Mutex<AppState>>(); let state = app.state::<Mutex<AppState>>();
let handle = state.lock().unwrap(); let handle = state.lock().unwrap();
let game = handle.games.get(&id); let game = handle.games.get(&id);
if let Some(game) = game { if let Some(game) = game {
let db_handle = DB.borrow_data().unwrap(); let db_handle = DB.borrow_data().unwrap();
let data = FetchGameStruct { let data = FetchGameStruct {
game: game.clone(), game: game.clone(),
status: db_handle.games.games_statuses.get(&game.id).unwrap().clone(), status: db_handle
.games
.games_statuses
.get(&game.id)
.unwrap()
.clone(),
}; };
return Ok(json!(data).to_string()); return Ok(json!(data).to_string());
} }
// TODO request games that aren't found from remote server
Err("".to_string()) Err("".to_string().into())
}
#[tauri::command]
pub fn fetch_game(id: String, app: tauri::AppHandle) -> Result<String, String> {
let result = fetch_game_logic(id, app);
if result.is_err() {
return Err(result.err().unwrap().to_string());
}
Ok(result.unwrap())
} }

92
src-tauri/src/remote.rs
View File

@ -1,48 +1,80 @@
use std::sync::Mutex; use std::{
fmt::{write, Display, Formatter},
sync::Mutex,
};
use log::{info, warn}; use log::{info, warn};
use serde::Deserialize; use serde::Deserialize;
use url::Url; use url::{ParseError, Url};
use crate::{AppState, AppStatus, DB}; use crate::{AppState, AppStatus, DB};
macro_rules! unwrap_or_return { #[derive(Debug)]
( $e:expr ) => { pub enum RemoteAccessError {
match $e { FetchError(reqwest::Error),
Ok(x) => x, ParsingError(ParseError),
Err(e) => { InvalidCodeError(u16),
return Err(format!( GenericErrror(String),
"Invalid URL or Drop is inaccessible ({})",
e.to_string()
))
}
}
};
} }
impl Display for RemoteAccessError {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
match self {
RemoteAccessError::FetchError(error) => write!(f, "{}", error),
RemoteAccessError::GenericErrror(error) => write!(f, "{}", error),
RemoteAccessError::ParsingError(parse_error) => {
write!(f, "{}", parse_error)
}
RemoteAccessError::InvalidCodeError(error) => write!(f, "HTTP {}", error),
}
}
}
impl From<reqwest::Error> for RemoteAccessError {
fn from(err: reqwest::Error) -> Self {
RemoteAccessError::FetchError(err)
}
}
impl From<String> for RemoteAccessError {
fn from(err: String) -> Self {
RemoteAccessError::GenericErrror(err)
}
}
impl From<ParseError> for RemoteAccessError {
fn from(err: ParseError) -> Self {
RemoteAccessError::ParsingError(err)
}
}
impl From<u16> for RemoteAccessError {
fn from(err: u16) -> Self {
RemoteAccessError::InvalidCodeError(err)
}
}
impl std::error::Error for RemoteAccessError {}
#[derive(Deserialize)] #[derive(Deserialize)]
#[serde(rename_all="camelCase")] #[serde(rename_all = "camelCase")]
struct DropHealthcheck { struct DropHealthcheck {
app_name: String, app_name: String,
} }
#[tauri::command] async fn use_remote_logic<'a>(
pub async fn use_remote<'a>(
url: String, url: String,
state: tauri::State<'_, Mutex<AppState>>, state: tauri::State<'_, Mutex<AppState>>,
) -> Result<(), String> { ) -> Result<(), RemoteAccessError> {
info!("connecting to url {}", url); info!("connecting to url {}", url);
let base_url = unwrap_or_return!(Url::parse(&url)); let base_url = Url::parse(&url)?;
// Test Drop url // Test Drop url
let test_endpoint = base_url.join("/api/v1").unwrap(); let test_endpoint = base_url.join("/api/v1")?;
let response = unwrap_or_return!(reqwest::get(test_endpoint.to_string()).await); let response = reqwest::get(test_endpoint.to_string()).await?;
let result = response.json::<DropHealthcheck>().await.unwrap(); let result = response.json::<DropHealthcheck>().await?;
if result.app_name != "Drop" { if result.app_name != "Drop" {
warn!("user entered drop endpoint that connected, but wasn't identified as Drop"); warn!("user entered drop endpoint that connected, but wasn't identified as Drop");
return Err("Not a valid Drop endpoint".to_string()); return Err("Not a valid Drop endpoint".to_string().into());
} }
let mut app_state = state.lock().unwrap(); let mut app_state = state.lock().unwrap();
@ -58,6 +90,20 @@ pub async fn use_remote<'a>(
Ok(()) Ok(())
} }
#[tauri::command]
pub async fn use_remote<'a>(
url: String,
state: tauri::State<'_, Mutex<AppState>>,
) -> Result<(), String> {
let result = use_remote_logic(url, state).await;
if result.is_err() {
return Err(result.err().unwrap().to_string());
}
Ok(())
}
#[tauri::command] #[tauri::command]
pub fn gen_drop_url(path: String) -> Result<String, String> { pub fn gen_drop_url(path: String) -> Result<String, String> {
let base_url = { let base_url = {

1
types.d.ts vendored
View File

@ -22,6 +22,7 @@ export enum AppStatus {
SignedOut = "SignedOut", SignedOut = "SignedOut",
SignedIn = "SignedIn", SignedIn = "SignedIn",
SignedInNeedsReauth = "SignedInNeedsReauth", SignedInNeedsReauth = "SignedInNeedsReauth",
ServerUnavailable = "ServerUnavailable",
} }
export enum GameStatus { export enum GameStatus {