Reformat the source code
This commit is contained in:
Artem Vorotnikov
@@ -30,10 +30,10 @@ extern crate panic_hook;
|
||||
extern crate parity_whisper as whisper;
|
||||
extern crate serde;
|
||||
|
||||
extern crate jsonrpc_core;
|
||||
extern crate jsonrpc_pubsub;
|
||||
extern crate jsonrpc_http_server;
|
||||
extern crate ethkey;
|
||||
extern crate jsonrpc_core;
|
||||
extern crate jsonrpc_http_server;
|
||||
extern crate jsonrpc_pubsub;
|
||||
extern crate rustc_hex;
|
||||
|
||||
#[macro_use]
|
||||
@@ -43,14 +43,18 @@ extern crate log as rlog;
|
||||
extern crate serde_derive;
|
||||
|
||||
use docopt::Docopt;
|
||||
use std::{fmt, io, process, env, sync::Arc};
|
||||
use jsonrpc_core::{Metadata, MetaIoHandler};
|
||||
use jsonrpc_pubsub::{PubSubMetadata, Session};
|
||||
use jsonrpc_http_server::{AccessControlAllowOrigin, DomainsValidation};
|
||||
use std::net::{SocketAddr, SocketAddrV4, Ipv4Addr};
|
||||
use std::str::FromStr;
|
||||
use ethkey::Secret;
|
||||
use jsonrpc_core::{MetaIoHandler, Metadata};
|
||||
use jsonrpc_http_server::{AccessControlAllowOrigin, DomainsValidation};
|
||||
use jsonrpc_pubsub::{PubSubMetadata, Session};
|
||||
use rustc_hex::FromHex;
|
||||
use std::{
|
||||
env, fmt, io,
|
||||
net::{Ipv4Addr, SocketAddr, SocketAddrV4},
|
||||
process,
|
||||
str::FromStr,
|
||||
sync::Arc,
|
||||
};
|
||||
|
||||
const POOL_UNIT: usize = 1024 * 1024;
|
||||
const USAGE: &'static str = r#"
|
||||
@@ -78,266 +82,292 @@ struct Meta;
|
||||
impl Metadata for Meta {}
|
||||
|
||||
impl PubSubMetadata for Meta {
|
||||
fn session(&self) -> Option<Arc<Session>> {
|
||||
None
|
||||
}
|
||||
fn session(&self) -> Option<Arc<Session>> {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct Args {
|
||||
flag_whisper_pool_size: usize,
|
||||
flag_port: String,
|
||||
flag_address: String,
|
||||
flag_rpc_port: String,
|
||||
flag_rpc_address: String,
|
||||
flag_log: String,
|
||||
flag_secret: String,
|
||||
flag_whisper_pool_size: usize,
|
||||
flag_port: String,
|
||||
flag_address: String,
|
||||
flag_rpc_port: String,
|
||||
flag_rpc_address: String,
|
||||
flag_log: String,
|
||||
flag_secret: String,
|
||||
}
|
||||
|
||||
struct WhisperPoolHandle {
|
||||
/// Pool handle.
|
||||
handle: Arc<whisper::net::Network<Arc<whisper::rpc::FilterManager>>>,
|
||||
/// Network manager.
|
||||
net: Arc<devp2p::NetworkService>,
|
||||
/// Pool handle.
|
||||
handle: Arc<whisper::net::Network<Arc<whisper::rpc::FilterManager>>>,
|
||||
/// Network manager.
|
||||
net: Arc<devp2p::NetworkService>,
|
||||
}
|
||||
|
||||
impl whisper::rpc::PoolHandle for WhisperPoolHandle {
|
||||
fn relay(&self, message: whisper::message::Message) -> bool {
|
||||
let mut res = false;
|
||||
let mut message = Some(message);
|
||||
self.with_proto_context(whisper::net::PROTOCOL_ID, &mut |ctx| {
|
||||
if let Some(message) = message.take() {
|
||||
res = self.handle.post_message(message, ctx);
|
||||
}
|
||||
});
|
||||
res
|
||||
}
|
||||
fn relay(&self, message: whisper::message::Message) -> bool {
|
||||
let mut res = false;
|
||||
let mut message = Some(message);
|
||||
self.with_proto_context(whisper::net::PROTOCOL_ID, &mut |ctx| {
|
||||
if let Some(message) = message.take() {
|
||||
res = self.handle.post_message(message, ctx);
|
||||
}
|
||||
});
|
||||
res
|
||||
}
|
||||
|
||||
fn pool_status(&self) -> whisper::net::PoolStatus {
|
||||
self.handle.pool_status()
|
||||
}
|
||||
fn pool_status(&self) -> whisper::net::PoolStatus {
|
||||
self.handle.pool_status()
|
||||
}
|
||||
}
|
||||
|
||||
impl WhisperPoolHandle {
|
||||
fn with_proto_context(&self, proto: net::ProtocolId, f: &mut FnMut(&net::NetworkContext)) {
|
||||
self.net.with_context_eval(proto, f);
|
||||
}
|
||||
fn with_proto_context(&self, proto: net::ProtocolId, f: &mut FnMut(&net::NetworkContext)) {
|
||||
self.net.with_context_eval(proto, f);
|
||||
}
|
||||
}
|
||||
|
||||
struct RpcFactory {
|
||||
handle: Arc<whisper::Network<Arc<whisper::rpc::FilterManager>>>,
|
||||
manager: Arc<whisper::rpc::FilterManager>,
|
||||
handle: Arc<whisper::Network<Arc<whisper::rpc::FilterManager>>>,
|
||||
manager: Arc<whisper::rpc::FilterManager>,
|
||||
}
|
||||
|
||||
impl RpcFactory {
|
||||
fn make_handler(&self, net: Arc<devp2p::NetworkService>) -> whisper::rpc::WhisperClient<WhisperPoolHandle, Meta> {
|
||||
let whisper_pool_handle = WhisperPoolHandle { handle: self.handle.clone(), net: net };
|
||||
whisper::rpc::WhisperClient::new(whisper_pool_handle, self.manager.clone())
|
||||
}
|
||||
fn make_handler(
|
||||
&self,
|
||||
net: Arc<devp2p::NetworkService>,
|
||||
) -> whisper::rpc::WhisperClient<WhisperPoolHandle, Meta> {
|
||||
let whisper_pool_handle = WhisperPoolHandle {
|
||||
handle: self.handle.clone(),
|
||||
net: net,
|
||||
};
|
||||
whisper::rpc::WhisperClient::new(whisper_pool_handle, self.manager.clone())
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
enum Error {
|
||||
Docopt(docopt::Error),
|
||||
Io(io::Error),
|
||||
JsonRpc(jsonrpc_core::Error),
|
||||
Network(net::Error),
|
||||
SockAddr(std::net::AddrParseError),
|
||||
FromHex(rustc_hex::FromHexError),
|
||||
ParseInt(std::num::ParseIntError),
|
||||
Docopt(docopt::Error),
|
||||
Io(io::Error),
|
||||
JsonRpc(jsonrpc_core::Error),
|
||||
Network(net::Error),
|
||||
SockAddr(std::net::AddrParseError),
|
||||
FromHex(rustc_hex::FromHexError),
|
||||
ParseInt(std::num::ParseIntError),
|
||||
}
|
||||
|
||||
impl From<std::net::AddrParseError> for Error {
|
||||
fn from(err: std::net::AddrParseError) -> Self {
|
||||
Error::SockAddr(err)
|
||||
}
|
||||
fn from(err: std::net::AddrParseError) -> Self {
|
||||
Error::SockAddr(err)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<net::Error> for Error {
|
||||
fn from(err: net::Error) -> Self {
|
||||
Error::Network(err)
|
||||
}
|
||||
fn from(err: net::Error) -> Self {
|
||||
Error::Network(err)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<docopt::Error> for Error {
|
||||
fn from(err: docopt::Error) -> Self {
|
||||
Error::Docopt(err)
|
||||
}
|
||||
fn from(err: docopt::Error) -> Self {
|
||||
Error::Docopt(err)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<io::Error> for Error {
|
||||
fn from(err: io::Error) -> Self {
|
||||
Error::Io(err)
|
||||
}
|
||||
fn from(err: io::Error) -> Self {
|
||||
Error::Io(err)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<jsonrpc_core::Error> for Error {
|
||||
fn from(err: jsonrpc_core::Error) -> Self {
|
||||
Error::JsonRpc(err)
|
||||
}
|
||||
fn from(err: jsonrpc_core::Error) -> Self {
|
||||
Error::JsonRpc(err)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<rustc_hex::FromHexError> for Error {
|
||||
fn from(err: rustc_hex::FromHexError) -> Self {
|
||||
Error::FromHex(err)
|
||||
}
|
||||
fn from(err: rustc_hex::FromHexError) -> Self {
|
||||
Error::FromHex(err)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<std::num::ParseIntError> for Error {
|
||||
fn from(err: std::num::ParseIntError) -> Self {
|
||||
Error::ParseInt(err)
|
||||
}
|
||||
fn from(err: std::num::ParseIntError) -> Self {
|
||||
Error::ParseInt(err)
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for Error {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
|
||||
match *self {
|
||||
Error::SockAddr(ref e) => write!(f, "{}", e),
|
||||
Error::Docopt(ref e) => write!(f, "{}", e),
|
||||
Error::Io(ref e) => write!(f, "{}", e),
|
||||
Error::JsonRpc(ref e) => write!(f, "{:?}", e),
|
||||
Error::Network(ref e) => write!(f, "{}", e),
|
||||
Error::ParseInt(ref e) => write!(f, "Invalid port: {}", e),
|
||||
Error::FromHex(ref e) => write!(f, "Error deciphering key: {}", e),
|
||||
}
|
||||
}
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
|
||||
match *self {
|
||||
Error::SockAddr(ref e) => write!(f, "{}", e),
|
||||
Error::Docopt(ref e) => write!(f, "{}", e),
|
||||
Error::Io(ref e) => write!(f, "{}", e),
|
||||
Error::JsonRpc(ref e) => write!(f, "{:?}", e),
|
||||
Error::Network(ref e) => write!(f, "{}", e),
|
||||
Error::ParseInt(ref e) => write!(f, "Invalid port: {}", e),
|
||||
Error::FromHex(ref e) => write!(f, "Error deciphering key: {}", e),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
panic_hook::set_abort();
|
||||
panic_hook::set_abort();
|
||||
|
||||
match execute(env::args()) {
|
||||
Ok(_) => {
|
||||
println!("whisper-cli terminated");
|
||||
process::exit(1);
|
||||
},
|
||||
Err(Error::Docopt(ref e)) => e.exit(),
|
||||
Err(err) => {
|
||||
println!("{}", err);
|
||||
process::exit(1);
|
||||
}
|
||||
}
|
||||
match execute(env::args()) {
|
||||
Ok(_) => {
|
||||
println!("whisper-cli terminated");
|
||||
process::exit(1);
|
||||
}
|
||||
Err(Error::Docopt(ref e)) => e.exit(),
|
||||
Err(err) => {
|
||||
println!("{}", err);
|
||||
process::exit(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn execute<S, I>(command: I) -> Result<(), Error> where I: IntoIterator<Item=S>, S: AsRef<str> {
|
||||
fn execute<S, I>(command: I) -> Result<(), Error>
|
||||
where
|
||||
I: IntoIterator<Item = S>,
|
||||
S: AsRef<str>,
|
||||
{
|
||||
// Parse arguments
|
||||
let args: Args = Docopt::new(USAGE).and_then(|d| d.argv(command).deserialize())?;
|
||||
let pool_size = args.flag_whisper_pool_size * POOL_UNIT;
|
||||
let rpc_url = format!("{}:{}", args.flag_rpc_address, args.flag_rpc_port);
|
||||
|
||||
// Parse arguments
|
||||
let args: Args = Docopt::new(USAGE).and_then(|d| d.argv(command).deserialize())?;
|
||||
let pool_size = args.flag_whisper_pool_size * POOL_UNIT;
|
||||
let rpc_url = format!("{}:{}", args.flag_rpc_address, args.flag_rpc_port);
|
||||
initialize_logger(args.flag_log);
|
||||
info!(target: "whisper-cli", "start");
|
||||
|
||||
initialize_logger(args.flag_log);
|
||||
info!(target: "whisper-cli", "start");
|
||||
// Filter manager that will dispatch `decryption tasks`
|
||||
let manager = Arc::new(whisper::rpc::FilterManager::new()?);
|
||||
|
||||
// Filter manager that will dispatch `decryption tasks`
|
||||
let manager = Arc::new(whisper::rpc::FilterManager::new()?);
|
||||
// Whisper protocol network handler
|
||||
let whisper_network_handler = Arc::new(whisper::net::Network::new(pool_size, manager.clone()));
|
||||
|
||||
// Whisper protocol network handler
|
||||
let whisper_network_handler = Arc::new(whisper::net::Network::new(pool_size, manager.clone()));
|
||||
let network_config = {
|
||||
let mut cfg = net::NetworkConfiguration::new();
|
||||
let port = match args.flag_port.as_str() {
|
||||
"random" => 0 as u16,
|
||||
port => port.parse::<u16>()?,
|
||||
};
|
||||
let addr = Ipv4Addr::from_str(&args.flag_address[..])?;
|
||||
cfg.listen_address = Some(SocketAddr::V4(SocketAddrV4::new(addr, port)));
|
||||
cfg.use_secret = match args.flag_secret.as_str() {
|
||||
"" => None,
|
||||
fname => {
|
||||
let key_text = std::fs::read_to_string(fname)?;
|
||||
let key: Vec<u8> = FromHex::from_hex(key_text.as_str())?;
|
||||
Secret::from_slice(key.as_slice())
|
||||
}
|
||||
};
|
||||
cfg.nat_enabled = false;
|
||||
cfg
|
||||
};
|
||||
|
||||
let network_config = {
|
||||
let mut cfg = net::NetworkConfiguration::new();
|
||||
let port = match args.flag_port.as_str() {
|
||||
"random" => 0 as u16,
|
||||
port => port.parse::<u16>()?,
|
||||
// Create network service
|
||||
let network = devp2p::NetworkService::new(network_config, None)?;
|
||||
|
||||
};
|
||||
let addr = Ipv4Addr::from_str(&args.flag_address[..])?;
|
||||
cfg.listen_address = Some(SocketAddr::V4(SocketAddrV4::new(addr, port)));
|
||||
cfg.use_secret = match args.flag_secret.as_str() {
|
||||
"" => None,
|
||||
fname => {
|
||||
let key_text = std::fs::read_to_string(fname)?;
|
||||
let key : Vec<u8> = FromHex::from_hex(key_text.as_str())?;
|
||||
Secret::from_slice(key.as_slice())
|
||||
}
|
||||
};
|
||||
cfg.nat_enabled = false;
|
||||
cfg
|
||||
};
|
||||
// Start network service
|
||||
network.start().map_err(|(err, _)| err)?;
|
||||
|
||||
// Create network service
|
||||
let network = devp2p::NetworkService::new(network_config, None)?;
|
||||
// Attach whisper protocol to the network service
|
||||
network.register_protocol(
|
||||
whisper_network_handler.clone(),
|
||||
whisper::net::PROTOCOL_ID,
|
||||
whisper::net::SUPPORTED_VERSIONS,
|
||||
)?;
|
||||
network.register_protocol(
|
||||
Arc::new(whisper::net::ParityExtensions),
|
||||
whisper::net::PARITY_PROTOCOL_ID,
|
||||
whisper::net::SUPPORTED_VERSIONS,
|
||||
)?;
|
||||
|
||||
// Start network service
|
||||
network.start().map_err(|(err, _)| err)?;
|
||||
// Request handler
|
||||
let mut io = MetaIoHandler::default();
|
||||
|
||||
// Attach whisper protocol to the network service
|
||||
network.register_protocol(whisper_network_handler.clone(), whisper::net::PROTOCOL_ID,
|
||||
whisper::net::SUPPORTED_VERSIONS)?;
|
||||
network.register_protocol(Arc::new(whisper::net::ParityExtensions), whisper::net::PARITY_PROTOCOL_ID,
|
||||
whisper::net::SUPPORTED_VERSIONS)?;
|
||||
// Shared network service
|
||||
let shared_network = Arc::new(network);
|
||||
|
||||
// Request handler
|
||||
let mut io = MetaIoHandler::default();
|
||||
// Pool handler
|
||||
let whisper_factory = RpcFactory {
|
||||
handle: whisper_network_handler,
|
||||
manager: manager,
|
||||
};
|
||||
|
||||
// Shared network service
|
||||
let shared_network = Arc::new(network);
|
||||
io.extend_with(whisper::rpc::Whisper::to_delegate(
|
||||
whisper_factory.make_handler(shared_network.clone()),
|
||||
));
|
||||
io.extend_with(whisper::rpc::WhisperPubSub::to_delegate(
|
||||
whisper_factory.make_handler(shared_network.clone()),
|
||||
));
|
||||
|
||||
// Pool handler
|
||||
let whisper_factory = RpcFactory { handle: whisper_network_handler, manager: manager };
|
||||
let server = jsonrpc_http_server::ServerBuilder::new(io)
|
||||
.cors(DomainsValidation::AllowOnly(vec![
|
||||
AccessControlAllowOrigin::Null,
|
||||
]))
|
||||
.start_http(&rpc_url.parse()?)?;
|
||||
|
||||
io.extend_with(whisper::rpc::Whisper::to_delegate(whisper_factory.make_handler(shared_network.clone())));
|
||||
io.extend_with(whisper::rpc::WhisperPubSub::to_delegate(whisper_factory.make_handler(shared_network.clone())));
|
||||
server.wait();
|
||||
|
||||
let server = jsonrpc_http_server::ServerBuilder::new(io)
|
||||
.cors(DomainsValidation::AllowOnly(vec![AccessControlAllowOrigin::Null]))
|
||||
.start_http(&rpc_url.parse()?)?;
|
||||
|
||||
server.wait();
|
||||
|
||||
// This will never return if the http server runs without errors
|
||||
Ok(())
|
||||
// This will never return if the http server runs without errors
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn initialize_logger(log_level: String) {
|
||||
env_logger::Builder::from_env(env_logger::Env::default())
|
||||
.parse(&log_level)
|
||||
.init();
|
||||
env_logger::Builder::from_env(env_logger::Env::default())
|
||||
.parse(&log_level)
|
||||
.init();
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::execute;
|
||||
use super::execute;
|
||||
|
||||
#[test]
|
||||
fn invalid_argument() {
|
||||
let command = vec!["whisper", "--foo=12"]
|
||||
.into_iter()
|
||||
.map(Into::into)
|
||||
.collect::<Vec<String>>();
|
||||
#[test]
|
||||
fn invalid_argument() {
|
||||
let command = vec!["whisper", "--foo=12"]
|
||||
.into_iter()
|
||||
.map(Into::into)
|
||||
.collect::<Vec<String>>();
|
||||
|
||||
assert!(execute(command).is_err());
|
||||
}
|
||||
assert!(execute(command).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn privileged_port() {
|
||||
let command = vec!["whisper", "--port=3"]
|
||||
.into_iter()
|
||||
.map(Into::into)
|
||||
.collect::<Vec<String>>();
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn privileged_port() {
|
||||
let command = vec!["whisper", "--port=3"]
|
||||
.into_iter()
|
||||
.map(Into::into)
|
||||
.collect::<Vec<String>>();
|
||||
|
||||
assert!(execute(command).is_err());
|
||||
}
|
||||
assert!(execute(command).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_ip_address() {
|
||||
let command = vec!["whisper", "--address=x.x.x.x"]
|
||||
.into_iter()
|
||||
.map(Into::into)
|
||||
.collect::<Vec<String>>();
|
||||
#[test]
|
||||
fn invalid_ip_address() {
|
||||
let command = vec!["whisper", "--address=x.x.x.x"]
|
||||
.into_iter()
|
||||
.map(Into::into)
|
||||
.collect::<Vec<String>>();
|
||||
|
||||
assert!(execute(command).is_err());
|
||||
}
|
||||
assert!(execute(command).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_whisper_pool_size() {
|
||||
let command = vec!["whisper", "--whisper-pool-size=-100000000000000000000000000000000000000"]
|
||||
.into_iter()
|
||||
.map(Into::into)
|
||||
.collect::<Vec<String>>();
|
||||
#[test]
|
||||
fn invalid_whisper_pool_size() {
|
||||
let command = vec![
|
||||
"whisper",
|
||||
"--whisper-pool-size=-100000000000000000000000000000000000000",
|
||||
]
|
||||
.into_iter()
|
||||
.map(Into::into)
|
||||
.collect::<Vec<String>>();
|
||||
|
||||
assert!(execute(command).is_err());
|
||||
}
|
||||
assert!(execute(command).is_err());
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user