openethereum/util/network/src/client_version.rs

516 lines
15 KiB
Rust
Raw Normal View History

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
// Copyright 2015-2019 Parity Technologies (UK) Ltd.
// This file is part of Parity Ethereum.
// Parity Ethereum 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 Ethereum 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 Ethereum. If not, see <http://www.gnu.org/licenses/>.
#![warn(missing_docs)]
//! Parse ethereum client ID strings and provide querying functionality
use semver::Version;
use std::fmt;
/// Parity client string prefix
const LEGACY_CLIENT_ID_PREFIX: &str = "Parity";
const PARITY_CLIENT_ID_PREFIX: &str = "Parity-Ethereum";
lazy_static! {
/// Parity versions starting from this will accept block bodies requests
/// of 256 bodies
static ref PARITY_CLIENT_LARGE_REQUESTS_VERSION: Version = Version::parse("2.4.0").unwrap();
}
/// Description of the software version running in a peer
/// according to https://github.com/ethereum/wiki/wiki/Client-Version-Strings
/// This structure as it is represents the format used by Parity clients. Other
/// vendors may provide additional fields.
#[derive(Clone,Debug,PartialEq,Eq,Serialize)]
pub struct ParityClientData {
name: String,
identity: Option<String>,
semver: Version,
os: String,
compiler: String,
// Capability flags, should be calculated in constructor
can_handle_large_requests: bool,
}
/// Accessor methods for ParityClientData. This will probably
/// need to be abstracted away into a trait.
impl ParityClientData {
fn new(
name: String,
identity: Option<String>,
semver: Version,
os: String,
compiler: String,
) -> Self {
// Flags logic
let can_handle_large_requests = &semver >= &PARITY_CLIENT_LARGE_REQUESTS_VERSION;
// Instantiate and return
ParityClientData {
name: name,
identity: identity,
semver: semver,
os: os,
compiler: compiler,
can_handle_large_requests: can_handle_large_requests,
}
}
fn name(&self) -> &str {
self.name.as_str()
}
fn identity(&self) -> Option<&str> {
self.identity.as_ref().map(String::as_str)
}
fn semver(&self) -> &Version {
&self.semver
}
fn os(&self) -> &str {
self.os.as_str()
}
fn compiler(&self) -> &str {
self.compiler.as_str()
}
fn can_handle_large_requests(&self) -> bool {
self.can_handle_large_requests
}
}
/// Enum describing the version of the software running on a peer.
#[derive(Clone,Debug,Eq,PartialEq,Serialize)]
pub enum ClientVersion {
/// The peer runs software from parity and the string format is known
ParityClient(
/// The actual information fields: name, version, os, ...
ParityClientData
),
/// The string ID is recognized as Parity but the overall format
/// could not be parsed
ParityUnknownFormat(String),
/// Other software vendors than Parity
Other(String),
}
impl Default for ClientVersion {
fn default() -> Self {
ClientVersion::Other("".to_owned())
}
}
/// Provide information about what a particular version of a
/// peer software can do
pub trait ClientCapabilities {
/// Parity versions before PARITY_CLIENT_LARGE_REQUESTS_VERSION would not
/// check the accumulated size of a packet when building a response to a
/// GET_BLOCK_BODIES request. If the packet was larger than a given limit,
/// instead of sending fewer blocks no packet would get sent at all. Query
/// if this version can handle requests for a large number of block bodies.
fn can_handle_large_requests(&self) -> bool;
/// Service transactions are specific to parity. Query if this version
/// accepts them.
fn accepts_service_transaction(&self) -> bool;
}
impl ClientCapabilities for ClientVersion {
fn can_handle_large_requests(&self) -> bool {
match self {
ClientVersion::ParityClient(data) => data.can_handle_large_requests(),
ClientVersion::ParityUnknownFormat(_) => false, // Play it safe
ClientVersion::Other(_) => true // As far as we know
}
}
fn accepts_service_transaction(&self) -> bool {
match self {
ClientVersion::ParityClient(_) => true,
ClientVersion::ParityUnknownFormat(_) => true,
ClientVersion::Other(_) => false
}
}
}
fn is_parity(client_id: &str) -> bool {
client_id.starts_with(LEGACY_CLIENT_ID_PREFIX) || client_id.starts_with(PARITY_CLIENT_ID_PREFIX)
}
/// Parse known parity formats. Recognizes either a short format with four fields
/// or a long format which includes the same fields and an identity one.
fn parse_parity_format(client_version: &str) -> Result<ParityClientData, ()> {
const PARITY_ID_STRING_MINIMUM_TOKENS: usize = 4;
let tokens: Vec<&str> = client_version.split("/").collect();
if tokens.len() < PARITY_ID_STRING_MINIMUM_TOKENS {
return Err(())
}
let name = tokens[0];
let identity = if tokens.len() - 3 > 1 {
Some(tokens[1..(tokens.len() - 3)].join("/"))
} else {
None
};
let compiler = tokens[tokens.len() - 1];
let os = tokens[tokens.len() - 2];
// If version is in the right position and valid format return a valid
// result. Otherwise return an error.
get_number_from_version(tokens[tokens.len() - 3])
.and_then(|v| Version::parse(v).ok())
.map(|semver| ParityClientData::new(
name.to_owned(),
identity,
semver,
os.to_owned(),
compiler.to_owned(),
))
.ok_or(())
}
/// Parse a version string and return the corresponding
/// ClientVersion. Only Parity clients are destructured right now, other
/// strings will just get wrapped in a variant so that the information is
/// not lost.
/// The parsing for parity may still fail, in which case return a ParityUnknownFormat with
/// the original version string. TryFrom would be a better trait to implement.
impl<T> From<T> for ClientVersion
where T: AsRef<str> {
fn from(client_version: T) -> Self {
let client_version_str: &str = client_version.as_ref();
if !is_parity(client_version_str) {
return ClientVersion::Other(client_version_str.to_owned());
}
if let Ok(data) = parse_parity_format(client_version_str) {
ClientVersion::ParityClient(data)
} else {
ClientVersion::ParityUnknownFormat(client_version_str.to_owned())
}
}
}
fn format_parity_version_string(client_version: &ParityClientData, f: &mut fmt::Formatter) -> std::fmt::Result {
let name = client_version.name();
let semver = client_version.semver();
let os = client_version.os();
let compiler = client_version.compiler();
match client_version.identity() {
None => write!(f, "{}/v{}/{}/{}", name, semver, os, compiler),
Some(identity) => write!(f, "{}/{}/v{}/{}/{}", name, identity, semver, os, compiler),
}
}
impl fmt::Display for ClientVersion {
fn fmt(&self, f: &mut fmt::Formatter) -> std::fmt::Result {
match self {
ClientVersion::ParityClient(data) => format_parity_version_string(data, f),
ClientVersion::ParityUnknownFormat(id) => write!(f, "{}", id),
ClientVersion::Other(id) => write!(f, "{}", id)
}
}
}
fn get_number_from_version(version: &str) -> Option<&str> {
if version.starts_with("v") {
return version.get(1..);
}
None
}
#[cfg(test)]
pub mod tests {
use super::*;
const PARITY_CLIENT_SEMVER: &str = "2.4.0";
const PARITY_CLIENT_OLD_SEMVER: &str = "2.2.0";
const PARITY_CLIENT_OS: &str = "linux";
const PARITY_CLIENT_COMPILER: &str = "rustc";
const PARITY_CLIENT_IDENTITY: &str = "ExpanseSOLO";
const PARITY_CLIENT_MULTITOKEN_IDENTITY: &str = "ExpanseSOLO/abc/v1.2.3";
fn make_default_version_string() -> String {
format!(
"{}/v{}/{}/{}",
PARITY_CLIENT_ID_PREFIX,
PARITY_CLIENT_SEMVER,
PARITY_CLIENT_OS,
PARITY_CLIENT_COMPILER
)
}
fn make_default_long_version_string() -> String {
format!(
"{}/{}/v{}/{}/{}",
PARITY_CLIENT_ID_PREFIX,
PARITY_CLIENT_IDENTITY,
PARITY_CLIENT_SEMVER,
PARITY_CLIENT_OS,
PARITY_CLIENT_COMPILER
)
}
fn make_multitoken_identity_long_version_string() -> String {
format!(
"{}/{}/v{}/{}/{}",
PARITY_CLIENT_ID_PREFIX,
PARITY_CLIENT_MULTITOKEN_IDENTITY,
PARITY_CLIENT_SEMVER,
PARITY_CLIENT_OS,
PARITY_CLIENT_COMPILER
)
}
fn make_old_semver_version_string() -> String {
format!(
"{}/v{}/{}/{}",
PARITY_CLIENT_ID_PREFIX,
PARITY_CLIENT_OLD_SEMVER,
PARITY_CLIENT_OS,
PARITY_CLIENT_COMPILER
)
}
#[test]
pub fn client_version_when_from_empty_string_then_default() {
let default = ClientVersion::default();
assert_eq!(ClientVersion::from(""), default);
}
#[test]
pub fn get_number_from_version_when_valid_then_number() {
let version_string = format!("v{}", PARITY_CLIENT_SEMVER);
assert_eq!(get_number_from_version(&version_string).unwrap(), PARITY_CLIENT_SEMVER);
}
#[test]
pub fn client_version_when_str_parity_format_and_valid_then_all_fields_match() {
let client_version_string = make_default_version_string();
if let ClientVersion::ParityClient(client_version) = ClientVersion::from(client_version_string.as_str()) {
assert_eq!(client_version.name(), PARITY_CLIENT_ID_PREFIX);
assert_eq!(*client_version.semver(), Version::parse(PARITY_CLIENT_SEMVER).unwrap());
assert_eq!(client_version.os(), PARITY_CLIENT_OS);
assert_eq!(client_version.compiler(), PARITY_CLIENT_COMPILER);
} else {
panic!("shouldn't be here");
}
}
#[test]
pub fn client_version_when_str_parity_long_format_and_valid_then_all_fields_match() {
let client_version_string = make_default_long_version_string();
if let ClientVersion::ParityClient(client_version) = ClientVersion::from(client_version_string.as_str()) {
assert_eq!(client_version.name(), PARITY_CLIENT_ID_PREFIX);
assert_eq!(client_version.identity().unwrap(), PARITY_CLIENT_IDENTITY);
assert_eq!(*client_version.semver(), Version::parse(PARITY_CLIENT_SEMVER).unwrap());
assert_eq!(client_version.os(), PARITY_CLIENT_OS);
assert_eq!(client_version.compiler(), PARITY_CLIENT_COMPILER);
} else {
panic!("shouldnt be here");
}
}
#[test]
pub fn client_version_when_str_parity_long_format_and_valid_and_identity_multiple_tokens_then_all_fields_match() {
let client_version_string = make_multitoken_identity_long_version_string();
if let ClientVersion::ParityClient(client_version) = ClientVersion::from(client_version_string.as_str()) {
assert_eq!(client_version.name(), PARITY_CLIENT_ID_PREFIX);
assert_eq!(client_version.identity().unwrap(), PARITY_CLIENT_MULTITOKEN_IDENTITY);
assert_eq!(*client_version.semver(), Version::parse(PARITY_CLIENT_SEMVER).unwrap());
assert_eq!(client_version.os(), PARITY_CLIENT_OS);
assert_eq!(client_version.compiler(), PARITY_CLIENT_COMPILER);
} else {
panic!("shouldnt be here");
}
}
#[test]
pub fn client_version_when_string_parity_format_and_valid_then_all_fields_match() {
let client_version_string: String = make_default_version_string();
if let ClientVersion::ParityClient(client_version) = ClientVersion::from(client_version_string.as_str()) {
assert_eq!(client_version.name(), PARITY_CLIENT_ID_PREFIX);
assert_eq!(*client_version.semver(), Version::parse(PARITY_CLIENT_SEMVER).unwrap());
assert_eq!(client_version.os(), PARITY_CLIENT_OS);
assert_eq!(client_version.compiler(), PARITY_CLIENT_COMPILER);
} else {
panic!("shouldn't be here");
}
}
#[test]
pub fn client_version_when_parity_format_and_invalid_then_equals_parity_unknown_client_version_string() {
// This is invalid because version has no leading 'v'
let client_version_string = format!(
"{}/{}/{}/{}",
PARITY_CLIENT_ID_PREFIX,
PARITY_CLIENT_SEMVER,
PARITY_CLIENT_OS,
PARITY_CLIENT_COMPILER);
let client_version = ClientVersion::from(client_version_string.as_str());
let parity_unknown = ClientVersion::ParityUnknownFormat(client_version_string.to_string());
assert_eq!(client_version, parity_unknown);
}
#[test]
pub fn client_version_when_parity_format_without_identity_and_missing_compiler_field_then_equals_parity_unknown_client_version_string() {
let client_version_string = format!(
"{}/v{}/{}",
PARITY_CLIENT_ID_PREFIX,
PARITY_CLIENT_SEMVER,
PARITY_CLIENT_OS,
);
let client_version = ClientVersion::from(client_version_string.as_str());
let parity_unknown = ClientVersion::ParityUnknownFormat(client_version_string.to_string());
assert_eq!(client_version, parity_unknown);
}
#[test]
pub fn client_version_when_parity_format_with_identity_and_missing_compiler_field_then_equals_parity_unknown_client_version_string() {
let client_version_string = format!(
"{}/{}/v{}/{}",
PARITY_CLIENT_ID_PREFIX,
PARITY_CLIENT_IDENTITY,
PARITY_CLIENT_SEMVER,
PARITY_CLIENT_OS,
);
let client_version = ClientVersion::from(client_version_string.as_str());
let parity_unknown = ClientVersion::ParityUnknownFormat(client_version_string.to_string());
assert_eq!(client_version, parity_unknown);
}
#[test]
pub fn client_version_when_not_parity_format_and_valid_then_other_with_client_version_string() {
let client_version_string = "Geth/main.jnode.network/v1.8.21-stable-9dc5d1a9/linux";
let client_version = ClientVersion::from(client_version_string);
assert_eq!(client_version, ClientVersion::Other(client_version_string.to_string()));
}
#[test]
pub fn client_version_when_parity_format_and_valid_then_to_string_equal() {
let client_version_string: String = make_default_version_string();
let client_version = ClientVersion::from(client_version_string.as_str());
assert_eq!(client_version.to_string(), client_version_string);
}
#[test]
pub fn client_version_when_other_then_to_string_equal_input_string() {
let client_version_string: String = "Other".to_string();
let client_version = ClientVersion::from("Other");
assert_eq!(client_version.to_string(), client_version_string);
}
#[test]
pub fn client_capabilities_when_parity_old_version_then_handles_large_requests_false() {
let client_version_string: String = make_old_semver_version_string();
let client_version = ClientVersion::from(client_version_string.as_str());
assert!(!client_version.can_handle_large_requests());
}
#[test]
pub fn client_capabilities_when_parity_beta_version_then_not_handles_large_requests_true() {
let client_version_string: String = format!(
"{}/v{}/{}/{}",
"Parity-Ethereum",
"2.4.0-beta",
"x86_64-linux-gnu",
"rustc1.31.1")
.to_string();
let client_version = ClientVersion::from(client_version_string.as_str());
assert!(!client_version.can_handle_large_requests());
}
#[test]
pub fn client_version_when_to_owned_then_both_objects_equal() {
let client_version_string: String = make_old_semver_version_string();
let origin = ClientVersion::from(client_version_string.as_str());
let borrowed = &origin;
let owned = origin.to_owned();
assert_eq!(*borrowed, owned);
}
#[test]
fn client_version_accepts_service_transaction_for_different_versions() {
assert!(!ClientVersion::from("Geth").accepts_service_transaction());
assert!(ClientVersion::from("Parity-Ethereum/v2.6.0/linux/rustc").accepts_service_transaction());
assert!(ClientVersion::from("Parity-Ethereum/ABCDEFGH/v2.7.3/linux/rustc").accepts_service_transaction());
}
#[test]
fn is_parity_when_parity_then_true() {
let client_id = format!("{}/", PARITY_CLIENT_ID_PREFIX);
assert!(is_parity(&client_id));
}
#[test]
fn is_parity_when_empty_then_false() {
let client_id = "";
assert!(!is_parity(&client_id));
}
#[test]
fn is_parity_when_other_then_false() {
let client_id = "other";
assert!(!is_parity(&client_id));
}
}