fix(cache): Added proper error handling to fetch_object(_offline)

src-tauri/src/lib.rs

@@ -40,11 +40,11 @@ use log4rs::encode::pattern::PatternEncoder;
 use log4rs::Config;
 use process::commands::{kill_game, launch_game};
 use process::process_manager::ProcessManager;
-use remote::auth::{self, generate_authorization_header, recieve_handshake};
-use remote::cache::{cache_object, fetch_object, fetch_object_offline, get_cached_object, ObjectCache};
+use remote::auth::{self, recieve_handshake};
 use remote::commands::{
     auth_initiate, fetch_drop_object, gen_drop_url, manual_recieve_handshake, retry_connect, sign_out, use_remote
 };
+use remote::fetch_object::{fetch_object, fetch_object_offline};
 use remote::requests::make_request;
 use reqwest::blocking::Body;
 use serde::{Deserialize, Serialize};

src-tauri/src/remote/cache.rs

@@ -35,53 +35,6 @@ pub fn get_cached_object<'a, K: AsRef<str>, D: Serialize + DeserializeOwned>(
     Ok(data)
 }
 
-pub fn fetch_object(
-    request: http::Request<Vec<u8>>,
-    responder: UriSchemeResponder,
-) {
-    // Drop leading /
-    let object_id = &request.uri().path()[1..];
-
-    let header = generate_authorization_header();
-    let client: reqwest::blocking::Client = reqwest::blocking::Client::new();
-    let response = make_request(&client, &["/api/v1/client/object/", object_id], &[], |f| {
-        f.header("Authorization", header)
-    })
-    .unwrap()
-    .send();
-    if response.is_err() {
-        let data = get_cached_object::<&str, ObjectCache>(object_id);
-
-        match data {
-            Ok(data) => responder.respond(data.into()),
-            Err(_) => todo!(),
-        }
-        return;
-    }
-    let response = response.unwrap();
-
-    let resp_builder = ResponseBuilder::new().header(
-        CONTENT_TYPE,
-        response.headers().get("Content-Type").unwrap(),
-    );
-    let data = Vec::from(response.bytes().unwrap());
-    let resp = resp_builder.body(data).unwrap();
-    cache_object::<&str, ObjectCache>(object_id, &resp.clone().into()).unwrap();
-
-    responder.respond(resp);
-}
-pub fn fetch_object_offline(
-    request: http::Request<Vec<u8>>,
-    responder: UriSchemeResponder,
-) {
-    let object_id = &request.uri().path()[1..];
-    let data = get_cached_object::<&str, ObjectCache>(object_id);
-
-    match data {
-        Ok(data) => responder.respond(data.into()),
-        Err(_) => todo!(),
-    }
-}
 #[derive(Serialize, Deserialize)]
 pub struct ObjectCache {
     content_type: String,

src-tauri/src/remote/fetch_object.rs

@@ -0,0 +1,55 @@
+use http::{header::CONTENT_TYPE, response::Builder as ResponseBuilder};
+use log::warn;
+use tauri::UriSchemeResponder;
+
+use super::{auth::generate_authorization_header, cache::{cache_object, get_cached_object, ObjectCache}, requests::make_request};
+
+pub fn fetch_object(
+    request: http::Request<Vec<u8>>,
+    responder: UriSchemeResponder,
+) {
+    // Drop leading /
+    let object_id = &request.uri().path()[1..];
+
+    let header = generate_authorization_header();
+    let client: reqwest::blocking::Client = reqwest::blocking::Client::new();
+    let response = make_request(&client, &["/api/v1/client/object/", object_id], &[], |f| {
+        f.header("Authorization", header)
+    })
+    .unwrap()
+    .send();
+    if response.is_err() {
+        let data = get_cached_object::<&str, ObjectCache>(object_id);
+
+        match data {
+            Ok(data) => responder.respond(data.into()),
+            Err(e) => {
+                warn!("{}", e)
+            },
+        }
+        return;
+    }
+    let response = response.unwrap();
+
+    let resp_builder = ResponseBuilder::new().header(
+        CONTENT_TYPE,
+        response.headers().get("Content-Type").unwrap(),
+    );
+    let data = Vec::from(response.bytes().unwrap());
+    let resp = resp_builder.body(data).unwrap();
+    cache_object::<&str, ObjectCache>(object_id, &resp.clone().into()).unwrap();
+
+    responder.respond(resp);
+}
+pub fn fetch_object_offline(
+    request: http::Request<Vec<u8>>,
+    responder: UriSchemeResponder,
+) {
+    let object_id = &request.uri().path()[1..];
+    let data = get_cached_object::<&str, ObjectCache>(object_id);
+
+    match data {
+        Ok(data) => responder.respond(data.into()),
+        Err(e) => warn!("{}", e),
+    }
+}

src-tauri/src/remote/mod.rs

@@ -2,5 +2,6 @@ pub mod auth;
 #[macro_use]
 pub mod cache;
 pub mod commands;
+pub mod fetch_object;
 pub mod remote;
 pub mod requests;