openethereum/crates/net/network-devp2p/src/service.rs

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

215 lines
6.8 KiB
Rust
Raw Normal View History

2020-09-22 14:53:52 +02:00
// Copyright 2015-2020 Parity Technologies (UK) Ltd.
// This file is part of OpenEthereum.
2016-02-05 13:40:41 +01:00
2020-09-22 14:53:52 +02:00
// OpenEthereum is free software: you can redistribute it and/or modify
2016-02-05 13:40:41 +01:00
// 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.
2020-09-22 14:53:52 +02:00
// OpenEthereum is distributed in the hope that it will be useful,
2016-02-05 13:40:41 +01:00
// 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
2020-09-22 14:53:52 +02:00
// along with OpenEthereum. If not, see <http://www.gnu.org/licenses/>.
2016-02-05 13:40:41 +01:00
use ansi_term::Colour;
use host::Host;
use io::*;
use network::{
2017-11-13 14:37:08 +01:00
ConnectionFilter, Error, NetworkConfiguration, NetworkContext, NetworkIoMessage,
NetworkProtocolHandler, NonReservedPeerMode, PeerId, ProtocolId,
2020-08-05 06:08:03 +02:00
};
use parking_lot::RwLock;
use std::{net::SocketAddr, ops::RangeInclusive, sync::Arc};
struct HostHandler {
public_url: RwLock<Option<String>>,
}
impl IoHandler<NetworkIoMessage> for HostHandler {
fn message(&self, _io: &IoContext<NetworkIoMessage>, message: &NetworkIoMessage) {
if let NetworkIoMessage::NetworkStarted(ref public_url) = *message {
let mut url = self.public_url.write();
2016-07-19 09:25:51 +02:00
if url.as_ref().map_or(true, |uref| uref != public_url) {
info!(target: "network", "Public node URL: {}", Colour::White.bold().paint(AsRef::<str>::as_ref(public_url)));
}
*url = Some(public_url.to_owned());
}
}
}
2015-12-30 12:23:36 +01:00
/// IO Service with networking
/// `Message` defines a notification data type.
pub struct NetworkService {
io_service: IoService<NetworkIoMessage>,
2016-01-14 19:04:13 +01:00
host_info: String,
host: RwLock<Option<Arc<Host>>>,
host_handler: Arc<HostHandler>,
2016-06-17 12:58:28 +02:00
config: NetworkConfiguration,
2020-07-29 10:36:15 +02:00
filter: Option<Arc<dyn ConnectionFilter>>,
2015-12-17 11:42:30 +01:00
}
impl NetworkService {
2015-12-30 12:23:36 +01:00
/// Starts IO event loop
2017-11-13 14:37:08 +01:00
pub fn new(
config: NetworkConfiguration,
2020-07-29 10:36:15 +02:00
filter: Option<Arc<dyn ConnectionFilter>>,
2017-11-13 14:37:08 +01:00
) -> Result<NetworkService, Error> {
let host_handler = Arc::new(HostHandler {
public_url: RwLock::new(None),
});
let io_service = IoService::<NetworkIoMessage>::start("devp2p")?;
2020-08-05 06:08:03 +02:00
2015-12-17 11:42:30 +01:00
Ok(NetworkService {
io_service,
host_info: config.client_version.clone(),
2016-06-17 12:58:28 +02:00
host: RwLock::new(None),
config,
host_handler,
filter,
2015-12-17 11:42:30 +01:00
})
}
2020-08-05 06:08:03 +02:00
2018-08-17 16:04:03 +02:00
/// Register a new protocol handler with the event loop.
pub fn register_protocol(
&self,
2020-07-29 10:36:15 +02:00
handler: Arc<dyn NetworkProtocolHandler + Send + Sync>,
protocol: ProtocolId,
// version id + packet count
versions: &[(u8, u8)],
) -> Result<(), Error> {
self.io_service.send_message(NetworkIoMessage::AddHandler {
handler,
protocol,
2015-12-17 11:42:30 +01:00
versions: versions.to_vec(),
})?;
2015-12-17 11:42:30 +01:00
Ok(())
}
2020-08-05 06:08:03 +02: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()
}
2020-08-05 06:08:03 +02:00
2016-01-14 19:04:13 +01:00
/// Returns underlying io service.
pub fn io(&self) -> &IoService<NetworkIoMessage> {
2016-06-17 12:58:28 +02:00
&self.io_service
2016-01-13 23:13:57 +01:00
}
2020-08-05 06:08:03 +02:00
/// Returns the number of peers allowed.
pub fn num_peers_range(&self) -> RangeInclusive<u32> {
self.config.min_peers..=self.config.max_peers
}
2020-08-05 06:08:03 +02:00
2016-03-20 11:35:46 +01:00
/// Returns external url if available.
pub fn external_url(&self) -> Option<String> {
let host = self.host.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
}
2020-08-05 06:08:03 +02:00
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.read();
2016-06-17 12:58:28 +02:00
host.as_ref().map(|h| h.local_url())
}
2020-08-05 06:08:03 +02:00
/// Start network IO.
///
/// In case of error, also returns the listening address for better error reporting.
pub fn start(&self) -> Result<(), (Error, Option<SocketAddr>)> {
let mut host = self.host.write();
let listen_addr = self.config.listen_address;
2016-06-17 12:58:28 +02:00
if host.is_none() {
let h = Arc::new(
Host::new(self.config.clone(), self.filter.clone())
.map_err(|err| (err, listen_addr))?,
);
self.io_service
.register_handler(h.clone())
.map_err(|err| (err.into(), listen_addr))?;
2016-06-17 12:58:28 +02:00
*host = Some(h);
}
2020-08-05 06:08:03 +02:00
if self.host_handler.public_url.read().is_none() {
self.io_service
.register_handler(self.host_handler.clone())
.map_err(|err| (err.into(), listen_addr))?;
}
2020-08-05 06:08:03 +02:00
2016-06-17 12:58:28 +02:00
Ok(())
}
2020-08-05 06:08:03 +02:00
/// Stop network IO.
pub fn stop(&self) {
let mut host = self.host.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
host.stop(&io);
2016-06-17 12:58:28 +02:00
}
*host = None;
2016-03-20 11:35:46 +01:00
}
2020-08-05 06:08:03 +02:00
/// Get a list of all connected peers by id.
pub fn connected_peers(&self) -> Vec<PeerId> {
self.host
.read()
.as_ref()
.map(|h| h.connected_peers())
.unwrap_or_else(Vec::new)
}
2020-08-05 06:08:03 +02:00
/// Try to add a reserved peer.
2017-11-13 14:37:08 +01:00
pub fn add_reserved_peer(&self, peer: &str) -> Result<(), Error> {
let host = self.host.read();
if let Some(ref host) = *host {
host.add_reserved_node(peer)
} else {
Ok(())
2020-08-05 06:08:03 +02:00
}
}
2020-08-05 06:08:03 +02:00
/// Try to remove a reserved peer.
2017-11-13 14:37:08 +01:00
pub fn remove_reserved_peer(&self, peer: &str) -> Result<(), Error> {
let host = self.host.read();
if let Some(ref host) = *host {
host.remove_reserved_node(peer)
} else {
Ok(())
2020-08-05 06:08:03 +02:00
}
}
2020-08-05 06:08:03 +02:00
/// Set the non-reserved peer mode.
pub fn set_non_reserved_mode(&self, mode: NonReservedPeerMode) {
let host = self.host.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);
2020-08-05 06:08:03 +02:00
}
}
2020-08-05 06:08:03 +02:00
/// Executes action in the network context
2017-02-02 17:02:46 +01:00
pub fn with_context<F>(&self, protocol: ProtocolId, action: F)
where
2020-07-29 10:36:15 +02:00
F: FnOnce(&dyn NetworkContext),
2017-02-02 17:02:46 +01:00
{
let io = IoContext::new(self.io_service.channel(), 0);
let host = self.host.read();
if let Some(ref host) = host.as_ref() {
host.with_context(protocol, &io, action);
};
}
2020-08-05 06:08:03 +02:00
/// Evaluates function in the network context
2017-02-02 17:02:46 +01:00
pub fn with_context_eval<F, T>(&self, protocol: ProtocolId, action: F) -> Option<T>
where
2020-07-29 10:36:15 +02:00
F: FnOnce(&dyn NetworkContext) -> T,
2017-02-02 17:02:46 +01:00
{
let io = IoContext::new(self.io_service.channel(), 0);
let host = self.host.read();
host.as_ref()
.map(|ref host| host.with_context_eval(protocol, &io, action))
}
2016-03-20 11:35:46 +01:00
}