2019-03-14 23:17:52 +00:00
|
|
|
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
|
2019-07-17 22:15:30 +00:00
|
|
|
use crate::compiler::TsCompiler;
|
2019-03-14 23:17:52 +00:00
|
|
|
use crate::deno_dir;
|
2019-07-31 11:58:41 +00:00
|
|
|
use crate::file_fetcher::SourceFile;
|
|
|
|
use crate::file_fetcher::SourceFileFetcher;
|
2019-03-14 23:17:52 +00:00
|
|
|
use crate::flags;
|
|
|
|
use crate::global_timer::GlobalTimer;
|
2019-06-09 13:08:20 +00:00
|
|
|
use crate::import_map::ImportMap;
|
2019-04-09 17:11:25 +00:00
|
|
|
use crate::ops;
|
2019-03-20 00:55:59 +00:00
|
|
|
use crate::permissions::DenoPermissions;
|
2019-05-11 14:23:19 +00:00
|
|
|
use crate::progress::Progress;
|
2019-04-08 21:10:00 +00:00
|
|
|
use crate::resources;
|
2019-04-01 19:09:59 +00:00
|
|
|
use crate::resources::ResourceId;
|
2019-04-08 21:10:00 +00:00
|
|
|
use crate::worker::Worker;
|
2019-03-30 23:30:40 +00:00
|
|
|
use deno::Buf;
|
2019-06-18 01:02:08 +00:00
|
|
|
use deno::CoreOp;
|
2019-07-10 22:53:48 +00:00
|
|
|
use deno::ErrBox;
|
2019-06-05 20:35:38 +00:00
|
|
|
use deno::Loader;
|
2019-06-12 23:55:59 +00:00
|
|
|
use deno::ModuleSpecifier;
|
2019-04-28 19:31:10 +00:00
|
|
|
use deno::PinnedBuf;
|
2019-04-01 19:09:59 +00:00
|
|
|
use futures::future::Shared;
|
2019-06-05 20:35:38 +00:00
|
|
|
use futures::Future;
|
2019-06-11 14:34:39 +00:00
|
|
|
use rand::rngs::StdRng;
|
|
|
|
use rand::SeedableRng;
|
2019-03-14 23:17:52 +00:00
|
|
|
use std;
|
2019-04-01 19:09:59 +00:00
|
|
|
use std::collections::HashMap;
|
2019-03-14 23:17:52 +00:00
|
|
|
use std::env;
|
2019-04-09 17:11:25 +00:00
|
|
|
use std::ops::Deref;
|
2019-03-14 23:17:52 +00:00
|
|
|
use std::sync::atomic::{AtomicUsize, Ordering};
|
2019-04-09 17:11:25 +00:00
|
|
|
use std::sync::Arc;
|
2019-03-14 23:17:52 +00:00
|
|
|
use std::sync::Mutex;
|
2019-04-08 20:22:40 +00:00
|
|
|
use std::time::Instant;
|
2019-04-08 21:10:00 +00:00
|
|
|
use tokio::sync::mpsc as async_mpsc;
|
2019-03-14 23:17:52 +00:00
|
|
|
|
|
|
|
pub type WorkerSender = async_mpsc::Sender<Buf>;
|
|
|
|
pub type WorkerReceiver = async_mpsc::Receiver<Buf>;
|
|
|
|
pub type WorkerChannels = (WorkerSender, WorkerReceiver);
|
2019-04-08 21:10:00 +00:00
|
|
|
pub type UserWorkerTable = HashMap<ResourceId, Shared<Worker>>;
|
2019-03-14 23:17:52 +00:00
|
|
|
|
|
|
|
#[derive(Default)]
|
|
|
|
pub struct Metrics {
|
|
|
|
pub ops_dispatched: AtomicUsize,
|
|
|
|
pub ops_completed: AtomicUsize,
|
|
|
|
pub bytes_sent_control: AtomicUsize,
|
|
|
|
pub bytes_sent_data: AtomicUsize,
|
|
|
|
pub bytes_received: AtomicUsize,
|
|
|
|
pub resolve_count: AtomicUsize,
|
2019-05-20 16:06:57 +00:00
|
|
|
pub compiler_starts: AtomicUsize,
|
2019-03-14 23:17:52 +00:00
|
|
|
}
|
|
|
|
|
2019-05-11 14:23:19 +00:00
|
|
|
/// Isolate cannot be passed between threads but ThreadSafeState can.
|
|
|
|
/// ThreadSafeState satisfies Send and Sync. So any state that needs to be
|
|
|
|
/// accessed outside the main V8 thread should be inside ThreadSafeState.
|
2019-04-09 17:11:25 +00:00
|
|
|
pub struct ThreadSafeState(Arc<State>);
|
|
|
|
|
2019-03-14 23:17:52 +00:00
|
|
|
#[cfg_attr(feature = "cargo-clippy", allow(stutter))]
|
2019-04-09 17:11:25 +00:00
|
|
|
pub struct State {
|
2019-06-11 18:35:03 +00:00
|
|
|
pub modules: Arc<Mutex<deno::Modules>>,
|
2019-06-12 19:00:08 +00:00
|
|
|
pub main_module: Option<ModuleSpecifier>,
|
2019-03-14 23:17:52 +00:00
|
|
|
pub dir: deno_dir::DenoDir,
|
|
|
|
pub argv: Vec<String>,
|
2019-03-20 00:55:59 +00:00
|
|
|
pub permissions: DenoPermissions,
|
2019-03-14 23:17:52 +00:00
|
|
|
pub flags: flags::DenoFlags,
|
2019-06-09 13:08:20 +00:00
|
|
|
/// When flags contains a `.import_map_path` option, the content of the
|
|
|
|
/// import map file will be resolved and set.
|
|
|
|
pub import_map: Option<ImportMap>,
|
2019-03-14 23:17:52 +00:00
|
|
|
pub metrics: Metrics,
|
2019-04-08 21:10:00 +00:00
|
|
|
pub worker_channels: Mutex<WorkerChannels>,
|
2019-03-14 23:17:52 +00:00
|
|
|
pub global_timer: Mutex<GlobalTimer>,
|
2019-04-01 19:09:59 +00:00
|
|
|
pub workers: Mutex<UserWorkerTable>,
|
2019-04-08 20:22:40 +00:00
|
|
|
pub start_time: Instant,
|
2019-05-11 14:23:19 +00:00
|
|
|
/// A reference to this worker's resource.
|
2019-04-08 21:10:00 +00:00
|
|
|
pub resource: resources::Resource,
|
2019-04-11 14:58:31 +00:00
|
|
|
pub dispatch_selector: ops::OpSelector,
|
2019-05-11 14:23:19 +00:00
|
|
|
/// Reference to global progress bar.
|
|
|
|
pub progress: Progress,
|
2019-06-11 14:34:39 +00:00
|
|
|
pub seeded_rng: Option<Mutex<StdRng>>,
|
2019-05-20 16:06:57 +00:00
|
|
|
|
2019-07-31 11:58:41 +00:00
|
|
|
pub file_fetcher: SourceFileFetcher,
|
2019-07-17 22:15:30 +00:00
|
|
|
pub ts_compiler: TsCompiler,
|
2019-03-14 23:17:52 +00:00
|
|
|
}
|
|
|
|
|
2019-04-09 17:11:25 +00:00
|
|
|
impl Clone for ThreadSafeState {
|
|
|
|
fn clone(&self) -> Self {
|
|
|
|
ThreadSafeState(self.0.clone())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Deref for ThreadSafeState {
|
|
|
|
type Target = Arc<State>;
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
|
|
&self.0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-23 22:58:00 +00:00
|
|
|
impl ThreadSafeState {
|
2019-06-18 01:02:08 +00:00
|
|
|
pub fn dispatch(
|
|
|
|
&self,
|
|
|
|
control: &[u8],
|
|
|
|
zero_copy: Option<PinnedBuf>,
|
|
|
|
) -> CoreOp {
|
2019-04-11 14:58:31 +00:00
|
|
|
ops::dispatch_all(self, control, zero_copy, self.dispatch_selector)
|
2019-04-09 17:11:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-07-17 22:15:30 +00:00
|
|
|
pub fn fetch_source_file_and_maybe_compile_async(
|
2019-06-05 20:35:38 +00:00
|
|
|
state: &ThreadSafeState,
|
2019-06-12 19:00:08 +00:00
|
|
|
module_specifier: &ModuleSpecifier,
|
2019-07-17 22:15:30 +00:00
|
|
|
) -> impl Future<Item = SourceFile, Error = ErrBox> {
|
2019-06-05 20:35:38 +00:00
|
|
|
let state_ = state.clone();
|
2019-06-12 19:00:08 +00:00
|
|
|
|
|
|
|
state_
|
2019-07-31 11:58:41 +00:00
|
|
|
.file_fetcher
|
2019-07-17 22:15:30 +00:00
|
|
|
.fetch_source_file_async(&module_specifier)
|
2019-06-25 20:14:36 +00:00
|
|
|
.and_then(move |out| {
|
2019-07-17 22:15:30 +00:00
|
|
|
state_
|
|
|
|
.clone()
|
|
|
|
.ts_compiler
|
|
|
|
.compile_async(state_.clone(), &out)
|
|
|
|
.map_err(|e| {
|
|
|
|
debug!("compiler error exiting!");
|
|
|
|
eprintln!("\n{}", e.to_string());
|
|
|
|
std::process::exit(1);
|
|
|
|
})
|
2019-06-12 19:00:08 +00:00
|
|
|
})
|
2019-06-05 20:35:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Loader for ThreadSafeState {
|
2019-06-09 13:08:20 +00:00
|
|
|
fn resolve(
|
|
|
|
&self,
|
|
|
|
specifier: &str,
|
|
|
|
referrer: &str,
|
|
|
|
is_root: bool,
|
2019-07-10 22:53:48 +00:00
|
|
|
) -> Result<ModuleSpecifier, ErrBox> {
|
2019-06-09 13:08:20 +00:00
|
|
|
if !is_root {
|
|
|
|
if let Some(import_map) = &self.import_map {
|
2019-06-12 19:00:08 +00:00
|
|
|
let result = import_map.resolve(specifier, referrer)?;
|
|
|
|
if result.is_some() {
|
2019-06-12 23:55:59 +00:00
|
|
|
return Ok(result.unwrap());
|
2019-06-09 13:08:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-07-10 22:53:48 +00:00
|
|
|
ModuleSpecifier::resolve_import(specifier, referrer).map_err(ErrBox::from)
|
2019-06-05 20:35:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Given an absolute url, load its source code.
|
2019-06-12 23:55:59 +00:00
|
|
|
fn load(
|
|
|
|
&self,
|
|
|
|
module_specifier: &ModuleSpecifier,
|
2019-07-10 22:53:48 +00:00
|
|
|
) -> Box<deno::SourceCodeInfoFuture> {
|
2019-06-05 20:35:38 +00:00
|
|
|
self.metrics.resolve_count.fetch_add(1, Ordering::SeqCst);
|
|
|
|
Box::new(
|
2019-07-17 22:15:30 +00:00
|
|
|
fetch_source_file_and_maybe_compile_async(self, module_specifier).map(
|
|
|
|
|source_file| deno::SourceCodeInfo {
|
|
|
|
// Real module name, might be different from initial specifier
|
2019-06-05 20:35:38 +00:00
|
|
|
// due to redirections.
|
2019-07-17 22:15:30 +00:00
|
|
|
code: source_file.js_source(),
|
|
|
|
module_name: source_file.url.to_string(),
|
|
|
|
},
|
|
|
|
),
|
2019-06-05 20:35:38 +00:00
|
|
|
)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-09 17:11:25 +00:00
|
|
|
impl ThreadSafeState {
|
2019-04-11 14:58:31 +00:00
|
|
|
pub fn new(
|
|
|
|
flags: flags::DenoFlags,
|
|
|
|
argv_rest: Vec<String>,
|
|
|
|
dispatch_selector: ops::OpSelector,
|
2019-05-11 14:23:19 +00:00
|
|
|
progress: Progress,
|
2019-07-31 11:58:41 +00:00
|
|
|
) -> Result<Self, ErrBox> {
|
2019-04-17 13:25:51 +00:00
|
|
|
let custom_root = env::var("DENO_DIR").map(String::into).ok();
|
2019-03-14 23:17:52 +00:00
|
|
|
|
2019-04-08 21:10:00 +00:00
|
|
|
let (worker_in_tx, worker_in_rx) = async_mpsc::channel::<Buf>(1);
|
|
|
|
let (worker_out_tx, worker_out_rx) = async_mpsc::channel::<Buf>(1);
|
|
|
|
let internal_channels = (worker_out_tx, worker_in_rx);
|
|
|
|
let external_channels = (worker_in_tx, worker_out_rx);
|
|
|
|
let resource = resources::add_worker(external_channels);
|
|
|
|
|
2019-07-31 11:58:41 +00:00
|
|
|
let dir = deno_dir::DenoDir::new(custom_root)?;
|
|
|
|
|
|
|
|
let file_fetcher = SourceFileFetcher::new(
|
|
|
|
dir.deps_cache.clone(),
|
2019-07-17 22:15:30 +00:00
|
|
|
progress.clone(),
|
|
|
|
!flags.reload,
|
|
|
|
flags.no_fetch,
|
2019-07-31 11:58:41 +00:00
|
|
|
)?;
|
|
|
|
|
|
|
|
let ts_compiler = TsCompiler::new(
|
|
|
|
file_fetcher.clone(),
|
|
|
|
dir.gen_cache.clone(),
|
|
|
|
!flags.reload,
|
|
|
|
flags.config_path.clone(),
|
|
|
|
);
|
2019-06-09 13:08:20 +00:00
|
|
|
|
2019-06-12 19:00:08 +00:00
|
|
|
let main_module: Option<ModuleSpecifier> = if argv_rest.len() <= 1 {
|
2019-06-09 13:08:20 +00:00
|
|
|
None
|
|
|
|
} else {
|
2019-06-12 19:00:08 +00:00
|
|
|
let root_specifier = argv_rest[1].clone();
|
core: clearly define when module lookup is path-based vs URL-based
The rules are now as follows:
* In `import` statements, as mandated by the WHATWG specification,
the import specifier is always treated as a URL.
If it is a relative URL, it must start with either / or ./ or ../
* A script name passed to deno as a command line argument may be either
an absolute URL or a local path.
- If the name starts with a valid URI scheme followed by a colon, e.g.
'http:', 'https:', 'file:', 'foo+bar:', it always interpreted as a
URL (even if Deno doesn't support the indicated protocol).
- Otherwise, the script name is interpreted as a local path. The local
path may be relative, and operating system semantics determine how
it is resolved. Prefixing a relative path with ./ is not required.
2019-07-08 07:55:24 +00:00
|
|
|
match ModuleSpecifier::resolve_url_or_path(&root_specifier) {
|
2019-06-12 19:00:08 +00:00
|
|
|
Ok(specifier) => Some(specifier),
|
2019-06-09 13:08:20 +00:00
|
|
|
Err(e) => {
|
2019-06-12 19:00:08 +00:00
|
|
|
// TODO: handle unresolvable specifier
|
|
|
|
panic!("Unable to resolve root specifier: {:?}", e);
|
2019-06-09 13:08:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
let mut import_map = None;
|
|
|
|
if let Some(file_name) = &flags.import_map_path {
|
|
|
|
let base_url = match &main_module {
|
2019-06-12 19:00:08 +00:00
|
|
|
Some(module_specifier) => module_specifier.clone(),
|
2019-06-09 13:08:20 +00:00
|
|
|
None => unreachable!(),
|
|
|
|
};
|
|
|
|
|
2019-06-12 19:00:08 +00:00
|
|
|
match ImportMap::load(&base_url.to_string(), file_name) {
|
2019-06-09 13:08:20 +00:00
|
|
|
Ok(map) => import_map = Some(map),
|
|
|
|
Err(err) => {
|
|
|
|
println!("{:?}", err);
|
|
|
|
panic!("Error parsing import map");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-11 14:34:39 +00:00
|
|
|
let mut seeded_rng = None;
|
|
|
|
if let Some(seed) = flags.seed {
|
|
|
|
seeded_rng = Some(Mutex::new(StdRng::seed_from_u64(seed)));
|
|
|
|
};
|
|
|
|
|
2019-06-11 18:35:03 +00:00
|
|
|
let modules = Arc::new(Mutex::new(deno::Modules::new()));
|
|
|
|
|
2019-07-31 11:58:41 +00:00
|
|
|
let state = State {
|
2019-06-09 13:08:20 +00:00
|
|
|
main_module,
|
2019-06-11 18:35:03 +00:00
|
|
|
modules,
|
2019-06-09 13:08:20 +00:00
|
|
|
dir,
|
2019-03-14 23:17:52 +00:00
|
|
|
argv: argv_rest,
|
2019-03-20 00:55:59 +00:00
|
|
|
permissions: DenoPermissions::from_flags(&flags),
|
2019-03-14 23:17:52 +00:00
|
|
|
flags,
|
2019-06-09 13:08:20 +00:00
|
|
|
import_map,
|
2019-03-14 23:17:52 +00:00
|
|
|
metrics: Metrics::default(),
|
2019-04-08 21:10:00 +00:00
|
|
|
worker_channels: Mutex::new(internal_channels),
|
2019-03-14 23:17:52 +00:00
|
|
|
global_timer: Mutex::new(GlobalTimer::new()),
|
2019-04-01 19:09:59 +00:00
|
|
|
workers: Mutex::new(UserWorkerTable::new()),
|
2019-04-08 20:22:40 +00:00
|
|
|
start_time: Instant::now(),
|
2019-04-08 21:10:00 +00:00
|
|
|
resource,
|
2019-04-11 14:58:31 +00:00
|
|
|
dispatch_selector,
|
2019-05-11 14:23:19 +00:00
|
|
|
progress,
|
2019-06-11 14:34:39 +00:00
|
|
|
seeded_rng,
|
2019-07-31 11:58:41 +00:00
|
|
|
file_fetcher,
|
2019-07-17 22:15:30 +00:00
|
|
|
ts_compiler,
|
2019-07-31 11:58:41 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
Ok(ThreadSafeState(Arc::new(state)))
|
2019-03-14 23:17:52 +00:00
|
|
|
}
|
|
|
|
|
2019-04-01 19:09:59 +00:00
|
|
|
/// Read main module from argv
|
2019-06-12 19:00:08 +00:00
|
|
|
pub fn main_module(&self) -> Option<ModuleSpecifier> {
|
2019-06-09 13:08:20 +00:00
|
|
|
match &self.main_module {
|
2019-06-12 19:00:08 +00:00
|
|
|
Some(module_specifier) => Some(module_specifier.clone()),
|
2019-06-09 13:08:20 +00:00
|
|
|
None => None,
|
2019-03-14 23:17:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-20 00:55:59 +00:00
|
|
|
#[inline]
|
2019-07-10 22:53:48 +00:00
|
|
|
pub fn check_read(&self, filename: &str) -> Result<(), ErrBox> {
|
2019-03-20 00:55:59 +00:00
|
|
|
self.permissions.check_read(filename)
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
2019-07-10 22:53:48 +00:00
|
|
|
pub fn check_write(&self, filename: &str) -> Result<(), ErrBox> {
|
2019-03-20 00:55:59 +00:00
|
|
|
self.permissions.check_write(filename)
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
2019-07-10 22:53:48 +00:00
|
|
|
pub fn check_env(&self) -> Result<(), ErrBox> {
|
2019-03-20 00:55:59 +00:00
|
|
|
self.permissions.check_env()
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
2019-07-10 22:53:48 +00:00
|
|
|
pub fn check_net(&self, host_and_port: &str) -> Result<(), ErrBox> {
|
2019-05-08 23:20:30 +00:00
|
|
|
self.permissions.check_net(host_and_port)
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
2019-07-10 22:53:48 +00:00
|
|
|
pub fn check_net_url(&self, url: url::Url) -> Result<(), ErrBox> {
|
2019-05-08 23:20:30 +00:00
|
|
|
self.permissions.check_net_url(url)
|
2019-03-20 00:55:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
2019-07-10 22:53:48 +00:00
|
|
|
pub fn check_run(&self) -> Result<(), ErrBox> {
|
2019-03-20 00:55:59 +00:00
|
|
|
self.permissions.check_run()
|
|
|
|
}
|
|
|
|
|
2019-03-14 23:17:52 +00:00
|
|
|
#[cfg(test)]
|
2019-06-08 18:42:28 +00:00
|
|
|
pub fn mock(argv: Vec<String>) -> ThreadSafeState {
|
2019-04-21 15:34:18 +00:00
|
|
|
ThreadSafeState::new(
|
|
|
|
flags::DenoFlags::default(),
|
|
|
|
argv,
|
|
|
|
ops::op_selector_std,
|
2019-05-11 14:23:19 +00:00
|
|
|
Progress::new(),
|
2019-07-31 11:58:41 +00:00
|
|
|
).unwrap()
|
2019-03-14 23:17:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn metrics_op_dispatched(
|
|
|
|
&self,
|
|
|
|
bytes_sent_control: usize,
|
|
|
|
bytes_sent_data: usize,
|
|
|
|
) {
|
|
|
|
self.metrics.ops_dispatched.fetch_add(1, Ordering::SeqCst);
|
|
|
|
self
|
|
|
|
.metrics
|
|
|
|
.bytes_sent_control
|
|
|
|
.fetch_add(bytes_sent_control, Ordering::SeqCst);
|
|
|
|
self
|
|
|
|
.metrics
|
|
|
|
.bytes_sent_data
|
|
|
|
.fetch_add(bytes_sent_data, Ordering::SeqCst);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn metrics_op_completed(&self, bytes_received: usize) {
|
|
|
|
self.metrics.ops_completed.fetch_add(1, Ordering::SeqCst);
|
|
|
|
self
|
|
|
|
.metrics
|
|
|
|
.bytes_received
|
|
|
|
.fetch_add(bytes_received, Ordering::SeqCst);
|
|
|
|
}
|
|
|
|
}
|
2019-04-09 17:11:25 +00:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn thread_safe() {
|
|
|
|
fn f<S: Send + Sync>(_: S) {}
|
2019-06-08 18:42:28 +00:00
|
|
|
f(ThreadSafeState::mock(vec![
|
|
|
|
String::from("./deno"),
|
|
|
|
String::from("hello.js"),
|
|
|
|
]));
|
2019-04-09 17:11:25 +00:00
|
|
|
}
|