Error063/STARTLINER
1
0
Fork 0
forked from akanyan/STARTLINER
Code Pull Requests Activity

feat: less bad installations

Browse Source
This commit is contained in:
あかニャン
2025-02-23 20:54:47 +01:00
parent caead1e70f
commit 6236b8ef96
13 changed files with 124 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
rust/src/appdata.rs
View File

@ -26,6 +26,13 @@ impl AppData {
}
} else {
profile.mods.remove(&key);
for (ckey, pkg) in self.pkgs.get_all() {
if let Some(loc) = pkg.loc {
if loc.dependencies.contains(&key) {
self.toggle_package(ckey, false)?;
}
}
}
}
Ok(())

19
rust/src/cmd.rs
View File

@ -29,24 +29,17 @@ pub async fn startline(state: State<'_, Mutex<AppData>>) -> Result<(), String> {
#[tauri::command]
pub async fn install_package(state: State<'_, tokio::sync::Mutex<AppData>>, key: PkgKey) -> Result<InstallResult, String> {
log::debug!("invoke: install_package");
log::debug!("invoke: install_package({})", key);
let mut appd = state.lock().await;
let rv = appd.pkgs.install_package(&key, true)
appd.pkgs.install_package(&key, true, true)
.await
.map_err(|e| e.to_string());
// if rv.is_ok() {
// _ = appd.toggle_package(key, true);
// }
rv
.map_err(|e| e.to_string())
}
#[tauri::command]
pub async fn delete_package(state: State<'_, tokio::sync::Mutex<AppData>>, key: PkgKey) -> Result<(), String> {
log::debug!("invoke: delete_package");
log::debug!("invoke: delete_package({})", key);
let mut appd = state.lock().await;
appd.pkgs.delete_package(&key, true)
@ -56,7 +49,7 @@ pub async fn delete_package(state: State<'_, tokio::sync::Mutex<AppData>>, key:
#[tauri::command]
pub async fn get_package(state: State<'_, tokio::sync::Mutex<AppData>>, key: PkgKey) -> Result<Package, String> {
log::debug!("invoke: get_package");
log::debug!("invoke: get_package({})", key);
let appd = state.lock().await;
appd.pkgs.get(key)
@ -66,7 +59,7 @@ pub async fn get_package(state: State<'_, tokio::sync::Mutex<AppData>>, key: Pkg
#[tauri::command]
pub async fn toggle_package(state: State<'_, tokio::sync::Mutex<AppData>>, key: PkgKey, enable: bool) -> Result<(), String> {
log::debug!("invoke: toggle_package");
log::debug!("invoke: toggle_package({}, {})", key, enable);
let mut appd = state.lock().await;
appd.toggle_package(key, enable)

1
rust/src/download_handler.rs
View File

@ -23,6 +23,7 @@ impl DownloadHandler {
.ok_or_else(|| anyhow!("Attempted to download a package without remote data"))?
.clone();
if self.set.contains(zip_path.to_string_lossy().as_ref()) {
// Todo when there is a clear cache button, it should clear the set
Err(anyhow!("Already downloading"))
} else {
self.set.insert(zip_path.to_string_lossy().to_string());

4
rust/src/lib.rs
View File

@ -58,7 +58,7 @@ pub async fn run(_args: Vec<String>) {
let mutex = apph.state::<Mutex<AppData>>();
let mut appd = mutex.lock().await;
_ = appd.pkgs.fetch_listings().await;
if let Err(e) = appd.pkgs.install_package(&key, true).await {
if let Err(e) = appd.pkgs.install_package(&key, true, true).await {
log::warn!("Fail: {}", e.to_string());
}
});
@ -89,7 +89,7 @@ pub async fn run(_args: Vec<String>) {
tauri::async_runtime::spawn(async move {
let mutex = apph.state::<Mutex<AppData>>();
let mut appd = mutex.lock().await;
_ = appd.pkgs.install_package(&key, true).await;
_ = appd.pkgs.install_package(&key, true, false).await;
});
}));

63
rust/src/pkg_store.rs
View File

@ -1,4 +1,5 @@
use std::collections::HashMap;
use std::path::Path;
use anyhow::{Result, anyhow};
use serde::{Deserialize, Serialize};
use tauri::{AppHandle, Emitter};
@ -118,7 +119,7 @@ impl PackageStore {
Ok(())
}
pub async fn install_package(&mut self, key: &PkgKey, force: bool) -> Result<InstallResult> {
pub async fn install_package(&mut self, key: &PkgKey, force: bool, install_deps: bool) -> Result<InstallResult> {
log::debug!("Installing {}", key);
let pkg = self.store.get(key)
@ -128,14 +129,18 @@ impl PackageStore {
if pkg.loc.is_some() && !force {
return Ok(InstallResult::Ready);
}
self.app.emit("install-start", Payload {
pkg: key.to_owned()
})?;
let rmt = pkg.rmt.as_ref() //clone()
.ok_or_else(|| anyhow!("Attempted to install a pkg without remote data"))?;
for dep in &rmt.dependencies {
self.app.emit("install-start", Payload {
pkg: dep.to_owned()
})?;
Box::pin(self.install_package(&dep, false)).await?;
if install_deps {
for dep in &rmt.dependencies {
Box::pin(self.install_package(&dep, false, true)).await?;
}
}
let zip_path = util::cache_dir().join(format!(
@ -145,6 +150,7 @@ impl PackageStore {
if !zip_path.exists() {
self.dlh.download_zip(&zip_path, &pkg)?;
log::debug!("Deferring {}", key);
return Ok(InstallResult::Deferred);
}
@ -168,16 +174,16 @@ impl PackageStore {
}
pub async fn delete_package(&mut self, key: &PkgKey, force: bool) -> Result<()> {
log::debug!("Will delete {} {}", key, force);
let pkg = self.store.get_mut(key)
.ok_or_else(|| anyhow!("Attempted to delete a nonexistent pkg"))?;
let path = pkg.path();
if path.exists() && path.join("manifest.json").exists() {
// TODO don't rm -r - use a file whitelist
log::debug!("rm -r'ing {}", path.to_string_lossy());
pkg.loc = None;
let rv = tokio::fs::remove_dir_all(&path).await
.map_err(|e| anyhow!("Could not delete a package: {}", e));
let rv = Self::clean_up_package(&path).await;
if rv.is_ok() {
self.app.emit("install-end", Payload {
@ -201,4 +207,41 @@ impl PackageStore {
}
self.store.insert(key, new);
}
async fn clean_up_dir(path: impl AsRef<Path>, name: &str) -> Result<()> {
let path = path.as_ref().join(name);
if path.exists() {
tokio::fs::remove_dir_all(path)
.await
.map_err(|e| anyhow!("Could not delete /{}: {}", name, e))?;
}
Ok(())
}
async fn clean_up_file(path: impl AsRef<Path>, name: &str, force: bool) -> Result<()> {
let path = path.as_ref().join(name);
if force || path.exists() {
tokio::fs::remove_file(path)
.await
.map_err(|e| anyhow!("Could not delete /{}: {}", name, e))?;
}
Ok(())
}
async fn clean_up_package(path: impl AsRef<Path>) -> Result<()> {
// todo case sensitivity for linux
Self::clean_up_dir(&path, "app").await?;
Self::clean_up_dir(&path, "option").await?;
Self::clean_up_file(&path, "icon.png", true).await?;
Self::clean_up_file(&path, "manifest.json", true).await?;
Self::clean_up_file(&path, "README.md", true).await?;
tokio::fs::remove_dir(path.as_ref())
.await
.map_err(|e| anyhow!("Could not delete {}: {}", path.as_ref().to_string_lossy(), e))?;
Ok(())
}
}

2
rust/src/profile.rs
View File

@ -26,7 +26,7 @@ impl Profile {
mods: HashSet::new(),
#[cfg(target_os = "linux")]
wine_runtime: Some(Path::new("/usr/bin/wine").to_path_buf()),
wine_runtime: Some(std::path::Path::new("/usr/bin/wine").to_path_buf()),
#[cfg(target_os = "windows")]
wine_runtime: None,

13
rust/src/start.rs
View File

@ -1,24 +1,27 @@
use anyhow::Result;
use std::process::Stdio;
use tokio::task::JoinSet;
use tokio::process::Command;
use crate::profile::Profile;
use crate::util;
#[cfg(target_os = "linux")]
pub fn start(p: &Profile) -> Result<Child> {
Ok(Command::new(p.wine_runtime.as_ref().unwrap())
pub fn start(p: &Profile) -> Result<()> {
Command::new(p.wine_runtime.as_ref().unwrap())
.env(
"SEGATOOLS_CONFIG_PATH",
util::profile_dir(&p).join("segatools.ini"),
)
.env("WINEPREFIX", p.wine_prefix.as_ref().unwrap())
.arg(p.exe_dir.join("start.bat"))
.spawn()?)
.spawn()?;
Ok(())
}
#[cfg(target_os = "windows")]
pub fn start(p: &Profile) -> Result<()> {
use std::process::Stdio;
use tokio::task::JoinSet;
let ini_path = util::profile_dir(&p).join("segatools.ini");
log::debug!("With path {}", ini_path.to_string_lossy());