723 lines
24 KiB
Rust
723 lines
24 KiB
Rust
use super::content::get_projects;
|
|
use super::get::get;
|
|
use super::paths::get_full_path;
|
|
use crate::api::content_search::original_content_relative_path;
|
|
use crate::event::LoadingBarType;
|
|
use crate::event::emit::{emit_loading, init_loading};
|
|
use crate::pack::install_from::{
|
|
EnvType, PackDependency, PackFile, PackFileHash, PackFormat,
|
|
};
|
|
use crate::state::{
|
|
CacheBehaviour, CachedEntry, ContentProviderRef, InstanceMetadata,
|
|
ModLoader, ModrinthVersionId, SideType, State,
|
|
};
|
|
use crate::util::io::{self, IOError};
|
|
use async_zip::tokio::write::ZipFileWriter;
|
|
use async_zip::{Compression, DeflateOption, ZipEntryBuilder};
|
|
use futures::io::AsyncWriteExt;
|
|
use path_util::SafeRelativeUtf8UnixPathBuf;
|
|
use std::collections::{HashMap, HashSet};
|
|
use std::path::PathBuf;
|
|
use tokio::fs::File;
|
|
use tokio::io::AsyncReadExt;
|
|
|
|
const METADATA_PROGRESS_WEIGHT: f64 = 15.0;
|
|
const WRITE_PROGRESS_WEIGHT: f64 = 80.0;
|
|
/// Minimum bar movement (in progress points) before another loading event is
|
|
/// emitted, so small packs do not spam the UI with per-chunk updates.
|
|
const PROGRESS_EMIT_THRESHOLD: f64 = 0.1;
|
|
/// Hard floor on how many copy chunks may pass between loading events, so very
|
|
/// large files still move the bar while they are being packed.
|
|
const PROGRESS_EMIT_CHUNKS: u32 = 64;
|
|
/// Deflate is only applied to compressible text/config files; a low level
|
|
/// keeps packing fast while still shrinking those files.
|
|
const DEFLATE_OPTION: DeflateOption = DeflateOption::Other(1);
|
|
const COPY_BUFFER_SIZE: usize = 256 * 1024;
|
|
|
|
#[tracing::instrument(skip_all)]
|
|
pub async fn export_mrpack(
|
|
instance_id: &str,
|
|
export_path: PathBuf,
|
|
included_export_candidates: Vec<String>,
|
|
version_id: Option<String>,
|
|
description: Option<String>,
|
|
_name: Option<String>,
|
|
) -> crate::Result<()> {
|
|
let state = State::get().await?;
|
|
let _permit: tokio::sync::SemaphorePermit =
|
|
state.io_semaphore.0.acquire().await?;
|
|
let metadata = get(instance_id).await?.ok_or_else(|| {
|
|
crate::ErrorKind::OtherError(format!(
|
|
"Tried to export a nonexistent instance {instance_id}!"
|
|
))
|
|
})?;
|
|
// Directly associated instances own no files: everything lives in the
|
|
// linked launcher's `.minecraft`, so there is nothing exportable here.
|
|
if metadata.instance.is_direct_linked() {
|
|
return Err(crate::ErrorKind::InputError(format!(
|
|
"\"{}\" is directly associated with an external launcher; its \
|
|
files are managed by that launcher and cannot be exported",
|
|
metadata.instance.name
|
|
))
|
|
.into());
|
|
}
|
|
let included_export_candidates = included_export_candidates
|
|
.into_iter()
|
|
.map(|candidate| candidate.replace('\\', "/"))
|
|
.filter(|x| {
|
|
if let Some(f) = PathBuf::from(x).file_name()
|
|
&& f.to_string_lossy().starts_with(".DS_Store")
|
|
{
|
|
return false;
|
|
}
|
|
true
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
let instance_base_path = get_full_path(instance_id).await?;
|
|
let mut file = File::create(&export_path)
|
|
.await
|
|
.map_err(|e| IOError::with_path(e, &export_path))?;
|
|
let mut writer = ZipFileWriter::with_tokio(&mut file);
|
|
let version_id = version_id.unwrap_or("1.0.0".to_string());
|
|
let loading_bar = init_loading(
|
|
LoadingBarType::ZipExtract {
|
|
instance_id: metadata.instance.id.clone(),
|
|
instance_name: metadata.instance.name.clone(),
|
|
},
|
|
100.0,
|
|
"Exporting instance to .mrpack",
|
|
)
|
|
.await?;
|
|
|
|
let (mut progress, mut packfile) = {
|
|
let mut metadata_progress = 0.0;
|
|
let mut on_metadata_progress = |target: f64| {
|
|
let target = METADATA_PROGRESS_WEIGHT * target.clamp(0.0, 1.0);
|
|
let delta = target - metadata_progress;
|
|
metadata_progress = target;
|
|
let _ = emit_loading(
|
|
&loading_bar,
|
|
delta,
|
|
Some("Preparing modpack metadata"),
|
|
);
|
|
};
|
|
let packfile = create_mrpack_json_inner(
|
|
&metadata,
|
|
version_id,
|
|
description,
|
|
&mut on_metadata_progress,
|
|
)
|
|
.await?;
|
|
drop(on_metadata_progress);
|
|
(metadata_progress, packfile)
|
|
};
|
|
packfile.files.retain(|f| {
|
|
is_export_candidate_included(
|
|
f.path.as_str(),
|
|
&included_export_candidates,
|
|
)
|
|
});
|
|
strip_localized_pack_file_paths(&mut packfile.files);
|
|
|
|
let mut path_list = Vec::new();
|
|
add_all_recursive_folder_paths(&instance_base_path, &mut path_list).await?;
|
|
let disk_paths = path_list
|
|
.iter()
|
|
.filter(|path| path.is_file())
|
|
.filter_map(|path| {
|
|
pack_get_relative_path(&instance_base_path, path)
|
|
.ok()
|
|
.map(|relative_path| relative_path.as_str().to_string())
|
|
})
|
|
.collect::<HashSet<_>>();
|
|
let mut write_list: Vec<(PathBuf, String)> = Vec::new();
|
|
let mut write_total_bytes: u64 = 0;
|
|
for path in &path_list {
|
|
let Ok(relative_path) =
|
|
pack_get_relative_path(&instance_base_path, path)
|
|
else {
|
|
continue;
|
|
};
|
|
let exported_path =
|
|
original_content_relative_path(relative_path.as_str());
|
|
let Ok(metadata) = path.metadata() else {
|
|
continue;
|
|
};
|
|
if !metadata.is_file()
|
|
|| packfile
|
|
.files
|
|
.iter()
|
|
.any(|f| f.path.as_str() == exported_path)
|
|
|| !is_export_candidate_included(
|
|
relative_path.as_str(),
|
|
&included_export_candidates,
|
|
)
|
|
{
|
|
continue;
|
|
}
|
|
write_total_bytes += metadata.len();
|
|
write_list.push((path.clone(), relative_path.as_str().to_string()));
|
|
}
|
|
let mut written_override_paths = HashSet::new();
|
|
let mut buffer = vec![0u8; COPY_BUFFER_SIZE];
|
|
let mut bytes_written = 0u64;
|
|
let mut write_progress = 0.0_f64;
|
|
for (path, relative_path) in write_list {
|
|
let exported_path =
|
|
original_content_relative_path(relative_path.as_str());
|
|
let entry_path = if exported_path != relative_path.as_str()
|
|
&& !disk_paths.contains(&exported_path)
|
|
&& written_override_paths.insert(exported_path.clone())
|
|
{
|
|
exported_path
|
|
} else {
|
|
relative_path.as_str().to_string()
|
|
};
|
|
let compression = if is_already_compressed(&entry_path) {
|
|
Compression::Stored
|
|
} else {
|
|
Compression::Deflate
|
|
};
|
|
let builder = ZipEntryBuilder::new(
|
|
format!("overrides/{entry_path}").into(),
|
|
compression,
|
|
)
|
|
.deflate_option(DEFLATE_OPTION);
|
|
let mut file = File::open(&path)
|
|
.await
|
|
.map_err(|e| IOError::with_path(e, &path))?;
|
|
let mut entry = writer.write_entry_stream(builder).await?;
|
|
let mut chunks_since_emit = 0u32;
|
|
loop {
|
|
let read = file
|
|
.read(&mut buffer)
|
|
.await
|
|
.map_err(|e| IOError::with_path(e, &path))?;
|
|
if read == 0 {
|
|
break;
|
|
}
|
|
entry
|
|
.write_all(&buffer[..read])
|
|
.await
|
|
.map_err(|e| IOError::with_path(e, &path))?;
|
|
bytes_written += read as u64;
|
|
chunks_since_emit += 1;
|
|
let target = WRITE_PROGRESS_WEIGHT
|
|
* (bytes_written as f64 / write_total_bytes.max(1) as f64)
|
|
.min(1.0);
|
|
let delta = target - write_progress;
|
|
if delta >= PROGRESS_EMIT_THRESHOLD
|
|
|| chunks_since_emit >= PROGRESS_EMIT_CHUNKS
|
|
{
|
|
write_progress = target;
|
|
progress += delta;
|
|
let _ = emit_loading(
|
|
&loading_bar,
|
|
delta,
|
|
Some(relative_path.as_str()),
|
|
);
|
|
chunks_since_emit = 0;
|
|
}
|
|
}
|
|
entry.close().await?;
|
|
let target = WRITE_PROGRESS_WEIGHT
|
|
* (bytes_written as f64 / write_total_bytes.max(1) as f64).min(1.0);
|
|
let delta = target - write_progress;
|
|
if delta > 0.0 {
|
|
write_progress = target;
|
|
progress += delta;
|
|
let _ =
|
|
emit_loading(&loading_bar, delta, Some(relative_path.as_str()));
|
|
}
|
|
}
|
|
|
|
let data = serde_json::to_vec_pretty(&packfile)?;
|
|
let builder = ZipEntryBuilder::new(
|
|
"modrinth.index.json".to_string().into(),
|
|
Compression::Deflate,
|
|
);
|
|
writer.write_entry_whole(builder, &data).await?;
|
|
writer.close().await?;
|
|
|
|
let _ =
|
|
emit_loading(&loading_bar, 100.0 - progress, Some("Finalizing export"));
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Files in these formats are already compressed, so re-compressing them
|
|
/// with Deflate wastes CPU for little size gain; store them as-is instead.
|
|
fn is_already_compressed(path: &str) -> bool {
|
|
let Some(extension) = path.rsplit('.').next() else {
|
|
return false;
|
|
};
|
|
matches!(
|
|
extension.to_ascii_lowercase().as_str(),
|
|
"7z" | "aac"
|
|
| "apk"
|
|
| "avif"
|
|
| "bz2"
|
|
| "flac"
|
|
| "gif"
|
|
| "gz"
|
|
| "heic"
|
|
| "jar"
|
|
| "jpeg"
|
|
| "jpg"
|
|
| "lz4"
|
|
| "lzma"
|
|
| "m4a"
|
|
| "mkv"
|
|
| "mov"
|
|
| "mp3"
|
|
| "mp4"
|
|
| "ogg"
|
|
| "oga"
|
|
| "opus"
|
|
| "png"
|
|
| "rar"
|
|
| "webm"
|
|
| "webp"
|
|
| "woff"
|
|
| "woff2"
|
|
| "xz"
|
|
| "zip"
|
|
| "zst"
|
|
)
|
|
}
|
|
|
|
fn is_export_candidate_included(
|
|
path: &str,
|
|
included_export_candidates: &[String],
|
|
) -> bool {
|
|
included_export_candidates.iter().any(|candidate| {
|
|
path == candidate
|
|
|| path
|
|
.strip_prefix(candidate)
|
|
.is_some_and(|suffix| suffix.starts_with('/'))
|
|
})
|
|
}
|
|
|
|
/// Rewrites `[中文名]`-prefixed install paths back to their original names so
|
|
/// exported packs stay free of localized file names. Entries whose stripped
|
|
/// path would collide with another entry keep their on-disk name.
|
|
fn strip_localized_pack_file_paths(files: &mut [PackFile]) {
|
|
let mut used = files
|
|
.iter()
|
|
.map(|file| file.path.as_str().to_string())
|
|
.collect::<HashSet<_>>();
|
|
for file in files {
|
|
let stripped = original_content_relative_path(file.path.as_str());
|
|
if stripped == file.path.as_str() || used.contains(&stripped) {
|
|
continue;
|
|
}
|
|
let Ok(path) = SafeRelativeUtf8UnixPathBuf::try_from(stripped.clone())
|
|
else {
|
|
continue;
|
|
};
|
|
used.insert(stripped);
|
|
file.path = path;
|
|
}
|
|
}
|
|
|
|
#[tracing::instrument]
|
|
pub async fn get_pack_export_candidates(
|
|
instance_id: &str,
|
|
) -> crate::Result<Vec<SafeRelativeUtf8UnixPathBuf>> {
|
|
let mut path_list = Vec::new();
|
|
let instance_base_dir = get_full_path(instance_id).await?;
|
|
let mut read_dir = io::read_dir(&instance_base_dir).await?;
|
|
while let Some(entry) = read_dir
|
|
.next_entry()
|
|
.await
|
|
.map_err(|e| IOError::with_path(e, &instance_base_dir))?
|
|
{
|
|
let path = entry.path();
|
|
if path.is_dir() {
|
|
let mut read_dir = io::read_dir(&path).await?;
|
|
while let Some(entry) = read_dir
|
|
.next_entry()
|
|
.await
|
|
.map_err(|e| IOError::with_path(e, &instance_base_dir))?
|
|
{
|
|
path_list.push(pack_get_relative_path(
|
|
&instance_base_dir,
|
|
&entry.path(),
|
|
)?);
|
|
}
|
|
} else {
|
|
path_list.push(pack_get_relative_path(&instance_base_dir, &path)?);
|
|
}
|
|
}
|
|
Ok(path_list)
|
|
}
|
|
|
|
fn pack_get_relative_path(
|
|
instance_path: &PathBuf,
|
|
path: &PathBuf,
|
|
) -> crate::Result<SafeRelativeUtf8UnixPathBuf> {
|
|
Ok(SafeRelativeUtf8UnixPathBuf::try_from(
|
|
path.strip_prefix(instance_path)
|
|
.map_err(|_| {
|
|
crate::ErrorKind::FSError(format!(
|
|
"Path {path:?} does not correspond to an instance"
|
|
))
|
|
})?
|
|
.components()
|
|
.map(|c| c.as_os_str().to_string_lossy())
|
|
.collect::<Vec<_>>()
|
|
.join("/"),
|
|
)?)
|
|
}
|
|
|
|
/// The `.mrpack` specification stores archive paths as Unix-style relative
|
|
/// paths, even when the source instance is on Windows.
|
|
fn mrpack_relative_path(
|
|
relative_path: &str,
|
|
) -> crate::Result<SafeRelativeUtf8UnixPathBuf> {
|
|
Ok(SafeRelativeUtf8UnixPathBuf::try_from(
|
|
relative_path.replace('\\', "/"),
|
|
)?)
|
|
}
|
|
|
|
#[tracing::instrument(skip_all)]
|
|
pub async fn create_mrpack_json(
|
|
metadata: &InstanceMetadata,
|
|
version_id: String,
|
|
description: Option<String>,
|
|
) -> crate::Result<PackFormat> {
|
|
create_mrpack_json_inner(metadata, version_id, description, &mut |_| {})
|
|
.await
|
|
}
|
|
|
|
#[tracing::instrument(skip_all)]
|
|
async fn create_mrpack_json_inner(
|
|
metadata: &InstanceMetadata,
|
|
version_id: String,
|
|
description: Option<String>,
|
|
on_progress: &mut impl FnMut(f64),
|
|
) -> crate::Result<PackFormat> {
|
|
let mut dependencies = HashMap::new();
|
|
match (
|
|
metadata.applied_content_set.loader,
|
|
metadata.applied_content_set.loader_version.clone(),
|
|
) {
|
|
(ModLoader::Forge, Some(v)) => {
|
|
dependencies.insert(PackDependency::Forge, v)
|
|
}
|
|
(ModLoader::NeoForge, Some(v)) => {
|
|
dependencies.insert(PackDependency::NeoForge, v)
|
|
}
|
|
(ModLoader::Fabric, Some(v)) => {
|
|
dependencies.insert(PackDependency::FabricLoader, v)
|
|
}
|
|
(ModLoader::Quilt, Some(v)) => {
|
|
dependencies.insert(PackDependency::QuiltLoader, v)
|
|
}
|
|
(ModLoader::Babric, _) => {
|
|
return Err(crate::ErrorKind::OtherError(
|
|
"Babric instances cannot be exported to mrpack, as the format has no Babric dependency type".to_string(),
|
|
).into())
|
|
}
|
|
(ModLoader::Vanilla, _) => None,
|
|
(ModLoader::OptiFine, _) => {
|
|
return Err(crate::ErrorKind::OtherError(
|
|
"OptiFine instances cannot be exported to mrpack, as the format has no OptiFine dependency type".to_string(),
|
|
)
|
|
.into());
|
|
}
|
|
_ => {
|
|
return Err(crate::ErrorKind::OtherError(
|
|
"Loader version mismatch".to_string(),
|
|
)
|
|
.into());
|
|
}
|
|
};
|
|
dependencies.insert(
|
|
PackDependency::Minecraft,
|
|
metadata.applied_content_set.game_version.clone(),
|
|
);
|
|
|
|
let state = State::get().await?;
|
|
let projects = get_projects(
|
|
&metadata.instance.id,
|
|
Some(CacheBehaviour::MustRevalidate),
|
|
)
|
|
.await?
|
|
.into_iter()
|
|
.collect::<Vec<_>>();
|
|
on_progress(0.2);
|
|
let instance_path = get_full_path(&metadata.instance.id).await?;
|
|
let mut modrinth_version_ids = projects
|
|
.iter()
|
|
.flat_map(|(_, file)| file.provider_refs.iter())
|
|
.filter_map(|reference| match reference {
|
|
ContentProviderRef::Modrinth {
|
|
version_id: Some(version_id),
|
|
..
|
|
} => Some(version_id.to_string()),
|
|
_ => None,
|
|
})
|
|
.collect::<HashSet<_>>();
|
|
for file in projects.iter().map(|(_, file)| file) {
|
|
if let Some(metadata) = &file.modrinth {
|
|
modrinth_version_ids.insert(metadata.version_id.to_string());
|
|
}
|
|
}
|
|
let modrinth_version_id_refs = modrinth_version_ids
|
|
.iter()
|
|
.map(|id| ModrinthVersionId::new(id.clone()))
|
|
.collect::<crate::Result<Vec<_>>>()?;
|
|
let versions = CachedEntry::get_version_many(
|
|
&modrinth_version_id_refs,
|
|
None,
|
|
&state.pool,
|
|
&state.api_semaphore,
|
|
)
|
|
.await?;
|
|
on_progress(0.4);
|
|
let versions_by_id = versions
|
|
.into_iter()
|
|
.map(|version| (version.id.clone(), version))
|
|
.collect::<HashMap<_, _>>();
|
|
let mut files = Vec::new();
|
|
let mut remote_paths = HashSet::new();
|
|
let project_total = projects.len();
|
|
for (index, (path, content_file)) in projects.into_iter().enumerate() {
|
|
on_progress(
|
|
0.4 + 0.6 * ((index + 1) as f64 / project_total.max(1) as f64),
|
|
);
|
|
let disk_path = instance_path.join(path.as_str());
|
|
let Ok((disk_size, local_sha1)) =
|
|
crate::util::fetch::sha1_file_async(&disk_path).await
|
|
else {
|
|
continue;
|
|
};
|
|
let Some(file_size) = u32::try_from(disk_size).ok() else {
|
|
continue;
|
|
};
|
|
let mut remote: Option<(HashMap<PackFileHash, String>, String)> = None;
|
|
for reference in &content_file.provider_refs {
|
|
match reference {
|
|
ContentProviderRef::Modrinth {
|
|
version_id: Some(version_id),
|
|
..
|
|
} => {
|
|
let Some(version) = versions_by_id.get(version_id.as_str())
|
|
else {
|
|
continue;
|
|
};
|
|
if let Some(version_file) =
|
|
version.files.iter().find(|file| {
|
|
file.size == file_size
|
|
&& file.hashes.get("sha1").is_some_and(|hash| {
|
|
hash.eq_ignore_ascii_case(&local_sha1)
|
|
})
|
|
&& !file.url.trim().is_empty()
|
|
})
|
|
{
|
|
remote = Some((
|
|
version_file
|
|
.hashes
|
|
.clone()
|
|
.into_iter()
|
|
.map(|(kind, hash)| {
|
|
(PackFileHash::from(kind), hash)
|
|
})
|
|
.collect(),
|
|
version_file.url.clone(),
|
|
));
|
|
break;
|
|
}
|
|
}
|
|
ContentProviderRef::CurseForge {
|
|
project_id,
|
|
file_id: Some(file_id),
|
|
} => {
|
|
let Ok(file) = crate::api::curseforge::get_file(
|
|
project_id.get(),
|
|
file_id.get(),
|
|
)
|
|
.await
|
|
else {
|
|
continue;
|
|
};
|
|
let allowed =
|
|
crate::api::curseforge::get_project(project_id.get())
|
|
.await
|
|
.ok()
|
|
.and_then(|project| project.allow_mod_distribution)
|
|
.unwrap_or(true);
|
|
if !allowed {
|
|
continue;
|
|
}
|
|
let hash = file
|
|
.hashes
|
|
.iter()
|
|
.find(|hash| hash.algo == 1)
|
|
.map(|hash| hash.value.as_str());
|
|
if file.file_length == u64::from(file_size)
|
|
&& hash.is_some_and(|hash| {
|
|
hash.eq_ignore_ascii_case(&local_sha1)
|
|
})
|
|
&& file
|
|
.download_url
|
|
.as_deref()
|
|
.is_some_and(|url| !url.trim().is_empty())
|
|
{
|
|
let mut hashes = HashMap::new();
|
|
if let Some(hash) = hash {
|
|
hashes.insert(PackFileHash::Sha1, hash.to_string());
|
|
}
|
|
remote = Some((
|
|
hashes,
|
|
file.download_url.unwrap_or_default(),
|
|
));
|
|
break;
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
let Some((hashes, download)) = remote else {
|
|
continue;
|
|
};
|
|
let relative_path = path.as_str().replace('\\', "/");
|
|
let Ok(path) = mrpack_relative_path(&original_content_relative_path(
|
|
&relative_path,
|
|
)) else {
|
|
continue;
|
|
};
|
|
if !remote_paths.insert(path.as_str().to_string()) {
|
|
continue;
|
|
}
|
|
let mut env = HashMap::new();
|
|
env.insert(EnvType::Client, SideType::Required);
|
|
env.insert(EnvType::Server, SideType::Required);
|
|
files.push(PackFile {
|
|
path,
|
|
hashes,
|
|
env: Some(env),
|
|
downloads: vec![download],
|
|
file_size,
|
|
});
|
|
}
|
|
on_progress(1.0);
|
|
|
|
Ok(PackFormat {
|
|
game: "minecraft".to_string(),
|
|
format_version: 1,
|
|
version_id,
|
|
name: metadata.instance.name.clone(),
|
|
summary: description,
|
|
files,
|
|
dependencies,
|
|
})
|
|
}
|
|
|
|
#[async_recursion::async_recursion]
|
|
async fn add_all_recursive_folder_paths(
|
|
folder: &PathBuf,
|
|
output: &mut Vec<PathBuf>,
|
|
) -> crate::Result<()> {
|
|
let mut read_dir = io::read_dir(folder).await?;
|
|
while let Some(entry) = read_dir
|
|
.next_entry()
|
|
.await
|
|
.map_err(|e| IOError::with_path(e, folder))?
|
|
{
|
|
let path = entry.path();
|
|
if path.is_dir() {
|
|
add_all_recursive_folder_paths(&path, output).await?;
|
|
} else {
|
|
output.push(path);
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use crate::state::{CreateDirectLinkInstance, State};
|
|
use std::sync::Arc;
|
|
use tempfile::TempDir;
|
|
|
|
#[test]
|
|
fn mrpack_paths_normalize_windows_separators() {
|
|
let path =
|
|
super::mrpack_relative_path(r"config\subdir\options.txt").unwrap();
|
|
|
|
assert_eq!(path.as_str(), "config/subdir/options.txt");
|
|
}
|
|
|
|
/// The launcher state is a process-wide singleton; initialize it once and
|
|
/// reuse it so `State::get()` resolves inside these APIs. The state root
|
|
/// is intentionally leaked (`.keep()`) because the shared state outlives
|
|
/// this function.
|
|
async fn global_state() -> Arc<State> {
|
|
if !State::initialized() {
|
|
let root = TempDir::new().unwrap().keep();
|
|
let _ =
|
|
State::init_for_test(root.to_string_lossy().to_string()).await;
|
|
}
|
|
State::get().await.unwrap()
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn direct_link_instances_cannot_be_exported() {
|
|
let state = global_state().await;
|
|
let minecraft = TempDir::new().unwrap();
|
|
let version_dir = minecraft.path().join("versions/export-demo");
|
|
std::fs::create_dir_all(&version_dir).unwrap();
|
|
std::fs::write(
|
|
version_dir.join("export-demo.json"),
|
|
serde_json::to_vec_pretty(&serde_json::json!({
|
|
"id": "export-demo",
|
|
"inheritsFrom": "1.20.1",
|
|
"mainClass": "net.minecraft.client.main.Main"
|
|
}))
|
|
.unwrap(),
|
|
)
|
|
.unwrap();
|
|
|
|
let instance = crate::state::create_direct_link_instance(
|
|
CreateDirectLinkInstance {
|
|
name: None,
|
|
launcher_type:
|
|
crate::api::pack::import::ImportLauncherType::Generic,
|
|
base_path: minecraft.path().to_path_buf(),
|
|
instance_folder: "versions/export-demo".to_string(),
|
|
instance_path: None,
|
|
game_dir_mode: None,
|
|
},
|
|
&state,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
let export_target = minecraft.path().join("out.mrpack");
|
|
let error = super::export_mrpack(
|
|
&instance.id,
|
|
export_target,
|
|
Vec::new(),
|
|
None,
|
|
None,
|
|
None,
|
|
)
|
|
.await
|
|
.unwrap_err();
|
|
|
|
let message = error.to_string();
|
|
assert!(
|
|
message.contains("directly associated"),
|
|
"expected a friendly rejection, got: {message}"
|
|
);
|
|
assert!(
|
|
!minecraft.path().join("out.mrpack").exists(),
|
|
"no archive may be written"
|
|
);
|
|
}
|
|
}
|