fluencelabs/rust-libp2p
1
0
Fork 0
mirror of https://github.com/fluencelabs/rust-libp2p synced 2025-06-13 01:51:23 +00:00
Code Issues Projects Releases Wiki Activity

Use upstream version of multihash instead of a fork (#1472)

Browse Source 
The changes from the libp2p fork have been backported to upstream, hence
upstream can now be used instead.
This commit is contained in:
Pierre Krieger
2020-03-05 16:49:36 +01:00
committed by GitHub
parent 8337687b3a
commit 10089c5f46
18 changed files with 59 additions and 806 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
protocols/kad/Cargo.toml
View File

@ -19,7 +19,7 @@ futures = "0.3.1"
log = "0.4"
libp2p-core = { version = "0.16.0", path = "../../core" }
libp2p-swarm = { version = "0.16.0", path = "../../swarm" }
multihash = { package = "parity-multihash", version = "0.2.3", path = "../../misc/multihash" }
multihash = "0.10"
prost = "0.6.1"
rand = "0.7.2"
sha2 = "0.8.0"

12
protocols/kad/src/behaviour/test.rs
View File

@ -45,7 +45,7 @@ use libp2p_yamux as yamux;
use quickcheck::*;
use rand::{Rng, random, thread_rng};
use std::{collections::{HashSet, HashMap}, io, num::NonZeroUsize, u64};
use multihash::{Multihash, Hash::SHA2256};
use multihash::{wrap, Code, Multihash};
type TestSwarm = Swarm<Kademlia<MemoryStore>>;
@ -106,6 +106,10 @@ fn build_connected_nodes_with_config(total: usize, step: usize, cfg: KademliaCon
(swarm_ids, swarms)
}
fn random_multihash() -> Multihash {
wrap(Code::Sha2_256, &thread_rng().gen::<[u8; 32]>())
}
#[test]
fn bootstrap() {
fn run(rng: &mut impl Rng) {
@ -302,7 +306,7 @@ fn get_record_not_found() {
swarms[0].add_address(&swarm_ids[1], Protocol::Memory(port_base + 1).into());
swarms[1].add_address(&swarm_ids[2], Protocol::Memory(port_base + 2).into());
let target_key = record::Key::from(Multihash::random(SHA2256));
let target_key = record::Key::from(random_multihash());
swarms[0].get_record(&target_key, Quorum::One);
block_on(
@ -460,7 +464,7 @@ fn get_value() {
swarms[0].add_address(&swarm_ids[1], Protocol::Memory(port_base + 1).into());
swarms[1].add_address(&swarm_ids[2], Protocol::Memory(port_base + 2).into());
let record = Record::new(Multihash::random(SHA2256), vec![4,5,6]);
let record = Record::new(random_multihash(), vec![4,5,6]);
swarms[1].store.put(record.clone()).unwrap();
swarms[0].get_record(&record.key, Quorum::One);
@ -495,7 +499,7 @@ fn get_value_many() {
let (_, mut swarms) = build_connected_nodes(num_nodes, num_nodes);
let num_results = 10;
let record = Record::new(Multihash::random(SHA2256), vec![4,5,6]);
let record = Record::new(random_multihash(), vec![4,5,6]);
for i in 0 .. num_nodes {
swarms[i].store.put(record.clone()).unwrap();

6
protocols/kad/src/kbucket/key.rs
View File

@ -173,7 +173,8 @@ pub struct Distance(pub(super) U256);
mod tests {
use super::*;
use quickcheck::*;
use multihash::Hash::SHA2256;
use multihash::{wrap, Code};
use rand::Rng;
impl Arbitrary for Key<PeerId> {
fn arbitrary<G: Gen>(_: &mut G) -> Key<PeerId> {
@ -183,7 +184,8 @@ mod tests {
impl Arbitrary for Key<Multihash> {
fn arbitrary<G: Gen>(_: &mut G) -> Key<Multihash> {
Key::from(Multihash::random(SHA2256))
let hash = rand::thread_rng().gen::<[u8; 32]>();
Key::from(wrap(Code::Sha2_256, &hash))
}
}

5
protocols/kad/src/record.rs
View File

@ -142,13 +142,14 @@ impl ProviderRecord {
mod tests {
use super::*;
use quickcheck::*;
use multihash::Hash::SHA2256;
use multihash::{wrap, Code};
use rand::Rng;
use std::time::Duration;
impl Arbitrary for Key {
fn arbitrary<G: Gen>(_: &mut G) -> Key {
Key::from(Multihash::random(SHA2256))
let hash = rand::thread_rng().gen::<[u8; 32]>();
Key::from(wrap(Code::Sha2_256, &hash))
}
}

17
protocols/kad/src/record/store/memory.rs
View File

@ -215,8 +215,13 @@ impl<'a> RecordStore<'a> for MemoryStore {
#[cfg(test)]
mod tests {
use super::*;
use multihash::Hash::SHA2256;
use multihash::{wrap, Code};
use quickcheck::*;
use rand::Rng;
fn random_multihash() -> Multihash {
wrap(Code::Sha2_256, &rand::thread_rng().gen::<[u8; 32]>())
}
fn distance(r: &ProviderRecord) -> kbucket::Distance {
kbucket::Key::new(r.key.clone())
@ -251,7 +256,7 @@ mod tests {
fn providers_ordered_by_distance_to_key() {
fn prop(providers: Vec<kbucket::Key<PeerId>>) -> bool {
let mut store = MemoryStore::new(PeerId::random());
let key = Key::from(Multihash::random(SHA2256));
let key = Key::from(random_multihash());
let mut records = providers.into_iter().map(|p| {
ProviderRecord::new(key.clone(), p.into_preimage())
@ -274,7 +279,7 @@ mod tests {
fn provided() {
let id = PeerId::random();
let mut store = MemoryStore::new(id.clone());
let key = Multihash::random(SHA2256);
let key = random_multihash();
let rec = ProviderRecord::new(key, id.clone());
assert!(store.add_provider(rec.clone()).is_ok());
assert_eq!(vec![Cow::Borrowed(&rec)], store.provided().collect::<Vec<_>>());
@ -285,7 +290,7 @@ mod tests {
#[test]
fn update_provider() {
let mut store = MemoryStore::new(PeerId::random());
let key = Multihash::random(SHA2256);
let key = random_multihash();
let prv = PeerId::random();
let mut rec = ProviderRecord::new(key, prv);
assert!(store.add_provider(rec.clone()).is_ok());
@ -299,12 +304,12 @@ mod tests {
fn max_provided_keys() {
let mut store = MemoryStore::new(PeerId::random());
for _ in 0 .. store.config.max_provided_keys {
let key = Multihash::random(SHA2256);
let key = random_multihash();
let prv = PeerId::random();
let rec = ProviderRecord::new(key, prv);
let _ = store.add_provider(rec);
}
let key = Multihash::random(SHA2256);
let key = random_multihash();
let prv = PeerId::random();
let rec = ProviderRecord::new(key, prv);
match store.add_provider(rec) {

4
protocols/mdns/src/service.rs
View File

@ -557,7 +557,7 @@ impl fmt::Debug for MdnsPeer {
#[cfg(test)]
mod tests {
use futures::executor::block_on;
use libp2p_core::{PeerId, multiaddr::multihash::*};
use libp2p_core::{PeerId, multiaddr::multihash};
use std::{io::{Error, ErrorKind}, time::Duration};
use wasm_timer::ext::TryFutureExt;
use crate::service::{MdnsPacket, MdnsService};
@ -646,7 +646,7 @@ mod tests {
#[test]
fn discover_long_peer_id() {
let max_value = String::from_utf8(vec![b'f'; 42]).unwrap();
let hash = encode(Hash::Identity, max_value.as_ref()).unwrap();
let hash = multihash::Identity::digest(max_value.as_ref());
discover(PeerId::from_multihash(hash).unwrap())
}
}