pub mod store;
use bytes::Bytes;
use instant::Instant;
use libp2p_core::{multihash::Multihash, Multiaddr, PeerId};
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};
use std::borrow::Borrow;
use std::hash::{Hash, Hasher};
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "serde", serde(crate = "_serde"))]
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct Key(Bytes);
impl Key {
pub fn new<K: AsRef<[u8]>>(key: &K) -> Self {
Key(Bytes::copy_from_slice(key.as_ref()))
}
pub fn to_vec(&self) -> Vec<u8> {
Vec::from(&self.0[..])
}
}
impl Borrow<[u8]> for Key {
fn borrow(&self) -> &[u8] {
&self.0[..]
}
}
impl AsRef<[u8]> for Key {
fn as_ref(&self) -> &[u8] {
&self.0[..]
}
}
impl From<Vec<u8>> for Key {
fn from(v: Vec<u8>) -> Key {
Key(Bytes::from(v))
}
}
impl From<Multihash> for Key {
fn from(m: Multihash) -> Key {
Key::from(m.to_bytes())
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Record {
pub key: Key,
pub value: Vec<u8>,
pub publisher: Option<PeerId>,
pub expires: Option<Instant>,
}
impl Record {
pub fn new<K>(key: K, value: Vec<u8>) -> Self
where
K: Into<Key>,
{
Record {
key: key.into(),
value,
publisher: None,
expires: None,
}
}
pub fn is_expired(&self, now: Instant) -> bool {
self.expires.map_or(false, |t| now >= t)
}
}
#[derive(Clone, Debug)]
pub struct ProviderRecord {
pub key: Key,
pub provider: PeerId,
pub expires: Option<Instant>,
pub addresses: Vec<Multiaddr>,
}
impl Hash for ProviderRecord {
fn hash<H: Hasher>(&self, state: &mut H) {
self.key.hash(state);
self.provider.hash(state);
}
}
impl PartialEq for ProviderRecord {
fn eq(&self, other: &Self) -> bool {
self.key == other.key && self.provider == other.provider
}
}
impl Eq for ProviderRecord {}
impl ProviderRecord {
pub fn new<K>(key: K, provider: PeerId, addresses: Vec<Multiaddr>) -> Self
where
K: Into<Key>,
{
ProviderRecord {
key: key.into(),
provider,
expires: None,
addresses,
}
}
pub fn is_expired(&self, now: Instant) -> bool {
self.expires.map_or(false, |t| now >= t)
}
}
#[cfg(test)]
mod tests {
use super::*;
use libp2p_core::multihash::Code;
use quickcheck::*;
use rand::Rng;
use std::time::Duration;
impl Arbitrary for Key {
fn arbitrary<G: Gen>(_: &mut G) -> Key {
let hash = rand::thread_rng().gen::<[u8; 32]>();
Key::from(Multihash::wrap(Code::Sha2_256.into(), &hash).unwrap())
}
}
impl Arbitrary for Record {
fn arbitrary<G: Gen>(g: &mut G) -> Record {
Record {
key: Key::arbitrary(g),
value: Vec::arbitrary(g),
publisher: if g.gen() {
Some(PeerId::random())
} else {
None
},
expires: if g.gen() {
Some(Instant::now() + Duration::from_secs(g.gen_range(0, 60)))
} else {
None
},
}
}
}
impl Arbitrary for ProviderRecord {
fn arbitrary<G: Gen>(g: &mut G) -> ProviderRecord {
ProviderRecord {
key: Key::arbitrary(g),
provider: PeerId::random(),
expires: if g.gen() {
Some(Instant::now() + Duration::from_secs(g.gen_range(0, 60)))
} else {
None
},
addresses: vec![],
}
}
}
}