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;
enum Spec<'a> {
Registry {
crate_name: &'a str,
version: &'a str,
},
Local {
crate_name: &'a str,
version: &'a str,
dir: &'a Path,
},
}
impl Spec<'_> {
fn crate_name(&self) -> &str {
match self {
Spec::Registry { crate_name, .. } | Spec::Local { crate_name, .. } => crate_name,
}
}
fn version(&self) -> &str {
match self {
Spec::Registry { version, .. } | Spec::Local { version, .. } => version,
}
}
fn probe_dependency(&self) -> String {
match self {
Spec::Registry {
crate_name,
version,
} => format!("{crate_name} = \"={version}\""),
Spec::Local {
crate_name, dir, ..
} => {
format!("{crate_name} = {{ path = '{}' }}", dir.display())
}
}
}
fn plugin_source(&self) -> PluginSource<'_> {
match self {
Spec::Registry { version, .. } => PluginSource::Registry { version },
Spec::Local { dir, .. } => PluginSource::Path { dir },
}
}
fn install_source(&self) -> InstallSource {
match self {
Spec::Registry { .. } => InstallSource::BuildHost,
Spec::Local { dir, .. } => InstallSource::Local {
path: dir.to_path_buf(),
},
}
}
fn manifest_source<'a>(&'a self, from_cargo: Option<&'a Path>) -> Option<&'a Path> {
match self {
Spec::Local { dir, .. } => Some(dir),
Spec::Registry { .. } => from_cargo,
}
}
}
pub fn install(
cfg: &KitConfig,
paths: &KitPaths,
crate_name: &str,
version: &str,
) -> KitResult<Installed> {
install_with(
cfg,
paths,
&Spec::Registry {
crate_name,
version,
},
)
}
pub fn install_from_path(
cfg: &KitConfig,
paths: &KitPaths,
crate_name: &str,
version: &str,
dir: &Path,
) -> KitResult<Installed> {
install_with(
cfg,
paths,
&Spec::Local {
crate_name,
version,
dir,
},
)
}
fn install_with(cfg: &KitConfig, paths: &KitPaths, spec: &Spec<'_>) -> KitResult<Installed> {
let crate_name = spec.crate_name();
let cargo = which::which("cargo").map_err(|_| KitError::CargoNotFound)?;
let wrapper_dir = paths.build_dir(crate_name);
reset_wrapper(&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, spec)?;
remove_dir_if_exists(&probe_dir)?;
wrapper::write(
cfg,
&wrapper_dir,
crate_name,
&stem,
spec.plugin_source(),
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, spec.manifest_source(plugin_src))?;
Ok(Installed {
crate_name: crate_name.to_string(),
version: spec.version().to_string(),
dir: plugin_dir,
library: dest_lib,
source: spec.install_source(),
})
}
fn reset_wrapper(dir: &Path) -> KitResult<()> {
if !dir.is_dir() {
return Ok(());
}
for entry in std::fs::read_dir(dir)? {
let entry = entry?;
if entry.file_name() == "target" {
continue;
}
remove_entry(&entry.path())?;
}
Ok(())
}
fn remove_entry(path: &Path) -> KitResult<()> {
if path.is_dir() {
std::fs::remove_dir_all(path)?;
} else {
std::fs::remove_file(path)?;
}
Ok(())
}
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,
spec: &Spec<'_>,
) -> 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{}\n",
spec.probe_dependency()
),
)?;
std::fs::write(dir.join("src").join("lib.rs"), "")?;
let v = cargo_metadata_json(cargo, &dir.join("Cargo.toml"))?;
Ok(declared_contract_dep(
&v,
spec.crate_name(),
&cfg.contract_crate,
))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn reset_wrapper_keeps_the_target_directory() {
let tmp = tempfile::tempdir().unwrap();
let dir = tmp.path().join("myapp-plugin-foo");
std::fs::create_dir_all(dir.join("src")).unwrap();
std::fs::create_dir_all(dir.join("target").join("release")).unwrap();
std::fs::write(dir.join("Cargo.toml"), "# stale\n").unwrap();
std::fs::write(dir.join("src").join("lib.rs"), "// stale\n").unwrap();
std::fs::write(dir.join("target").join("release").join("cached"), "x").unwrap();
reset_wrapper(&dir).unwrap();
assert!(
!dir.join("Cargo.toml").exists() && !dir.join("src").exists(),
"a stale generated file must not survive into the next build"
);
assert!(
dir.join("target").join("release").join("cached").is_file(),
"cargo's cache is what makes an update cheap"
);
}
#[test]
fn reset_wrapper_accepts_a_missing_directory() {
let tmp = tempfile::tempdir().unwrap();
reset_wrapper(&tmp.path().join("never-built")).unwrap();
}
}