mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-07-08 05:27:27 +00:00
Max Inden
2d5ec72331
* client/authority-discovery: Rename AuthorityDiscovery to XXXWorker
* client/authority-discovery: Introduce AuthorityDiscoveryService
Add a basic `AuthorityDiscoveryService` implementation which enables
callers to get the addresses for a given `AuthorityId` from the local
cache.
* client/authority-discovery: Split into worker and service mod
Move `Service` and `Worker` to their own Rust modules resulting in the
following file structure.
├── build.rs
├── Cargo.toml
└── src
├── error.rs
├── lib.rs
├── service.rs
├── tests.rs
├── worker
│ ├── addr_cache.rs
│ ├── schema
│ │ └── dht.proto
│ └── tests.rs
└── worker.rs
* client/authority-discovery: Cache PeerId -> AuthorityId mapping
* client/authority-discovery: Update priority group on interval
Instead of updating the authority discovery peerset priority group each
time a new DHT value is found, update it regularly on an interval.
This removes the need for deterministic random selection. Instead of
trying to return a random stable set of `Multiaddr`s, the `AddrCache`
now returns a random set on each call.
* client/authority-discovery: Implement Service::get_authority_id
* client/authority-discovery: Use HashMap instead of BTreeMap
* client/authority-discovery: Rework priority group interval
* client/authority-discovery: Fix comment
* bin/node/cli: Update authority discovery constructor
* client/authority-discovery: Fuse from_service receiver
* client/authority-discovery: Remove Rng import
* client/authority-discovery: Ignore Multiaddr without PeerId
* client/authority-discovery/service: Add note on returned None
* client/authority-discovery/addr_cache: Replace double clone with deref
79 lines
2.4 KiB
Rust
79 lines
2.4 KiB
Rust
// This file is part of Substrate.
|
|
|
|
// Copyright (C) 2017-2020 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::{new_worker_and_service, worker::{tests::{TestApi, TestNetwork}, Role}};
|
|
|
|
use std::sync::Arc;
|
|
|
|
use futures::prelude::*;
|
|
use futures::channel::mpsc::channel;
|
|
use futures::executor::LocalPool;
|
|
use futures::task::LocalSpawn;
|
|
use libp2p::core::{multiaddr::{Multiaddr, Protocol}, PeerId};
|
|
|
|
use sp_authority_discovery::AuthorityId;
|
|
use sp_core::crypto::key_types;
|
|
use sp_core::testing::KeyStore;
|
|
|
|
#[test]
|
|
fn get_addresses_and_authority_id() {
|
|
let (_dht_event_tx, dht_event_rx) = channel(0);
|
|
let network: Arc<TestNetwork> = Arc::new(Default::default());
|
|
|
|
let key_store = KeyStore::new();
|
|
let remote_authority_id: AuthorityId = key_store
|
|
.write()
|
|
.sr25519_generate_new(key_types::AUTHORITY_DISCOVERY, None)
|
|
.unwrap()
|
|
.into();
|
|
|
|
let remote_peer_id = PeerId::random();
|
|
let remote_addr = "/ip6/2001:db8:0:0:0:0:0:2/tcp/30333".parse::<Multiaddr>()
|
|
.unwrap()
|
|
.with(Protocol::P2p(remote_peer_id.clone().into()));
|
|
|
|
let test_api = Arc::new(TestApi {
|
|
authorities: vec![],
|
|
});
|
|
|
|
let (mut worker, mut service) = new_worker_and_service(
|
|
test_api,
|
|
network.clone(),
|
|
vec![],
|
|
dht_event_rx.boxed(),
|
|
Role::Authority(key_store),
|
|
None,
|
|
);
|
|
|
|
worker.inject_addresses(remote_authority_id.clone(), vec![remote_addr.clone()]);
|
|
|
|
let mut pool = LocalPool::new();
|
|
pool.spawner().spawn_local_obj(Box::pin(worker).into()).unwrap();
|
|
|
|
pool.run_until(async {
|
|
assert_eq!(
|
|
Some(vec![remote_addr]),
|
|
service.get_addresses_by_authority_id(remote_authority_id.clone()).await,
|
|
);
|
|
assert_eq!(
|
|
Some(remote_authority_id),
|
|
service.get_authority_id_by_peer_id(remote_peer_id).await,
|
|
);
|
|
});
|
|
}
|