openethereum/util/src/network/service.rs

156 lines
4.7 KiB
Rust
Raw Normal View History

2016-02-05 13:40:41 +01:00
// Copyright 2015, 2016 Ethcore (UK) Ltd.
// This file is part of Parity.
// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Parity is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
2016-01-21 16:48:37 +01:00
use std::sync::*;
use error::*;
2016-02-10 16:35:52 +01:00
use panics::*;
use misc::RwLockable;
2016-01-23 02:36:58 +01:00
use network::{NetworkProtocolHandler, NetworkConfiguration};
use network::error::NetworkError;
use network::host::{Host, NetworkIoMessage, ProtocolId};
use network::stats::NetworkStats;
use io::*;
2015-12-17 11:42:30 +01:00
2015-12-30 12:23:36 +01:00
/// IO Service with networking
/// `Message` defines a notification data type.
2016-01-21 16:48:37 +01:00
pub struct NetworkService<Message> where Message: Send + Sync + Clone + 'static {
io_service: IoService<NetworkIoMessage<Message>>,
2016-01-14 19:04:13 +01:00
host_info: String,
2016-06-17 12:58:28 +02:00
host: RwLock<Option<Arc<Host<Message>>>>,
2016-02-10 16:35:52 +01:00
stats: Arc<NetworkStats>,
2016-06-17 12:58:28 +02:00
panic_handler: Arc<PanicHandler>,
config: NetworkConfiguration,
2015-12-17 11:42:30 +01:00
}
2016-01-21 16:48:37 +01:00
impl<Message> NetworkService<Message> where Message: Send + Sync + Clone + 'static {
2015-12-30 12:23:36 +01:00
/// Starts IO event loop
2016-06-17 12:58:28 +02:00
pub fn new(config: NetworkConfiguration) -> Result<NetworkService<Message>, UtilError> {
2016-02-10 16:35:52 +01:00
let panic_handler = PanicHandler::new_in_arc();
2016-06-17 12:58:28 +02:00
let io_service = try!(IoService::<NetworkIoMessage<Message>>::start());
2016-02-10 16:35:52 +01:00
panic_handler.forward_from(&io_service);
2016-06-17 12:58:28 +02:00
let stats = Arc::new(NetworkStats::new());
let host_info = Host::<Message>::client_version();
2015-12-17 11:42:30 +01:00
Ok(NetworkService {
2016-01-14 19:04:13 +01:00
io_service: io_service,
host_info: host_info,
2016-01-24 18:53:54 +01:00
stats: stats,
2016-03-20 11:35:46 +01:00
panic_handler: panic_handler,
2016-06-17 12:58:28 +02:00
host: RwLock::new(None),
config: config,
2015-12-17 11:42:30 +01:00
})
}
2015-12-30 12:23:36 +01:00
/// Regiter a new protocol handler with the event loop.
2016-06-17 12:58:28 +02:00
pub fn register_protocol(&self, handler: Arc<NetworkProtocolHandler<Message>+Send + Sync>, protocol: ProtocolId, versions: &[u8]) -> Result<(), NetworkError> {
try!(self.io_service.send_message(NetworkIoMessage::AddHandler {
2016-01-21 16:48:37 +01:00
handler: handler,
2015-12-17 11:42:30 +01:00
protocol: protocol,
versions: versions.to_vec(),
}));
Ok(())
}
2016-01-13 23:13:57 +01:00
2016-01-14 19:04:13 +01:00
/// Returns host identifier string as advertised to other peers
pub fn host_info(&self) -> String {
self.host_info.clone()
}
/// Returns underlying io service.
2016-06-17 12:58:28 +02:00
pub fn io(&self) -> &IoService<NetworkIoMessage<Message>> {
&self.io_service
2016-01-13 23:13:57 +01:00
}
2016-01-24 18:53:54 +01:00
2016-03-20 11:35:46 +01:00
/// Returns network statistics.
2016-01-24 18:53:54 +01:00
pub fn stats(&self) -> &NetworkStats {
&self.stats
}
2016-02-10 16:35:52 +01:00
/// Returns network configuration.
pub fn config(&self) -> &NetworkConfiguration {
&self.config
}
2016-03-20 11:35:46 +01:00
/// Returns external url if available.
pub fn external_url(&self) -> Option<String> {
let host = self.host.unwrapped_read();
2016-06-17 12:58:28 +02:00
host.as_ref().and_then(|h| h.external_url())
2016-03-20 11:35:46 +01:00
}
/// Returns external url if available.
2016-06-17 12:58:28 +02:00
pub fn local_url(&self) -> Option<String> {
let host = self.host.unwrapped_read();
2016-06-17 12:58:28 +02:00
host.as_ref().map(|h| h.local_url())
}
/// Start network IO
pub fn start(&self) -> Result<(), UtilError> {
let mut host = self.host.unwrapped_write();
2016-06-17 12:58:28 +02:00
if host.is_none() {
let h = Arc::new(try!(Host::new(self.config.clone(), self.stats.clone())));
try!(self.io_service.register_handler(h.clone()));
*host = Some(h);
}
Ok(())
}
/// Stop network IO
pub fn stop(&self) -> Result<(), UtilError> {
let mut host = self.host.unwrapped_write();
2016-06-17 12:58:28 +02:00
if let Some(ref host) = *host {
let io = IoContext::new(self.io_service.channel(), 0); //TODO: take token id from host
2016-06-17 18:26:54 +02:00
try!(host.stop(&io));
2016-06-17 12:58:28 +02:00
}
*host = None;
Ok(())
2016-03-20 11:35:46 +01:00
}
/// Try to add a reserved peer.
pub fn add_reserved_peer(&self, peer: &str) -> Result<(), UtilError> {
let host = self.host.unwrapped_read();
if let Some(ref host) = *host {
host.add_reserved_node(peer)
} else {
Ok(())
}
}
/// Try to remove a reserved peer.
pub fn remove_reserved_peer(&self, peer: &str) -> Result<(), UtilError> {
let host = self.host.unwrapped_read();
if let Some(ref host) = *host {
host.remove_reserved_node(peer)
} else {
Ok(())
}
}
/// Set the non-reserved peer mode.
pub fn set_non_reserved_mode(&self, mode: ::network::NonReservedPeerMode) {
let host = self.host.unwrapped_read();
if let Some(ref host) = *host {
let io_ctxt = IoContext::new(self.io_service.channel(), 0);
host.set_non_reserved_mode(mode, &io_ctxt);
}
}
2016-03-20 11:35:46 +01:00
}
2016-03-20 12:12:58 +01:00
2016-02-10 16:35:52 +01:00
impl<Message> MayPanic for NetworkService<Message> where Message: Send + Sync + Clone + 'static {
fn on_panic<F>(&self, closure: F) where F: OnPanicListener {
self.panic_handler.on_panic(closure);
}
}