pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-12 07:41:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

sp-utils => sc-utils (#9677)

Browse Source 
* sp-utils => sc-utils

* cargo fmt

* These files are now in the client so should be licensed as GPL3

* Apply suggestions from code review

Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>
This commit is contained in:
Squirrel
2021-09-04 20:20:48 +01:00
committed by GitHub
parent 8c3ad4300a
commit ffced22fb7
51 changed files with 206 additions and 194 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/client/api/Cargo.toml
+1 -1
View File
@@ -30,7 +30,7 @@ sp-database = { version = "4.0.0-dev", path = "../../primitives/database" }
sp-core = { version = "4.0.0-dev", default-features = false, path = "../../primitives/core" }
sp-keystore = { version = "0.10.0-dev", default-features = false, path = "../../primitives/keystore" }
sp-api = { version = "4.0.0-dev", path = "../../primitives/api" }
sp-utils = { version = "4.0.0-dev", path = "../../primitives/utils" }
sc-utils = { version = "4.0.0-dev", path = "../utils" }
sp-runtime = { version = "4.0.0-dev", default-features = false, path = "../../primitives/runtime" }
sp-state-machine = { version = "0.10.0-dev", path = "../../primitives/state-machine" }
sp-trie = { version = "4.0.0-dev", path = "../../primitives/trie" }
substrate/client/api/src/client.rs
+1 -1
View File
@@ -29,8 +29,8 @@ use std::{collections::HashSet, convert::TryFrom, fmt, sync::Arc};
use crate::{blockchain::Info, notifications::StorageEventStream};
use sc_transaction_pool_api::ChainEvent;
use sc_utils::mpsc::TracingUnboundedReceiver;
use sp_blockchain;
use sp_utils::mpsc::TracingUnboundedReceiver;
/// Type that implements `futures::Stream` of block import events.
pub type ImportNotifications<Block> = TracingUnboundedReceiver<BlockImportNotification<Block>>;
substrate/client/api/src/notifications.rs
+1 -1
View File
@@ -25,9 +25,9 @@ use std::{
use fnv::{FnvHashMap, FnvHashSet};
use prometheus_endpoint::{register, CounterVec, Opts, Registry, U64};
use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use sp_core::storage::{StorageData, StorageKey};
use sp_runtime::traits::Block as BlockT;
use sp_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
/// Storage change set
#[derive(Debug)]
substrate/client/cli/Cargo.toml
+1 -1
View File
@@ -30,7 +30,7 @@ sc-client-api = { version = "4.0.0-dev", path = "../api" }
sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
sc-network = { version = "0.10.0-dev", path = "../network" }
sp-runtime = { version = "4.0.0-dev", path = "../../primitives/runtime" }
sp-utils = { version = "4.0.0-dev", path = "../../primitives/utils" }
sc-utils = { version = "4.0.0-dev", path = "../utils" }
sp-version = { version = "4.0.0-dev", path = "../../primitives/version" }
sp-core = { version = "4.0.0-dev", path = "../../primitives/core" }
sp-keystore = { version = "0.10.0-dev", path = "../../primitives/keystore" }
substrate/client/cli/src/runner.rs
+1 -1
View File
@@ -21,7 +21,7 @@ use chrono::prelude::*;
use futures::{future, future::FutureExt, pin_mut, select, Future};
use log::info;
use sc_service::{Configuration, Error as ServiceError, TaskManager, TaskType};
use sp_utils::metrics::{TOKIO_THREADS_ALIVE, TOKIO_THREADS_TOTAL};
use sc_utils::metrics::{TOKIO_THREADS_ALIVE, TOKIO_THREADS_TOTAL};
use std::marker::PhantomData;
#[cfg(target_family = "unix")]
substrate/client/consensus/common/Cargo.toml
+1 -1
View File
@@ -24,7 +24,7 @@ sp-core = { path = "../../../primitives/core", version = "4.0.0-dev" }
sp-consensus = { path = "../../../primitives/consensus/common", version = "0.10.0-dev" }
sp-state-machine = { version = "0.10.0-dev", path = "../../../primitives/state-machine" }
sp-runtime = { version = "4.0.0-dev", path = "../../../primitives/runtime" }
sp-utils = { version = "4.0.0-dev", path = "../../../primitives/utils" }
sc-utils = { version = "4.0.0-dev", path = "../../utils" }
sp-api = { version = "4.0.0-dev", path = "../../../primitives/api" }
parking_lot = "0.11.1"
serde = { version = "1.0", features = ["derive"] }
substrate/client/consensus/common/src/block_import.rs
+13 -12
View File
@@ -1,19 +1,20 @@
// This file is part of Substrate.
// Copyright (C) 2017-2021 Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: Apache-2.0
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// This program 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.
// This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
//! Block import helpers.
substrate/client/consensus/common/src/import_queue.rs
+13 -12
View File
@@ -1,19 +1,20 @@
// This file is part of Substrate.
// Copyright (C) 2017-2021 Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: Apache-2.0
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// This program 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.
// This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
//! Import Queue primitive: something which can verify and import blocks.
//!
substrate/client/consensus/common/src/import_queue/basic_queue.rs
+14 -13
View File
@@ -1,19 +1,20 @@
// This file is part of Substrate.
// Copyright (C) 2017-2021 Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: Apache-2.0
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// This program 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.
// This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
use futures::{
prelude::*,
task::{Context, Poll},
@@ -21,12 +22,12 @@ use futures::{
use futures_timer::Delay;
use log::{debug, trace};
use prometheus_endpoint::Registry;
use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use sp_consensus::BlockOrigin;
use sp_runtime::{
traits::{Block as BlockT, Header as HeaderT, NumberFor},
Justification, Justifications,
};
use sp_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use std::{marker::PhantomData, pin::Pin, time::Duration};
use crate::{
substrate/client/consensus/common/src/import_queue/buffered_link.rs
+14 -13
View File
@@ -1,19 +1,20 @@
// This file is part of Substrate.
// Copyright (C) 2017-2021 Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: Apache-2.0
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// This program 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.
// This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
//! Provides the `buffered_link` utility.
//!
@@ -39,8 +40,8 @@
use crate::import_queue::{Link, Origin};
use futures::prelude::*;
use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use sp_runtime::traits::{Block as BlockT, NumberFor};
use sp_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use std::{
pin::Pin,
task::{Context, Poll},
substrate/client/consensus/common/src/metrics.rs
+13 -12
View File
@@ -1,19 +1,20 @@
// This file is part of Substrate.
// Copyright (C) 2020-2021 Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: Apache-2.0
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// This program 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.
// This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
//! Metering tools for consensus
substrate/client/finality-grandpa/Cargo.toml
+1 -1
View File
@@ -27,7 +27,7 @@ parity-scale-codec = { version = "2.0.0", features = ["derive"] }
sp-application-crypto = { version = "4.0.0-dev", path = "../../primitives/application-crypto" }
sp-arithmetic = { version = "4.0.0-dev", path = "../../primitives/arithmetic" }
sp-runtime = { version = "4.0.0-dev", path = "../../primitives/runtime" }
sp-utils = { version = "4.0.0-dev", path = "../../primitives/utils" }
sc-utils = { version = "4.0.0-dev", path = "../utils" }
sp-consensus = { version = "0.10.0-dev", path = "../../primitives/consensus/common" }
sc-consensus = { version = "0.10.0-dev", path = "../consensus/common" }
sp-core = { version = "4.0.0-dev", path = "../../primitives/core" }
substrate/client/finality-grandpa/src/communication/gossip.rs
+1 -1
View File
@@ -94,7 +94,7 @@ use log::{debug, trace};
use prometheus_endpoint::{register, CounterVec, Opts, PrometheusError, Registry, U64};
use rand::seq::SliceRandom;
use sc_telemetry::{telemetry, TelemetryHandle, CONSENSUS_DEBUG};
use sp_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use super::{benefit, cost, Round, SetId};
use crate::{environment, CatchUp, CompactCommit, SignedMessage};
substrate/client/finality-grandpa/src/communication/mod.rs
+1 -1
View File
@@ -58,8 +58,8 @@ use crate::{
use gossip::{
FullCatchUpMessage, FullCommitMessage, GossipMessage, GossipValidator, PeerReport, VoteMessage,
};
use sc_utils::mpsc::TracingUnboundedReceiver;
use sp_finality_grandpa::{AuthorityId, AuthoritySignature, RoundNumber, SetId as SetIdNumber};
use sp_utils::mpsc::TracingUnboundedReceiver;
pub mod gossip;
mod periodic;
substrate/client/finality-grandpa/src/communication/periodic.rs
+1 -1
View File
@@ -21,7 +21,7 @@
use futures::{future::FutureExt as _, prelude::*, ready, stream::Stream};
use futures_timer::Delay;
use log::debug;
use sp_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use std::{
pin::Pin,
task::{Context, Poll},
substrate/client/finality-grandpa/src/communication/tests.rs
+1 -1
View File
@@ -28,10 +28,10 @@ use parity_scale_codec::Encode;
use sc_network::{config::Role, Event as NetworkEvent, ObservedRole, PeerId};
use sc_network_gossip::Validator;
use sc_network_test::{Block, Hash};
use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use sp_finality_grandpa::AuthorityList;
use sp_keyring::Ed25519Keyring;
use sp_runtime::traits::NumberFor;
use sp_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use std::{
borrow::Cow,
pin::Pin,
substrate/client/finality-grandpa/src/import.rs
+1 -1
View File
@@ -27,6 +27,7 @@ use sc_consensus::{
BlockCheckParams, BlockImport, BlockImportParams, ImportResult, JustificationImport,
};
use sc_telemetry::TelemetryHandle;
use sc_utils::mpsc::TracingUnboundedSender;
use sp_api::{Core, RuntimeApiInfo, TransactionFor};
use sp_blockchain::{well_known_cache_keys, BlockStatus};
use sp_consensus::{BlockOrigin, Error as ConsensusError, SelectChain};
@@ -37,7 +38,6 @@ use sp_runtime::{
traits::{Block as BlockT, DigestFor, Header as HeaderT, NumberFor, Zero},
Justification,
};
use sp_utils::mpsc::TracingUnboundedSender;
use crate::{
authorities::{AuthoritySet, DelayKind, PendingChange, SharedAuthoritySet},
substrate/client/finality-grandpa/src/lib.rs
+1 -1
View File
@@ -68,6 +68,7 @@ use sc_client_api::{
};
use sc_consensus::BlockImport;
use sc_telemetry::{telemetry, TelemetryHandle, CONSENSUS_DEBUG, CONSENSUS_INFO};
use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver};
use sp_api::ProvideRuntimeApi;
use sp_application_crypto::AppKey;
use sp_blockchain::{Error as ClientError, HeaderBackend, HeaderMetadata};
@@ -78,7 +79,6 @@ use sp_runtime::{
generic::BlockId,
traits::{Block as BlockT, DigestFor, NumberFor, Zero},
};
use sp_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver};
pub use finality_grandpa::BlockNumberOps;
use finality_grandpa::{voter, voter_set::VoterSet, Error as GrandpaError};
substrate/client/finality-grandpa/src/notification.rs
+1 -1
View File
@@ -19,8 +19,8 @@
use parking_lot::Mutex;
use std::sync::Arc;
use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use sp_runtime::traits::Block as BlockT;
use sp_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use crate::{justification::GrandpaJustification, Error};
substrate/client/finality-grandpa/src/observer.rs
+2 -2
View File
@@ -29,12 +29,12 @@ use log::{debug, info, warn};
use sc_client_api::backend::Backend;
use sc_telemetry::TelemetryHandle;
use sc_utils::mpsc::TracingUnboundedReceiver;
use sp_blockchain::HeaderMetadata;
use sp_consensus::SelectChain;
use sp_finality_grandpa::AuthorityId;
use sp_keystore::SyncCryptoStorePtr;
use sp_runtime::traits::{Block as BlockT, NumberFor};
use sp_utils::mpsc::TracingUnboundedReceiver;
use crate::{
authorities::SharedAuthoritySet,
@@ -403,8 +403,8 @@ mod tests {
};
use assert_matches::assert_matches;
use sc_network::PeerId;
use sc_utils::mpsc::tracing_unbounded;
use sp_blockchain::HeaderBackend as _;
use sp_utils::mpsc::tracing_unbounded;
use substrate_test_runtime_client::{TestClientBuilder, TestClientBuilderExt};
use futures::executor;
substrate/client/finality-grandpa/src/until_imported.rs
+2 -2
View File
@@ -37,9 +37,9 @@ use log::{debug, warn};
use parking_lot::Mutex;
use prometheus_endpoint::{register, Gauge, PrometheusError, Registry, U64};
use sc_client_api::{BlockImportNotification, ImportNotifications};
use sc_utils::mpsc::TracingUnboundedReceiver;
use sp_finality_grandpa::AuthorityId;
use sp_runtime::traits::{Block as BlockT, Header as HeaderT, NumberFor};
use sp_utils::mpsc::TracingUnboundedReceiver;
use std::{
collections::{HashMap, VecDeque},
@@ -561,8 +561,8 @@ mod tests {
use futures::future::Either;
use futures_timer::Delay;
use sc_client_api::BlockImportNotification;
use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedSender};
use sp_consensus::BlockOrigin;
use sp_utils::mpsc::{tracing_unbounded, TracingUnboundedSender};
use substrate_test_runtime_client::runtime::{Block, Hash, Header};
#[derive(Clone)]
substrate/client/network/Cargo.toml
+1 -1
View File
@@ -55,7 +55,7 @@ sp-consensus = { version = "0.10.0-dev", path = "../../primitives/consensus/comm
sc-consensus = { version = "0.10.0-dev", path = "../consensus/common" }
sp-core = { version = "4.0.0-dev", path = "../../primitives/core" }
sp-runtime = { version = "4.0.0-dev", path = "../../primitives/runtime" }
sp-utils = { version = "4.0.0-dev", path = "../../primitives/utils" }
sc-utils = { version = "4.0.0-dev", path = "../utils" }
sp-finality-grandpa = { version = "4.0.0-dev", path = "../../primitives/finality-grandpa" }
thiserror = "1"
unsigned-varint = { version = "0.6.0", features = [
substrate/client/network/src/on_demand_layer.rs
+1 -1
View File
@@ -27,9 +27,9 @@ use sc_client_api::{
RemoteChangesRequest, RemoteHeaderRequest, RemoteReadChildRequest, RemoteReadRequest,
StorageProof,
};
use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use sp_blockchain::Error as ClientError;
use sp_runtime::traits::{Block as BlockT, Header as HeaderT, NumberFor};
use sp_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use std::{
collections::HashMap,
pin::Pin,
substrate/client/network/src/service.rs
+1 -1
View File
@@ -70,8 +70,8 @@ use metrics::{Histogram, HistogramVec, MetricSources, Metrics};
use parking_lot::Mutex;
use sc_consensus::{BlockImportError, BlockImportStatus, ImportQueue, Link};
use sc_peerset::PeersetHandle;
use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use sp_runtime::traits::{Block as BlockT, NumberFor};
use sp_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use std::{
borrow::Cow,
cmp,
substrate/client/offchain/Cargo.toml
+1 -1
View File
@@ -29,7 +29,7 @@ sp-api = { version = "4.0.0-dev", path = "../../primitives/api" }
sp-core = { version = "4.0.0-dev", path = "../../primitives/core" }
sp-offchain = { version = "4.0.0-dev", path = "../../primitives/offchain" }
sp-runtime = { version = "4.0.0-dev", path = "../../primitives/runtime" }
sp-utils = { version = "4.0.0-dev", path = "../../primitives/utils" }
sc-utils = { version = "4.0.0-dev", path = "../utils" }
threadpool = "1.7"
[target.'cfg(not(target_os = "unknown"))'.dependencies]
substrate/client/offchain/src/api/http.rs
+1 -1
View File
@@ -34,8 +34,8 @@ use futures::{channel::mpsc, future, prelude::*};
use hyper::{client, Body, Client as HyperClient};
use hyper_rustls::HttpsConnector;
use log::error;
use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use sp_core::offchain::{HttpError, HttpRequestId, HttpRequestStatus, Timestamp};
use sp_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use std::{
convert::TryFrom,
fmt,
substrate/client/peerset/Cargo.toml
+1 -1
View File
@@ -17,7 +17,7 @@ targets = ["x86_64-unknown-linux-gnu"]
[dependencies]
futures = "0.3.9"
libp2p = { version = "0.39.1", default-features = false }
sp-utils = { version = "4.0.0-dev", path = "../../primitives/utils"}
sc-utils = { version = "4.0.0-dev", path = "../utils"}
log = "0.4.8"
serde_json = "1.0.41"
wasm-timer = "0.2"
substrate/client/peerset/src/lib.rs
+1 -1
View File
@@ -36,8 +36,8 @@ mod peersstate;
use futures::prelude::*;
use log::{debug, error, trace};
use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use serde_json::json;
use sp_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use std::{
collections::{HashMap, HashSet, VecDeque},
pin::Pin,
substrate/client/rpc/Cargo.toml
+1 -1
View File
@@ -27,7 +27,7 @@ serde_json = "1.0.41"
sp-session = { version = "4.0.0-dev", path = "../../primitives/session" }
sp-offchain = { version = "4.0.0-dev", path = "../../primitives/offchain" }
sp-runtime = { version = "4.0.0-dev", path = "../../primitives/runtime" }
sp-utils = { version = "4.0.0-dev", path = "../../primitives/utils" }
sc-utils = { version = "4.0.0-dev", path = "../utils" }
sp-rpc = { version = "4.0.0-dev", path = "../../primitives/rpc" }
sp-keystore = { version = "0.10.0-dev", path = "../../primitives/keystore" }
sc-chain-spec = { version = "4.0.0-dev", path = "../chain-spec" }
substrate/client/rpc/src/system/mod.rs
+1 -1
View File
@@ -22,8 +22,8 @@ use self::error::Result;
use futures::{channel::oneshot, FutureExt};
use sc_rpc_api::{DenyUnsafe, Receiver};
use sc_tracing::logging;
use sc_utils::mpsc::TracingUnboundedSender;
use sp_runtime::traits::{self, Header as HeaderT};
use sp_utils::mpsc::TracingUnboundedSender;
pub use self::{
gen_client::Client as SystemClient,
substrate/client/rpc/src/system/tests.rs
+1 -1
View File
@@ -21,7 +21,7 @@ use super::*;
use assert_matches::assert_matches;
use futures::{executor, prelude::*};
use sc_network::{self, config::Role, PeerId};
use sp_utils::mpsc::tracing_unbounded;
use sc_utils::mpsc::tracing_unbounded;
use std::{
env,
io::{BufRead, BufReader, Write},
substrate/client/service/Cargo.toml
+1 -1
View File
@@ -39,7 +39,7 @@ sc-keystore = { version = "4.0.0-dev", path = "../keystore" }
sp-runtime = { version = "4.0.0-dev", path = "../../primitives/runtime" }
sp-trie = { version = "4.0.0-dev", path = "../../primitives/trie" }
sp-externalities = { version = "0.10.0-dev", path = "../../primitives/externalities" }
sp-utils = { version = "4.0.0-dev", path = "../../primitives/utils" }
sc-utils = { version = "4.0.0-dev", path = "../utils" }
sp-version = { version = "4.0.0-dev", path = "../../primitives/version" }
sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
sp-core = { version = "4.0.0-dev", path = "../../primitives/core" }
substrate/client/service/src/builder.rs
+1 -1
View File
@@ -49,6 +49,7 @@ use sc_network::{
};
use sc_telemetry::{telemetry, ConnectionMessage, Telemetry, TelemetryHandle, SUBSTRATE_INFO};
use sc_transaction_pool_api::MaintainedTransactionPool;
use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedSender};
use sp_api::{CallApiAt, ProvideRuntimeApi};
use sp_blockchain::{HeaderBackend, HeaderMetadata};
use sp_consensus::block_validation::{
@@ -61,7 +62,6 @@ use sp_runtime::{
traits::{Block as BlockT, BlockIdTo, HashFor, Zero},
BuildStorage,
};
use sp_utils::mpsc::{tracing_unbounded, TracingUnboundedSender};
use std::{str::FromStr, sync::Arc, time::SystemTime};
/// A utility trait for building an RPC extension given a `DenyUnsafe` instance.
substrate/client/service/src/client/client.rs
+1 -1
View File
@@ -61,6 +61,7 @@ use sp_blockchain::{
};
use sp_consensus::{BlockOrigin, BlockStatus, Error as ConsensusError};
use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedSender};
use sp_core::{
convert_hash,
storage::{well_known_keys, ChildInfo, PrefixedStorageKey, StorageData, StorageKey},
@@ -82,7 +83,6 @@ use sp_state_machine::{
ChangesTrieConfigurationRange, ChangesTrieRootsStorage, ChangesTrieStorage, DBValue,
};
use sp_trie::StorageProof;
use sp_utils::mpsc::{tracing_unbounded, TracingUnboundedSender};
use std::{
collections::{BTreeMap, HashMap, HashSet},
marker::PhantomData,
substrate/client/service/src/lib.rs
+1 -1
View File
@@ -41,11 +41,11 @@ use futures::{stream, Future, FutureExt, Stream, StreamExt};
use log::{debug, error, warn};
use parity_util_mem::MallocSizeOf;
use sc_network::PeerId;
use sc_utils::mpsc::TracingUnboundedReceiver;
use sp_runtime::{
generic::BlockId,
traits::{Block as BlockT, Header as HeaderT},
};
use sp_utils::mpsc::TracingUnboundedReceiver;
pub use self::{
builder::{
substrate/client/service/src/metrics.rs
+1 -1
View File
@@ -25,9 +25,9 @@ use sc_client_api::{ClientInfo, UsageProvider};
use sc_network::{config::Role, NetworkService, NetworkStatus};
use sc_telemetry::{telemetry, TelemetryHandle, SUBSTRATE_INFO};
use sc_transaction_pool_api::{MaintainedTransactionPool, PoolStatus};
use sc_utils::metrics::register_globals;
use sp_api::ProvideRuntimeApi;
use sp_runtime::traits::{Block, NumberFor, SaturatedConversion, UniqueSaturatedInto};
use sp_utils::metrics::register_globals;
use std::{
sync::Arc,
time::{Duration, Instant},
substrate/client/service/src/task_manager/mod.rs
+1 -1
View File
@@ -33,7 +33,7 @@ use prometheus_endpoint::{
exponential_buckets, register, CounterVec, HistogramOpts, HistogramVec, Opts, PrometheusError,
Registry, U64,
};
use sp_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use std::{panic, pin::Pin, result::Result};
use tracing_futures::Instrument;
substrate/client/transaction-pool/Cargo.toml
+1 -1
View File
@@ -29,7 +29,7 @@ sp-tracing = { version = "4.0.0-dev", path = "../../primitives/tracing" }
sp-transaction-pool = { version = "4.0.0-dev", path = "../../primitives/transaction-pool" }
sc-transaction-pool-api = { version = "4.0.0-dev", path = "./api" }
sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
sp-utils = { version = "4.0.0-dev", path = "../../primitives/utils" }
sc-utils = { version = "4.0.0-dev", path = "../utils" }
serde = { version = "1.0.126", features = ["derive"] }
linked-hash-map = "0.5.4"
retain_mut = "0.1.3"
substrate/client/transaction-pool/api/src/error.rs
+13 -12
View File
@@ -1,19 +1,20 @@
// This file is part of Substrate.
// Copyright (C) 2018-2021 Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: Apache-2.0
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// This program 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.
// This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
//! Transaction pool errors.
substrate/client/transaction-pool/api/src/lib.rs
+13 -12
View File
@@ -1,19 +1,20 @@
// This file is part of Substrate.
// Copyright (C) 2019-2021 Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: Apache-2.0
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// This program 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.
// This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
//! Transaction pool client facing API.
#![warn(missing_docs)]
substrate/client/transaction-pool/graph/Cargo.toml
+1 -1
View File
@@ -20,7 +20,7 @@ log = "0.4.8"
parking_lot = "0.11.1"
serde = { version = "1.0.101", features = ["derive"] }
sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
sp-utils = { version = "4.0.0-dev", path = "../../../primitives/utils" }
sc-utils = { version = "4.0.0-dev", path = "../../utils" }
sp-core = { version = "4.0.0-dev", path = "../../../primitives/core" }
sp-runtime = { version = "4.0.0-dev", path = "../../../primitives/runtime" }
sp-transaction-pool = { version = "4.0.0-dev", path = "../../../primitives/transaction-pool" }
substrate/client/transaction-pool/src/graph/watcher.rs
+1 -1
View File
@@ -20,7 +20,7 @@
use futures::Stream;
use sc_transaction_pool_api::TransactionStatus;
use sp_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
/// Extrinsic watcher.
///
substrate/client/transaction-pool/src/revalidation.rs
+1 -1
View File
@@ -25,12 +25,12 @@ use std::{
};
use crate::graph::{ChainApi, ExtrinsicHash, NumberFor, Pool, ValidatedTransaction};
use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use sp_runtime::{
generic::BlockId,
traits::{SaturatedConversion, Zero},
transaction_validity::TransactionValidityError,
};
use sp_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use futures::prelude::*;
use std::time::Duration;
substrate/client/utils/Cargo.toml
+20
View File
@@ -0,0 +1,20 @@
[package]
name = "sc-utils"
version = "4.0.0-dev"
authors = ["Parity Technologies <admin@parity.io>"]
edition = "2018"
license = "Apache-2.0"
homepage = "https://substrate.dev"
repository = "https://github.com/paritytech/substrate/"
description = "I/O for Substrate runtimes"
readme = "README.md"
[dependencies]
futures = "0.3.9"
lazy_static = "1.4.0"
prometheus = { version = "0.11.0", default-features = false }
futures-timer = "3.0.2"
[features]
default = ["metered"]
metered = []
substrate/client/utils/README.md
+20
View File
@@ -0,0 +1,20 @@
Utilities Primitives for Substrate
## Features
### metered
This feature changes the behaviour of the function `mpsc::tracing_unbounded`.
With the disabled feature this function is an alias to `futures::channel::mpsc::unbounded`.
However, when the feature is enabled it creates wrapper types to `UnboundedSender<T>`
and `UnboundedReceiver<T>` to register every `send`/`received`/`dropped` action happened on
the channel.
Also this feature creates and registers a prometheus vector with name `unbounded_channel_len` and labels:
| Label | Description |
| ------------ | --------------------------------------------- |
| entity | Name of channel passed to `tracing_unbounded` |
| action | One of `send`/`received`/`dropped` |
License: Apache-2.0
substrate/client/utils/src/lib.rs
+41
View File
@@ -0,0 +1,41 @@
// This file is part of Substrate.
// Copyright (C) 2020-2021 Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
// This program 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.
// This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
//! Utilities Primitives for Substrate
//!
//! # Features
//!
//! ## metered
//!
//! This feature changes the behaviour of the function `mpsc::tracing_unbounded`.
//! With the disabled feature this function is an alias to `futures::channel::mpsc::unbounded`.
//! However, when the feature is enabled it creates wrapper types to `UnboundedSender<T>`
//! and `UnboundedReceiver<T>` to register every `send`/`received`/`dropped` action happened on
//! the channel.
//!
//! Also this feature creates and registers a prometheus vector with name `unbounded_channel_len`
//! and labels:
//!
//! | Label | Description |
//! | ------------ | --------------------------------------------- |
//! | entity | Name of channel passed to `tracing_unbounded` |
//! | action | One of `send`/`received`/`dropped` |
pub mod metrics;
pub mod mpsc;
pub mod status_sinks;
substrate/client/utils/src/metrics.rs
+58
View File
@@ -0,0 +1,58 @@
// This file is part of Substrate.
// Copyright (C) 2020-2021 Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
// This program 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.
// This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
//! Metering primitives and globals
use lazy_static::lazy_static;
use prometheus::{
core::{AtomicU64, GenericCounter, GenericGauge},
Error as PrometheusError, Registry,
};
#[cfg(feature = "metered")]
use prometheus::{core::GenericCounterVec, Opts};
lazy_static! {
pub static ref TOKIO_THREADS_TOTAL: GenericCounter<AtomicU64> =
GenericCounter::new("tokio_threads_total", "Total number of threads created")
.expect("Creating of statics doesn't fail. qed");
pub static ref TOKIO_THREADS_ALIVE: GenericGauge<AtomicU64> =
GenericGauge::new("tokio_threads_alive", "Number of threads alive right now")
.expect("Creating of statics doesn't fail. qed");
}
#[cfg(feature = "metered")]
lazy_static! {
pub static ref UNBOUNDED_CHANNELS_COUNTER : GenericCounterVec<AtomicU64> = GenericCounterVec::new(
Opts::new("unbounded_channel_len", "Items in each mpsc::unbounded instance"),
&["entity", "action"] // 'name of channel, send|received|dropped
).expect("Creating of statics doesn't fail. qed");
}
/// Register the statics to report to registry
pub fn register_globals(registry: &Registry) -> Result<(), PrometheusError> {
registry.register(Box::new(TOKIO_THREADS_ALIVE.clone()))?;
registry.register(Box::new(TOKIO_THREADS_TOTAL.clone()))?;
#[cfg(feature = "metered")]
registry.register(Box::new(UNBOUNDED_CHANNELS_COUNTER.clone()))?;
Ok(())
}
substrate/client/utils/src/mpsc.rs
+232
View File
@@ -0,0 +1,232 @@
// This file is part of Substrate.
// Copyright (C) 2020-2021 Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
// This program 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.
// This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
//! Features to meter unbounded channels
#[cfg(not(feature = "metered"))]
mod inner {
// just aliased, non performance implications
use futures::channel::mpsc::{self, UnboundedReceiver, UnboundedSender};
pub type TracingUnboundedSender<T> = UnboundedSender<T>;
pub type TracingUnboundedReceiver<T> = UnboundedReceiver<T>;
/// Alias `mpsc::unbounded`
pub fn tracing_unbounded<T>(
_key: &'static str,
) -> (TracingUnboundedSender<T>, TracingUnboundedReceiver<T>) {
mpsc::unbounded()
}
}
#[cfg(feature = "metered")]
mod inner {
// tracing implementation
use crate::metrics::UNBOUNDED_CHANNELS_COUNTER;
use futures::{
channel::mpsc::{
self, SendError, TryRecvError, TrySendError, UnboundedReceiver, UnboundedSender,
},
sink::Sink,
stream::{FusedStream, Stream},
task::{Context, Poll},
};
use std::pin::Pin;
/// Wrapper Type around `UnboundedSender` that increases the global
/// measure when a message is added
#[derive(Debug)]
pub struct TracingUnboundedSender<T>(&'static str, UnboundedSender<T>);
// Strangely, deriving `Clone` requires that `T` is also `Clone`.
impl<T> Clone for TracingUnboundedSender<T> {
fn clone(&self) -> Self {
Self(self.0, self.1.clone())
}
}
/// Wrapper Type around `UnboundedReceiver` that decreases the global
/// measure when a message is polled
#[derive(Debug)]
pub struct TracingUnboundedReceiver<T>(&'static str, UnboundedReceiver<T>);
/// Wrapper around `mpsc::unbounded` that tracks the in- and outflow via
/// `UNBOUNDED_CHANNELS_COUNTER`
pub fn tracing_unbounded<T>(
key: &'static str,
) -> (TracingUnboundedSender<T>, TracingUnboundedReceiver<T>) {
let (s, r) = mpsc::unbounded();
(TracingUnboundedSender(key, s), TracingUnboundedReceiver(key, r))
}
impl<T> TracingUnboundedSender<T> {
/// Proxy function to mpsc::UnboundedSender
pub fn poll_ready(&self, ctx: &mut Context) -> Poll<Result<(), SendError>> {
self.1.poll_ready(ctx)
}
/// Proxy function to mpsc::UnboundedSender
pub fn is_closed(&self) -> bool {
self.1.is_closed()
}
/// Proxy function to mpsc::UnboundedSender
pub fn close_channel(&self) {
self.1.close_channel()
}
/// Proxy function to mpsc::UnboundedSender
pub fn disconnect(&mut self) {
self.1.disconnect()
}
/// Proxy function to mpsc::UnboundedSender
pub fn start_send(&mut self, msg: T) -> Result<(), SendError> {
self.1.start_send(msg)
}
/// Proxy function to mpsc::UnboundedSender
pub fn unbounded_send(&self, msg: T) -> Result<(), TrySendError<T>> {
self.1.unbounded_send(msg).map(|s| {
UNBOUNDED_CHANNELS_COUNTER.with_label_values(&[self.0, "send"]).inc();
s
})
}
/// Proxy function to mpsc::UnboundedSender
pub fn same_receiver(&self, other: &UnboundedSender<T>) -> bool {
self.1.same_receiver(other)
}
}
impl<T> TracingUnboundedReceiver<T> {
fn consume(&mut self) {
// consume all items, make sure to reflect the updated count
let mut count = 0;
loop {
if self.1.is_terminated() {
break
}
match self.try_next() {
Ok(Some(..)) => count += 1,
_ => break,
}
}
// and discount the messages
if count > 0 {
UNBOUNDED_CHANNELS_COUNTER.with_label_values(&[self.0, "dropped"]).inc_by(count);
}
}
/// Proxy function to mpsc::UnboundedReceiver
/// that consumes all messages first and updates the counter
pub fn close(&mut self) {
self.consume();
self.1.close()
}
/// Proxy function to mpsc::UnboundedReceiver
/// that discounts the messages taken out
pub fn try_next(&mut self) -> Result<Option<T>, TryRecvError> {
self.1.try_next().map(|s| {
if s.is_some() {
UNBOUNDED_CHANNELS_COUNTER.with_label_values(&[self.0, "received"]).inc();
}
s
})
}
}
impl<T> Drop for TracingUnboundedReceiver<T> {
fn drop(&mut self) {
self.consume();
}
}
impl<T> Unpin for TracingUnboundedReceiver<T> {}
impl<T> Stream for TracingUnboundedReceiver<T> {
type Item = T;
fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<T>> {
let s = self.get_mut();
match Pin::new(&mut s.1).poll_next(cx) {
Poll::Ready(msg) => {
if msg.is_some() {
UNBOUNDED_CHANNELS_COUNTER.with_label_values(&[s.0, "received"]).inc();
}
Poll::Ready(msg)
},
Poll::Pending => Poll::Pending,
}
}
}
impl<T> FusedStream for TracingUnboundedReceiver<T> {
fn is_terminated(&self) -> bool {
self.1.is_terminated()
}
}
impl<T> Sink<T> for TracingUnboundedSender<T> {
type Error = SendError;
fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
TracingUnboundedSender::poll_ready(&*self, cx)
}
fn start_send(mut self: Pin<&mut Self>, msg: T) -> Result<(), Self::Error> {
TracingUnboundedSender::start_send(&mut *self, msg)
}
fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(()))
}
fn poll_close(
mut self: Pin<&mut Self>,
_: &mut Context<'_>,
) -> Poll<Result<(), Self::Error>> {
self.disconnect();
Poll::Ready(Ok(()))
}
}
impl<T> Sink<T> for &TracingUnboundedSender<T> {
type Error = SendError;
fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
TracingUnboundedSender::poll_ready(*self, cx)
}
fn start_send(self: Pin<&mut Self>, msg: T) -> Result<(), Self::Error> {
self.unbounded_send(msg).map_err(TrySendError::into_send_error)
}
fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(()))
}
fn poll_close(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.close_channel();
Poll::Ready(Ok(()))
}
}
}
pub use inner::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
substrate/client/utils/src/status_sinks.rs
+218
View File
@@ -0,0 +1,218 @@
// This file is part of Substrate.
// Copyright (C) 2019-2021 Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
// This program 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.
// This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
use crate::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use futures::{lock::Mutex, prelude::*};
use futures_timer::Delay;
use std::{
pin::Pin,
task::{Context, Poll},
time::Duration,
};
/// Holds a list of `UnboundedSender`s, each associated with a certain time period. Every time the
/// period elapses, we push an element on the sender.
///
/// Senders are removed only when they are closed.
pub struct StatusSinks<T> {
/// Should only be locked by `next`.
inner: Mutex<Inner<T>>,
/// Sending side of `Inner::entries_rx`.
entries_tx: TracingUnboundedSender<YieldAfter<T>>,
}
struct Inner<T> {
/// The actual entries of the list.
entries: stream::FuturesUnordered<YieldAfter<T>>,
/// Receives new entries and puts them in `entries`.
entries_rx: TracingUnboundedReceiver<YieldAfter<T>>,
}
struct YieldAfter<T> {
delay: Delay,
interval: Duration,
sender: Option<TracingUnboundedSender<T>>,
}
impl<T> Default for StatusSinks<T> {
fn default() -> Self {
Self::new()
}
}
impl<T> StatusSinks<T> {
/// Builds a new empty collection.
pub fn new() -> StatusSinks<T> {
let (entries_tx, entries_rx) = tracing_unbounded("status-sinks-entries");
StatusSinks {
inner: Mutex::new(Inner { entries: stream::FuturesUnordered::new(), entries_rx }),
entries_tx,
}
}
/// Adds a sender to the collection.
///
/// The `interval` is the time period between two pushes on the sender.
pub fn push(&self, interval: Duration, sender: TracingUnboundedSender<T>) {
let _ = self.entries_tx.unbounded_send(YieldAfter {
delay: Delay::new(interval),
interval,
sender: Some(sender),
});
}
/// Waits until one of the sinks is ready, then returns an object that can be used to send
/// an element on said sink.
///
/// If the object isn't used to send an element, the slot is skipped.
pub async fn next(&self) -> ReadySinkEvent<'_, T> {
// This is only ever locked by `next`, which means that one `next` at a time can run.
let mut inner = self.inner.lock().await;
let inner = &mut *inner;
loop {
// Future that produces the next ready entry in `entries`, or doesn't produce anything
// if the list is empty.
let next_ready_entry = {
let entries = &mut inner.entries;
async move {
if let Some(v) = entries.next().await {
v
} else {
loop {
futures::pending!()
}
}
}
};
futures::select! {
new_entry = inner.entries_rx.next() => {
if let Some(new_entry) = new_entry {
inner.entries.push(new_entry);
}
},
(sender, interval) = next_ready_entry.fuse() => {
return ReadySinkEvent {
sinks: self,
sender: Some(sender),
interval,
}
}
}
}
}
}
/// One of the sinks is ready.
#[must_use]
pub struct ReadySinkEvent<'a, T> {
sinks: &'a StatusSinks<T>,
sender: Option<TracingUnboundedSender<T>>,
interval: Duration,
}
impl<'a, T> ReadySinkEvent<'a, T> {
/// Sends an element on the sender.
pub fn send(mut self, element: T) {
if let Some(sender) = self.sender.take() {
if sender.unbounded_send(element).is_ok() {
let _ = self.sinks.entries_tx.unbounded_send(YieldAfter {
// Note that since there's a small delay between the moment a task is
// woken up and the moment it is polled, the period is actually not
// `interval` but `interval + <delay>`. We ignore this problem in
// practice.
delay: Delay::new(self.interval),
interval: self.interval,
sender: Some(sender),
});
}
}
}
}
impl<'a, T> Drop for ReadySinkEvent<'a, T> {
fn drop(&mut self) {
if let Some(sender) = self.sender.take() {
if sender.is_closed() {
return
}
let _ = self.sinks.entries_tx.unbounded_send(YieldAfter {
delay: Delay::new(self.interval),
interval: self.interval,
sender: Some(sender),
});
}
}
}
impl<T> futures::Future for YieldAfter<T> {
type Output = (TracingUnboundedSender<T>, Duration);
fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
let this = Pin::into_inner(self);
match Pin::new(&mut this.delay).poll(cx) {
Poll::Pending => Poll::Pending,
Poll::Ready(()) => {
let sender = this
.sender
.take()
.expect("sender is always Some unless the future is finished; qed");
Poll::Ready((sender, this.interval))
},
}
}
}
#[cfg(test)]
mod tests {
use super::StatusSinks;
use crate::mpsc::tracing_unbounded;
use futures::prelude::*;
use std::time::Duration;
#[test]
fn works() {
// We're not testing that the `StatusSink` properly enforces an order in the intervals, as
// this easily causes test failures on busy CPUs.
let status_sinks = StatusSinks::new();
let (tx, rx) = tracing_unbounded("test");
status_sinks.push(Duration::from_millis(100), tx);
let mut val_order = 5;
futures::executor::block_on(futures::future::select(
Box::pin(async move {
loop {
let ev = status_sinks.next().await;
val_order += 1;
ev.send(val_order);
}
}),
Box::pin(async {
let items: Vec<i32> = rx.take(3).collect().await;
assert_eq!(items, [6, 7, 8]);
}),
));
}
}