2019-01-01 19:58:40 -05:00
|
|
|
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
|
2018-07-26 17:54:22 -04:00
|
|
|
use std;
|
2018-09-14 15:30:43 -04:00
|
|
|
use std::fs::{create_dir, DirBuilder, File, OpenOptions};
|
2018-08-23 18:36:45 -04:00
|
|
|
use std::io::ErrorKind;
|
2018-08-22 13:19:32 -04:00
|
|
|
use std::io::Write;
|
2018-08-23 18:36:45 -04:00
|
|
|
use std::path::{Path, PathBuf};
|
|
|
|
|
2019-07-10 18:53:48 -04:00
|
|
|
use deno::ErrBox;
|
2018-08-23 18:36:45 -04:00
|
|
|
use rand;
|
2018-08-29 14:06:41 -04:00
|
|
|
use rand::Rng;
|
2019-07-17 18:15:30 -04:00
|
|
|
use url::Url;
|
2018-07-26 17:54:22 -04:00
|
|
|
|
2019-05-07 21:58:58 -04:00
|
|
|
#[cfg(unix)]
|
|
|
|
use nix::unistd::{chown as unix_chown, Gid, Uid};
|
2018-09-14 15:30:43 -04:00
|
|
|
#[cfg(any(unix))]
|
|
|
|
use std::os::unix::fs::DirBuilderExt;
|
2018-09-11 12:00:57 -04:00
|
|
|
#[cfg(any(unix))]
|
|
|
|
use std::os::unix::fs::PermissionsExt;
|
|
|
|
|
2018-12-11 08:36:34 -05:00
|
|
|
pub fn write_file<T: AsRef<[u8]>>(
|
2018-09-11 12:00:57 -04:00
|
|
|
filename: &Path,
|
2018-12-11 08:36:34 -05:00
|
|
|
data: T,
|
2018-09-11 12:00:57 -04:00
|
|
|
perm: u32,
|
|
|
|
) -> std::io::Result<()> {
|
2019-02-02 14:26:18 -05:00
|
|
|
write_file_2(filename, data, true, perm, true, false)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn write_file_2<T: AsRef<[u8]>>(
|
|
|
|
filename: &Path,
|
|
|
|
data: T,
|
|
|
|
update_perm: bool,
|
|
|
|
perm: u32,
|
|
|
|
is_create: bool,
|
|
|
|
is_append: bool,
|
|
|
|
) -> std::io::Result<()> {
|
2018-09-11 12:00:57 -04:00
|
|
|
let mut file = OpenOptions::new()
|
|
|
|
.read(false)
|
|
|
|
.write(true)
|
|
|
|
.append(is_append)
|
|
|
|
.truncate(!is_append)
|
2019-02-02 14:26:18 -05:00
|
|
|
.create(is_create)
|
2018-09-11 12:00:57 -04:00
|
|
|
.open(filename)?;
|
|
|
|
|
2019-02-02 14:26:18 -05:00
|
|
|
if update_perm {
|
|
|
|
set_permissions(&mut file, perm)?;
|
|
|
|
}
|
|
|
|
|
2018-12-11 08:36:34 -05:00
|
|
|
file.write_all(data.as_ref())
|
2018-09-11 12:00:57 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(any(unix))]
|
|
|
|
fn set_permissions(file: &mut File, perm: u32) -> std::io::Result<()> {
|
|
|
|
debug!("set file perm to {}", perm);
|
|
|
|
file.set_permissions(PermissionsExt::from_mode(perm & 0o777))
|
|
|
|
}
|
|
|
|
#[cfg(not(any(unix)))]
|
|
|
|
fn set_permissions(_file: &mut File, _perm: u32) -> std::io::Result<()> {
|
|
|
|
// NOOP on windows
|
|
|
|
Ok(())
|
2018-08-22 13:19:32 -04:00
|
|
|
}
|
|
|
|
|
2018-08-23 18:36:45 -04:00
|
|
|
pub fn make_temp_dir(
|
|
|
|
dir: Option<&Path>,
|
|
|
|
prefix: Option<&str>,
|
|
|
|
suffix: Option<&str>,
|
|
|
|
) -> std::io::Result<PathBuf> {
|
|
|
|
let prefix_ = prefix.unwrap_or("");
|
|
|
|
let suffix_ = suffix.unwrap_or("");
|
|
|
|
let mut buf: PathBuf = match dir {
|
|
|
|
Some(ref p) => p.to_path_buf(),
|
|
|
|
None => std::env::temp_dir(),
|
2019-07-31 17:11:37 -04:00
|
|
|
}
|
|
|
|
.join("_");
|
2018-08-29 14:06:41 -04:00
|
|
|
let mut rng = rand::thread_rng();
|
2018-08-23 18:36:45 -04:00
|
|
|
loop {
|
2018-08-29 14:06:41 -04:00
|
|
|
let unique = rng.gen::<u32>();
|
2018-08-23 18:36:45 -04:00
|
|
|
buf.set_file_name(format!("{}{:08x}{}", prefix_, unique, suffix_));
|
|
|
|
// TODO: on posix, set mode flags to 0o700.
|
|
|
|
let r = create_dir(buf.as_path());
|
|
|
|
match r {
|
|
|
|
Err(ref e) if e.kind() == ErrorKind::AlreadyExists => continue,
|
|
|
|
Ok(_) => return Ok(buf),
|
|
|
|
Err(e) => return Err(e),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-17 23:39:06 -05:00
|
|
|
pub fn mkdir(path: &Path, perm: u32, recursive: bool) -> std::io::Result<()> {
|
2018-07-26 17:54:22 -04:00
|
|
|
debug!("mkdir -p {}", path.display());
|
2018-09-14 15:30:43 -04:00
|
|
|
let mut builder = DirBuilder::new();
|
2019-01-17 23:39:06 -05:00
|
|
|
builder.recursive(recursive);
|
2018-09-14 15:30:43 -04:00
|
|
|
set_dir_permission(&mut builder, perm);
|
2019-01-17 23:39:06 -05:00
|
|
|
builder.create(path)
|
2018-07-26 17:54:22 -04:00
|
|
|
}
|
2018-08-23 03:58:59 -04:00
|
|
|
|
2018-09-14 15:30:43 -04:00
|
|
|
#[cfg(any(unix))]
|
|
|
|
fn set_dir_permission(builder: &mut DirBuilder, perm: u32) {
|
|
|
|
debug!("set dir perm to {}", perm);
|
2018-09-17 19:53:55 -04:00
|
|
|
builder.mode(perm & 0o777);
|
2018-09-14 15:30:43 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(not(any(unix)))]
|
|
|
|
fn set_dir_permission(_builder: &mut DirBuilder, _perm: u32) {
|
|
|
|
// NOOP on windows
|
|
|
|
}
|
|
|
|
|
2018-08-23 03:58:59 -04:00
|
|
|
pub fn normalize_path(path: &Path) -> String {
|
|
|
|
let s = String::from(path.to_str().unwrap());
|
|
|
|
if cfg!(windows) {
|
|
|
|
// TODO This isn't correct. Probbly should iterate over components.
|
|
|
|
s.replace("\\", "/")
|
|
|
|
} else {
|
|
|
|
s
|
|
|
|
}
|
|
|
|
}
|
2019-05-07 21:58:58 -04:00
|
|
|
|
|
|
|
#[cfg(unix)]
|
2019-07-10 18:53:48 -04:00
|
|
|
pub fn chown(path: &str, uid: u32, gid: u32) -> Result<(), ErrBox> {
|
2019-05-07 21:58:58 -04:00
|
|
|
let nix_uid = Uid::from_raw(uid);
|
|
|
|
let nix_gid = Gid::from_raw(gid);
|
|
|
|
unix_chown(path, Option::Some(nix_uid), Option::Some(nix_gid))
|
2019-07-10 18:53:48 -04:00
|
|
|
.map_err(ErrBox::from)
|
2019-05-07 21:58:58 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(not(unix))]
|
2019-07-10 18:53:48 -04:00
|
|
|
pub fn chown(_path: &str, _uid: u32, _gid: u32) -> Result<(), ErrBox> {
|
2019-05-07 21:58:58 -04:00
|
|
|
// Noop
|
|
|
|
// TODO: implement chown for Windows
|
2019-07-10 18:53:48 -04:00
|
|
|
Err(crate::deno_error::op_not_implemented())
|
2019-05-07 21:58:58 -04:00
|
|
|
}
|
2019-07-17 18:15:30 -04:00
|
|
|
|
|
|
|
pub fn resolve_from_cwd(path: &str) -> Result<(PathBuf, String), ErrBox> {
|
|
|
|
let candidate_path = Path::new(path);
|
|
|
|
|
|
|
|
let resolved_path = if candidate_path.is_absolute() {
|
|
|
|
candidate_path.to_owned()
|
|
|
|
} else {
|
|
|
|
let cwd = std::env::current_dir().unwrap();
|
|
|
|
cwd.join(path)
|
|
|
|
};
|
|
|
|
|
2019-09-07 14:13:09 -04:00
|
|
|
// HACK: `Url::parse` is used here because it normalizes the path.
|
2019-07-17 18:15:30 -04:00
|
|
|
// Joining `/dev/deno/" with "./tests" using `PathBuf` yields `/deno/dev/./tests/`.
|
|
|
|
// On the other hand joining `/dev/deno/" with "./tests" using `Url` yields "/dev/deno/tests"
|
|
|
|
// - and that's what we want.
|
|
|
|
// There exists similar method on `PathBuf` - `PathBuf.canonicalize`, but the problem
|
|
|
|
// is `canonicalize` resolves symlinks and we don't want that.
|
2019-09-07 14:13:09 -04:00
|
|
|
// We just want to normalize the path...
|
|
|
|
// This only works on absolute paths - not worth extracting as a public utility.
|
|
|
|
let resolved_url =
|
|
|
|
Url::from_file_path(resolved_path).expect("Path should be absolute");
|
|
|
|
let normalized_url = Url::parse(resolved_url.as_str())
|
|
|
|
.expect("String from a URL should parse to a URL");
|
|
|
|
let normalized_path = normalized_url
|
2019-07-17 18:15:30 -04:00
|
|
|
.to_file_path()
|
2019-09-07 14:13:09 -04:00
|
|
|
.expect("URL from a path should contain a valid path");
|
2019-07-17 18:15:30 -04:00
|
|
|
|
|
|
|
let path_string = normalized_path.to_str().unwrap().to_string();
|
|
|
|
|
|
|
|
Ok((normalized_path, path_string))
|
|
|
|
}
|
2019-09-07 14:13:09 -04:00
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn resolve_from_cwd_child() {
|
|
|
|
let cwd = std::env::current_dir().unwrap();
|
|
|
|
assert_eq!(resolve_from_cwd("a").unwrap().0, cwd.join("a"));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn resolve_from_cwd_dot() {
|
|
|
|
let cwd = std::env::current_dir().unwrap();
|
|
|
|
assert_eq!(resolve_from_cwd(".").unwrap().0, cwd);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn resolve_from_cwd_parent() {
|
|
|
|
let cwd = std::env::current_dir().unwrap();
|
|
|
|
assert_eq!(resolve_from_cwd("a/..").unwrap().0, cwd);
|
|
|
|
}
|
|
|
|
|
2019-09-10 23:16:30 -04:00
|
|
|
// TODO: Get a good expected value here for Windows.
|
|
|
|
#[cfg(not(windows))]
|
2019-09-07 14:13:09 -04:00
|
|
|
#[test]
|
|
|
|
fn resolve_from_cwd_absolute() {
|
2019-09-10 23:16:30 -04:00
|
|
|
let expected = Path::new("/a");
|
2019-09-07 14:13:09 -04:00
|
|
|
assert_eq!(resolve_from_cwd("/a").unwrap().0, expected);
|
|
|
|
}
|
|
|
|
}
|