use std::{
collections::HashSet,
path::{Path, PathBuf},
};
use anyhow::{Context, Result, bail};
use elemental_core::{
minecraft::MinecraftVersionId,
runtime::distribution::Distribution,
runtime::{RuntimeValidationMode, resolve_runtime},
storage::{
Storage,
layout::{Layout, Layoutable},
},
};
use elemental_infra::downloader::{
core::ElementalDownloader,
task::{DownloadExecutionPolicy, DownloadPlan},
};
use elemental_schema::{
forge::ForgeInstallerProfile,
mojang::piston::{
PistonMetaArguments, PistonMetaAssetIndex, PistonMetaData, PistonMetaDownloads,
PistonMetaJavaVersion, PistonMetaLibraries, PistonMetaLibrariesDownloadsArtifact,
PistonMetaLogging,
},
};
use serde::Deserialize;
use tokio::fs::create_dir_all;
use crate::{
drivers::vanilla::source::{VanillaSource, resolve_vanilla_metadata},
families::{
installer::{InstallerArchive, InstallerArtifact, installer_client_processors_ready},
version_json::{
BaseInstanceLayout, PreparedVersionJsonInstance, ResolvedVersionJsonInstance,
ResolvedVersionJsonMetadata, VersionJsonInstanceLayout, VersionJsonInstanceResource,
VersionJsonRemoteResolver, VersionJsonRootLayout, VersionJsonRootResource,
},
},
loader_version::LoaderVersionId,
};
const INSTALL_PROFILE_ENTRY: &str = "install_profile.json";
#[derive(Debug, Clone)]
pub struct InstallerPersistedState {
pub install_profile: ForgeInstallerProfile,
pub embedded_version: Option<serde_json::Value>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct InstallerInstallStatus {
pub installer_downloaded: bool,
pub install_profile_persisted: bool,
pub embedded_version_persisted: bool,
pub profile_libraries_ready: bool,
pub processors_completed: bool,
pub launch_version_ready: bool,
}
#[derive(Debug, Clone, Copy)]
struct InstallerStatePaths<'a> {
instance_root: &'a Path,
family_name: &'a str,
}
impl<'a> InstallerStatePaths<'a> {
fn new(instance_root: &'a Path, family_name: &'a str) -> Self {
Self {
instance_root,
family_name,
}
}
fn install_profile_path(self) -> PathBuf {
self.relative_path(PathBuf::from(INSTALL_PROFILE_ENTRY))
}
fn embedded_version_path(self) -> PathBuf {
self.relative_path(PathBuf::from("version.json"))
}
fn root(self) -> PathBuf {
self.resource_path(PathBuf::from(self.family_name))
}
fn relative_path(self, relative_path: PathBuf) -> PathBuf {
self.root().join(relative_path)
}
fn resource_path(self, resource_path: PathBuf) -> PathBuf {
BaseInstanceLayout
.get_extended_resource(
self.instance_root,
VersionJsonInstanceResource::Elemental(Some(resource_path)),
)
.expect("BaseInstanceLayout elemental resource path must always resolve")
}
fn load(self) -> Result<InstallerPersistedState> {
let install_profile_path = self.install_profile_path();
let install_profile = serde_json::from_reader(std::fs::File::open(&install_profile_path)?)
.with_context(|| {
format!(
"read persisted {} install profile failed: {}",
self.family_name,
install_profile_path.display()
)
})?;
let embedded_version_path = self.embedded_version_path();
let embedded_version = if embedded_version_path.exists() {
Some(
serde_json::from_reader(std::fs::File::open(&embedded_version_path)?)
.with_context(|| {
format!(
"read persisted {} embedded version failed: {}",
self.family_name,
embedded_version_path.display()
)
})?,
)
} else {
None
};
Ok(InstallerPersistedState {
install_profile,
embedded_version,
})
}
async fn persist_install_profile(self, install_profile: &ForgeInstallerProfile) -> Result<()> {
let path = self.install_profile_path();
let parent = path.parent().with_context(|| {
format!(
"{} install profile path has no parent directory",
self.family_name
)
})?;
create_dir_all(parent).await?;
tokio::fs::write(path, serde_json::to_vec_pretty(install_profile)?).await?;
Ok(())
}
async fn persist_embedded_version(
self,
embedded_version: Option<&serde_json::Value>,
) -> Result<()> {
let path = self.embedded_version_path();
if let Some(version) = embedded_version {
let parent = path.parent().with_context(|| {
format!(
"{} embedded version path has no parent directory",
self.family_name
)
})?;
create_dir_all(parent).await?;
tokio::fs::write(path, serde_json::to_vec_pretty(version)?).await?;
return Ok(());
}
if path.exists() {
tokio::fs::remove_file(path).await?;
}
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct InstallerProfileIdentity {
game_version: String,
loader_version: LoaderVersionId,
}
impl InstallerProfileIdentity {
fn from_profile(
install_profile: &ForgeInstallerProfile,
family_name: &str,
loader_name: &str,
) -> Result<Self> {
let game_version = install_profile
.minecraft
.clone()
.or_else(|| {
install_profile
.install
.as_ref()
.and_then(|legacy| legacy.minecraft.clone())
})
.with_context(|| {
format!("{family_name} install profile is missing minecraft version")
})?;
let raw_loader_version = install_profile
.path
.clone()
.or_else(|| {
install_profile
.install
.as_ref()
.and_then(|legacy| legacy.path.clone())
})
.and_then(|coordinate| coordinate.split(':').nth(2).map(ToOwned::to_owned))
.or_else(|| install_profile.version.clone())
.with_context(|| {
format!("{family_name} install profile is missing {loader_name} version identity")
})?;
Ok(Self {
game_version,
loader_version: LoaderVersionId::from(raw_loader_version),
})
}
fn validate_requested(
&self,
expected_game_version: &str,
expected_loader_version: &LoaderVersionId,
family_name: &str,
) -> Result<()> {
if self.game_version != expected_game_version {
bail!(
"{family_name} installer game version '{}' does not match requested game version '{}'",
self.game_version,
expected_game_version
);
}
if &self.loader_version != expected_loader_version {
bail!(
"{family_name} installer loader version '{}' does not match requested loader version '{}'",
self.loader_version,
expected_loader_version
);
}
Ok(())
}
}
pub fn read_embedded_version<P: AsRef<Path>>(
archive: &InstallerArchive<P>,
install_profile: &ForgeInstallerProfile,
family_name: &str,
) -> Result<Option<serde_json::Value>> {
if let Some(version_info) = &install_profile.version_info {
return Ok(Some(version_info.clone()));
}
let Some(json_path) = install_profile.json.as_deref() else {
return Ok(None);
};
Ok(Some(
archive
.read_json::<serde_json::Value>(json_path)
.with_context(|| {
format!("read {family_name} embedded version json failed: {json_path}")
})?,
))
}
pub async fn ensure_installer_artifact_downloaded(
downloader: &ElementalDownloader,
installer_artifact: &InstallerArtifact,
family_name: &str,
) -> Result<()> {
downloader
.run_plan(DownloadPlan::named(
format!("{family_name}-installer-{}", installer_artifact.coordinate),
DownloadExecutionPolicy::ServiceDefault,
vec![installer_artifact.download_task()],
)?)
.await
.with_context(|| format!("download {family_name} installer failed"))?;
Ok(())
}
pub async fn prepare_installer_state<V>(
downloader: &ElementalDownloader,
installer_artifact: &InstallerArtifact,
instance_root: &Path,
libraries_root: &Path,
family_name: &str,
validate_profile: V,
) -> Result<InstallerPersistedState>
where
V: Fn(&ForgeInstallerProfile) -> Result<()>,
{
ensure_installer_artifact_downloaded(downloader, installer_artifact, family_name).await?;
let archive = InstallerArchive::new(installer_artifact.path.clone());
let state_paths = InstallerStatePaths::new(instance_root, family_name);
let install_profile = archive
.read_json::<ForgeInstallerProfile>(INSTALL_PROFILE_ENTRY)
.with_context(|| {
format!("read {family_name} {INSTALL_PROFILE_ENTRY} from installer failed")
})?;
validate_profile(&install_profile)?;
let embedded_version = read_embedded_version(&archive, &install_profile, family_name)?;
state_paths
.persist_install_profile(&install_profile)
.await?;
state_paths
.persist_embedded_version(embedded_version.as_ref())
.await?;
archive
.extract_maven_artifacts(libraries_root)
.with_context(|| format!("extract {family_name} embedded maven artifacts failed"))?;
Ok(InstallerPersistedState {
install_profile,
embedded_version,
})
}
pub async fn prepare_installer_launch_version<RR, L, VL, F, M>(
request: InstallerLaunchVersionRequest<'_, RR, L, VL, F, M>,
) -> Result<PreparedVersionJsonInstance<RR, L, VL>>
where
RR: VersionJsonRemoteResolver + Clone,
L: VersionJsonRootLayout + Clone,
VL: VersionJsonInstanceLayout + Clone,
F: Fn(Vec<PistonMetaLibraries>) -> Result<Vec<PistonMetaLibraries>>,
M: Fn(Vec<PistonMetaLibraries>, Vec<PistonMetaLibraries>) -> Vec<PistonMetaLibraries>,
{
let embedded_version = request.embedded_version.context(format!(
"{} installer is missing an embedded version json; launchable {} preparation is not available",
request.family_name, request.family_name
))?;
let base_metadata =
resolve_vanilla_metadata(request.vanilla_source, request.game_version.as_str()).await?;
let merged_metadata = merge_embedded_version(
base_metadata.metadata,
embedded_version,
request.normalize_libraries,
request.merge_libraries,
request.family_name,
)?;
let launch_version = ResolvedVersionJsonMetadata::new(
request.remote_resolver.clone(),
merged_metadata,
base_metadata.asset_index_objects,
)
.persist(request.instance)
.await?;
launch_version.prepare(request.downloader).await
}
pub struct InstallerLaunchVersionRequest<'a, RR, L, VL, F, M>
where
RR: VersionJsonRemoteResolver + Clone,
L: VersionJsonRootLayout + Clone,
VL: VersionJsonInstanceLayout + Clone,
F: Fn(Vec<PistonMetaLibraries>) -> Result<Vec<PistonMetaLibraries>>,
M: Fn(Vec<PistonMetaLibraries>, Vec<PistonMetaLibraries>) -> Vec<PistonMetaLibraries>,
{
pub instance: &'a Storage<VL, Storage<L>>,
pub game_version: &'a MinecraftVersionId,
pub remote_resolver: &'a RR,
pub downloader: &'a ElementalDownloader,
pub vanilla_source: &'a VanillaSource,
pub embedded_version: Option<&'a serde_json::Value>,
pub normalize_libraries: F,
pub merge_libraries: M,
pub family_name: &'a str,
}
pub fn load_persisted_installer_state(
instance_root: &Path,
family_name: &str,
) -> Result<InstallerPersistedState> {
InstallerStatePaths::new(instance_root, family_name).load()
}
pub fn profile_game_and_raw_loader_version(
install_profile: &ForgeInstallerProfile,
family_name: &str,
loader_name: &str,
) -> Result<(String, LoaderVersionId)> {
let identity =
InstallerProfileIdentity::from_profile(install_profile, family_name, loader_name)?;
Ok((identity.game_version, identity.loader_version))
}
pub fn validate_installer_profile_identity(
expected_game_version: &str,
expected_loader_version: &LoaderVersionId,
actual_game_version: &str,
actual_loader_version: &LoaderVersionId,
family_name: &str,
) -> Result<()> {
InstallerProfileIdentity {
game_version: actual_game_version.to_owned(),
loader_version: actual_loader_version.clone(),
}
.validate_requested(expected_game_version, expected_loader_version, family_name)
}
pub fn profile_libraries_ready<L, VL>(
instance: &Storage<VL, Storage<L>>,
install_profile: &ForgeInstallerProfile,
) -> Result<bool>
where
L: VersionJsonRootLayout,
VL: VersionJsonInstanceLayout,
{
for library in &install_profile.libraries {
for artifact in installer_library_artifacts(library) {
if !instance
.parent
.try_get_resource(VersionJsonRootResource::Libraries(Some(PathBuf::from(
artifact.path.as_str(),
))))?
.exists()
{
return Ok(false);
}
}
}
Ok(true)
}
pub async fn resolve_installer_processor_runtime<RR, L, VL>(
launch_version: &PreparedVersionJsonInstance<RR, L, VL>,
runtime_executable_path: Option<&Path>,
runtime_validation: RuntimeValidationMode,
operation_name: &str,
) -> Result<Distribution>
where
RR: VersionJsonRemoteResolver,
L: VersionJsonRootLayout,
VL: VersionJsonInstanceLayout,
{
let required_major_version = launch_version.required_java_major_version();
resolve_runtime(
required_major_version,
runtime_executable_path,
runtime_validation,
operation_name,
)
.await
}
pub async fn installer_install_status<RR, L, VL>(
instance: &Storage<VL, Storage<L>>,
installer_artifact: &InstallerArtifact,
install_profile: &ForgeInstallerProfile,
launch_version: &ResolvedVersionJsonInstance<RR, L, VL>,
family_name: &str,
) -> Result<InstallerInstallStatus>
where
RR: VersionJsonRemoteResolver,
L: VersionJsonRootLayout,
VL: VersionJsonInstanceLayout,
{
let state_paths = InstallerStatePaths::new(&instance.path, family_name);
Ok(InstallerInstallStatus {
installer_downloaded: installer_artifact.path.exists(),
install_profile_persisted: state_paths.install_profile_path().exists(),
embedded_version_persisted: state_paths.embedded_version_path().exists(),
profile_libraries_ready: profile_libraries_ready(instance, install_profile)?,
processors_completed: installer_client_processors_ready(
instance,
installer_artifact,
install_profile,
family_name,
)?,
launch_version_ready: launch_version.status().await?.is_ready(),
})
}
pub async fn persist_install_profile(
instance_root: &Path,
install_profile: &ForgeInstallerProfile,
family_name: &str,
) -> Result<()> {
InstallerStatePaths::new(instance_root, family_name)
.persist_install_profile(install_profile)
.await
}
pub async fn persist_embedded_version(
instance_root: &Path,
embedded_version: Option<&serde_json::Value>,
family_name: &str,
) -> Result<()> {
InstallerStatePaths::new(instance_root, family_name)
.persist_embedded_version(embedded_version)
.await
}
pub fn install_profile_path(instance_root: &Path, family_name: &str) -> PathBuf {
InstallerStatePaths::new(instance_root, family_name).install_profile_path()
}
pub fn embedded_version_path(instance_root: &Path, family_name: &str) -> PathBuf {
InstallerStatePaths::new(instance_root, family_name).embedded_version_path()
}
#[derive(Debug, Clone, Deserialize)]
struct EmbeddedVersionData {
#[serde(default)]
arguments: Option<PistonMetaArguments>,
#[serde(rename = "minecraftArguments", default)]
minecraft_arguments: Option<String>,
#[serde(rename = "inheritsFrom", default)]
inherits_from: Option<String>,
#[serde(rename = "assetIndex", default)]
asset_index: Option<PistonMetaAssetIndex>,
#[serde(default)]
assets: Option<String>,
#[serde(rename = "complianceLevel", default)]
compliance_level: Option<usize>,
#[serde(default)]
downloads: Option<PistonMetaDownloads>,
#[serde(default)]
id: Option<String>,
#[serde(rename = "javaVersion", default)]
java_version: Option<PistonMetaJavaVersion>,
#[serde(default)]
libraries: Vec<PistonMetaLibraries>,
#[serde(default)]
logging: Option<PistonMetaLogging>,
#[serde(rename = "mainClass", default)]
main_class: Option<String>,
#[serde(rename = "minimumLauncherVersion", default)]
minimum_launcher_version: Option<usize>,
#[serde(rename = "type", default)]
release_type: Option<String>,
#[serde(default)]
time: Option<String>,
#[serde(rename = "releaseTime", default)]
release_time: Option<String>,
}
fn merge_embedded_version<F, M>(
base_metadata: PistonMetaData,
embedded_version: &serde_json::Value,
normalize_libraries: F,
merge_libraries: M,
family_name: &str,
) -> Result<PistonMetaData>
where
F: Fn(Vec<PistonMetaLibraries>) -> Result<Vec<PistonMetaLibraries>>,
M: Fn(Vec<PistonMetaLibraries>, Vec<PistonMetaLibraries>) -> Vec<PistonMetaLibraries>,
{
let mut embedded = serde_json::from_value::<EmbeddedVersionData>(embedded_version.clone())
.with_context(|| format!("decode {family_name} embedded version json failed"))?;
embedded.libraries = normalize_libraries(embedded.libraries)?;
let (arguments, minecraft_arguments) = merge_embedded_arguments(
base_metadata.arguments.clone(),
base_metadata.minecraft_arguments.clone(),
embedded.arguments,
embedded.minecraft_arguments,
)?;
Ok(PistonMetaData {
arguments,
minecraft_arguments,
inherits_from: embedded
.inherits_from
.or(base_metadata.inherits_from.clone()),
asset_index: embedded.asset_index.unwrap_or(base_metadata.asset_index),
assets: embedded.assets.unwrap_or(base_metadata.assets),
compliance_level: embedded
.compliance_level
.unwrap_or(base_metadata.compliance_level),
downloads: embedded.downloads.unwrap_or(base_metadata.downloads),
id: embedded.id.unwrap_or(base_metadata.id),
java_version: embedded.java_version.unwrap_or(base_metadata.java_version),
libraries: merge_libraries(base_metadata.libraries, embedded.libraries),
logging: merge_embedded_logging(base_metadata.logging, embedded.logging),
main_class: embedded.main_class.unwrap_or(base_metadata.main_class),
minimum_launcher_version: embedded
.minimum_launcher_version
.unwrap_or(base_metadata.minimum_launcher_version),
release_type: embedded.release_type.unwrap_or(base_metadata.release_type),
time: embedded.time.unwrap_or(base_metadata.time),
release_time: embedded.release_time.unwrap_or(base_metadata.release_time),
})
}
pub fn merge_libraries_prefer_embedded(
base_libraries: Vec<PistonMetaLibraries>,
embedded_libraries: Vec<PistonMetaLibraries>,
) -> Vec<PistonMetaLibraries> {
let embedded_keys = embedded_libraries
.iter()
.map(library_identity_key)
.collect::<HashSet<String>>();
let mut merged = base_libraries
.into_iter()
.filter(|library| !embedded_keys.contains(&library_identity_key(library)))
.collect::<Vec<PistonMetaLibraries>>();
let mut seen = merged
.iter()
.map(library_identity_key)
.collect::<HashSet<String>>();
for library in embedded_libraries {
let identity = library_identity_key(&library);
if seen.insert(identity) {
merged.push(library);
}
}
merged
}
pub(crate) fn installer_library_artifacts(
library: &PistonMetaLibraries,
) -> impl Iterator<Item = &PistonMetaLibrariesDownloadsArtifact> + '_ {
library.downloads.artifact.iter().chain(
library
.downloads
.classifiers
.iter()
.flat_map(|classifiers| classifiers.values()),
)
}
fn merge_embedded_arguments(
base_arguments: Option<PistonMetaArguments>,
base_minecraft_arguments: Option<String>,
embedded_arguments: Option<PistonMetaArguments>,
embedded_minecraft_arguments: Option<String>,
) -> Result<(Option<PistonMetaArguments>, Option<String>)> {
if let Some(arguments) = embedded_minecraft_arguments {
return Ok((None, Some(arguments)));
}
let base_arguments = match (base_arguments, base_minecraft_arguments) {
(Some(arguments), _) => Some(arguments),
(None, Some(arguments)) => Some(PistonMetaArguments {
game: crate::families::version_json::parse_argument_string(arguments.as_str())?
.into_iter()
.map(elemental_schema::mojang::piston::PistonMetaGenericArgument::Plain)
.collect(),
jvm: Vec::new(),
}),
(None, None) => None,
};
match (base_arguments, embedded_arguments) {
(None, None) => Ok((None, None)),
(Some(arguments), None) | (None, Some(arguments)) => Ok((Some(arguments), None)),
(Some(mut base), Some(embedded)) => {
base.game.extend(embedded.game);
base.jvm.extend(embedded.jvm);
Ok((Some(base), None))
}
}
}
fn merge_embedded_logging(
base_logging: Option<PistonMetaLogging>,
embedded_logging: Option<PistonMetaLogging>,
) -> Option<PistonMetaLogging> {
match (base_logging, embedded_logging) {
(None, None) => None,
(Some(base), None) => Some(base),
(None, Some(embedded)) => Some(embedded),
(Some(base), Some(embedded)) => Some(PistonMetaLogging {
client: embedded.client.or(base.client),
}),
}
}
fn library_identity_key(library: &PistonMetaLibraries) -> String {
let notation = library.name.as_str();
let (coordinates, extension) = notation.split_once('@').unwrap_or((notation, "jar"));
let segments = coordinates.split(':').collect::<Vec<&str>>();
match segments.as_slice() {
[group, artifact, _version] => format!("{group}:{artifact}@{extension}"),
[group, artifact, _version, classifier] => {
format!("{group}:{artifact}:{classifier}@{extension}")
}
_ => notation.to_owned(),
}
}