freenet.node

Class FailureTable

java.lang.Object

freenet.node.FailureTable

public class FailureTable
extends java.lang.Object

Tracks recently DNFed keys, where they were routed to, what the location was at the time, who requested them. Implements Ultra-Lightweight Persistent Requests: Refuse requests for a key for 10 minutes after it's DNFed (UNLESS we find a better route for the request), and when it is found, offer it to those who've asked for it in the last hour. LOCKING: Do not lock PeerNode before FailureTable/FailureTableEntry.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
class	FailureTable.FailureTableCleaner

Field Summary

Fields

Modifier and Type	Field and Description
freenet.node.FailureTable.OfferedKeysByteCounter	senderCounter

Method Summary

Modifier and Type	Method and Description
freenet.node.FailureTable.OfferList	getOffers(Key key)
TimedOutNodesList	getTimedOutNodesList(Key key)
boolean	hadAnyOffers(Key key) Have we had any offers for the key?
protected void	innerOnOffer(Key key, PeerNode peer, byte[] authenticator) This method runs on the SerialExecutor.
protected void	innerSendOfferedKey(Key key, boolean isSSK, boolean needPubKey, long uid, PeerNode source, OfferReplyTag tag, boolean realTimeFlag) This method runs on the SerialExecutor.
short	minOfferedHTL(Key key, short htl)
void	onDisconnect(PeerNode pn) Called when a node disconnects
void	onFailed(Key key, PeerNode routedTo, short htl, long rfTimeout, long ftTimeout) Called when we route to a node and it fails for some reason, but we continue the request.
void	onFinalFailure(Key key, PeerNode routedTo, short htl, short origHTL, long rfTimeout, long ftTimeout, PeerNode requestor) When a request finishes with a failure, record who generated the failure so we don't route to them next time, and also who originated it so we can send the data back to them if we find them.
void	onFound(KeyBlock block) Called when a data block is found (after it has been stored; there is a good chance of its being available in the near future).
boolean	peersWantKey(Key key, PeerNode apartFrom)
void	sendOfferedKey(Key key, boolean isSSK, boolean needPubKey, long uid, PeerNode source, OfferReplyTag tag, boolean realTimeFlag) We offered a key, a node has responded to the offer.
void	start()

Methods inherited from class java.lang.Object

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

Field Detail

senderCounter

public final freenet.node.FailureTable.OfferedKeysByteCounter senderCounter

Method Detail

start

public void start()

onFailed

public void onFailed(Key key,
                     PeerNode routedTo,
                     short htl,
                     long rfTimeout,
                     long ftTimeout)

Called when we route to a node and it fails for some reason, but we continue the request. Normally the timeout will be the time it took to route to that node and wait for its response / timeout waiting for its response.

Parameters:

key -

routedTo -

htl -

rfTimeout -

ftTimeout -

onFinalFailure

public void onFinalFailure(Key key,
                           PeerNode routedTo,
                           short htl,
                           short origHTL,
                           long rfTimeout,
                           long ftTimeout,
                           PeerNode requestor)

When a request finishes with a failure, record who generated the failure so we don't route to them next time, and also who originated it so we can send the data back to them if we find them. ORDERING: You should generally call this *before* calling finish() to avoid problems. LOCKING: NEVER synchronize on PeerNode before calling any FailureTable method.

onFound

public void onFound(KeyBlock block)

Called when a data block is found (after it has been stored; there is a good chance of its being available in the near future). If there are nodes waiting for it, we will offer it to them. Removes the list of nodes that offered the key too (but this is a separate operation). LOCKING: Never call when locked PeerNode, and try to avoid other locks as they might cause a deadlock. Schedule off-thread if necessary.

innerOnOffer

protected void innerOnOffer(Key key,
                            PeerNode peer,
                            byte[] authenticator)

This method runs on the SerialExecutor. Therefore, any blocking network I/O needs to be scheduled on a separate thread. However, blocking disk I/O *should happen on this thread*. We deliberately serialise it, as high latencies can otherwise result.

sendOfferedKey

public void sendOfferedKey(Key key,
                           boolean isSSK,
                           boolean needPubKey,
                           long uid,
                           PeerNode source,
                           OfferReplyTag tag,
                           boolean realTimeFlag)
                    throws NotConnectedException

We offered a key, a node has responded to the offer. Note that this runs on the incoming packets thread so should allocate a new thread if it does anything heavy. Note also that it is responsible for unlocking the UID.

Parameters:

key - The key to send.

isSSK - Whether it is an SSK.

uid - The UID.

source - The node that asked for the key.

Throws:

NotConnectedException - If the sender ceases to be connected.

innerSendOfferedKey

protected void innerSendOfferedKey(Key key,
                                   boolean isSSK,
                                   boolean needPubKey,
                                   long uid,
                                   PeerNode source,
                                   OfferReplyTag tag,
                                   boolean realTimeFlag)
                            throws NotConnectedException

This method runs on the SerialExecutor. Therefore, any blocking network I/O needs to be scheduled on a separate thread. However, blocking disk I/O *should happen on this thread*. We deliberately serialise it, as high latencies can otherwise result.

Throws:

NotConnectedException

hadAnyOffers

public boolean hadAnyOffers(Key key)

Have we had any offers for the key?

Parameters:

key - The key to check.

Returns:

True if there are any offers, false otherwise.

getOffers

public freenet.node.FailureTable.OfferList getOffers(Key key)

onDisconnect

public void onDisconnect(PeerNode pn)

Called when a node disconnects

getTimedOutNodesList

public TimedOutNodesList getTimedOutNodesList(Key key)

peersWantKey

public boolean peersWantKey(Key key,
                            PeerNode apartFrom)

minOfferedHTL

public short minOfferedHTL(Key key,
                           short htl)

Returns:

The lowest HTL at which any peer has requested this key recently