net.tomp2p.peers

Class PeerMap

java.lang.Object

net.tomp2p.peers.PeerMap

All Implemented Interfaces:

Maintainable, PeerStatusListener

public class PeerMap
extends Object
implements PeerStatusListener, Maintainable

This routing implementation uses is based on Kademlia. However, many changes have been applied to make it faster and more flexible. This class is partially thread-safe.

Author:

Thomas Bocek

Constructor Summary

Constructors

Constructor and Description
PeerMap(PeerMapConfiguration peerMapConfiguration) Creates the bag for the peers.

Method Summary

Methods

Modifier and Type	Method and Description
void	addPeerMapChangeListener(PeerMapChangeListener peerMapChangeListener) Add a map change listener.
List<PeerAddress>	all() Return all addresses from the neighbor list.
List<PeerAddress>	allOverflow() Return all addresses from the overflow / non-verified list.
int	bagSizeOverflow(int bag)
int	bagSizeVerified(int bag)
static int	classCloser(Number160 ln, PeerAddress rn, PeerAddress rn2) Returns -1 if the first remote node is closer to the key, if the secondBITS is closer, then 1 is returned.
static int	classMember(Number160 id1, Number160 id2) Returns the difference in terms of bit counts of two ids, minus 1.
NavigableSet<PeerStatistic>	closePeers(int atLeast) Returns close peers to the peer itself.
NavigableSet<PeerStatistic>	closePeers(Number160 id, int atLeast) Returns close peer from the set to a given key.
static NavigableSet<PeerStatistic>	closePeers(Number160 self, Number160 other, int atLeast, List<Map<Number160,PeerStatistic>> peerMap, Comparator<PeerStatistic> comparator)
boolean	contains(PeerAddress peerAddress) Checks if a peer address in either in the verified map.
boolean	containsOverflow(PeerAddress peerAddress) Checks if a peer address in either in the overflow / non-verified map.
static Comparator<Number160>	createComparator2(Number160 id)
Comparator<PeerStatistic>	createStatisticComparator(Number160 location)
Comparator<PeerAddress>	createXORAddressComparator() Creates an XOR comparator based on this peer ID.
static Comparator<PeerAddress>	createXORAddressComparator(Number160 location) Create the Kademlia distance comparator.
static Comparator<PeerStatistic>	createXORStatisticComparator(Number160 location)
PeerAddress	find(Number160 peerId)
PeerStatistic	getPeerStatistic(PeerAddress peerAddress) Checks if an entry of that peerAddress is available in the verified peer map or overflow peer map.
Collection<PeerStatistic>	getPeerStatistics(Collection<PeerAddress> peerAddresses) Takes a collection of PeerAddress and returns an equivalent collection of PeerStatistic from the PeerMap.
static int	isCloser(Number160 id, Number160 rn, Number160 rn2) Returns -1 if the first key is closer to the key, if the second is closer, then 1 is returned.
static int	isCloser(Number160 id, PeerAddress rn, PeerAddress rn2) Returns -1 if the first remote node is closer to the key, if the second is closer, then 1 is returned.
static int	isKadCloser(Number160 id, PeerAddress rn, PeerAddress rn2) Returns -1 if the first remote node is closer to the key, if the secondBITS is closer, then 1 is returned.
boolean	isPeerRemovedTemporarly(PeerAddress peerAddress) Checks if a peer is in the offline map.
PeerStatistic	nextForMaintenance(Collection<PeerAddress> notInterestedAddresses) Finds the next peer that should have a maintenance check.
boolean	peerFailed(PeerAddress remotePeer, PeerException peerException) Remove a peer from the list.
boolean	peerFound(PeerAddress remotePeer, PeerAddress referrer, PeerConnection peerConnection, RTT roundTripTime) Adds a neighbor to the neighbor list.
List<Map<Number160,PeerStatistic>>	peerMapOverflow()
List<Map<Number160,PeerStatistic>>	peerMapVerified()
void	removePeerMapChangeListener(PeerMapChangeListener peerMapChangeListener) Remove a map change listener.
Number160	self() Each node that has a bag has an ID itself to define what is close.
int	size() The number of the peers in the verified map.
String	toString()
static PeerStatistic	updateExistingVerifiedPeerAddress(Map<Number160,PeerStatistic> tmp, PeerAddress peerAddress, boolean firstHand, RTT roundTripTime) Checks if a peer already exists in this map and if it does, it will update the entry because the peer address (e.g.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

PeerMap

public PeerMap(PeerMapConfiguration peerMapConfiguration)

Creates the bag for the peers. This peer knows a lot about close peers and the further away the peers are, the less known they are. Distance is measured with XOR of the peer ID. The distance of peer with ID 0x12 and peer with Id 0x28 is 0x3a.

Parameters:

peerMapConfiguration - The configuration values of this map

Method Detail

addPeerMapChangeListener

public void addPeerMapChangeListener(PeerMapChangeListener peerMapChangeListener)

Add a map change listener. This is thread-safe

Parameters:

peerMapChangeListener - The listener

removePeerMapChangeListener

public void removePeerMapChangeListener(PeerMapChangeListener peerMapChangeListener)

Remove a map change listener. This is thread-safe

Parameters:

peerMapChangeListener - The listener

size

public int size()

The number of the peers in the verified map.

Returns:

the total number of peers

self

public Number160 self()

Each node that has a bag has an ID itself to define what is close. This method returns this ID.

Returns:

The id of this node

peerFound

public boolean peerFound(PeerAddress remotePeer,
                PeerAddress referrer,
                PeerConnection peerConnection,
                RTT roundTripTime)

Adds a neighbor to the neighbor list. If the bag is full, the id zero or the same as our id, the neighbor is not added. This method is tread-safe

Specified by:

peerFound in interface PeerStatusListener

Parameters:

remotePeer - The node that should be added

referrer - If we had direct contact and we know for sure that this node is online, we set firsthand to true. Information from 3rd party peers are always second hand and treated as such

roundTripTime - A RTT object, that measured the round-trip-time related to the finding of this peer. This is will be saved into the PeerStatistic

Returns:

True if the neighbor could be added or updated, otherwise false.

peerFailed

public boolean peerFailed(PeerAddress remotePeer,
                 PeerException peerException)

Remove a peer from the list. In order to not reappear, the node is put for a certain time in a cache list to keep the node removed. This method is thread-safe.

Specified by:

peerFailed in interface PeerStatusListener

Parameters:

remotePeer - The node that should be removed

Returns:

True if the neighbor was removed and added to a cache list. False if peer has not been removed or is already in the peer removed temporarily list.

contains

public boolean contains(PeerAddress peerAddress)

Checks if a peer address in either in the verified map.

Parameters:

peerAddress - The peer address to check

Returns:

True, if the peer address is either in the verified map

containsOverflow

public boolean containsOverflow(PeerAddress peerAddress)

Checks if a peer address in either in the overflow / non-verified map.

Parameters:

peerAddress - The peer address to check

Returns:

True, if the peer address is either in the overflow / non-verified map

getPeerStatistic

public PeerStatistic getPeerStatistic(PeerAddress peerAddress)

Checks if an entry of that peerAddress is available in the verified peer map or overflow peer map.

Parameters:

peerAddress -

Returns:

The PeerStatistic or null if peer is not in peer map

closePeers

public NavigableSet<PeerStatistic> closePeers(int atLeast)

Returns close peers to the peer itself.

Parameters:

atLeast - The number we want to find at least

Returns:

A sorted set with close peers first in this set.

closePeers

public NavigableSet<PeerStatistic> closePeers(Number160 id,
                                     int atLeast)

Returns close peer from the set to a given key. This method is tread-safe. You can use the returned set as its a copy of the actual PeerMap and changes in the return set do not affect PeerMap.

Parameters:

id - The key that should be close to the keys in the map

atLeast - The number we want to find at least

Returns:

A sorted set with close peers first in this set. Use set.first() to get the closest peer

closePeers

public static NavigableSet<PeerStatistic> closePeers(Number160 self,
                                     Number160 other,
                                     int atLeast,
                                     List<Map<Number160,PeerStatistic>> peerMap,
                                     Comparator<PeerStatistic> comparator)

toString

public String toString()

Overrides:

toString in class Object

createXORAddressComparator

public Comparator<PeerAddress> createXORAddressComparator()

Creates an XOR comparator based on this peer ID.

Returns:

The XOR comparator

all

public List<PeerAddress> all()

Return all addresses from the neighbor list. The collection is a copy and it is partially sorted. This operation is slow.

Returns:

All neighbors

peerMapVerified

public List<Map<Number160,PeerStatistic>> peerMapVerified()

peerMapOverflow

public List<Map<Number160,PeerStatistic>> peerMapOverflow()

allOverflow

public List<PeerAddress> allOverflow()

Return all addresses from the overflow / non-verified list. The collection is a copy and it is partially sorted.

Returns:

All neighbors

isPeerRemovedTemporarly

public boolean isPeerRemovedTemporarly(PeerAddress peerAddress)

Checks if a peer is in the offline map.

Parameters:

peerAddress - The address to look for

Returns:

True if the peer is in the offline map, meaning that we consider this peer offline.

nextForMaintenance

public PeerStatistic nextForMaintenance(Collection<PeerAddress> notInterestedAddresses)

Finds the next peer that should have a maintenance check. Returns null if no maintenance is needed at the moment. It will return the most important peers first. Importance is as follows: The most important peers are the close ones in the verified peer map. If a certain threshold in a bag is not reached, the unverified becomes important too.

Specified by:

nextForMaintenance in interface Maintainable

Returns:

The next most important peer to check if its still alive.

isCloser

public static int isCloser(Number160 id,
           PeerAddress rn,
           PeerAddress rn2)

Returns -1 if the first remote node is closer to the key, if the second is closer, then 1 is returned. If both are equal, 0 is returned

Parameters:

id - The key to search for

rn - The remote node on the routing path to node close to key

rn2 - An other remote node on the routing path to node close to key

Returns:

-1 if nodeAddress1 is closer to the key than nodeAddress2, otherwise 1. 0 is returned if both are equal.

isCloser

public static int isCloser(Number160 id,
           Number160 rn,
           Number160 rn2)

Returns -1 if the first key is closer to the key, if the second is closer, then 1 is returned. If both are equal, 0 is returned

Parameters:

id - The key to search for

rn - The first key

rn2 - The second key

Returns:

-1 if key1 is closer to key, otherwise 1. 0 is returned if both are equal.

isKadCloser

public static int isKadCloser(Number160 id,
              PeerAddress rn,
              PeerAddress rn2)

Returns -1 if the first remote node is closer to the key, if the secondBITS is closer, then 1 is returned. If both are equal, 0 is returned

Parameters:

id - The id as a distance reference

rn - The peer to test if closer to the id

rn2 - The other peer to test if closer to the id

Returns:

-1 if first peer is closer, 1 otherwise, 0 if both are equal

classCloser

public static int classCloser(Number160 ln,
              PeerAddress rn,
              PeerAddress rn2)

Returns -1 if the first remote node is closer to the key, if the secondBITS is closer, then 1 is returned. If both are equal, 0 is returned

Parameters:

ln - The location

rn - The peer to test if closer to the id

rn2 - The other peer to test if closer to the id

Returns:

-1 if rn2 is closer to ln (in terms of xor distance bit length), 1 if rn1 is closer or 0 if they are equal.

createXORAddressComparator

public static Comparator<PeerAddress> createXORAddressComparator(Number160 location)

Create the Kademlia distance comparator.

Parameters:

location - The id of this peer

Returns:

The XOR comparator

createXORStatisticComparator

public static Comparator<PeerStatistic> createXORStatisticComparator(Number160 location)

createStatisticComparator

public Comparator<PeerStatistic> createStatisticComparator(Number160 location)

getPeerStatistics

public Collection<PeerStatistic> getPeerStatistics(Collection<PeerAddress> peerAddresses)

Takes a collection of PeerAddress and returns an equivalent collection of PeerStatistic from the PeerMap. New PeerStatistics are created for peers that are not yet in the PeerMap

Parameters:

peerAddresses -

Returns:

createComparator2

public static Comparator<Number160> createComparator2(Number160 id)

classMember

public static int classMember(Number160 id1,
              Number160 id2)

Returns the difference in terms of bit counts of two ids, minus 1. So two IDs with one bit difference are in the class 0.

Parameters:

id1 - The first id

id2 - The second id

Returns:

returns the bit difference and -1 if they are equal

updateExistingVerifiedPeerAddress

public static PeerStatistic updateExistingVerifiedPeerAddress(Map<Number160,PeerStatistic> tmp,
                                              PeerAddress peerAddress,
                                              boolean firstHand,
                                              RTT roundTripTime)

Checks if a peer already exists in this map and if it does, it will update the entry because the peer address (e.g. port) may have changed.

Parameters:

tmp - The map where the peer is suppost to be

peerAddress - The address of the peer that may have been changed

firstHand - True if this peer send and received a message from the remote peer

roundTripTime -

Returns:

The old peer address if we have updated the peer, null otherwise

bagSizeVerified

public int bagSizeVerified(int bag)

bagSizeOverflow

public int bagSizeOverflow(int bag)

find

public PeerAddress find(Number160 peerId)