freenet.node

Class NewPacketFormat

java.lang.Object

freenet.node.NewPacketFormat

All Implemented Interfaces:

PacketFormat

public class NewPacketFormat
extends java.lang.Object
implements PacketFormat

Field Summary

Fields

Modifier and Type	Field and Description
static int	MAX_MESSAGE_SIZE Maximum message size in bytes.

Method Summary

Modifier and Type	Method and Description
boolean	canSend(SessionKey tracker) Returns false if the packet format can't send new messages because it must wait for some internal event.
void	checkForLostPackets()
boolean	fullPacketQueued(int maxPacketSize) Is there enough data queued to justify sending a packet immediately? Ideally this should take into account transport level headers.
boolean	handleReceivedPacket(byte[] buf, int offset, int length, long now, Peer replyTo)
boolean	maybeSendPacket(long now, boolean ackOnly) Maybe send something.
java.util.List<MessageItem>	onDisconnect() Called when the peer has been disconnected.
long	timeCheckForLostPackets()
long	timeNextUrgent(boolean canSend, long now) When do we need to send a packet?
long	timeSendAcks()
java.lang.String	toString()

Methods inherited from class java.lang.Object

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

Field Detail

MAX_MESSAGE_SIZE

public static final int MAX_MESSAGE_SIZE

Maximum message size in bytes.

See Also:

Constant Field Values

Method Detail

handleReceivedPacket

public boolean handleReceivedPacket(byte[] buf,
                                    int offset,
                                    int length,
                                    long now,
                                    Peer replyTo)

Specified by:

handleReceivedPacket in interface PacketFormat

maybeSendPacket

public boolean maybeSendPacket(long now,
                               boolean ackOnly)
                        throws BlockedTooLongException

Description copied from interface: PacketFormat

Maybe send something. A SINGLE PACKET. Don't send everything at once, for two reasons:

1. It is possible for a node to have a very long backlog.
2. Sometimes sending a packet can take a long time.
3. In the near future PacketSender will be responsible for output bandwidth throttling. So it makes sense to send a single packet and round-robin.

Specified by:

maybeSendPacket in interface PacketFormat

Throws:

BlockedTooLongException

timeCheckForLostPackets

public long timeCheckForLostPackets()

Specified by:

timeCheckForLostPackets in interface PacketFormat

checkForLostPackets

public void checkForLostPackets()

Specified by:

checkForLostPackets in interface PacketFormat

onDisconnect

public java.util.List<MessageItem> onDisconnect()

Description copied from interface: PacketFormat

Called when the peer has been disconnected. THE CALLER SHOULD STOP USING THE PACKET FORMAT OBJECT AFTER CALLING THIS FUNCTION!

Specified by:

onDisconnect in interface PacketFormat

timeNextUrgent

public long timeNextUrgent(boolean canSend,
                           long now)

When do we need to send a packet?

Specified by:

timeNextUrgent in interface PacketFormat

Parameters:

canSend - If false, canSend() has returned false. Some transports will want to send a packet anyway e.g. an ack, a resend in some cases.

Returns:

0 if there is anything already in flight. The time that the oldest ack was queued at plus the lesser of half the RTT or 100ms if there are acks queued. Otherwise Long.MAX_VALUE to indicate that we need to get messages from the queue.

timeSendAcks

public long timeSendAcks()

Specified by:

timeSendAcks in interface PacketFormat

Returns:

The time at which the packet format will want to send an ack. Resends etc don't count, only acks. The reason acks are special is they are needed for the other side to recognise that their packets have been received and thus avoid retransmission.

canSend

public boolean canSend(SessionKey tracker)

Description copied from interface: PacketFormat

Returns false if the packet format can't send new messages because it must wait for some internal event. For example, if a packet sequence number can not be allocated this method should return false, but if nothing can be sent because there is no (external) data to send it should not. Note that this only applies to packets being created from messages on the @see PeerMessageQueue. Note also that there may already be messages in flight, but it may return false in that case, so you need to check timeNextUrgent() as well.

Specified by:

canSend in interface PacketFormat

Returns:

false if the packet format can't send packets

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

fullPacketQueued

public boolean fullPacketQueued(int maxPacketSize)

Description copied from interface: PacketFormat

Is there enough data queued to justify sending a packet immediately? Ideally this should take into account transport level headers.

Specified by:

fullPacketQueued in interface PacketFormat