1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-11-01 09:24:20 -04:00
denoland-deno/op_crates/fetch/lib.rs

304 lines
7.5 KiB
Rust
Raw Normal View History

2020-09-18 09:20:55 -04:00
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
2020-09-18 12:31:30 -04:00
#![deny(warnings)]
2020-09-18 09:20:55 -04:00
use deno_core::error::bad_resource_id;
use deno_core::error::type_error;
use deno_core::error::AnyError;
use deno_core::serde_json;
use deno_core::serde_json::json;
use deno_core::serde_json::Value;
use deno_core::url::Url;
use deno_core::AsyncRefCell;
2020-09-18 09:20:55 -04:00
use deno_core::BufVec;
use deno_core::CancelFuture;
use deno_core::CancelHandle;
2020-09-18 09:20:55 -04:00
use deno_core::JsRuntime;
use deno_core::OpState;
use deno_core::RcRef;
use deno_core::Resource;
2020-09-18 09:20:55 -04:00
use deno_core::ZeroCopyBuf;
2020-09-18 12:31:30 -04:00
2020-09-18 09:20:55 -04:00
use reqwest::header::HeaderName;
use reqwest::header::HeaderValue;
use reqwest::redirect::Policy;
use reqwest::Client;
use reqwest::Method;
use reqwest::Response;
use serde::Deserialize;
use std::borrow::Cow;
2020-09-18 09:20:55 -04:00
use std::cell::RefCell;
use std::convert::From;
use std::fs::File;
use std::io::Read;
use std::path::PathBuf;
use std::rc::Rc;
2020-09-18 12:31:30 -04:00
pub use reqwest; // Re-export reqwest
/// Execute this crates' JS source files.
2020-09-18 09:20:55 -04:00
pub fn init(isolate: &mut JsRuntime) {
let files = vec![
(
"deno:op_crates/fetch/01_fetch_util.js",
include_str!("01_fetch_util.js"),
),
(
"deno:op_crates/fetch/03_dom_iterable.js",
include_str!("03_dom_iterable.js"),
),
(
"deno:op_crates/fetch/11_streams.js",
include_str!("11_streams.js"),
),
(
"deno:op_crates/fetch/20_headers.js",
include_str!("20_headers.js"),
),
(
"deno:op_crates/fetch/26_fetch.js",
include_str!("26_fetch.js"),
),
2020-09-18 09:20:55 -04:00
];
for (url, source_code) in files {
isolate.execute(url, source_code).unwrap();
2020-09-18 09:20:55 -04:00
}
}
pub trait FetchPermissions {
fn check_net_url(&self, _url: &Url) -> Result<(), AnyError>;
fn check_read(&self, _p: &PathBuf) -> Result<(), AnyError>;
}
/// For use with `op_fetch` when the user does not want permissions.
pub struct NoFetchPermissions;
impl FetchPermissions for NoFetchPermissions {
fn check_net_url(&self, _url: &Url) -> Result<(), AnyError> {
Ok(())
}
fn check_read(&self, _p: &PathBuf) -> Result<(), AnyError> {
Ok(())
}
2020-09-18 09:20:55 -04:00
}
pub fn get_declaration() -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("lib.deno_fetch.d.ts")
}
pub async fn op_fetch<FP>(
state: Rc<RefCell<OpState>>,
args: Value,
data: BufVec,
) -> Result<Value, AnyError>
where
FP: FetchPermissions + 'static,
{
2020-09-18 12:31:30 -04:00
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct FetchArgs {
method: Option<String>,
url: String,
headers: Vec<(String, String)>,
client_rid: Option<u32>,
}
2020-09-18 09:20:55 -04:00
let args: FetchArgs = serde_json::from_value(args)?;
let url = args.url;
let client = if let Some(rid) = args.client_rid {
let state_ = state.borrow();
let r = state_
.resource_table
.get::<HttpClientResource>(rid)
.ok_or_else(bad_resource_id)?;
r.client.clone()
} else {
let state_ = state.borrow();
let client = state_.borrow::<reqwest::Client>();
client.clone()
};
let method = match args.method {
Some(method_str) => Method::from_bytes(method_str.as_bytes())?,
None => Method::GET,
};
let url_ = Url::parse(&url)?;
2020-09-18 09:20:55 -04:00
// Check scheme before asking for net permission
let scheme = url_.scheme();
if scheme != "http" && scheme != "https" {
return Err(type_error(format!("scheme '{}' not supported", scheme)));
}
{
let state_ = state.borrow();
let permissions = state_.borrow::<FP>();
2020-09-18 09:20:55 -04:00
permissions.check_net_url(&url_)?;
}
let mut request = client.request(method, url_);
match data.len() {
0 => {}
1 => request = request.body(Vec::from(&*data[0])),
_ => panic!("Invalid number of arguments"),
}
for (key, value) in args.headers {
let name = HeaderName::from_bytes(key.as_bytes()).unwrap();
let v = HeaderValue::from_str(&value).unwrap();
request = request.header(name, v);
}
//debug!("Before fetch {}", url);
let res = match request.send().await {
Ok(res) => res,
Err(e) => return Err(type_error(e.to_string())),
};
2020-09-18 09:20:55 -04:00
//debug!("Fetch response {}", url);
let status = res.status();
let mut res_headers = Vec::new();
for (key, val) in res.headers().iter() {
let key_string = key.to_string();
if val.as_bytes().is_ascii() {
res_headers.push((key_string, val.to_str().unwrap().to_owned()))
} else {
res_headers.push((
key_string,
val
.as_bytes()
.iter()
.map(|&c| c as char)
.collect::<String>(),
));
}
2020-09-18 09:20:55 -04:00
}
let rid = state.borrow_mut().resource_table.add(HttpBodyResource {
response: AsyncRefCell::new(res),
cancel: Default::default(),
});
2020-09-18 09:20:55 -04:00
Ok(json!({
"bodyRid": rid,
"status": status.as_u16(),
"statusText": status.canonical_reason().unwrap_or(""),
"headers": res_headers
}))
}
pub async fn op_fetch_read(
state: Rc<RefCell<OpState>>,
args: Value,
_data: BufVec,
) -> Result<Value, AnyError> {
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct Args {
rid: u32,
}
let args: Args = serde_json::from_value(args)?;
let rid = args.rid;
let resource = state
.borrow()
.resource_table
.get::<HttpBodyResource>(rid as u32)
.ok_or_else(bad_resource_id)?;
let mut response = RcRef::map(&resource, |r| &r.response).borrow_mut().await;
let cancel = RcRef::map(resource, |r| &r.cancel);
let maybe_chunk = response.chunk().or_cancel(cancel).await??;
if let Some(chunk) = maybe_chunk {
// TODO(ry) This is terribly inefficient. Make this zero-copy.
Ok(json!({ "chunk": &*chunk }))
} else {
Ok(json!({ "chunk": null }))
}
}
2020-09-18 09:20:55 -04:00
struct HttpBodyResource {
response: AsyncRefCell<Response>,
cancel: CancelHandle,
}
impl Resource for HttpBodyResource {
fn name(&self) -> Cow<str> {
"httpBody".into()
}
2020-09-18 09:20:55 -04:00
}
struct HttpClientResource {
client: Client,
}
impl Resource for HttpClientResource {
fn name(&self) -> Cow<str> {
"httpClient".into()
}
}
2020-09-18 09:20:55 -04:00
impl HttpClientResource {
fn new(client: Client) -> Self {
Self { client }
}
}
pub fn op_create_http_client<FP>(
state: &mut OpState,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
) -> Result<Value, AnyError>
where
FP: FetchPermissions + 'static,
{
#[derive(Deserialize, Default, Debug)]
#[serde(rename_all = "camelCase")]
#[serde(default)]
struct CreateHttpClientOptions {
ca_file: Option<String>,
ca_data: Option<String>,
2020-09-18 09:20:55 -04:00
}
let args: CreateHttpClientOptions = serde_json::from_value(args)?;
if let Some(ca_file) = args.ca_file.clone() {
let permissions = state.borrow::<FP>();
2020-09-18 09:20:55 -04:00
permissions.check_read(&PathBuf::from(ca_file))?;
}
let client =
create_http_client(args.ca_file.as_deref(), args.ca_data.as_deref())
.unwrap();
2020-09-18 09:20:55 -04:00
let rid = state.resource_table.add(HttpClientResource::new(client));
2020-09-18 09:20:55 -04:00
Ok(json!(rid))
}
/// Create new instance of async reqwest::Client. This client supports
/// proxies and doesn't follow redirects.
fn create_http_client(
ca_file: Option<&str>,
ca_data: Option<&str>,
) -> Result<Client, AnyError> {
2020-09-18 12:31:30 -04:00
let mut builder = Client::builder().redirect(Policy::none()).use_rustls_tls();
if let Some(ca_data) = ca_data {
let ca_data_vec = ca_data.as_bytes().to_vec();
let cert = reqwest::Certificate::from_pem(&ca_data_vec)?;
builder = builder.add_root_certificate(cert);
} else if let Some(ca_file) = ca_file {
2020-09-18 09:20:55 -04:00
let mut buf = Vec::new();
File::open(ca_file)?.read_to_end(&mut buf)?;
let cert = reqwest::Certificate::from_pem(&buf)?;
builder = builder.add_root_certificate(cert);
}
builder
.build()
.map_err(|_| deno_core::error::generic_error("Unable to build http client"))
}