use crate::error::AnyError;
use crate::error::GetErrorClassFn;
use crate::gotham_state::GothamState;
use crate::io::ResourceTable;
use crate::ops_metrics::OpMetricsFn;
use crate::runtime::JsRuntimeState;
use crate::runtime::OpDriverImpl;
use crate::FeatureChecker;
use crate::OpDecl;
use futures::task::AtomicWaker;
use std::cell::RefCell;
use std::cell::UnsafeCell;
use std::ops::Deref;
use std::ops::DerefMut;
use std::ptr::NonNull;
use std::rc::Rc;
use std::sync::Arc;
use v8::fast_api::CFunctionInfo;
use v8::fast_api::CTypeInfo;
use v8::Isolate;
pub type PromiseId = i32;
pub type OpId = u16;
#[cfg(debug_assertions)]
thread_local! {
static CURRENT_OP: std::cell::Cell<Option<&'static OpDecl>> = None.into();
}
#[cfg(debug_assertions)]
pub struct ReentrancyGuard {}
#[cfg(debug_assertions)]
impl Drop for ReentrancyGuard {
fn drop(&mut self) {
CURRENT_OP.with(|f| f.set(None));
}
}
#[cfg(debug_assertions)]
#[doc(hidden)]
pub fn reentrancy_check(decl: &'static OpDecl) -> Option<ReentrancyGuard> {
if decl.is_reentrant {
return None;
}
let current = CURRENT_OP.with(|f| f.get());
if let Some(current) = current {
panic!("op {} was not marked as #[op2(reentrant)], but re-entrantly invoked op {}", current.name, decl.name);
}
CURRENT_OP.with(|f| f.set(Some(decl)));
Some(ReentrancyGuard {})
}
pub struct OpCtx {
pub id: OpId,
pub isolate: *mut Isolate,
#[doc(hidden)]
pub state: Rc<RefCell<OpState>>,
#[doc(hidden)]
pub get_error_class_fn: GetErrorClassFn,
pub(crate) decl: OpDecl,
pub(crate) fast_fn_c_info: Option<NonNull<v8::fast_api::CFunctionInfo>>,
pub(crate) metrics_fn: Option<OpMetricsFn>,
pub(crate) last_fast_error: UnsafeCell<Option<AnyError>>,
op_driver: Rc<OpDriverImpl>,
runtime_state: Rc<JsRuntimeState>,
}
impl OpCtx {
#[allow(clippy::too_many_arguments)]
pub(crate) fn new(
id: OpId,
isolate: *mut Isolate,
op_driver: Rc<OpDriverImpl>,
decl: OpDecl,
state: Rc<RefCell<OpState>>,
runtime_state: Rc<JsRuntimeState>,
get_error_class_fn: GetErrorClassFn,
metrics_fn: Option<OpMetricsFn>,
) -> Self {
let mut fast_fn_c_info = None;
let fast_fn = if metrics_fn.is_some() {
&decl.fast_fn_with_metrics
} else {
&decl.fast_fn
};
if let Some(fast_fn) = fast_fn {
let args = CTypeInfo::new_from_slice(fast_fn.args);
let ret = CTypeInfo::new(fast_fn.return_type);
let c_fn = unsafe {
CFunctionInfo::new(
args.as_ptr(),
fast_fn.args.len(),
ret.as_ptr(),
fast_fn.repr,
)
};
fast_fn_c_info = Some(c_fn);
}
Self {
id,
state,
get_error_class_fn,
runtime_state,
decl,
op_driver,
fast_fn_c_info,
last_fast_error: UnsafeCell::new(None),
isolate,
metrics_fn,
}
}
#[inline(always)]
pub const fn decl(&self) -> &OpDecl {
&self.decl
}
#[inline(always)]
pub const fn metrics_enabled(&self) -> bool {
self.metrics_fn.is_some()
}
pub const fn external_references(&self) -> [v8::ExternalReference; 4] {
extern "C" fn placeholder() {}
let ctx_ptr = v8::ExternalReference {
pointer: self as *const OpCtx as _,
};
let null = v8::ExternalReference {
pointer: placeholder as _,
};
if self.metrics_enabled() {
let slow_fn = v8::ExternalReference {
function: self.decl.slow_fn_with_metrics,
};
if let (Some(fast_fn), Some(fast_fn_c_info)) =
(&self.decl.fast_fn_with_metrics, &self.fast_fn_c_info)
{
let fast_fn = v8::ExternalReference {
pointer: fast_fn.function as _,
};
let fast_info = v8::ExternalReference {
pointer: fast_fn_c_info.as_ptr() as _,
};
[ctx_ptr, slow_fn, fast_fn, fast_info]
} else {
[ctx_ptr, slow_fn, null, null]
}
} else {
let slow_fn = v8::ExternalReference {
function: self.decl.slow_fn,
};
if let (Some(fast_fn), Some(fast_fn_c_info)) =
(&self.decl.fast_fn, &self.fast_fn_c_info)
{
let fast_fn = v8::ExternalReference {
pointer: fast_fn.function as _,
};
let fast_info = v8::ExternalReference {
pointer: fast_fn_c_info.as_ptr() as _,
};
[ctx_ptr, slow_fn, fast_fn, fast_info]
} else {
[ctx_ptr, slow_fn, null, null]
}
}
}
#[inline(always)]
pub unsafe fn unsafely_take_last_error_for_ops_only(
&self,
) -> Option<AnyError> {
let opt_mut = &mut *self.last_fast_error.get();
opt_mut.take()
}
#[inline(always)]
pub unsafe fn unsafely_set_last_error_for_ops_only(&self, error: AnyError) {
let opt_mut = &mut *self.last_fast_error.get();
*opt_mut = Some(error);
}
pub(crate) fn op_driver(&self) -> &OpDriverImpl {
&self.op_driver
}
pub(crate) fn runtime_state(&self) -> &JsRuntimeState {
&self.runtime_state
}
}
pub struct OpState {
pub resource_table: ResourceTable,
pub(crate) gotham_state: GothamState,
pub waker: Arc<AtomicWaker>,
pub feature_checker: Arc<FeatureChecker>,
}
impl OpState {
pub fn new(maybe_feature_checker: Option<Arc<FeatureChecker>>) -> OpState {
OpState {
resource_table: Default::default(),
gotham_state: Default::default(),
waker: Arc::new(AtomicWaker::new()),
feature_checker: maybe_feature_checker.unwrap_or_default(),
}
}
pub(crate) fn clear(&mut self) {
std::mem::take(&mut self.gotham_state);
std::mem::take(&mut self.resource_table);
}
}
impl Deref for OpState {
type Target = GothamState;
fn deref(&self) -> &Self::Target {
&self.gotham_state
}
}
impl DerefMut for OpState {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.gotham_state
}
}