pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-14 06:21:11 +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/offchain/src/lib.rs
+84 -91
View File
@@ -35,20 +35,22 @@
#![warn(missing_docs)]
use std::{
fmt, marker::PhantomData, sync::Arc,
collections::HashSet,
};
use std::{collections::HashSet, fmt, marker::PhantomData, sync::Arc};
use parking_lot::Mutex;
use threadpool::ThreadPool;
use sp_api::{ApiExt, ProvideRuntimeApi};
use futures::future::Future;
use futures::{
future::{ready, Future},
prelude::*,
};
use log::{debug, warn};
use parking_lot::Mutex;
use sc_network::{ExHashT, NetworkService, NetworkStateInfo, PeerId};
use sp_core::{offchain, ExecutionContext, traits::SpawnNamed};
use sp_runtime::{generic::BlockId, traits::{self, Header}};
use futures::{prelude::*, future::ready};
use sp_api::{ApiExt, ProvideRuntimeApi};
use sp_core::{offchain, traits::SpawnNamed, ExecutionContext};
use sp_runtime::{
generic::BlockId,
traits::{self, Header},
};
use threadpool::ThreadPool;
mod api;
@@ -94,25 +96,23 @@ impl<Client, Block: traits::Block> OffchainWorkers<Client, Block> {
Self {
client,
_block: PhantomData,
thread_pool: Mutex::new(ThreadPool::with_name("offchain-worker".into(), num_cpus::get())),
thread_pool: Mutex::new(ThreadPool::with_name(
"offchain-worker".into(),
num_cpus::get(),
)),
shared_client,
}
}
}
impl<Client, Block: traits::Block> fmt::Debug for OffchainWorkers<
Client,
Block,
> {
impl<Client, Block: traits::Block> fmt::Debug for OffchainWorkers<Client, Block> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_tuple("OffchainWorkers").finish()
}
}
impl<Client, Block> OffchainWorkers<
Client,
Block,
> where
impl<Client, Block> OffchainWorkers<Client, Block>
where
Block: traits::Block,
Client: ProvideRuntimeApi<Block> + Send + Sync + 'static,
Client::Api: OffchainWorkerApi<Block>,
@@ -127,28 +127,22 @@ impl<Client, Block> OffchainWorkers<
) -> impl Future<Output = ()> {
let runtime = self.client.runtime_api();
let at = BlockId::hash(header.hash());
let has_api_v1 = runtime.has_api_with::<dyn OffchainWorkerApi<Block>, _>(
&at, |v| v == 1
);
let has_api_v2 = runtime.has_api_with::<dyn OffchainWorkerApi<Block>, _>(
&at, |v| v == 2
);
let has_api_v1 = runtime.has_api_with::<dyn OffchainWorkerApi<Block>, _>(&at, |v| v == 1);
let has_api_v2 = runtime.has_api_with::<dyn OffchainWorkerApi<Block>, _>(&at, |v| v == 2);
let version = match (has_api_v1, has_api_v2) {
(_, Ok(true)) => 2,
(Ok(true), _) => 1,
err => {
let help = "Consider turning off offchain workers if they are not part of your runtime.";
let help =
"Consider turning off offchain workers if they are not part of your runtime.";
log::error!("Unsupported Offchain Worker API version: {:?}. {}.", err, help);
0
}
},
};
debug!("Checking offchain workers at {:?}: version:{}", at, version);
if version > 0 {
let (api, runner) = api::AsyncApi::new(
network_provider,
is_validator,
self.shared_client.clone(),
);
let (api, runner) =
api::AsyncApi::new(network_provider, is_validator, self.shared_client.clone());
debug!("Spawning offchain workers at {:?}", at);
let header = header.clone();
let client = self.client.clone();
@@ -156,18 +150,19 @@ impl<Client, Block> OffchainWorkers<
let runtime = client.runtime_api();
let api = Box::new(api);
debug!("Running offchain workers at {:?}", at);
let context = ExecutionContext::OffchainCall(Some(
(api, offchain::Capabilities::all())
));
let context =
ExecutionContext::OffchainCall(Some((api, offchain::Capabilities::all())));
let run = if version == 2 {
runtime.offchain_worker_with_context(&at, context, &header)
} else {
#[allow(deprecated)]
runtime.offchain_worker_before_version_2_with_context(
&at, context, *header.number()
&at,
context,
*header.number(),
)
};
if let Err(e) = run {
if let Err(e) = run {
log::error!("Error running offchain workers at {:?}: {:?}", at, e);
}
});
@@ -197,50 +192,51 @@ pub async fn notification_future<Client, Block, Spawner>(
offchain: Arc<OffchainWorkers<Client, Block>>,
spawner: Spawner,
network_provider: Arc<dyn NetworkProvider + Send + Sync>,
)
where
Block: traits::Block,
Client: ProvideRuntimeApi<Block> + sc_client_api::BlockchainEvents<Block> + Send + Sync + 'static,
Client::Api: OffchainWorkerApi<Block>,
Spawner: SpawnNamed
) where
Block: traits::Block,
Client:
ProvideRuntimeApi<Block> + sc_client_api::BlockchainEvents<Block> + Send + Sync + 'static,
Client::Api: OffchainWorkerApi<Block>,
Spawner: SpawnNamed,
{
client.import_notification_stream().for_each(move |n| {
if n.is_new_best {
spawner.spawn(
"offchain-on-block",
offchain.on_block_imported(
&n.header,
network_provider.clone(),
is_validator,
).boxed(),
);
} else {
log::debug!(
target: "sc_offchain",
"Skipping offchain workers for non-canon block: {:?}",
n.header,
)
}
client
.import_notification_stream()
.for_each(move |n| {
if n.is_new_best {
spawner.spawn(
"offchain-on-block",
offchain
.on_block_imported(&n.header, network_provider.clone(), is_validator)
.boxed(),
);
} else {
log::debug!(
target: "sc_offchain",
"Skipping offchain workers for non-canon block: {:?}",
n.header,
)
}
ready(())
}).await;
ready(())
})
.await;
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::Arc;
use sc_network::{Multiaddr, PeerId};
use substrate_test_runtime_client::{
TestClient, runtime::Block, TestClientBuilderExt,
DefaultTestClientBuilderExt, ClientBlockImportExt,
};
use sc_transaction_pool::{BasicPool, FullChainApi};
use sc_transaction_pool_api::{TransactionPool, InPoolTransaction};
use sp_consensus::BlockOrigin;
use sc_client_api::Backend as _;
use sc_block_builder::BlockBuilderProvider as _;
use futures::executor::block_on;
use sc_block_builder::BlockBuilderProvider as _;
use sc_client_api::Backend as _;
use sc_network::{Multiaddr, PeerId};
use sc_transaction_pool::{BasicPool, FullChainApi};
use sc_transaction_pool_api::{InPoolTransaction, TransactionPool};
use sp_consensus::BlockOrigin;
use std::sync::Arc;
use substrate_test_runtime_client::{
runtime::Block, ClientBlockImportExt, DefaultTestClientBuilderExt, TestClient,
TestClientBuilderExt,
};
struct TestNetwork();
@@ -264,9 +260,7 @@ mod tests {
}
}
struct TestPool(
Arc<BasicPool<FullChainApi<TestClient, Block>, Block>>
);
struct TestPool(Arc<BasicPool<FullChainApi<TestClient, Block>, Block>>);
impl sc_transaction_pool_api::OffchainSubmitTransaction<Block> for TestPool {
fn submit_at(
@@ -299,9 +293,7 @@ mod tests {
// when
let offchain = OffchainWorkers::new(client);
futures::executor::block_on(
offchain.on_block_imported(&header, network, false)
);
futures::executor::block_on(offchain.on_block_imported(&header, network, false));
// then
assert_eq!(pool.0.status().ready, 1);
@@ -314,22 +306,21 @@ mod tests {
sp_tracing::try_init_simple();
let (client, backend) =
substrate_test_runtime_client::TestClientBuilder::new()
.enable_offchain_indexing_api()
.build_with_backend();
let (client, backend) = substrate_test_runtime_client::TestClientBuilder::new()
.enable_offchain_indexing_api()
.build_with_backend();
let mut client = Arc::new(client);
let offchain_db = backend.offchain_storage().unwrap();
let key = &b"hello"[..];
let value = &b"world"[..];
let mut block_builder = client.new_block(Default::default()).unwrap();
block_builder.push(
substrate_test_runtime_client::runtime::Extrinsic::OffchainIndexSet(
block_builder
.push(substrate_test_runtime_client::runtime::Extrinsic::OffchainIndexSet(
key.to_vec(),
value.to_vec(),
),
).unwrap();
))
.unwrap();
let block = block_builder.build().unwrap().block;
block_on(client.import(BlockOrigin::Own, block)).unwrap();
@@ -337,9 +328,11 @@ mod tests {
assert_eq!(value, &offchain_db.get(sp_offchain::STORAGE_PREFIX, &key).unwrap());
let mut block_builder = client.new_block(Default::default()).unwrap();
block_builder.push(
substrate_test_runtime_client::runtime::Extrinsic::OffchainIndexClear(key.to_vec()),
).unwrap();
block_builder
.push(substrate_test_runtime_client::runtime::Extrinsic::OffchainIndexClear(
key.to_vec(),
))
.unwrap();
let block = block_builder.build().unwrap().block;
block_on(client.import(BlockOrigin::Own, block)).unwrap();