Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-06 16:45:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

Move code related to json packet reading to JsonPacketSender trait

Browse source 
fixup! Move code related to json packet reading to JsonPacketSender trait
This commit is contained in:
thiagopnts 2014-11-10 22:55:41 -02:00
parent f0184a2d01
commit 4c1a89544e
6 changed files with 41 additions and 39 deletions
Download patch file Download diff file Expand all files Collapse all files

2
components/devtools/actors/console.rs
View file

@ -7,7 +7,7 @@
/// inspection, JS evaluation, autocompletion) in Servo.
use actor::{Actor, ActorRegistry};
use protocol::JsonPacketSender;
use protocol::JsonPacketStream;
use devtools_traits::{EvaluateJS, NullValue, VoidValue, NumberValue, StringValue, BooleanValue};
use devtools_traits::{ActorValue, DevtoolScriptControlMsg};

2
components/devtools/actors/inspector.rs
View file

@ -8,7 +8,7 @@ use devtools_traits::{GetRootNode, GetDocumentElement, GetChildren, DevtoolScrip
use devtools_traits::{GetLayout, NodeInfo};
use actor::{Actor, ActorRegistry};
use protocol::JsonPacketSender;
use protocol::JsonPacketStream;
use collections::TreeMap;
use servo_msg::constellation_msg::PipelineId;

2
components/devtools/actors/root.rs
View file

@ -8,7 +8,7 @@
use actor::{Actor, ActorRegistry};
use actors::tab::{TabActor, TabActorMsg};
use protocol::JsonPacketSender;
use protocol::JsonPacketStream;
use serialize::json;
use std::io::TcpStream;

2
components/devtools/actors/tab.rs
View file

@ -7,7 +7,7 @@
/// Supports dynamic attaching and detaching which control notifications of navigation, etc.
use actor::{Actor, ActorRegistry};
use protocol::JsonPacketSender;
use protocol::JsonPacketStream;
use serialize::json;
use std::io::TcpStream;

41
components/devtools/lib.rs
View file

@ -34,7 +34,7 @@ use actors::console::ConsoleActor;
use actors::inspector::InspectorActor;
use actors::root::RootActor;
use actors::tab::TabActor;
use protocol::JsonPacketSender;
use protocol::JsonPacketStream;
use devtools_traits::{ServerExitMsg, DevtoolsControlMsg, NewGlobal, DevtoolScriptControlMsg};
use servo_msg::constellation_msg::PipelineId;
@ -44,9 +44,7 @@ use std::cell::RefCell;
use std::comm;
use std::comm::{Disconnected, Empty};
use std::io::{TcpListener, TcpStream};
use std::io::{Acceptor, Listener, EndOfFile, TimedOut};
use std::num;
use serialize::json;
use std::io::{Acceptor, Listener, TimedOut};
use sync::{Arc, Mutex};
mod actor;
@ -91,41 +89,20 @@ fn run_server(receiver: Receiver<DevtoolsControlMsg>, port: u16) {
/// Process the input from a single devtools client until EOF.
fn handle_client(actors: Arc<Mutex<ActorRegistry>>, mut stream: TcpStream) {
println!("connection established to {:?}", stream.peer_name().unwrap());
{
let mut actors = actors.lock();
let msg = actors.find::<RootActor>("root").encodable();
stream.write_json_packet(&msg);
}
// https://wiki.mozilla.org/Remote_Debugging_Protocol_Stream_Transport
// In short, each JSON packet is [ascii length]:[JSON data of given length]
// TODO: this really belongs in the protocol module.
'outer: loop {
let mut buffer = vec!();
loop {
let colon = ':' as u8;
match stream.read_byte() {
Ok(c) if c != colon => buffer.push(c as u8),
Ok(_) => {
let packet_len_str = String::from_utf8(buffer).unwrap();
let packet_len = num::from_str_radix(packet_len_str.as_slice(), 10).unwrap();
let packet_buf = stream.read_exact(packet_len).unwrap();
let packet = String::from_utf8(packet_buf).unwrap();
println!("{:s}", packet);
let json_packet = json::from_str(packet.as_slice()).unwrap();
actors.lock().handle_message(json_packet.as_object().unwrap(),
&mut stream);
break;
}
Err(ref e) if e.kind == EndOfFile => {
println!("\nEOF");
break 'outer;
},
_ => {
println!("\nconnection error");
break 'outer;
}
match stream.read_json_packet() {
Ok(json_packet) =>
actors.lock().handle_message(json_packet.as_object().unwrap(),
&mut stream),
Err(e) => {
println!("error: {}", e.desc);
break 'outer
}
}
}

31
components/devtools/protocol.rs
View file

@ -5,13 +5,15 @@
/// Low-level wire protocol implementation. Currently only supports [JSON packets](https://wiki.mozilla.org/Remote_Debugging_Protocol_Stream_Transport#JSON_Packets).
use serialize::{json, Encodable};
use std::io::{IoError, TcpStream};
use std::io::{IoError, OtherIoError, EndOfFile, TcpStream, IoResult};
use std::num;
pub trait JsonPacketSender {
pub trait JsonPacketStream {
fn write_json_packet<'a, T: Encodable<json::Encoder<'a>,IoError>>(&mut self, obj: &T);
fn read_json_packet(&mut self) -> IoResult<json::Json>;
}
impl JsonPacketSender for TcpStream {
impl JsonPacketStream for TcpStream {
fn write_json_packet<'a, T: Encodable<json::Encoder<'a>,IoError>>(&mut self, obj: &T) {
let s = json::encode(obj).replace("__type__", "type");
println!("<- {:s}", s);
@ -19,4 +21,27 @@ impl JsonPacketSender for TcpStream {
self.write_u8(':' as u8).unwrap();
self.write_str(s.as_slice()).unwrap();
}
fn read_json_packet<'a>(&mut self) -> IoResult<json::Json> {
// https://wiki.mozilla.org/Remote_Debugging_Protocol_Stream_Transport
// In short, each JSON packet is [ascii length]:[JSON data of given length]
let mut buffer = vec!();
loop {
let colon = ':' as u8;
match self.read_byte() {
Ok(c) if c != colon => buffer.push(c as u8),
Ok(_) => {
let packet_len_str = String::from_utf8(buffer).unwrap();
let packet_len = num::from_str_radix(packet_len_str.as_slice(), 10).unwrap();
let packet_buf = self.read_exact(packet_len).unwrap();
let packet = String::from_utf8(packet_buf).unwrap();
println!("{:s}", packet);
return Ok(json::from_str(packet.as_slice()).unwrap())
},
Err(ref e) if e.kind == EndOfFile =>
return Err(IoError { kind: EndOfFile, desc: "EOF", detail: None }),
_ => return Err(IoError { kind: OtherIoError, desc: "connection error", detail: None })
}
}
}
}