freenet.node.updater

Class UpdateOverMandatoryManager

java.lang.Object

freenet.node.updater.UpdateOverMandatoryManager

All Implemented Interfaces:

RequestClient

public class UpdateOverMandatoryManager
extends java.lang.Object
implements RequestClient

Co-ordinates update over mandatory. Update over mandatory = updating from your peers, even though they may be so much newer than you that you can't route requests through them. NodeDispatcher feeds UOMAnnouncement's received from peers to this class, and it decides what to do about them.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	UpdateOverMandatoryManager.UOMDependencyFetcherCallback

Field Summary

Fields

Modifier and Type	Field and Description
static long	GRACE_TIME
protected static int	RANDOM_INSERT_BLOB If we fetched the main jar locally, there is a 1 in RANDOM_INSERT_BLOB chance of inserting it.

Constructor Summary

Constructors

Constructor and Description
UpdateOverMandatoryManager(NodeUpdateManager manager)

Method Summary

Modifier and Type	Method and Description
void	addDependency(byte[] expectedHash, java.io.File filename)
void	disconnected(PeerNode pn)
freenet.node.updater.UpdateOverMandatoryManager.UOMDependencyFetcher	fetchDependency(byte[] expectedHash, long size, java.io.File saveTo, boolean executable, UpdateOverMandatoryManager.UOMDependencyFetcherCallback cb) Try to fetch a dependency by hash.
boolean	fetchingFromTwo()
PeerNode[][]	getNodesSayBlown()
boolean	handleAnnounce(Message m, PeerNode source) Handle a UOMAnnouncement message.
void	handleFetchDependency(Message m, PeerNode source)
void	handleRequestJar(Message m, PeerNode source)
boolean	handleRequestRevocation(Message m, PeerNode source) A peer node requests us to send the binary blob of the revocation key.
boolean	handleSendingMain(Message m, PeerNode source)
boolean	handleSendingRevocation(Message m, PeerNode source)
protected void	insertBlob(RandomAccessBucket bucket, java.lang.String type, short priority)
boolean	isFetchingMain()
void	killAlert()
protected void	maybeInsertMainJar(NodeUpdater mainUpdater, PeerNode source, int version) Maybe insert the main jar blob.
protected void	maybeNotRevoked()
protected void	maybeRequestMainJar()
protected void	peerMaybeFreeAllSlots(PeerNode fetchFrom) A download succeeded from a peer.
boolean	persistent() Is this request persistent? **Must not change!**
protected void	processMainJarBlob(java.io.File temp, PeerNode source, int version, FreenetURI uri)
boolean	realTimeFlag() Send the request with the real time flag enabled? Real-time requests are given a higher priority in data transfers, but fewer of them are accepted.
protected boolean	removeOldTempFiles()
protected void	startSomeDependencyFetchers()

Methods inherited from class java.lang.Object

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

Field Detail

GRACE_TIME

public static final long GRACE_TIME

RANDOM_INSERT_BLOB

protected static final int RANDOM_INSERT_BLOB

If we fetched the main jar locally, there is a 1 in RANDOM_INSERT_BLOB chance of inserting it. We always insert it if we downloaded it via UOM. We always reinsert revocations.

See Also:

Constant Field Values

Constructor Detail

UpdateOverMandatoryManager

public UpdateOverMandatoryManager(NodeUpdateManager manager)

Method Detail

handleAnnounce

public boolean handleAnnounce(Message m,
                              PeerNode source)

Handle a UOMAnnouncement message. A node has sent us a message offering us use of its update over mandatory facilities in some way.

Parameters:

m - The message to handle. Either a UOMAnnounce or a UOMAnnouncement.

source - The PeerNode which sent the message.

Returns:

True unless we don't want the message (in this case, always true).

maybeRequestMainJar

protected void maybeRequestMainJar()

getNodesSayBlown

public PeerNode[][] getNodesSayBlown()

handleRequestRevocation

public boolean handleRequestRevocation(Message m,
                                       PeerNode source)

A peer node requests us to send the binary blob of the revocation key.

Parameters:

m - The message requesting the transfer.

source - The node requesting the transfer.

Returns:

True if we handled the message (i.e. always).

handleSendingRevocation

public boolean handleSendingRevocation(Message m,
                                       PeerNode source)

maybeNotRevoked

protected void maybeNotRevoked()

insertBlob

protected void insertBlob(RandomAccessBucket bucket,
                          java.lang.String type,
                          short priority)

killAlert

public void killAlert()

handleRequestJar

public void handleRequestJar(Message m,
                             PeerNode source)

handleSendingMain

public boolean handleSendingMain(Message m,
                                 PeerNode source)

processMainJarBlob

protected void processMainJarBlob(java.io.File temp,
                                  PeerNode source,
                                  int version,
                                  FreenetURI uri)

maybeInsertMainJar

protected void maybeInsertMainJar(NodeUpdater mainUpdater,
                                  PeerNode source,
                                  int version)

Maybe insert the main jar blob. If so, compute the appropriate priority.

removeOldTempFiles

protected boolean removeOldTempFiles()

persistent

public boolean persistent()

Description copied from interface: RequestClient

Is this request persistent? **Must not change!**

Specified by:

persistent in interface RequestClient

disconnected

public void disconnected(PeerNode pn)

fetchingFromTwo

public boolean fetchingFromTwo()

realTimeFlag

public boolean realTimeFlag()

Description copied from interface: RequestClient

Send the request with the real time flag enabled? Real-time requests are given a higher priority in data transfers, but fewer of them are accepted. They are optimised for latency rather than throughput, and are expected to be bursty rather than continual. **Must not change!**

Specified by:

realTimeFlag in interface RequestClient

isFetchingMain

public boolean isFetchingMain()

addDependency

public void addDependency(byte[] expectedHash,
                          java.io.File filename)

handleFetchDependency

public void handleFetchDependency(Message m,
                                  PeerNode source)

fetchDependency

public freenet.node.updater.UpdateOverMandatoryManager.UOMDependencyFetcher fetchDependency(byte[] expectedHash,
                                                                                            long size,
                                                                                            java.io.File saveTo,
                                                                                            boolean executable,
                                                                                            UpdateOverMandatoryManager.UOMDependencyFetcherCallback cb)

Try to fetch a dependency by hash.

Parameters:

expectedHash - The hash of the expected file. Will be checked.

size - The length of the expected file.

saveTo - The file will be overwritten only if the download is successful and the hash is correct.

uomDependencyFetchCallback - Callback to call when done.

startSomeDependencyFetchers

protected void startSomeDependencyFetchers()

peerMaybeFreeAllSlots

protected void peerMaybeFreeAllSlots(PeerNode fetchFrom)

A download succeeded from a peer. Reconsider all the other downloads that failed from it. E.g. when we have one darknet connection and a transfer fails due to a transfer glitch.