openethereum/crates/net/network-devp2p/tests/tests.rs

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

168 lines
5.3 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
extern crate env_logger;
extern crate ethcore_io as io;
extern crate ethcore_network;
extern crate ethcore_network_devp2p;
extern crate ethereum_types;
extern crate parity_bytes;
extern crate parity_crypto as crypto;
extern crate parking_lot;
use crypto::publickey::{Generator, Random};
use ethcore_network::*;
use ethcore_network_devp2p::NetworkService;
use ethereum_types::U64;
use io::TimerToken;
use parity_bytes::Bytes;
use parking_lot::Mutex;
2016-01-24 18:53:54 +01:00
use std::{
2020-08-05 06:08:03 +02:00
sync::{
2016-01-24 18:53:54 +01:00
atomic::{AtomicBool, Ordering as AtomicOrdering},
2020-08-05 06:08:03 +02:00
Arc,
},
thread,
time::*,
};
2016-01-24 18:53:54 +01:00
pub struct TestProtocol {
2016-02-16 19:08:58 +01:00
drop_session: bool,
2016-01-24 18:53:54 +01:00
pub packet: Mutex<Bytes>,
pub got_timeout: AtomicBool,
2016-02-16 19:08:58 +01:00
pub got_disconnect: AtomicBool,
2016-01-24 18:53:54 +01:00
}
impl TestProtocol {
2016-02-16 19:08:58 +01:00
pub fn new(drop_session: bool) -> Self {
TestProtocol {
packet: Mutex::new(Vec::new()),
got_timeout: AtomicBool::new(false),
got_disconnect: AtomicBool::new(false),
2016-02-16 19:08:58 +01:00
drop_session: drop_session,
}
}
2016-01-24 18:53:54 +01:00
/// Creates and register protocol with the network service
pub fn register(service: &mut NetworkService, drop_session: bool) -> Arc<TestProtocol> {
2016-02-16 19:08:58 +01:00
let handler = Arc::new(TestProtocol::new(drop_session));
service
.register_protocol(
handler.clone(),
U64::from(0x000aaa00),
&[(42u8, 1u8), (43u8, 1u8)],
)
.expect("Error registering test protocol handler");
2016-01-24 18:53:54 +01:00
handler
}
2020-08-05 06:08:03 +02:00
2016-01-24 18:53:54 +01:00
pub fn got_packet(&self) -> bool {
self.packet.lock()[..] == b"hello"[..]
2016-01-24 18:53:54 +01:00
}
2020-08-05 06:08:03 +02:00
2016-01-24 18:53:54 +01:00
pub fn got_timeout(&self) -> bool {
self.got_timeout.load(AtomicOrdering::SeqCst)
2016-01-24 18:53:54 +01:00
}
2020-08-05 06:08:03 +02:00
2016-02-16 19:08:58 +01:00
pub fn got_disconnect(&self) -> bool {
self.got_disconnect.load(AtomicOrdering::SeqCst)
2016-02-16 19:08:58 +01:00
}
2016-01-24 18:53:54 +01:00
}
impl NetworkProtocolHandler for TestProtocol {
2020-07-29 10:36:15 +02:00
fn initialize(&self, io: &dyn NetworkContext) {
io.register_timer(0, Duration::from_millis(10)).unwrap();
2016-01-24 18:53:54 +01:00
}
2020-08-05 06:08:03 +02:00
2020-07-29 10:36:15 +02:00
fn read(&self, _io: &dyn NetworkContext, _peer: &PeerId, packet_id: u8, data: &[u8]) {
2016-01-24 18:53:54 +01:00
assert_eq!(packet_id, 33);
self.packet.lock().extend(data);
2016-01-24 18:53:54 +01:00
}
2020-08-05 06:08:03 +02:00
2020-07-29 10:36:15 +02:00
fn connected(&self, io: &dyn NetworkContext, peer: &PeerId) {
Increase number of requested block bodies in chain sync (#10247) * Increase the number of block bodies requested during Sync. * Increase the number of block bodies requested during Sync. * Check if our peer is an older parity client with the bug of not handling large requests properly * Add a ClientVersion struct and a ClientCapabilites trait * Make ClientVersion its own module * Refactor and extend use of ClientVersion * Replace strings with ClientVersion in PeerInfo * Group further functionality in ClientCapabilities * Move parity client version data from tuple to its own struct. * Implement accessor methods for ParityClientData and remove them from ClientVersion. * Minor fixes * Make functions specific to parity return types specific to parity. * Test for shorter ID strings * Fix formatting and remove unneeded dependencies. * Roll back Cargo.lock * Commit last Cargo.lock * Convert from string to ClientVersion * * When checking if peer accepts service transactions just check if it's parity, remove version check. * Remove dependency on semver in ethcore-sync * Remove unnecessary String instantiation * Rename peer_info to peer_version * Update RPC test helpers * Simplify From<String> * Parse static version string only once * Update RPC tests to new ClientVersion struct * Document public members * More robust parsing of ID string * Minor changes. * Update version in which large block bodies requests appear. * Update ethcore/sync/src/block_sync.rs Co-Authored-By: elferdo <elferdo@gmail.com> * Update util/network/src/client_version.rs Co-Authored-By: elferdo <elferdo@gmail.com> * Update util/network/src/client_version.rs Co-Authored-By: elferdo <elferdo@gmail.com> * Update tests. * Minor fixes.
2019-02-07 15:27:09 +01:00
assert!(io.peer_client_version(*peer).to_string().contains("Parity"));
2016-02-16 19:08:58 +01:00
if self.drop_session {
io.disconnect_peer(*peer)
} else {
io.respond(33, "hello".to_owned().into_bytes()).unwrap();
}
2016-01-24 18:53:54 +01:00
}
2020-08-05 06:08:03 +02:00
2020-07-29 10:36:15 +02:00
fn disconnected(&self, _io: &dyn NetworkContext, _peer: &PeerId) {
self.got_disconnect.store(true, AtomicOrdering::SeqCst);
2016-01-24 18:53:54 +01:00
}
2020-08-05 06:08:03 +02:00
2016-01-24 18:53:54 +01:00
/// Timer function called after a timeout created with `NetworkContext::timeout`.
2020-07-29 10:36:15 +02:00
fn timeout(&self, _io: &dyn NetworkContext, timer: TimerToken) {
2016-01-24 18:53:54 +01:00
assert_eq!(timer, 0);
self.got_timeout.store(true, AtomicOrdering::SeqCst);
2016-01-24 18:53:54 +01:00
}
}
#[test]
2016-02-03 12:04:24 +01:00
fn net_service() {
2017-08-29 14:38:01 +02:00
let service = NetworkService::new(NetworkConfiguration::new_local(), None)
.expect("Error creating network service");
2016-06-17 18:26:54 +02:00
service.start().unwrap();
service
.register_protocol(
Arc::new(TestProtocol::new(false)),
U64::from(0x000aff00),
&[(1u8, 1u8)],
)
.unwrap();
2016-01-24 18:53:54 +01:00
}
2016-06-17 18:26:54 +02:00
#[test]
fn net_start_stop() {
let config = NetworkConfiguration::new_local();
2017-08-29 14:38:01 +02:00
let service = NetworkService::new(config, None).unwrap();
2016-06-17 18:26:54 +02:00
service.start().unwrap();
service.stop();
2016-06-17 18:26:54 +02:00
service.start().unwrap();
}
2016-02-16 19:08:58 +01:00
#[test]
fn net_disconnect() {
let key1 = Random.generate();
2016-03-20 11:35:46 +01:00
let mut config1 = NetworkConfiguration::new_local();
2016-02-16 19:08:58 +01:00
config1.use_secret = Some(key1.secret().clone());
config1.boot_nodes = vec![];
2017-08-29 14:38:01 +02:00
let mut service1 = NetworkService::new(config1, None).unwrap();
2016-06-17 18:26:54 +02:00
service1.start().unwrap();
2016-02-16 19:08:58 +01:00
let handler1 = TestProtocol::register(&mut service1, false);
2016-03-20 11:35:46 +01:00
let mut config2 = NetworkConfiguration::new_local();
2016-06-17 18:26:54 +02:00
config2.boot_nodes = vec![service1.local_url().unwrap()];
2017-08-29 14:38:01 +02:00
let mut service2 = NetworkService::new(config2, None).unwrap();
2016-06-17 18:26:54 +02:00
service2.start().unwrap();
2016-02-16 19:08:58 +01:00
let handler2 = TestProtocol::register(&mut service2, true);
while !(handler1.got_disconnect() && handler2.got_disconnect()) {
thread::sleep(Duration::from_millis(50));
}
assert!(handler1.got_disconnect());
assert!(handler2.got_disconnect());
}
2016-01-24 18:53:54 +01:00
#[test]
2016-02-03 12:04:24 +01:00
fn net_timeout() {
2016-03-20 11:35:46 +01:00
let config = NetworkConfiguration::new_local();
2017-08-29 14:38:01 +02:00
let mut service = NetworkService::new(config, None).unwrap();
2016-06-17 18:26:54 +02:00
service.start().unwrap();
2016-02-16 19:08:58 +01:00
let handler = TestProtocol::register(&mut service, false);
2016-01-24 18:53:54 +01:00
while !handler.got_timeout() {
thread::sleep(Duration::from_millis(50));
}
}