pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-04-30 00:17:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

Run cargo fmt on the whole code base (#9394)

Browse Source 
* Run cargo fmt on the whole code base

* Second run

* Add CI check

* Fix compilation

* More unnecessary braces

* Handle weights

* Use --all

* Use correct attributes...

* Fix UI tests

* AHHHHHHHHH

* 🤦

* Docs

* Fix compilation

* 🤷

* Please stop

* 🤦 x 2

* More

* make rustfmt.toml consistent with polkadot

Co-authored-by: André Silva <andrerfosilva@gmail.com>
This commit is contained in:
Bastian Köcher
2021-07-21 16:32:32 +02:00
committed by GitHub
parent d451c38c1c
commit 7b56ab15b4
1010 changed files with 53339 additions and 51208 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/client/rpc/src/system/mod.rs
+35 -32
View File
@@ -21,24 +21,25 @@
#[cfg(test)]
mod tests;
use futures::{future::BoxFuture, FutureExt, TryFutureExt};
use futures::{channel::oneshot, compat::Compat};
use futures::{channel::oneshot, compat::Compat, future::BoxFuture, FutureExt, TryFutureExt};
use sc_rpc_api::{DenyUnsafe, Receiver};
use sc_tracing::logging;
use sp_utils::mpsc::TracingUnboundedSender;
use sp_runtime::traits::{self, Header as HeaderT};
use sp_utils::mpsc::TracingUnboundedSender;
use self::error::Result;
pub use self::{
gen_client::Client as SystemClient,
helpers::{Health, NodeRole, PeerInfo, SyncState, SystemInfo},
};
pub use sc_rpc_api::system::*;
pub use self::helpers::{SystemInfo, Health, PeerInfo, NodeRole, SyncState};
pub use self::gen_client::Client as SystemClient;
/// Early exit for RPCs that require `--rpc-methods=Unsafe` to be enabled
macro_rules! bail_if_unsafe {
($value: expr) => {
if let Err(err) = $value.check_if_safe() {
return async move { Err(err.into()) }.boxed().compat();
return async move { Err(err.into()) }.boxed().compat()
}
};
}
@@ -85,11 +86,7 @@ impl<B: traits::Block> System<B> {
send_back: TracingUnboundedSender<Request<B>>,
deny_unsafe: DenyUnsafe,
) -> Self {
System {
info,
send_back,
deny_unsafe,
}
System { info, send_back, deny_unsafe }
}
}
@@ -132,35 +129,36 @@ impl<B: traits::Block> SystemApi<B::Hash, <B::Header as HeaderT>::Number> for Sy
Receiver(Compat::new(rx))
}
fn system_peers(&self)
-> Compat<BoxFuture<'static, rpc::Result<Vec<PeerInfo<B::Hash, <B::Header as HeaderT>::Number>>>>>
{
fn system_peers(
&self,
) -> Compat<
BoxFuture<'static, rpc::Result<Vec<PeerInfo<B::Hash, <B::Header as HeaderT>::Number>>>>,
> {
bail_if_unsafe!(self.deny_unsafe);
let (tx, rx) = oneshot::channel();
let _ = self.send_back.unbounded_send(Request::Peers(tx));
async move {
rx.await.map_err(|_| rpc::Error::internal_error())
}.boxed().compat()
async move { rx.await.map_err(|_| rpc::Error::internal_error()) }
.boxed()
.compat()
}
fn system_network_state(&self)
-> Compat<BoxFuture<'static, rpc::Result<rpc::Value>>>
{
fn system_network_state(&self) -> Compat<BoxFuture<'static, rpc::Result<rpc::Value>>> {
bail_if_unsafe!(self.deny_unsafe);
let (tx, rx) = oneshot::channel();
let _ = self.send_back.unbounded_send(Request::NetworkState(tx));
async move {
rx.await.map_err(|_| rpc::Error::internal_error())
}.boxed().compat()
async move { rx.await.map_err(|_| rpc::Error::internal_error()) }
.boxed()
.compat()
}
fn system_add_reserved_peer(&self, peer: String)
-> Compat<BoxFuture<'static, std::result::Result<(), rpc::Error>>>
{
fn system_add_reserved_peer(
&self,
peer: String,
) -> Compat<BoxFuture<'static, std::result::Result<(), rpc::Error>>> {
bail_if_unsafe!(self.deny_unsafe);
let (tx, rx) = oneshot::channel();
@@ -171,12 +169,15 @@ impl<B: traits::Block> SystemApi<B::Hash, <B::Header as HeaderT>::Number> for Sy
Ok(Err(e)) => Err(rpc::Error::from(e)),
Err(_) => Err(rpc::Error::internal_error()),
}
}.boxed().compat()
}
.boxed()
.compat()
}
fn system_remove_reserved_peer(&self, peer: String)
-> Compat<BoxFuture<'static, std::result::Result<(), rpc::Error>>>
{
fn system_remove_reserved_peer(
&self,
peer: String,
) -> Compat<BoxFuture<'static, std::result::Result<(), rpc::Error>>> {
bail_if_unsafe!(self.deny_unsafe);
let (tx, rx) = oneshot::channel();
@@ -187,7 +188,9 @@ impl<B: traits::Block> SystemApi<B::Hash, <B::Header as HeaderT>::Number> for Sy
Ok(Err(e)) => Err(rpc::Error::from(e)),
Err(_) => Err(rpc::Error::internal_error()),
}
}.boxed().compat()
}
.boxed()
.compat()
}
fn system_reserved_peers(&self) -> Receiver<Vec<String>> {
@@ -214,7 +217,7 @@ impl<B: traits::Block> SystemApi<B::Hash, <B::Header as HeaderT>::Number> for Sy
logging::reload_filter().map_err(|_e| rpc::Error::internal_error())
}
fn system_reset_log_filter(&self)-> std::result::Result<(), rpc::Error> {
fn system_reset_log_filter(&self) -> std::result::Result<(), rpc::Error> {
self.deny_unsafe.check_if_safe()?;
logging::reset_log_filter().map_err(|_e| rpc::Error::internal_error())
}
substrate/client/rpc/src/system/tests.rs
+72 -108
View File
@@ -18,13 +18,17 @@
use super::*;
use sc_network::{self, PeerId};
use sc_network::config::Role;
use substrate_test_runtime_client::runtime::Block;
use assert_matches::assert_matches;
use futures::prelude::*;
use sc_network::{self, config::Role, PeerId};
use sp_utils::mpsc::tracing_unbounded;
use std::{process::{Stdio, Command}, env, io::{BufReader, BufRead, Write}, thread};
use std::{
env,
io::{BufRead, BufReader, Write},
process::{Command, Stdio},
thread,
};
use substrate_test_runtime_client::runtime::Block;
struct Status {
pub peers: usize,
@@ -35,12 +39,7 @@ struct Status {
impl Default for Status {
fn default() -> Status {
Status {
peer_id: PeerId::random(),
peers: 0,
is_syncing: false,
is_dev: false,
}
Status { peer_id: PeerId::random(), peers: 0, is_syncing: false, is_dev: false }
}
}
@@ -59,7 +58,8 @@ fn api<T: Into<Option<Status>>>(sync: T) -> System<Block> {
});
},
Request::LocalPeerId(sender) => {
let _ = sender.send("QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV".to_string());
let _ =
sender.send("QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV".to_string());
},
Request::LocalListenAddresses(sender) => {
let _ = sender.send(vec![
@@ -78,42 +78,48 @@ fn api<T: Into<Option<Status>>>(sync: T) -> System<Block> {
});
}
let _ = sender.send(peers);
}
},
Request::NetworkState(sender) => {
let _ = sender.send(serde_json::to_value(&sc_network::network_state::NetworkState {
peer_id: String::new(),
listened_addresses: Default::default(),
external_addresses: Default::default(),
connected_peers: Default::default(),
not_connected_peers: Default::default(),
peerset: serde_json::Value::Null,
}).unwrap());
let _ = sender.send(
serde_json::to_value(&sc_network::network_state::NetworkState {
peer_id: String::new(),
listened_addresses: Default::default(),
external_addresses: Default::default(),
connected_peers: Default::default(),
not_connected_peers: Default::default(),
peerset: serde_json::Value::Null,
})
.unwrap(),
);
},
Request::NetworkAddReservedPeer(peer, sender) => {
let _ = match sc_network::config::parse_str_addr(&peer) {
Ok(_) => sender.send(Ok(())),
Err(s) => sender.send(Err(error::Error::MalformattedPeerArg(s.to_string()))),
Err(s) =>
sender.send(Err(error::Error::MalformattedPeerArg(s.to_string()))),
};
},
Request::NetworkRemoveReservedPeer(peer, sender) => {
let _ = match peer.parse::<PeerId>() {
Ok(_) => sender.send(Ok(())),
Err(s) => sender.send(Err(error::Error::MalformattedPeerArg(s.to_string()))),
Err(s) =>
sender.send(Err(error::Error::MalformattedPeerArg(s.to_string()))),
};
}
},
Request::NetworkReservedPeers(sender) => {
let _ = sender.send(vec!["QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV".to_string()]);
}
let _ = sender
.send(vec!["QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV".to_string()]);
},
Request::NodeRoles(sender) => {
let _ = sender.send(vec![NodeRole::Authority]);
}
},
Request::SyncState(sender) => {
let _ = sender.send(SyncState {
starting_block: 1,
current_block: 2,
highest_block: Some(3),
});
}
},
};
future::ready(())
@@ -128,7 +134,7 @@ fn api<T: Into<Option<Status>>>(sync: T) -> System<Block> {
chain_type: Default::default(),
},
tx,
sc_rpc_api::DenyUnsafe::No
sc_rpc_api::DenyUnsafe::No,
)
}
@@ -139,95 +145,58 @@ fn wait_receiver<T>(rx: Receiver<T>) -> T {
#[test]
fn system_name_works() {
assert_eq!(
api(None).system_name().unwrap(),
"testclient".to_owned(),
);
assert_eq!(api(None).system_name().unwrap(), "testclient".to_owned(),);
}
#[test]
fn system_version_works() {
assert_eq!(
api(None).system_version().unwrap(),
"0.2.0".to_owned(),
);
assert_eq!(api(None).system_version().unwrap(), "0.2.0".to_owned(),);
}
#[test]
fn system_chain_works() {
assert_eq!(
api(None).system_chain().unwrap(),
"testchain".to_owned(),
);
assert_eq!(api(None).system_chain().unwrap(), "testchain".to_owned(),);
}
#[test]
fn system_properties_works() {
assert_eq!(
api(None).system_properties().unwrap(),
serde_json::map::Map::new(),
);
assert_eq!(api(None).system_properties().unwrap(), serde_json::map::Map::new(),);
}
#[test]
fn system_type_works() {
assert_eq!(
api(None).system_type().unwrap(),
Default::default(),
);
assert_eq!(api(None).system_type().unwrap(), Default::default(),);
}
#[test]
fn system_health() {
assert_matches!(
wait_receiver(api(None).system_health()),
Health {
peers: 0,
is_syncing: false,
should_have_peers: true,
}
Health { peers: 0, is_syncing: false, should_have_peers: true }
);
assert_matches!(
wait_receiver(api(Status {
peer_id: PeerId::random(),
peers: 5,
is_syncing: true,
is_dev: true,
}).system_health()),
Health {
peers: 5,
is_syncing: true,
should_have_peers: false,
}
wait_receiver(
api(Status { peer_id: PeerId::random(), peers: 5, is_syncing: true, is_dev: true })
.system_health()
),
Health { peers: 5, is_syncing: true, should_have_peers: false }
);
assert_eq!(
wait_receiver(api(Status {
peer_id: PeerId::random(),
peers: 5,
is_syncing: false,
is_dev: false,
}).system_health()),
Health {
peers: 5,
is_syncing: false,
should_have_peers: true,
}
wait_receiver(
api(Status { peer_id: PeerId::random(), peers: 5, is_syncing: false, is_dev: false })
.system_health()
),
Health { peers: 5, is_syncing: false, should_have_peers: true }
);
assert_eq!(
wait_receiver(api(Status {
peer_id: PeerId::random(),
peers: 0,
is_syncing: false,
is_dev: true,
}).system_health()),
Health {
peers: 0,
is_syncing: false,
should_have_peers: false,
}
wait_receiver(
api(Status { peer_id: PeerId::random(), peers: 0, is_syncing: false, is_dev: true })
.system_health()
),
Health { peers: 0, is_syncing: false, should_have_peers: false }
);
}
@@ -244,8 +213,10 @@ fn system_local_listen_addresses_works() {
assert_eq!(
wait_receiver(api(None).system_local_listen_addresses()),
vec![
"/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV".to_string(),
"/ip4/127.0.0.1/tcp/30334/ws/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV".to_string(),
"/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV"
.to_string(),
"/ip4/127.0.0.1/tcp/30334/ws/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV"
.to_string(),
]
);
}
@@ -255,12 +226,8 @@ fn system_peers() {
let mut runtime = tokio::runtime::current_thread::Runtime::new().unwrap();
let peer_id = PeerId::random();
let req = api(Status {
peer_id: peer_id.clone(),
peers: 1,
is_syncing: false,
is_dev: true,
}).system_peers();
let req = api(Status { peer_id: peer_id.clone(), peers: 1, is_syncing: false, is_dev: true })
.system_peers();
let res = runtime.block_on(req).unwrap();
assert_eq!(
@@ -295,27 +262,21 @@ fn system_network_state() {
#[test]
fn system_node_roles() {
assert_eq!(
wait_receiver(api(None).system_node_roles()),
vec![NodeRole::Authority]
);
assert_eq!(wait_receiver(api(None).system_node_roles()), vec![NodeRole::Authority]);
}
#[test]
fn system_sync_state() {
assert_eq!(
wait_receiver(api(None).system_sync_state()),
SyncState {
starting_block: 1,
current_block: 2,
highest_block: Some(3),
}
SyncState { starting_block: 1, current_block: 2, highest_block: Some(3) }
);
}
#[test]
fn system_network_add_reserved() {
let good_peer_id = "/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV";
let good_peer_id =
"/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV";
let bad_peer_id = "/ip4/198.51.100.19/tcp/30333";
let mut runtime = tokio::runtime::current_thread::Runtime::new().unwrap();
@@ -328,7 +289,8 @@ fn system_network_add_reserved() {
#[test]
fn system_network_remove_reserved() {
let good_peer_id = "QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV";
let bad_peer_id = "/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV";
let bad_peer_id =
"/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV";
let mut runtime = tokio::runtime::current_thread::Runtime::new().unwrap();
let good_fut = api(None).system_remove_reserved_peer(good_peer_id.into());
@@ -357,15 +319,17 @@ fn test_add_reset_log_filter() {
for line in std::io::stdin().lock().lines() {
let line = line.expect("Failed to read bytes");
if line.contains("add_reload") {
api(None).system_add_log_filter("test_after_add".into())
api(None)
.system_add_log_filter("test_after_add".into())
.expect("`system_add_log_filter` failed");
} else if line.contains("add_trace") {
api(None).system_add_log_filter("test_before_add=trace".into())
api(None)
.system_add_log_filter("test_before_add=trace".into())
.expect("`system_add_log_filter` failed");
} else if line.contains("reset") {
api(None).system_reset_log_filter().expect("`system_reset_log_filter` failed");
} else if line.contains("exit") {
return;
return
}
log::trace!(target: "test_before_add", "{}", EXPECTED_WITH_TRACE);
log::debug!(target: "test_before_add", "{}", EXPECTED_BEFORE_ADD);