mirror of
https://github.com/fluencelabs/rust-libp2p
synced 2025-05-29 02:31:20 +00:00
cde93f5432
* 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]: https://github.com/libp2p/rust-libp2p/issues/146
[libp2p-1089]: https://github.com/libp2p/rust-libp2p/issues/1089
[libp2p-go-323]: https://github.com/libp2p/go-libp2p-kad-dht/issues/323
[libp2p-js-98]: https://github.com/libp2p/js-libp2p-kad-dht/issues/98
* Tweak kad-ipfs example.
* Add missing files.
* Ensure new delays are polled immediately.
To ensure task notification, since `NotReady` is returned right after.
* Fix ipfs-kad example and use wasm_timer.
* Small cleanup.
* Incorporate some feedback.
* Adjustments after rebase.
* Distinguish events further.
In order for a user to easily distinguish the result of e.g.
a `put_record` operation from the result of a later republication,
different event constructors are used. Furthermore, for now,
re-replication and "caching" of records (at the closest peer to
the key that did not return a value during a successful lookup)
do not yield events for now as they are less interesting.
* Speed up tests for CI.
* Small refinements and more documentation.
* Guard a node against overriding records for which it considers
itself to be the publisher.
* Document the jobs module more extensively.
* More inline docs around removal of "unreachable" addresses.
* Remove wildcard re-exports.
* Use NonZeroUsize for the constants.
* Re-add method lost on merge.
* Add missing 'pub'.
* Further increase the timeout in the ipfs-kad example.
* Readd log dependency to libp2p-kad.
* Simplify RecordStore API slightly.
* Some more commentary.
* Change Addresses::remove to return Result<(),()>.
Change the semantics of `Addresses::remove` so that the error case
is unambiguous, instead of the success case. Use the `Result` for
clearer semantics to that effect.
* Add some documentation to .
90 lines
2.2 KiB
Protocol Buffer
90 lines
2.2 KiB
Protocol Buffer
syntax = "proto3";
|
|
package dht.pb;
|
|
|
|
// Record represents a dht record that contains a value
|
|
// for a key value pair
|
|
message Record {
|
|
// The key that references this record
|
|
bytes key = 1;
|
|
|
|
// The actual value this record is storing
|
|
bytes value = 2;
|
|
|
|
// Note: These fields were removed from the Record message
|
|
// hash of the authors public key
|
|
//optional string author = 3;
|
|
// A PKI signature for the key+value+author
|
|
//optional bytes signature = 4;
|
|
|
|
// 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 {
|
|
enum MessageType {
|
|
PUT_VALUE = 0;
|
|
GET_VALUE = 1;
|
|
ADD_PROVIDER = 2;
|
|
GET_PROVIDERS = 3;
|
|
FIND_NODE = 4;
|
|
PING = 5;
|
|
}
|
|
|
|
enum ConnectionType {
|
|
// sender does not have a connection to peer, and no extra information (default)
|
|
NOT_CONNECTED = 0;
|
|
|
|
// sender has a live connection to peer
|
|
CONNECTED = 1;
|
|
|
|
// sender recently connected to peer
|
|
CAN_CONNECT = 2;
|
|
|
|
// sender recently tried to connect to peer repeatedly but failed to connect
|
|
// ("try" here is loose, but this should signal "made strong effort, failed")
|
|
CANNOT_CONNECT = 3;
|
|
}
|
|
|
|
message Peer {
|
|
// ID of a given peer.
|
|
bytes id = 1;
|
|
|
|
// multiaddrs for a given peer
|
|
repeated bytes addrs = 2;
|
|
|
|
// used to signal the sender's connection capabilities to the peer
|
|
ConnectionType connection = 3;
|
|
}
|
|
|
|
// defines what type of message it is.
|
|
MessageType type = 1;
|
|
|
|
// defines what coral cluster level this query/response belongs to.
|
|
// in case we want to implement coral's cluster rings in the future.
|
|
int32 clusterLevelRaw = 10; // NOT USED
|
|
|
|
// Used to specify the key associated with this message.
|
|
// PUT_VALUE, GET_VALUE, ADD_PROVIDER, GET_PROVIDERS
|
|
bytes key = 2;
|
|
|
|
// Used to return a value
|
|
// PUT_VALUE, GET_VALUE
|
|
Record record = 3;
|
|
|
|
// Used to return peers closer to a key in a query
|
|
// GET_VALUE, GET_PROVIDERS, FIND_NODE
|
|
repeated Peer closerPeers = 8;
|
|
|
|
// Used to return Providers
|
|
// GET_VALUE, ADD_PROVIDER, GET_PROVIDERS
|
|
repeated Peer providerPeers = 9;
|
|
}
|