mirror of
https://github.com/denoland/deno.git
synced 2024-10-29 08:58:01 -04:00
0260b488fb
Extensions allow declarative extensions to "JsRuntime" (ops, state, JS or middleware). This allows for: - `op_crates` to be plug-and-play & self-contained, reducing complexity leaked to consumers - op middleware (like metrics_op) to be opt-in and for new middleware (unstable, tracing,...) - `MainWorker` and `WebWorker` to be composable, allowing users to extend workers with their ops whilst benefiting from the other infrastructure (inspector, etc...) In short extensions improve deno's modularity, reducing complexity and leaky abstractions for embedders and the internal codebase.
87 lines
2.5 KiB
Rust
87 lines
2.5 KiB
Rust
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
|
|
|
|
pub mod fs;
|
|
pub mod fs_events;
|
|
pub mod http;
|
|
pub mod io;
|
|
pub mod net;
|
|
#[cfg(unix)]
|
|
mod net_unix;
|
|
pub mod os;
|
|
pub mod permissions;
|
|
pub mod plugin;
|
|
pub mod process;
|
|
pub mod runtime;
|
|
pub mod signal;
|
|
pub mod tls;
|
|
pub mod tty;
|
|
mod utils;
|
|
pub mod web_worker;
|
|
pub mod worker_host;
|
|
|
|
use crate::metrics::metrics_op;
|
|
use deno_core::error::AnyError;
|
|
use deno_core::op_async;
|
|
use deno_core::op_sync;
|
|
use deno_core::serde::de::DeserializeOwned;
|
|
use deno_core::serde::Serialize;
|
|
use deno_core::JsRuntime;
|
|
use deno_core::OpState;
|
|
use deno_core::ZeroCopyBuf;
|
|
use std::cell::RefCell;
|
|
use std::future::Future;
|
|
use std::rc::Rc;
|
|
|
|
pub fn reg_async<F, V, R, RV>(rt: &mut JsRuntime, name: &'static str, op_fn: F)
|
|
where
|
|
F: Fn(Rc<RefCell<OpState>>, V, Option<ZeroCopyBuf>) -> R + 'static,
|
|
V: DeserializeOwned,
|
|
R: Future<Output = Result<RV, AnyError>> + 'static,
|
|
RV: Serialize + 'static,
|
|
{
|
|
rt.register_op(name, metrics_op(name, op_async(op_fn)));
|
|
}
|
|
|
|
pub fn reg_sync<F, V, R>(rt: &mut JsRuntime, name: &'static str, op_fn: F)
|
|
where
|
|
F: Fn(&mut OpState, V, Option<ZeroCopyBuf>) -> Result<R, AnyError> + 'static,
|
|
V: DeserializeOwned,
|
|
R: Serialize + 'static,
|
|
{
|
|
rt.register_op(name, metrics_op(name, op_sync(op_fn)));
|
|
}
|
|
|
|
/// `UnstableChecker` is a struct so it can be placed inside `GothamState`;
|
|
/// using type alias for a bool could work, but there's a high chance
|
|
/// that there might be another type alias pointing to a bool, which
|
|
/// would override previously used alias.
|
|
pub struct UnstableChecker {
|
|
pub unstable: bool,
|
|
}
|
|
|
|
impl UnstableChecker {
|
|
/// Quits the process if the --unstable flag was not provided.
|
|
///
|
|
/// This is intentionally a non-recoverable check so that people cannot probe
|
|
/// for unstable APIs from stable programs.
|
|
// NOTE(bartlomieju): keep in sync with `cli/program_state.rs`
|
|
pub fn check_unstable(&self, api_name: &str) {
|
|
if !self.unstable {
|
|
eprintln!(
|
|
"Unstable API '{}'. The --unstable flag must be provided.",
|
|
api_name
|
|
);
|
|
std::process::exit(70);
|
|
}
|
|
}
|
|
}
|
|
/// Helper for checking unstable features. Used for sync ops.
|
|
pub fn check_unstable(state: &OpState, api_name: &str) {
|
|
state.borrow::<UnstableChecker>().check_unstable(api_name)
|
|
}
|
|
|
|
/// Helper for checking unstable features. Used for async ops.
|
|
pub fn check_unstable2(state: &Rc<RefCell<OpState>>, api_name: &str) {
|
|
let state = state.borrow();
|
|
state.borrow::<UnstableChecker>().check_unstable(api_name)
|
|
}
|