Version bump: v0.3.0

* feat: Redownloading invalid chunks

Signed-off-by: quexeky <git@quexeky.dev>

* fix: clippy

* fix: clippy x2

---------

Signed-off-by: quexeky <git@quexeky.dev>
Co-authored-by: quexeky <git@quexeky.dev>

app.vue

@@ -1,4 +1,5 @@
 <template>
+  <LoadingIndicator />
   <NuxtLayout class="select-none w-screen h-screen">
     <NuxtPage />
     <ModalStack />

components/HeaderUserWidget.vue

@@ -23,7 +23,7 @@
       <MenuItems
         class="absolute bg-zinc-900 right-0 top-10 z-50 w-56 origin-top-right focus:outline-none shadow-md"
       >
-        <PanelWidget class="flex-col gap-y-2">
+        <div class="flex-col gap-y-2">
           <NuxtLink
             to="/id/me"
             class="transition inline-flex items-center w-full py-3 px-4 hover:bg-zinc-800"
@@ -65,7 +65,7 @@
               </button>
             </MenuItem>
           </div>
-        </PanelWidget>
+        </div>
       </MenuItems>
     </transition>
   </Menu>

components/LoadingIndicator.vue

@@ -0,0 +1,7 @@
+<template></template>
+
+<script setup lang="ts">
+const loading = useLoadingIndicator();
+
+watch(loading.isLoading, console.log);
+</script>

package.json

