2020-01-02 20:13:47 +00:00
|
|
|
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
|
2019-08-13 18:51:15 +00:00
|
|
|
use crate::deno_error::permission_denied;
|
2019-11-04 15:38:52 +00:00
|
|
|
use crate::global_state::ThreadSafeGlobalState;
|
2019-03-14 23:17:52 +00:00
|
|
|
use crate::global_timer::GlobalTimer;
|
2019-06-09 13:08:20 +00:00
|
|
|
use crate::import_map::ImportMap;
|
2019-11-04 15:38:52 +00:00
|
|
|
use crate::metrics::Metrics;
|
2019-10-01 22:51:05 +00:00
|
|
|
use crate::ops::JsonOp;
|
2019-11-14 17:10:25 +00:00
|
|
|
use crate::ops::MinimalOp;
|
2019-03-20 00:55:59 +00:00
|
|
|
use crate::permissions::DenoPermissions;
|
2019-04-08 21:10:00 +00:00
|
|
|
use crate::worker::Worker;
|
2019-11-04 15:38:52 +00:00
|
|
|
use crate::worker::WorkerChannels;
|
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-10-01 22:51:05 +00:00
|
|
|
use deno::Op;
|
2019-04-28 19:31:10 +00:00
|
|
|
use deno::PinnedBuf;
|
2019-11-14 17:10:25 +00:00
|
|
|
use deno::ResourceTable;
|
2019-11-17 00:17:47 +00:00
|
|
|
use futures::channel::mpsc;
|
|
|
|
use futures::future::FutureExt;
|
|
|
|
use futures::future::TryFutureExt;
|
2019-06-11 14:34:39 +00:00
|
|
|
use rand::rngs::StdRng;
|
|
|
|
use rand::SeedableRng;
|
2019-10-01 22:51:05 +00:00
|
|
|
use serde_json::Value;
|
2019-03-14 23:17:52 +00:00
|
|
|
use std;
|
2019-04-01 19:09:59 +00:00
|
|
|
use std::collections::HashMap;
|
2019-04-09 17:11:25 +00:00
|
|
|
use std::ops::Deref;
|
2019-11-17 00:17:47 +00:00
|
|
|
use std::pin::Pin;
|
2019-07-31 17:16:03 +00:00
|
|
|
use std::str;
|
2019-11-09 20:07:14 +00:00
|
|
|
use std::sync::atomic::AtomicUsize;
|
2019-11-04 15:38:52 +00:00
|
|
|
use std::sync::atomic::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-11-14 17:10:25 +00:00
|
|
|
use std::sync::MutexGuard;
|
2019-04-08 20:22:40 +00:00
|
|
|
use std::time::Instant;
|
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-11-04 15:38:52 +00:00
|
|
|
pub global_state: ThreadSafeGlobalState,
|
2019-06-11 18:35:03 +00:00
|
|
|
pub modules: Arc<Mutex<deno::Modules>>,
|
2019-11-24 15:42:30 +00:00
|
|
|
pub permissions: Arc<Mutex<DenoPermissions>>,
|
2019-11-04 15:38:52 +00:00
|
|
|
pub main_module: Option<ModuleSpecifier>,
|
|
|
|
pub worker_channels: Mutex<WorkerChannels>,
|
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,
|
|
|
|
pub global_timer: Mutex<GlobalTimer>,
|
2019-11-09 20:07:14 +00:00
|
|
|
pub workers: Mutex<HashMap<u32, Worker>>,
|
|
|
|
pub next_worker_id: AtomicUsize,
|
2019-04-08 20:22:40 +00:00
|
|
|
pub start_time: Instant,
|
2019-06-11 14:34:39 +00:00
|
|
|
pub seeded_rng: Option<Mutex<StdRng>>,
|
2019-08-05 11:23:41 +00:00
|
|
|
pub include_deno_namespace: bool,
|
2019-11-14 17:10:25 +00:00
|
|
|
pub resource_table: Mutex<ResourceTable>,
|
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-11-14 17:10:25 +00:00
|
|
|
pub fn lock_resource_table(&self) -> MutexGuard<ResourceTable> {
|
|
|
|
self.resource_table.lock().unwrap()
|
|
|
|
}
|
|
|
|
|
2019-10-01 22:51:05 +00:00
|
|
|
/// Wrap core `OpDispatcher` to collect metrics.
|
2019-10-11 18:41:54 +00:00
|
|
|
pub fn core_op<D>(
|
2019-06-18 01:02:08 +00:00
|
|
|
&self,
|
2019-10-01 22:51:05 +00:00
|
|
|
dispatcher: D,
|
|
|
|
) -> impl Fn(&[u8], Option<PinnedBuf>) -> CoreOp
|
|
|
|
where
|
|
|
|
D: Fn(&[u8], Option<PinnedBuf>) -> CoreOp,
|
|
|
|
{
|
|
|
|
let state = self.clone();
|
|
|
|
|
|
|
|
move |control: &[u8], zero_copy: Option<PinnedBuf>| -> CoreOp {
|
|
|
|
let bytes_sent_control = control.len();
|
|
|
|
let bytes_sent_zero_copy =
|
|
|
|
zero_copy.as_ref().map(|b| b.len()).unwrap_or(0);
|
|
|
|
|
|
|
|
let op = dispatcher(control, zero_copy);
|
|
|
|
state.metrics_op_dispatched(bytes_sent_control, bytes_sent_zero_copy);
|
|
|
|
|
|
|
|
match op {
|
|
|
|
Op::Sync(buf) => {
|
|
|
|
state.metrics_op_completed(buf.len());
|
|
|
|
Op::Sync(buf)
|
|
|
|
}
|
|
|
|
Op::Async(fut) => {
|
|
|
|
let state = state.clone();
|
2019-11-17 00:17:47 +00:00
|
|
|
let result_fut = fut.map_ok(move |buf: Buf| {
|
2019-12-23 14:59:44 +00:00
|
|
|
state.metrics_op_completed(buf.len());
|
2019-10-01 22:51:05 +00:00
|
|
|
buf
|
2019-11-17 00:17:47 +00:00
|
|
|
});
|
|
|
|
Op::Async(result_fut.boxed())
|
2019-10-01 22:51:05 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-14 17:10:25 +00:00
|
|
|
/// This is a special function that provides `state` argument to dispatcher.
|
|
|
|
pub fn stateful_minimal_op<D>(
|
|
|
|
&self,
|
|
|
|
dispatcher: D,
|
2019-11-17 00:17:47 +00:00
|
|
|
) -> impl Fn(i32, Option<PinnedBuf>) -> Pin<Box<MinimalOp>>
|
2019-11-14 17:10:25 +00:00
|
|
|
where
|
2019-11-17 00:17:47 +00:00
|
|
|
D: Fn(&ThreadSafeState, i32, Option<PinnedBuf>) -> Pin<Box<MinimalOp>>,
|
2019-11-14 17:10:25 +00:00
|
|
|
{
|
|
|
|
let state = self.clone();
|
|
|
|
|
2019-11-17 00:17:47 +00:00
|
|
|
move |rid: i32, zero_copy: Option<PinnedBuf>| -> Pin<Box<MinimalOp>> {
|
2019-11-14 17:10:25 +00:00
|
|
|
dispatcher(&state, rid, zero_copy)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-01 22:51:05 +00:00
|
|
|
/// This is a special function that provides `state` argument to dispatcher.
|
|
|
|
///
|
|
|
|
/// NOTE: This only works with JSON dispatcher.
|
|
|
|
/// This is a band-aid for transition to `Isolate.register_op` API as most of our
|
|
|
|
/// ops require `state` argument.
|
|
|
|
pub fn stateful_op<D>(
|
|
|
|
&self,
|
|
|
|
dispatcher: D,
|
|
|
|
) -> impl Fn(Value, Option<PinnedBuf>) -> Result<JsonOp, ErrBox>
|
|
|
|
where
|
|
|
|
D: Fn(&ThreadSafeState, Value, Option<PinnedBuf>) -> Result<JsonOp, ErrBox>,
|
|
|
|
{
|
|
|
|
let state = self.clone();
|
|
|
|
|
|
|
|
move |args: Value, zero_copy: Option<PinnedBuf>| -> Result<JsonOp, ErrBox> {
|
|
|
|
dispatcher(&state, args, zero_copy)
|
|
|
|
}
|
2019-04-09 17:11:25 +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,
|
2019-08-07 16:55:39 +00:00
|
|
|
is_main: bool,
|
2019-08-13 18:51:15 +00:00
|
|
|
is_dyn_import: bool,
|
2019-07-10 22:53:48 +00:00
|
|
|
) -> Result<ModuleSpecifier, ErrBox> {
|
2019-08-07 16:55:39 +00:00
|
|
|
if !is_main {
|
2019-06-09 13:08:20 +00:00
|
|
|
if let Some(import_map) = &self.import_map {
|
2019-06-12 19:00:08 +00:00
|
|
|
let result = import_map.resolve(specifier, referrer)?;
|
2019-10-03 13:16:06 +00:00
|
|
|
if let Some(r) = result {
|
|
|
|
return Ok(r);
|
2019-06-09 13:08:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-08-13 18:51:15 +00:00
|
|
|
let module_specifier =
|
|
|
|
ModuleSpecifier::resolve_import(specifier, referrer)?;
|
2019-06-09 13:08:20 +00:00
|
|
|
|
2019-08-13 18:51:15 +00:00
|
|
|
if is_dyn_import {
|
|
|
|
self.check_dyn_import(&module_specifier)?;
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(module_specifier)
|
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-11-25 14:33:23 +00:00
|
|
|
maybe_referrer: Option<ModuleSpecifier>,
|
2019-11-17 00:17:47 +00:00
|
|
|
) -> Pin<Box<deno::SourceCodeInfoFuture>> {
|
2019-06-05 20:35:38 +00:00
|
|
|
self.metrics.resolve_count.fetch_add(1, Ordering::SeqCst);
|
2019-08-07 16:55:39 +00:00
|
|
|
let module_url_specified = module_specifier.to_string();
|
2019-11-04 15:38:52 +00:00
|
|
|
let fut = self
|
|
|
|
.global_state
|
2019-11-25 14:33:23 +00:00
|
|
|
.fetch_compiled_module(module_specifier, maybe_referrer)
|
2019-11-17 00:17:47 +00:00
|
|
|
.map_ok(|compiled_module| deno::SourceCodeInfo {
|
2019-07-31 17:16:03 +00:00
|
|
|
// Real module name, might be different from initial specifier
|
|
|
|
// due to redirections.
|
|
|
|
code: compiled_module.code,
|
2019-08-07 16:55:39 +00:00
|
|
|
module_url_specified,
|
|
|
|
module_url_found: compiled_module.name,
|
2019-11-04 15:38:52 +00:00
|
|
|
});
|
|
|
|
|
2019-11-17 00:17:47 +00:00
|
|
|
fut.boxed()
|
2019-06-05 20:35:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-09 17:11:25 +00:00
|
|
|
impl ThreadSafeState {
|
2019-11-09 20:07:14 +00:00
|
|
|
pub fn create_channels() -> (WorkerChannels, WorkerChannels) {
|
|
|
|
let (in_tx, in_rx) = mpsc::channel::<Buf>(1);
|
|
|
|
let (out_tx, out_rx) = mpsc::channel::<Buf>(1);
|
2019-11-04 15:38:52 +00:00
|
|
|
let internal_channels = WorkerChannels {
|
2019-11-09 20:07:14 +00:00
|
|
|
sender: out_tx,
|
|
|
|
receiver: in_rx,
|
2019-06-09 13:08:20 +00:00
|
|
|
};
|
2019-11-04 15:38:52 +00:00
|
|
|
let external_channels = WorkerChannels {
|
2019-11-09 20:07:14 +00:00
|
|
|
sender: in_tx,
|
|
|
|
receiver: out_rx,
|
2019-07-31 17:16:03 +00:00
|
|
|
};
|
2019-11-09 20:07:14 +00:00
|
|
|
(internal_channels, external_channels)
|
|
|
|
}
|
2019-06-09 13:08:20 +00:00
|
|
|
|
2019-11-09 20:07:14 +00:00
|
|
|
pub fn new(
|
|
|
|
global_state: ThreadSafeGlobalState,
|
2019-11-24 15:42:30 +00:00
|
|
|
// If Some(perm), use perm. Else copy from global_state.
|
|
|
|
shared_permissions: Option<Arc<Mutex<DenoPermissions>>>,
|
2019-11-09 20:07:14 +00:00
|
|
|
main_module: Option<ModuleSpecifier>,
|
|
|
|
include_deno_namespace: bool,
|
|
|
|
internal_channels: WorkerChannels,
|
|
|
|
) -> Result<Self, ErrBox> {
|
2019-11-04 15:38:52 +00:00
|
|
|
let import_map: Option<ImportMap> =
|
|
|
|
match global_state.flags.import_map_path.as_ref() {
|
|
|
|
None => None,
|
|
|
|
Some(file_path) => Some(ImportMap::load(file_path)?),
|
|
|
|
};
|
2019-06-11 18:35:03 +00:00
|
|
|
|
2019-11-04 15:38:52 +00:00
|
|
|
let seeded_rng = match global_state.flags.seed {
|
|
|
|
Some(seed) => Some(Mutex::new(StdRng::seed_from_u64(seed))),
|
|
|
|
None => None,
|
2019-11-03 15:39:27 +00:00
|
|
|
};
|
|
|
|
|
2019-11-04 15:38:52 +00:00
|
|
|
let modules = Arc::new(Mutex::new(deno::Modules::new()));
|
2019-11-24 15:42:30 +00:00
|
|
|
let permissions = if let Some(perm) = shared_permissions {
|
|
|
|
perm
|
|
|
|
} else {
|
|
|
|
Arc::new(Mutex::new(global_state.permissions.clone()))
|
|
|
|
};
|
2019-11-04 15:38:52 +00:00
|
|
|
|
2019-07-31 11:58:41 +00:00
|
|
|
let state = State {
|
2019-11-04 15:38:52 +00:00
|
|
|
global_state,
|
2019-06-11 18:35:03 +00:00
|
|
|
modules,
|
2019-11-04 15:38:52 +00:00
|
|
|
main_module,
|
|
|
|
permissions,
|
2019-06-09 13:08:20 +00:00
|
|
|
import_map,
|
2019-04-08 21:10:00 +00:00
|
|
|
worker_channels: Mutex::new(internal_channels),
|
2019-11-04 15:38:52 +00:00
|
|
|
metrics: Metrics::default(),
|
2019-03-14 23:17:52 +00:00
|
|
|
global_timer: Mutex::new(GlobalTimer::new()),
|
2019-11-09 20:07:14 +00:00
|
|
|
workers: Mutex::new(HashMap::new()),
|
|
|
|
next_worker_id: AtomicUsize::new(0),
|
2019-04-08 20:22:40 +00:00
|
|
|
start_time: Instant::now(),
|
2019-06-11 14:34:39 +00:00
|
|
|
seeded_rng,
|
2019-08-05 11:23:41 +00:00
|
|
|
include_deno_namespace,
|
2019-11-14 17:10:25 +00:00
|
|
|
resource_table: Mutex::new(ResourceTable::default()),
|
2019-07-31 11:58:41 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
Ok(ThreadSafeState(Arc::new(state)))
|
2019-03-14 23:17:52 +00:00
|
|
|
}
|
|
|
|
|
2019-11-09 20:07:14 +00:00
|
|
|
pub fn add_child_worker(&self, worker: Worker) -> u32 {
|
|
|
|
let worker_id = self.next_worker_id.fetch_add(1, Ordering::Relaxed) as u32;
|
|
|
|
let mut workers_tl = self.workers.lock().unwrap();
|
|
|
|
workers_tl.insert(worker_id, worker);
|
|
|
|
worker_id
|
|
|
|
}
|
|
|
|
|
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-11-24 15:42:30 +00:00
|
|
|
self.permissions.lock().unwrap().check_read(filename)
|
2019-03-20 00:55:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
2019-07-10 22:53:48 +00:00
|
|
|
pub fn check_write(&self, filename: &str) -> Result<(), ErrBox> {
|
2019-11-24 15:42:30 +00:00
|
|
|
self.permissions.lock().unwrap().check_write(filename)
|
2019-03-20 00:55:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
2019-07-10 22:53:48 +00:00
|
|
|
pub fn check_env(&self) -> Result<(), ErrBox> {
|
2019-11-24 15:42:30 +00:00
|
|
|
self.permissions.lock().unwrap().check_env()
|
2019-03-20 00:55:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
2019-10-23 14:19:27 +00:00
|
|
|
pub fn check_net(&self, hostname: &str, port: u16) -> Result<(), ErrBox> {
|
2019-11-24 15:42:30 +00:00
|
|
|
self.permissions.lock().unwrap().check_net(hostname, port)
|
2019-05-08 23:20:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
2019-08-13 18:51:15 +00:00
|
|
|
pub fn check_net_url(&self, url: &url::Url) -> Result<(), ErrBox> {
|
2019-11-24 15:42:30 +00:00
|
|
|
self.permissions.lock().unwrap().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-11-24 15:42:30 +00:00
|
|
|
self.permissions.lock().unwrap().check_run()
|
2019-03-20 00:55:59 +00:00
|
|
|
}
|
|
|
|
|
2019-12-05 20:30:20 +00:00
|
|
|
#[inline]
|
|
|
|
pub fn check_plugin(&self, filename: &str) -> Result<(), ErrBox> {
|
|
|
|
self.permissions.lock().unwrap().check_plugin(filename)
|
|
|
|
}
|
|
|
|
|
2019-08-13 18:51:15 +00:00
|
|
|
pub fn check_dyn_import(
|
2020-01-04 10:20:52 +00:00
|
|
|
&self,
|
2019-08-13 18:51:15 +00:00
|
|
|
module_specifier: &ModuleSpecifier,
|
|
|
|
) -> Result<(), ErrBox> {
|
|
|
|
let u = module_specifier.as_url();
|
|
|
|
match u.scheme() {
|
|
|
|
"http" | "https" => {
|
|
|
|
self.check_net_url(u)?;
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
"file" => {
|
|
|
|
let filename = u
|
|
|
|
.to_file_path()
|
|
|
|
.unwrap()
|
|
|
|
.into_os_string()
|
|
|
|
.into_string()
|
|
|
|
.unwrap();
|
|
|
|
self.check_read(&filename)?;
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
_ => Err(permission_denied()),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-14 23:17:52 +00:00
|
|
|
#[cfg(test)]
|
2019-11-09 20:07:14 +00:00
|
|
|
pub fn mock(
|
|
|
|
argv: Vec<String>,
|
|
|
|
internal_channels: WorkerChannels,
|
|
|
|
) -> ThreadSafeState {
|
2019-11-04 15:38:52 +00:00
|
|
|
let module_specifier = if argv.is_empty() {
|
|
|
|
None
|
|
|
|
} else {
|
|
|
|
let module_specifier = ModuleSpecifier::resolve_url_or_path(&argv[0])
|
|
|
|
.expect("Invalid entry module");
|
|
|
|
Some(module_specifier)
|
|
|
|
};
|
|
|
|
|
2019-04-21 15:34:18 +00:00
|
|
|
ThreadSafeState::new(
|
2019-11-04 15:38:52 +00:00
|
|
|
ThreadSafeGlobalState::mock(argv),
|
2019-11-24 15:42:30 +00:00
|
|
|
None,
|
2019-11-04 15:38:52 +00:00
|
|
|
module_specifier,
|
2019-08-05 11:23:41 +00:00
|
|
|
true,
|
2019-11-09 20:07:14 +00:00
|
|
|
internal_channels,
|
2019-07-31 21:11:37 +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-11-09 20:07:14 +00:00
|
|
|
let (int, _) = ThreadSafeState::create_channels();
|
|
|
|
f(ThreadSafeState::mock(
|
|
|
|
vec![String::from("./deno"), String::from("hello.js")],
|
|
|
|
int,
|
|
|
|
));
|
2019-04-09 17:11:25 +00:00
|
|
|
}
|