363 lines
14 KiB
Rust
363 lines
14 KiB
Rust
|
use anyhow::{bail, Context};
|
||
|
|
use serde::Deserialize;
|
||
|
|
use std::collections::HashMap;
|
||
|
|
use std::fs;
|
||
|
|
use std::path::Path;
|
||
|
|
use std::process::Command;
|
||
|
|
|
||
|
|
mod symbols;
|
||
|
|
|
||
|
|
/// Re-export for the main function.
|
||
|
|
pub use anyhow::Result;
|
||
|
|
|
||
|
|
const USAGE_STRING: &str = "Usage:
|
||
|
|
cargo xtask bundle <package> [--release] [--target <triple>]
|
||
|
|
cargo xtask bundle -p <package1> -p <package2> ... [--release] [--target <triple>]";
|
||
|
|
|
||
|
|
/// The base birectory for the bundler's output.
|
||
|
|
const BUNDLE_HOME: &str = "target/bundled";
|
||
|
|
|
||
|
|
/// Any additional configuration that might be useful for creating plugin bundles, stored as
|
||
|
|
/// `bundler.toml` alongside the workspace's main `Cargo.toml` file.
|
||
|
|
type BundlerConfig = HashMap<String, PackageConfig>;
|
||
|
|
|
||
|
|
#[derive(Debug, Clone, Deserialize)]
|
||
|
|
struct PackageConfig {
|
||
|
|
name: Option<String>,
|
||
|
|
}
|
||
|
|
|
||
|
|
/// The target we're generating a plugin for. This can be either the native target or a cross
|
||
|
|
/// compilation target, so to reduce redundancy when determining the correct bundle paths we'll use
|
||
|
|
/// an enum for this.
|
||
|
|
///
|
||
|
|
/// TODO: Right now we don't consider ARM targets at all
|
||
|
|
#[allow(dead_code)]
|
||
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
|
|
pub enum CompilationTarget {
|
||
|
|
Linux64,
|
||
|
|
Linux32,
|
||
|
|
Mac64,
|
||
|
|
Windows64,
|
||
|
|
Windows32,
|
||
|
|
}
|
||
|
|
|
||
|
|
/// The main xtask entry point function. See the readme for instructions on how to use this.
|
||
|
|
pub fn main() -> Result<()> {
|
||
|
|
chdir_workspace_root()?;
|
||
|
|
|
||
|
|
let mut args = std::env::args().skip(1);
|
||
|
|
let command = args
|
||
|
|
.next()
|
||
|
|
.context(format!("Missing command name\n\n{USAGE_STRING}"))?;
|
||
|
|
match command.as_str() {
|
||
|
|
"bundle" => {
|
||
|
|
// For convenience's sake we'll allow building multiple packages with -p just like carg
|
||
|
|
// obuild, but you can also build a single package without specifying -p
|
||
|
|
let mut args = args.peekable();
|
||
|
|
let mut packages = Vec::new();
|
||
|
|
if args.peek().map(|s| s.as_str()) == Some("-p") {
|
||
|
|
while args.peek().map(|s| s.as_str()) == Some("-p") {
|
||
|
|
packages.push(
|
||
|
|
args.nth(1)
|
||
|
|
.context(format!("Missing package name after -p\n\n{USAGE_STRING}"))?,
|
||
|
|
);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
packages.push(
|
||
|
|
args.next()
|
||
|
|
.context(format!("Missing package name\n\n{USAGE_STRING}"))?,
|
||
|
|
);
|
||
|
|
};
|
||
|
|
let other_args: Vec<_> = args.collect();
|
||
|
|
|
||
|
|
bundle(&packages[0], &other_args)?;
|
||
|
|
for package in packages.into_iter().skip(1) {
|
||
|
|
eprintln!();
|
||
|
|
bundle(&package, &other_args)?;
|
||
|
|
}
|
||
|
|
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
// This is only meant to be used by the CI, since using awk for this can be a bit spotty on
|
||
|
|
// macOS
|
||
|
|
"known-packages" => list_known_packages(),
|
||
|
|
_ => bail!("Unknown command '{command}'\n\n{USAGE_STRING}"),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Change the current directory into the Cargo workspace's root.
|
||
|
|
pub fn chdir_workspace_root() -> Result<()> {
|
||
|
|
let project_root = Path::new(env!("CARGO_MANIFEST_DIR"))
|
||
|
|
.parent()
|
||
|
|
.context("Could not find project root")?;
|
||
|
|
std::env::set_current_dir(project_root).context("Could not change to project root directory")
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Bundle a package using the provided `cargo build` arguments. Options from the `bundler.toml`
|
||
|
|
/// file in the workspace's root are respected (see
|
||
|
|
/// <https://github.com/robbert-vdh/nih-plug/blob/master/bundler.toml>). This requires the current
|
||
|
|
/// working directory to have been set to the workspace's root using [chdir_workspace_root].
|
||
|
|
pub fn bundle(package: &str, args: &[String]) -> Result<()> {
|
||
|
|
let bundle_name = match load_bundler_config()?.and_then(|c| c.get(package).cloned()) {
|
||
|
|
Some(PackageConfig { name: Some(name) }) => name,
|
||
|
|
_ => package.to_string(),
|
||
|
|
};
|
||
|
|
|
||
|
|
let mut is_release_build = false;
|
||
|
|
let mut cross_compile_target: Option<String> = None;
|
||
|
|
for arg_idx in (0..args.len()).rev() {
|
||
|
|
let arg = &args[arg_idx];
|
||
|
|
match arg.as_str() {
|
||
|
|
"--release" => is_release_build = true,
|
||
|
|
"--target" => {
|
||
|
|
// When cross compiling we should generate the correct bundle type
|
||
|
|
cross_compile_target = Some(
|
||
|
|
args.get(arg_idx + 1)
|
||
|
|
.context("Missing cross-compile target")?
|
||
|
|
.to_owned(),
|
||
|
|
);
|
||
|
|
}
|
||
|
|
arg if arg.starts_with("--target=") => {
|
||
|
|
cross_compile_target = Some(
|
||
|
|
arg.strip_prefix("--target=")
|
||
|
|
.context("Missing cross-compile target")?
|
||
|
|
.to_owned(),
|
||
|
|
);
|
||
|
|
}
|
||
|
|
_ => (),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
let status = Command::new("cargo")
|
||
|
|
.arg("build")
|
||
|
|
.arg("-p")
|
||
|
|
.arg(package)
|
||
|
|
.args(args)
|
||
|
|
.status()
|
||
|
|
.context(format!("Could not call cargo to build {package}"))?;
|
||
|
|
if !status.success() {
|
||
|
|
bail!("Could not build {}", package);
|
||
|
|
}
|
||
|
|
|
||
|
|
let compilation_target = compilation_target(cross_compile_target.as_deref())?;
|
||
|
|
let lib_path = Path::new(target_base(cross_compile_target.as_deref())?)
|
||
|
|
.join(if is_release_build { "release" } else { "debug" })
|
||
|
|
.join(library_basename(package, compilation_target));
|
||
|
|
if !lib_path.exists() {
|
||
|
|
bail!("Could not find built library at '{}'", lib_path.display());
|
||
|
|
}
|
||
|
|
|
||
|
|
// We'll detect the pugin formats supported by the plugin binary and create bundled accordingly
|
||
|
|
// TODO: Support VST2 at some point
|
||
|
|
let bundle_clap = symbols::exported(&lib_path, "clap_entry")
|
||
|
|
.with_context(|| format!("Could not parse '{}'", lib_path.display()))?;
|
||
|
|
let bundle_vst3 = symbols::exported(&lib_path, "GetPluginFactory")
|
||
|
|
.with_context(|| format!("Could not parse '{}'", lib_path.display()))?;
|
||
|
|
let bundled_plugin = bundle_clap || bundle_vst3;
|
||
|
|
|
||
|
|
eprintln!();
|
||
|
|
if bundle_clap {
|
||
|
|
let clap_bundle_library_name = clap_bundle_library_name(&bundle_name, compilation_target);
|
||
|
|
let clap_lib_path = Path::new(BUNDLE_HOME).join(&clap_bundle_library_name);
|
||
|
|
|
||
|
|
fs::create_dir_all(clap_lib_path.parent().unwrap())
|
||
|
|
.context("Could not create CLAP bundle directory")?;
|
||
|
|
reflink::reflink_or_copy(&lib_path, &clap_lib_path)
|
||
|
|
.context("Could not copy library to CLAP bundle")?;
|
||
|
|
|
||
|
|
// In contrast to VST3, CLAP only uses bundles on macOS, so we'll just take the first
|
||
|
|
// component of the library name instead
|
||
|
|
let clap_bundle_home = Path::new(BUNDLE_HOME).join(
|
||
|
|
Path::new(&clap_bundle_library_name)
|
||
|
|
.components()
|
||
|
|
.next()
|
||
|
|
.expect("Malformed CLAP library path"),
|
||
|
|
);
|
||
|
|
maybe_create_macos_bundle_metadata(package, &clap_bundle_home, compilation_target)?;
|
||
|
|
|
||
|
|
eprintln!("Created a CLAP bundle at '{}'", clap_bundle_home.display());
|
||
|
|
}
|
||
|
|
if bundle_vst3 {
|
||
|
|
let vst3_lib_path =
|
||
|
|
Path::new(BUNDLE_HOME).join(vst3_bundle_library_name(&bundle_name, compilation_target));
|
||
|
|
|
||
|
|
fs::create_dir_all(vst3_lib_path.parent().unwrap())
|
||
|
|
.context("Could not create VST3 bundle directory")?;
|
||
|
|
reflink::reflink_or_copy(&lib_path, &vst3_lib_path)
|
||
|
|
.context("Could not copy library to VST3 bundle")?;
|
||
|
|
|
||
|
|
let vst3_bundle_home = vst3_lib_path
|
||
|
|
.parent()
|
||
|
|
.unwrap()
|
||
|
|
.parent()
|
||
|
|
.unwrap()
|
||
|
|
.parent()
|
||
|
|
.unwrap();
|
||
|
|
maybe_create_macos_bundle_metadata(package, vst3_bundle_home, compilation_target)?;
|
||
|
|
|
||
|
|
eprintln!("Created a VST3 bundle at '{}'", vst3_bundle_home.display());
|
||
|
|
}
|
||
|
|
if !bundled_plugin {
|
||
|
|
eprintln!("Not creating any plugin bundles because the package does not export any plugins")
|
||
|
|
}
|
||
|
|
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
|
||
|
|
/// This lists the packages configured in `bundler.toml`. This is only used as part of the CI when
|
||
|
|
/// bundling plugins.
|
||
|
|
pub fn list_known_packages() -> Result<()> {
|
||
|
|
if let Some(config) = load_bundler_config()? {
|
||
|
|
for package in config.keys() {
|
||
|
|
println!("{package}");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Load the `bundler.toml` file, if it exists. If it does exist but it cannot be parsed, then this
|
||
|
|
/// will return an error.
|
||
|
|
fn load_bundler_config() -> Result<Option<BundlerConfig>> {
|
||
|
|
// We're already in the project root
|
||
|
|
let bundler_config_path = Path::new("bundler.toml");
|
||
|
|
if !bundler_config_path.exists() {
|
||
|
|
return Ok(None);
|
||
|
|
}
|
||
|
|
|
||
|
|
let result = toml::from_str(
|
||
|
|
&fs::read_to_string(&bundler_config_path)
|
||
|
|
.with_context(|| format!("Could not read '{}'", bundler_config_path.display()))?,
|
||
|
|
)
|
||
|
|
.with_context(|| format!("Could not parse '{}'", bundler_config_path.display()))?;
|
||
|
|
|
||
|
|
Ok(Some(result))
|
||
|
|
}
|
||
|
|
|
||
|
|
/// The target we're compiling for. This is used to determine the paths and options for creating
|
||
|
|
/// plugin bundles.
|
||
|
|
fn compilation_target(cross_compile_target: Option<&str>) -> Result<CompilationTarget> {
|
||
|
|
match cross_compile_target {
|
||
|
|
Some("x86_64-unknown-linux-gnu") => Ok(CompilationTarget::Linux64),
|
||
|
|
Some("x86_64-apple-darwin") => Ok(CompilationTarget::Mac64),
|
||
|
|
Some("x86_64-pc-windows-gnu") => Ok(CompilationTarget::Windows64),
|
||
|
|
Some(target) => bail!("Unhandled cross-compilation target: {}", target),
|
||
|
|
None => {
|
||
|
|
#[cfg(all(target_os = "linux", target_arch = "x86_64"))]
|
||
|
|
return Ok(CompilationTarget::Linux64);
|
||
|
|
#[cfg(all(target_os = "linux", target_arch = "x86"))]
|
||
|
|
return Ok(CompilationTarget::Linux32);
|
||
|
|
#[cfg(all(target_os = "macos", target_arch = "x86_64"))]
|
||
|
|
return Ok(CompilationTarget::Mac64);
|
||
|
|
#[cfg(all(target_os = "windows", target_arch = "x86_64"))]
|
||
|
|
return Ok(CompilationTarget::Windows64);
|
||
|
|
#[cfg(all(target_os = "windows", target_arch = "x86"))]
|
||
|
|
return Ok(CompilationTarget::Windows32);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// The base directory for the compiled binaries. This does not use [CompilationTarget] as we need
|
||
|
|
/// to be able to differentiate between native and cross-compilation.
|
||
|
|
fn target_base(cross_compile_target: Option<&str>) -> Result<&'static str> {
|
||
|
|
match cross_compile_target {
|
||
|
|
Some("x86_64-unknown-linux-gnu") => Ok("target/x86_64-unknown-linux-gnu"),
|
||
|
|
Some("x86_64-pc-windows-gnu") => Ok("target/x86_64-pc-windows-gnu"),
|
||
|
|
Some("x86_64-apple-darwin") => Ok("target/x86_64-apple-darwin"),
|
||
|
|
Some(target) => bail!("Unhandled cross-compilation target: {}", target),
|
||
|
|
None => Ok("target"),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// The file name of the compiled library for a `cdylib` crate.
|
||
|
|
fn library_basename(package: &str, target: CompilationTarget) -> String {
|
||
|
|
match target {
|
||
|
|
CompilationTarget::Linux64 | CompilationTarget::Linux32 => format!("lib{package}.so"),
|
||
|
|
CompilationTarget::Mac64 => format!("lib{package}.dylib"),
|
||
|
|
CompilationTarget::Windows64 | CompilationTarget::Windows32 => format!("{package}.dll"),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// The filename of the CLAP plugin for Linux and Windows, or the full path to the library file
|
||
|
|
/// inside of a CLAP bundle on macOS
|
||
|
|
fn clap_bundle_library_name(package: &str, target: CompilationTarget) -> String {
|
||
|
|
match target {
|
||
|
|
CompilationTarget::Linux64
|
||
|
|
| CompilationTarget::Linux32
|
||
|
|
| CompilationTarget::Windows64
|
||
|
|
| CompilationTarget::Windows32 => format!("{package}.clap"),
|
||
|
|
CompilationTarget::Mac64 => format!("{package}.clap/Contents/MacOS/{package}"),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// The full path to the library file inside of a VST3 bundle, including the leading `.vst3`
|
||
|
|
/// directory.
|
||
|
|
///
|
||
|
|
/// See <https://developer.steinberg.help/display/VST/Plug-in+Format+Structure>.
|
||
|
|
fn vst3_bundle_library_name(package: &str, target: CompilationTarget) -> String {
|
||
|
|
match target {
|
||
|
|
CompilationTarget::Linux64 => format!("{package}.vst3/Contents/x86_64-linux/{package}.so"),
|
||
|
|
CompilationTarget::Linux32 => format!("{package}.vst3/Contents/i386-linux/{package}.so"),
|
||
|
|
CompilationTarget::Mac64 => format!("{package}.vst3/Contents/MacOS/{package}"),
|
||
|
|
CompilationTarget::Windows64 => {
|
||
|
|
format!("{package}.vst3/Contents/x86_64-win/{package}.vst3")
|
||
|
|
}
|
||
|
|
CompilationTarget::Windows32 => format!("{package}.vst3/Contents/x86-win/{package}.vst3"),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// If compiling for macOS, create all of the bundl-y stuff Steinberg and Apple require you to have.
|
||
|
|
///
|
||
|
|
/// This still requires you to move the dylib file to `{bundle_home}/Contents/macOS/{package}`
|
||
|
|
/// yourself first.
|
||
|
|
pub fn maybe_create_macos_bundle_metadata(
|
||
|
|
package: &str,
|
||
|
|
bundle_home: &Path,
|
||
|
|
target: CompilationTarget,
|
||
|
|
) -> Result<()> {
|
||
|
|
if target != CompilationTarget::Mac64 {
|
||
|
|
return Ok(());
|
||
|
|
}
|
||
|
|
|
||
|
|
// TODO: May want to add bundler.toml fields for the identifier, version and signature at some
|
||
|
|
// point.
|
||
|
|
fs::write(bundle_home.join("Contents").join("PkgInfo"), "BNDL????")
|
||
|
|
.context("Could not create PkgInfo file")?;
|
||
|
|
fs::write(
|
||
|
|
bundle_home.join("Contents").join("Info.plist"),
|
||
|
|
format!(r#"<?xml version="1.0" encoding="UTF-8"?>
|
||
|
|
|
||
|
|
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
|
||
|
|
<plist>
|
||
|
|
<dict>
|
||
|
|
<key>CFBundleExecutable</key>
|
||
|
|
<string>{package}</string>
|
||
|
|
<key>CFBundleIconFile</key>
|
||
|
|
<string></string>
|
||
|
|
<key>CFBundleIdentifier</key>
|
||
|
|
<string>com.nih-plug.{package}</string>
|
||
|
|
<key>CFBundleName</key>
|
||
|
|
<string>{package}</string>
|
||
|
|
<key>CFBundleDisplayName</key>
|
||
|
|
<string>{package}</string>
|
||
|
|
<key>CFBundlePackageType</key>
|
||
|
|
<string>BNDL</string>
|
||
|
|
<key>CFBundleSignature</key>
|
||
|
|
<string>????</string>
|
||
|
|
<key>CFBundleShortVersionString</key>
|
||
|
|
<string>1.0.0</string>
|
||
|
|
<key>CFBundleVersion</key>
|
||
|
|
<string>1.0.0</string>
|
||
|
|
<key>NSHumanReadableCopyright</key>
|
||
|
|
<string></string>
|
||
|
|
<key>NSHighResolutionCapable</key>
|
||
|
|
<true/>
|
||
|
|
</dict>
|
||
|
|
</plist>
|
||
|
|
"#),
|
||
|
|
)
|
||
|
|
.context("Could not create Info.plist file")?;
|
||
|
|
|
||
|
|
Ok(())
|
||
|
|
}
|