use std::path::{Path, PathBuf};
use std::process::Command;
use crate::cache::InstallSource;
use crate::config::{KitConfig, KitPaths};
use crate::error::{KitError, KitResult};
use crate::install::{remove_dir_if_exists, Installed};
use crate::loader;
use crate::wrapper::{self, cargo_metadata_json, declared_contract_dep, ContractDep, PluginSource};
mod metadata;
use metadata::cargo_metadata;
pub fn install(
cfg: &KitConfig,
paths: &KitPaths,
crate_name: &str,
version: &str,
) -> KitResult<Installed> {
let cargo = which::which("cargo").map_err(|_| KitError::CargoNotFound)?;
let wrapper_dir = paths.build_dir(crate_name);
remove_dir_if_exists(&wrapper_dir)?;
std::fs::create_dir_all(wrapper_dir.join("src"))?;
let stem = cfg.lib_stem(crate_name);
let probe_dir = paths.build_dir(&format!("{crate_name}-probe"));
let contract = probe_contract_requirement(cfg, &cargo, &probe_dir, crate_name, version)?;
remove_dir_if_exists(&probe_dir)?;
wrapper::write(
cfg,
&wrapper_dir,
crate_name,
&stem,
PluginSource::Registry { version },
contract.as_ref(),
)?;
let manifest_path = wrapper_dir.join("Cargo.toml");
let metadata = cargo_metadata(&cargo, &manifest_path)?;
let target_dir = metadata.target_directory.clone();
let plugin_src = metadata.plugin_source_dir(crate_name);
let status = Command::new(&cargo)
.arg("build")
.arg("--release")
.arg("--manifest-path")
.arg(&manifest_path)
.status()
.map_err(KitError::Io)?;
if !status.success() {
return Err(KitError::BuildFailed {
code: status.code(),
});
}
let release_dir = target_dir.join("release");
let built =
loader::find_library(&release_dir, &stem).map_err(|_| KitError::BuildArtifactMissing {
stem: stem.clone(),
dir: release_dir.display().to_string(),
})?;
let plugin_dir = paths.plugin_dir(crate_name);
remove_dir_if_exists(&plugin_dir)?;
std::fs::create_dir_all(&plugin_dir)?;
let dest_lib = plugin_dir.join(
built
.file_name()
.expect("an artifact always has a file name"),
);
std::fs::copy(&built, &dest_lib)?;
copy_manifest(cfg, &plugin_dir, plugin_src)?;
Ok(Installed {
crate_name: crate_name.to_string(),
version: version.to_string(),
dir: plugin_dir,
library: dest_lib,
source: InstallSource::BuildHost,
})
}
fn copy_manifest(cfg: &KitConfig, plugin_dir: &Path, plugin_src: Option<&Path>) -> KitResult<()> {
let Some(src_dir) = plugin_src else {
return Err(KitError::ManifestMissingField {
field: cfg.manifest_name.clone(),
path: PathBuf::from("<plugin source dir not located>"),
});
};
let src = src_dir.join(&cfg.manifest_name);
if !src.is_file() {
return Err(KitError::ManifestMissingField {
field: cfg.manifest_name.clone(),
path: src,
});
}
std::fs::copy(&src, plugin_dir.join(&cfg.manifest_name))?;
Ok(())
}
fn probe_contract_requirement(
cfg: &KitConfig,
cargo: &Path,
dir: &Path,
crate_name: &str,
version: &str,
) -> KitResult<Option<ContractDep>> {
std::fs::create_dir_all(dir.join("src"))?;
std::fs::write(
dir.join("Cargo.toml"),
format!(
"[package]\nname = \"probe\"\nversion = \"0.0.0\"\nedition = \"2021\"\npublish = false\n\n\
[workspace]\n\n[dependencies]\n{crate_name} = \"={version}\"\n"
),
)?;
std::fs::write(dir.join("src").join("lib.rs"), "")?;
let v = cargo_metadata_json(cargo, &dir.join("Cargo.toml"))?;
Ok(declared_contract_dep(&v, crate_name, &cfg.contract_crate))
}