implement BridgeStan download and module compilation on Rust

rust/Cargo.toml

@@ -11,6 +11,10 @@ homepage = "https://roualdes.github.io/bridgestan/latest/"
 [dependencies]
 libloading = "0.8.0"
 thiserror = "1.0.40"
+ureq = "2.7"
+tar = "0.4"
+flate2 = "1.0"
+dirs = "5.0"
 
 [build-dependencies]
 bindgen = "0.69.1"

rust/examples/example.rs

@@ -1,4 +1,4 @@
-use bridgestan::{open_library, BridgeStanError, Model};
+use bridgestan::{compile_model, open_library, BridgeStanError, Model};
 use std::ffi::CString;
 use std::path::Path;
 
@@ -8,7 +8,10 @@ fn main() {
     let path = Path::new(env!["CARGO_MANIFEST_DIR"])
         .parent()
         .unwrap()
-        .join("test_models/simple/simple_model.so");
+        .join("test_models/simple/simple.stan");
+
+    let path = compile_model(path, None).expect("Could not compile Stan model.");
+    println!("Compiled model: {:?}", path);
 
     let lib = open_library(path).expect("Could not load compiled Stan model.");
 

rust/src/bs_safe.rs

@@ -1,3 +1,4 @@
+use crate::download_compile::VERSION;
 use crate::ffi;
 use std::borrow::Borrow;
 use std::collections::hash_map::DefaultHasher;
@@ -101,9 +102,15 @@ pub enum BridgeStanError {
     /// Setting a print-callback failed.
     #[error("Failed to set a print-callback: {0}")]
     SetCallbackFailed(String),
+    /// Setting a compile Stan model failed.
+    #[error("Failed to compile Stan model: {0}")]
+    ModelCompilingFailed(String),
+    /// Setting a download BridgeStan failed.
+    #[error("Failed to download BridgeStan {VERSION} from github.com: {0}")]
+    DownloadFailed(String),
 }
 
-type Result<T> = std::result::Result<T, BridgeStanError>;
+pub(crate) type Result<T> = std::result::Result<T, BridgeStanError>;
 
 /// Open a compiled Stan library.
 ///

rust/src/download_compile.rs

@@ -0,0 +1,108 @@
+use crate::bs_safe::{BridgeStanError, Result};
+use flate2::read::GzDecoder;
+use std::{env::temp_dir, fs, path::PathBuf};
+use tar::Archive;
+
+pub(crate) const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+/// Download and unzip the BridgeStan source distribution for this version
+/// to ~/.bridgestan/bridgestan-version
+pub fn get_bridgestan_src() -> Result<PathBuf> {
+    let homedir = dirs::home_dir().unwrap_or(temp_dir());
+
+    let bs_path_download_temp = homedir.join(".bridgestan_tmp_dir");
+    let bs_path_download = homedir.join(".bridgestan");
+
+    let bs_path_download_temp_join_version =
+        bs_path_download_temp.join(format!("bridgestan-{VERSION}"));
+    let bs_path_download_join_version = bs_path_download.join(format!("bridgestan-{VERSION}"));
+
+    if !bs_path_download_join_version.exists() {
+        println!("Downloading BridgeStan");
+
+        fs::remove_dir_all(&bs_path_download_temp).unwrap_or_default();
+        fs::create_dir(&bs_path_download_temp).unwrap_or_default();
+        fs::create_dir(&bs_path_download).unwrap_or_default();
+
+        let url = "https://github.com/roualdes/bridgestan/releases/download/".to_owned()
+            + format!("v{VERSION}/bridgestan-{VERSION}.tar.gz").as_str();
+
+        let response = ureq::get(url.as_str())
+            .call()
+            .map_err(|e| BridgeStanError::DownloadFailed(e.to_string()))?;
+        let len = response
+            .header("Content-Length")
+            .and_then(|s| s.parse::<usize>().ok())
+            .unwrap_or(50_000_000);
+
+        let mut bytes: Vec<u8> = Vec::with_capacity(len);
+        response
+            .into_reader()
+            .read_to_end(&mut bytes)
+            .map_err(|e| BridgeStanError::DownloadFailed(e.to_string()))?;
+
+        let tar = GzDecoder::new(bytes.as_slice());
+        let mut archive = Archive::new(tar);
+        archive
+            .unpack(&bs_path_download_temp)
+            .map_err(|e| BridgeStanError::DownloadFailed(e.to_string()))?;
+
+        fs::rename(
+            bs_path_download_temp_join_version,
+            &bs_path_download_join_version,
+        )
+        .map_err(|e| BridgeStanError::DownloadFailed(e.to_string()))?;
+
+        fs::remove_dir(bs_path_download_temp).unwrap_or_default();
+
+        println!("Finished downloading BridgeStan");
+    }
+
+    Ok(bs_path_download_join_version)
+}
+
+/// Compile a Stan Model given a stan_file and the path to BridgeStan
+/// if None, then calls get_bridgestan_src() to download BridgeStan
+pub fn compile_model(stan_file: PathBuf, bs_path: Option<PathBuf>) -> Result<PathBuf> {
+    let bs_path = match bs_path {
+        Some(path) => path,
+        None => get_bridgestan_src()?,
+    };
+
+    let stan_file = fs::canonicalize(stan_file)
+        .map_err(|e| BridgeStanError::ModelCompilingFailed(e.to_string()))?;
+
+    if stan_file.extension().unwrap_or_default() != "stan" {
+        return Err(BridgeStanError::ModelCompilingFailed(
+            "File must be a .stan file".to_owned(),
+        ));
+    }
+
+    // add _model suffix and change extension to .so
+    let output = stan_file.with_extension("");
+    let output = output.with_file_name(format!(
+        "{}_model",
+        output.file_name().unwrap_or_default().to_string_lossy()
+    ));
+    let output = output.with_extension("so");
+
+    let cmd = vec![output.to_str().unwrap_or_default().to_owned()];
+
+    println!("Compiling model");
+    let proc = std::process::Command::new("make")
+        .args(cmd)
+        .current_dir(bs_path)
+        .env("STAN_THREADS", "true")
+        .output()
+        .map_err(|e| BridgeStanError::ModelCompilingFailed(e.to_string()))?;
+    println!("Finished compiling model");
+
+    if !proc.status.success() {
+        return Err(BridgeStanError::ModelCompilingFailed(format!(
+            "{} {}",
+            String::from_utf8_lossy(proc.stdout.as_slice()).into_owned(),
+            String::from_utf8_lossy(proc.stderr.as_slice()).into_owned(),
+        )));
+    }
+    Ok(output)
+}

rust/src/lib.rs

@@ -1,6 +1,8 @@
 #![doc = include_str!("../README.md")]
 
 mod bs_safe;
+mod download_compile;
 pub(crate) mod ffi;
 
 pub use bs_safe::{open_library, BridgeStanError, Model, Rng, StanLibrary};
+pub use download_compile::{compile_model, get_bridgestan_src};

rust/tests/model.rs

@@ -25,17 +25,17 @@ fn throw_data() {
 fn bad_arglength() {
     let (lib, data) = get_model("stdnormal");
     let model = Model::new(&lib, data, 42).unwrap();
-    let theta = vec![];
-    let mut grad = vec![];
+    let theta = [];
+    let mut grad = [];
     let _ = model.log_density_gradient(&theta[..], true, true, &mut grad[..]);
 }
 
 #[test]
 fn logp_gradient() {
     let (lib, data) = get_model("stdnormal");
     let model = Model::new(&lib, data, 42).unwrap();
-    let theta = vec![1f64];
-    let mut grad = vec![0f64];
+    let theta = [1f64];
+    let mut grad = [0f64];
     let logp = model
         .log_density_gradient(&theta[..], false, true, &mut grad[..])
         .unwrap();
@@ -47,8 +47,8 @@ fn logp_gradient() {
 fn logp_hessian() {
     let (lib, data) = get_model("stdnormal");
     let model = Model::new(&lib, data, 42).unwrap();
-    let theta = vec![1f64];
-    let mut grad = vec![0f64];
+    let theta = [1f64];
+    let mut grad = [0f64];
     let mut hessian = vec![0f64];
     let logp = model
         .log_density_hessian(&theta[..], false, true, &mut grad[..], &mut hessian)