chore: commit changes, still bad

* fix: launching on linux

* feat: #70

* feat: add dummy store page

* feat: add store redir and refresh button to library

* feat: cache first object fetching

* feat: Remove let_chains feature and update to Rust 2024

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

* feat: Check for if process was manually stopped

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

* fix: use bitcode instead of serde

* chore: remove logs

* fix: clippy

* fix: clippy 2

* fix: swap to stop icon

---------

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

.github/workflows/clippy.yml

@@ -0,0 +1,23 @@
+on: push
+name: Clippy check
+jobs:
+  clippy_check:
+    runs-on: ubuntu-24.04
+    permissions:
+      checks: write
+    steps:
+      - uses: actions/checkout@v1
+      - name: install dependencies (ubuntu only)
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libglib2.0-dev libgtk-3-dev libwebkit2gtk-4.1-dev
+
+      - uses: actions-rs/toolchain@v1
+        with:
+            toolchain: nightly
+            components: clippy
+            override: true
+      - uses: actions-rs/clippy-check@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --manifest-path ./src-tauri/Cargo.toml

.github/workflows/release.yml

@@ -22,9 +22,9 @@ jobs:
             args: '--target aarch64-apple-darwin'
           - platform: 'macos-latest' # for Intel based macs.
             args: '--target x86_64-apple-darwin'
-          - platform: 'ubuntu-24.04' # for Tauri v1 you could replace this with ubuntu-20.04.
+          - platform: 'ubuntu-22.04' # for Tauri v1 you could replace this with ubuntu-20.04.
             args: ''
-          - platform: 'ubuntu-24.04-arm'
+          - platform: 'ubuntu-22.04-arm'
             args: '--target aarch64-unknown-linux-gnu'
           - platform: 'windows-latest'
             args: ''
@@ -48,12 +48,11 @@ jobs:
           targets: ${{ matrix.platform == 'macos-latest' && 'aarch64-apple-darwin,x86_64-apple-darwin' || '' }}
 
       - name: install dependencies (ubuntu only)
-        if: matrix.platform == 'ubuntu-22.04' # This must match the platform value defined above.
+        if: matrix.platform == 'ubuntu-22.04' || matrix.platform == 'ubuntu-22.04-arm' # This must match the platform value defined above.
         run: |
           sudo apt-get update
-          sudo apt-get install -y libwebkit2gtk-4.0-dev libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf libgtk2.0-dev libsoup3.0-dev
+          sudo apt-get install -y libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf
         # webkitgtk 4.0 is for Tauri v1 - webkitgtk 4.1 is for Tauri v2.
-        # You can remove the one that doesn't apply to your app to speed up the workflow a bit.
 
       - name: install frontend dependencies
         run: yarn install # change this to npm, pnpm or bun depending on which one you use.

README.md

@@ -4,7 +4,7 @@ Drop app is the companion app for [Drop](https://github.com/Drop-OSS/drop). It u
 
 ## Running
 Before setting up the drop app, be sure that you have a server set up. 
-The instructions for this can be found on the [Drop Wiki](https://wiki.droposs.org/guides/quickstart.html)
+The instructions for this can be found on the [Drop Docs](https://docs.droposs.org/docs/guides/quickstart)
 
 ## Current features
 Currently supported are the following features:

app.vue

@@ -22,6 +22,7 @@ const router = useRouter();
 const state = useAppState();
 try {
   state.value = JSON.parse(await invoke("fetch_state"));
+  console.log(state.value)
 } catch (e) {
   console.error("failed to parse state", e);
 }

components/GameStatusButton.vue

@@ -1,78 +1,52 @@
 <template>
   <!-- Do not add scale animations to this: https://stackoverflow.com/a/35683068 -->
   <div class="inline-flex divide-x divide-zinc-900">
-    <button
-      type="button"
-      @click="() => buttonActions[props.status.type]()"
-      :class="[
-        styles[props.status.type],
-        showDropdown ? 'rounded-l-md' : 'rounded-md',
-        'inline-flex uppercase font-display items-center gap-x-2 px-4 py-3 text-md font-semibold shadow-sm focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2',
-      ]"
-    >
-      <component
-        :is="buttonIcons[props.status.type]"
-        class="-mr-0.5 size-5"
-        aria-hidden="true"
-      />
+    <button type="button" @click="() => buttonActions[props.status.type]()" :class="[
+      styles[props.status.type],
+      showDropdown ? 'rounded-l-md' : 'rounded-md',
+      'inline-flex uppercase font-display items-center gap-x-2 px-4 py-3 text-md font-semibold shadow-sm focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2',
+    ]">
+      <component :is="buttonIcons[props.status.type]" class="-mr-0.5 size-5" aria-hidden="true" />
       {{ buttonNames[props.status.type] }}
     </button>
-    <Menu
-      v-if="showDropdown"
-      as="div"
-      class="relative inline-block text-left grow"
-    >
+    <Menu v-if="showDropdown" as="div" class="relative inline-block text-left grow">
       <div class="h-full">
-        <MenuButton
-          :class="[
-            styles[props.status.type],
-            'inline-flex w-full h-full justify-center items-center rounded-r-md px-1 py-2 text-sm font-semibold shadow-sm group',
-            'focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2',
-          ]"
-        >
+        <MenuButton :class="[
+          styles[props.status.type],
+          'inline-flex w-full h-full justify-center items-center rounded-r-md px-1 py-2 text-sm font-semibold shadow-sm group',
+          'focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2',
+        ]">
           <ChevronDownIcon class="size-5" aria-hidden="true" />
         </MenuButton>
       </div>
 
-      <transition
-        enter-active-class="transition ease-out duration-100"
-        enter-from-class="transform opacity-0 scale-95"
-        enter-to-class="transform opacity-100 scale-100"
-        leave-active-class="transition ease-in duration-75"
-        leave-from-class="transform opacity-100 scale-100"
-        leave-to-class="transform opacity-0 scale-95"
-      >
+      <transition enter-active-class="transition ease-out duration-100" enter-from-class="transform opacity-0 scale-95"
+        enter-to-class="transform opacity-100 scale-100" leave-active-class="transition ease-in duration-75"
+        leave-from-class="transform opacity-100 scale-100" leave-to-class="transform opacity-0 scale-95">
         <MenuItems
-          class="absolute right-0 z-[500] mt-2 w-32 origin-top-right rounded-md bg-zinc-900 shadow-lg ring-1 ring-zinc-100/5 focus:outline-none"
-        >
+          class="absolute right-0 z-[500] mt-2 w-32 origin-top-right rounded-md bg-zinc-900 shadow-lg ring-1 ring-zinc-100/5 focus:outline-none">
           <div class="py-1">
             <MenuItem v-slot="{ active }">
-              <button
-                @click="() => emit('options')"
-                :class="[
-                  active
-                    ? 'bg-zinc-800 text-zinc-100 outline-none'
-                    : 'text-zinc-400',
-                  'w-full block px-4 py-2 text-sm inline-flex justify-between',
-                ]"
-              >
-                Options
-                <Cog6ToothIcon class="size-5" />
-              </button>
+            <button @click="() => emit('options')" :class="[
+              active
+                ? 'bg-zinc-800 text-zinc-100 outline-none'
+                : 'text-zinc-400',
+              'w-full block px-4 py-2 text-sm inline-flex justify-between',
+            ]">
+              Options
+              <Cog6ToothIcon class="size-5" />
+            </button>
             </MenuItem>
             <MenuItem v-slot="{ active }">
-              <button
-                @click="() => emit('uninstall')"
-                :class="[
-                  active
-                    ? 'bg-zinc-800 text-zinc-100 outline-none'
-                    : 'text-zinc-400',
-                  'w-full block px-4 py-2 text-sm inline-flex justify-between',
-                ]"
-              >
-                Uninstall
-                <TrashIcon class="size-5" />
-              </button>
+            <button @click="() => emit('uninstall')" :class="[
+              active
+                ? 'bg-zinc-800 text-zinc-100 outline-none'
+                : 'text-zinc-400',
+              'w-full block px-4 py-2 text-sm inline-flex justify-between',
+            ]">
+              Uninstall
+              <TrashIcon class="size-5" />
+            </button>
             </MenuItem>
           </div>
         </MenuItems>
@@ -87,6 +61,7 @@ import {
   ChevronDownIcon,
   PlayIcon,
   QueueListIcon,
+  StopIcon,
   WrenchIcon,
 } from "@heroicons/vue/20/solid";
 