@@ -1,7 +1,7 @@
 {
   "name": "drop-app",
   "private": true,
-  "version": "0.3.0-rc-8",
+  "version": "0.3.0",
   "type": "module",
   "scripts": {
     "build": "nuxt build",

pages/library/[id]/index.vue

@@ -76,7 +76,7 @@
                       <TransitionGroup name="slide" tag="div" class="h-full">
                         <img
                           v-for="(url, index) in mediaUrls"
-                          :key="url"
+                          :key="index"
                           :src="url"
                           class="absolute inset-0 w-full h-full object-cover"
                           v-show="index === currentImageIndex"
@@ -157,8 +157,8 @@
     <template #default>
       <div class="sm:flex sm:items-start">
         <div class="mt-3 text-center sm:mt-0 sm:text-left">
-          <h3 class="text-base font-semibold text-zinc-100"
-            >Install {{ game.mName }}?
+          <h3 class="text-base font-semibold text-zinc-100">
+            Install {{ game.mName }}?
           </h3>
           <div class="mt-2">
             <p class="text-sm text-zinc-400">
@@ -350,9 +350,7 @@
     <template #buttons>
       <LoadingButton
         @click="() => install()"
-        :disabled="
-          !(versionOptions && versionOptions.length > 0)
-        "
+        :disabled="!(versionOptions && versionOptions.length > 0)"
         :loading="installLoading"
         type="submit"
         class="ml-2 w-full sm:w-fit"
@@ -370,7 +368,11 @@
     </template>
   </ModalTemplate>
 
-  <GameOptionsModal v-if="status.type === GameStatusEnum.Installed" v-model="configureModalOpen" :game-id="game.id" />
+  <GameOptionsModal
+    v-if="status.type === GameStatusEnum.Installed"
+    v-model="configureModalOpen"
+    :game-id="game.id"
+  />
 
   <Transition
     enter="transition ease-out duration-300"
@@ -420,7 +422,7 @@
           <img
             v-for="(url, index) in mediaUrls"
             v-show="currentImageIndex === index"
-            :key="url"
+            :key="index"
             :src="url"
             class="max-h-[90vh] max-w-[90vw] object-contain"
             :alt="`${game.mName} screenshot ${index + 1}`"
@@ -441,10 +443,6 @@
 
 <script setup lang="ts">
 import {
-  Dialog,
-  DialogTitle,
-  TransitionChild,
-  TransitionRoot,
   Listbox,
   ListboxButton,
   ListboxLabel,
@@ -482,7 +480,10 @@ const bannerUrl = await useObject(game.value.mBannerObjectId);
 
 // Get all available images
 const mediaUrls = await Promise.all(
-  game.value.mImageCarouselObjectIds.map((id) => useObject(id))
+  game.value.mImageCarouselObjectIds.map(async (v) => {
+    const src = await useObject(v);
+    return src;
+  })
 );
 
 const htmlDescription = micromark(game.value.mDescription);
@@ -496,7 +497,6 @@ const currentImageIndex = ref(0);
 
 const configureModalOpen = ref(false);
 
-
 async function installFlow() {
   installFlowOpen.value = true;
   versionOptions.value = undefined;
@@ -535,12 +535,11 @@ async function install() {
 }
 
 async function resumeDownload() {
-    try {
-      await invoke("resume_download", { gameId: game.value.id })
-    }
-    catch(e) {
-      console.error(e)
-    }
+  try {
+    await invoke("resume_download", { gameId: game.value.id });
+  } catch (e) {
+    console.error(e);
+  }
 }
 
 async function launch() {

src-tauri/Cargo.lock

@@ -1268,7 +1268,7 @@ dependencies = [
 
 [[package]]
 name = "drop-app"
-version = "0.3.0-rc-8"
+version = "0.3.0"
 dependencies = [
  "atomic-instant-full",
  "bitcode",

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "drop-app"
-version = "0.3.0-rc-8"
+version = "0.3.0"
 description = "The client application for the open-source, self-hosted game distribution platform Drop"
 authors = ["Drop OSS"]
 edition = "2024"

src-tauri/src/download_manager/download_manager_builder.rs

@@ -242,43 +242,47 @@ impl DownloadManagerBuilder {
         let app_handle = self.app_handle.clone();
 
         *download_thread_lock = Some(spawn(move || {
-            match download_agent.download(&app_handle) {
-                // Ok(true) is for completed and exited properly
-                Ok(true) => {
-                    debug!("download {:?} has completed", download_agent.metadata());
-                    match download_agent.validate() {
-                        Ok(true) => {
-                            download_agent.on_complete(&app_handle);
-                            sender
-                                .send(DownloadManagerSignal::Completed(download_agent.metadata()))
-                                .unwrap();
-                        }
-                        Ok(false) => {
-                            download_agent.on_incomplete(&app_handle);
-                        }
-                        Err(e) => {
-                            error!(
-                                "download {:?} has validation error {}",
-                                download_agent.metadata(),
-                                &e
-                            );
-                            download_agent.on_error(&app_handle, &e);
-                            sender.send(DownloadManagerSignal::Error(e)).unwrap();
-                        }
+            loop {
+                let download_result = match download_agent.download(&app_handle) {
+                    // Ok(true) is for completed and exited properly
+                    Ok(v) => v,
+                    Err(e) => {
+                        error!("download {:?} has error {}", download_agent.metadata(), &e);
+                        download_agent.on_error(&app_handle, &e);
+                        sender.send(DownloadManagerSignal::Error(e)).unwrap();
+                        return;
                     }
-                }
-                // Ok(false) is for incomplete but exited properly
-                Ok(false) => {
-                    debug!("Donwload agent finished incomplete");
+                };
+
+                // If the download gets cancel
+                if !download_result {
                     download_agent.on_incomplete(&app_handle);
+                    return;
                 }
-                Err(e) => {
-                    error!("download {:?} has error {}", download_agent.metadata(), &e);
-                    download_agent.on_error(&app_handle, &e);
-                    sender.send(DownloadManagerSignal::Error(e)).unwrap();
+
+                let validate_result = match download_agent.validate() {
+                    Ok(v) => v,
+                    Err(e) => {
+                        error!(
+                            "download {:?} has validation error {}",
+                            download_agent.metadata(),
+                            &e
+                        );
+                        download_agent.on_error(&app_handle, &e);
+                        sender.send(DownloadManagerSignal::Error(e)).unwrap();
+                        return;
+                    }
+                };
+
+                if validate_result {
+                    download_agent.on_complete(&app_handle);
+                    sender
+                        .send(DownloadManagerSignal::Completed(download_agent.metadata()))
+                        .unwrap();
+                    sender.send(DownloadManagerSignal::UpdateUIQueue).unwrap();
+                    return;
                 }
             }
-            sender.send(DownloadManagerSignal::UpdateUIQueue).unwrap();
         }));
 
         self.set_status(DownloadManagerStatus::Downloading);

src-tauri/src/error/process_error.rs

@@ -4,7 +4,6 @@ use serde_with::SerializeDisplay;
 
 #[derive(SerializeDisplay)]
 pub enum ProcessError {
-    SetupRequired,
     NotInstalled,
     AlreadyRunning,
     NotDownloaded,
@@ -19,7 +18,6 @@ pub enum ProcessError {
 impl Display for ProcessError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let s = match self {
-            ProcessError::SetupRequired => "Game not set up",
             ProcessError::NotInstalled => "Game not installed",
             ProcessError::AlreadyRunning => "Game already running",
             ProcessError::NotDownloaded => "Game not downloaded",

src-tauri/src/error/remote_access_error.rs

@@ -21,7 +21,7 @@ pub enum RemoteAccessError {
     UnparseableResponse(String),
     ManifestDownloadFailed(StatusCode, String),
     OutOfSync,
-    Cache(cacache::Error),
+    Cache(std::io::Error),
 }
 
 impl Display for RemoteAccessError {

src-tauri/src/games/downloads/download_agent.rs

@@ -18,7 +18,7 @@ use crate::remote::requests::make_request;
 use log::{debug, error, info};
 use rayon::ThreadPoolBuilder;
 use std::collections::HashMap;
-use std::fs::{create_dir_all, OpenOptions};
+use std::fs::{OpenOptions, create_dir_all};
 use std::path::{Path, PathBuf};
 use std::sync::mpsc::Sender;
 use std::sync::{Arc, Mutex};
@@ -26,7 +26,7 @@ use std::time::Instant;
 use tauri::{AppHandle, Emitter};
 
 #[cfg(target_os = "linux")]
-use rustix::fs::{fallocate, FallocateFlags};
+use rustix::fs::{FallocateFlags, fallocate};
 
 use super::download_logic::download_game_chunk;
 use super::drop_data::DropData;
@@ -187,10 +187,7 @@ impl GameDownloadAgent {
             self.generate_contexts()?;
         }
 
-        self.context_map
-            .lock()
-            .unwrap()
-            .extend(self.stored_manifest.get_contexts());
+        *self.context_map.lock().unwrap() = self.stored_manifest.get_contexts();
 
         Ok(())
     }
@@ -423,6 +420,7 @@ impl Downloadable for GameDownloadAgent {
             app_handle,
         )
         .unwrap();
+        println!("Attempting to redownload");
     }
 
     fn on_cancelled(&self, _app_handle: &tauri::AppHandle) {}

src-tauri/src/games/downloads/download_logic.rs

@@ -27,8 +27,9 @@ pub struct DropWriter<W: Write> {
 }
 impl DropWriter<File> {
     fn new(path: PathBuf) -> Self {
+        let destination = OpenOptions::new().write(true).create(true).truncate(false).open(&path).unwrap();
         Self {
-            destination: OpenOptions::new().write(true).open(path).unwrap(),
+            destination,
             hasher: Context::new(),
         }
     }

src-tauri/src/games/downloads/drop_data.rs

@@ -1,7 +1,5 @@
 use std::{
-    fs::File,
-    io::{Read, Write},
-    path::PathBuf,
+    collections::HashMap, fs::File, io::{Read, Write}, path::PathBuf
 };
 
 use log::{debug, error, info, warn};
@@ -12,7 +10,7 @@ pub type DropData = v1::DropData;
 static DROP_DATA_PATH: &str = ".dropdata";
 
 pub mod v1 {
-    use std::{path::PathBuf, sync::Mutex};
+    use std::{collections::HashMap, path::PathBuf, sync::Mutex};
 
     use native_model::native_model;
     use serde::{Deserialize, Serialize};
@@ -22,7 +20,7 @@ pub mod v1 {
     pub struct DropData {
         pub game_id: String,
         pub game_version: String,
-        pub contexts: Mutex<Vec<(String, bool)>>,
+        pub contexts: Mutex<HashMap<String, bool>>,
         pub base_path: PathBuf,
     }
 
@@ -32,7 +30,7 @@ pub mod v1 {
                 base_path,
                 game_id,
                 game_version,
-                contexts: Mutex::new(Vec::new()),
+                contexts: Mutex::new(HashMap::new()),
             }
         }
     }
@@ -85,20 +83,23 @@ impl DropData {
         };
     }
     pub fn set_contexts(&self, completed_contexts: &[(String, bool)]) {
-        *self.contexts.lock().unwrap() = completed_contexts.to_owned();
+        *self.contexts.lock().unwrap() = completed_contexts.iter().map(|s| (s.0.clone(), s.1)).collect();
+    }
+    pub fn set_context(&self, context: String, state: bool) {
+        self.contexts.lock().unwrap().entry(context).insert_entry(state);
     }
     pub fn get_completed_contexts(&self) -> Vec<String> {
         self.contexts
             .lock()
             .unwrap()
             .iter()
-            .filter_map(|x| if x.1 { Some(x.0.clone()) } else { None })
+            .filter_map(|x| if *x.1 { Some(x.0.clone()) } else { None })
             .collect()
     }
-    pub fn get_contexts(&self) -> Vec<(String, bool)> {
+    pub fn get_contexts(&self) -> HashMap<String, bool> {
         info!(
             "Any contexts which are complete? {}",
-            self.contexts.lock().unwrap().iter().any(|x| x.1)
+            self.contexts.lock().unwrap().iter().any(|x| *x.1)
         );
         self.contexts.lock().unwrap().clone()
     }

src-tauri/src/games/downloads/validate.rs

@@ -1,7 +1,7 @@
 use std::{
     fs::File,
     io::{self, BufWriter, Read, Seek, SeekFrom, Write},
-    sync::{mpsc::Sender, Arc},
+    sync::{Arc, mpsc::Sender},
 };
 
 use log::{debug, error, info};
@@ -73,6 +73,7 @@ pub fn game_validate_logic(
         }
     });
 
+
     // If there are any contexts left which are false
     if !invalid_chunks.is_empty() {
         info!(
@@ -80,6 +81,13 @@ pub fn game_validate_logic(
             dropdata.game_id.clone(),
             invalid_chunks
         );
+
+        for context in invalid_chunks.iter() {
+            dropdata.set_context(context.1.clone(), false);
+        }
+
+        dropdata.write();
+
         return Ok(false);
     }
 
@@ -101,7 +109,9 @@ pub fn validate_game_chunk(
         return Ok(false);
     }
 
-    let mut source = File::open(&ctx.path).unwrap();
+    let Ok(mut source) = File::open(&ctx.path) else {
+        return Ok(false);
+    };
 
     if ctx.offset != 0 {
         source

src-tauri/src/games/library.rs

@@ -113,7 +113,7 @@ pub fn fetch_library_logic(
         }
         // We should always have a cache of the object
         // Pass db_handle because otherwise we get a gridlock
-        let game = get_cached_object_db::<String, Game>(meta.id.clone(), &db_handle)?;
+        let game = get_cached_object_db::<Game>(&meta.id.clone(), &db_handle)?;
         games.push(game);
     }
 
@@ -173,7 +173,7 @@ pub fn fetch_game_logic(
             version,
         };
 
-        cache_object(id, game)?;
+        cache_object(&id, game)?;
 
         return Ok(data);
     }
@@ -212,7 +212,7 @@ pub fn fetch_game_logic(
         version,
     };
 
-    cache_object(id, &game)?;
+    cache_object(&id, &game)?;
 
     Ok(data)
 }
@@ -239,7 +239,7 @@ pub fn fetch_game_logic_offline(
     drop(handle);
 
     let status = GameStatusManager::fetch_state(&id);
-    let game = get_cached_object::<String, Game>(id)?;
+    let game = get_cached_object::<Game>(&id)?;
 
     Ok(FetchGameStruct {
         game,

src-tauri/src/lib.rs

@@ -13,6 +13,7 @@ mod remote;
 
 use crate::process::commands::open_process_logs;
 use crate::{database::db::DatabaseImpls, games::downloads::commands::resume_download};
+use bitcode::{Decode, Encode};
 use client::commands::fetch_state;
 use client::{
     autostart::{get_autostart_enabled, sync_autostart_on_startup, toggle_autostart},
@@ -22,7 +23,7 @@ use database::commands::{
     add_download_dir, delete_download_dir, fetch_download_dir_stats, fetch_settings,
     fetch_system_data, update_settings,
 };
-use database::db::{borrow_db_checked, borrow_db_mut_checked, DatabaseInterface, DATA_ROOT_DIR};
+use database::db::{DATA_ROOT_DIR, DatabaseInterface, borrow_db_checked, borrow_db_mut_checked};
 use database::models::data::GameDownloadStatus;
 use download_manager::commands::{
     cancel_game, move_download_in_queue, pause_downloads, resume_downloads,
@@ -37,13 +38,13 @@ use games::commands::{
     fetch_game, fetch_game_status, fetch_game_verion_options, fetch_library, uninstall_game,
 };
 use games::downloads::commands::download_game;
-use games::library::{update_game_configuration, Game};
-use log::{debug, info, warn, LevelFilter};
+use games::library::{Game, update_game_configuration};
+use log::{LevelFilter, debug, info, warn};
+use log4rs::Config;
 use log4rs::append::console::ConsoleAppender;
 use log4rs::append::file::FileAppender;
 use log4rs::config::{Appender, Root};
 use log4rs::encode::pattern::PatternEncoder;
-use log4rs::Config;
 use process::commands::{kill_game, launch_game};
 use process::process_manager::ProcessManager;
 use remote::auth::{self, recieve_handshake};
@@ -51,7 +52,7 @@ 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::fetch_object::fetch_object;
 use remote::server_proto::{handle_server_proto, handle_server_proto_offline};
 use serde::{Deserialize, Serialize};
 use std::fs::File;
@@ -71,7 +72,6 @@ use tauri::tray::TrayIconBuilder;
 use tauri::{AppHandle, Manager, RunEvent, WindowEvent};
 use tauri_plugin_deep_link::DeepLinkExt;
 use tauri_plugin_dialog::DialogExt;
-use bitcode::{Encode, Decode};
 
 #[derive(Clone, Copy, Serialize, Eq, PartialEq)]
 pub enum AppStatus {
@@ -401,15 +401,10 @@ pub fn run() {
 
             Ok(())
         })
-        .register_asynchronous_uri_scheme_protocol("object", move |ctx, request, responder| {
-            let state: tauri::State<'_, Mutex<AppState>> = ctx.app_handle().state();
-            offline!(
-                state,
-                fetch_object,
-                fetch_object_offline,
-                request,
-                responder
-            );
+        .register_asynchronous_uri_scheme_protocol("object", move |_ctx, request, responder| {
+            tauri::async_runtime::spawn(async move {
+                fetch_object(request, responder).await;
+            });
         })
         .register_asynchronous_uri_scheme_protocol("server", move |ctx, request, responder| {
             let state: tauri::State<'_, Mutex<AppState>> = ctx.app_handle().state();

src-tauri/src/process/process_manager.rs

@@ -181,9 +181,7 @@ impl ProcessManager<'_> {
             .cloned()
         {
             Some(GameDownloadStatus::Installed { version_name, .. }) => version_name,
-            Some(GameDownloadStatus::SetupRequired { .. }) => {
-                return Err(ProcessError::SetupRequired);
-            }
+            Some(GameDownloadStatus::SetupRequired { version_name, .. }) => version_name,
             _ => return Err(ProcessError::NotInstalled),
         };
         let meta = DownloadableMetadata {

src-tauri/src/remote/auth.rs

@@ -212,7 +212,7 @@ pub fn setup() -> (AppStatus, Option<User>) {
         let user_result = match fetch_user() {
             Ok(data) => data,
             Err(RemoteAccessError::FetchError(_)) => {
-                let user = get_cached_object::<_, User>("user").unwrap();
+                let user = get_cached_object::<User>("user").unwrap();
                 return (AppStatus::Offline, Some(user));
             }
             Err(_) => return (AppStatus::SignedInNeedsReauth, None),

src-tauri/src/remote/cache.rs

@@ -1,6 +1,8 @@
 use std::{
-    fmt::Display,
-    time::{Duration, SystemTime},
+    fs::File,
+    io::{self, Write},
+    path::{Path, PathBuf},
+    time::SystemTime,
 };
 
 use crate::{
@@ -8,8 +10,8 @@ use crate::{
     error::remote_access_error::RemoteAccessError,
 };
 use bitcode::{Decode, DecodeOwned, Encode};
-use cacache::Integrity;
 use http::{Response, header::CONTENT_TYPE, response::Builder as ResponseBuilder};
+use log::debug;
 
 #[macro_export]
 macro_rules! offline {
@@ -23,47 +25,67 @@ macro_rules! offline {
     }
 }
 
-pub fn cache_object<K: AsRef<str>, D: Encode>(
-    key: K,
-    data: &D,
-) -> Result<Integrity, RemoteAccessError> {
+fn get_sys_time_in_secs() -> u64 {
+    match SystemTime::now().duration_since(SystemTime::UNIX_EPOCH) {
+        Ok(n) => n.as_secs(),
+        Err(_) => panic!("SystemTime before UNIX EPOCH!"),
+    }
+}
+
+fn get_cache_path(base: &Path, key: &str) -> PathBuf {
+    let key_hash = hex::encode(md5::compute(key.as_bytes()).0);
+    base.join(key_hash)
+}
+
+fn write_sync(base: &Path, key: &str, data: Vec<u8>) -> io::Result<()> {
+    let cache_path = get_cache_path(base, key);
+    let mut file = File::create(cache_path)?;
+    file.write_all(&data)?;
+    Ok(())
+}
+
+fn read_sync(base: &Path, key: &str) -> io::Result<Vec<u8>> {
+    let cache_path = get_cache_path(base, key);
+    let file = std::fs::read(cache_path)?;
+    Ok(file)
+}
+
+pub fn cache_object<D: Encode>(key: &str, data: &D) -> Result<(), RemoteAccessError> {
     let bytes = bitcode::encode(data);
-    cacache::write_sync(&borrow_db_checked().cache_dir, key, bytes)
-        .map_err(RemoteAccessError::Cache)
+    write_sync(&borrow_db_checked().cache_dir, key, bytes).map_err(RemoteAccessError::Cache)
 }
-pub fn get_cached_object<K: AsRef<str> + Display, D: Encode + DecodeOwned>(
-    key: K,
-) -> Result<D, RemoteAccessError> {
-    get_cached_object_db::<K, D>(key, &borrow_db_checked())
+pub fn get_cached_object<D: Encode + DecodeOwned>(key: &str) -> Result<D, RemoteAccessError> {
+    get_cached_object_db::<D>(key, &borrow_db_checked())
 }
-pub fn get_cached_object_db<K: AsRef<str> + Display, D: DecodeOwned>(
-    key: K,
+pub fn get_cached_object_db<D: DecodeOwned>(
+    key: &str,
     db: &Database,
 ) -> Result<D, RemoteAccessError> {
-    let bytes = cacache::read_sync(&db.cache_dir, &key).map_err(RemoteAccessError::Cache)?;
-    let data = bitcode::decode::<D>(&bytes).map_err(|_| {
-        RemoteAccessError::Cache(cacache::Error::EntryNotFound(
-            db.cache_dir.clone(),
-            key.to_string(),
-        ))
-    })?;
+    let start = SystemTime::now();
+    let bytes = read_sync(&db.cache_dir, key).map_err(RemoteAccessError::Cache)?;
+    let read = start.elapsed().unwrap();
+    let data =
+        bitcode::decode::<D>(&bytes).map_err(|e| RemoteAccessError::Cache(io::Error::other(e)))?;
+    let decode = start.elapsed().unwrap();
+    debug!(
+        "cache object took: r:{}, d:{}, b:{}",
+        read.as_millis(),
+        read.abs_diff(decode).as_millis(),
+        bytes.len()
+    );
     Ok(data)
 }
 #[derive(Encode, Decode)]
 pub struct ObjectCache {
     content_type: String,
     body: Vec<u8>,
-    expiry: u128,
+    expiry: u64,
 }
 
 impl ObjectCache {
     pub fn has_expired(&self) -> bool {
-        let duration = Duration::from_millis(self.expiry.try_into().unwrap());
-        SystemTime::UNIX_EPOCH
-            .checked_add(duration)
-            .unwrap()
-            .elapsed()
-            .is_err()
+        let current = get_sys_time_in_secs();
+        self.expiry < current
     }
 }
 
@@ -78,12 +100,7 @@ impl From<Response<Vec<u8>>> for ObjectCache {
                 .unwrap()
                 .to_owned(),
             body: value.body().clone(),
-            expiry: SystemTime::now()
-                .checked_add(Duration::from_days(1))
-                .unwrap()
-                .duration_since(SystemTime::UNIX_EPOCH)
-                .unwrap()
-                .as_millis(),
+            expiry: get_sys_time_in_secs() + 60 * 60 * 24,
         }
     }
 }

src-tauri/src/remote/commands.rs

@@ -55,7 +55,7 @@ pub fn fetch_drop_object(path: String) -> Result<Vec<u8>, RemoteAccessError> {
         }
         Err(e) => {
             debug!("{e}");
-            get_cached_object::<&str, Vec<u8>>(&path)
+            get_cached_object::<Vec<u8>>(&path)
         }
     }
 }

src-tauri/src/remote/fetch_object.rs

@@ -2,17 +2,18 @@ use http::{header::CONTENT_TYPE, response::Builder as ResponseBuilder};
 use log::warn;
 use tauri::UriSchemeResponder;
 
+use crate::{DB, database::db::DatabaseImpls};
+
 use super::{
     auth::generate_authorization_header,
-    cache::{cache_object, get_cached_object, ObjectCache},
-    requests::make_request,
+    cache::{ObjectCache, cache_object, get_cached_object},
 };
 
-pub fn fetch_object(request: http::Request<Vec<u8>>, responder: UriSchemeResponder) {
+pub async fn fetch_object(request: http::Request<Vec<u8>>, responder: UriSchemeResponder) {
     // Drop leading /
     let object_id = &request.uri().path()[1..];
 
-    let cache_result = get_cached_object::<&str, ObjectCache>(object_id);
+    let cache_result = get_cached_object::<ObjectCache>(object_id);
     if let Ok(cache_result) = &cache_result
         && !cache_result.has_expired()
     {
@@ -21,12 +22,10 @@ pub fn fetch_object(request: http::Request<Vec<u8>>, responder: UriSchemeRespond
     }
 
     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();
+    let client = reqwest::Client::new();
+    let url = format!("{}api/v1/client/object/{object_id}", DB.fetch_base_url());
+    let response = client.get(url).header("Authorization", header).send().await;
+
     if response.is_err() {
         match cache_result {
             Ok(cache_result) => responder.respond(cache_result.into()),
@@ -42,20 +41,11 @@ pub fn fetch_object(request: http::Request<Vec<u8>>, responder: UriSchemeRespond
         CONTENT_TYPE,
         response.headers().get("Content-Type").unwrap(),
     );
-    let data = Vec::from(response.bytes().unwrap());
+    let data = Vec::from(response.bytes().await.unwrap());
     let resp = resp_builder.body(data).unwrap();
     if cache_result.is_err() || cache_result.unwrap().has_expired() {
-        cache_object::<&str, ObjectCache>(object_id, &resp.clone().into()).unwrap();
+        cache_object::<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/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2.0.0",
   "productName": "Drop Desktop Client",
-  "version": "0.3.0-rc-8",
+  "version": "0.3.0",
   "identifier": "dev.drop.app",
   "build": {
     "beforeDevCommand": "yarn dev --port 1432",
@@ -11,7 +11,7 @@
   },
   "app": {
     "security": {
-      "csp": null,
+      "csp": "",
       "assetProtocol": {
         "enable": true,
         "scope": {}