Merge branch 'master' of https://github.com/rustwasm/wasm-pack
daubaris
6 years ago
commit
e918fddb71
@ -1,23 +0,0 @@ |
||||
[package] |
||||
name = "binary-install" |
||||
description = "install a binary from a path to a global cache" |
||||
authors = ["The wasm-pack team"] |
||||
repository = "https://github.com/rustwasm/wasm-pack/tree/master/binary-install" |
||||
license = "MIT/Apache-2.0" |
||||
version = "0.0.2" |
||||
documentation = "https://docs.rs/binary-install" |
||||
readme = "./README.md" |
||||
|
||||
[dependencies] |
||||
curl = "0.4.13" |
||||
dirs = "1.0.4" |
||||
failure = "0.1.2" |
||||
flate2 = "1.0.2" |
||||
hex = "0.3" |
||||
is_executable = "0.1.2" |
||||
siphasher = "0.2.3" |
||||
tar = "0.4.16" |
||||
zip = "0.5.0" |
||||
|
||||
[dev-dependencies] |
||||
tempfile = "3.0.5" |
||||
@ -1,2 +0,0 @@ |
||||
# `binary-install` |
||||
> install a binary from a path to a global cache |
||||
@ -1,346 +0,0 @@ |
||||
//! Utilities for finding and installing binaries that we depend on.
|
||||
|
||||
extern crate curl; |
||||
#[macro_use] |
||||
extern crate failure; |
||||
extern crate dirs; |
||||
extern crate flate2; |
||||
extern crate hex; |
||||
extern crate is_executable; |
||||
extern crate siphasher; |
||||
extern crate tar; |
||||
extern crate zip; |
||||
|
||||
use failure::{Error, ResultExt}; |
||||
use siphasher::sip::SipHasher13; |
||||
use std::collections::HashSet; |
||||
use std::env; |
||||
use std::ffi; |
||||
use std::fs; |
||||
use std::hash::{Hash, Hasher}; |
||||
use std::io; |
||||
use std::path::{Path, PathBuf}; |
||||
|
||||
/// Global cache for wasm-pack, currently containing binaries downloaded from
|
||||
/// urls like wasm-bindgen and such.
|
||||
#[derive(Debug)] |
||||
pub struct Cache { |
||||
destination: PathBuf, |
||||
} |
||||
|
||||
/// Representation of a downloaded tarball/zip
|
||||
#[derive(Debug)] |
||||
pub struct Download { |
||||
root: PathBuf, |
||||
} |
||||
|
||||
impl Cache { |
||||
/// Returns the global cache directory, as inferred from env vars and such.
|
||||
///
|
||||
/// This function may return an error if a cache directory cannot be
|
||||
/// determined.
|
||||
pub fn new(name: &str) -> Result<Cache, Error> { |
||||
let cache_name = format!(".{}", name); |
||||
let destination = dirs::cache_dir() |
||||
.map(|p| p.join(&cache_name)) |
||||
.or_else(|| { |
||||
let home = dirs::home_dir()?; |
||||
Some(home.join(&cache_name)) |
||||
}) |
||||
.ok_or_else(|| format_err!("couldn't find your home directory, is $HOME not set?"))?; |
||||
Ok(Cache::at(&destination)) |
||||
} |
||||
|
||||
/// Creates a new cache specifically at a particular directory, useful in
|
||||
/// testing and such.
|
||||
pub fn at(path: &Path) -> Cache { |
||||
Cache { |
||||
destination: path.to_path_buf(), |
||||
} |
||||
} |
||||
|
||||
/// Joins a path to the destination of this cache, returning the result
|
||||
pub fn join(&self, path: &Path) -> PathBuf { |
||||
self.destination.join(path) |
||||
} |
||||
|
||||
/// Downloads a tarball or zip file from the specified url, extracting it
|
||||
/// locally and returning the directory that the contents were extracted
|
||||
/// into.
|
||||
///
|
||||
/// Note that this function requries that the contents of `url` never change
|
||||
/// as the contents of the url are globally cached on the system and never
|
||||
/// invalidated.
|
||||
///
|
||||
/// The `name` is a human-readable name used to go into the folder name of
|
||||
/// the destination, and `binaries` is a list of binaries expected to be at
|
||||
/// the url. If the URL's extraction doesn't contain all the binaries this
|
||||
/// function will return an error.
|
||||
pub fn download( |
||||
&self, |
||||
install_permitted: bool, |
||||
name: &str, |
||||
binaries: &[&str], |
||||
url: &str, |
||||
) -> Result<Option<Download>, Error> { |
||||
let dirname = hashed_dirname(url, name); |
||||
|
||||
let destination = self.destination.join(&dirname); |
||||
|
||||
if destination.exists() { |
||||
return Ok(Some(Download { root: destination })); |
||||
} |
||||
|
||||
if !install_permitted { |
||||
return Ok(None); |
||||
} |
||||
|
||||
let data = curl(&url).with_context(|_| format!("failed to download from {}", url))?; |
||||
|
||||
// Extract everything in a temporary directory in case we're ctrl-c'd.
|
||||
// Don't want to leave around corrupted data!
|
||||
let temp = self.destination.join(&format!(".{}", dirname)); |
||||
drop(fs::remove_dir_all(&temp)); |
||||
fs::create_dir_all(&temp)?; |
||||
|
||||
if url.ends_with(".tar.gz") { |
||||
self.extract_tarball(&data, &temp, binaries) |
||||
.with_context(|_| format!("failed to extract tarball from {}", url))?; |
||||
} else if url.ends_with(".zip") { |
||||
self.extract_zip(&data, &temp, binaries) |
||||
.with_context(|_| format!("failed to extract zip from {}", url))?; |
||||
} else { |
||||
// panic instead of runtime error as it's a static violation to
|
||||
// download a different kind of url, all urls should be encoded into
|
||||
// the binary anyway
|
||||
panic!("don't know how to extract {}", url) |
||||
} |
||||
|
||||
// Now that everything is ready move this over to our destination and
|
||||
// we're good to go.
|
||||
fs::rename(&temp, &destination)?; |
||||
Ok(Some(Download { root: destination })) |
||||
} |
||||
|
||||
fn extract_tarball(&self, tarball: &[u8], dst: &Path, binaries: &[&str]) -> Result<(), Error> { |
||||
let mut binaries: HashSet<_> = binaries.into_iter().map(ffi::OsStr::new).collect(); |
||||
let mut archive = tar::Archive::new(flate2::read::GzDecoder::new(tarball)); |
||||
|
||||
for entry in archive.entries()? { |
||||
let mut entry = entry?; |
||||
|
||||
let dest = match entry.path()?.file_stem() { |
||||
Some(f) if binaries.contains(f) => { |
||||
binaries.remove(f); |
||||
dst.join(entry.path()?.file_name().unwrap()) |
||||
} |
||||
_ => continue, |
||||
}; |
||||
|
||||
entry.unpack(dest)?; |
||||
} |
||||
|
||||
if !binaries.is_empty() { |
||||
bail!( |
||||
"the tarball was missing expected executables: {}", |
||||
binaries |
||||
.into_iter() |
||||
.map(|s| s.to_string_lossy()) |
||||
.collect::<Vec<_>>() |
||||
.join(", "), |
||||
) |
||||
} |
||||
|
||||
Ok(()) |
||||
} |
||||
|
||||
fn extract_zip(&self, zip: &[u8], dst: &Path, binaries: &[&str]) -> Result<(), Error> { |
||||
let mut binaries: HashSet<_> = binaries.into_iter().map(ffi::OsStr::new).collect(); |
||||
|
||||
let data = io::Cursor::new(zip); |
||||
let mut zip = zip::ZipArchive::new(data)?; |
||||
|
||||
for i in 0..zip.len() { |
||||
let mut entry = zip.by_index(i).unwrap(); |
||||
let entry_path = entry.sanitized_name(); |
||||
match entry_path.file_stem() { |
||||
Some(f) if binaries.contains(f) => { |
||||
binaries.remove(f); |
||||
let mut dest = bin_open_options() |
||||
.write(true) |
||||
.create_new(true) |
||||
.open(dst.join(entry_path.file_name().unwrap()))?; |
||||
io::copy(&mut entry, &mut dest)?; |
||||
} |
||||
_ => continue, |
||||
}; |
||||
} |
||||
|
||||
if !binaries.is_empty() { |
||||
bail!( |
||||
"the zip was missing expected executables: {}", |
||||
binaries |
||||
.into_iter() |
||||
.map(|s| s.to_string_lossy()) |
||||
.collect::<Vec<_>>() |
||||
.join(", "), |
||||
) |
||||
} |
||||
|
||||
return Ok(()); |
||||
|
||||
#[cfg(unix)] |
||||
fn bin_open_options() -> fs::OpenOptions { |
||||
use std::os::unix::fs::OpenOptionsExt; |
||||
|
||||
let mut opts = fs::OpenOptions::new(); |
||||
opts.mode(0o755); |
||||
opts |
||||
} |
||||
|
||||
#[cfg(not(unix))] |
||||
fn bin_open_options() -> fs::OpenOptions { |
||||
fs::OpenOptions::new() |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl Download { |
||||
/// Manually constructs a download at the specified path
|
||||
pub fn at(path: &Path) -> Download { |
||||
Download { |
||||
root: path.to_path_buf(), |
||||
} |
||||
} |
||||
|
||||
/// Returns the path to the binary `name` within this download
|
||||
pub fn binary(&self, name: &str) -> Result<PathBuf, Error> { |
||||
use is_executable::IsExecutable; |
||||
|
||||
let ret = self |
||||
.root |
||||
.join(name) |
||||
.with_extension(env::consts::EXE_EXTENSION); |
||||
|
||||
if !ret.is_file() { |
||||
bail!("{} binary does not exist", ret.display()); |
||||
} |
||||
if !ret.is_executable() { |
||||
bail!("{} is not executable", ret.display()); |
||||
} |
||||
|
||||
Ok(ret) |
||||
} |
||||
} |
||||
|
||||
fn curl(url: &str) -> Result<Vec<u8>, Error> { |
||||
let mut data = Vec::new(); |
||||
|
||||
let mut easy = curl::easy::Easy::new(); |
||||
easy.follow_location(true)?; |
||||
easy.url(url)?; |
||||
easy.get(true)?; |
||||
{ |
||||
let mut transfer = easy.transfer(); |
||||
transfer.write_function(|part| { |
||||
data.extend_from_slice(part); |
||||
Ok(part.len()) |
||||
})?; |
||||
transfer.perform()?; |
||||
} |
||||
|
||||
let status_code = easy.response_code()?; |
||||
if 200 <= status_code && status_code < 300 { |
||||
Ok(data) |
||||
} else { |
||||
bail!( |
||||
"received a bad HTTP status code ({}) when requesting {}", |
||||
status_code, |
||||
url |
||||
) |
||||
} |
||||
} |
||||
|
||||
fn hashed_dirname(url: &str, name: &str) -> String { |
||||
let mut hasher = SipHasher13::new(); |
||||
url.hash(&mut hasher); |
||||
let result = hasher.finish(); |
||||
let hex = hex::encode(&[ |
||||
(result >> 0) as u8, |
||||
(result >> 8) as u8, |
||||
(result >> 16) as u8, |
||||
(result >> 24) as u8, |
||||
(result >> 32) as u8, |
||||
(result >> 40) as u8, |
||||
(result >> 48) as u8, |
||||
(result >> 56) as u8, |
||||
]); |
||||
format!("{}-{}", name, hex) |
||||
} |
||||
|
||||
#[cfg(test)] |
||||
mod tests { |
||||
use super::*; |
||||
|
||||
#[test] |
||||
fn it_returns_same_hash_for_same_name_and_url() { |
||||
let name = "wasm-pack"; |
||||
let url = "http://localhost:7878/wasm-pack-v0.6.0.tar.gz"; |
||||
|
||||
let first = hashed_dirname(url, name); |
||||
let second = hashed_dirname(url, name); |
||||
|
||||
assert!(!first.is_empty()); |
||||
assert!(!second.is_empty()); |
||||
assert_eq!(first, second); |
||||
} |
||||
|
||||
#[test] |
||||
fn it_returns_different_hashes_for_different_urls() { |
||||
let name = "wasm-pack"; |
||||
let url = "http://localhost:7878/wasm-pack-v0.5.1.tar.gz"; |
||||
let second_url = "http://localhost:7878/wasm-pack-v0.6.0.tar.gz"; |
||||
|
||||
let first = hashed_dirname(url, name); |
||||
let second = hashed_dirname(second_url, name); |
||||
|
||||
assert_ne!(first, second); |
||||
} |
||||
|
||||
#[test] |
||||
fn it_returns_cache_dir() { |
||||
let name = "wasm-pack"; |
||||
let cache = Cache::new(name); |
||||
|
||||
let expected = dirs::cache_dir() |
||||
.unwrap() |
||||
.join(PathBuf::from(".".to_owned() + name)); |
||||
|
||||
assert!(cache.is_ok()); |
||||
assert_eq!(cache.unwrap().destination, expected); |
||||
} |
||||
|
||||
#[test] |
||||
fn it_returns_destination_if_binary_already_exists() { |
||||
use std::fs; |
||||
|
||||
let binary_name = "wasm-pack"; |
||||
let binaries = vec![binary_name]; |
||||
|
||||
let dir = tempfile::TempDir::new().unwrap(); |
||||
let cache = Cache::at(dir.path()); |
||||
let url = &format!("{}/{}.tar.gz", "http://localhost:7878", binary_name); |
||||
|
||||
let dirname = hashed_dirname(&url, &binary_name); |
||||
let full_path = dir.path().join(dirname); |
||||
|
||||
// Create temporary directory and binary to simulate that
|
||||
// a cached binary already exists.
|
||||
fs::create_dir_all(full_path).unwrap(); |
||||
|
||||
let dl = cache.download(true, binary_name, &binaries, url); |
||||
|
||||
assert!(dl.is_ok()); |
||||
assert!(dl.unwrap().is_some()) |
||||
} |
||||
} |
||||
@ -1,142 +0,0 @@ |
||||
use binary_install::Cache; |
||||
use std::path::Path; |
||||
use utils; |
||||
|
||||
#[test] |
||||
fn it_returns_none_if_install_is_not_permitted() { |
||||
let binary_name = "wasm-pack"; |
||||
let binaries = vec![binary_name]; |
||||
|
||||
let dir = tempfile::TempDir::new().unwrap(); |
||||
let cache = Cache::at(dir.path()); |
||||
|
||||
let dl = cache.download( |
||||
false, |
||||
binary_name, |
||||
&binaries, |
||||
&format!("{}/{}.tar.gz", "", binary_name), |
||||
); |
||||
|
||||
assert!(dl.is_ok()); |
||||
assert!(dl.unwrap().is_none()) |
||||
} |
||||
|
||||
#[test] |
||||
fn it_downloads_tarball() { |
||||
let binary_name = "wasm-pack"; |
||||
let binaries = vec![binary_name]; |
||||
|
||||
// Create a temporary tarball.
|
||||
let tarball = utils::create_tarball(binary_name).ok(); |
||||
|
||||
// Spin up a local TcpListener.
|
||||
let server_port = utils::start_server(tarball, None).recv().unwrap(); |
||||
|
||||
let url = format!("http://{}:{}", utils::TEST_SERVER_HOST, server_port); |
||||
|
||||
let dir = tempfile::TempDir::new().unwrap(); |
||||
let cache = Cache::at(dir.path()); |
||||
|
||||
let dl = cache.download( |
||||
true, |
||||
binary_name, |
||||
&binaries, |
||||
&format!("{}/{}.tar.gz", &url, binary_name), |
||||
); |
||||
|
||||
assert!(dl.is_ok()); |
||||
assert!(dl.unwrap().is_some()) |
||||
} |
||||
|
||||
#[test] |
||||
fn it_returns_error_when_it_failed_to_download() { |
||||
let server_port = 7881; |
||||
let url = format!("http://{}:{}", utils::TEST_SERVER_HOST, server_port); |
||||
let binary_name = "wasm-pack"; |
||||
let binaries = vec![binary_name]; |
||||
|
||||
let dir = tempfile::TempDir::new().unwrap(); |
||||
let cache = Cache::at(dir.path()); |
||||
let full_url = &format!("{}/{}.tar.gz", &url, binary_name); |
||||
|
||||
let dl = cache.download(true, binary_name, &binaries, full_url); |
||||
|
||||
assert!(dl.is_err()); |
||||
assert_eq!( |
||||
&format!("failed to download from {}", full_url), |
||||
&format!("{}", dl.unwrap_err()) |
||||
); |
||||
} |
||||
|
||||
#[test] |
||||
fn it_returns_error_when_it_failed_to_extract_tarball() { |
||||
let binary_name = "wasm-pack"; |
||||
let binaries = vec![binary_name]; |
||||
|
||||
let dir = tempfile::TempDir::new().unwrap(); |
||||
let cache = Cache::at(dir.path()); |
||||
|
||||
// Spin up a local TcpListener.
|
||||
let server_port = utils::start_server(None, None).recv().unwrap(); |
||||
|
||||
let url = format!("http://{}:{}", utils::TEST_SERVER_HOST, server_port); |
||||
let full_url = &format!("{}/{}.tar.gz", &url, binary_name); |
||||
|
||||
let dl = cache.download(true, binary_name, &binaries, full_url); |
||||
|
||||
assert!(dl.is_err()); |
||||
assert_eq!( |
||||
&format!("failed to extract tarball from {}", full_url), |
||||
&format!("{}", dl.unwrap_err()) |
||||
); |
||||
} |
||||
|
||||
#[test] |
||||
fn it_returns_error_when_it_failed_to_extract_zip() { |
||||
let binary_name = "wasm-pack"; |
||||
let binaries = vec![binary_name]; |
||||
|
||||
let dir = tempfile::TempDir::new().unwrap(); |
||||
let cache = Cache::at(dir.path()); |
||||
|
||||
// Spin up a local TcpListener.
|
||||
let server_port = utils::start_server(None, None).recv().unwrap(); |
||||
|
||||
let url = format!("http://{}:{}", utils::TEST_SERVER_HOST, server_port); |
||||
let full_url = &format!("{}/{}.zip", &url, binary_name); |
||||
|
||||
let dl = cache.download(true, binary_name, &binaries, full_url); |
||||
|
||||
assert!(dl.is_err()); |
||||
assert_eq!( |
||||
&format!("failed to extract zip from {}", full_url), |
||||
&format!("{}", dl.unwrap_err()) |
||||
); |
||||
} |
||||
|
||||
#[test] |
||||
#[should_panic(expected = "don't know how to extract http://localhost:7884/wasm-pack.bin")] |
||||
fn it_panics_if_not_tarball_or_zip() { |
||||
let server_port = 7884; |
||||
let binary_name = "wasm-pack"; |
||||
let binaries = vec![binary_name]; |
||||
|
||||
let dir = tempfile::TempDir::new().unwrap(); |
||||
let cache = Cache::at(dir.path()); |
||||
|
||||
// Spin up a local TcpListener.
|
||||
utils::start_server(None, Some(server_port)).recv().unwrap(); |
||||
|
||||
let url = format!("http://{}:{}", utils::TEST_SERVER_HOST, server_port); |
||||
let full_url = &format!("{}/{}.bin", &url, binary_name); |
||||
|
||||
let _ = cache.download(true, binary_name, &binaries, full_url); |
||||
} |
||||
|
||||
#[test] |
||||
fn it_joins_path_with_destination() { |
||||
let dir = tempfile::TempDir::new().unwrap(); |
||||
let cache = Cache::at(dir.path()); |
||||
|
||||
assert_eq!(dir.path().join("hello"), cache.join(Path::new("hello"))); |
||||
} |
||||
@ -1,125 +0,0 @@ |
||||
use binary_install::Download; |
||||
use std::fs::OpenOptions; |
||||
|
||||
#[test] |
||||
#[cfg(unix)] |
||||
fn it_returns_binary_name_for_unix() { |
||||
use std::os::unix::fs::OpenOptionsExt; |
||||
|
||||
let binary_name = "wasm-pack"; |
||||
|
||||
let dir = tempfile::TempDir::new().unwrap(); |
||||
let download = Download::at(dir.path()); |
||||
|
||||
let full_path = dir.path().join(binary_name); |
||||
|
||||
let mut options = OpenOptions::new(); |
||||
options.create(true); |
||||
options.write(true); |
||||
|
||||
// Make the "binary" an executable.
|
||||
options.mode(0o755); |
||||
|
||||
options.open(&full_path).unwrap(); |
||||
|
||||
let binary = download.binary(binary_name); |
||||
|
||||
assert!(binary.is_ok()); |
||||
assert_eq!(full_path, binary.unwrap()); |
||||
} |
||||
|
||||
#[test] |
||||
#[cfg(not(windows))] |
||||
fn it_bails_if_not_file_for_unix() { |
||||
let binary_name = "wasm-pack"; |
||||
|
||||
let dir = tempfile::TempDir::new().unwrap(); |
||||
let download = Download::at(dir.path()); |
||||
|
||||
let full_path = dir.path().join(binary_name); |
||||
|
||||
let mut options = OpenOptions::new(); |
||||
options.create(true); |
||||
options.write(true); |
||||
|
||||
let binary = download.binary(binary_name); |
||||
|
||||
assert!(binary.is_err()); |
||||
assert_eq!( |
||||
format!("{} binary does not exist", full_path.to_str().unwrap()), |
||||
binary.unwrap_err().to_string() |
||||
); |
||||
} |
||||
|
||||
#[test] |
||||
#[cfg(windows)] |
||||
fn it_bails_if_not_file_for_windows() { |
||||
let binary_name = "wasm-pack.exe"; |
||||
|
||||
let dir = tempfile::TempDir::new().unwrap(); |
||||
let download = Download::at(dir.path()); |
||||
|
||||
let full_path = dir.path().join(binary_name); |
||||
|
||||
let mut options = OpenOptions::new(); |
||||
options.create(true); |
||||
options.write(true); |
||||
|
||||
let binary = download.binary(binary_name); |
||||
|
||||
assert!(binary.is_err()); |
||||
assert_eq!( |
||||
format!("{} binary does not exist", full_path.to_str().unwrap()), |
||||
binary.unwrap_err().to_string() |
||||
); |
||||
} |
||||
|
||||
#[test] |
||||
#[cfg(not(windows))] |
||||
fn it_bails_if_not_executable_for_unix() { |
||||
let binary_name = "wasm-pack"; |
||||
|
||||
let dir = tempfile::TempDir::new().unwrap(); |
||||
let download = Download::at(dir.path()); |
||||
|
||||
let full_path = dir.path().join(binary_name); |
||||
|
||||
let mut options = OpenOptions::new(); |
||||
options.create(true); |
||||
options.write(true); |
||||
|
||||
options.open(&full_path).unwrap(); |
||||
|
||||
let binary = download.binary(binary_name); |
||||
|
||||
assert!(binary.is_err()); |
||||
assert_eq!( |
||||
format!("{} is not executable", full_path.to_str().unwrap()), |
||||
binary.unwrap_err().to_string() |
||||
); |
||||
} |
||||
|
||||
#[test] |
||||
#[cfg(windows)] |
||||
fn it_bails_if_not_executable_for_windows() { |
||||
let binary_name = "wasm-pack.exe"; |
||||
|
||||
let dir = tempfile::TempDir::new().unwrap(); |
||||
let download = Download::at(dir.path()); |
||||
|
||||
let full_path = dir.path().join(binary_name); |
||||
|
||||
let mut options = OpenOptions::new(); |
||||
options.create(true); |
||||
options.write(true); |
||||
|
||||
options.open(&full_path).unwrap(); |
||||
|
||||
let binary = download.binary(binary_name); |
||||
|
||||
assert!(binary.is_err()); |
||||
assert_eq!( |
||||
format!("{} is not executable", full_path.to_str().unwrap()), |
||||
binary.unwrap_err().to_string() |
||||
); |
||||
} |
||||
@ -1,7 +0,0 @@ |
||||
extern crate binary_install; |
||||
extern crate flate2; |
||||
extern crate tar; |
||||
|
||||
mod cache; |
||||
mod download; |
||||
mod utils; |
||||
@ -1,79 +0,0 @@ |
||||
use flate2::write::GzEncoder; |
||||
use flate2::Compression; |
||||
use std::fs::{File, OpenOptions}; |
||||
use std::io::{self, Read, Write}; |
||||
use std::net::TcpListener; |
||||
use std::sync::mpsc::{channel, Receiver}; |
||||
use std::thread; |
||||
|
||||
pub const TEST_SERVER_HOST: &'static str = "localhost"; |
||||
|
||||
pub fn start_server(tarball: Option<Vec<u8>>, server_port: Option<u16>) -> Receiver<u16> { |
||||
let (sender, receiver) = channel(); |
||||
|
||||
thread::spawn(move || { |
||||
TcpListener::bind(format!( |
||||
"{}:{}", |
||||
TEST_SERVER_HOST, |
||||
server_port.unwrap_or_else(|| 0) |
||||
)) |
||||
.map(|listener| { |
||||
sender.send(listener.local_addr().unwrap().port()).unwrap(); |
||||
|
||||
for stream in listener.incoming() { |
||||
let mut stream = stream.unwrap(); |
||||
|
||||
let mut buffer = [0; 512]; |
||||
|
||||
stream.read(&mut buffer).unwrap(); |
||||
|
||||
let response = "HTTP/1.1 200 OK\r\n\r\n"; |
||||
|
||||
stream.write(response.as_bytes()).unwrap(); |
||||
|
||||
match tarball.to_owned() { |
||||
Some(tar) => { |
||||
stream.write(tar.as_ref()).unwrap(); |
||||
} |
||||
None => {} |
||||
} |
||||
|
||||
stream.flush().unwrap(); |
||||
} |
||||
}) |
||||
.unwrap(); |
||||
}); |
||||
|
||||
receiver |
||||
} |
||||
|
||||
pub fn create_tarball(binary_name: &str) -> Result<Vec<u8>, io::Error> { |
||||
let temp_dir = tempfile::TempDir::new().unwrap(); |
||||
let full_path = temp_dir.path().join(binary_name.to_owned() + ".tar.gz"); |
||||
|
||||
let tar = OpenOptions::new() |
||||
.create(true) |
||||
.read(true) |
||||
.write(true) |
||||
.open(&full_path)?; |
||||
|
||||
let mut file = OpenOptions::new() |
||||
.create(true) |
||||
.read(true) |
||||
.write(true) |
||||
.open(temp_dir.path().join(binary_name))?; |
||||
|
||||
let mut encoder = GzEncoder::new(tar, Compression::default()); |
||||
{ |
||||
let mut archive = tar::Builder::new(&mut encoder); |
||||
archive.append_file(binary_name, &mut file)?; |
||||
} |
||||
|
||||
let mut contents = vec![]; |
||||
|
||||
encoder.finish()?; |
||||
|
||||
File::open(temp_dir.path().join(&full_path))?.read_to_end(&mut contents)?; |
||||
|
||||
Ok(contents) |
||||
} |
||||
@ -1,24 +0,0 @@ |
||||
# Building your package |
||||
|
||||
We've written our code so now we need to package it all up. |
||||
|
||||
We are writing a package that should be used in the browser, so we run this in our terminal: |
||||
|
||||
```bash |
||||
$ wasm-pack build --scope MYSCOPE |
||||
``` |
||||
|
||||
If you were writing a package that should be used in Node.js (with CommonJS modules, e.g. `require`), |
||||
you would run this in your terminal: |
||||
|
||||
```bash |
||||
$ wasm-pack build --scope MYSCOPE --target nodejs |
||||
``` |
||||
|
||||
where `MYSCOPE` is your npm username. Normally you could just type `wasm-pack init` but since |
||||
other people are doing this tutorial as well we don't want conflicts with the `wasm-add` package |
||||
name! This command when run does a few things: |
||||
|
||||
1. It'll compile your code to wasm if you haven't already |
||||
2. It'll generate a pkg folder with the wasm file, a JS wrapper file around the wasm, your README, |
||||
and a `package.json` file. |
||||
@ -0,0 +1,23 @@ |
||||
# Building your project |
||||
|
||||
We've written our code so now we need to build it. |
||||
|
||||
We are writing a crate that should be used in the browser, so we run this in |
||||
our terminal: |
||||
|
||||
```bash |
||||
$ wasm-pack build |
||||
``` |
||||
|
||||
If you were writing a package that should be used in Node.js (with CommonJS |
||||
modules, e.g. `require`), you would run this in your terminal: |
||||
|
||||
```bash |
||||
$ wasm-pack build --target nodejs |
||||
``` |
||||
|
||||
This command when run does a few things: |
||||
|
||||
1. It'll compile your code to wasm if you haven't already |
||||
2. It'll generate a `pkg` folder with the wasm file, a JS wrapper file around |
||||
the wasm, your README, and a `package.json` file. |
||||
@ -1,10 +0,0 @@ |
||||
# Project Setup |
||||
|
||||
In this section, how to setup a `wasm-pack` project. |
||||
|
||||
There are a few things you need to do to setup a project for `wasm-pack`. |
||||
We strongly recommending [using a template], but you can also set the project |
||||
up [manually]. |
||||
|
||||
[using a template]: ./using-a-template.html |
||||
[manually]: ./manual-setup.html |
||||
@ -1,21 +0,0 @@ |
||||
# Using a Template |
||||
|
||||
You can create a new Rust-WebAssembly project by using the [rustwasm wasm-pack-template]. |
||||
|
||||
To so do, you'll need the `cargo-generate` tool. To install `cargo-generate`: |
||||
|
||||
``` |
||||
cargo install cargo-generate |
||||
``` |
||||
|
||||
Then run: |
||||
|
||||
``` |
||||
cargo generate --git https://github.com/rustwasm/wasm-pack-template |
||||
``` |
||||
|
||||
You will be prompted to give your project a name. Once you do, you will have a directory |
||||
with a new project, ready to go. We'll talk about what's been included in this template |
||||
further in this guide. |
||||
|
||||
[rustwasm wasm-pack-template]: https://github.com/rustwasm/wasm-pack-template |
||||
@ -1 +0,0 @@ |
||||
# Template Deep Dive |
||||
@ -0,0 +1,74 @@ |
||||
# tests/web.rs |
||||
|
||||
`web.rs` is an integration test [defined with Cargo][cargo-tests] that is |
||||
intended to be run in a headless web browser via the `wasm-pack test` command. |
||||
|
||||
[cargo-tests]: https://doc.rust-lang.org/cargo/guide/tests.html |
||||
|
||||
It contains three key parts: |
||||
|
||||
1. [`#[wasm_bindgen_test] functions`](#a1-wasm_bindgen_test-functions) |
||||
2. [Crate Configuration](#a2-crate-configuration) |
||||
3. [`#![cfg]` directives](#a3-cfg-directives) |
||||
|
||||
--- |
||||
|
||||
## 1. `#[wasm_bindgen_test]` functions |
||||
|
||||
The `#[wasm_bindgen_test]` is like the [normal Rust `#[test]` |
||||
attribute][rust-test], except it defines a test accessible to WebAssembly and |
||||
headless web browser testing. |
||||
|
||||
> **Note**: Eventually `#[test]` will work with WebAssembly as well! Currently |
||||
> though [custom test frameworks][ctf] are not stable. |
||||
|
||||
[rust-test]: https://doc.rust-lang.org/book/ch11-01-writing-tests.html |
||||
[ctf]: https://github.com/rust-lang/rust/issues/50297 |
||||
|
||||
```rust |
||||
#[wasm_bindgen_test] |
||||
fn pass() { |
||||
assert_eq!(1 + 1, 2); |
||||
} |
||||
``` |
||||
|
||||
Here the `pass` function is a unit test which asserts that arithmetic works in |
||||
WebAssembly like we'd expect everywhere else. If the test panics (such as the |
||||
`assert_eq!` being false) then the test will fail, otherwise the test will |
||||
succeed. |
||||
|
||||
The [reference documentation for `#[wasm_bindgen_test]`][wbg-test] should have |
||||
more information about defining these tests. |
||||
|
||||
[wbg-test]: https://rustwasm.github.io/docs/wasm-bindgen/wasm-bindgen-test/index.html |
||||
|
||||
## 2. Crate Configuration |
||||
|
||||
Other than the test in this module, we'll also see: |
||||
|
||||
```rust |
||||
use wasm_bindgen_test::*; |
||||
|
||||
wasm_bindgen_test_configure!(run_in_browser); |
||||
``` |
||||
|
||||
Like we saw earlier in `src/lib.rs` the `*` import pulls in everything from |
||||
`wasm_bindgen_test`, notably the `wasm_bindgen_test_configure` macro and the |
||||
`wasm_bindgen_test` attribute. |
||||
|
||||
The `wasm_bindgen_test_configure` macro (denoted by ending in `!`) is used to |
||||
indicate that the test is intended to execute in a web browser as opposed to |
||||
Node.js, which is the default. |
||||
|
||||
## 3. `#![cfg]` directives |
||||
|
||||
The last part we'll notice about this crate is this statement at the top: |
||||
|
||||
```rust |
||||
#![cfg(target_arch = "wasm32")] |
||||
``` |
||||
|
||||
This statement means that the test is only intended for the `wasm32` |
||||
architecture, or the `wasm32-unknown-unknown` target. This enables `cargo test` |
||||
to work in your project if the library is also being developed for other |
||||
platforms by ensuring that these tests only execute in a web browser. |
||||
@ -0,0 +1,45 @@ |
||||
# Testing your project |
||||
|
||||
Now after writing and building code, let's actually execute it! You can execute |
||||
tests with: |
||||
|
||||
```bash |
||||
$ wasm-pack test --firefox |
||||
[INFO]: Checking for the Wasm target... |
||||
Finished dev [unoptimized + debuginfo] target(s) in 0.02s |
||||
Running target/wasm32-unknown-unknown/debug/deps/web-9e7d380f8600b08e.wasm |
||||
Interactive browsers tests are now available at http://127.0.0.1:8000 |
||||
|
||||
Note that interactive mode is enabled because `NO_HEADLESS` |
||||
is specified in the environment of this process. Once you're |
||||
done with testing you'll need to kill this server with |
||||
Ctrl-C. |
||||
``` |
||||
|
||||
The console won't finish just yet, but as indicated you can visit |
||||
http://127.0.0.1:8000 in your web browser to see the test output: |
||||
|
||||
``` |
||||
running 1 test |
||||
|
||||
test web::pass ... ok |
||||
|
||||
test result: ok. 1 passed; 0 failed; 0 ignored |
||||
``` |
||||
|
||||
and we've now executed our first tests in a web browser! |
||||
|
||||
If you'd like to execute tests in a headless web browser (you don't need to |
||||
manually visit a page) you can do: |
||||
|
||||
```bash |
||||
$ wasm-pack test --headless --firefox |
||||
``` |
||||
|
||||
and similarly if you're developing a project for Node.js you can also execute |
||||
`wasm-pack test --nodejs` to run tests in Node. |
||||
|
||||
Be sure to see the [testing reference documentation][testing-reference] for |
||||
other supported features as well! |
||||
|
||||
[testing-reference]: https://rustwasm.github.io/docs/wasm-bindgen/wasm-bindgen-test/index.html |
||||
Loading…
Reference in new issue