Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-09-30 00:29:14 +01:00
Code Issues Projects Releases Packages Wiki Activity

script: Make the resource task communication use IPC channels.

Browse source
This commit is contained in:
Patrick Walton 2015-07-09 17:16:21 -07:00
parent 44d13f7fd4
commit 2aa5174246
35 changed files with 234 additions and 458 deletions
Download patch file Download diff file Expand all files Collapse all files

6
components/net/Cargo.toml
View file

@ -27,9 +27,12 @@ features = [ "serde-serialization" ]
[dependencies.ipc-channel]
git = "https://github.com/pcwalton/ipc-channel"
[dependencies.url]
version = "0.2"
features = [ "serde_serialization" ]
[dependencies]
log = "0.3"
url = "0.2.36"
time = "0.1.17"
openssl="0.6.1"
rustc-serialize = "0.3"
@ -39,3 +42,4 @@ regex_macros = "0.1.8"
flate2 = "0.2.0"
uuid = "0.1.16"
euclid = "0.1"

17
components/net/about_loader.rs
View file

@ -2,8 +2,7 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use net_traits::{LoadData, Metadata, LoadConsumer, SerializableContentType, SerializableRawStatus};
use net_traits::{SerializableStringResult, SerializableUrl};
use net_traits::{LoadData, Metadata, LoadConsumer};
use net_traits::ProgressMsg::Done;
use mime_classifier::MIMEClassifier;
use resource_task::start_sending;
@ -23,14 +22,12 @@ pub fn factory(mut load_data: LoadData, start_chan: LoadConsumer, classifier: Ar
"blank" => {
let chan = start_sending(start_chan, Metadata {
final_url: load_data.url,
content_type: Some(SerializableContentType(ContentType(Mime(TopLevel::Text,
SubLevel::Html,
vec![])))),
content_type: Some(ContentType(Mime(TopLevel::Text, SubLevel::Html, vec![]))),
charset: Some("utf-8".to_string()),
headers: None,
status: Some(SerializableRawStatus(RawStatus(200, "OK".into()))),
status: Some(RawStatus(200, "OK".into())),
});
chan.send(Done(SerializableStringResult(Ok(())))).unwrap();
chan.send(Done(Ok(()))).unwrap();
return
}
"crash" => panic!("Loading the about:crash URL."),
@ -38,11 +35,11 @@ pub fn factory(mut load_data: LoadData, start_chan: LoadConsumer, classifier: Ar
let mut path = resources_dir_path();
path.push("failure.html");
assert!(path.exists());
load_data.url = SerializableUrl(Url::from_file_path(&*path).unwrap());
load_data.url = Url::from_file_path(&*path).unwrap();
}
_ => {
start_sending(start_chan, Metadata::default(load_data.url.0))
.send(Done(SerializableStringResult(Err("Unknown about: URL.".to_string()))))
start_sending(start_chan, Metadata::default(load_data.url))
.send(Done(Err("Unknown about: URL.".to_string())))
.unwrap();
return
}

17
components/net/data_loader.rs
View file

@ -2,7 +2,7 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use net_traits::{LoadData, Metadata, LoadConsumer, SerializableStringResult};
use net_traits::{LoadData, Metadata, LoadConsumer};
use net_traits::ProgressMsg::{Payload, Done};
use mime_classifier::MIMEClassifier;
use resource_task::start_sending;
@ -26,11 +26,11 @@ pub fn load(load_data: LoadData, start_chan: LoadConsumer) {
let url = load_data.url;
assert!(&*url.scheme == "data");
let mut metadata = Metadata::default((*url).clone());
let mut metadata = Metadata::default(url.clone());
// Split out content type and data.
let mut scheme_data = match url.scheme_data {
SchemeData::NonRelative(ref scheme_data) => (*scheme_data).clone(),
SchemeData::NonRelative(scheme_data) => scheme_data,
_ => panic!("Expected a non-relative scheme URL.")
};
match url.query {
@ -42,8 +42,8 @@ pub fn load(load_data: LoadData, start_chan: LoadConsumer) {
}
let parts: Vec<&str> = scheme_data.splitn(2, ',').collect();
if parts.len() != 2 {
start_sending(start_chan, metadata).send(Done(SerializableStringResult(Err(
"invalid data uri".to_string())))).unwrap();
start_sending(start_chan,
metadata).send(Done(Err("invalid data uri".to_string()))).unwrap();
return;
}
@ -70,16 +70,15 @@ pub fn load(load_data: LoadData, start_chan: LoadConsumer) {
let bytes = bytes.into_iter().filter(|&b| b != ' ' as u8).collect::<Vec<u8>>();
match bytes.from_base64() {
Err(..) => {
progress_chan.send(Done(SerializableStringResult(Err(
"non-base64 data uri".to_string())))).unwrap();
progress_chan.send(Done(Err("non-base64 data uri".to_string()))).unwrap();
}
Ok(data) => {
progress_chan.send(Payload(data)).unwrap();
progress_chan.send(Done(SerializableStringResult(Ok(())))).unwrap();
progress_chan.send(Done(Ok(()))).unwrap();
}
}
} else {
progress_chan.send(Payload(bytes)).unwrap();
progress_chan.send(Done(SerializableStringResult(Ok(())))).unwrap();
progress_chan.send(Done(Ok(()))).unwrap();
}
}

12
components/net/file_loader.rs
View file

@ -2,7 +2,7 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use net_traits::{LoadData, Metadata, LoadConsumer, SerializableStringResult};
use net_traits::{LoadData, Metadata, LoadConsumer};
use net_traits::ProgressMsg::{Payload, Done};
use mime_classifier::MIMEClassifier;
use resource_task::{start_sending, start_sending_sniffed, ProgressSender};
@ -48,7 +48,7 @@ pub fn factory(load_data: LoadData, senders: LoadConsumer, classifier: Arc<MIMEC
let url = load_data.url;
assert!(&*url.scheme == "file");
spawn_named("file_loader".to_owned(), move || {
let metadata = Metadata::default(url.0.clone());
let metadata = Metadata::default(url.clone());
let file_path: Result<PathBuf, ()> = url.to_file_path();
match file_path {
Ok(file_path) => {
@ -65,19 +65,17 @@ pub fn factory(load_data: LoadData, senders: LoadConsumer, classifier: Arc<MIMEC
Ok(ReadStatus::EOF) | Err(_) =>
(res.map(|_| ()), start_sending(senders, metadata)),
};
progress_chan.send(Done(SerializableStringResult(res))).unwrap();
progress_chan.send(Done(res)).unwrap();
}
Err(e) => {
let progress_chan = start_sending(senders, metadata);
progress_chan.send(Done(SerializableStringResult(Err(e.description()
.to_string()))))
.unwrap();
progress_chan.send(Done(Err(e.description().to_string()))).unwrap();
}
}
}
Err(_) => {
let progress_chan = start_sending(senders, metadata);
progress_chan.send(Done(SerializableStringResult(Err(url.to_string())))).unwrap();
progress_chan.send(Done(Err(url.to_string()))).unwrap();
}
}
});

49
components/net/http_loader.rs
View file

@ -2,15 +2,14 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use net_traits::{ControlMsg, CookieSource, LoadData, Metadata, LoadConsumer, SerializableMethod};
use net_traits::{SerializableHeaders, SerializableRawStatus, SerializableStringResult};
use net_traits::{SerializableUrl};
use net_traits::{ControlMsg, CookieSource, LoadData, Metadata, LoadConsumer};
use net_traits::ProgressMsg::{Payload, Done};
use devtools_traits::{ChromeToDevtoolsControlMsg, DevtoolsControlMsg, NetworkEvent};
use mime_classifier::MIMEClassifier;
use resource_task::{start_sending_opt, start_sending_sniffed_opt};
use hsts::{HSTSList, secure_url};
use ipc_channel::ipc::{self, IpcSender};
use log;
use std::collections::HashSet;
use file_loader;
@ -38,7 +37,7 @@ use uuid;
use std::borrow::ToOwned;
use std::boxed::FnBox;
pub fn factory(cookies_chan: Sender<ControlMsg>,
pub fn factory(cookies_chan: IpcSender<ControlMsg>,
devtools_chan: Option<Sender<DevtoolsControlMsg>>,
hsts_list: Arc<Mutex<HSTSList>>)
-> Box<FnBox(LoadData, LoadConsumer, Arc<MIMEClassifier>) + Send> {
@ -53,7 +52,7 @@ fn send_error(url: Url, err: String, start_chan: LoadConsumer) {
metadata.status = None;
match start_sending_opt(start_chan, metadata) {
Ok(p) => p.send(Done(SerializableStringResult(Err(err)))).unwrap(),
Ok(p) => p.send(Done(Err(err))).unwrap(),
_ => {}
};
}
@ -88,7 +87,7 @@ fn request_must_be_secured(hsts_list: &HSTSList, url: &Url) -> bool {
fn load(mut load_data: LoadData,
start_chan: LoadConsumer,
classifier: Arc<MIMEClassifier>,
cookies_chan: Sender<ControlMsg>,
cookies_chan: IpcSender<ControlMsg>,
devtools_chan: Option<Sender<DevtoolsControlMsg>>,
hsts_list: Arc<Mutex<HSTSList>>) {
// FIXME: At the time of writing this FIXME, servo didn't have any central
@ -96,7 +95,7 @@ fn load(mut load_data: LoadData,
// repository DOES exist, please update this constant to use it.
let max_redirects = 50;
let mut iters = 0;
let mut url = load_data.url.0.clone();
let mut url = load_data.url.clone();
let mut redirected_to = HashSet::new();
// If the URL is a view-source scheme then the scheme data contains the
@ -156,9 +155,7 @@ reason: \"certificate verify failed\" }]))";
&HttpsConnector::new(Openssl { context: Arc::new(context) }))
};
let mut req = match Request::with_connector(load_data.method.0.clone(),
url.clone(),
&mut connector) {
let mut req = match req {
Ok(req) => req,
Err(HttpError::Io(ref io_error)) if (
io_error.kind() == io::ErrorKind::Other &&
@ -187,11 +184,11 @@ reason: \"certificate verify failed\" }]))";
// https://bugzilla.mozilla.org/show_bug.cgi?id=216828 .
// Only preserve ones which have been explicitly marked as such.
if iters == 1 {
let mut combined_headers = (*load_data.headers).clone();
let mut combined_headers = load_data.headers.clone();
combined_headers.extend(load_data.preserved_headers.iter());
*req.headers_mut() = combined_headers;
} else {
*req.headers_mut() = (*load_data.preserved_headers).clone();
*req.headers_mut() = load_data.preserved_headers.clone();
}
req.headers_mut().set(host);
@ -206,8 +203,8 @@ reason: \"certificate verify failed\" }]))";
req.headers_mut().set(accept);
}
let (tx, rx) = channel();
cookies_chan.send(ControlMsg::GetCookiesForUrl(SerializableUrl(url.clone()),
let (tx, rx) = ipc::channel().unwrap();
cookies_chan.send(ControlMsg::GetCookiesForUrl(url.clone(),
tx,
CookieSource::HTTP)).unwrap();
if let Some(cookie_list) = rx.recv().unwrap() {
@ -220,7 +217,7 @@ reason: \"certificate verify failed\" }]))";
req.headers_mut().set_raw("Accept-Encoding".to_owned(), vec![b"gzip, deflate".to_vec()]);
}
if log_enabled!(log::LogLevel::Info) {
info!("{}", load_data.method.0);
info!("{}", load_data.method);
for header in req.headers().iter() {
info!(" - {}", header);
}
@ -248,7 +245,7 @@ reason: \"certificate verify failed\" }]))";
writer
},
_ => {
match *load_data.method {
match load_data.method {
Method::Get | Method::Head => (),
_ => req.headers_mut().set(ContentLength(0))
}
@ -266,9 +263,9 @@ reason: \"certificate verify failed\" }]))";
// TODO: Do this only if load_data has some pipeline_id, and send the pipeline_id in the message
let request_id = uuid::Uuid::new_v4().to_simple_string();
if let Some(ref chan) = devtools_chan {
let net_event = NetworkEvent::HttpRequest((*load_data.url).clone(),
(*load_data.method).clone(),
(*load_data.headers).clone(),
let net_event = NetworkEvent::HttpRequest(load_data.url.clone(),
load_data.method.clone(),
load_data.headers.clone(),
load_data.data.clone());
chan.send(DevtoolsControlMsg::FromChrome(
ChromeToDevtoolsControlMsg::NetworkEventMessage(request_id.clone(),
@ -294,7 +291,7 @@ reason: \"certificate verify failed\" }]))";
if let Some(cookies) = response.headers.get_raw("set-cookie") {
for cookie in cookies.iter() {
if let Ok(cookies) = String::from_utf8(cookie.clone()) {
cookies_chan.send(ControlMsg::SetCookiesForUrl(SerializableUrl(url.clone()),
cookies_chan.send(ControlMsg::SetCookiesForUrl(url.clone(),
cookies,
CookieSource::HTTP)).unwrap();
}
@ -332,10 +329,10 @@ reason: \"certificate verify failed\" }]))";
// According to https://tools.ietf.org/html/rfc7231#section-6.4.2,
// historically UAs have rewritten POST->GET on 301 and 302 responses.
if *load_data.method == Method::Post &&
if load_data.method == Method::Post &&
(response.status == StatusCode::MovedPermanently ||
response.status == StatusCode::Found) {
load_data.method = SerializableMethod(Method::Get);
load_data.method = Method::Get;
}
if redirected_to.contains(&url) {
@ -359,8 +356,8 @@ reason: \"certificate verify failed\" }]))";
Some(&ContentType(ref mime)) => Some(mime),
None => None
});
metadata.headers = Some(SerializableHeaders(adjusted_headers));
metadata.status = Some(SerializableRawStatus(response.status_raw().clone()));
metadata.headers = Some(adjusted_headers);
metadata.status = Some(response.status_raw().clone());
let mut encoding_str: Option<String> = None;
//FIXME: Implement Content-Encoding Header https://github.com/hyperium/hyper/issues/391
@ -396,7 +393,7 @@ reason: \"certificate verify failed\" }]))";
send_data(&mut response_decoding, start_chan, metadata, classifier);
}
Err(err) => {
send_error((*metadata.final_url).clone(), err.to_string(), start_chan);
send_error(metadata.final_url, err.to_string(), start_chan);
return;
}
}
@ -445,5 +442,5 @@ fn send_data<R: Read>(reader: &mut R,
};
}
let _ = progress_chan.send(Done(SerializableStringResult(Ok(()))));
let _ = progress_chan.send(Done(Ok(())));
}

43
components/net/image_cache_task.rs
View file

@ -14,7 +14,6 @@ use std::collections::hash_map::Entry::{Occupied, Vacant};
use std::mem;
use std::sync::Arc;
use std::sync::mpsc::{channel, Sender, Receiver, Select};
use std::thread;
use util::resource_files::resources_dir_path;
use util::task::spawn_named;
use util::taskpool::TaskPool;
@ -98,23 +97,6 @@ struct ResourceLoadInfo {
url: Url,
}
struct ResourceListener {
url: Url,
sender: Sender<ResourceLoadInfo>,
receiver: Receiver<ResponseAction>,
}
impl ResourceListener {
fn run(&self) {
while let Ok(action) = self.receiver.recv() {
self.sender.send(ResourceLoadInfo {
action: action,
url: self.url.clone(),
}).unwrap();
}
}
}
/// Implementation of the image cache
struct ImageCache {
// Receive commands from clients
@ -252,10 +234,10 @@ impl ImageCache {
pending_load.bytes.push_all(&data);
}
ResponseAction::ResponseComplete(result) => {
match *result {
match result {
Ok(()) => {
let pending_load = self.pending_loads.get_mut(&msg.url).unwrap();
pending_load.result = Some((*result).clone());
pending_load.result = Some(result);
let bytes = mem::replace(&mut pending_load.bytes, vec!());
let url = msg.url.clone();
@ -334,17 +316,20 @@ impl ImageCache {
e.insert(pending_load);
let load_data = LoadData::new(url.clone(), None);
let (action_sender, action_receiver) = channel();
let listener = box ResourceListener {
url: url,
sender: self.progress_sender.clone(),
receiver: action_receiver,
let (action_sender, action_receiver) = ipc::channel().unwrap();
let response_target = AsyncResponseTarget {
sender: action_sender,
};
let msg = ControlMsg::Load(load_data,
LoadConsumer::Listener(AsyncResponseTarget {
sender: action_sender,
}));
thread::spawn(move || listener.run());
LoadConsumer::Listener(response_target));
let progress_sender = self.progress_sender.clone();
ROUTER.add_route(action_receiver.to_opaque(), box move |message| {
let action: ResponseAction = message.to().unwrap();
progress_sender.send(ResourceLoadInfo {
action: action,
url: url.clone(),
}).unwrap();
});
self.resource_task.send(msg).unwrap();
}
}

35
components/net/resource_task.rs
View file

@ -12,9 +12,8 @@ use cookie_storage::CookieStorage;
use cookie;
use mime_classifier::MIMEClassifier;
use net_traits::{ControlMsg, LoadData, LoadResponse, LoadConsumer};
use net_traits::{ControlMsg, LoadData, LoadResponse, LoadConsumer, CookieSource};
use net_traits::{Metadata, ProgressMsg, ResourceTask, AsyncResponseTarget, ResponseAction};
use net_traits::{CookieSource, SerializableContentType, SerializableStringResult};
use net_traits::ProgressMsg::Done;
use util::opts;
use util::task::spawn_named;
@ -25,6 +24,7 @@ use hsts::{HSTSList, HSTSEntry, preload_hsts_domains};
use devtools_traits::{DevtoolsControlMsg};
use hyper::header::{ContentType, Header, SetCookie, UserAgent};
use hyper::mime::{Mime, TopLevel, SubLevel};
use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
use regex::Regex;
use std::borrow::ToOwned;
@ -35,7 +35,7 @@ use std::fs::File;
use std::io::{BufReader, Read};
use std::sync::Arc;
use std::sync::Mutex;
use std::sync::mpsc::{channel, Receiver, Sender};
use std::sync::mpsc::{channel, Sender};
static mut HOST_TABLE: Option<*mut HashMap<String, String>> = None;
pub static IPV4_REGEX: Regex = regex!(
@ -68,7 +68,7 @@ pub fn global_init() {
}
pub enum ProgressSender {
Channel(Sender<ProgressMsg>),
Channel(IpcSender<ProgressMsg>),
Listener(AsyncResponseTarget),
}
@ -126,16 +126,14 @@ pub fn start_sending_sniffed_opt(start_chan: LoadConsumer, mut metadata: Metadat
}
let supplied_type =
metadata.content_type.map(|SerializableContentType(ContentType(Mime(toplevel,
sublevel,
_)))| {
metadata.content_type.map(|ContentType(Mime(toplevel, sublevel, _))| {
(format!("{}", toplevel), format!("{}", sublevel))
});
metadata.content_type = classifier.classify(nosniff, check_for_apache_bug, &supplied_type,
&partial_body).map(|(toplevel, sublevel)| {
let mime_tp: TopLevel = toplevel.parse().unwrap();
let mime_sb: SubLevel = sublevel.parse().unwrap();
SerializableContentType(ContentType(Mime(mime_tp, mime_sb, vec!())))
ContentType(Mime(mime_tp, mime_sb, vec!()))
});
}
@ -147,7 +145,7 @@ pub fn start_sending_sniffed_opt(start_chan: LoadConsumer, mut metadata: Metadat
pub fn start_sending_opt(start_chan: LoadConsumer, metadata: Metadata) -> Result<ProgressSender, ()> {
match start_chan {
LoadConsumer::Channel(start_chan) => {
let (progress_chan, progress_port) = channel();
let (progress_chan, progress_port) = ipc::channel().unwrap();
let result = start_chan.send(LoadResponse {
metadata: metadata,
progress_port: progress_port,
@ -172,7 +170,7 @@ pub fn new_resource_task(user_agent: Option<String>,
None => HSTSList::new()
};
let (setup_chan, setup_port) = channel();
let (setup_chan, setup_port) = ipc::channel().unwrap();
let setup_chan_clone = setup_chan.clone();
spawn_named("ResourceManager".to_owned(), move || {
let resource_manager = ResourceManager::new(
@ -222,7 +220,7 @@ pub fn replace_hosts(mut load_data: LoadData, host_table: *mut HashMap<String, S
}
struct ResourceChannelManager {
from_client: Receiver<ControlMsg>,
from_client: IpcReceiver<ControlMsg>,
resource_manager: ResourceManager
}
@ -252,19 +250,18 @@ impl ResourceChannelManager {
}
}
pub struct ResourceManager {
struct ResourceManager {
user_agent: Option<String>,
cookie_storage: CookieStorage,
// TODO: Can this be de-coupled?
resource_task: Sender<ControlMsg>,
resource_task: IpcSender<ControlMsg>,
mime_classifier: Arc<MIMEClassifier>,
devtools_chan: Option<Sender<DevtoolsControlMsg>>,
hsts_list: Arc<Mutex<HSTSList>>
}
impl ResourceManager {
pub fn new(user_agent: Option<String>,
resource_task: Sender<ControlMsg>,
fn new(user_agent: Option<String>,
resource_task: IpcSender<ControlMsg>,
hsts_list: HSTSList,
devtools_channel: Option<Sender<DevtoolsControlMsg>>) -> ResourceManager {
ResourceManager {
@ -278,7 +275,6 @@ impl ResourceManager {
}
}
impl ResourceManager {
fn set_cookies_for_url(&mut self, request: Url, cookie_list: String, source: CookieSource) {
let header = Header::parse_header(&[cookie_list.into_bytes()]);
@ -325,9 +321,8 @@ impl ResourceManager {
"about" => from_factory(about_loader::factory),
_ => {
debug!("resource_task: no loader for scheme {}", load_data.url.scheme);
start_sending(consumer, Metadata::default((*load_data.url).clone()))
.send(ProgressMsg::Done(SerializableStringResult(Err(
"no loader for scheme".to_string())))).unwrap();
start_sending(consumer, Metadata::default(load_data.url))
.send(ProgressMsg::Done(Err("no loader for scheme".to_string()))).unwrap();
return
}
};