net.i2p.router.tunnel
Class TrivialPreprocessor

java.lang.Object
  extended by net.i2p.router.tunnel.TrivialPreprocessor
All Implemented Interfaces:
TunnelGateway.QueuePreprocessor
Direct Known Subclasses:
BatchedPreprocessor, TrivialRouterPreprocessor

public class TrivialPreprocessor
extends java.lang.Object
implements TunnelGateway.QueuePreprocessor

Do the simplest thing possible for preprocessing - for each message available, turn it into the minimum number of fragmented preprocessed blocks, sending each of those out. This does not coallesce message fragments or delay for more optimal throughput.


Field Summary
protected  I2PAppContext _context
           
protected static ByteCache _dataCache
           
protected static ByteCache _hashCache
           
protected static ByteCache _ivCache
           
protected static int IV_SIZE
           
static int PREPROCESSED_SIZE
           
 
Constructor Summary
TrivialPreprocessor(I2PAppContext ctx)
           
 
Method Summary
 long getDelayAmount()
          how long do we want to wait before flushing
protected  int getInstructionAugmentationSize(TunnelGateway.Pending msg, int offset, int instructionsSize)
           
protected  int getInstructionsSize(TunnelGateway.Pending msg)
           
protected  void notePreprocessing(long messageId, int numFragments, int totalLength, java.util.List messageIds, java.lang.String msg)
           
protected  void preprocess(byte[] fragments, int fragmentLength)
          Wrap the preprocessed fragments with the necessary padding / checksums to act as a tunnel message.
 boolean preprocessQueue(java.util.List pending, TunnelGateway.Sender sender, TunnelGateway.Receiver rec)
          Return true if there were messages remaining, and we should queue up a delayed flush to clear them
protected  int writeFirstFragment(TunnelGateway.Pending msg, byte[] target, int offset)
           
protected  int writeSubsequentFragment(TunnelGateway.Pending msg, byte[] target, int offset)
           
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

_context

protected I2PAppContext _context

PREPROCESSED_SIZE

public static final int PREPROCESSED_SIZE
See Also:
Constant Field Values

IV_SIZE

protected static final int IV_SIZE
See Also:
Constant Field Values

_dataCache

protected static final ByteCache _dataCache

_ivCache

protected static final ByteCache _ivCache

_hashCache

protected static final ByteCache _hashCache
Constructor Detail

TrivialPreprocessor

public TrivialPreprocessor(I2PAppContext ctx)
Method Detail

getDelayAmount

public long getDelayAmount()
how long do we want to wait before flushing

Specified by:
getDelayAmount in interface TunnelGateway.QueuePreprocessor

preprocessQueue

public boolean preprocessQueue(java.util.List pending,
                               TunnelGateway.Sender sender,
                               TunnelGateway.Receiver rec)
Return true if there were messages remaining, and we should queue up a delayed flush to clear them

Specified by:
preprocessQueue in interface TunnelGateway.QueuePreprocessor
Parameters:
pending - list of Pending objects for messages either unsent or partly sent. This list should be update with any values removed (the preprocessor owns the lock)
Returns:
true if we should delay before preprocessing again

notePreprocessing

protected void notePreprocessing(long messageId,
                                 int numFragments,
                                 int totalLength,
                                 java.util.List messageIds,
                                 java.lang.String msg)

preprocess

protected void preprocess(byte[] fragments,
                          int fragmentLength)
Wrap the preprocessed fragments with the necessary padding / checksums to act as a tunnel message.

Parameters:
fragmentLength - fragments[0:fragmentLength] is used

writeFirstFragment

protected int writeFirstFragment(TunnelGateway.Pending msg,
                                 byte[] target,
                                 int offset)

writeSubsequentFragment

protected int writeSubsequentFragment(TunnelGateway.Pending msg,
                                      byte[] target,
                                      int offset)

getInstructionsSize

protected int getInstructionsSize(TunnelGateway.Pending msg)

getInstructionAugmentationSize

protected int getInstructionAugmentationSize(TunnelGateway.Pending msg,
                                             int offset,
                                             int instructionsSize)