Somewhat complete the implementation of Kademlia records.

This commit relates to [libp2p-146] and [libp2p-1089].

  * All records expire (by default, configurable).
  * Provider records are also stored in the RecordStore, and the RecordStore
    API extended.
  * Background jobs for periodic (re-)replication and (re-)publication
    of records. Regular (value-)records are subject to re-replication and
    re-publication as per standard Kademlia. Provider records are only
    subject to re-publication.
  * For standard Kademlia value lookups (quorum = 1), the record is cached
    at the closest peer to the key that did not return the value, as per
    standard Kademlia.
  * Expiration times of regular (value-)records is computed exponentially
    inversely proportional to the number of nodes between the local node
    and the closest node known to the key (beyond the k closest), as per
    standard Kademlia.

The protobuf messages are extended with two fields: `ttl` and `publisher`
in order to implement the different semantics of re-replication (by any
of the k closest peers to the key, not affecting expiry) and re-publication
(by the original publisher, resetting the expiry). This is not done yet in
other libp2p Kademlia implementations, see e.g. [libp2p-go-323]. The new protobuf fields
have been given somewhat unique identifiers to prevent future collision.

Similarly, periodic re-publication of provider records does not seem to
be done yet in other implementations, see e.g. [libp2p-js-98].

[libp2p-146]: libp2p#146
[libp2p-1089]: libp2p#1089
[libp2p-go-323]: libp2p/go-libp2p-kad-dht#323
[libp2p-js-98]: libp2p/js-libp2p-kad-dht#98

protocols/kad/dht.proto

@@ -18,6 +18,14 @@ message Record {
 
  // Time the record was received, set by receiver
  string timeReceived = 5;
+
+ // The original publisher of the record.
+ // Currently specific to rust-libp2p.
+ bytes publisher = 666;
+
+ // The remaining TTL of the record, in seconds.
+ // Currently specific to rust-libp2p.
+ uint32 ttl = 777;
 };
 
 message Message {

protocols/kad/src/addresses.rs

@@ -22,67 +22,77 @@ use libp2p_core::Multiaddr;
 use smallvec::SmallVec;
 use std::fmt;
 
-/// List of addresses of a peer.
+/// A non-empty list of (unique) addresses of a peer in the routing table.
 #[derive(Clone)]
 pub struct Addresses {
  addrs: SmallVec<[Multiaddr; 6]>,
 }
 
 impl Addresses {
  /// Creates a new list of addresses.
- pub fn new() -> Addresses {
- Addresses {
- addrs: SmallVec::new(),
- }
+ pub fn new(addr: Multiaddr) -> Addresses {
+ let mut addrs = SmallVec::new();
+ addrs.push(addr);
+ Addresses { addrs }
+ }
+
+ /// Gets a reference to the first address in the list.
+ pub fn first(&self) -> &Multiaddr {
+ &self.addrs[0]
  }
 
- /// Returns an iterator over the list of addresses.
+ /// Returns an iterator over the addresses.
  pub fn iter(&self) -> impl Iterator<Item = &Multiaddr> {
  self.addrs.iter()
  }
 
+ /// Returns the number of addresses in the list.
+ pub fn len(&self) -> usize {
+ self.addrs.len()
+ }
+
  /// Converts the addresses into a `Vec`.
  pub fn into_vec(self) -> Vec<Multiaddr> {
  self.addrs.into_vec()
  }
 
- /// Returns true if the list of addresses is empty.
- pub fn is_empty(&self) -> bool {
- self.addrs.is_empty()
- }
+ /// Removes the given address from the list.
+ ///
+ /// Returns true if the address was found and removed, false otherwise.
+ /// The last remaining address in the list cannot be remvoved.
+ ///
+ /// An address should only be removed if is determined to be invalid or
+ /// otherwise unreachable.
+ pub fn remove(&mut self, addr: &Multiaddr) -> bool {
+ if self.addrs.len() == 1 {
+ return false
+ }
 
- /// Removes the given address from the list. Typically called if an address is determined to
- /// be invalid or unreachable.
- pub fn remove(&mut self, addr: &Multiaddr) {
  if let Some(pos) = self.addrs.iter().position(|a| a == addr) {
  self.addrs.remove(pos);
+ if self.addrs.len() <= self.addrs.inline_size() {
+ self.addrs.shrink_to_fit();
+ }
+ return true
  }
 
- if self.addrs.len() <= self.addrs.inline_size() {
- self.addrs.shrink_to_fit();
- }
- }
-
- /// Clears the list. It is empty afterwards.
- pub fn clear(&mut self) {
- self.addrs.clear();
- self.addrs.shrink_to_fit();
+ false
  }
 
- /// Inserts an address in the list. No effect if the address was already in the list.
- pub fn insert(&mut self, addr: Multiaddr) {
+ /// Adds a new address to the end of the list.
+ ///
+ /// Returns true if the address was added, false otherwise (i.e. if the
+ /// address is already in the list).
+ pub fn insert(&mut self, addr: Multiaddr) -> bool {
  if self.addrs.iter().all(|a| *a != addr) {
  self.addrs.push(addr);
+ true
+ } else {
+ false
  }
  }
 }
 
-impl Default for Addresses {
- fn default() -> Self {
- Addresses::new()
- }
-}
-
 impl fmt::Debug for Addresses {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  f.debug_list()