@@ -103,12 +78,14 @@ const emit = defineEmits<{
   (e: "uninstall"): void;
   (e: "kill"): void;
   (e: "options"): void;
+  (e: "resume"): void
 }>();
 
 const showDropdown = computed(
   () =>
     props.status.type === GameStatusEnum.Installed ||
-    props.status.type === GameStatusEnum.SetupRequired
+    props.status.type === GameStatusEnum.SetupRequired ||
+    props.status.type === GameStatusEnum.PartiallyInstalled
 );
 
 const styles: { [key in GameStatusEnum]: string } = {
@@ -128,6 +105,8 @@ const styles: { [key in GameStatusEnum]: string } = {
     "bg-zinc-800 text-white hover:bg-zinc-700 focus-visible:outline-zinc-700 hover:bg-zinc-700",
   [GameStatusEnum.Running]:
     "bg-zinc-800 text-white hover:bg-zinc-700 focus-visible:outline-zinc-700 hover:bg-zinc-700",
+  [GameStatusEnum.PartiallyInstalled]:
+    "bg-gray-600 text-white hover:bg-gray-500 focus-visible:outline-gray-600 hover:bg-gray-500"
 };
 
 const buttonNames: { [key in GameStatusEnum]: string } = {
@@ -139,6 +118,7 @@ const buttonNames: { [key in GameStatusEnum]: string } = {
   [GameStatusEnum.Updating]: "Updating",
   [GameStatusEnum.Uninstalling]: "Uninstalling",
   [GameStatusEnum.Running]: "Stop",
+  [GameStatusEnum.PartiallyInstalled]: "Resume"
 };
 
 const buttonIcons: { [key in GameStatusEnum]: Component } = {
@@ -149,7 +129,8 @@ const buttonIcons: { [key in GameStatusEnum]: Component } = {
   [GameStatusEnum.Installed]: PlayIcon,
   [GameStatusEnum.Updating]: ArrowDownTrayIcon,
   [GameStatusEnum.Uninstalling]: TrashIcon,
-  [GameStatusEnum.Running]: PlayIcon,
+  [GameStatusEnum.Running]: StopIcon,
+  [GameStatusEnum.PartiallyInstalled]: ArrowDownTrayIcon
 };
 
 const buttonActions: { [key in GameStatusEnum]: () => void } = {
@@ -159,7 +140,8 @@ const buttonActions: { [key in GameStatusEnum]: () => void } = {
   [GameStatusEnum.SetupRequired]: () => emit("launch"),
   [GameStatusEnum.Installed]: () => emit("launch"),
   [GameStatusEnum.Updating]: () => emit("queue"),
-  [GameStatusEnum.Uninstalling]: () => {},
+  [GameStatusEnum.Uninstalling]: () => { },
   [GameStatusEnum.Running]: () => emit("kill"),
+  [GameStatusEnum.PartiallyInstalled]: () => emit("resume")
 };
 </script>

components/LibrarySearch.vue

@@ -1,19 +1,30 @@
 <template>
   <div>
-    <div
-      class="relative mb-3 transition-transform duration-300 hover:scale-105 active:scale-95"
-    >
+    <div class="mb-3 inline-flex gap-x-2">
       <div
-        class="pointer-events-none absolute inset-y-0 left-0 flex items-center pl-3"
+        class="relative transition-transform duration-300 hover:scale-105 active:scale-95"
       >
-        <MagnifyingGlassIcon class="h-5 w-5 text-zinc-400" aria-hidden="true" />
+        <div
+          class="pointer-events-none absolute inset-y-0 left-0 flex items-center pl-3"
+        >
+          <MagnifyingGlassIcon
+            class="h-5 w-5 text-zinc-400"
+            aria-hidden="true"
+          />
+        </div>
+        <input
+          type="text"
+          v-model="searchQuery"
+          class="block w-full rounded-lg border-0 bg-zinc-800/50 py-2 pl-10 pr-3 text-zinc-100 placeholder:text-zinc-500 focus:bg-zinc-800 focus:ring-2 focus:ring-inset focus:ring-blue-500 sm:text-sm sm:leading-6"
+          placeholder="Search library..."
+        />
       </div>
-      <input
-        type="text"
-        v-model="searchQuery"
-        class="block w-full rounded-lg border-0 bg-zinc-800/50 py-2 pl-10 pr-3 text-zinc-100 placeholder:text-zinc-500 focus:bg-zinc-800 focus:ring-2 focus:ring-inset focus:ring-blue-500 sm:text-sm sm:leading-6"
-        placeholder="Search library..."
-      />
+      <button
+        @click="() => calculateGames(true)"
+        class="p-1 flex items-center justify-center transition-transform duration-300 size-10 hover:scale-110 active:scale-90 rounded-lg bg-zinc-800/50 text-zinc-100"
+      >
+        <ArrowPathIcon class="size-4" />
+      </button>
     </div>
 
     <TransitionGroup name="list" tag="ul" class="flex flex-col gap-y-1.5">
@@ -60,7 +71,7 @@
 </template>
 
 <script setup lang="ts">
-import { MagnifyingGlassIcon } from "@heroicons/vue/20/solid";
+import { ArrowPathIcon, MagnifyingGlassIcon } from "@heroicons/vue/20/solid";
 import { invoke } from "@tauri-apps/api/core";
 import { GameStatusEnum, type Game, type GameStatus } from "~/types";
 import { TransitionGroup } from "vue";
@@ -76,6 +87,7 @@ const gameStatusTextStyle: { [key in GameStatusEnum]: string } = {
   [GameStatusEnum.Updating]: "text-blue-500",
   [GameStatusEnum.Uninstalling]: "text-zinc-100",
   [GameStatusEnum.SetupRequired]: "text-yellow-500",
+  [GameStatusEnum.PartiallyInstalled]: "text-gray-600",
 };
 const gameStatusText: { [key in GameStatusEnum]: string } = {
   [GameStatusEnum.Remote]: "Not installed",
@@ -86,6 +98,7 @@ const gameStatusText: { [key in GameStatusEnum]: string } = {
   [GameStatusEnum.Uninstalling]: "Uninstalling...",
   [GameStatusEnum.SetupRequired]: "Setup required",
   [GameStatusEnum.Running]: "Running",
+  [GameStatusEnum.PartiallyInstalled]: "Partially installed",
 };
 
 const router = useRouter();
@@ -99,16 +112,20 @@ const icons: { [key: string]: string } = {};
 
 const rawGames: Ref<Game[], Game[]> = ref([]);
 
-async function calculateGames() {
-  rawGames.value = await invoke("fetch_library");
-  for (const game of rawGames.value) {
+async function calculateGames(clearAll = false) {
+  if (clearAll) rawGames.value = [];
+  // If we update immediately, the navigation gets re-rendered before we
+  // add all the necessary state, and it freaks tf out
+  const newGames = await invoke<typeof rawGames.value>("fetch_library");
+  for (const game of newGames) {
     if (games[game.id]) continue;
     games[game.id] = await useGame(game.id);
   }
-  for (const game of rawGames.value) {
+  for (const game of newGames) {
     if (icons[game.id]) continue;
     icons[game.id] = await useObject(game.mIconObjectId);
   }
+  rawGames.value = newGames;
 }
 
 await calculateGames();

composables/game.ts

@@ -14,7 +14,6 @@ export type SerializedGameStatus = [
 ];
 
 export const parseStatus = (status: SerializedGameStatus): GameStatus => {
-  console.log(status);
   if (status[0]) {
     return {
       type: status[0].type,
@@ -48,7 +47,6 @@ export const useGame = async (gameId: string) => {
           status: SerializedGameStatus;
           version?: GameVersion;
         } = event.payload as any;
-        console.log(payload.status);
         gameStatusRegistry[gameId].value = parseStatus(payload.status);
         
         /**

composables/state-navigation.ts

@@ -1,9 +1,11 @@
+import { invoke } from "@tauri-apps/api/core";
 import { listen } from "@tauri-apps/api/event";
 import { data } from "autoprefixer";
 import { AppStatus, type AppState } from "~/types";
 
 export function setupHooks() {
   const router = useRouter();
+  const state = useAppState();
 
   listen("auth/processing", (event) => {
     router.push("/auth/processing");
@@ -15,8 +17,9 @@ export function setupHooks() {
     );
   });
 
-  listen("auth/finished", (event) => {
-    router.push("/store");
+  listen("auth/finished", async (event) => {
+    router.push("/library");
+    state.value = JSON.parse(await invoke("fetch_state"));
   });
 
   listen("download_error", (event) => {
@@ -27,12 +30,31 @@ export function setupHooks() {
         description: `Drop encountered an error while downloading your game: "${(
           event.payload as unknown as string
         ).toString()}"`,
-        buttonText: "Close"
+        buttonText: "Close",
       },
       (e, c) => c()
     );
   });
 
+  // This is for errors that (we think) aren't our fault
+  listen("launch_external_error", (event) => {
+    createModal(
+      ModalType.Confirmation,
+      {
+        title: "Did something go wrong?",
+        description:
+          "Drop detected that something might've gone wrong with launching your game. Do you want to open the log directory?",
+        buttonText: "Open",
+      },
+      async (e, c) => {
+        if (e == "confirm") {
+          await invoke("open_process_logs", { gameId: event.payload });
+        }
+        c();
+      }
+    );
+  });
+
   /*
 
   document.addEventListener("contextmenu", (event) => {
@@ -60,6 +82,6 @@ export function initialNavigation(state: Ref<AppState>) {
       router.push("/error/serverunavailable");
       break;
     default:
-      router.push("/store");
+      router.push("/library");
   }
 }

package.json

@@ -1,7 +1,7 @@
 {
   "name": "drop-app",
   "private": true,
-  "version": "0.3.0-rc-2",
+  "version": "0.3.0-rc-8",
   "type": "module",
   "scripts": {
     "build": "nuxt build",
@@ -18,6 +18,7 @@
     "@tauri-apps/api": ">=2.0.0",
     "@tauri-apps/plugin-deep-link": "~2",
     "@tauri-apps/plugin-dialog": "^2.0.1",
+    "@tauri-apps/plugin-opener": "^2.4.0",
     "@tauri-apps/plugin-os": "~2",
     "@tauri-apps/plugin-shell": "^2.2.1",
     "koa": "^2.16.1",

pages/library/[id]/index.vue

@@ -32,6 +32,7 @@
             @uninstall="() => uninstall()"
             @kill="() => kill()"
             @options="() => (configureModalOpen = true)"
+            @resume="() => resumeDownload()"
             :status="status"
           />
           <a
@@ -77,6 +78,7 @@
                           v-for="(url, index) in mediaUrls"
                           :key="url"
                           :src="url"
+                          loading="lazy"
                           class="absolute inset-0 w-full h-full object-cover"
                           v-show="index === currentImageIndex"
                         />
@@ -495,6 +497,7 @@ const currentImageIndex = ref(0);
 
 const configureModalOpen = ref(false);
 
+
 async function installFlow() {
   installFlowOpen.value = true;
   versionOptions.value = undefined;
@@ -532,6 +535,15 @@ async function install() {
   installLoading.value = false;
 }
 
+async function resumeDownload() {
+    try {
+      await invoke("resume_download", { gameId: game.value.id })
+    }
+    catch(e) {
+      console.error(e)
+    }
+}
+
 async function launch() {
   try {
     await invoke("launch_game", { id: game.value.id });

pages/queue.vue

@@ -91,7 +91,12 @@
 <script setup lang="ts">
 import { ServerIcon, XMarkIcon } from "@heroicons/vue/20/solid";
 import { invoke } from "@tauri-apps/api/core";
-import type { DownloadableMetadata, Game, GameStatus } from "~/types";
+import { GameStatusEnum, type DownloadableMetadata, type Game, type GameStatus } from "~/types";
+
+// const actionNames = {
+//   [GameStatusEnum.Downloading]: "downloading",
+//   [GameStatusEnum.Verifying]: "verifying",
+// }
 
 const windowWidth = ref(window.innerWidth);
 window.addEventListener("resize", (event) => {

pages/settings/debug.vue

@@ -106,8 +106,6 @@ const systemData = await invoke<{
   dataDir: string;
 }>("fetch_system_data");
 
-console.log(systemData);
-
 clientId.value = systemData.clientId;
 baseUrl.value = systemData.baseUrl;
 dataDir.value = systemData.dataDir;

pages/store/index.vue

@@ -1,4 +1,37 @@
 <template>
-  <iframe src="server://drop.local/store" class="w-full h-full" />
+  <div class="grow w-full h-full flex items-center justify-center">
+    <div class="flex flex-col items-center">
+      <BuildingStorefrontIcon
+        class="h-12 w-12 text-blue-600"
+        aria-hidden="true"
+      />
+      <div class="mt-3 text-center sm:mt-5">
+        <h1 class="text-3xl font-semibold font-display leading-6 text-zinc-100">
+          Store not supported in client
+        </h1>
+        <div class="mt-4">
+          <p class="text-sm text-zinc-400 max-w-lg">
+            Currently, Drop requires you to view the store in your browser.
+            Please click the button below to open it in your default browser.
+          </p>
+          <NuxtLink
+            :href="storeUrl"
+            target="_blank"
+            class="mt-6 transition text-sm/6 font-semibold text-zinc-400 hover:text-zinc-100 inline-flex gap-x-2 items-center duration-200 hover:scale-105"
+          >
+            Open Store <ArrowTopRightOnSquareIcon class="size-4" />
+          </NuxtLink>
+        </div>
+      </div>
+    </div>
+  </div>
 </template>
-<script setup lang="ts"></script>
+<script setup lang="ts">
+import {
+  ArrowTopRightOnSquareIcon,
+  BuildingStorefrontIcon,
+} from "@heroicons/vue/20/solid";
+import { invoke } from "@tauri-apps/api/core";
+
+const storeUrl = await invoke<string>("gen_drop_url", { path: "/store" });
+</script>

src-tauri/Cargo.toml

@@ -1,9 +1,9 @@
 [package]
 name = "drop-app"
-version = "0.3.0-rc-2"
+version = "0.3.0-rc-8"
 description = "The client application for the open-source, self-hosted game distribution platform Drop"
 authors = ["Drop OSS"]
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -25,8 +25,6 @@ tauri-build = { version = "2.0.0", features = [] }
 [dependencies]
 tauri-plugin-shell = "2.2.1"
 serde_json = "1"
-serde-binary = "0.5.0"
-rayon = "1.10.0"
 webbrowser = "1.0.2"
 url = "2.5.2"
 tauri-plugin-deep-link = "2"
@@ -67,6 +65,13 @@ filetime = "0.2.25"
 walkdir = "2.5.0"
 known-folders = "1.2.0"
 native_model = { version = "0.6.1", features = ["rmp_serde_1_3"] }
+tauri-plugin-opener = "2.4.0"
+bitcode = "0.6.6"
+async-trait = "0.1.88"
+futures = "0.3.31"
+tokio-util = { version = "0.7.15", features = ["io"] }
+async-scoped = { version = "0.9.0", features = ["use-tokio"] }
+async-once-cell = "0.5.4"
 # tailscale = { path = "./tailscale" }
 
 [dependencies.dynfmt]
@@ -75,7 +80,7 @@ features = ["curly"]
 
 [dependencies.tauri]
 version = "2.1.1"
-features = ["tray-icon"]
+features = ["protocol-asset", "tray-icon"]
 
 [dependencies.tokio]
 version = "1.40.0"
@@ -93,14 +98,14 @@ features = ["fs"]
 version = "1.10.0"
 features = ["v4", "fast-rng", "macro-diagnostics"]
 
-[dependencies.rustbreak]
-version = "2"
-features = ["other_errors"] # You can also use "yaml_enc" or "bin_enc"
+[dependencies.dropbreak]
+git = "https://github.com/Drop-OSS/dropbreak.git"
+features = ["other_errors"]                       # You can also use "yaml_enc" or "bin_enc"
 
 [dependencies.reqwest]
 version = "0.12"
 default-features = false
-features = ["json", "http2", "blocking", "rustls-tls-webpki-roots"]
+features = ["json", "http2", "rustls-tls-webpki-roots", "stream"]
 
 [dependencies.serde]
 version = "1"

src-tauri/capabilities/default.json

@@ -14,6 +14,7 @@
     "core:window:allow-close",
     "deep-link:default",
     "dialog:default",
-    "os:default"
+    "os:default",
+    "opener:default"
   ]
 }

src-tauri/src/client/autostart.rs

@@ -1,9 +1,9 @@
-use crate::database::db::{borrow_db_checked, borrow_db_mut_checked, save_db};
+use crate::database::db::{borrow_db_checked, borrow_db_mut_checked};
 use log::debug;
 use tauri::AppHandle;
 use tauri_plugin_autostart::ManagerExt;
 
-pub fn toggle_autostart_logic(app: AppHandle, enabled: bool) -> Result<(), String> {
+pub async fn toggle_autostart_logic(app: AppHandle, enabled: bool) -> Result<(), String> {
     let manager = app.autolaunch();
     if enabled {
         manager.enable().map_err(|e| e.to_string())?;
@@ -14,17 +14,18 @@ pub fn toggle_autostart_logic(app: AppHandle, enabled: bool) -> Result<(), Strin
     }
 
     // Store the state in DB
-    let mut db_handle = borrow_db_mut_checked();
+    let mut db_handle = borrow_db_mut_checked().await;
     db_handle.settings.autostart = enabled;
     drop(db_handle);
-    save_db();
 
     Ok(())
 }
 
-pub fn get_autostart_enabled_logic(app: AppHandle) -> Result<bool, tauri_plugin_autostart::Error> {
+pub async fn get_autostart_enabled_logic(
+    app: AppHandle,
+) -> Result<bool, tauri_plugin_autostart::Error> {
     // First check DB state
-    let db_handle = borrow_db_checked();
+    let db_handle = borrow_db_checked().await;
     let db_state = db_handle.settings.autostart;
     drop(db_handle);
 
@@ -45,8 +46,8 @@ pub fn get_autostart_enabled_logic(app: AppHandle) -> Result<bool, tauri_plugin_
 }
 
 // New function to sync state on startup
-pub fn sync_autostart_on_startup(app: &AppHandle) -> Result<(), String> {
-    let db_handle = borrow_db_checked();
+pub async fn sync_autostart_on_startup(app: &AppHandle) -> Result<(), String> {
+    let db_handle = borrow_db_checked().await;
     let should_be_enabled = db_handle.settings.autostart;
     drop(db_handle);
 
@@ -66,11 +67,11 @@ pub fn sync_autostart_on_startup(app: &AppHandle) -> Result<(), String> {
     Ok(())
 }
 #[tauri::command]
-pub fn toggle_autostart(app: AppHandle, enabled: bool) -> Result<(), String> {
-    toggle_autostart_logic(app, enabled)
+pub async fn toggle_autostart(app: AppHandle, enabled: bool) -> Result<(), String> {
+    toggle_autostart_logic(app, enabled).await
 }
 
 #[tauri::command]
-pub fn get_autostart_enabled(app: AppHandle) -> Result<bool, tauri_plugin_autostart::Error> {
-    get_autostart_enabled_logic(app)
+pub async fn get_autostart_enabled(app: AppHandle) -> Result<bool, tauri_plugin_autostart::Error> {
+    get_autostart_enabled_logic(app).await
 }

src-tauri/src/client/cleanup.rs

@@ -1,22 +1,27 @@
 use log::{debug, error};
 use tauri::AppHandle;
 
-use crate::AppState;
+use crate::DropFunctionState;
 
 #[tauri::command]
-pub fn quit(app: tauri::AppHandle, state: tauri::State<'_, std::sync::Mutex<AppState<'_>>>) {
-    cleanup_and_exit(&app, &state);
+pub async fn quit<>(app: tauri::AppHandle, state: tauri::State<'_, DropFunctionState<'_>>) -> Result<(), ()> {
+    cleanup_and_exit(&app, &state).await;
+
+    Ok(())
 }
 
-pub fn cleanup_and_exit(app: &AppHandle, state: &tauri::State<'_, std::sync::Mutex<AppState<'_>>>) {
+pub async fn cleanup_and_exit(
+    app: &AppHandle,
+    state: &tauri::State<'_, DropFunctionState<'_>>,
+) {
     debug!("cleaning up and exiting application");
-    let download_manager = state.lock().unwrap().download_manager.clone();
-    match download_manager.ensure_terminated() {
+    let download_manager = state.lock().await.download_manager.clone();
+    match download_manager.ensure_terminated().await {
         Ok(res) => match res {
             Ok(_) => debug!("download manager terminated correctly"),
             Err(_) => error!("download manager failed to terminate correctly"),
         },
-        Err(e) => panic!("{:?}", e),
+        Err(e) => panic!("{e:?}"),
     }
 
     app.exit(0);

src-tauri/src/client/commands.rs

@@ -1,10 +1,10 @@
-use crate::AppState;
+use crate::DropFunctionState;
 
 #[tauri::command]
-pub fn fetch_state(
-    state: tauri::State<'_, std::sync::Mutex<AppState<'_>>>,
+pub async fn fetch_state(
+    state: tauri::State<'_, DropFunctionState<'_>>,
 ) -> Result<String, String> {
-    let guard = state.lock().unwrap();
+    let guard = state.lock().await;
     let cloned_state = serde_json::to_string(&guard.clone()).map_err(|e| e.to_string())?;
     drop(guard);
     Ok(cloned_state)

src-tauri/src/client/mod.rs

@@ -1,3 +1,3 @@
 pub mod autostart;
 pub mod cleanup;
-pub mod commands;
+pub mod commands;

src-tauri/src/database/commands.rs

@@ -6,10 +6,12 @@ use std::{
 
 use serde_json::Value;
 
-use crate::{database::db::borrow_db_mut_checked, error::download_manager_error::DownloadManagerError};
+use crate::{
+    database::db::borrow_db_mut_checked, error::download_manager_error::DownloadManagerError,
+};
 
 use super::{
-    db::{borrow_db_checked, save_db, DATA_ROOT_DIR},
+    db::{DATA_ROOT_DIR, borrow_db_checked},
     debug::SystemData,
     models::data::Settings,
 };
@@ -17,21 +19,19 @@ use super::{
 // Will, in future, return disk/remaining size
 // Just returns the directories that have been set up
 #[tauri::command]
-pub fn fetch_download_dir_stats() -> Vec<PathBuf> {
-    let lock = borrow_db_checked();
+pub async fn fetch_download_dir_stats() -> Vec<PathBuf> {
+    let lock = borrow_db_checked().await;
     lock.applications.install_dirs.clone()
 }
 
 #[tauri::command]
-pub fn delete_download_dir(index: usize) {
-    let mut lock = borrow_db_mut_checked();
+pub async fn delete_download_dir(index: usize) {
+    let mut lock = borrow_db_mut_checked().await;
     lock.applications.install_dirs.remove(index);
-    drop(lock);
-    save_db();
 }
 
 #[tauri::command]
-pub fn add_download_dir(new_dir: PathBuf) -> Result<(), DownloadManagerError<()>> {
+pub async fn add_download_dir(new_dir: PathBuf) -> Result<(), DownloadManagerError<()>> {
     // Check the new directory is all good
     let new_dir_path = Path::new(&new_dir);
     if new_dir_path.exists() {
@@ -48,7 +48,7 @@ pub fn add_download_dir(new_dir: PathBuf) -> Result<(), DownloadManagerError<()>
     }
 
     // Add it to the dictionary
-    let mut lock = borrow_db_mut_checked();
+    let mut lock = borrow_db_mut_checked().await;
     if lock.applications.install_dirs.contains(&new_dir) {
         return Err(Error::new(
             ErrorKind::AlreadyExists,
@@ -58,34 +58,31 @@ pub fn add_download_dir(new_dir: PathBuf) -> Result<(), DownloadManagerError<()>
     }
     lock.applications.install_dirs.push(new_dir);
     drop(lock);
-    save_db();
 
     Ok(())
 }
 
 #[tauri::command]
-pub fn update_settings(new_settings: Value) {
-    let mut db_lock = borrow_db_mut_checked();
+pub async fn update_settings(new_settings: Value) {
+    let mut db_lock = borrow_db_mut_checked().await;
     let mut current_settings = serde_json::to_value(db_lock.settings.clone()).unwrap();
     for (key, value) in new_settings.as_object().unwrap() {
         current_settings[key] = value.clone();
     }
     let new_settings: Settings = serde_json::from_value(current_settings).unwrap();
     db_lock.settings = new_settings;
-    drop(db_lock);
-    save_db();
 }
 #[tauri::command]
-pub fn fetch_settings() -> Settings {
-    borrow_db_checked().settings.clone()
+pub async fn fetch_settings() -> Settings {
+    borrow_db_checked().await.settings.clone()
 }
 #[tauri::command]
-pub fn fetch_system_data() -> SystemData {
-    let db_handle = borrow_db_checked();
+pub async fn fetch_system_data() -> SystemData {
+    let db_handle = borrow_db_checked().await;
     SystemData::new(
         db_handle.auth.as_ref().unwrap().client_id.clone(),
         db_handle.base_url.clone(),
-        DATA_ROOT_DIR.lock().unwrap().to_string_lossy().to_string(),
+        DATA_ROOT_DIR.to_string_lossy().to_string(),
         std::env::var("RUST_LOG").unwrap_or_else(|_| "info".to_string()),
     )
 }

src-tauri/src/database/db.rs

@@ -1,22 +1,29 @@
 use std::{
     fs::{self, create_dir_all},
+    mem::ManuallyDrop,
+    ops::{Deref, DerefMut},
     path::PathBuf,
-    sync::{LazyLock, Mutex, RwLockReadGuard, RwLockWriteGuard},
+    sync::{Arc, LazyLock},
 };
 
+use async_once_cell::OnceCell;
 use chrono::Utc;
-use log::{debug, error, info, warn};
-use rustbreak::{DeSerError, DeSerializer, PathDatabase, RustbreakError};
-use serde::{de::DeserializeOwned, Serialize};
+use dropbreak::{DeSerError, DeSerializer, PathDatabase, RustbreakError};
+use log::{debug, info, warn};
+use native_model::{Decode, Encode};
+use serde::{Serialize, de::DeserializeOwned};
+use tokio::{
+    spawn,
+    sync::{RwLockReadGuard, RwLockWriteGuard},
+};
 use url::Url;
 
 use crate::DB;
 
 use super::models::data::Database;
 
-pub static DATA_ROOT_DIR: LazyLock<Mutex<PathBuf>> =
-    LazyLock::new(|| Mutex::new(dirs::data_dir().unwrap().join("drop")));
-
+pub static DATA_ROOT_DIR: LazyLock<Arc<PathBuf>> =
+    LazyLock::new(|| Arc::new(dirs::data_dir().unwrap().join("drop")));
 
 // Custom JSON serializer to support everything we need
 #[derive(Debug, Default, Clone)]
@@ -25,39 +32,57 @@ pub struct DropDatabaseSerializer;
 impl<T: native_model::Model + Serialize + DeserializeOwned> DeSerializer<T>
     for DropDatabaseSerializer
 {
-    fn serialize(&self, val: &T) -> rustbreak::error::DeSerResult<Vec<u8>> {
-        native_model::encode(val).map_err(|e| DeSerError::Internal(e.to_string()))
+    fn serialize(&self, val: &T) -> dropbreak::error::DeSerResult<Vec<u8>> {
+        native_model::rmp_serde_1_3::RmpSerde::encode(val)
+            .map_err(|e| DeSerError::Internal(e.to_string()))
     }
 
-    fn deserialize<R: std::io::Read>(&self, mut s: R) -> rustbreak::error::DeSerResult<T> {
+    fn deserialize<R: std::io::Read>(&self, mut s: R) -> dropbreak::error::DeSerResult<T> {
         let mut buf = Vec::new();
         s.read_to_end(&mut buf)
-            .map_err(|e| rustbreak::error::DeSerError::Other(e.into()))?;
-        let (val, _version) =
-            native_model::decode::<T>(buf).map_err(|e| DeSerError::Internal(e.to_string()))?;
+            .map_err(|e| dropbreak::error::DeSerError::Other(e.into()))?;
+        let val = native_model::rmp_serde_1_3::RmpSerde::decode(buf)
+            .map_err(|e| DeSerError::Internal(e.to_string()))?;
         Ok(val)
     }
 }
 
 pub type DatabaseInterface =
-    rustbreak::Database<Database, rustbreak::backend::PathBackend, DropDatabaseSerializer>;
+    dropbreak::Database<Database, dropbreak::backend::PathBackend, DropDatabaseSerializer>;
+
+pub struct OnceCellDatabase(OnceCell<DatabaseInterface>);
+impl OnceCellDatabase {
+    pub const fn new() -> Self {
+        Self(OnceCell::new())
+    }
+
+    pub async fn init(&self, init: impl Future<Output = DatabaseInterface>) {
+        self.0.get_or_init(init).await;
+    }
+}
+impl<'a> Deref for OnceCellDatabase {
+    type Target = DatabaseInterface;
+
+    fn deref(&self) -> &Self::Target {
+        self.0.get().unwrap()
+    }
+}
 
 pub trait DatabaseImpls {
-    fn set_up_database() -> DatabaseInterface;
-    fn database_is_set_up(&self) -> bool;
-    fn fetch_base_url(&self) -> Url;
+    async fn set_up_database() -> DatabaseInterface;
+    async fn database_is_set_up(&self) -> bool;
+    async fn fetch_base_url(&self) -> Url;
 }
 impl DatabaseImpls for DatabaseInterface {
-    fn set_up_database() -> DatabaseInterface {
-        let data_root_dir = DATA_ROOT_DIR.lock().unwrap();
-        let db_path = data_root_dir.join("drop.db");
-        let games_base_dir = data_root_dir.join("games");
-        let logs_root_dir = data_root_dir.join("logs");
-        let cache_dir = data_root_dir.join("cache");
-        let pfx_dir = data_root_dir.join("pfx");
+    async fn set_up_database() -> DatabaseInterface {
+        let db_path = DATA_ROOT_DIR.join("drop.db");
+        let games_base_dir = DATA_ROOT_DIR.join("games");
+        let logs_root_dir = DATA_ROOT_DIR.join("logs");
+        let cache_dir = DATA_ROOT_DIR.join("cache");
+        let pfx_dir = DATA_ROOT_DIR.join("pfx");
 
-        debug!("creating data directory at {:?}", data_root_dir);
-        create_dir_all(data_root_dir.clone()).unwrap();
+        debug!("creating data directory at {DATA_ROOT_DIR:?}");
+        create_dir_all(DATA_ROOT_DIR.as_path()).unwrap();
         create_dir_all(&games_base_dir).unwrap();
         create_dir_all(&logs_root_dir).unwrap();
         create_dir_all(&cache_dir).unwrap();
@@ -66,9 +91,9 @@ impl DatabaseImpls for DatabaseInterface {
         let exists = fs::exists(db_path.clone()).unwrap();
 
         match exists {
-            true => match PathDatabase::load_from_path(db_path.clone()) {
+            true => match PathDatabase::load_from_path(db_path.clone()).await {
                 Ok(db) => db,
-                Err(e) => handle_invalid_database(e, db_path, games_base_dir, cache_dir),
+                Err(e) => handle_invalid_database(e, db_path, games_base_dir, cache_dir).await,
             },
             false => {
                 let default = Database::new(games_base_dir, None, cache_dir);
@@ -77,39 +102,36 @@ impl DatabaseImpls for DatabaseInterface {
                     db_path.as_os_str().to_str().unwrap()
                 );
                 PathDatabase::create_at_path(db_path, default)
+                    .await
                     .expect("Database could not be created")
             }
         }
     }
 
-    fn database_is_set_up(&self) -> bool {
-        !self.borrow_data().unwrap().base_url.is_empty()
+    async fn database_is_set_up(&self) -> bool {
+        !self.borrow_data().await.base_url.is_empty()
     }
 
-    fn fetch_base_url(&self) -> Url {
-        let handle = self.borrow_data().unwrap();
+    async fn fetch_base_url(&self) -> Url {
+        let handle = self.borrow_data().await;
         Url::parse(&handle.base_url).unwrap()
     }
 }
 
-// TODO: Make the error relelvant rather than just assume that it's a Deserialize error
-fn handle_invalid_database(
+async fn handle_invalid_database(
     _e: RustbreakError,
     db_path: PathBuf,
     games_base_dir: PathBuf,
     cache_dir: PathBuf,
-) -> rustbreak::Database<Database, rustbreak::backend::PathBackend, DropDatabaseSerializer> {
-    warn!("{}", _e);
+) -> dropbreak::Database<Database, dropbreak::backend::PathBackend, DropDatabaseSerializer> {
+    warn!("{_e}");
     let new_path = {
         let time = Utc::now().timestamp();
         let mut base = db_path.clone();
-        base.set_file_name(format!("drop.db.backup-{}", time));
+        base.set_file_name(format!("drop.db.backup-{time}"));
         base
     };
-    info!(
-        "old database stored at: {}",
-        new_path.to_string_lossy().to_string()
-    );
+    info!("old database stored at: {}", new_path.to_string_lossy());
     fs::rename(&db_path, &new_path).unwrap();
 
     let db = Database::new(
@@ -118,35 +140,53 @@ fn handle_invalid_database(
         cache_dir,
     );
 
-    PathDatabase::create_at_path(db_path, db).expect("Database could not be created")
+    PathDatabase::create_at_path(db_path, db)
+        .await
+        .expect("Database could not be created")
 }
 
-pub fn borrow_db_checked<'a>() -> RwLockReadGuard<'a, Database> {
-    match DB.borrow_data() {
-        Ok(data) => data,
-        Err(e) => {
-            error!("database borrow failed with error {}", e);
-            panic!("database borrow failed with error {}", e);
-        }
+// To automatically save the database upon drop
+pub struct DBRead<'a>(RwLockReadGuard<'a, Database>);
+pub struct DBWrite<'a>(ManuallyDrop<RwLockWriteGuard<'a, Database>>);
+impl<'a> Deref for DBWrite<'a> {
+    type Target = RwLockWriteGuard<'a, Database>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
     }
 }
+impl<'a> Deref for DBRead<'a> {
+    type Target = RwLockReadGuard<'a, Database>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl<'a> DerefMut for DBWrite<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl<'a> Drop for DBWrite<'a> {
+    fn drop(&mut self) {
+        unsafe {
+            ManuallyDrop::drop(&mut self.0);
+        }
+
+        spawn(async {
+            match DB.save().await {
+                Ok(_) => {}
+                Err(e) => {
+                    panic!("database failed to save with error {e}")
+                }
+            }
+        });
+    }
+}
+pub async fn borrow_db_checked<'a>() -> DBRead<'a> {
+    DBRead(DB.borrow_data().await)
+}
 
-pub fn borrow_db_mut_checked<'a>() -> RwLockWriteGuard<'a, Database> {
-    match DB.borrow_data_mut() {
-        Ok(data) => data,
-        Err(e) => {
-            error!("database borrow mut failed with error {}", e);
-            panic!("database borrow mut failed with error {}", e);
-        }
-    }
-}
-
-pub fn save_db() {
-    match DB.save() {
-        Ok(_) => {}
-        Err(e) => {
-            error!("database failed to save with error {}", e);
-            panic!("database failed to save with error {}", e)
-        }
-    }
+pub async fn borrow_db_mut_checked<'a>() -> DBWrite<'a> {
+    DBWrite(ManuallyDrop::new(DB.borrow_data_mut().await))
 }

src-tauri/src/database/mod.rs

@@ -1,4 +1,4 @@
 pub mod commands;
 pub mod db;
 pub mod debug;
-pub mod models;
+pub mod models;

src-tauri/src/database/models.rs

@@ -1,19 +1,27 @@
+use crate::database::models::data::Database;
+
 pub mod data {
-    use native_model::{native_model, Model};
+    use std::path::PathBuf;
+
+    use native_model::native_model;
     use serde::{Deserialize, Serialize};
 
     pub type GameVersion = v1::GameVersion;
-    pub type Database = v2::Database;
+    pub type Database = v3::Database;
     pub type Settings = v1::Settings;
     pub type DatabaseAuth = v1::DatabaseAuth;
 
-    pub type GameDownloadStatus = v1::GameDownloadStatus;
+    pub type GameDownloadStatus = v2::GameDownloadStatus;
     pub type ApplicationTransientStatus = v1::ApplicationTransientStatus;
     pub type DownloadableMetadata = v1::DownloadableMetadata;
     pub type DownloadType = v1::DownloadType;
-    pub type DatabaseApplications = v1::DatabaseApplications;
+    pub type DatabaseApplications = v2::DatabaseApplications;
     pub type DatabaseCompatInfo = v2::DatabaseCompatInfo;
 
+    use std::{collections::HashMap, process::Command};
+
+    use crate::process::process_manager::UMU_LAUNCHER_EXECUTABLE;
+
     pub mod v1 {
         use crate::process::process_manager::Platform;
         use serde_with::serde_as;
@@ -27,7 +35,7 @@ pub mod data {
 
         #[derive(Serialize, Deserialize, Clone, Debug)]
         #[serde(rename_all = "camelCase")]
-        #[native_model(id = 2, version = 1)]
+        #[native_model(id = 2, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
         pub struct GameVersion {
             pub game_id: String,
             pub version_name: String,
@@ -69,7 +77,7 @@ pub mod data {
 
         #[derive(Serialize, Deserialize, Clone, Debug)]
         #[serde(rename_all = "camelCase")]
-        #[native_model(id = 4, version = 1)]
+        #[native_model(id = 4, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
         pub struct Settings {
             pub autostart: bool,
             pub max_download_threads: usize,
@@ -88,7 +96,7 @@ pub mod data {
         // Strings are version names for a particular game
         #[derive(Serialize, Clone, Deserialize)]
         #[serde(tag = "type")]
-        #[native_model(id = 5, version = 1)]
+        #[native_model(id = 5, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
         pub enum GameDownloadStatus {
             Remote {},
             SetupRequired {
@@ -102,7 +110,7 @@ pub mod data {
         }
 
         // Stuff that shouldn't be synced to disk
-        #[derive(Clone, Serialize, Deserialize)]
+        #[derive(Clone, Serialize, Deserialize, Debug)]
         pub enum ApplicationTransientStatus {
             Downloading { version_name: String },
             Uninstalling {},
@@ -111,7 +119,7 @@ pub mod data {
         }
 
         #[derive(serde::Serialize, Clone, Deserialize)]
-        #[native_model(id = 6, version = 1)]
+        #[native_model(id = 6, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
         pub struct DatabaseAuth {
             pub private: String,
             pub cert: String,
@@ -126,11 +134,11 @@ pub mod data {
         pub enum DownloadType {
             Game,
             Tool,
-            DLC,
+            Dlc,
             Mod,
         }
 
-        #[native_model(id = 7, version = 1)]
+        #[native_model(id = 7, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
         #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, Clone)]
         #[serde(rename_all = "camelCase")]
         pub struct DownloadableMetadata {
@@ -162,13 +170,121 @@ pub mod data {
     }
 
     pub mod v2 {
-        use std::{collections::HashMap, path::PathBuf, process::Command};
+        use std::{collections::HashMap, path::PathBuf};
 
-        use crate::process::process_manager::UMU_LAUNCHER_EXECUTABLE;
+        use serde_with::serde_as;
 
         use super::*;
 
-        #[native_model(id = 1, version = 2)]
+        #[native_model(id = 1, version = 2, with = native_model::rmp_serde_1_3::RmpSerde)]
+        #[derive(Serialize, Deserialize, Clone, Default)]
+        pub struct Database {
+            #[serde(default)]
+            pub settings: Settings,
+            pub auth: Option<DatabaseAuth>,
+            pub base_url: String,
+            pub applications: v1::DatabaseApplications,
+            #[serde(skip)]
+            pub prev_database: Option<PathBuf>,
+            pub cache_dir: PathBuf,
+            pub compat_info: Option<DatabaseCompatInfo>,
+        }
+
+        #[native_model(id = 8, version = 2, with = native_model::rmp_serde_1_3::RmpSerde)]
+        #[derive(Serialize, Deserialize, Clone, Default)]
+
+        pub struct DatabaseCompatInfo {
+            pub umu_installed: bool,
+        }
+
+        impl From<v1::Database> for Database {
+            fn from(value: v1::Database) -> Self {
+                Self {
+                    settings: value.settings,
+                    auth: value.auth,
+                    base_url: value.base_url,
+                    applications: value.applications,
+                    prev_database: value.prev_database,
+                    cache_dir: value.cache_dir,
+                    compat_info: crate::database::models::Database::create_new_compat_info(),
+                }
+            }
+        }
+        // Strings are version names for a particular game
+        #[derive(Serialize, Clone, Deserialize, Debug)]
+        #[serde(tag = "type")]
+        #[native_model(id = 5, version = 2, with = native_model::rmp_serde_1_3::RmpSerde)]
+        pub enum GameDownloadStatus {
+            Remote {},
+            SetupRequired {
+                version_name: String,
+                install_dir: String,
+            },
+            Installed {
+                version_name: String,
+                install_dir: String,
+            },
+            PartiallyInstalled {
+                version_name: String,
+                install_dir: String,
+            },
+        }
+        impl From<v1::GameDownloadStatus> for GameDownloadStatus {
+            fn from(value: v1::GameDownloadStatus) -> Self {
+                match value {
+                    v1::GameDownloadStatus::Remote {} => Self::Remote {},
+                    v1::GameDownloadStatus::SetupRequired {
+                        version_name,
+                        install_dir,
+                    } => Self::SetupRequired {
+                        version_name,
+                        install_dir,
+                    },
+                    v1::GameDownloadStatus::Installed {
+                        version_name,
+                        install_dir,
+                    } => Self::Installed {
+                        version_name,
+                        install_dir,
+                    },
+                }
+            }
+        }
+        #[serde_as]
+        #[derive(Serialize, Clone, Deserialize, Default)]
+        #[serde(rename_all = "camelCase")]
+        #[native_model(id = 3, version = 2, with = native_model::rmp_serde_1_3::RmpSerde)]
+        pub struct DatabaseApplications {
+            pub install_dirs: Vec<PathBuf>,
+            // Guaranteed to exist if the game also exists in the app state map
+            pub game_statuses: HashMap<String, GameDownloadStatus>,
+            pub game_versions: HashMap<String, HashMap<String, GameVersion>>,
+            pub installed_game_version: HashMap<String, DownloadableMetadata>,
+
+            #[serde(skip)]
+            pub transient_statuses: HashMap<DownloadableMetadata, ApplicationTransientStatus>,
+        }
+        impl From<v1::DatabaseApplications> for DatabaseApplications {
+            fn from(value: v1::DatabaseApplications) -> Self {
+                Self {
+                    game_statuses: value
+                        .game_statuses
+                        .into_iter()
+                        .map(|x| (x.0, x.1.into()))
+                        .collect::<HashMap<String, GameDownloadStatus>>(),
+                    install_dirs: value.install_dirs,
+                    game_versions: value.game_versions,
+                    installed_game_version: value.installed_game_version,
+                    transient_statuses: value.transient_statuses,
+                }
+            }
+        }
+    }
+    mod v3 {
+        use std::path::PathBuf;
+
+        use super::*;
+        #[native_model(id = 1, version = 3, with = native_model::rmp_serde_1_3::RmpSerde)]
         #[derive(Serialize, Deserialize, Clone, Default)]
         pub struct Database {
             #[serde(default)]
@@ -181,55 +297,13 @@ pub mod data {
             pub cache_dir: PathBuf,
             pub compat_info: Option<DatabaseCompatInfo>,
         }
-
-        #[native_model(id = 8, version = 2)]
-        #[derive(Serialize, Deserialize, Clone, Default)]
-
-        pub struct DatabaseCompatInfo {
-            umu_installed: bool,
-        }
-
-        impl Database {
-            fn create_new_compat_info() -> Option<DatabaseCompatInfo> {
-                #[cfg(target_os = "windows")]
-                return None;
-
-                let has_umu_installed = Command::new(UMU_LAUNCHER_EXECUTABLE).spawn().is_ok();
-                Some(DatabaseCompatInfo {
-                    umu_installed: has_umu_installed,
-                })
-            }
-
-            pub fn new<T: Into<PathBuf>>(
-                games_base_dir: T,
-                prev_database: Option<PathBuf>,
-                cache_dir: PathBuf,
-            ) -> Self {
-                Self {
-                    applications: DatabaseApplications {
-                        install_dirs: vec![games_base_dir.into()],
-                        game_statuses: HashMap::new(),
-                        game_versions: HashMap::new(),
-                        installed_game_version: HashMap::new(),
-                        transient_statuses: HashMap::new(),
-                    },
-                    prev_database,
-                    base_url: "".to_owned(),
-                    auth: None,
-                    settings: Settings::default(),
-                    cache_dir,
-                    compat_info: Database::create_new_compat_info(),
-                }
-            }
-        }
-
-        impl From<v1::Database> for Database {
-            fn from(value: v1::Database) -> Self {
+        impl From<v2::Database> for Database {
+            fn from(value: v2::Database) -> Self {
                 Self {
                     settings: value.settings,
                     auth: value.auth,
                     base_url: value.base_url,
-                    applications: value.applications,
+                    applications: value.applications.into(),
                     prev_database: value.prev_database,
                     cache_dir: value.cache_dir,
                     compat_info: Database::create_new_compat_info(),
@@ -237,4 +311,37 @@ pub mod data {
             }
         }
     }
+    impl Database {
+        fn create_new_compat_info() -> Option<DatabaseCompatInfo> {
+            #[cfg(target_os = "windows")]
+            return None;
+
+            let has_umu_installed = Command::new(UMU_LAUNCHER_EXECUTABLE).spawn().is_ok();
+            Some(DatabaseCompatInfo {
+                umu_installed: has_umu_installed,
+            })
+        }
+
+        pub fn new<T: Into<PathBuf>>(
+            games_base_dir: T,
+            prev_database: Option<PathBuf>,
+            cache_dir: PathBuf,
+        ) -> Self {
+            Self {
+                applications: DatabaseApplications {
+                    install_dirs: vec![games_base_dir.into()],
+                    game_statuses: HashMap::new(),
+                    game_versions: HashMap::new(),
+                    installed_game_version: HashMap::new(),
+                    transient_statuses: HashMap::new(),
+                },
+                prev_database,
+                base_url: "".to_owned(),
+                auth: None,
+                settings: Settings::default(),
+                cache_dir,
+                compat_info: Database::create_new_compat_info(),
+            }
+        }
+    }
 }

src-tauri/src/download_manager/commands.rs

@@ -1,31 +1,33 @@
-use std::sync::Mutex;
-
-use crate::{database::models::data::DownloadableMetadata, AppState};
+use crate::{database::models::data::DownloadableMetadata, DropFunctionState};
 
 #[tauri::command]
-pub fn pause_downloads(state: tauri::State<'_, Mutex<AppState>>) {
-    state.lock().unwrap().download_manager.pause_downloads()
+pub async fn pause_downloads(state: tauri::State<'_, DropFunctionState<'_>>) -> Result<(), ()> {
+    state.lock().await.download_manager.pause_downloads();
+    Ok(())
 }
 
 #[tauri::command]
-pub fn resume_downloads(state: tauri::State<'_, Mutex<AppState>>) {
-    state.lock().unwrap().download_manager.resume_downloads()
+pub async fn resume_downloads(state: tauri::State<'_, DropFunctionState<'_>>) -> Result<(), ()> {
+    state.lock().await.download_manager.resume_downloads();
+    Ok(())
 }
 
 #[tauri::command]
-pub fn move_download_in_queue(
-    state: tauri::State<'_, Mutex<AppState>>,
+pub async fn move_download_in_queue(
+    state: tauri::State<'_, DropFunctionState<'_>>,
     old_index: usize,
     new_index: usize,
-) {
+) -> Result<(), ()> {
     state
         .lock()
-        .unwrap()
+        .await
         .download_manager
-        .rearrange(old_index, new_index)
+        .rearrange(old_index, new_index);
+    Ok(())
 }
 
 #[tauri::command]
-pub fn cancel_game(state: tauri::State<'_, Mutex<AppState>>, meta: DownloadableMetadata) {
-    state.lock().unwrap().download_manager.cancel(meta)
+pub async fn cancel_game(state: tauri::State<'_, DropFunctionState<'_>>, meta: DownloadableMetadata) -> Result<(), ()> {
+    state.lock().await.download_manager.cancel(meta);
+    Ok(())
 }

src-tauri/src/download_manager/download_manager_builder.rs

@@ -1,14 +1,15 @@
 use std::{
     collections::HashMap,
     sync::{
-        mpsc::{channel, Receiver, Sender},
-        Arc, Mutex,
+        Arc,
+        mpsc::{Receiver, Sender, channel},
     },
-    thread::{spawn, JoinHandle},
 };
 
+use ::futures::future::join_all;
 use log::{debug, error, info, warn};
 use tauri::{AppHandle, Emitter};
+use tokio::{runtime::Runtime, sync::Mutex};
 
 use crate::{
     database::models::data::DownloadableMetadata,
@@ -17,8 +18,13 @@ use crate::{
 };
 
 use super::{
-    download_manager::{DownloadManager, DownloadManagerSignal, DownloadManagerStatus},
-    downloadable::Downloadable, util::{download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag}, progress_object::ProgressObject, queue::Queue},
+    download_manager_frontend::{DownloadManager, DownloadManagerSignal, DownloadManagerStatus},
+    downloadable::Downloadable,
+    util::{
+        download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag},
+        progress_object::ProgressObject,
+        queue::Queue,
+    },
 };
 
 pub type DownloadAgent = Arc<Box<dyn Downloadable + Send + Sync>>;
@@ -64,14 +70,15 @@ Behold, my madness - quexeky
 pub struct DownloadManagerBuilder {
     download_agent_registry: HashMap<DownloadableMetadata, DownloadAgent>,
     download_queue: Queue,
-    command_receiver: Receiver<DownloadManagerSignal>,
+    command_receiver: Mutex<Receiver<DownloadManagerSignal>>,
     sender: Sender<DownloadManagerSignal>,
     progress: CurrentProgressObject,
     status: Arc<Mutex<DownloadManagerStatus>>,
     app_handle: AppHandle,
+    runtime: Runtime,
 
     current_download_agent: Option<DownloadAgent>, // Should be the only download agent in the map with the "Go" flag
-    current_download_thread: Mutex<Option<JoinHandle<()>>>,
+    current_download_thread: Mutex<Option<tokio::task::JoinHandle<()>>>,
     active_control_flag: Option<DownloadThreadControl>,
 }
 impl DownloadManagerBuilder {
@@ -84,109 +91,121 @@ impl DownloadManagerBuilder {
         let manager = Self {
             download_agent_registry: HashMap::new(),
             download_queue: queue.clone(),
-            command_receiver,
+            command_receiver: Mutex::new(command_receiver),
             status: status.clone(),
             sender: command_sender.clone(),
             progress: active_progress.clone(),
             app_handle,
+            runtime: tokio::runtime::Builder::new_multi_thread()
+                .worker_threads(1)
+                .enable_all()
+                .build()
+                .unwrap(),
 
             current_download_agent: None,
             current_download_thread: Mutex::new(None),
             active_control_flag: None,
         };
 
-        let terminator = spawn(|| manager.manage_queue());
+        let terminator = tauri::async_runtime::spawn(async {
+            if let Err(_err) = manager.manage_queue().await {
+                panic!("download manager exited with error");
+            } else {
+                Ok(())
+            }
+        });
 
         DownloadManager::new(terminator, queue, active_progress, command_sender)
     }
 
-    fn set_status(&self, status: DownloadManagerStatus) {
-        *self.status.lock().unwrap() = status;
+    async fn set_status(&self, status: DownloadManagerStatus) {
+        *self.status.lock().await = status;
     }
 
-    fn remove_and_cleanup_front_download(&mut self, meta: &DownloadableMetadata) -> DownloadAgent {
+    async fn remove_and_cleanup_front_download(
+        &mut self,
+        meta: &DownloadableMetadata,
+    ) -> DownloadAgent {
         self.download_queue.pop_front();
         let download_agent = self.download_agent_registry.remove(meta).unwrap();
-        self.cleanup_current_download();
+        self.cleanup_current_download().await;
         download_agent
     }
 
     // CAREFUL WITH THIS FUNCTION
     // Make sure the download thread is terminated
-    fn cleanup_current_download(&mut self) {
+    async fn cleanup_current_download(&mut self) {
         self.active_control_flag = None;
-        *self.progress.lock().unwrap() = None;
+        *self.progress.lock().await = None;
         self.current_download_agent = None;
 
-        let mut download_thread_lock = self.current_download_thread.lock().unwrap();
+        let mut download_thread_lock = self.current_download_thread.lock().await;
         *download_thread_lock = None;
-        drop(download_thread_lock);
     }
 
-    fn stop_and_wait_current_download(&self) {
-        self.set_status(DownloadManagerStatus::Paused);
+    async fn stop_and_wait_current_download(&self) {
+        self.set_status(DownloadManagerStatus::Paused).await;
         if let Some(current_flag) = &self.active_control_flag {
             current_flag.set(DownloadThreadControlFlag::Stop);
         }
 
-        let mut download_thread_lock = self.current_download_thread.lock().unwrap();
+        let mut download_thread_lock = self.current_download_thread.lock().await;
         if let Some(current_download_thread) = download_thread_lock.take() {
-            current_download_thread.join().unwrap();
+            current_download_thread.await.unwrap();
         }
     }
 
-    fn manage_queue(mut self) -> Result<(), ()> {
+    async fn manage_queue(mut self) -> Result<(), ()> {
         loop {
-            let signal = match self.command_receiver.recv() {
+            let signal = match self.command_receiver.lock().await.recv() {
                 Ok(signal) => signal,
                 Err(_) => return Err(()),
             };
 
             match signal {
                 DownloadManagerSignal::Go => {
-                    self.manage_go_signal();
+                    self.manage_go_signal().await;
                 }
                 DownloadManagerSignal::Stop => {
-                    self.manage_stop_signal();
+                    self.manage_stop_signal().await;
                 }
                 DownloadManagerSignal::Completed(meta) => {
-                    self.manage_completed_signal(meta);
+                    self.manage_completed_signal(meta).await;
                 }
                 DownloadManagerSignal::Queue(download_agent) => {
-                    self.manage_queue_signal(download_agent);
+                    self.manage_queue_signal(download_agent).await;
                 }
                 DownloadManagerSignal::Error(e) => {
-                    self.manage_error_signal(e);
+                    self.manage_error_signal(e).await;
                 }
                 DownloadManagerSignal::UpdateUIQueue => {
-                    self.push_ui_queue_update();
+                    self.push_ui_queue_update().await;
                 }
                 DownloadManagerSignal::UpdateUIStats(kbs, time) => {
                     self.push_ui_stats_update(kbs, time);
                 }
                 DownloadManagerSignal::Finish => {
-                    self.stop_and_wait_current_download();
+                    self.stop_and_wait_current_download().await;
                     return Ok(());
                 }
                 DownloadManagerSignal::Cancel(meta) => {
-                    self.manage_cancel_signal(&meta);
+                    self.manage_cancel_signal(&meta).await;
                 }
-                _ => {}
             };
         }
     }
-    fn manage_queue_signal(&mut self, download_agent: DownloadAgent) {
+    async fn manage_queue_signal(&mut self, download_agent: DownloadAgent) {
         debug!("got signal Queue");
         let meta = download_agent.metadata();
 
-        debug!("queue metadata: {:?}", meta);
+        debug!("queue metadata: {meta:?}");
 
         if self.download_queue.exists(meta.clone()) {
             warn!("download with same ID already exists");
             return;
         }
 
-        download_agent.on_initialised(&self.app_handle);
+        download_agent.on_initialised(&self.app_handle).await;
         self.download_queue.append(meta.clone());
         self.download_agent_registry.insert(meta, download_agent);
 
@@ -195,7 +214,7 @@ impl DownloadManagerBuilder {
             .unwrap();
     }
 
-    fn manage_go_signal(&mut self) {
+    async fn manage_go_signal(&mut self) {
         debug!("got signal Go");
         if self.download_agent_registry.is_empty() {
             debug!(
@@ -205,16 +224,15 @@ impl DownloadManagerBuilder {
             return;
         }
 
-        if self.current_download_agent.is_some() {
-            if self.download_queue.read().front().unwrap()
+        if self.current_download_agent.is_some()
+            && self.download_queue.read().front().unwrap()
                 == &self.current_download_agent.as_ref().unwrap().metadata()
-            {
-                debug!(
-                    "Current download agent: {:?}",
-                    self.current_download_agent.as_ref().unwrap().metadata()
-                );
-                return;
-            }
+        {
+            debug!(
+                "Current download agent: {:?}",
+                self.current_download_agent.as_ref().unwrap().metadata()
+            );
+            return;
         }
 
         debug!("current download queue: {:?}", self.download_queue.read());
@@ -222,7 +240,7 @@ impl DownloadManagerBuilder {
         // Should always be Some if the above two statements keep going
         let agent_data = self.download_queue.read().front().unwrap().clone();
 
-        info!("starting download for {:?}", agent_data);
+        info!("starting download for {agent_data:?}");
 
         let download_agent = self
             .download_agent_registry
@@ -230,88 +248,117 @@ impl DownloadManagerBuilder {
             .unwrap()
             .clone();
 
-        self.active_control_flag = Some(download_agent.control_flag());
+        self.active_control_flag = Some(download_agent.control_flag().await);
         self.current_download_agent = Some(download_agent.clone());
 
+        info!("fetched control flag");
+
         let sender = self.sender.clone();
 
-        let mut download_thread_lock = self.current_download_thread.lock().unwrap();
+        info!("cloned sender");
+
+        let mut download_thread_lock = self.current_download_thread.lock().await;
+        info!("acquired download thread lock");
         let app_handle = self.app_handle.clone();
 
-        *download_thread_lock = Some(spawn(move || {
-            match download_agent.download(&app_handle) {
+        info!("starting download agent thread");
+
+        *download_thread_lock = Some(self.runtime.spawn(async move {
+            info!("started download agent thread");
+            match download_agent.download(&app_handle).await {
                 // Ok(true) is for completed and exited properly
                 Ok(true) => {
                     debug!("download {:?} has completed", download_agent.metadata());
-                    download_agent.on_complete(&app_handle);
-                    sender
-                        .send(DownloadManagerSignal::Completed(download_agent.metadata()))
-                        .unwrap();
+                    match download_agent.validate().await {
+                        Ok(true) => {
+                            download_agent.on_complete(&app_handle).await;
+                            sender
+                                .send(DownloadManagerSignal::Completed(download_agent.metadata()))
+                                .unwrap();
+                        }
+                        Ok(false) => {
+                            download_agent.on_incomplete(&app_handle).await;
+                        }
+                        Err(e) => {
+                            error!(
+                                "download {:?} has validation error {}",
+                                download_agent.metadata(),
+                                &e
+                            );
+                            download_agent.on_error(&app_handle, &e).await;
+                            sender.send(DownloadManagerSignal::Error(e)).unwrap();
+                        }
+                    }
                 }
                 // Ok(false) is for incomplete but exited properly
                 Ok(false) => {
-                    download_agent.on_incomplete(&app_handle);
+                    debug!("Donwload agent finished incomplete");
+                    download_agent.on_incomplete(&app_handle).await;
                 }
                 Err(e) => {
                     error!("download {:?} has error {}", download_agent.metadata(), &e);
-                    download_agent.on_error(&app_handle, &e);
+                    download_agent.on_error(&app_handle, &e).await;
                     sender.send(DownloadManagerSignal::Error(e)).unwrap();
                 }
             }
             sender.send(DownloadManagerSignal::UpdateUIQueue).unwrap();
         }));
 
-        self.set_status(DownloadManagerStatus::Downloading);
+        self.set_status(DownloadManagerStatus::Downloading).await;
         let active_control_flag = self.active_control_flag.clone().unwrap();
         active_control_flag.set(DownloadThreadControlFlag::Go);
+
+        // download_thread_lock.take().unwrap().await;
     }
-    fn manage_stop_signal(&mut self) {
+    async fn manage_stop_signal(&mut self) {
         debug!("got signal Stop");
 
         if let Some(active_control_flag) = self.active_control_flag.clone() {
-            self.set_status(DownloadManagerStatus::Paused);
+            self.set_status(DownloadManagerStatus::Paused).await;
             active_control_flag.set(DownloadThreadControlFlag::Stop);
         }
     }
-    fn manage_completed_signal(&mut self, meta: DownloadableMetadata) {
+    async fn manage_completed_signal(&mut self, meta: DownloadableMetadata) {
         debug!("got signal Completed");
-        if let Some(interface) = &self.current_download_agent {
-            if interface.metadata() == meta {
-                self.remove_and_cleanup_front_download(&meta);
-            }
+        if let Some(interface) = &self.current_download_agent
+            && interface.metadata() == meta
+        {
+            self.remove_and_cleanup_front_download(&meta).await;
         }
-        self.push_ui_queue_update();
+
+        self.push_ui_queue_update().await;
         self.sender.send(DownloadManagerSignal::Go).unwrap();
     }
-    fn manage_error_signal(&mut self, error: ApplicationDownloadError) {
+    async fn manage_error_signal(&mut self, error: ApplicationDownloadError) {
         debug!("got signal Error");
         if let Some(current_agent) = self.current_download_agent.clone() {
-            current_agent.on_error(&self.app_handle, &error);
+            current_agent.on_error(&self.app_handle, &error).await;
 
-            self.stop_and_wait_current_download();
-            self.remove_and_cleanup_front_download(&current_agent.metadata());
+            self.stop_and_wait_current_download().await;
+            self.remove_and_cleanup_front_download(&current_agent.metadata())
+                .await;
         }
-        self.set_status(DownloadManagerStatus::Error(error));
+        self.set_status(DownloadManagerStatus::Error).await;
     }
-    fn manage_cancel_signal(&mut self, meta: &DownloadableMetadata) {
+    async fn manage_cancel_signal(&mut self, meta: &DownloadableMetadata) {
         debug!("got signal Cancel");
 
         if let Some(current_download) = &self.current_download_agent {
             if &current_download.metadata() == meta {
-                self.set_status(DownloadManagerStatus::Paused);
-                current_download.on_cancelled(&self.app_handle);
-                self.stop_and_wait_current_download();
+                self.set_status(DownloadManagerStatus::Paused).await;
+                current_download.on_cancelled(&self.app_handle).await;
+                self.stop_and_wait_current_download().await;
 
                 self.download_queue.pop_front();
 
-                self.cleanup_current_download();
+                self.cleanup_current_download().await;
                 debug!("current download queue: {:?}", self.download_queue.read());
             }
             // TODO: Collapse these two into a single if statement somehow
             else if let Some(download_agent) = self.download_agent_registry.get(meta) {
                 let index = self.download_queue.get_by_meta(meta);
                 if let Some(index) = index {
-                    download_agent.on_cancelled(&self.app_handle);
+                    download_agent.on_cancelled(&self.app_handle).await;
                     let _ = self.download_queue.edit().remove(index).unwrap();
                     let removed = self.download_agent_registry.remove(meta);
                     debug!(
@@ -324,7 +371,7 @@ impl DownloadManagerBuilder {
         } else if let Some(download_agent) = self.download_agent_registry.get(meta) {
             let index = self.download_queue.get_by_meta(meta);
             if let Some(index) = index {
-                download_agent.on_cancelled(&self.app_handle);
+                download_agent.on_cancelled(&self.app_handle).await;
                 let _ = self.download_queue.edit().remove(index).unwrap();
                 let removed = self.download_agent_registry.remove(meta);
                 debug!(
@@ -334,28 +381,26 @@ impl DownloadManagerBuilder {
                 );
             }
         }
-        self.push_ui_queue_update();
+        self.push_ui_queue_update().await;
     }
     fn push_ui_stats_update(&self, kbs: usize, time: usize) {
         let event_data = StatsUpdateEvent { speed: kbs, time };
 
         self.app_handle.emit("update_stats", event_data).unwrap();
     }
-    fn push_ui_queue_update(&self) {
+    async fn push_ui_queue_update(&self) {
         let queue = &self.download_queue.read();
-        let queue_objs = queue
-            .iter()
-            .map(|key| {
-                let val = self.download_agent_registry.get(key).unwrap();
-                QueueUpdateEventQueueData {
-                    meta: DownloadableMetadata::clone(key),
-                    status: val.status(),
-                    progress: val.progress().get_progress(),
-                    current: val.progress().sum(),
-                    max: val.progress().get_max(),
-                }
-            })
-            .collect();
+        let queue_objs = join_all(queue.iter().map(async |key| {
+            let val = self.download_agent_registry.get(key).unwrap();
+            QueueUpdateEventQueueData {
+                meta: DownloadableMetadata::clone(key),
+                status: val.status().await,
+                progress: val.progress().await.get_progress(),
+                current: val.progress().await.sum(),
+                max: val.progress().await.get_max(),
+            }
+        }))
+        .await;
 
         let event_data = QueueUpdateEvent { queue: queue_objs };
         self.app_handle.emit("update_queue", event_data).unwrap();

src-tauri/src/download_manager/download_manager_frontend.rs

@@ -1,16 +1,15 @@
 use std::{
-    any::Any,
     collections::VecDeque,
     fmt::Debug,
     sync::{
         mpsc::{SendError, Sender},
         Mutex, MutexGuard,
     },
-    thread::JoinHandle,
 };
 
 use log::{debug, info};
 use serde::Serialize;
+use tauri::async_runtime::JoinHandle;
 
 use crate::{
     database::models::data::DownloadableMetadata,
@@ -18,7 +17,8 @@ use crate::{
 };
 
 use super::{
-    download_manager_builder::{CurrentProgressObject, DownloadAgent}, util::queue::Queue,
+    download_manager_builder::{CurrentProgressObject, DownloadAgent},
+    util::queue::Queue,
 };
 
 pub enum DownloadManagerSignal {
@@ -37,16 +37,11 @@ pub enum DownloadManagerSignal {
     Finish,
     /// Stops, removes, and tells a download to cleanup
     Cancel(DownloadableMetadata),
-    /// Removes a given application
-    Remove(DownloadableMetadata),
     /// Any error which occurs in the agent
     Error(ApplicationDownloadError),
     /// Pushes UI update
     UpdateUIQueue,
     UpdateUIStats(usize, usize), //kb/s and seconds
-    /// Uninstall download
-    /// Takes download ID
-    Uninstall(DownloadableMetadata),
 }
 
 #[derive(Debug)]
@@ -54,8 +49,7 @@ pub enum DownloadManagerStatus {
     Downloading,
     Paused,
     Empty,
-    Error(ApplicationDownloadError),
-    Finished,
+    Error,
 }
 
 impl Serialize for DownloadManagerStatus {
@@ -63,7 +57,7 @@ impl Serialize for DownloadManagerStatus {
     where
         S: serde::Serializer,
     {
-        serializer.serialize_str(&format!["{:?}", self])
+        serializer.serialize_str(&format!["{self:?}"])
     }
 }
 
@@ -71,6 +65,7 @@ impl Serialize for DownloadManagerStatus {
 pub enum DownloadStatus {
     Queued,
     Downloading,
+    Validating,
     Error,
 }
 
@@ -122,8 +117,8 @@ impl DownloadManager {
     pub fn read_queue(&self) -> VecDeque<DownloadableMetadata> {
         self.download_queue.read()
     }
-    pub fn get_current_download_progress(&self) -> Option<f64> {
-        let progress_object = (*self.progress.lock().unwrap()).clone()?;
+    pub async fn get_current_download_progress(&self) -> Option<f64> {
+        let progress_object = (*self.progress.lock().await).clone()?;
         Some(progress_object.get_progress())
     }
     pub fn rearrange_string(&self, meta: &DownloadableMetadata, new_index: usize) {
@@ -152,10 +147,7 @@ impl DownloadManager {
                 .unwrap();
         }
 
-        debug!(
-            "moving download at index {} to index {}",
-            current_index, new_index
-        );
+        debug!("moving download at index {current_index} to index {new_index}");
 
         let mut queue = self.edit();
         let to_move = queue.remove(current_index).unwrap();
@@ -178,17 +170,12 @@ impl DownloadManager {
     pub fn resume_downloads(&self) {
         self.command_sender.send(DownloadManagerSignal::Go).unwrap();
     }
-    pub fn ensure_terminated(&self) -> Result<Result<(), ()>, Box<dyn Any + Send>> {
+    pub async fn ensure_terminated(&self) -> Result<Result<(), ()>, tauri::Error> {
         self.command_sender
             .send(DownloadManagerSignal::Finish)
             .unwrap();
         let terminator = self.terminator.lock().unwrap().take();
-        terminator.unwrap().join()
-    }
-    pub fn uninstall_application(&self, meta: DownloadableMetadata) {
-        self.command_sender
-            .send(DownloadManagerSignal::Uninstall(meta))
-            .unwrap();
+        terminator.unwrap().await
     }
     pub fn get_sender(&self) -> Sender<DownloadManagerSignal> {
         self.command_sender.clone()

src-tauri/src/download_manager/downloadable.rs

@@ -8,18 +8,21 @@ use crate::{
 };
 
 use super::{
-    download_manager::DownloadStatus, util::{download_thread_control_flag::DownloadThreadControl, progress_object::ProgressObject},
+    download_manager_frontend::DownloadStatus,
+    util::{download_thread_control_flag::DownloadThreadControl, progress_object::ProgressObject},
 };
 
+#[async_trait::async_trait]
 pub trait Downloadable: Send + Sync {
-    fn download(&self, app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError>;
-    fn progress(&self) -> Arc<ProgressObject>;
-    fn control_flag(&self) -> DownloadThreadControl;
-    fn status(&self) -> DownloadStatus;
+    async fn download(&self, app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError>;
+    async fn progress(&self) -> Arc<ProgressObject>;
+    async fn control_flag(&self) -> DownloadThreadControl;
+    async fn validate(&self) -> Result<bool, ApplicationDownloadError>;
+    async fn status(&self) -> DownloadStatus;
     fn metadata(&self) -> DownloadableMetadata;
-    fn on_initialised(&self, app_handle: &AppHandle);
-    fn on_error(&self, app_handle: &AppHandle, error: &ApplicationDownloadError);
-    fn on_complete(&self, app_handle: &AppHandle);
-    fn on_incomplete(&self, app_handle: &AppHandle);
-    fn on_cancelled(&self, app_handle: &AppHandle);
+    async fn on_initialised(&self, app_handle: &AppHandle);
+    async fn on_error(&self, app_handle: &AppHandle, error: &ApplicationDownloadError);
+    async fn on_complete(&self, app_handle: &AppHandle);
+    async fn on_incomplete(&self, app_handle: &AppHandle);
+    async fn on_cancelled(&self, app_handle: &AppHandle);
 }

src-tauri/src/download_manager/mod.rs

@@ -1,5 +1,5 @@
 pub mod commands;
-pub mod download_manager;
 pub mod download_manager_builder;
+pub mod download_manager_frontend;
 pub mod downloadable;
-pub mod util;
+pub mod util;

src-tauri/src/download_manager/util/mod.rs

@@ -1,4 +1,4 @@
+pub mod download_thread_control_flag;
 pub mod progress_object;
 pub mod queue;
 pub mod rolling_progress_updates;
-pub mod download_thread_control_flag;

src-tauri/src/download_manager/util/progress_object.rs

@@ -10,11 +10,9 @@ use std::{
 use atomic_instant_full::AtomicInstant;
 use throttle_my_fn::throttle;
 
-use crate::download_manager::download_manager::DownloadManagerSignal;
+use crate::download_manager::download_manager_frontend::DownloadManagerSignal;
 
-use super::{
-    rolling_progress_updates::RollingProgressWindow,
-};
+use super::rolling_progress_updates::RollingProgressWindow;
 
 #[derive(Clone)]
 pub struct ProgressObject {
@@ -86,6 +84,17 @@ impl ProgressObject {
             .map(|instance| instance.load(Ordering::Relaxed))
             .sum()
     }
+    pub fn reset(&self, size: usize) {
+        self.set_time_now();
+        self.set_size(size);
+        self.bytes_last_update.store(0, Ordering::Release);
+        self.rolling.reset();
+        self.progress_instances
+            .lock()
+            .unwrap()
+            .iter()
+            .for_each(|x| x.store(0, Ordering::Release));
+    }
     pub fn get_max(&self) -> usize {
         *self.max.lock().unwrap()
     }
@@ -124,7 +133,7 @@ pub fn calculate_update(progress: &ProgressObject) {
 
     let kilobytes_per_second = bytes_since_last_update / (time_since_last_update as usize).max(1);
 
-    let bytes_remaining = max - current_bytes_downloaded; // bytes
+    let bytes_remaining = max.saturating_sub(current_bytes_downloaded); // bytes
 
     progress.update_window(kilobytes_per_second);
     push_update(progress, bytes_remaining);

src-tauri/src/download_manager/util/queue.rs

@@ -32,49 +32,13 @@ impl Queue {
     pub fn pop_front(&self) -> Option<DownloadableMetadata> {
         self.edit().pop_front()
     }
-    pub fn is_empty(&self) -> bool {
-        self.inner.lock().unwrap().len() == 0
-    }
     pub fn exists(&self, meta: DownloadableMetadata) -> bool {
         self.read().contains(&meta)
     }
-    /// Either inserts `interface` at the specified index, or appends to
-    /// the back of the deque if index is greater than the length of the deque
-    pub fn insert(&self, interface: DownloadableMetadata, index: usize) {
-        if self.read().len() > index {
-            self.append(interface);
-        } else {
-            self.edit().insert(index, interface);
-        }
-    }
     pub fn append(&self, interface: DownloadableMetadata) {
         self.edit().push_back(interface);
     }
-    pub fn pop_front_if_equal(&self, meta: &DownloadableMetadata) -> Option<DownloadableMetadata> {
-        let mut queue = self.edit();
-        let front = queue.front()?;
-        if front == meta {
-            return queue.pop_front();
-        }
-        None
-    }
     pub fn get_by_meta(&self, meta: &DownloadableMetadata) -> Option<usize> {
         self.read().iter().position(|data| data == meta)
     }
-    pub fn move_to_index_by_meta(
-        &self,
-        meta: &DownloadableMetadata,
-        new_index: usize,
-    ) -> Result<(), ()> {
-        let index = match self.get_by_meta(meta) {
-            Some(index) => index,
-            None => return Err(()),
-        };
-        let existing = match self.edit().remove(index) {
-            Some(existing) => existing,
-            None => return Err(()),
-        };
-        self.edit().insert(new_index, existing);
-        Ok(())
-    }
 }

src-tauri/src/download_manager/util/rolling_progress_updates.rs

@@ -30,4 +30,9 @@ impl<const S: usize> RollingProgressWindow<S> {
             .sum::<usize>()
             / S
     }
+    pub fn reset(&self) {
+        self.window
+            .iter()
+            .for_each(|x| x.store(0, Ordering::Release));
+    }
 }

src-tauri/src/error/application_download_error.rs

@@ -5,14 +5,13 @@ use std::{
 
 use serde_with::SerializeDisplay;
 
-use super::{remote_access_error::RemoteAccessError, setup_error::SetupError};
+use super::remote_access_error::RemoteAccessError;
 
 // TODO: Rename / separate from downloads
 #[derive(Debug, SerializeDisplay)]
 pub enum ApplicationDownloadError {
     Communication(RemoteAccessError),
     Checksum,
-    Setup(SetupError),
     Lock,
     IoError(io::ErrorKind),
     DownloadError,
@@ -21,11 +20,10 @@ pub enum ApplicationDownloadError {
 impl Display for ApplicationDownloadError {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
-            ApplicationDownloadError::Communication(error) => write!(f, "{}", error),
-            ApplicationDownloadError::Setup(error) => write!(f, "an error occurred while setting up the download: {}", error),
+            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, "{}", error),
+            ApplicationDownloadError::IoError(error) => write!(f, "io error: {error}"),
             ApplicationDownloadError::DownloadError => write!(f, "download failed. See Download Manager status for specific error"),
         }
     }

src-tauri/src/error/backup_error.rs

@@ -1,21 +0,0 @@
-use std::fmt::Display;
-
-use serde_with::SerializeDisplay;
-
-#[derive(Debug, SerializeDisplay, Clone, Copy)]
-pub enum BackupError {
-    InvalidSystem,
-    NotFound,
-    ParseError
-}
-
-impl Display for BackupError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let s = match self {
-            BackupError::InvalidSystem => "Attempted to generate path for invalid system",
-            BackupError::NotFound => "Could not generate or find path",
-            BackupError::ParseError => "Failed to parse path",
-        };
-        write!(f, "{}", s)
-    }
-}

src-tauri/src/error/download_manager_error.rs

@@ -10,8 +10,8 @@ pub enum DownloadManagerError<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),
+            DownloadManagerError::IOError(error) => write!(f, "{error}"),
+            DownloadManagerError::SignalError(send_error) => write!(f, "{send_error}"),
         }
     }
 }

src-tauri/src/error/drop_server_error.rs

@@ -5,6 +5,6 @@ use serde::Deserialize;
 pub struct DropServerError {
     pub status_code: usize,
     pub status_message: String,
-    pub message: String,
-    pub url: String,
+    // pub message: String,
+    // pub url: String,
 }

src-tauri/src/error/library_error.rs

@@ -11,8 +11,7 @@ impl Display for LibraryError {
         match self {
             LibraryError::MetaNotFound(id) => write!(
                 f,
-                "Could not locate any installed version of game ID {} in the database",
-                id
+                "Could not locate any installed version of game ID {id} in the database"
             ),
         }
     }

src-tauri/src/error/mod.rs

@@ -1,8 +1,6 @@
 pub mod application_download_error;
-pub mod drop_server_error;
 pub mod download_manager_error;
+pub mod drop_server_error;
 pub mod library_error;
 pub mod process_error;
 pub mod remote_access_error;
-pub mod setup_error;
-pub mod backup_error;

src-tauri/src/error/process_error.rs

@@ -13,6 +13,7 @@ pub enum ProcessError {
     IOError(Error),
     FormatError(String), // String errors supremacy
     InvalidPlatform,
+    OpenerError(tauri_plugin_opener::Error)
 }
 
 impl Display for ProcessError {
@@ -22,12 +23,13 @@ impl Display for ProcessError {
             ProcessError::NotInstalled => "Game not installed",
             ProcessError::AlreadyRunning => "Game already running",
             ProcessError::NotDownloaded => "Game not downloaded",
-            ProcessError::InvalidID => "Invalid Game ID",
-            ProcessError::InvalidVersion => "Invalid Game version",
+            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),
-        };
-        write!(f, "{}", s)
+            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/src/error/remote_access_error.rs

@@ -18,7 +18,7 @@ pub enum RemoteAccessError {
     HandshakeFailed(String),
     GameNotFound(String),
     InvalidResponse(DropServerError),
-    InvalidRedirect,
+    UnparseableResponse(String),
     ManifestDownloadFailed(StatusCode, String),
     OutOfSync,
     Cache(cacache::Error),
@@ -44,20 +44,19 @@ impl Display for RemoteAccessError {
                 )
             },
             RemoteAccessError::ParsingError(parse_error) => {
-                write!(f, "{}", 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::InvalidRedirect => write!(f, "server redirect was invalid"),
+            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
+                "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::Cache(error) => write!(f, "Cache Error: {error}"),
         }
     }
 }

src-tauri/src/error/setup_error.rs

@@ -1,14 +0,0 @@
-use std::fmt::{Display, Formatter};
-
-#[derive(Debug, Clone)]
-pub enum SetupError {
-    Context,
-}
-
-impl Display for SetupError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            SetupError::Context => write!(f, "failed to generate contexts for download"),
-        }
-    }
-}

src-tauri/src/games/collections/commands.rs

@@ -1,110 +1,116 @@
-use reqwest::blocking::Client;
+use reqwest::Client;
 use serde_json::json;
 use url::Url;
 
 use crate::{
+    DB,
     database::db::DatabaseImpls,
     error::remote_access_error::RemoteAccessError,
     remote::{auth::generate_authorization_header, requests::make_request},
-    DB,
 };
 
 use super::collection::{Collection, Collections};
 
 #[tauri::command]
-pub fn fetch_collections() -> Result<Collections, RemoteAccessError> {
+pub async fn fetch_collections() -> Result<Collections, RemoteAccessError> {
     let client = Client::new();
-    let response = make_request(&client, &["/api/v1/client/collection"], &[], |r| {
-        r.header("Authorization", generate_authorization_header())
-    })?
-    .send()?;
+    let response = make_request(&client, &["/api/v1/client/collection"], &[], async |r| {
+        r.header("Authorization", generate_authorization_header().await)
+    })
+    .await?
+    .send()
+    .await?;
 
-    Ok(response.json()?)
+    Ok(response.json().await?)
 }
 
 #[tauri::command]
-pub fn fetch_collection(collection_id: String) -> Result<Collection, RemoteAccessError> {
+pub async fn fetch_collection(collection_id: String) -> Result<Collection, RemoteAccessError> {
     let client = Client::new();
     let response = make_request(
         &client,
         &["/api/v1/client/collection/", &collection_id],
         &[],
-        |r| r.header("Authorization", generate_authorization_header()),
-    )?
-    .send()?;
+        async |r| r.header("Authorization", generate_authorization_header().await),
+    )
+    .await?
+    .send()
+    .await?;
 
-    Ok(response.json()?)
+    Ok(response.json().await?)
 }
 
 #[tauri::command]
-pub fn create_collection(name: String) -> Result<Collection, RemoteAccessError> {
+pub async fn create_collection(name: String) -> Result<Collection, RemoteAccessError> {
     let client = Client::new();
-    let base_url = DB.fetch_base_url();
+    let base_url = DB.fetch_base_url().await;
 
-    let base_url = Url::parse(&format!("{}api/v1/client/collection/", base_url))?;
+    let base_url = Url::parse(&format!("{base_url}api/v1/client/collection/"))?;
 
     let response = client
         .post(base_url)
-        .header("Authorization", generate_authorization_header())
+        .header("Authorization", generate_authorization_header().await)
         .json(&json!({"name": name}))
-        .send()?;
+        .send()
+        .await?;
 
-    Ok(response.json()?)
+    Ok(response.json().await?)
 }
 
 #[tauri::command]
-pub fn add_game_to_collection(
+pub async fn add_game_to_collection(
     collection_id: String,
     game_id: String,
 ) -> Result<(), RemoteAccessError> {
     let client = Client::new();
     let url = Url::parse(&format!(
         "{}api/v1/client/collection/{}/entry/",
-        DB.fetch_base_url(),
+        DB.fetch_base_url().await,
         collection_id
     ))?;
 
     client
         .post(url)
-        .header("Authorization", generate_authorization_header())
+        .header("Authorization", generate_authorization_header().await)
         .json(&json!({"id": game_id}))
-        .send()?;
+        .send()
+        .await?;
     Ok(())
 }
 
 #[tauri::command]
-pub fn delete_collection(collection_id: String) -> Result<bool, RemoteAccessError> {
+pub async fn delete_collection(collection_id: String) -> Result<(), RemoteAccessError> {
     let client = Client::new();
     let base_url = Url::parse(&format!(
         "{}api/v1/client/collection/{}",
-        DB.fetch_base_url(),
+        DB.fetch_base_url().await,
         collection_id
     ))?;
 
-    let response = client
+    client
         .delete(base_url)
-        .header("Authorization", generate_authorization_header())
-        .send()?;
+        .header("Authorization", generate_authorization_header().await)
+        .send().await?;
 
-    Ok(response.json()?)
+    Ok(())
 }
 #[tauri::command]
-pub fn delete_game_in_collection(
+pub async fn delete_game_in_collection(
     collection_id: String,
     game_id: String,
 ) -> Result<(), RemoteAccessError> {
     let client = Client::new();
     let base_url = Url::parse(&format!(
         "{}api/v1/client/collection/{}/entry",
-        DB.fetch_base_url(),
+        DB.fetch_base_url().await,
         collection_id
     ))?;
 
     client
         .delete(base_url)
-        .header("Authorization", generate_authorization_header())
+        .header("Authorization", generate_authorization_header().await)
         .json(&json!({"id": game_id}))
-        .send()?;
+        .send().await?;
 
     Ok(())
 }

src-tauri/src/games/commands.rs

@@ -1,28 +1,24 @@
-use std::sync::Mutex;
-
+use serde::Deserialize;
 use tauri::AppHandle;
 
 use crate::{
-    database::models::data::GameVersion,
-    error::{library_error::LibraryError, remote_access_error::RemoteAccessError},
-    games::library::{
+    database::{db::borrow_db_mut_checked, models::data::GameVersion}, error::{library_error::LibraryError, remote_access_error::RemoteAccessError}, games::library::{
         fetch_game_logic_offline, fetch_library_logic_offline, get_current_meta,
         uninstall_game_logic,
-    },
-    offline, AppState,
+    }, offline, DropFunctionState
 };
 
 use super::{
     library::{
-        fetch_game_logic, fetch_game_verion_options_logic, fetch_library_logic, FetchGameStruct,
-        Game,
+        FetchGameStruct, Game, fetch_game_logic, fetch_game_verion_options_logic,
+        fetch_library_logic,
     },
     state::{GameStatusManager, GameStatusWithTransient},
 };
 
 #[tauri::command]
-pub fn fetch_library(
-    state: tauri::State<'_, Mutex<AppState>>,
+pub async fn fetch_library(
+    state: tauri::State<'_, DropFunctionState<'_>>,
 ) -> Result<Vec<Game>, RemoteAccessError> {
     offline!(
         state,
@@ -30,12 +26,13 @@ pub fn fetch_library(
         fetch_library_logic_offline,
         state
     )
+    .await
 }
 
 #[tauri::command]
-pub fn fetch_game(
+pub async fn fetch_game(
     game_id: String,
-    state: tauri::State<'_, Mutex<AppState>>,
+    state: tauri::State<'_, DropFunctionState<'_>>,
 ) -> Result<FetchGameStruct, RemoteAccessError> {
     offline!(
         state,
@@ -44,28 +41,74 @@ pub fn fetch_game(
         game_id,
         state
     )
+    .await
 }
 
 #[tauri::command]
-pub fn fetch_game_status(id: String) -> GameStatusWithTransient {
-    GameStatusManager::fetch_state(&id)
+pub async fn fetch_game_status(id: String) -> GameStatusWithTransient {
+    GameStatusManager::fetch_state(&id).await
 }
 
 #[tauri::command]
-pub fn uninstall_game(game_id: String, app_handle: AppHandle) -> Result<(), LibraryError> {
-    let meta = match get_current_meta(&game_id) {
+pub async fn uninstall_game(game_id: String, app_handle: AppHandle) -> Result<(), LibraryError> {
+    let meta = match get_current_meta(&game_id).await {
         Some(data) => data,
         None => return Err(LibraryError::MetaNotFound(game_id)),
     };
-    uninstall_game_logic(meta, &app_handle);
+    uninstall_game_logic(meta, &app_handle).await;
 
     Ok(())
 }
 
 #[tauri::command]
-pub fn fetch_game_verion_options(
+pub async fn fetch_game_verion_options(
     game_id: String,
-    state: tauri::State<'_, Mutex<AppState>>,
+    state: tauri::State<'_, DropFunctionState<'_>>,
 ) -> Result<Vec<GameVersion>, RemoteAccessError> {
-    fetch_game_verion_options_logic(game_id, state)
+    fetch_game_verion_options_logic(game_id, state).await
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FrontendGameOptions {
+    launch_string: String,
+}
+
+#[tauri::command]
+pub async fn update_game_configuration(
+    game_id: String,
+    options: FrontendGameOptions,
+) -> Result<(), LibraryError> {
+    let mut handle = borrow_db_mut_checked().await;
+    let installed_version = handle
+        .applications
+        .installed_game_version
+        .get(&game_id)
+        .ok_or(LibraryError::MetaNotFound(game_id))?;
+
+    let id = installed_version.id.clone();
+    let version = installed_version.version.clone().unwrap();
+
+    let mut existing_configuration = handle
+        .applications
+        .game_versions
+        .get(&id)
+        .unwrap()
+        .get(&version)
+        .unwrap()
+        .clone();
+
+    // Add more options in here
+    existing_configuration.launch_command_template = options.launch_string;
+
+    // Add no more options past here
+
+    handle
+        .applications
+        .game_versions
+        .get_mut(&id)
+        .unwrap()
+        .insert(version.to_string(), existing_configuration);
+
+    Ok(())
 }

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

@@ -1,30 +1,71 @@
-use std::sync::{Arc, Mutex};
+use std::{
+    path::PathBuf,
+    sync::Arc,
+};
 
 use crate::{
+    database::{db::borrow_db_checked, models::data::GameDownloadStatus},
     download_manager::{
-        download_manager::DownloadManagerSignal, downloadable::Downloadable,
-    }, error::download_manager_error::DownloadManagerError, AppState
+        download_manager_frontend::DownloadManagerSignal, downloadable::Downloadable,
+    },
+    error::download_manager_error::DownloadManagerError, DropFunctionState,
 };
 
 use super::download_agent::GameDownloadAgent;
 
 #[tauri::command]
-pub fn download_game(
+pub async fn download_game(
     game_id: String,
     game_version: String,
     install_dir: usize,
-    state: tauri::State<'_, Mutex<AppState>>,
+    state: tauri::State<'_, DropFunctionState<'_>>,
 ) -> Result<(), DownloadManagerError<DownloadManagerSignal>> {
-    let sender = state.lock().unwrap().download_manager.get_sender();
-    let game_download_agent = Arc::new(Box::new(GameDownloadAgent::new(
+    let sender = state.lock().await.download_manager.get_sender();
+    let game_download_agent = Arc::new(Box::new(GameDownloadAgent::new_from_index(
         game_id,
         game_version,
         install_dir,
         sender,
-    )) as Box<dyn Downloadable + Send + Sync>);
+    ).await) as Box<dyn Downloadable + Send + Sync>);
     Ok(state
         .lock()
-        .unwrap()
+        .await
+        .download_manager
+        .queue_download(game_download_agent)?)
+}
+
+#[tauri::command]
+pub async fn resume_download(
+    game_id: String,
+    state: tauri::State<'_, DropFunctionState<'_>>,
+) -> Result<(), DownloadManagerError<DownloadManagerSignal>> {
+    let s = borrow_db_checked().await
+        .applications
+        .game_statuses
+        .get(&game_id)
+        .unwrap()
+        .clone();
+
+    let (version_name, install_dir) = match s {
+        GameDownloadStatus::Remote {} => unreachable!(),
+        GameDownloadStatus::SetupRequired { .. } => unreachable!(),
+        GameDownloadStatus::Installed { .. } => unreachable!(),
+        GameDownloadStatus::PartiallyInstalled {
+            version_name,
+            install_dir,
+        } => (version_name, install_dir),
+    };
+    let sender = state.lock().await.download_manager.get_sender();
+    let parent_dir: PathBuf = install_dir.into();
+    let game_download_agent = Arc::new(Box::new(GameDownloadAgent::new(
+        game_id,
+        version_name.clone(),
+        parent_dir.parent().unwrap().to_path_buf(),
+        sender,
+    )) as Box<dyn Downloadable + Send + Sync>);
+    Ok(state
+        .lock()
+        .await
         .download_manager
         .queue_download(game_download_agent)?)
 }

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

@@ -1,66 +1,83 @@
+use crate::DB;
 use crate::auth::generate_authorization_header;
-use crate::database::db::borrow_db_checked;
+use crate::database::db::{DatabaseImpls, borrow_db_checked, borrow_db_mut_checked};
 use crate::database::models::data::{
-    ApplicationTransientStatus, DownloadType, DownloadableMetadata, GameDownloadStatus,
+    ApplicationTransientStatus, DownloadType, DownloadableMetadata,
 };
-use crate::download_manager::download_manager::{DownloadManagerSignal, DownloadStatus};
+use crate::download_manager::download_manager_frontend::{DownloadManagerSignal, DownloadStatus};
 use crate::download_manager::downloadable::Downloadable;
-use crate::download_manager::util::download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag};
+use crate::download_manager::util::download_thread_control_flag::{
+    DownloadThreadControl, DownloadThreadControlFlag,
+};
 use crate::download_manager::util::progress_object::{ProgressHandle, ProgressObject};
 use crate::error::application_download_error::ApplicationDownloadError;
 use crate::error::remote_access_error::RemoteAccessError;
 use crate::games::downloads::manifest::{DropDownloadContext, DropManifest};
-use crate::games::library::{on_game_complete, push_game_update, GameUpdateEvent};
+use crate::games::downloads::validate::game_validate_logic;
+use crate::games::library::{on_game_complete, on_game_incomplete, push_game_update};
 use crate::remote::requests::make_request;
-use crate::DB;
-use log::{debug, error, info};
-use rayon::ThreadPoolBuilder;
-use slice_deque::SliceDeque;
-use std::fs::{create_dir_all, File};
-use std::path::Path;
+use log::{debug, error, info, warn};
+use std::collections::HashMap;
+use std::fs::{OpenOptions, create_dir_all};
+use std::path::{Path, PathBuf};
 use std::sync::mpsc::Sender;
 use std::sync::{Arc, Mutex};
 use std::time::Instant;
 use tauri::{AppHandle, Emitter};
+use tokio::sync::mpsc;
 
 #[cfg(target_os = "linux")]
-use rustix::fs::{fallocate, FallocateFlags};
+use rustix::fs::{FallocateFlags, fallocate};
 
 use super::download_logic::download_game_chunk;
-use super::stored_manifest::StoredManifest;
+use super::drop_data::DropData;
+
+// This is cursed but necessary
+// See the message where it is used
+unsafe fn extend_lifetime<'b, R>(r: &'b R) -> &'static R {
+    unsafe { std::mem::transmute::<&'b R, &'static R>(r) }
+}
 
 pub struct GameDownloadAgent {
     pub id: String,
     pub version: String,
     pub control_flag: DownloadThreadControl,
     contexts: Mutex<Vec<DropDownloadContext>>,
-    completed_contexts: Mutex<SliceDeque<usize>>,
+    context_map: Mutex<HashMap<String, bool>>,
     pub manifest: Mutex<Option<DropManifest>>,
     pub progress: Arc<ProgressObject>,
     sender: Sender<DownloadManagerSignal>,
-    pub stored_manifest: StoredManifest,
+    pub stored_manifest: DropData,
     status: Mutex<DownloadStatus>,
 }
 
 impl GameDownloadAgent {
-    pub fn new(
+    pub async fn new_from_index(
         id: String,
         version: String,
         target_download_dir: usize,
         sender: Sender<DownloadManagerSignal>,
     ) -> Self {
-        // Don't run by default
-        let control_flag = DownloadThreadControl::new(DownloadThreadControlFlag::Stop);
-
-        let db_lock = borrow_db_checked();
+        let db_lock = borrow_db_checked().await;
         let base_dir = db_lock.applications.install_dirs[target_download_dir].clone();
         drop(db_lock);
 
+        Self::new(id, version, base_dir, sender)
+    }
+    pub fn new(
+        id: String,
+        version: String,
+        base_dir: PathBuf,
+        sender: Sender<DownloadManagerSignal>,
+    ) -> Self {
+        // Don't run by default
+        let control_flag = DownloadThreadControl::new(DownloadThreadControlFlag::Stop);
+
         let base_dir_path = Path::new(&base_dir);
         let data_base_dir_path = base_dir_path.join(id.clone());
 
         let stored_manifest =
-            StoredManifest::generate(id.clone(), version.clone(), data_base_dir_path.clone());
+            DropData::generate(id.clone(), version.clone(), data_base_dir_path.clone());
 
         Self {
             id,
@@ -68,7 +85,7 @@ impl GameDownloadAgent {
             control_flag,
             manifest: Mutex::new(None),
             contexts: Mutex::new(Vec::new()),
-            completed_contexts: Mutex::new(SliceDeque::new()),
+            context_map: Mutex::new(HashMap::new()),
             progress: Arc::new(ProgressObject::new(0, 0, sender.clone())),
             sender,
             stored_manifest,
@@ -77,8 +94,8 @@ impl GameDownloadAgent {
     }
 
     // Blocking
-    pub fn setup_download(&self) -> Result<(), ApplicationDownloadError> {
-        self.ensure_manifest_exists()?;
+    pub async fn setup_download(&self) -> Result<(), ApplicationDownloadError> {
+        self.ensure_manifest_exists().await?;
 
         self.ensure_contexts()?;
 
@@ -88,8 +105,9 @@ impl GameDownloadAgent {
     }
 
     // Blocking
-    pub fn download(&self, app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError> {
-        self.setup_download()?;
+    pub async fn download(&self, app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError> {
+        debug!("starting download");
+        self.setup_download().await?;
         self.set_progress_object_params();
         let timer = Instant::now();
         push_game_update(
@@ -105,6 +123,7 @@ impl GameDownloadAgent {
         );
         let res = self
             .run()
+            .await
             .map_err(|_| ApplicationDownloadError::DownloadError);
 
         debug!(
@@ -115,37 +134,39 @@ impl GameDownloadAgent {
         res
     }
 
-    pub fn ensure_manifest_exists(&self) -> Result<(), ApplicationDownloadError> {
+    pub async fn ensure_manifest_exists(&self) -> Result<(), ApplicationDownloadError> {
         if self.manifest.lock().unwrap().is_some() {
             return Ok(());
         }
 
-        self.download_manifest()
+        self.download_manifest().await
     }
 
-    fn download_manifest(&self) -> Result<(), ApplicationDownloadError> {
-        let header = generate_authorization_header();
-        let client = reqwest::blocking::Client::new();
+    async fn download_manifest(&self) -> Result<(), ApplicationDownloadError> {
+        let header = generate_authorization_header().await;
+        let client = reqwest::Client::new();
         let response = make_request(
             &client,
             &["/api/v1/client/game/manifest"],
             &[("id", &self.id), ("version", &self.version)],
-            |f| f.header("Authorization", header),
+            async |f| f.header("Authorization", header),
         )
+        .await
         .map_err(ApplicationDownloadError::Communication)?
         .send()
+        .await
         .map_err(|e| ApplicationDownloadError::Communication(e.into()))?;
 
         if response.status() != 200 {
             return Err(ApplicationDownloadError::Communication(
                 RemoteAccessError::ManifestDownloadFailed(
                     response.status(),
-                    response.text().unwrap(),
+                    response.text().await.unwrap(),
                 ),
             ));
         }
 
-        let manifest_download: DropManifest = response.json().unwrap();
+        let manifest_download: DropManifest = response.json().await.unwrap();
 
         if let Ok(mut manifest) = self.manifest.lock() {
             *manifest = Some(manifest_download);
@@ -173,11 +194,15 @@ impl GameDownloadAgent {
     }
 
     pub fn ensure_contexts(&self) -> Result<(), ApplicationDownloadError> {
-        if !self.contexts.lock().unwrap().is_empty() {
-            return Ok(());
+        if self.contexts.lock().unwrap().is_empty() {
+            self.generate_contexts()?;
         }
 
-        self.generate_contexts()?;
+        self.context_map
+            .lock()
+            .unwrap()
+            .extend(self.stored_manifest.get_contexts());
+
         Ok(())
     }
 
@@ -189,20 +214,19 @@ impl GameDownloadAgent {
         let base_path = Path::new(&self.stored_manifest.base_path);
         create_dir_all(base_path).unwrap();
 
-        {
-            let mut completed_contexts_lock = self.completed_contexts.lock().unwrap();
-            completed_contexts_lock.clear();
-            completed_contexts_lock
-                .extend_from_slice(&self.stored_manifest.get_completed_contexts());
-        }
-
         for (raw_path, chunk) in manifest {
             let path = base_path.join(Path::new(&raw_path));
 
             let container = path.parent().unwrap();
             create_dir_all(container).unwrap();
 
-            let file = File::create(path.clone()).unwrap();
+            let file = OpenOptions::new()
+                .read(true)
+                .write(true)
+                .truncate(true)
+                .create(true)
+                .open(path.clone())
+                .unwrap();
             let mut running_offset = 0;
 
             for (index, length) in chunk.lengths.iter().enumerate() {
@@ -225,133 +249,156 @@ impl GameDownloadAgent {
                 let _ = fallocate(file, FallocateFlags::empty(), 0, running_offset);
             }
         }
+        let existing_contexts = self.stored_manifest.get_completed_contexts();
+        self.stored_manifest.set_contexts(
+            &contexts
+                .iter()
+                .map(|x| (x.checksum.clone(), existing_contexts.contains(&x.checksum)))
+                .collect::<Vec<(String, bool)>>(),
+        );
+
         *self.contexts.lock().unwrap() = contexts;
 
         Ok(())
     }
 
-    // TODO: Change return value on Err
-    pub fn run(&self) -> Result<bool, ()> {
-        let max_download_threads = borrow_db_checked().settings.max_download_threads;
+    pub async fn run(&self) -> Result<bool, ()> {
+        let max_download_threads = borrow_db_checked().await.settings.max_download_threads;
 
         debug!(
             "downloading game: {} with {} threads",
             self.id, max_download_threads
         );
-        let pool = ThreadPoolBuilder::new()
-            .num_threads(max_download_threads)
-            .build()
+
+        let base_url = DB
+            .fetch_base_url()
+            .await
+            .join("/api/v1/client/chunk")
             .unwrap();
+        let client = reqwest::Client::new();
+        let client_ref = unsafe { extend_lifetime(&client) };
 
-        let completed_indexes = Arc::new(boxcar::Vec::new());
-        let completed_indexes_loop_arc = completed_indexes.clone();
+        let rt = tokio::runtime::Builder::new_multi_thread()
+            .worker_threads(max_download_threads)
+            .thread_name("drop-download-thread")
+            .enable_io()
+            .enable_time()
+            .build()
+            .map_err(|e| {
+                warn!("failed to create download scheduler: {e}");
+                ()
+            })?;
 
-        let contexts = self.contexts.lock().unwrap();
-        debug!("{:#?}", contexts);
-        pool.scope(|scope| {
-            let client = &reqwest::blocking::Client::new();
+        let (tx, mut rx) = mpsc::channel(32);
+
+        // Scope this for safety
+        {
+            let contexts = self.contexts.lock().unwrap();
+            debug!("{contexts:#?}");
+
+            let context_map = self.context_map.lock().unwrap();
             for (index, context) in contexts.iter().enumerate() {
-                let client = client.clone();
-                let completed_indexes = completed_indexes_loop_arc.clone();
-
                 let progress = self.progress.get(index);
                 let progress_handle = ProgressHandle::new(progress, self.progress.clone());
 
                 // If we've done this one already, skip it
-                if self.completed_contexts.lock().unwrap().contains(&index) {
+                if Some(&true) == context_map.get(&context.checksum) {
                     progress_handle.skip(context.length);
                     continue;
                 }
 
                 let sender = self.sender.clone();
 
-                let request = match make_request(
-                    &client,
-                    &["/api/v1/client/chunk"],
-                    &[
-                        ("id", &context.game_id),
-                        ("version", &context.version),
-                        ("name", &context.file_name),
-                        ("chunk", &context.index.to_string()),
-                    ],
-                    |r| r.header("Authorization", generate_authorization_header()),
-                ) {
-                    Ok(request) => request,
-                    Err(e) => {
-                        sender
-                            .send(DownloadManagerSignal::Error(
-                                ApplicationDownloadError::Communication(e),
-                            ))
-                            .unwrap();
-                        continue;
-                    }
-                };
-
-                scope.spawn(move |_| {
-                    match download_game_chunk(context, &self.control_flag, progress_handle, request)
+                let local_tx = tx.clone();
+                /*
+                This lifetime extensions are necessary, because this loop acts like a scope
+                but Rust doesn't know that.
+                */
+                let context = unsafe { extend_lifetime(context) };
+                let self_static = unsafe { extend_lifetime(self) };
+                let mut base_url = base_url.clone();
+                rt.spawn(async move {
                     {
-                        Ok(res) => {
-                            if res {
-                                completed_indexes.push(index);
-                            }
+                        let mut query = base_url.query_pairs_mut();
+                        let query_params = [
+                            ("id", &context.game_id),
+                            ("version", &context.version),
+                            ("name", &context.file_name),
+                            ("chunk", &context.index.to_string()),
+                        ];
+                        for (param, val) in query_params {
+                            query.append_pair(param.as_ref(), val.as_ref());
                         }
+                    }
+
+                    let request = client_ref.get(base_url);
+
+                    match download_game_chunk(
+                        context,
+                        &self_static.control_flag,
+                        progress_handle,
+                        request,
+                    )
+                    .await
+                    {
+                        Ok(true) => {
+                            local_tx.send(context.checksum.clone()).await.unwrap();
+                        }
+                        Ok(false) => {}
                         Err(e) => {
-                            error!("{}", e);
+                            error!("{e}");
                             sender.send(DownloadManagerSignal::Error(e)).unwrap();
                         }
                     }
                 });
             }
-        });
+        }
 
-        let newly_completed = completed_indexes.to_owned();
+        let mut newly_completed = Vec::new();
+        while let Some(completed_checksum) = rx.recv().await {
+            newly_completed.push(completed_checksum);
+        }
 
-        let completed_lock_len = {
-            let mut completed_contexts_lock = self.completed_contexts.lock().unwrap();
-            for (_, item) in newly_completed.iter() {
-                completed_contexts_lock.push_front(*item);
-            }
+        // 'return' from the download
+        let mut context_map_lock = self.context_map.lock().unwrap();
+        for item in newly_completed.iter() {
+            context_map_lock.insert(item.clone(), true);
+        }
+        let completed_lock_len = context_map_lock.values().filter(|x| **x).count();
 
-            completed_contexts_lock.len()
-        };
+        let contexts = self.contexts.lock().unwrap();
+        let contexts = contexts
+            .iter()
+            .map(|x| {
+                (
+                    x.checksum.clone(),
+                    context_map_lock.get(&x.checksum).cloned().unwrap_or(false),
+                )
+            })
+            .collect::<Vec<(String, bool)>>();
 
-        // If we're not out of contexts, we're not done, so we don't fire completed
-        if completed_lock_len != contexts.len() {
+        drop(context_map_lock);
+
+        self.stored_manifest.set_contexts(&contexts);
+        self.stored_manifest.write();
+
+        // If there are any contexts left which are false
+        if !contexts.iter().all(|x| x.1) {
             info!(
                 "download agent for {} exited without completing ({}/{})",
                 self.id.clone(),
                 completed_lock_len,
                 contexts.len(),
             );
-            self.stored_manifest
-                .set_completed_contexts(self.completed_contexts.lock().unwrap().as_slice());
-            self.stored_manifest.write();
             return Ok(false);
         }
 
-        // We've completed
-        self.sender
-            .send(DownloadManagerSignal::Completed(self.metadata()))
-            .unwrap();
-
         Ok(true)
     }
 }
 
+#[async_trait::async_trait]
 impl Downloadable for GameDownloadAgent {
-    fn download(&self, app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError> {
-        *self.status.lock().unwrap() = DownloadStatus::Downloading;
-        self.download(app_handle)
-    }
-
-    fn progress(&self) -> Arc<ProgressObject> {
-        self.progress.clone()
-    }
-
-    fn control_flag(&self) -> DownloadThreadControl {
-        self.control_flag.clone()
-    }
-
     fn metadata(&self) -> DownloadableMetadata {
         DownloadableMetadata {
             id: self.id.clone(),
@@ -360,53 +407,75 @@ impl Downloadable for GameDownloadAgent {
         }
     }
 
-    fn on_initialised(&self, _app_handle: &tauri::AppHandle) {
+    async fn download(&self, app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError> {
+        debug!("starting download from downloadable trait");
+        *self.status.lock().unwrap() = DownloadStatus::Downloading;
+        self.download(app_handle).await
+    }
+
+    async fn progress(&self) -> Arc<ProgressObject> {
+        self.progress.clone()
+    }
+
+    async fn control_flag(&self) -> DownloadThreadControl {
+        self.control_flag.clone()
+    }
+
+    async fn on_initialised(&self, _app_handle: &tauri::AppHandle) {
         *self.status.lock().unwrap() = DownloadStatus::Queued;
     }
 
-    fn on_error(&self, app_handle: &tauri::AppHandle, error: &ApplicationDownloadError) {
+    async fn on_error(&self, app_handle: &tauri::AppHandle, error: &ApplicationDownloadError) {
         *self.status.lock().unwrap() = DownloadStatus::Error;
         app_handle
             .emit("download_error", error.to_string())
             .unwrap();
 
-        error!("error while managing download: {}", error);
+        error!("error while managing download: {error}");
 
-        let mut handle = DB.borrow_data_mut().unwrap();
+        let mut handle = borrow_db_mut_checked().await;
         handle
             .applications
             .transient_statuses
             .remove(&self.metadata());
     }
 
-    fn on_complete(&self, app_handle: &tauri::AppHandle) {
+    async fn on_complete(&self, app_handle: &tauri::AppHandle) {
         on_game_complete(
             &self.metadata(),
             self.stored_manifest.base_path.to_string_lossy().to_string(),
             app_handle,
         )
+        .await
         .unwrap();
     }
 
-    // TODO: fix this function. It doesn't restart the download properly, nor does it reset the state properly
-    fn on_incomplete(&self, app_handle: &tauri::AppHandle) {
-        let meta = self.metadata();
-        *self.status.lock().unwrap() = DownloadStatus::Queued;
-        app_handle
-            .emit(
-                &format!("update_game/{}", meta.id),
-                GameUpdateEvent {
-                    game_id: meta.id.clone(),
-                    status: (Some(GameDownloadStatus::Remote {}), None),
-                    version: None,
-                },
-            )
-            .unwrap();
+    async fn on_incomplete(&self, app_handle: &tauri::AppHandle) {
+        on_game_incomplete(
+            &self.metadata(),
+            self.stored_manifest.base_path.to_string_lossy().to_string(),
+            app_handle,
+        )
+        .await
+        .unwrap();
     }
 
-    fn on_cancelled(&self, _app_handle: &tauri::AppHandle) {}
+    async fn on_cancelled(&self, _app_handle: &tauri::AppHandle) {}
 
-    fn status(&self) -> DownloadStatus {
+    async fn status(&self) -> DownloadStatus {
         self.status.lock().unwrap().clone()
     }
+
+    async fn validate(&self) -> Result<bool, ApplicationDownloadError> {
+        *self.status.lock().unwrap() = DownloadStatus::Validating;
+        let contexts = self.contexts.lock().unwrap().clone();
+        game_validate_logic(
+            &self.stored_manifest,
+            contexts,
+            self.progress.clone(),
+            self.sender.clone(),
+            &self.control_flag,
+        )
+        .await
+    }
 }

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

@@ -1,73 +1,76 @@
-use crate::download_manager::util::download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag};
+use crate::download_manager::util::download_thread_control_flag::{
+    DownloadThreadControl, DownloadThreadControlFlag,
+};
 use crate::download_manager::util::progress_object::ProgressHandle;
 use crate::error::application_download_error::ApplicationDownloadError;
+use crate::error::drop_server_error::DropServerError;
 use crate::error::remote_access_error::RemoteAccessError;
 use crate::games::downloads::manifest::DropDownloadContext;
-use log::warn;
+use crate::remote::auth::{generate_authorization_header, generate_authorization_header_part};
+use futures::TryStreamExt;
+use log::{debug, info, warn};
 use md5::{Context, Digest};
-use reqwest::blocking::{RequestBuilder, Response};
+use reqwest::RequestBuilder;
+use tokio::fs::{File, OpenOptions};
+use tokio::io::{AsyncRead, AsyncReadExt, AsyncSeekExt, AsyncWrite, AsyncWriteExt};
+use tokio_util::io::StreamReader;
 
-use std::fs::{set_permissions, Permissions};
-use std::io::{ErrorKind, Read};
+use std::fs::{Permissions, set_permissions};
+use std::io::Write;
 #[cfg(unix)]
 use std::os::unix::fs::PermissionsExt;
 use std::{
-    fs::{File, OpenOptions},
-    io::{self, BufWriter, Seek, SeekFrom, Write},
+    io::{self, SeekFrom},
     path::PathBuf,
 };
 
-pub struct DropWriter<W: Write> {
+pub struct DropWriter<W: AsyncWrite> {
     hasher: Context,
     destination: W,
 }
 impl DropWriter<File> {
-    fn new(path: PathBuf) -> Self {
+    async fn new(path: PathBuf) -> Self {
         Self {
-            destination: OpenOptions::new().write(true).open(path).unwrap(),
+            destination: OpenOptions::new().write(true).open(path).await.unwrap(),
             hasher: Context::new(),
         }
     }
 
-    fn finish(mut self) -> io::Result<Digest> {
-        self.flush().unwrap();
+    async fn finish(mut self) -> io::Result<Digest> {
+        self.flush().await.unwrap();
         Ok(self.hasher.compute())
     }
-}
-// Write automatically pushes to file and hasher
-impl Write for DropWriter<File> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.hasher.write_all(buf).map_err(|e| {
-            io::Error::new(
-                ErrorKind::Other,
-                format!("Unable to write to hasher: {}", e),
-            )
-        })?;
-        self.destination.write(buf)
+
+    async fn write(&mut self, mut buf: &[u8]) -> io::Result<()> {
+        self.hasher
+            .write_all(buf)
+            .map_err(|e| io::Error::other(format!("Unable to write to hasher: {e}")))?;
+        self.destination.write_all_buf(&mut buf).await
     }
 
-    fn flush(&mut self) -> io::Result<()> {
+    async fn flush(&mut self) -> io::Result<()> {
         self.hasher.flush()?;
-        self.destination.flush()
+        self.destination.flush().await
     }
-}
-// Seek moves around destination output
-impl Seek for DropWriter<File> {
-    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
-        self.destination.seek(pos)
+
+    async fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
+        self.destination.seek(pos).await
     }
 }
 
-pub struct DropDownloadPipeline<'a, R: Read, W: Write> {
+pub struct DropDownloadPipeline<'a, R: AsyncRead, W: AsyncWrite> {
     pub source: R,
     pub destination: DropWriter<W>,
     pub control_flag: &'a DownloadThreadControl,
     pub progress: ProgressHandle,
     pub size: usize,
 }
-impl<'a> DropDownloadPipeline<'a, Response, File> {
+impl<'a, R> DropDownloadPipeline<'a, R, File>
+where
+    R: AsyncRead + Unpin,
+{
     fn new(
-        source: Response,
+        source: R,
         destination: DropWriter<File>,
         control_flag: &'a DownloadThreadControl,
         progress: ProgressHandle,
@@ -82,38 +85,51 @@ impl<'a> DropDownloadPipeline<'a, Response, File> {
         }
     }
 
-    fn copy(&mut self) -> Result<bool, io::Error> {
+    async fn copy(&mut self) -> Result<bool, io::Error> {
         let copy_buf_size = 512;
         let mut copy_buf = vec![0; copy_buf_size];
-        let mut buf_writer = BufWriter::with_capacity(1024 * 1024, &mut self.destination);
 
         let mut current_size = 0;
         loop {
             if self.control_flag.get() == DownloadThreadControlFlag::Stop {
+                self.destination.flush().await?;
                 return Ok(false);
             }
 
-            let bytes_read = self.source.read(&mut copy_buf)?;
+            let mut bytes_read = self.source.read(&mut copy_buf).await?;
+            info!("read {}", bytes_read);
             current_size += bytes_read;
 
-            buf_writer.write_all(&copy_buf[0..bytes_read])?;
+            if current_size > self.size {
+                let over = current_size - self.size;
+                warn!("server sent too many bytes... {over} over");
+                bytes_read -= over;
+                current_size = self.size;
+            }
+
+            self.destination.write(&copy_buf[0..bytes_read]).await?;
             self.progress.add(bytes_read);
 
-            if current_size == self.size {
+            if current_size >= self.size {
+                debug!(
+                    "finished with final size of {} vs {}",
+                    current_size, self.size
+                );
                 break;
             }
         }
+        self.destination.flush().await?;
 
         Ok(true)
     }
 
-    fn finish(self) -> Result<Digest, io::Error> {
-        let checksum = self.destination.finish()?;
+    async fn finish(self) -> Result<Digest, io::Error> {
+        let checksum = self.destination.finish().await?;
         Ok(checksum)
     }
 }
 
-pub fn download_game_chunk(
+pub async fn download_game_chunk(
     ctx: &DropDownloadContext,
     control_flag: &DownloadThreadControl,
     progress: ProgressHandle,
@@ -125,22 +141,33 @@ pub fn download_game_chunk(
         return Ok(false);
     }
 
+    let header_generator = generate_authorization_header_part().await;
+
     let response = request
+        .header("Authorization", header_generator())
         .send()
+        .await
         .map_err(|e| ApplicationDownloadError::Communication(e.into()))?;
 
     if response.status() != 200 {
-        let err = response.json().unwrap();
+        debug!("chunk request got status code: {}", response.status());
+        let raw_res = response.text().await.unwrap();
+        if let Ok(err) = serde_json::from_str::<DropServerError>(&raw_res) {
+            return Err(ApplicationDownloadError::Communication(
+                RemoteAccessError::InvalidResponse(err),
+            ));
+        };
         return Err(ApplicationDownloadError::Communication(
-            RemoteAccessError::InvalidResponse(err),
+            RemoteAccessError::UnparseableResponse(raw_res),
         ));
     }
 
-    let mut destination = DropWriter::new(ctx.path.clone());
+    let mut destination = DropWriter::new(ctx.path.clone()).await;
 
     if ctx.offset != 0 {
         destination
             .seek(SeekFrom::Start(ctx.offset))
+            .await
             .expect("Failed to seek to file offset");
     }
 
@@ -148,20 +175,27 @@ pub fn download_game_chunk(
     if content_length.is_none() {
         warn!("recieved 0 length content from server");
         return Err(ApplicationDownloadError::Communication(
-            RemoteAccessError::InvalidResponse(response.json().unwrap()),
+            RemoteAccessError::InvalidResponse(response.json().await.unwrap()),
         ));
     }
 
-    let mut pipeline = DropDownloadPipeline::new(
-        response,
-        destination,
-        control_flag,
-        progress,
-        content_length.unwrap().try_into().unwrap(),
+    let length = content_length.unwrap().try_into().unwrap();
+
+    if length != ctx.length {
+        return Err(ApplicationDownloadError::DownloadError);
+    }
+
+    let response_stream = StreamReader::new(
+        response
+            .bytes_stream()
+            .map_err(|e| std::io::Error::other(e)),
     );
+    let mut pipeline =
+        DropDownloadPipeline::new(response_stream, destination, control_flag, progress, length);
 
     let completed = pipeline
         .copy()
+        .await
         .map_err(|e| ApplicationDownloadError::IoError(e.kind()))?;
     if !completed {
         return Ok(false);
@@ -176,6 +210,7 @@ pub fn download_game_chunk(
 
     let checksum = pipeline
         .finish()
+        .await
         .map_err(|e| ApplicationDownloadError::IoError(e.kind()))?;
 
     let res = hex::encode(checksum.0);
@@ -183,5 +218,10 @@ pub fn download_game_chunk(
         return Err(ApplicationDownloadError::Checksum);
     }
 
+    debug!(
+        "Successfully finished download #{}, copied {} bytes",
+        ctx.checksum, length
+    );
+
     Ok(true)
 }

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

@@ -0,0 +1,105 @@
+use std::{
+    fs::File,
+    io::{Read, Write},
+    path::PathBuf,
+};
+
+use log::{debug, error, info, warn};
+use native_model::{Decode, Encode};
+
+pub type DropData = v1::DropData;
+
+static DROP_DATA_PATH: &str = ".dropdata";
+
+pub mod v1 {
+    use std::{path::PathBuf, sync::Mutex};
+
+    use native_model::native_model;
+    use serde::{Deserialize, Serialize};
+
+    #[derive(Serialize, Deserialize, Debug)]
+    #[native_model(id = 9, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
+    pub struct DropData {
+        pub game_id: String,
+        pub game_version: String,
+        pub contexts: Mutex<Vec<(String, bool)>>,
+        pub base_path: PathBuf,
+    }
+
+    impl DropData {
+        pub fn new(game_id: String, game_version: String, base_path: PathBuf) -> Self {
+            Self {
+                base_path,
+                game_id,
+                game_version,
+                contexts: Mutex::new(Vec::new()),
+            }
+        }
+    }
+}
+
+impl DropData {
+    pub fn generate(game_id: String, game_version: String, base_path: PathBuf) -> Self {
+        let mut file = match File::open(base_path.join(DROP_DATA_PATH)) {
+            Ok(file) => file,
+            Err(_) => {
+                debug!("Generating new dropdata for game {game_id}");
+                return DropData::new(game_id, game_version, base_path);
+            }
+        };
+
+        let mut s = Vec::new();
+        match file.read_to_end(&mut s) {
+            Ok(_) => {}
+            Err(e) => {
+                error!("{e}");
+                return DropData::new(game_id, game_version, base_path);
+            }
+        };
+
+        match native_model::rmp_serde_1_3::RmpSerde::decode(s) {
+            Ok(manifest) => manifest,
+            Err(e) => {
+                warn!("{e}");
+                DropData::new(game_id, game_version, base_path)
+            }
+        }
+    }
+    pub fn write(&self) {
+        let manifest_raw = match native_model::rmp_serde_1_3::RmpSerde::encode(&self) {
+            Ok(data) => data,
+            Err(_) => return,
+        };
+
+        let mut file = match File::create(self.base_path.join(DROP_DATA_PATH)) {
+            Ok(file) => file,
+            Err(e) => {
+                error!("{e}");
+                return;
+            }
+        };
+
+        match file.write_all(&manifest_raw) {
+            Ok(_) => {}
+            Err(e) => error!("{e}"),
+        };
+    }
+    pub fn set_contexts(&self, completed_contexts: &[(String, bool)]) {
+        *self.contexts.lock().unwrap() = completed_contexts.to_owned();
+    }
+    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 })
+            .collect()
+    }
+    pub fn get_contexts(&self) -> Vec<(String, bool)> {
+        info!(
+            "Any contexts which are complete? {}",
+            self.contexts.lock().unwrap().iter().any(|x| x.1)
+        );
+        self.contexts.lock().unwrap().clone()
+    }
+}

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

@@ -1,5 +1,6 @@
 pub mod commands;
 pub mod download_agent;
 mod download_logic;
+mod drop_data;
 mod manifest;
-mod stored_manifest;
+pub mod validate;

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

@@ -1,79 +0,0 @@
-use std::{
-    fs::File,
-    io::{Read, Write},
-    path::PathBuf,
-    sync::Mutex,
-};
-
-use log::{error, warn};
-use serde::{Deserialize, Serialize};
-use serde_binary::binary_stream::Endian;
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct StoredManifest {
-    game_id: String,
-    game_version: String,
-    pub completed_contexts: Mutex<Vec<usize>>,
-    pub base_path: PathBuf,
-}
-
-static DROP_DATA_PATH: &str = ".dropdata";
-
-impl StoredManifest {
-    pub fn new(game_id: String, game_version: String, base_path: PathBuf) -> Self {
-        Self {
-            base_path,
-            game_id,
-            game_version,
-            completed_contexts: Mutex::new(Vec::new()),
-        }
-    }
-    pub fn generate(game_id: String, game_version: String, base_path: PathBuf) -> Self {
-        let mut file = match File::open(base_path.join(DROP_DATA_PATH)) {
-            Ok(file) => file,
-            Err(_) => return StoredManifest::new(game_id, game_version, base_path),
-        };
-
-        let mut s = Vec::new();
-        match file.read_to_end(&mut s) {
-            Ok(_) => {}
-            Err(e) => {
-                error!("{}", e);
-                return StoredManifest::new(game_id, game_version, base_path);
-            }
-        };
-
-        match serde_binary::from_vec::<StoredManifest>(s, Endian::Little) {
-            Ok(manifest) => manifest,
-            Err(e) => {
-                warn!("{}", e);
-                StoredManifest::new(game_id, game_version, base_path)
-            }
-        }
-    }
-    pub fn write(&self) {
-        let manifest_raw = match serde_binary::to_vec(&self, Endian::Little) {
-            Ok(json) => json,
-            Err(_) => return,
-        };
-
-        let mut file = match File::create(self.base_path.join(DROP_DATA_PATH)) {
-            Ok(file) => file,
-            Err(e) => {
-                error!("{}", e);
-                return;
-            }
-        };
-
-        match file.write_all(&manifest_raw) {
-            Ok(_) => {}
-            Err(e) => error!("{}", e),
-        };
-    }
-    pub fn set_completed_contexts(&self, completed_contexts: &[usize]) {
-        *self.completed_contexts.lock().unwrap() = completed_contexts.to_owned();
-    }
-    pub fn get_completed_contexts(&self) -> Vec<usize> {
-        self.completed_contexts.lock().unwrap().clone()
-    }
-}

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

@@ -0,0 +1,172 @@
+use std::{
+    fs::File,
+    io::{self, BufWriter, Read, Seek, SeekFrom, Write},
+    sync::{Arc, mpsc::Sender},
+};
+
+use log::{debug, error, info};
+use md5::Context;
+
+use crate::{
+    database::db::borrow_db_checked,
+    download_manager::{
+        download_manager_frontend::DownloadManagerSignal,
+        util::{
+            download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag},
+            progress_object::{ProgressHandle, ProgressObject},
+        },
+    },
+    error::application_download_error::ApplicationDownloadError,
+    games::downloads::{drop_data::DropData, manifest::DropDownloadContext},
+};
+
+pub async fn game_validate_logic(
+    dropdata: &DropData,
+    contexts: Vec<DropDownloadContext>,
+    progress: Arc<ProgressObject>,
+    sender: Sender<DownloadManagerSignal>,
+    control_flag: &DownloadThreadControl,
+) -> Result<bool, ApplicationDownloadError> {
+    progress.reset(contexts.len());
+    let max_download_threads = borrow_db_checked().await.settings.max_download_threads;
+
+    debug!(
+        "validating game: {} with {} threads",
+        dropdata.game_id, max_download_threads
+    );
+
+    debug!("{contexts:#?}");
+    let invalid_chunks = Arc::new(boxcar::Vec::new());
+    unsafe {
+        async_scoped::TokioScope::scope_and_collect(|scope| {
+            for (index, context) in contexts.iter().enumerate() {
+                let current_progress = progress.get(index);
+                let progress_handle = ProgressHandle::new(current_progress, progress.clone());
+                let invalid_chunks_scoped = invalid_chunks.clone();
+                let sender = sender.clone();
+
+                scope.spawn(async move {
+                    match validate_game_chunk(context, control_flag, progress_handle) {
+                        Ok(true) => {
+                            debug!(
+                                "Finished context #{} with checksum {}",
+                                index, context.checksum
+                            );
+                        }
+                        Ok(false) => {
+                            debug!(
+                                "Didn't finish context #{} with checksum {}",
+                                index, &context.checksum
+                            );
+                            invalid_chunks_scoped.push(context.checksum.clone());
+                        }
+                        Err(e) => {
+                            error!("{e}");
+                            sender.send(DownloadManagerSignal::Error(e)).unwrap();
+                        }
+                    }
+                });
+            }
+        }).await
+    };
+
+    // If there are any contexts left which are false
+    if !invalid_chunks.is_empty() {
+        info!(
+            "validation of game id {} failed for chunks {:?}",
+            dropdata.game_id.clone(),
+            invalid_chunks
+        );
+        return Ok(false);
+    }
+
+    Ok(true)
+}
+
+pub fn validate_game_chunk(
+    ctx: &DropDownloadContext,
+    control_flag: &DownloadThreadControl,
+    progress: ProgressHandle,
+) -> Result<bool, ApplicationDownloadError> {
+    debug!(
+        "Starting chunk validation {}, {}, {} #{}",
+        ctx.file_name, ctx.index, ctx.offset, ctx.checksum
+    );
+    // If we're paused
+    if control_flag.get() == DownloadThreadControlFlag::Stop {
+        progress.set(0);
+        return Ok(false);
+    }
+
+    let mut source = File::open(&ctx.path).unwrap();
+
+    if ctx.offset != 0 {
+        source
+            .seek(SeekFrom::Start(ctx.offset))
+            .expect("Failed to seek to file offset");
+    }
+
+    let mut hasher = md5::Context::new();
+
+    let completed =
+        validate_copy(&mut source, &mut hasher, ctx.length, control_flag, progress).unwrap();
+    if !completed {
+        return Ok(false);
+    };
+
+    let res = hex::encode(hasher.compute().0);
+    if res != ctx.checksum {
+        println!(
+            "Checksum failed. Correct: {}, actual: {}",
+            &ctx.checksum, &res
+        );
+        return Ok(false);
+    }
+
+    debug!(
+        "Successfully finished verification #{}, copied {} bytes",
+        ctx.checksum, ctx.length
+    );
+
+    Ok(true)
+}
+
+fn validate_copy(
+    source: &mut File,
+    dest: &mut Context,
+    size: usize,
+    control_flag: &DownloadThreadControl,
+    progress: ProgressHandle,
+) -> Result<bool, io::Error> {
+    let copy_buf_size = 512;
+    let mut copy_buf = vec![0; copy_buf_size];
+    let mut buf_writer = BufWriter::with_capacity(1024 * 1024, dest);
+    let mut total_bytes = 0;
+
+    loop {
+        if control_flag.get() == DownloadThreadControlFlag::Stop {
+            buf_writer.flush()?;
+            return Ok(false);
+        }
+
+        let mut bytes_read = source.read(&mut copy_buf)?;
+        total_bytes += bytes_read;
+
+        // If we read over (likely), truncate our read to
+        // the right size
+        if total_bytes > size {
+            let over = total_bytes - size;
+            bytes_read -= over;
+            total_bytes = size;
+        }
+
+        buf_writer.write_all(&copy_buf[0..bytes_read])?;
+        progress.add(bytes_read);
+
+        if total_bytes >= size {
+            break;
+        }
+    }
+    buf_writer.flush()?;
+    Ok(true)
+}

src-tauri/src/games/library.rs

@@ -1,33 +1,32 @@
 use std::fs::remove_dir_all;
-use std::sync::Mutex;
-use std::thread::spawn;
 
 use log::{debug, error, warn};
 use serde::{Deserialize, Serialize};
-use tauri::Emitter;
 use tauri::AppHandle;
+use tauri::Emitter;
+use tokio::spawn;
 
-use crate::database::db::{borrow_db_checked, borrow_db_mut_checked, save_db};
+use crate::database::db::{borrow_db_checked, borrow_db_mut_checked};
 use crate::database::models::data::{
     ApplicationTransientStatus, DownloadableMetadata, GameDownloadStatus, GameVersion,
 };
-use crate::download_manager::download_manager::DownloadStatus;
-use crate::error::library_error::LibraryError;
+use crate::download_manager::download_manager_frontend::DownloadStatus;
 use crate::error::remote_access_error::RemoteAccessError;
 use crate::games::state::{GameStatusManager, GameStatusWithTransient};
 use crate::remote::auth::generate_authorization_header;
 use crate::remote::cache::{cache_object, get_cached_object, get_cached_object_db};
 use crate::remote::requests::make_request;
-use crate::{AppState, DB};
+use crate::DropFunctionState;
+use bitcode::{Decode, Encode};
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Debug)]
 pub struct FetchGameStruct {
     game: Game,
     status: GameStatusWithTransient,
     version: Option<GameVersion>,
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug, Default)]
+#[derive(Serialize, Deserialize, Clone, Debug, Default, Encode, Decode)]
 #[serde(rename_all = "camelCase")]
 pub struct Game {
     id: String,
@@ -72,28 +71,30 @@ pub struct StatsUpdateEvent {
     pub time: usize,
 }
 
-pub fn fetch_library_logic(
-    state: tauri::State<'_, Mutex<AppState>>,
+pub async fn fetch_library_logic(
+    state: tauri::State<'_, DropFunctionState<'_>>,
 ) -> Result<Vec<Game>, RemoteAccessError> {
-    let header = generate_authorization_header();
+    let header = generate_authorization_header().await;
 
-    let client = reqwest::blocking::Client::new();
-    let response = make_request(&client, &["/api/v1/client/user/library"], &[], |f| {
+    let client = reqwest::Client::new();
+    let response = make_request(&client, &["/api/v1/client/user/library"], &[], async |f| {
         f.header("Authorization", header)
-    })?
-    .send()?;
+    })
+    .await?
+    .send()
+    .await?;
 
     if response.status() != 200 {
-        let err = response.json().unwrap();
-        warn!("{:?}", err);
+        let err = response.json().await.unwrap();
+        warn!("{err:?}");
         return Err(RemoteAccessError::InvalidResponse(err));
     }
 
-    let mut games: Vec<Game> = response.json()?;
+    let mut games: Vec<Game> = response.json().await?;
 
-    let mut handle = state.lock().unwrap();
+    let mut handle = state.lock().await;
 
-    let mut db_handle = borrow_db_mut_checked();
+    let mut db_handle = borrow_db_mut_checked().await;
 
     for game in games.iter() {
         handle.games.insert(game.id.clone(), game.clone());
@@ -106,28 +107,28 @@ pub fn fetch_library_logic(
     }
 
     // Add games that are installed but no longer in library
-    for (_, meta) in &db_handle.applications.installed_game_version {
-        if games.iter().find(|e| e.id == meta.id).is_some() {
+    for meta in db_handle.applications.installed_game_version.values() {
+        if games.iter().any(|e| e.id == meta.id) {
             continue;
         }
         // 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::<String, Game>(meta.id.clone(), &db_handle).await?;
         games.push(game);
     }
 
     drop(handle);
     drop(db_handle);
-    cache_object("library", &games)?;
+    cache_object("library", &games).await?;
 
     Ok(games)
 }
-pub fn fetch_library_logic_offline(
-    _state: tauri::State<'_, Mutex<AppState>>,
+pub async fn fetch_library_logic_offline(
+    _state: tauri::State<'_, DropFunctionState<'_>>,
 ) -> Result<Vec<Game>, RemoteAccessError> {
-    let mut games: Vec<Game> = get_cached_object("library")?;
+    let mut games: Vec<Game> = get_cached_object("library").await?;
 
-    let db_handle = borrow_db_checked();
+    let db_handle = borrow_db_checked().await;
 
     games.retain(|game| {
         db_handle
@@ -138,13 +139,13 @@ pub fn fetch_library_logic_offline(
 
     Ok(games)
 }
-pub fn fetch_game_logic(
+pub async fn fetch_game_logic(
     id: String,
-    state: tauri::State<'_, Mutex<AppState>>,
+    state: tauri::State<'_, DropFunctionState<'_>>,
 ) -> Result<FetchGameStruct, RemoteAccessError> {
-    let mut state_handle = state.lock().unwrap();
+    let mut state_handle = state.lock().await;
 
-    let handle = DB.borrow_data().unwrap();
+    let handle = borrow_db_checked().await;
 
     let metadata_option = handle.applications.installed_game_version.get(&id);
     let version = match metadata_option {
@@ -164,7 +165,7 @@ pub fn fetch_game_logic(
 
     let game = state_handle.games.get(&id);
     if let Some(game) = game {
-        let status = GameStatusManager::fetch_state(&id);
+        let status = GameStatusManager::fetch_state(&id).await;
 
         let data = FetchGameStruct {
             game: game.clone(),
@@ -172,29 +173,31 @@ pub fn fetch_game_logic(
             version,
         };
 
-        cache_object(id, game)?;
+        cache_object(id, game).await?;
 
         return Ok(data);
     }
-    let client = reqwest::blocking::Client::new();
-    let response = make_request(&client, &["/api/v1/client/game/", &id], &[], |r| {
-        r.header("Authorization", generate_authorization_header())
-    })?
-    .send()?;
+    let client = reqwest::Client::new();
+    let response = make_request(&client, &["/api/v1/client/game/", &id], &[], async |r| {
+        r.header("Authorization", generate_authorization_header().await)
+    })
+    .await?
+    .send()
+    .await?;
 
     if response.status() == 404 {
         return Err(RemoteAccessError::GameNotFound(id));
     }
     if response.status() != 200 {
-        let err = response.json().unwrap();
-        warn!("{:?}", err);
+        let err = response.json().await.unwrap();
+        warn!("{err:?}");
         return Err(RemoteAccessError::InvalidResponse(err));
     }
 
-    let game: Game = response.json()?;
+    let game: Game = response.json().await?;
     state_handle.games.insert(id.clone(), game.clone());
 
-    let mut db_handle = borrow_db_mut_checked();
+    let mut db_handle = borrow_db_mut_checked().await;
 
     db_handle
         .applications
@@ -203,7 +206,7 @@ pub fn fetch_game_logic(
         .or_insert(GameDownloadStatus::Remote {});
     drop(db_handle);
 
-    let status = GameStatusManager::fetch_state(&id);
+    let status = GameStatusManager::fetch_state(&id).await;
 
     let data = FetchGameStruct {
         game: game.clone(),
@@ -211,16 +214,16 @@ pub fn fetch_game_logic(
         version,
     };
 
-    cache_object(id, &game)?;
+    cache_object(id, &game).await?;
 
     Ok(data)
 }
 
-pub fn fetch_game_logic_offline(
+pub async fn fetch_game_logic_offline(
     id: String,
-    _state: tauri::State<'_, Mutex<AppState>>,
+    _state: tauri::State<'_, DropFunctionState<'_>>,
 ) -> Result<FetchGameStruct, RemoteAccessError> {
-    let handle = DB.borrow_data().unwrap();
+    let handle = borrow_db_checked().await;
     let metadata_option = handle.applications.installed_game_version.get(&id);
     let version = match metadata_option {
         None => None,
@@ -237,8 +240,8 @@ pub fn fetch_game_logic_offline(
     };
     drop(handle);
 
-    let status = GameStatusManager::fetch_state(&id);
-    let game = get_cached_object::<String, Game>(id)?;
+    let status = GameStatusManager::fetch_state(&id).await;
+    let game = get_cached_object::<String, Game>(id).await?;
 
     Ok(FetchGameStruct {
         game,
@@ -247,30 +250,32 @@ pub fn fetch_game_logic_offline(
     })
 }
 
-pub fn fetch_game_verion_options_logic(
+pub async fn fetch_game_verion_options_logic(
     game_id: String,
-    state: tauri::State<'_, Mutex<AppState>>,
+    state: tauri::State<'_, DropFunctionState<'_>>,
 ) -> Result<Vec<GameVersion>, RemoteAccessError> {
-    let client = reqwest::blocking::Client::new();
+    let client = reqwest::Client::new();
 
     let response = make_request(
         &client,
         &["/api/v1/client/game/versions"],
         &[("id", &game_id)],
-        |r| r.header("Authorization", generate_authorization_header()),
-    )?
-    .send()?;
+        async |r| r.header("Authorization", generate_authorization_header().await),
+    )
+    .await?
+    .send()
+    .await?;
 
     if response.status() != 200 {
-        let err = response.json().unwrap();
-        warn!("{:?}", err);
+        let err = response.json().await.unwrap();
+        warn!("{err:?}");
         return Err(RemoteAccessError::InvalidResponse(err));
     }
 
-    let data: Vec<GameVersion> = response.json()?;
+    let data: Vec<GameVersion> = response.json().await?;
 
-    let state_lock = state.lock().unwrap();
-    let process_manager_lock = state_lock.process_manager.lock().unwrap();
+    let state_lock = state.lock().await;
+    let process_manager_lock = state_lock.process_manager.lock().await;
     let data: Vec<GameVersion> = data
         .into_iter()
         .filter(|v| process_manager_lock.valid_platform(&v.platform).unwrap())
@@ -281,9 +286,9 @@ pub fn fetch_game_verion_options_logic(
     Ok(data)
 }
 
-pub fn uninstall_game_logic(meta: DownloadableMetadata, app_handle: &AppHandle) {
+pub async fn uninstall_game_logic(meta: DownloadableMetadata, app_handle: &AppHandle) {
     debug!("triggered uninstall for agent");
-    let mut db_handle = borrow_db_mut_checked();
+    let mut db_handle = borrow_db_mut_checked().await;
     db_handle
         .applications
         .transient_statuses
@@ -313,6 +318,10 @@ pub fn uninstall_game_logic(meta: DownloadableMetadata, app_handle: &AppHandle)
             version_name,
             install_dir,
         } => Some((version_name, install_dir)),
+        GameDownloadStatus::PartiallyInstalled {
+            version_name,
+            install_dir,
+        } => Some((version_name, install_dir)),
         _ => None,
     } {
         db_handle
@@ -324,48 +333,52 @@ pub fn uninstall_game_logic(meta: DownloadableMetadata, app_handle: &AppHandle)
         drop(db_handle);
 
         let app_handle = app_handle.clone();
-        spawn(move || match remove_dir_all(install_dir) {
-            Err(e) => {
-                error!("{}", e);
-            }
-            Ok(_) => {
-                let mut db_handle = borrow_db_mut_checked();
-                db_handle.applications.transient_statuses.remove(&meta);
-                db_handle
-                    .applications
-                    .installed_game_version
-                    .remove(&meta.id);
-                db_handle
-                    .applications
-                    .game_statuses
-                    .entry(meta.id.clone())
-                    .and_modify(|e| *e = GameDownloadStatus::Remote {});
-                drop(db_handle);
-                save_db();
+        spawn(async move {
+            match remove_dir_all(install_dir) {
+                Err(e) => {
+                    error!("{e}");
+                }
+                Ok(_) => {
+                    let mut db_handle = borrow_db_mut_checked().await;
+                    db_handle.applications.transient_statuses.remove(&meta);
+                    db_handle
+                        .applications
+                        .installed_game_version
+                        .remove(&meta.id);
+                    db_handle
+                        .applications
+                        .game_statuses
+                        .entry(meta.id.clone())
+                        .and_modify(|e| *e = GameDownloadStatus::Remote {});
+                    drop(db_handle);
 
-                debug!("uninstalled game id {}", &meta.id);
-                app_handle.emit("update_library", {}).unwrap();
+                    debug!("uninstalled game id {}", &meta.id);
+                    app_handle.emit("update_library", ()).unwrap();
 
-                push_game_update(
-                    &app_handle,
-                    &meta.id,
-                    None,
-                    (Some(GameDownloadStatus::Remote {}), None),
-                );
+                    push_game_update(
+                        &app_handle,
+                        &meta.id,
+                        None,
+                        (Some(GameDownloadStatus::Remote {}), None),
+                    );
+                }
             }
         });
+    } else {
+        warn!("invalid previous state for uninstall, failing silently.")
     }
 }
 
-pub fn get_current_meta(game_id: &String) -> Option<DownloadableMetadata> {
+pub async fn get_current_meta(game_id: &String) -> Option<DownloadableMetadata> {
     borrow_db_checked()
+        .await
         .applications
         .installed_game_version
         .get(game_id)
         .cloned()
 }
 
-pub fn on_game_complete(
+pub async fn on_game_incomplete(
     meta: &DownloadableMetadata,
     install_dir: String,
     app_handle: &AppHandle,
@@ -375,9 +388,7 @@ pub fn on_game_complete(
         return Err(RemoteAccessError::GameNotFound(meta.id.clone()));
     }
 
-    let header = generate_authorization_header();
-
-    let client = reqwest::blocking::Client::new();
+    let client = reqwest::Client::new();
     let response = make_request(
         &client,
         &["/api/v1/client/game/version"],
@@ -385,13 +396,79 @@ pub fn on_game_complete(
             ("id", &meta.id),
             ("version", meta.version.as_ref().unwrap()),
         ],
-        |f| f.header("Authorization", header),
-    )?
-    .send()?;
+        async |f| f.header("Authorization", generate_authorization_header().await),
+    )
+    .await?
+    .send()
+    .await?;
 
-    let game_version: GameVersion = response.json()?;
+    let game_version: GameVersion = response.json().await?;
 
-    let mut handle = borrow_db_mut_checked();
+    let mut handle = borrow_db_mut_checked().await;
+    handle
+        .applications
+        .game_versions
+        .entry(meta.id.clone())
+        .or_default()
+        .insert(meta.version.clone().unwrap(), game_version.clone());
+    handle
+        .applications
+        .installed_game_version
+        .insert(meta.id.clone(), meta.clone());
+
+    let status = GameDownloadStatus::PartiallyInstalled {
+        version_name: meta.version.clone().unwrap(),
+        install_dir,
+    };
+
+    handle
+        .applications
+        .game_statuses
+        .insert(meta.id.clone(), status.clone());
+    drop(handle);
+    app_handle
+        .emit(
+            &format!("update_game/{}", meta.id),
+            GameUpdateEvent {
+                game_id: meta.id.clone(),
+                status: (Some(status), None),
+                version: Some(game_version),
+            },
+        )
+        .unwrap();
+
+    Ok(())
+}
+
+pub async fn on_game_complete(
+    meta: &DownloadableMetadata,
+    install_dir: String,
+    app_handle: &AppHandle,
+) -> Result<(), RemoteAccessError> {
+    // Fetch game version information from remote
+    if meta.version.is_none() {
+        return Err(RemoteAccessError::GameNotFound(meta.id.clone()));
+    }
+
+    let header = generate_authorization_header().await;
+
+    let client = reqwest::Client::new();
+    let response = make_request(
+        &client,
+        &["/api/v1/client/game/version"],
+        &[
+            ("id", &meta.id),
+            ("version", meta.version.as_ref().unwrap()),
+        ],
+        async |f| f.header("Authorization", header),
+    )
+    .await?
+    .send()
+    .await?;
+
+    let game_version: GameVersion = response.json().await?;
+
+    let mut handle = borrow_db_mut_checked().await;
     handle
         .applications
         .game_versions
@@ -404,7 +481,6 @@ pub fn on_game_complete(
         .insert(meta.id.clone(), meta.clone());
 
     drop(handle);
-    save_db();
 
     let status = if game_version.setup_command.is_empty() {
         GameDownloadStatus::Installed {
@@ -418,13 +494,12 @@ pub fn on_game_complete(
         }
     };
 
-    let mut db_handle = borrow_db_mut_checked();
+    let mut db_handle = borrow_db_mut_checked().await;
     db_handle
         .applications
         .game_statuses
         .insert(meta.id.clone(), status.clone());
     drop(db_handle);
-    save_db();
     app_handle
         .emit(
             &format!("update_game/{}", meta.id),
@@ -447,7 +522,7 @@ pub fn push_game_update(
 ) {
     app_handle
         .emit(
-            &format!("update_game/{}", game_id),
+            &format!("update_game/{game_id}"),
             GameUpdateEvent {
                 game_id: game_id.clone(),
                 status,
@@ -456,51 +531,3 @@ pub fn push_game_update(
         )
         .unwrap();
 }
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct FrontendGameOptions {
-    launch_string: String,
-}
-
-#[tauri::command]
-pub fn update_game_configuration(
-    game_id: String,
-    options: FrontendGameOptions,
-) -> Result<(), LibraryError> {
-    let mut handle = DB.borrow_data_mut().unwrap();
-    let installed_version = handle
-        .applications
-        .installed_game_version
-        .get(&game_id)
-        .ok_or(LibraryError::MetaNotFound(game_id))?;
-
-    let id = installed_version.id.clone();
-    let version = installed_version.version.clone().unwrap();
-
-    let mut existing_configuration = handle
-        .applications
-        .game_versions
-        .get(&id)
-        .unwrap()
-        .get(&version)
-        .unwrap()
-        .clone();
-
-    // Add more options in here
-    existing_configuration.launch_command_template = options.launch_string;
-
-    // Add no more options past here
-
-    handle
-        .applications
-        .game_versions
-        .get_mut(&id)
-        .unwrap()
-        .insert(version.to_string(), existing_configuration);
-
-    drop(handle);
-    save_db();
-
-    Ok(())
-}

src-tauri/src/games/state.rs

@@ -10,8 +10,8 @@ pub type GameStatusWithTransient = (
 pub struct GameStatusManager {}
 
 impl GameStatusManager {
-    pub fn fetch_state(game_id: &String) -> GameStatusWithTransient {
-        let db_lock = borrow_db_checked();
+    pub async fn fetch_state(game_id: &String) -> GameStatusWithTransient {
+        let db_lock = borrow_db_checked().await;
         let online_state = match db_lock.applications.installed_game_version.get(game_id) {
             Some(meta) => db_lock.applications.transient_statuses.get(meta).cloned(),
             None => None,

src-tauri/src/lib.rs

@@ -1,3 +1,8 @@
+#![feature(fn_traits)]
+#![feature(duration_constructors)]
+#![feature(impl_trait_in_assoc_type)]
+#![deny(clippy::all)]
+
 mod database;
 mod games;
 
@@ -7,23 +12,27 @@ mod error;
 mod process;
 mod remote;
 
-use crate::database::db::DatabaseImpls;
+use crate::database::db::OnceCellDatabase;
+use crate::games::commands::update_game_configuration;
+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},
     cleanup::{cleanup_and_exit, quit},
 };
-use client::commands::fetch_state;
 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,
 };
-use download_manager::download_manager::DownloadManager;
 use download_manager::download_manager_builder::DownloadManagerBuilder;
+use download_manager::download_manager_frontend::DownloadManager;
 use games::collections::commands::{
     add_game_to_collection, create_collection, delete_collection, delete_game_in_collection,
     fetch_collection, fetch_collections,
@@ -32,13 +41,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;
+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};
@@ -49,19 +58,21 @@ use remote::commands::{
 use remote::fetch_object::{fetch_object, fetch_object_offline};
 use remote::server_proto::{handle_server_proto, handle_server_proto_offline};
 use serde::{Deserialize, Serialize};
-use std::env;
+use std::collections::HashMap;
+use std::fs::File;
+use std::io::Write;
+use std::panic::PanicHookInfo;
 use std::path::Path;
 use std::str::FromStr;
 use std::sync::Arc;
-use std::{
-    collections::HashMap,
-    sync::{LazyLock, Mutex},
-};
+use std::time::SystemTime;
+use std::{env, panic};
 use tauri::menu::{Menu, MenuItem, PredefinedMenuItem};
 use tauri::tray::TrayIconBuilder;
 use tauri::{AppHandle, Manager, RunEvent, WindowEvent};
 use tauri_plugin_deep_link::DeepLinkExt;
 use tauri_plugin_dialog::DialogExt;
+use tokio::sync::Mutex;
 
 #[derive(Clone, Copy, Serialize, Eq, PartialEq)]
 pub enum AppStatus {
@@ -74,7 +85,7 @@ pub enum AppStatus {
     ServerUnavailable,
 }
 
-#[derive(Clone, Serialize, Deserialize)]
+#[derive(Clone, Serialize, Deserialize, Encode, Decode)]
 #[serde(rename_all = "camelCase")]
 pub struct User {
     id: String,
@@ -97,13 +108,13 @@ pub struct AppState<'a> {
     process_manager: Arc<Mutex<ProcessManager<'a>>>,
 }
 
-fn setup(handle: AppHandle) -> AppState<'static> {
+async fn setup(handle: AppHandle) -> AppState<'static> {
     let logfile = FileAppender::builder()
         .encoder(Box::new(PatternEncoder::new(
             "{d} | {l} | {f}:{L} - {m}{n}",
         )))
         .append(false)
-        .build(DATA_ROOT_DIR.lock().unwrap().join("./drop.log"))
+        .build(DATA_ROOT_DIR.join("./drop.log"))
         .unwrap();
 
     let console = ConsoleAppender::builder()
@@ -133,7 +144,7 @@ fn setup(handle: AppHandle) -> AppState<'static> {
     let process_manager = Arc::new(Mutex::new(ProcessManager::new(handle.clone())));
 
     debug!("checking if database is set up");
-    let is_set_up = DB.database_is_set_up();
+    let is_set_up = DB.database_is_set_up().await;
     if !is_set_up {
         return AppState {
             status: AppStatus::NotConfigured,
@@ -147,15 +158,16 @@ fn setup(handle: AppHandle) -> AppState<'static> {
     debug!("database is set up");
 
     // TODO: Account for possible failure
-    let (app_status, user) = auth::setup();
+    let (app_status, user) = auth::setup().await;
 
-    let db_handle = borrow_db_checked();
+    let db_handle = borrow_db_checked().await;
     let mut missing_games = Vec::new();
     let statuses = db_handle.applications.game_statuses.clone();
     drop(db_handle);
     for (game_id, status) in statuses.into_iter() {
         match status {
             GameDownloadStatus::Remote {} => {}
+            GameDownloadStatus::PartiallyInstalled { .. } => {}
             GameDownloadStatus::SetupRequired {
                 version_name: _,
                 install_dir,
@@ -177,9 +189,9 @@ fn setup(handle: AppHandle) -> AppState<'static> {
         }
     }
 
-    info!("detected games missing: {:?}", missing_games);
+    info!("detected games missing: {missing_games:?}");
 
-    let mut db_handle = borrow_db_mut_checked();
+    let mut db_handle = borrow_db_mut_checked().await;
     for game_id in missing_games {
         db_handle
             .applications
@@ -193,8 +205,8 @@ fn setup(handle: AppHandle) -> AppState<'static> {
     debug!("finished setup!");
 
     // Sync autostart state
-    if let Err(e) = sync_autostart_on_startup(&handle) {
-        warn!("failed to sync autostart state: {}", e);
+    if let Err(e) = sync_autostart_on_startup(&handle).await {
+        warn!("failed to sync autostart state: {e}");
     }
 
     AppState {
@@ -206,11 +218,34 @@ fn setup(handle: AppHandle) -> AppState<'static> {
     }
 }
 
-pub static DB: LazyLock<DatabaseInterface> = LazyLock::new(DatabaseInterface::set_up_database);
+pub static DB: OnceCellDatabase = OnceCellDatabase::new();
+pub type DropFunctionState<'a> = Mutex<AppState<'a>>;
+
+pub fn custom_panic_handler(e: &PanicHookInfo) -> Option<()> {
+    let crash_file = DATA_ROOT_DIR.join(format!(
+        "crash-{}.log",
+        SystemTime::now()
+            .duration_since(SystemTime::UNIX_EPOCH)
+            .ok()?
+            .as_secs()
+    ));
+    let mut file = File::create_new(crash_file).ok()?;
+    file.write_all(format!("Drop crashed with the following panic:\n{e}").as_bytes())
+        .ok()?;
+    drop(file);
+
+    Some(())
+}
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
+    panic::set_hook(Box::new(|e| {
+        let _ = custom_panic_handler(e);
+        println!("{e}");
+    }));
+
     let mut builder = tauri::Builder::default()
+        .plugin(tauri_plugin_opener::init())
         .plugin(tauri_plugin_os::init())
         .plugin(tauri_plugin_dialog::init());
 
@@ -259,6 +294,7 @@ pub fn run() {
             delete_game_in_collection,
             // Downloads
             download_game,
+            resume_download,
             move_download_in_queue,
             pause_downloads,
             resume_downloads,
@@ -269,6 +305,7 @@ pub fn run() {
             kill_game,
             toggle_autostart,
             get_autostart_enabled,
+            open_process_logs
         ])
         .plugin(tauri_plugin_shell::init())
         .plugin(tauri_plugin_dialog::init())
@@ -277,118 +314,142 @@ pub fn run() {
             Some(vec!["--minimize"]),
         ))
         .setup(|app| {
-            let handle = app.handle().clone();
-            let state = setup(handle);
-            debug!("initialized drop client");
-            app.manage(Mutex::new(state));
+            let app = app.handle().clone();
 
-            {
-                use tauri_plugin_deep_link::DeepLinkExt;
-                let _ = app.deep_link().register_all();
-                debug!("registered all pre-defined deep links");
-            }
+            tauri::async_runtime::spawn(async move {
+                DB.init(async { DatabaseInterface::set_up_database().await })
+                    .await;
 
-            let handle = app.handle().clone();
-
-            let _main_window = tauri::WebviewWindowBuilder::new(
-                &handle,
-                "main", // BTW this is not the name of the window, just the label. Keep this 'main', there are permissions & configs that depend on it
-                tauri::WebviewUrl::App("index.html".into()),
-            )
-            .title("Drop Desktop App")
-            .min_inner_size(1000.0, 500.0)
-            .inner_size(1536.0, 864.0)
-            .decorations(false)
-            .shadow(false)
-            .data_directory(DATA_ROOT_DIR.lock().unwrap().join(".webview"))
-            .build()
-            .unwrap();
-
-            app.deep_link().on_open_url(move |event| {
-                debug!("handling drop:// url");
-                let binding = event.urls();
-                let url = binding.first().unwrap();
-                if url.host_str().unwrap() == "handshake" {
-                    recieve_handshake(handle.clone(), url.path().to_string())
+                let state = setup(app.clone()).await;
+                info!("initialized drop client");
+                if !app.manage(Mutex::new(state)) {
+                    panic!("failed to setup drop state before Tauri does")
                 }
-            });
 
-            let menu = Menu::with_items(
-                app,
-                &[
-                    &MenuItem::with_id(app, "open", "Open", true, None::<&str>)?,
-                    &PredefinedMenuItem::separator(app)?,
-                    /*
-                    &MenuItem::with_id(app, "show_library", "Library", true, None::<&str>)?,
-                    &MenuItem::with_id(app, "show_settings", "Settings", true, None::<&str>)?,
-                    &PredefinedMenuItem::separator(app)?,
-                     */
-                    &MenuItem::with_id(app, "quit", "Quit", true, None::<&str>)?,
-                ],
-            )?;
-
-            run_on_tray(|| {
-                TrayIconBuilder::new()
-                    .icon(app.default_window_icon().unwrap().clone())
-                    .menu(&menu)
-                    .on_menu_event(|app, event| match event.id.as_ref() {
-                        "open" => {
-                            app.webview_windows().get("main").unwrap().show().unwrap();
-                        }
-                        "quit" => {
-                            cleanup_and_exit(app, &app.state());
-                        }
-
-                        _ => {
-                            warn!("menu event not handled: {:?}", event.id);
-                        }
-                    })
-                    .build(app)
-                    .expect("error while setting up tray menu");
-            });
-
-            {
-                let mut db_handle = borrow_db_mut_checked();
-                if let Some(original) = db_handle.prev_database.take() {
-                    warn!(
-                        "Database corrupted. Original file at {}",
-                        original
-                            .canonicalize()
-                            .unwrap()
-                            .to_string_lossy()
-                            .to_string()
-                    );
-                    app.dialog()
-                        .message(
-                            "Database corrupted. A copy has been saved at: ".to_string()
-                                + original.to_str().unwrap(),
-                        )
-                        .title("Database corrupted")
-                        .show(|_| {});
+                {
+                    use tauri_plugin_deep_link::DeepLinkExt;
+                    let _ = app.deep_link().register_all();
+                    debug!("registered all pre-defined deep links");
                 }
-            }
 
+                let deep_link_handle = app.clone();
+
+                app.deep_link().on_open_url(move |event| {
+                    let deep_link_handle = deep_link_handle.clone();
+
+                    tauri::async_runtime::block_on(async move {
+                        debug!("handling drop:// url");
+                        let binding = event.urls();
+                        let url = binding.first().unwrap();
+                        if url.host_str().unwrap() == "handshake" {
+                            recieve_handshake(deep_link_handle, url.path().to_string()).await
+                        }
+                    });
+                });
+
+                let menu = Menu::with_items(
+                    &app,
+                    &[
+                        &MenuItem::with_id(&app, "open", "Open", true, None::<&str>).unwrap(),
+                        &PredefinedMenuItem::separator(&app).unwrap(),
+                        /*
+                        &MenuItem::with_id(app, "show_library", "Library", true, None::<&str>)?,
+                        &MenuItem::with_id(app, "show_settings", "Settings", true, None::<&str>)?,
+                        &PredefinedMenuItem::separator(app)?,
+                         */
+                        &MenuItem::with_id(&app, "quit", "Quit", true, None::<&str>).unwrap(),
+                    ],
+                )
+                .unwrap();
+
+                let tray_app_handle = app.clone();
+                run_on_tray(move || {
+                    TrayIconBuilder::new()
+                        .icon(tray_app_handle.default_window_icon().unwrap().clone())
+                        .menu(&menu)
+                        .on_menu_event(|app, event| {
+                            let tray_app_handle = app.clone();
+                            tauri::async_runtime::block_on(async move {
+                                match event.id.as_ref() {
+                                    "open" => {
+                                        app.webview_windows().get("main").unwrap().show().unwrap();
+                                    }
+                                    "quit" => {
+                                        cleanup_and_exit(
+                                            &tray_app_handle,
+                                            &tray_app_handle.state(),
+                                        )
+                                        .await;
+                                    }
+
+                                    _ => {
+                                        warn!("menu event not handled: {:?}", event.id);
+                                    }
+                                }
+                            })
+                        })
+                        .build(&tray_app_handle)
+                        .expect("error while setting up tray menu");
+                });
+
+                {
+                    let mut db_handle = borrow_db_mut_checked().await;
+                    if let Some(original) = db_handle.prev_database.take() {
+                        warn!(
+                            "Database corrupted. Original file at {}",
+                            original.canonicalize().unwrap().to_string_lossy()
+                        );
+                        app.dialog()
+                            .message(
+                                "Database corrupted. A copy has been saved at: ".to_string()
+                                    + original.to_str().unwrap(),
+                            )
+                            .title("Database corrupted")
+                            .show(|_| {});
+                    }
+                };
+
+                let _main_window = tauri::WebviewWindowBuilder::new(
+                    &app,
+                    "main", // BTW this is not the name of the window, just the label. Keep this 'main', there are permissions & configs that depend on it
+                    tauri::WebviewUrl::App("index.html".into()),
+                )
+                .title("Drop Desktop App")
+                .min_inner_size(1000.0, 500.0)
+                .inner_size(1536.0, 864.0)
+                .decorations(false)
+                .shadow(false)
+                .data_directory(DATA_ROOT_DIR.join(".webview"))
+                .build()
+                .unwrap();
+            });
             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
-            );
+            tauri::async_runtime::block_on(async move {
+                let state = ctx.app_handle().state::<DropFunctionState<'_>>();
+                offline!(
+                    state,
+                    fetch_object,
+                    fetch_object_offline,
+                    request,
+                    responder
+                )
+                .await;
+            });
         })
         .register_asynchronous_uri_scheme_protocol("server", move |ctx, request, responder| {
-            let state: tauri::State<'_, Mutex<AppState>> = ctx.app_handle().state();
-            offline!(
-                state,
-                handle_server_proto,
-                handle_server_proto_offline,
-                request,
-                responder
-            );
+            tauri::async_runtime::block_on(async move {
+                let state = ctx.app_handle().state::<DropFunctionState<'_>>();
+                offline!(
+                    state,
+                    handle_server_proto,
+                    handle_server_proto_offline,
+                    request,
+                    responder
+                )
+                .await;
+            });
         })
         .on_window_event(|window, event| {
             if let WindowEvent::CloseRequested { api, .. } = event {
@@ -412,7 +473,7 @@ pub fn run() {
     });
 }
 
-fn run_on_tray<T: FnOnce() -> ()>(f: T) {
+fn run_on_tray<T: FnOnce()>(f: T) {
     if match std::env::var("NO_TRAY_ICON") {
         Ok(s) => s.to_lowercase() != "true",
         Err(_) => true,

src-tauri/src/main.rs

@@ -2,5 +2,11 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
 fn main() {
+    let global_runtime = tokio::runtime::Builder::new_multi_thread()
+        .worker_threads(32)
+        .enable_all()
+        .build()
+        .unwrap();
+    tauri::async_runtime::set(global_runtime.handle().clone());
     drop_app_lib::run()
 }

src-tauri/src/process/commands.rs

@@ -1,14 +1,12 @@
-use std::sync::Mutex;
-
-use crate::{error::process_error::ProcessError, AppState};
+use crate::{error::process_error::ProcessError, DropFunctionState};
 
 #[tauri::command]
-pub fn launch_game(
+pub async fn launch_game(
     id: String,
-    state: tauri::State<'_, Mutex<AppState>>,
+    state: tauri::State<'_, DropFunctionState<'_>>,
 ) -> Result<(), ProcessError> {
-    let state_lock = state.lock().unwrap();
-    let mut process_manager_lock = state_lock.process_manager.lock().unwrap();
+    let state_lock = state.lock().await;
+    let mut process_manager_lock = state_lock.process_manager.lock().await;
 
     //let meta = DownloadableMetadata {
     //    id,
@@ -16,7 +14,7 @@ pub fn launch_game(
     //    download_type: DownloadType::Game,
     //};
 
-    match process_manager_lock.launch_process(id) {
+    match process_manager_lock.launch_process(id).await {
         Ok(_) => {}
         Err(e) => return Err(e),
     };
@@ -28,13 +26,23 @@ pub fn launch_game(
 }
 
 #[tauri::command]
-pub fn kill_game(
+pub async fn kill_game(
     game_id: String,
-    state: tauri::State<'_, Mutex<AppState>>,
+    state: tauri::State<'_, DropFunctionState<'_>>,
 ) -> Result<(), ProcessError> {
-    let state_lock = state.lock().unwrap();
-    let mut process_manager_lock = state_lock.process_manager.lock().unwrap();
+    let state_lock = state.lock().await;
+    let mut process_manager_lock = state_lock.process_manager.lock().await;
     process_manager_lock
         .kill_game(game_id)
         .map_err(ProcessError::IOError)
 }
+
+#[tauri::command]
+pub async fn open_process_logs(
+    game_id: String,
+    state: tauri::State<'_, DropFunctionState<'_>>,
+) -> Result<(), ProcessError> {
+    let state_lock = state.lock().await;
+    let mut process_manager_lock = state_lock.process_manager.lock().await;
+    process_manager_lock.open_process_logs(game_id)
+}

src-tauri/src/process/process_manager.rs

@@ -1,12 +1,12 @@
 use std::{
     collections::HashMap,
-    fs::OpenOptions,
+    fs::{OpenOptions, create_dir_all},
     io::{self},
     path::PathBuf,
     process::{Command, ExitStatus},
     str::FromStr,
-    sync::{Arc, Mutex},
-    thread::spawn,
+    sync::{Arc},
+    time::{Duration, SystemTime},
 };
 
 use dynfmt::Format;
@@ -14,7 +14,9 @@ use dynfmt::SimpleCurlyFormat;
 use log::{debug, info, warn};
 use serde::{Deserialize, Serialize};
 use shared_child::SharedChild;
-use tauri::{AppHandle, Manager};
+use tauri::{AppHandle, Emitter, Manager};
+use tauri_plugin_opener::OpenerExt;
+use tokio::spawn;
 
 use crate::{
     database::{
@@ -23,25 +25,26 @@ use crate::{
             ApplicationTransientStatus, DownloadType, DownloadableMetadata, GameDownloadStatus,
             GameVersion,
         },
-    },
-    error::process_error::ProcessError,
-    games::{library::push_game_update, state::GameStatusManager},
-    AppState, DB,
+    }, error::process_error::ProcessError, games::{library::push_game_update, state::GameStatusManager}, DropFunctionState, DB
 };
 
+pub struct RunningProcess {
+    handle: Arc<SharedChild>,
+    start: SystemTime,
+    manually_killed: bool,
+}
+
 pub struct ProcessManager<'a> {
     current_platform: Platform,
     log_output_dir: PathBuf,
-    processes: HashMap<String, Arc<SharedChild>>,
+    processes: HashMap<String, RunningProcess>,
     app_handle: AppHandle,
     game_launchers: HashMap<(Platform, Platform), &'a (dyn ProcessHandler + Sync + Send + 'static)>,
 }
 
 impl ProcessManager<'_> {
     pub fn new(app_handle: AppHandle) -> Self {
-        let root_dir_lock = DATA_ROOT_DIR.lock().unwrap();
-        let log_output_dir = root_dir_lock.join("logs");
-        drop(root_dir_lock);
+        let log_output_dir = DATA_ROOT_DIR.join("logs");
 
         ProcessManager {
             #[cfg(target_os = "windows")]
@@ -79,10 +82,11 @@ impl ProcessManager<'_> {
     }
 
     pub fn kill_game(&mut self, game_id: String) -> Result<(), io::Error> {
-        match self.processes.get(&game_id) {
-            Some(child) => {
-                child.kill()?;
-                child.wait()?;
+        match self.processes.get_mut(&game_id) {
+            Some(process) => {
+                process.manually_killed = true;
+                process.handle.kill()?;
+                process.handle.wait()?;
                 Ok(())
             }
             None => Err(io::Error::new(
@@ -92,17 +96,28 @@ impl ProcessManager<'_> {
         }
     }
 
-    fn on_process_finish(&mut self, game_id: String, result: Result<ExitStatus, std::io::Error>) {
+    pub fn open_process_logs(&mut self, game_id: String) -> Result<(), ProcessError> {
+        let dir = self.log_output_dir.join(game_id);
+        self.app_handle
+            .opener()
+            .open_path(dir.to_str().unwrap(), None::<&str>)
+            .map_err(ProcessError::OpenerError)?;
+        Ok(())
+    }
+
+    async fn on_process_finish(&mut self, game_id: String, result: Result<ExitStatus, std::io::Error>) {
         if !self.processes.contains_key(&game_id) {
-            warn!("process on_finish was called, but game_id is no longer valid. finished with result: {:?}", result);
+            warn!(
+                "process on_finish was called, but game_id is no longer valid. finished with result: {result:?}"
+            );
             return;
         }
 
         debug!("process for {:?} exited with {:?}", &game_id, result);
 
-        self.processes.remove(&game_id);
+        let process = self.processes.remove(&game_id).unwrap();
 
-        let mut db_handle = borrow_db_mut_checked();
+        let mut db_handle = borrow_db_mut_checked().await;
         let meta = db_handle
             .applications
             .installed_game_version
@@ -112,49 +127,51 @@ impl ProcessManager<'_> {
         db_handle.applications.transient_statuses.remove(&meta);
 
         let current_state = db_handle.applications.game_statuses.get(&game_id).cloned();
-        if let Some(saved_state) = current_state {
-            if let GameDownloadStatus::SetupRequired {
-                version_name,
-                install_dir,
-            } = saved_state
-            {
-                if let Ok(exit_code) = result {
-                    if exit_code.success() {
-                        db_handle.applications.game_statuses.insert(
-                            game_id.clone(),
-                            GameDownloadStatus::Installed {
-                                version_name: version_name.to_string(),
-                                install_dir: install_dir.to_string(),
-                            },
-                        );
-                    }
-                }
-            }
+        if let Some(GameDownloadStatus::SetupRequired {
+            version_name,
+            install_dir,
+        }) = current_state
+            && let Ok(exit_code) = result
+            && exit_code.success()
+        {
+            db_handle.applications.game_statuses.insert(
+                game_id.clone(),
+                GameDownloadStatus::Installed {
+                    version_name: version_name.to_string(),
+                    install_dir: install_dir.to_string(),
+                },
+            );
         }
         drop(db_handle);
 
-        let status = GameStatusManager::fetch_state(&game_id);
+        let elapsed = process.start.elapsed().unwrap_or(Duration::ZERO);
+        // If we started and ended really quickly, something might've gone wrong
+        // Or if the status isn't 0
+        // Or if it's an error
+        if !process.manually_killed
+            && (elapsed.as_secs() <= 2 || result.is_err() || !result.unwrap().success())
+        {
+            warn!("drop detected that the game {game_id} may have failed to launch properly");
+            let _ = self.app_handle.emit("launch_external_error", &game_id);
+        }
 
+        let status = GameStatusManager::fetch_state(&game_id).await;
         push_game_update(&self.app_handle, &game_id, None, status);
-
-        // TODO better management
     }
 
     pub fn valid_platform(&self, platform: &Platform) -> Result<bool, String> {
         let current = &self.current_platform;
-        Ok(self
-            .game_launchers
-            .contains_key(&(current.clone(), platform.clone())))
+        Ok(self.game_launchers.contains_key(&(*current, *platform)))
     }
 
-    pub fn launch_process(&mut self, game_id: String) -> Result<(), ProcessError> {
+    pub async fn launch_process(&mut self, game_id: String) -> Result<(), ProcessError> {
         if self.processes.contains_key(&game_id) {
             return Err(ProcessError::AlreadyRunning);
         }
 
         let version = match DB
             .borrow_data()
-            .unwrap()
+            .await
             .applications
             .game_statuses
             .get(&game_id)
@@ -162,7 +179,7 @@ impl ProcessManager<'_> {
         {
             Some(GameDownloadStatus::Installed { version_name, .. }) => version_name,
             Some(GameDownloadStatus::SetupRequired { .. }) => {
-                return Err(ProcessError::SetupRequired)
+                return Err(ProcessError::SetupRequired);
             }
             _ => return Err(ProcessError::NotInstalled),
         };
@@ -172,7 +189,7 @@ impl ProcessManager<'_> {
             download_type: DownloadType::Game,
         };
 
-        let mut db_lock = borrow_db_mut_checked();
+        let mut db_lock = borrow_db_mut_checked().await;
         debug!(
             "Launching process {:?} with games {:?}",
             &game_id, db_lock.applications.game_versions
@@ -193,6 +210,10 @@ impl ProcessManager<'_> {
                 version_name,
                 install_dir,
             } => (version_name, install_dir),
+            GameDownloadStatus::PartiallyInstalled {
+                version_name,
+                install_dir,
+            } => (version_name, install_dir),
             _ => return Err(ProcessError::NotDownloaded),
         };
 
@@ -204,18 +225,17 @@ impl ProcessManager<'_> {
             .get(version_name)
             .ok_or(ProcessError::InvalidVersion)?;
 
+        // TODO: refactor this path with open_process_logs
+        let game_log_folder = &self.log_output_dir.join(game_id);
+        create_dir_all(game_log_folder).map_err(ProcessError::IOError)?;
+
         let current_time = chrono::offset::Local::now();
         let log_file = OpenOptions::new()
             .write(true)
             .truncate(true)
             .read(true)
             .create(true)
-            .open(self.log_output_dir.join(format!(
-                "{}-{}-{}.log",
-                &game_id,
-                &version,
-                current_time.timestamp()
-            )))
+            .open(game_log_folder.join(format!("{}-{}.log", &version, current_time.timestamp())))
             .map_err(ProcessError::IOError)?;
 
         let error_file = OpenOptions::new()
@@ -223,16 +243,15 @@ impl ProcessManager<'_> {
             .truncate(true)
             .read(true)
             .create(true)
-            .open(self.log_output_dir.join(format!(
-                "{}-{}-{}-error.log",
-                &game_id,
+            .open(game_log_folder.join(format!(
+                "{}-{}-error.log",
                 &version,
                 current_time.timestamp()
             )))
             .map_err(ProcessError::IOError)?;
 
-        let current_platform = self.current_platform.clone();
-        let target_platform = game_version.platform.clone();
+        let current_platform = self.current_platform;
+        let target_platform = game_version.platform;
 
         let game_launcher = self
             .game_launchers
@@ -248,10 +267,14 @@ impl ProcessManager<'_> {
                 version_name: _,
                 install_dir: _,
             } => (&game_version.setup_command, &game_version.setup_args),
-            GameDownloadStatus::Remote {} => unreachable!("nuh uh"),
+            GameDownloadStatus::PartiallyInstalled {
+                version_name: _,
+                install_dir: _,
+            } => unreachable!("Game registered as 'Partially Installed'"),
+            GameDownloadStatus::Remote {} => unreachable!("Game registered as 'Remote'"),
         };
 
-        let launch = PathBuf::from_str(&install_dir).unwrap().join(launch);
+        let launch = PathBuf::from_str(install_dir).unwrap().join(launch);
         let launch = launch.to_str().unwrap();
 
         let launch_string = game_launcher.create_launch_process(
@@ -275,12 +298,12 @@ impl ProcessManager<'_> {
         #[cfg(target_os = "windows")]
         command.raw_arg(format!("/C \"{}\"", &launch_string));
 
-        info!("launching (in {}): {}", install_dir, launch_string,);
+        info!("launching (in {install_dir}): {launch_string}",);
 
         #[cfg(unix)]
         let mut command: Command = Command::new("sh");
         #[cfg(unix)]
-        command.arg("-c").arg(launch_string);
+        command.args(vec!["-c", &launch_string]);
 
         command
             .stderr(error_file)
@@ -308,14 +331,14 @@ impl ProcessManager<'_> {
         let wait_thread_apphandle = self.app_handle.clone();
         let wait_thread_game_id = meta.clone();
 
-        spawn(move || {
+        spawn(async move {
             let result: Result<ExitStatus, std::io::Error> = launch_process_handle.wait();
 
-            let app_state = wait_thread_apphandle.state::<Mutex<AppState>>();
-            let app_state_handle = app_state.lock().unwrap();
+            let app_state = wait_thread_apphandle.state::<tauri::State<'_, DropFunctionState<'_>>>();
+            let app_state_handle = app_state.lock().await;
 
-            let mut process_manager_handle = app_state_handle.process_manager.lock().unwrap();
-            process_manager_handle.on_process_finish(wait_thread_game_id.id, result);
+            let mut process_manager_handle = app_state_handle.process_manager.lock().await;
+            process_manager_handle.on_process_finish(wait_thread_game_id.id, result).await;
 
             // As everything goes out of scope, they should get dropped
             // But just to explicit about it
@@ -323,7 +346,14 @@ impl ProcessManager<'_> {
             drop(app_state_handle);
         });
 
-        self.processes.insert(meta.id, wait_thread_handle);
+        self.processes.insert(
+            meta.id,
+            RunningProcess {
+                handle: wait_thread_handle,
+                start: SystemTime::now(),
+                manually_killed: false,
+            },
+        );
         Ok(())
     }
 }
@@ -336,9 +366,6 @@ pub enum Platform {
 }
 
 impl Platform {
-    const WINDOWS: bool = cfg!(target_os = "windows");
-    const MAC: bool = cfg!(target_os = "macos");
-    const LINUX: bool = cfg!(target_os = "linux");
     #[cfg(target_os = "windows")]
     pub const HOST: Platform = Self::Windows;
     #[cfg(target_os = "macos")]
@@ -346,8 +373,6 @@ impl Platform {
     #[cfg(target_os = "linux")]
     pub const HOST: Platform = Self::Linux;
 
-
-
     pub fn is_case_sensitive(&self) -> bool {
         match self {
             Self::Windows | Self::MacOs => false,
@@ -373,7 +398,7 @@ impl From<whoami::Platform> for Platform {
             whoami::Platform::Windows => Platform::Windows,
             whoami::Platform::Linux => Platform::Linux,
             whoami::Platform::MacOS => Platform::MacOs,
-            _ => unimplemented!()
+            _ => unimplemented!(),
         }
     }
 }
@@ -416,10 +441,13 @@ impl ProcessHandler for UMULauncher {
     ) -> String {
         debug!("Game override: \"{:?}\"", &game_version.umu_id_override);
         let game_id = match &game_version.umu_id_override {
-            Some(game_override) => game_override
-                .is_empty()
-                .then_some(game_version.game_id.clone())
-                .unwrap_or(game_override.clone()),
+            Some(game_override) => {
+                if game_override.is_empty() {
+                    game_version.game_id.clone()
+                } else {
+                    game_override.clone()
+                }
+            }
             None => game_version.game_id.clone(),
         };
         format!(

src-tauri/src/remote/auth.rs

@@ -3,18 +3,18 @@ use std::{collections::HashMap, env};
 use chrono::Utc;
 use droplet_rs::ssl::sign_nonce;
 use gethostname::gethostname;
-use log::{debug, error, warn};
+use log::{debug, error, info, warn};
 use serde::{Deserialize, Serialize};
-use tauri::{AppHandle, Emitter};
+use tauri::{AppHandle, Emitter, Manager};
 use url::Url;
 
 use crate::{
+    AppStatus, DropFunctionState, User,
     database::{
-        db::{borrow_db_checked, borrow_db_mut_checked, save_db},
+        db::{borrow_db_checked, borrow_db_mut_checked},
         models::data::DatabaseAuth,
     },
     error::{drop_server_error::DropServerError, remote_access_error::RemoteAccessError},
-    AppStatus, User,
 };
 
 use super::{
@@ -49,30 +49,39 @@ struct HandshakeResponse {
     id: String,
 }
 
-pub fn generate_authorization_header() -> String {
+pub async fn generate_authorization_header() -> String {
+    let func = generate_authorization_header_part().await;
+    func()
+}
+
+pub async fn generate_authorization_header_part() -> Box<dyn FnOnce() -> String> {
     let certs = {
-        let db = borrow_db_checked();
+        let db = borrow_db_checked().await;
         db.auth.clone().unwrap()
     };
 
-    let nonce = Utc::now().timestamp_millis().to_string();
+    Box::new(move || {
+        let nonce = Utc::now().timestamp_millis().to_string();
 
-    let signature = sign_nonce(certs.private, nonce.clone()).unwrap();
+        let signature = sign_nonce(certs.private, nonce.clone()).unwrap();
 
-    format!("Nonce {} {} {}", certs.client_id, nonce, signature)
+        format!("Nonce {} {} {}", certs.client_id, nonce, signature)
+    })
 }
 
-pub fn fetch_user() -> Result<User, RemoteAccessError> {
-    let header = generate_authorization_header();
+pub async fn fetch_user() -> Result<User, RemoteAccessError> {
+    let header = generate_authorization_header().await;
 
-    let client = reqwest::blocking::Client::new();
-    let response = make_request(&client, &["/api/v1/client/user"], &[], |f| {
+    let client = reqwest::Client::new();
+    let response = make_request(&client, &["/api/v1/client/user"], &[], async |f| {
         f.header("Authorization", header)
-    })?
-    .send()?;
+    })
+    .await?
+    .send()
+    .await?;
     if response.status() != 200 {
-        let err: DropServerError = response.json()?;
-        warn!("{:?}", err);
+        let err: DropServerError = response.json().await?;
+        warn!("{err:?}");
 
         if err.status_message == "Nonce expired" {
             return Err(RemoteAccessError::OutOfSync);
@@ -81,10 +90,10 @@ pub fn fetch_user() -> Result<User, RemoteAccessError> {
         return Err(RemoteAccessError::InvalidResponse(err));
     }
 
-    response.json::<User>().map_err(|e| e.into())
+    response.json::<User>().await.map_err(|e| e.into())
 }
 
-fn recieve_handshake_logic(app: &AppHandle, path: String) -> Result<(), RemoteAccessError> {
+async fn recieve_handshake_logic(app: &AppHandle, path: String) -> Result<(), RemoteAccessError> {
     let path_chunks: Vec<&str> = path.split("/").collect();
     if path_chunks.len() != 3 {
         app.emit("auth/failed", ()).unwrap();
@@ -94,7 +103,7 @@ fn recieve_handshake_logic(app: &AppHandle, path: String) -> Result<(), RemoteAc
     }
 
     let base_url = {
-        let handle = borrow_db_checked();
+        let handle = borrow_db_checked().await;
         Url::parse(handle.base_url.as_str())?
     };
 
@@ -106,63 +115,68 @@ fn recieve_handshake_logic(app: &AppHandle, path: String) -> Result<(), RemoteAc
     };
 
     let endpoint = base_url.join("/api/v1/client/auth/handshake")?;
-    let client = reqwest::blocking::Client::new();
-    let response = client.post(endpoint).json(&body).send()?;
+    let client = reqwest::Client::new();
+    let response = client.post(endpoint).json(&body).send().await?;
     debug!("handshake responsded with {}", response.status().as_u16());
     if !response.status().is_success() {
-        return Err(RemoteAccessError::InvalidResponse(response.json()?));
+        return Err(RemoteAccessError::InvalidResponse(response.json().await?));
     }
-    let response_struct: HandshakeResponse = response.json()?;
+    let response_struct: HandshakeResponse = response.json().await?;
 
     {
-        let mut handle = borrow_db_mut_checked();
+        let mut handle = borrow_db_mut_checked().await;
         handle.auth = Some(DatabaseAuth {
             private: response_struct.private,
             cert: response_struct.certificate,
             client_id: response_struct.id,
             web_token: None, // gets created later
         });
-        drop(handle);
-        save_db();
     }
 
     let web_token = {
-        let header = generate_authorization_header();
+        let header = generate_authorization_header().await;
         let token = client
             .post(base_url.join("/api/v1/client/user/webtoken").unwrap())
             .header("Authorization", header)
             .send()
+            .await
             .unwrap();
 
-        token.text().unwrap()
+        token.text().await.unwrap()
     };
 
-    let mut handle = borrow_db_mut_checked();
+    let mut handle = borrow_db_mut_checked().await;
     let mut_auth = handle.auth.as_mut().unwrap();
     mut_auth.web_token = Some(web_token);
-    drop(handle);
-    save_db();
 
     Ok(())
 }
 
-pub fn recieve_handshake(app: AppHandle, path: String) {
+pub async 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);
+    let handshake_result = recieve_handshake_logic(&app, path).await;
     if let Err(e) = handshake_result {
-        warn!("error with authentication: {}", e);
+        warn!("error with authentication: {e}");
         app.emit("auth/failed", e.to_string()).unwrap();
         return;
     }
 
+    let app_state = app.state::<DropFunctionState<'_>>();
+
+    let (app_status, user) = setup().await;
+
+    let mut state_lock = app_state.lock().await;
+    state_lock.status = app_status;
+    state_lock.user = user;
+
     app.emit("auth/finished", ()).unwrap();
 }
 
-pub fn auth_initiate_logic() -> Result<(), RemoteAccessError> {
+pub async fn auth_initiate_logic() -> Result<(), RemoteAccessError> {
     let base_url = {
-        let db_lock = borrow_db_checked();
+        let db_lock = borrow_db_checked().await;
         Url::parse(&db_lock.base_url.clone())?
     };
 
@@ -178,40 +192,40 @@ pub fn auth_initiate_logic() -> Result<(), RemoteAccessError> {
         ]),
     };
 
-    let client = reqwest::blocking::Client::new();
-    let response = client.post(endpoint.to_string()).json(&body).send()?;
+    let client = reqwest::Client::new();
+    let response = client.post(endpoint.to_string()).json(&body).send().await?;
 
     if response.status() != 200 {
-        let data: DropServerError = response.json()?;
+        let data: DropServerError = response.json().await?;
         error!("could not start handshake: {}", data.status_message);
 
         return Err(RemoteAccessError::HandshakeFailed(data.status_message));
     }
 
-    let redir_url = response.text()?;
+    let redir_url = response.text().await?;
     let complete_redir_url = base_url.join(&redir_url)?;
 
-    debug!("opening web browser to continue authentication");
+    info!("opening web browser to continue authentication: {}", complete_redir_url);
     webbrowser::open(complete_redir_url.as_ref()).unwrap();
 
     Ok(())
 }
 
-pub fn setup() -> (AppStatus, Option<User>) {
-    let data = borrow_db_checked();
+pub async fn setup() -> (AppStatus, Option<User>) {
+    let data = borrow_db_checked().await;
     let auth = data.auth.clone();
     drop(data);
 
     if auth.is_some() {
-        let user_result = match fetch_user() {
+        let user_result = match fetch_user().await {
             Ok(data) => data,
             Err(RemoteAccessError::FetchError(_)) => {
-                let user = get_cached_object::<String, User>("user".to_owned()).unwrap();
+                let user = get_cached_object::<_, User>("user").await.unwrap();
                 return (AppStatus::Offline, Some(user));
             }
             Err(_) => return (AppStatus::SignedInNeedsReauth, None),
         };
-        cache_object("user", &user_result).unwrap();
+        cache_object("user", &user_result).await.unwrap();
         return (AppStatus::SignedIn, Some(user_result));
     }
 

src-tauri/src/remote/cache.rs

@@ -1,49 +1,85 @@
+use std::{
+    fmt::Display,
+    time::{Duration, SystemTime},
+};
+
 use crate::{
-    database::{db::borrow_db_checked, models::data::Database},
+    database::{
+        db::borrow_db_checked,
+        models::data::Database,
+    },
     error::remote_access_error::RemoteAccessError,
 };
+use bitcode::{Decode, DecodeOwned, Encode};
 use cacache::Integrity;
-use http::{header::CONTENT_TYPE, response::Builder as ResponseBuilder, Response};
-use serde::{de::DeserializeOwned, Deserialize, Serialize};
-use serde_binary::binary_stream::Endian;
+use http::{Response, header::CONTENT_TYPE, response::Builder as ResponseBuilder};
+use log::info;
 
 #[macro_export]
 macro_rules! offline {
     ($var:expr, $func1:expr, $func2:expr, $( $arg:expr ),* ) => {
 
-        if crate::borrow_db_checked().settings.force_offline || $var.lock().unwrap().status == crate::AppStatus::Offline {
-            $func2( $( $arg ), *)
+        (async || if $crate::borrow_db_checked().await.settings.force_offline || $var.lock().await.status == $crate::AppStatus::Offline {
+            $func2( $( $arg ), *).await
         } else {
-            $func1( $( $arg ), *)
-        }
+            $func1( $( $arg ), *).await
+        })()
     }
 }
 
-pub fn cache_object<'a, K: AsRef<str>, D: Serialize + DeserializeOwned>(
+pub async fn cache_object<K: AsRef<str>, D: Encode>(
     key: K,
     data: &D,
 ) -> Result<Integrity, RemoteAccessError> {
-    let bytes = serde_binary::to_vec(data, Endian::Little).unwrap();
-    cacache::write_sync(&borrow_db_checked().cache_dir, key, bytes)
-        .map_err(|e| RemoteAccessError::Cache(e))
+    let bytes = bitcode::encode(data);
+    cacache::write_sync(&borrow_db_checked().await.cache_dir, key, bytes)
+        .map_err(RemoteAccessError::Cache)
 }
-pub fn get_cached_object<'a, K: AsRef<str>, D: Serialize + DeserializeOwned>(
+pub async 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())
+    get_cached_object_db::<K, D>(key, &&(borrow_db_checked().await)).await
 }
-pub fn get_cached_object_db<'a, K: AsRef<str>, D: Serialize + DeserializeOwned>(
+pub async fn get_cached_object_db<'a, K: AsRef<str> + Display, D: DecodeOwned>(
     key: K,
     db: &Database,
 ) -> Result<D, RemoteAccessError> {
-    let bytes = cacache::read_sync(&db.cache_dir, key).map_err(|e| RemoteAccessError::Cache(e))?;
-    let data = serde_binary::from_slice::<D>(&bytes, Endian::Little).unwrap();
+    let start = SystemTime::now();
+    let bytes = cacache::read(&db.cache_dir, &key)
+        .await
+        .map_err(RemoteAccessError::Cache)?;
+    let read = start.elapsed().unwrap();
+    let data = bitcode::decode::<D>(&bytes).map_err(|_| {
+        RemoteAccessError::Cache(cacache::Error::EntryNotFound(
+            db.cache_dir.clone(),
+            key.to_string(),
+        ))
+    })?;
+    let parse = start.elapsed().unwrap().abs_diff(read);
+    info!(
+        "read object: r: {}, p: {}, b: {}",
+        read.as_millis(),
+        parse.as_millis(),
+        bytes.len()
+    );
     Ok(data)
 }
-#[derive(Serialize, Deserialize)]
+#[derive(Encode, Decode)]
 pub struct ObjectCache {
     content_type: String,
     body: Vec<u8>,
+    expiry: u128,
+}
+
+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()
+    }
 }
 
 impl From<Response<Vec<u8>>> for ObjectCache {
@@ -57,6 +93,12 @@ 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(),
         }
     }
 }
@@ -66,3 +108,9 @@ impl From<ObjectCache> for Response<Vec<u8>> {
         resp_builder.body(value.body).unwrap()
     }
 }
+impl From<&ObjectCache> for Response<Vec<u8>> {
+    fn from(value: &ObjectCache) -> Self {
+        let resp_builder = ResponseBuilder::new().header(CONTENT_TYPE, value.content_type.clone());
+        resp_builder.body(value.body.clone()).unwrap()
+    }
+}

src-tauri/src/remote/commands.rs

@@ -1,35 +1,33 @@
-use std::sync::Mutex;
-
 use log::debug;
-use reqwest::blocking::Client;
+use reqwest::Client;
 use tauri::{AppHandle, Emitter, Manager};
 use url::Url;
 
 use crate::{
-    database::db::{borrow_db_checked, borrow_db_mut_checked, save_db},
+    AppStatus, DropFunctionState,
+    database::db::{borrow_db_checked, borrow_db_mut_checked},
     error::remote_access_error::RemoteAccessError,
     remote::{auth::generate_authorization_header, requests::make_request},
-    AppState, AppStatus,
 };
 
 use super::{
     auth::{auth_initiate_logic, recieve_handshake, setup},
     cache::{cache_object, get_cached_object},
-    remote::use_remote_logic,
+    utils::use_remote_logic,
 };
 
 #[tauri::command]
-pub fn use_remote(
+pub async fn use_remote(
     url: String,
-    state: tauri::State<'_, Mutex<AppState<'_>>>,
+    state: tauri::State<'_, DropFunctionState<'_>>,
 ) -> Result<(), RemoteAccessError> {
-    use_remote_logic(url, state)
+    use_remote_logic(url, state).await
 }
 
 #[tauri::command]
-pub fn gen_drop_url(path: String) -> Result<String, RemoteAccessError> {
+pub async fn gen_drop_url(path: String) -> Result<String, RemoteAccessError> {
     let base_url = {
-        let handle = borrow_db_checked();
+        let handle = borrow_db_checked().await;
 
         Url::parse(&handle.base_url).map_err(RemoteAccessError::ParsingError)?
     };
@@ -40,39 +38,39 @@ pub fn gen_drop_url(path: String) -> Result<String, RemoteAccessError> {
 }
 
 #[tauri::command]
-pub fn fetch_drop_object(path: String) -> Result<Vec<u8>, RemoteAccessError> {
-    let _drop_url = gen_drop_url(path.clone())?;
-    let req = make_request(&Client::new(), &[&path], &[], |r| {
-        r.header("Authorization", generate_authorization_header())
-    })?
-    .send();
+pub async fn fetch_drop_object(path: String) -> Result<Vec<u8>, RemoteAccessError> {
+    let _drop_url = gen_drop_url(path.clone()).await?;
+    let req = make_request(&Client::new(), &[&path], &[], async |r| {
+        r.header("Authorization", generate_authorization_header().await)
+    })
+    .await?
+    .send()
+    .await;
 
     match req {
         Ok(data) => {
-            let data = data.bytes()?.to_vec();
-            cache_object(&path, &data)?;
+            let data = data.bytes().await?.to_vec();
+            cache_object(&path, &data).await?;
             Ok(data)
         }
         Err(e) => {
-            debug!("{}", e);
-            get_cached_object::<&str, Vec<u8>>(&path)
+            debug!("{e}");
+            get_cached_object::<&str, Vec<u8>>(&path).await
         }
     }
 }
 #[tauri::command]
-pub fn sign_out(app: AppHandle) {
+pub async fn sign_out(app: AppHandle) {
     // Clear auth from database
     {
-        let mut handle = borrow_db_mut_checked();
+        let mut handle = borrow_db_mut_checked().await;
         handle.auth = None;
-        drop(handle);
-        save_db();
     }
 
     // Update app state
     {
-        let app_state = app.state::<Mutex<AppState>>();
-        let mut app_state_handle = app_state.lock().unwrap();
+        let app_state = app.state::<DropFunctionState<'_>>();
+        let mut app_state_handle = app_state.lock().await;
         app_state_handle.status = AppStatus::SignedOut;
         app_state_handle.user = None;
     }
@@ -82,21 +80,23 @@ pub fn sign_out(app: AppHandle) {
 }
 
 #[tauri::command]
-pub fn retry_connect(state: tauri::State<'_, Mutex<AppState>>) {
-    let (app_status, user) = setup();
+pub async fn retry_connect(state: tauri::State<'_, DropFunctionState<'_>>) -> Result<(), ()> {
+    let (app_status, user) = setup().await;
 
-    let mut guard = state.lock().unwrap();
+    let mut guard = state.lock().await;
     guard.status = app_status;
     guard.user = user;
     drop(guard);
+
+    Ok(())
 }
 
 #[tauri::command]
-pub fn auth_initiate() -> Result<(), RemoteAccessError> {
-    auth_initiate_logic()
+pub async fn auth_initiate() -> Result<(), RemoteAccessError> {
+    auth_initiate_logic().await
 }
 
 #[tauri::command]
-pub fn manual_recieve_handshake(app: AppHandle, token: String) {
-    recieve_handshake(app, format!("handshake/{}", token));
+pub async fn manual_recieve_handshake(app: AppHandle, token: String) {
+    recieve_handshake(app, format!("handshake/{token}")).await;
 }

src-tauri/src/remote/fetch_object.rs

@@ -4,28 +4,39 @@ use tauri::UriSchemeResponder;
 
 use super::{
     auth::generate_authorization_header,
-    cache::{cache_object, get_cached_object, ObjectCache},
+    cache::{ObjectCache, cache_object, get_cached_object},
     requests::make_request,
 };
 
-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 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);
+    let cache_result = get_cached_object::<&str, ObjectCache>(object_id).await;
+    if let Ok(cache_result) = &cache_result
+        && !cache_result.has_expired()
+    {
+        responder.respond(cache_result.into());
+        return;
+    }
 
-        match data {
-            Ok(data) => responder.respond(data.into()),
+    let header = generate_authorization_header().await;
+    let client = reqwest::Client::new();
+    let response = make_request(
+        &client,
+        &["/api/v1/client/object/", object_id],
+        &[],
+        async |f| f.header("Authorization", header),
+    )
+    .await
+    .unwrap()
+    .send()
+    .await;
+    if response.is_err() {
+        match cache_result {
+            Ok(cache_result) => responder.respond(cache_result.into()),
             Err(e) => {
-                warn!("{}", e)
+                warn!("{e}")
             }
         }
         return;
@@ -36,18 +47,22 @@ 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();
-    cache_object::<&str, ObjectCache>(object_id, &resp.clone().into()).unwrap();
+    if cache_result.is_err() || cache_result.unwrap().has_expired() {
+        cache_object::<&str, ObjectCache>(object_id, &resp.clone().into())
+            .await
+            .unwrap();
+    }
 
     responder.respond(resp);
 }
-pub fn fetch_object_offline(request: http::Request<Vec<u8>>, responder: UriSchemeResponder) {
+pub async 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);
+    let data = get_cached_object::<&str, ObjectCache>(object_id).await;
 
     match data {
         Ok(data) => responder.respond(data.into()),
-        Err(e) => warn!("{}", e),
+        Err(e) => warn!("{e}"),
     }
 }

src-tauri/src/remote/mod.rs

@@ -3,6 +3,6 @@ pub mod auth;
 pub mod cache;
 pub mod commands;
 pub mod fetch_object;
-pub mod remote;
 pub mod requests;
 pub mod server_proto;
+pub mod utils;

src-tauri/src/remote/remote.rs

@@ -1,48 +0,0 @@
-use std::sync::Mutex;
-
-use log::{debug, warn};
-use serde::Deserialize;
-use url::Url;
-
-use crate::{
-    database::db::{borrow_db_mut_checked, save_db},
-    error::remote_access_error::RemoteAccessError,
-    AppState, AppStatus,
-};
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct DropHealthcheck {
-    app_name: String,
-}
-
-pub fn use_remote_logic(
-    url: String,
-    state: tauri::State<'_, Mutex<AppState<'_>>>,
-) -> Result<(), RemoteAccessError> {
-    debug!("connecting to url {}", url);
-    let base_url = Url::parse(&url)?;
-
-    // Test Drop url
-    let test_endpoint = base_url.join("/api/v1")?;
-    let response = reqwest::blocking::get(test_endpoint.to_string())?;
-
-    let result: DropHealthcheck = response.json()?;
-
-    if result.app_name != "Drop" {
-        warn!("user entered drop endpoint that connected, but wasn't identified as Drop");
-        return Err(RemoteAccessError::InvalidEndpoint);
-    }
-
-    let mut app_state = state.lock().unwrap();
-    app_state.status = AppStatus::SignedOut;
-    drop(app_state);
-
-    let mut db_state = borrow_db_mut_checked();
-    db_state.base_url = base_url.to_string();
-    drop(db_state);
-
-    save_db();
-
-    Ok(())
-}

src-tauri/src/remote/requests.rs

@@ -1,14 +1,14 @@
-use reqwest::blocking::{Client, RequestBuilder};
+use reqwest::{Client, RequestBuilder};
 
 use crate::{database::db::DatabaseImpls, error::remote_access_error::RemoteAccessError, DB};
 
-pub fn make_request<T: AsRef<str>, F: FnOnce(RequestBuilder) -> RequestBuilder>(
+pub async fn make_request<T: AsRef<str>, F: AsyncFnOnce(RequestBuilder) -> RequestBuilder>(
     client: &Client,
     path_components: &[T],
     query: &[(T, T)],
     f: F,
 ) -> Result<RequestBuilder, RemoteAccessError> {
-    let mut base_url = DB.fetch_base_url();
+    let mut base_url = DB.fetch_base_url().await;
     for endpoint in path_components {
         base_url = base_url.join(endpoint.as_ref())?;
     }
@@ -19,5 +19,5 @@ pub fn make_request<T: AsRef<str>, F: FnOnce(RequestBuilder) -> RequestBuilder>(
         }
     }
     let response = client.get(base_url);
-    Ok(f(response))
+    Ok(f(response).await)
 }

src-tauri/src/remote/server_proto.rs

@@ -1,15 +1,12 @@
 use std::str::FromStr;
 
-use http::{
-    uri::PathAndQuery,
-    Request, Response, StatusCode, Uri,
-};
-use reqwest::blocking::Client;
+use http::{uri::PathAndQuery, Request, Response, StatusCode, Uri};
+use reqwest::Client;
 use tauri::UriSchemeResponder;
 
 use crate::database::db::borrow_db_checked;
 
-pub fn handle_server_proto_offline(_request: Request<Vec<u8>>, responder: UriSchemeResponder) {
+pub async fn handle_server_proto_offline(_request: Request<Vec<u8>>, responder: UriSchemeResponder) {
     let four_oh_four = Response::builder()
         .status(StatusCode::NOT_FOUND)
         .body(Vec::new())
@@ -17,8 +14,8 @@ pub fn handle_server_proto_offline(_request: Request<Vec<u8>>, responder: UriSch
     responder.respond(four_oh_four);
 }
 
-pub fn handle_server_proto(request: Request<Vec<u8>>, responder: UriSchemeResponder) {
-    let db_handle = borrow_db_checked();
+pub async fn handle_server_proto(request: Request<Vec<u8>>, responder: UriSchemeResponder) {
+    let db_handle = borrow_db_checked().await;
     let web_token = match &db_handle.auth.as_ref().unwrap().web_token {
         Some(e) => e,
         None => return,
@@ -29,18 +26,14 @@ pub fn handle_server_proto(request: Request<Vec<u8>>, responder: UriSchemeRespon
 
     let mut new_uri = request.uri().clone().into_parts();
     new_uri.path_and_query =
-        Some(PathAndQuery::from_str(&format!("{}?noWrapper=true", path)).unwrap());
+        Some(PathAndQuery::from_str(&format!("{path}?noWrapper=true")).unwrap());
     new_uri.authority = remote_uri.authority().cloned();
     new_uri.scheme = remote_uri.scheme().cloned();
     let new_uri = Uri::from_parts(new_uri).unwrap();
 
-    let whitelist_prefix = vec!["/store", "/api", "/_", "/fonts"];
+    let whitelist_prefix = ["/store", "/api", "/_", "/fonts"];
 
-    if whitelist_prefix
-        .iter()
-        .map(|f| !path.starts_with(f))
-        .all(|f| f)
-    {
+    if whitelist_prefix.iter().all(|f| !path.starts_with(f)) {
         webbrowser::open(&new_uri.to_string()).unwrap();
         return;
     }
@@ -48,13 +41,14 @@ pub fn handle_server_proto(request: Request<Vec<u8>>, responder: UriSchemeRespon
     let client = Client::new();
     let response = client
         .request(request.method().clone(), new_uri.to_string())
-        .header("Authorization", format!("Bearer {}", web_token))
+        .header("Authorization", format!("Bearer {web_token}"))
         .headers(request.headers().clone())
         .send()
+        .await
         .unwrap();
 
     let response_status = response.status();
-    let response_body = response.bytes().unwrap();
+    let response_body = response.bytes().await.unwrap();
 
     let http_response = Response::builder()
         .status(response_status)

src-tauri/src/remote/utils.rs

@@ -0,0 +1,42 @@
+use log::{debug, info, warn};
+use serde::Deserialize;
+use url::Url;
+
+use crate::{
+    database::db::borrow_db_mut_checked, error::remote_access_error::RemoteAccessError, AppStatus, DropFunctionState
+};
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct DropHealthcheck {
+    app_name: String,
+}
+
+pub async fn use_remote_logic(
+    url: String,
+    state: tauri::State<'_, DropFunctionState<'_>>,
+) -> Result<(), RemoteAccessError> {
+    info!("connecting to url {url}");
+    let base_url = Url::parse(&url)?;
+
+    // Test Drop url
+    let test_endpoint = base_url.join("/api/v1")?;
+    let response = reqwest::get(test_endpoint.to_string()).await?;
+
+    let result: DropHealthcheck = response.json().await?;
+
+    if result.app_name != "Drop" {
+        warn!("user entered drop endpoint that connected, but wasn't identified as Drop");
+        return Err(RemoteAccessError::InvalidEndpoint);
+    }
+
+    {
+        let mut app_state = state.lock().await;
+        app_state.status = AppStatus::SignedOut;
+    }
+
+    let mut db_state = borrow_db_mut_checked().await;
+    db_state.base_url = base_url.to_string();
+
+    Ok(())
+}

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-2",
+  "version": "0.3.0-rc-8",
   "identifier": "dev.drop.app",
   "build": {
     "beforeDevCommand": "yarn dev --port 1432",
@@ -11,7 +11,11 @@
   },
   "app": {
     "security": {
-      "csp": null
+      "csp": null,
+      "assetProtocol": {
+        "enable": true,
+        "scope": {}
+      }
     }
   },
   "plugins": {

types.ts

@@ -59,11 +59,13 @@ export enum GameStatusEnum {
   Uninstalling = "Uninstalling",
   SetupRequired = "SetupRequired",
   Running = "Running",
+  PartiallyInstalled = "PartiallyInstalled"
 }
 
 export type GameStatus = {
   type: GameStatusEnum;
   version_name?: string;
+  install_dir?: string;
 };
 
 export enum DownloadableType {

yarn.lock

@@ -1508,6 +1508,11 @@
   resolved "https://registry.yarnpkg.com/@tauri-apps/api/-/api-2.0.1.tgz#dc49d899fb873b96ee1d46a171384625ba5ad404"
   integrity sha512-eoQWT+Tq1qSwQpHV+nw1eNYe5B/nm1PoRjQCRiEOS12I1b+X4PUcREfXVX8dPcBT6GrzWGDtaecY0+1p0Rfqlw==
 
+"@tauri-apps/api@^2.6.0":
+  version "2.6.0"
+  resolved "https://registry.yarnpkg.com/@tauri-apps/api/-/api-2.6.0.tgz#efd873bf04b0d72cea81f9397e16218f5deafe0f"
+  integrity sha512-hRNcdercfgpzgFrMXWwNDBN0B7vNzOzRepy6ZAmhxi5mDLVPNrTpo9MGg2tN/F7JRugj4d2aF7E1rtPXAHaetg==
+
 "@tauri-apps/cli-darwin-arm64@2.0.1":
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/@tauri-apps/cli-darwin-arm64/-/cli-darwin-arm64-2.0.1.tgz#5816c0099977f705d1a7249822fa51f5d3c3750a"
@@ -1588,6 +1593,13 @@
   dependencies:
     "@tauri-apps/api" "^2.0.0"
 
+"@tauri-apps/plugin-opener@^2.4.0":
+  version "2.4.0"
+  resolved "https://registry.yarnpkg.com/@tauri-apps/plugin-opener/-/plugin-opener-2.4.0.tgz#57eae5998e1c396791af16832a9dde16eca06439"
+  integrity sha512-43VyN8JJtvKWJY72WI/KNZszTpDpzHULFxQs0CJBIYUdCRowQ6Q1feWTDb979N7nldqSuDOaBupZ6wz2nvuWwQ==
+  dependencies:
+    "@tauri-apps/api" "^2.6.0"
+
 "@tauri-apps/plugin-os@~2":
   version "2.2.0"
   resolved "https://registry.yarnpkg.com/@tauri-apps/plugin-os/-/plugin-os-2.2.0.tgz#ef5511269f59c0ccc580a9d09600034cfaa9743b"