TrivialPreprocessor (Javadocs [I2P+ 2.13.0+]

java.lang.Object
- net.i2p.router.tunnel.TrivialPreprocessor

All Implemented Interfaces:
TunnelGateway.QueuePreprocessor
Direct Known Subclasses:
BatchedPreprocessor
```
class TrivialPreprocessor
extends 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 coalesce message fragments or delay for more optimal throughput. See FragmentHandler Javadoc for tunnel message fragment format Not instantiated directly except in unit tests; see BatchedPreprocessor

Field Summary

Fields
Modifier and Type	Field and Description
`protected RouterContext`	`_context` The router context
`protected static ByteCache`	`_dataCache` Here in tunnels, we take from the cache but never add to it.
`protected Log`	`_log` The logger
`protected static int`	`IV_SIZE` Length of the IV
`static int`	`PREPROCESSED_SIZE` Size of preprocessed data blocks

Constructor Summary
Constructors
Constructor and Description
TrivialPreprocessor(RouterContext ctx)

Constructors
Constructor and Description
`TrivialPreprocessor(RouterContext ctx)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`long`	`getDelayAmount()` how long do we want to wait before flushing
`protected static int`	`getInstructionAugmentationSize(PendingGatewayMessage msg, int offset, int instructionsSize)` Get the augmentation size for instructions if fragmentation is needed.
`protected static int`	`getInstructionsSize(PendingGatewayMessage msg)` Calculate the size of the instructions for a pending message.
`protected void`	`notePreprocessing(long messageId, int numFragments, int totalLength, List<Long> messageIds, String msg)` Note preprocessing statistics.
`protected void`	`preprocess(byte[] fragments, int fragmentLength)` Wrap the preprocessed fragments with the necessary padding / checksums to act as a tunnel message.
`boolean`	`preprocessQueue(List<PendingGatewayMessage> 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 NOTE: Unused here, see BatchedPreprocessor override, super is not called.
`protected int`	`writeFirstFragment(PendingGatewayMessage msg, byte[] target, int offset)` Write the first fragment of a tunnel message.
`protected int`	`writeSubsequentFragment(PendingGatewayMessage msg, byte[] target, int offset)` Write a subsequent fragment of a tunnel message.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - _context
```
protected final RouterContext _context
```
    The router context
  - _dataCache
```
protected static final ByteCache _dataCache
```
    Here in tunnels, we take from the cache but never add to it. In other words, we take advantage of other places in the router also using 1024-byte ByteCaches (since ByteCache only maintains once instance for each size) Used in BatchedPreprocessor; see add'l comments there
  - _log
```
protected final Log _log
```
    The logger
  - IV_SIZE
```
protected static final int IV_SIZE
```
    Length of the IV
    See Also:
    Constant Field Values
  - PREPROCESSED_SIZE
```
public static final int PREPROCESSED_SIZE
```
    Size of preprocessed data blocks
    See Also:
    Constant Field Values
- Constructor Detail
  - TrivialPreprocessor
```
public TrivialPreprocessor(RouterContext ctx)
```
    Parameters:
    ctx - the router context
- Method Detail
  - getDelayAmount
```
public long getDelayAmount()
```
    how long do we want to wait before flushing
    Specified by:
    getDelayAmount in interface TunnelGateway.QueuePreprocessor
    Returns:
    delay in milliseconds
  - getInstructionAugmentationSize
```
protected static int getInstructionAugmentationSize(PendingGatewayMessage msg,
                                                    int offset,
                                                    int instructionsSize)
```
    Get the augmentation size for instructions if fragmentation is needed.
    Parameters:
    msg - the pending gateway message
    offset - the current offset
    instructionsSize - the current instructions size
    Returns:
    0 or 4
  - getInstructionsSize
```
protected static int getInstructionsSize(PendingGatewayMessage msg)
```
    Calculate the size of the instructions for a pending message.
    Parameters:
    msg - the pending gateway message
    Returns:
    generally 3 or 35 or 39 for first fragment, 7 for subsequent fragments. Does NOT include 4 for the message ID if the message will be fragmented; call getInstructionAugmentationSize() for that.
  - notePreprocessing
```
protected void notePreprocessing(long messageId,
                                 int numFragments,
                                 int totalLength,
                                 List<Long> messageIds,
                                 String msg)
```
    Note preprocessing statistics. No-op - intentionally empty.
  - preprocess
```
protected void preprocess(byte[] fragments,
                          int fragmentLength)
```
    Wrap the preprocessed fragments with the necessary padding / checksums to act as a tunnel message.
    Parameters:
    fragments - the fragment data
    fragmentLength - fragments[0:fragmentLength] is used
  - preprocessQueue
```
public boolean preprocessQueue(List<PendingGatewayMessage> 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 NOTE: Unused here, see BatchedPreprocessor override, super is not called.
    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) Messages are not removed from the list until actually sent. The status of unsent and partially-sent messages is stored in the Pending structure.
    sender - the sender
    rec - the receiver to accept encrypted data
    Returns:
    true if we should delay before preprocessing again
  - writeFirstFragment
```
protected int writeFirstFragment(PendingGatewayMessage msg,
                                 byte[] target,
                                 int offset)
```
    Write the first fragment of a tunnel message.
    Parameters:
    msg - the pending gateway message
    target - the target
    offset - the starting offset
    Returns:
    the new offset after writing
  - writeSubsequentFragment
```
protected int writeSubsequentFragment(PendingGatewayMessage msg,
                                      byte[] target,
                                      int offset)
```
    Write a subsequent fragment of a tunnel message.
    Parameters:
    msg - the pending gateway message
    target - the target
    offset - the starting offset
    Returns:
    the new offset after writing

Class TrivialPreprocessor

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

_context

_dataCache

_log

IV_SIZE

PREPROCESSED_SIZE

Constructor Detail

TrivialPreprocessor

Method Detail

getDelayAmount

getInstructionAugmentationSize

getInstructionsSize

notePreprocessing

preprocess

preprocessQueue

writeFirstFragment

writeSubsequentFragment