Merge pull request #178 from Online5277/fix/reuse-imported-minecraft
Reuse verified Minecraft imports when preparing new versions
This commit is contained in:
@@ -513,7 +513,27 @@ pub fn import(
|
||||
&hint(LAUNCHER_HINT, version),
|
||||
)?);
|
||||
}
|
||||
for (side, jar) in [("client", &client), ("server", &server)] {
|
||||
write_import_metadata(
|
||||
root,
|
||||
lock,
|
||||
&client,
|
||||
&server,
|
||||
&client_libraries,
|
||||
&server_libraries,
|
||||
log,
|
||||
)
|
||||
}
|
||||
|
||||
fn write_import_metadata(
|
||||
root: &Path,
|
||||
lock: &Lock,
|
||||
client: &Path,
|
||||
server: &Path,
|
||||
client_libraries: &[PathBuf],
|
||||
server_libraries: &[PathBuf],
|
||||
log: Log,
|
||||
) -> Result<(), String> {
|
||||
for (side, jar) in [("client", client), ("server", server)] {
|
||||
let data = crate::inventory::inventory(jar)?;
|
||||
let count = |key| data.get(key).cloned().unwrap_or(Value::Null);
|
||||
write_json(
|
||||
@@ -538,25 +558,19 @@ pub fn import(
|
||||
write_json(
|
||||
&lock.directory.join("prepared.json"),
|
||||
&Value::Object(vec![
|
||||
("version".into(), Value::str(id)),
|
||||
("version".into(), Value::str(&lock.version)),
|
||||
(
|
||||
"jars".into(),
|
||||
Value::Object(vec![
|
||||
(
|
||||
"client".into(),
|
||||
Value::Str(relative_display(&client, root)?),
|
||||
),
|
||||
(
|
||||
"server".into(),
|
||||
Value::Str(relative_display(&server, root)?),
|
||||
),
|
||||
("client".into(), Value::Str(relative_display(client, root)?)),
|
||||
("server".into(), Value::Str(relative_display(server, root)?)),
|
||||
]),
|
||||
),
|
||||
(
|
||||
"libraries".into(),
|
||||
Value::Object(vec![
|
||||
("client".into(), paths(&client_libraries)?),
|
||||
("server".into(), paths(&server_libraries)?),
|
||||
("client".into(), paths(client_libraries)?),
|
||||
("server".into(), paths(server_libraries)?),
|
||||
]),
|
||||
),
|
||||
]),
|
||||
@@ -573,6 +587,100 @@ pub struct Artifacts {
|
||||
pub libraries: Vec<PathBuf>,
|
||||
}
|
||||
|
||||
/// Reuses checked imports from this root or another installed version beside it.
|
||||
pub fn reuse_imported(root: &Path, log: Log) -> Result<bool, String> {
|
||||
let root = fs::canonicalize(root).map_err(|e| format!("{}: {e}", root.display()))?;
|
||||
let lock = Lock::read(&root)?;
|
||||
let checked = |directory: PathBuf| -> Result<Vec<PathBuf>, String> {
|
||||
let candidate = Lock {
|
||||
json: lock.json.clone(),
|
||||
version: lock.version.clone(),
|
||||
java_major: lock.java_major,
|
||||
directory,
|
||||
};
|
||||
let found = verify(&candidate)?;
|
||||
let client = client_libraries(&candidate, &found.manifest)?;
|
||||
let mut files = vec![
|
||||
candidate.directory.join("manifest.json"),
|
||||
candidate.directory.join("jars/client.jar"),
|
||||
candidate.directory.join("jars/server.jar"),
|
||||
found.jars["server"].clone(),
|
||||
];
|
||||
files.extend(found.libraries);
|
||||
files.extend(client);
|
||||
Ok(files)
|
||||
};
|
||||
if checked(lock.directory.clone()).is_ok() {
|
||||
if [
|
||||
"prepared.json",
|
||||
"reports/client-inventory.json",
|
||||
"reports/server-inventory.json",
|
||||
]
|
||||
.iter()
|
||||
.any(|path| !lock.directory.join(path).is_file())
|
||||
{
|
||||
let found = verify(&lock)?;
|
||||
let client_libraries = client_libraries(&lock, &found.manifest)?;
|
||||
write_import_metadata(
|
||||
&root,
|
||||
&lock,
|
||||
&found.jars["client"],
|
||||
&found.jars["server"],
|
||||
&client_libraries,
|
||||
&found.libraries,
|
||||
log,
|
||||
)?;
|
||||
}
|
||||
log(&format!("Using imported Minecraft {}", lock.version));
|
||||
return Ok(true);
|
||||
}
|
||||
let Some(versions) = root.parent() else {
|
||||
return Ok(false);
|
||||
};
|
||||
// Sibling discovery is intended for the launcher's versions/ folder.
|
||||
let mut siblings: Vec<_> = fs::read_dir(versions)
|
||||
.map_err(|e| format!("{}: {e}", versions.display()))?
|
||||
.filter_map(Result::ok)
|
||||
.map(|entry| entry.path())
|
||||
.filter(|path| path != &root && path.is_dir())
|
||||
.collect();
|
||||
siblings.sort();
|
||||
for sibling in siblings {
|
||||
let source = sibling.join(".local/minecraft").join(&lock.version);
|
||||
let Ok(files) = checked(source.clone()) else {
|
||||
continue;
|
||||
};
|
||||
for file in files {
|
||||
let relative = file.strip_prefix(&source).map_err(|e| e.to_string())?;
|
||||
import_copy(
|
||||
&file,
|
||||
&lock.directory.join(relative),
|
||||
&digest(&file, "sha256")?,
|
||||
"sha256",
|
||||
"",
|
||||
)?;
|
||||
}
|
||||
let found = verify(&lock)?;
|
||||
let client_libraries = client_libraries(&lock, &found.manifest)?;
|
||||
write_import_metadata(
|
||||
&root,
|
||||
&lock,
|
||||
&found.jars["client"],
|
||||
&found.jars["server"],
|
||||
&client_libraries,
|
||||
&found.libraries,
|
||||
log,
|
||||
)?;
|
||||
log(&format!(
|
||||
"Reused imported Minecraft {} from {}",
|
||||
lock.version,
|
||||
sibling.display()
|
||||
));
|
||||
return Ok(true);
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
|
||||
pub fn verify(lock: &Lock) -> Result<Artifacts, String> {
|
||||
let manifest_path = lock.directory.join("manifest.json");
|
||||
if !manifest_path.exists() {
|
||||
@@ -597,7 +705,10 @@ pub fn verify(lock: &Lock) -> Result<Artifacts, String> {
|
||||
.and_then(|d| d.get(side))
|
||||
.and_then(|d| d.get("sha1"))
|
||||
.and_then(Value::as_str);
|
||||
if !jar.exists() || Some(digest(&jar, "sha1")?.as_str()) != pinned {
|
||||
if pinned != Some(lock.pin(&format!("{side}_sha1"))?)
|
||||
|| !jar.exists()
|
||||
|| Some(digest(&jar, "sha1")?.as_str()) != pinned
|
||||
{
|
||||
return Err(format!(
|
||||
"{side} artifact checksum changed; prepare again with --prepare"
|
||||
));
|
||||
@@ -648,6 +759,238 @@ pub fn client_libraries(lock: &Lock, manifest: &Value) -> Result<Vec<PathBuf>, S
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::io::Write;
|
||||
|
||||
fn jar(marker: &[u8]) -> Vec<u8> {
|
||||
let mut archive = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
|
||||
archive
|
||||
.start_file("marker", zip::write::SimpleFileOptions::default())
|
||||
.unwrap();
|
||||
archive.write_all(marker).unwrap();
|
||||
archive.finish().unwrap().into_inner()
|
||||
}
|
||||
|
||||
struct Imports {
|
||||
directory: PathBuf,
|
||||
source: PathBuf,
|
||||
target: PathBuf,
|
||||
}
|
||||
|
||||
impl Imports {
|
||||
fn new() -> Self {
|
||||
static NEXT: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
|
||||
let n = NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
|
||||
let directory = std::env::temp_dir()
|
||||
.join(format!("horizon-import-reuse-{}-{n}", std::process::id()));
|
||||
let source = directory.join("old");
|
||||
let target = directory.join("new");
|
||||
fs::create_dir_all(&target).unwrap();
|
||||
let imported = source.join(".local/minecraft/9.9");
|
||||
let write = |path: &str, data: &[u8]| {
|
||||
let path = imported.join(path);
|
||||
fs::create_dir_all(path.parent().unwrap()).unwrap();
|
||||
fs::write(path, data).unwrap();
|
||||
};
|
||||
let client = jar(b"client");
|
||||
let game = jar(b"server game");
|
||||
write("jars/client.jar", &client);
|
||||
write("jars/server-game.jar", &game);
|
||||
write("libraries/server/server.jar", b"server library");
|
||||
write("libraries/client/client.jar", b"client library");
|
||||
write("reports/private.txt", b"not an imported artifact");
|
||||
let mut bundle =
|
||||
zip::ZipWriter::new(fs::File::create(imported.join("jars/server.jar")).unwrap());
|
||||
let entries = [
|
||||
(
|
||||
"META-INF/versions.list",
|
||||
format!("{}\t9.9\tgame.jar\n", crate::sha256_hex(&game)),
|
||||
),
|
||||
(
|
||||
"META-INF/libraries.list",
|
||||
format!(
|
||||
"{}\tserver:library:1\tserver.jar\n",
|
||||
crate::sha256_hex(b"server library")
|
||||
),
|
||||
),
|
||||
];
|
||||
for (name, text) in entries {
|
||||
bundle
|
||||
.start_file(name, zip::write::SimpleFileOptions::default())
|
||||
.unwrap();
|
||||
bundle.write_all(text.as_bytes()).unwrap();
|
||||
}
|
||||
for (name, bytes) in [
|
||||
("META-INF/versions/game.jar", game.as_slice()),
|
||||
(
|
||||
"META-INF/libraries/server.jar",
|
||||
b"server library".as_slice(),
|
||||
),
|
||||
] {
|
||||
bundle
|
||||
.start_file(name, zip::write::SimpleFileOptions::default())
|
||||
.unwrap();
|
||||
bundle.write_all(bytes).unwrap();
|
||||
}
|
||||
bundle.finish().unwrap();
|
||||
let client_sha1 = digest(&imported.join("jars/client.jar"), "sha1").unwrap();
|
||||
let server_sha1 = digest(&imported.join("jars/server.jar"), "sha1").unwrap();
|
||||
let library_sha1 =
|
||||
digest(&imported.join("libraries/client/client.jar"), "sha1").unwrap();
|
||||
let manifest = format!(
|
||||
"{{\"id\":\"9.9\",\"downloads\":{{\"client\":{{\"sha1\":\"{client_sha1}\"}},\"server\":{{\"sha1\":\"{server_sha1}\"}}}},\"libraries\":[{{\"name\":\"client:library:1\",\"downloads\":{{\"artifact\":{{\"path\":\"client.jar\",\"sha1\":\"{library_sha1}\"}}}}}}]}}"
|
||||
);
|
||||
write("manifest.json", manifest.as_bytes());
|
||||
let manifest_sha1 = digest(&imported.join("manifest.json"), "sha1").unwrap();
|
||||
let lock = format!(
|
||||
"{{\"minecraft\":{{\"version\":\"9.9\",\"java_major\":25,\"manifest_sha1\":\"{manifest_sha1}\",\"client_sha1\":\"{client_sha1}\",\"server_sha1\":\"{server_sha1}\"}}}}"
|
||||
);
|
||||
fs::write(target.join("research-lock.json"), lock).unwrap();
|
||||
Self {
|
||||
directory,
|
||||
source,
|
||||
target,
|
||||
}
|
||||
}
|
||||
|
||||
fn imported(&self, root: &Path) -> PathBuf {
|
||||
root.join(".local/minecraft/9.9")
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Imports {
|
||||
fn drop(&mut self) {
|
||||
let _ = fs::remove_dir_all(&self.directory);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn imported_files_are_reused_without_the_official_install() {
|
||||
let fixture = Imports::new();
|
||||
fs::write(
|
||||
fixture.imported(&fixture.source).join("prepared.json"),
|
||||
b"stale source metadata",
|
||||
)
|
||||
.unwrap();
|
||||
assert!(reuse_imported(&fixture.target, &|_| {}).unwrap());
|
||||
let lock = Lock::read(&fixture.target).unwrap();
|
||||
let artifacts = verify(&lock).unwrap();
|
||||
assert_eq!(
|
||||
client_libraries(&lock, &artifacts.manifest).unwrap().len(),
|
||||
1
|
||||
);
|
||||
assert_eq!(artifacts.libraries.len(), 1);
|
||||
let prepared = read_json(&lock.directory.join("prepared.json")).unwrap();
|
||||
assert_eq!(prepared.get("version").and_then(Value::as_str), Some("9.9"));
|
||||
for side in ["client", "server"] {
|
||||
assert_eq!(
|
||||
prepared
|
||||
.get("jars")
|
||||
.unwrap()
|
||||
.get(side)
|
||||
.and_then(Value::as_str),
|
||||
Some(
|
||||
relative_display(&artifacts.jars[side], &fixture.target)
|
||||
.unwrap()
|
||||
.as_str()
|
||||
)
|
||||
);
|
||||
let inventory = read_json(
|
||||
&lock
|
||||
.directory
|
||||
.join(format!("reports/{side}-inventory.json")),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
inventory.get("jar_sha256").and_then(Value::as_str),
|
||||
Some(digest(&artifacts.jars[side], "sha256").unwrap().as_str())
|
||||
);
|
||||
}
|
||||
assert!(!lock.directory.join("reports/private.txt").exists());
|
||||
for side in ["client", "server"] {
|
||||
let libraries = prepared
|
||||
.get("libraries")
|
||||
.unwrap()
|
||||
.get(side)
|
||||
.unwrap()
|
||||
.as_array()
|
||||
.unwrap();
|
||||
assert_eq!(libraries.len(), 1);
|
||||
assert_eq!(
|
||||
libraries[0].as_str(),
|
||||
Some(
|
||||
relative_display(
|
||||
&lock.directory.join(format!("libraries/{side}/{side}.jar")),
|
||||
&fixture.target
|
||||
)
|
||||
.unwrap()
|
||||
.as_str()
|
||||
)
|
||||
);
|
||||
}
|
||||
// The current root's valid imports suffice even after the older copy is corrupted.
|
||||
fs::write(
|
||||
fixture.imported(&fixture.source).join("jars/client.jar"),
|
||||
b"bad",
|
||||
)
|
||||
.unwrap();
|
||||
// Repair metadata omitted by earlier reuse implementations, without a sibling.
|
||||
fs::remove_file(lock.directory.join("prepared.json")).unwrap();
|
||||
fs::remove_file(lock.directory.join("reports/client-inventory.json")).unwrap();
|
||||
assert!(reuse_imported(&fixture.target, &|_| {}).unwrap());
|
||||
assert!(read_json(&lock.directory.join("prepared.json")).is_ok());
|
||||
assert!(read_json(&lock.directory.join("reports/client-inventory.json")).is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reuse_rejects_corrupt_imports() {
|
||||
for file in [
|
||||
"manifest.json",
|
||||
"jars/client.jar",
|
||||
"jars/server.jar",
|
||||
"jars/server-game.jar",
|
||||
"libraries/client/client.jar",
|
||||
"libraries/server/server.jar",
|
||||
] {
|
||||
let fixture = Imports::new();
|
||||
fs::write(fixture.imported(&fixture.source).join(file), b"bad").unwrap();
|
||||
assert!(!reuse_imported(&fixture.target, &|_| {}).unwrap(), "{file}");
|
||||
assert!(!fixture.imported(&fixture.target).exists());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reuse_checks_the_target_pins() {
|
||||
let fixture = Imports::new();
|
||||
let mut lock = Lock::read(&fixture.target).unwrap();
|
||||
let client = lock.pin("client_sha1").unwrap().to_string();
|
||||
let text = fs::read_to_string(fixture.target.join("research-lock.json")).unwrap();
|
||||
fs::write(
|
||||
fixture.target.join("research-lock.json"),
|
||||
text.replace(&client, "wrong-client-pin"),
|
||||
)
|
||||
.unwrap();
|
||||
assert!(!reuse_imported(&fixture.target, &|_| {}).unwrap());
|
||||
lock.directory = fixture.imported(&fixture.source);
|
||||
assert!(verify(&lock).is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reuse_skips_a_bad_sibling_and_repairs_bad_current_imports() {
|
||||
let fixture = Imports::new();
|
||||
let bad = fixture.directory.join("a-bad");
|
||||
fs::rename(&fixture.source, &bad).unwrap();
|
||||
let valid = Imports::new();
|
||||
fs::rename(&valid.source, &fixture.source).unwrap();
|
||||
fs::write(fixture.imported(&bad).join("jars/client.jar"), b"bad").unwrap();
|
||||
let target = fixture.imported(&fixture.target);
|
||||
fs::create_dir_all(target.join("jars")).unwrap();
|
||||
fs::write(target.join("jars/client.jar"), b"bad").unwrap();
|
||||
assert!(reuse_imported(&fixture.target, &|_| {}).unwrap());
|
||||
assert_eq!(
|
||||
fs::read(target.join("jars/client.jar")).unwrap(),
|
||||
fs::read(fixture.imported(&fixture.source).join("jars/client.jar")).unwrap()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn natives_follow_the_architecture() {
|
||||
|
||||
@@ -402,7 +402,7 @@ pub fn prepare(options: &Options, log: Log) -> Result<PathBuf, String> {
|
||||
let lock = artifacts::Lock::read(root)?;
|
||||
// Java first: nothing below can finish without it, and the player should hear it at once.
|
||||
let jdk = java::find(lock.java_major)?;
|
||||
if options.import {
|
||||
if options.import && !artifacts::reuse_imported(root, log)? {
|
||||
artifacts::import(
|
||||
root,
|
||||
&lock,
|
||||
|
||||
+4
-1
@@ -21,7 +21,10 @@ The opening, then Play ([clip](docs/opening.webm)):
|
||||
server (`--dedicated --nogui`) in a folder you choose, with a live console. Preparing is
|
||||
horizon-prepare: linked into the launcher, used in-process when a version ships the same
|
||||
preparer sources, else that version's own `horizon-prepare`; versions released before it
|
||||
still prepare with their Python script and need Python 3.10+.
|
||||
still prepare with their Python script and need Python 3.10+. Before importing,
|
||||
preparation reuses checksum-verified game jars and libraries from the current
|
||||
or another installed Horizon version, so the original Minecraft install is
|
||||
only required when no valid imported copy exists.
|
||||
- **Patch notes**: each release's notes, newest first, with a link to GitHub Sponsors. Quiet "Join Discord" and "Website" links sit in the sidebar footer.
|
||||
|
||||
Data lives in the platform's data directory (`~/.local/share/horizon-launcher` on Linux,
|
||||
|
||||
+19
-26
@@ -591,17 +591,18 @@ fn preparer_binary(dir: &Path) -> Option<PathBuf> {
|
||||
/// Java (and Python, for versions before horizon-prepare).
|
||||
pub fn preparer(tag: &str, minecraft: &Path, log: &dyn Fn(String)) -> Result<Preparer, String> {
|
||||
let version = game_version(tag);
|
||||
let dir = version_dir(tag);
|
||||
let reused = horizon_prepare::artifacts::reuse_imported(&dir, &|line| log(line.to_string()))?;
|
||||
let manifest = minecraft
|
||||
.join("versions")
|
||||
.join(&version)
|
||||
.join(format!("{version}.json"));
|
||||
if !manifest.exists() {
|
||||
if !reused && !manifest.exists() {
|
||||
return Err(format!(
|
||||
"Minecraft {version} is not in {}. Play {version} once from the official launcher, or choose another folder.",
|
||||
minecraft.display()
|
||||
));
|
||||
}
|
||||
let dir = version_dir(tag);
|
||||
let binary = preparer_binary(&dir);
|
||||
let python = if binary.is_some() {
|
||||
// The JDK the version pins, found as horizon-prepare finds it, so a missing one is
|
||||
@@ -625,7 +626,7 @@ pub fn preparer(tag: &str, minecraft: &Path, log: &dyn Fn(String)) -> Result<Pre
|
||||
let jar = data_dir()
|
||||
.join("server-jars")
|
||||
.join(format!("{version}.jar"));
|
||||
if !jar.exists() {
|
||||
if !reused && !jar.exists() {
|
||||
let json: serde_json::Value =
|
||||
serde_json::from_str(&fs::read_to_string(&manifest).map_err(|e| e.to_string())?)
|
||||
.map_err(|e| e.to_string())?;
|
||||
@@ -650,32 +651,26 @@ pub fn preparer(tag: &str, minecraft: &Path, log: &dyn Fn(String)) -> Result<Pre
|
||||
{
|
||||
return Ok(Preparer::InProcess(horizon_prepare::Options {
|
||||
root: dir,
|
||||
import: true,
|
||||
import: !reused,
|
||||
minecraft_dir: Some(minecraft.to_path_buf()),
|
||||
server_jar: Some(jar),
|
||||
server_jar: (!reused).then_some(jar),
|
||||
}));
|
||||
}
|
||||
let mut cmd = Command::new(binary);
|
||||
cmd.current_dir(&dir)
|
||||
.arg("--root")
|
||||
.arg(&dir)
|
||||
.args(["--prepare", "--server-jar"])
|
||||
.arg(&jar)
|
||||
.arg("--minecraft-dir")
|
||||
.arg(minecraft);
|
||||
cmd.current_dir(&dir).arg("--root").arg(&dir);
|
||||
if !reused {
|
||||
cmd.args(["--prepare", "--server-jar"]).arg(&jar);
|
||||
}
|
||||
cmd.arg("--minecraft-dir").arg(minecraft);
|
||||
return Ok(Preparer::Process(cmd));
|
||||
}
|
||||
let mut cmd = Command::new(python.unwrap());
|
||||
cmd.current_dir(&dir)
|
||||
.args([
|
||||
"-u",
|
||||
"tools/prepare_native_client.py",
|
||||
"--prepare",
|
||||
"--server-jar",
|
||||
])
|
||||
.arg(&jar)
|
||||
.arg("--minecraft-dir")
|
||||
.arg(minecraft);
|
||||
.args(["-u", "tools/prepare_native_client.py"]);
|
||||
if !reused {
|
||||
cmd.args(["--prepare", "--server-jar"]).arg(&jar);
|
||||
}
|
||||
cmd.arg("--minecraft-dir").arg(minecraft);
|
||||
Ok(Preparer::Process(cmd))
|
||||
}
|
||||
|
||||
@@ -965,14 +960,12 @@ pub fn remove_version(tag: &str) -> Result<(), String> {
|
||||
}
|
||||
|
||||
/// The Minecraft folder to prepare from: the one given, the one chosen in the launcher, or the
|
||||
/// official launcher's default.
|
||||
/// official launcher's default. It may be absent when imported files can be reused.
|
||||
pub fn minecraft_dir(requested: Option<PathBuf>) -> Result<PathBuf, String> {
|
||||
requested
|
||||
Ok(requested
|
||||
.or(Settings::load().minecraft_dir)
|
||||
.or_else(default_minecraft_dir)
|
||||
.ok_or_else(|| {
|
||||
"No Minecraft folder found. Pass the official launcher's game folder.".into()
|
||||
})
|
||||
.unwrap_or_else(|| horizon_prepare::artifacts::minecraft_dir(None)))
|
||||
}
|
||||
|
||||
/// The server folder: the one given, the one chosen in the launcher, or `server/` in the data folder.
|
||||
|
||||
@@ -501,10 +501,11 @@ impl Launcher {
|
||||
let Some(tag) = self.selected().cloned() else {
|
||||
return;
|
||||
};
|
||||
let Some(minecraft) = self.settings.minecraft_dir.clone() else {
|
||||
self.prepare_error = Some("Choose your Minecraft folder first.".into());
|
||||
return;
|
||||
};
|
||||
let minecraft = self
|
||||
.settings
|
||||
.minecraft_dir
|
||||
.clone()
|
||||
.unwrap_or_else(|| horizon_prepare::artifacts::minecraft_dir(None));
|
||||
self.prepare_log.clear();
|
||||
self.prepare_error = None;
|
||||
self.prepare_log
|
||||
|
||||
Reference in New Issue
Block a user