## net.i2p.router
Class MessageHistory

    java.lang.Object
      net.i2p.router.MessageHistory

    public class MessageHistory

extends Object

Simply act as a pen register of messages sent in and out of the router. This will be pulled out later on, but is useful now for debugging. (with clock synchronization, this will generate a log that can be used to analyze the entire network, if everyone provides their logs honestly)

Field Summary
`static String` `DEFAULT_MESSAGE_HISTORY_FILENAME`
`static String` `PROP_KEEP_MESSAGE_HISTORY` config property determining whether we want to debug with the message history - default false
`static String` `PROP_MESSAGE_HISTORY_FILENAME` config property determining where we want to log the message history, if we're keeping one

Constructor Summary
`MessageHistory(RouterContext context)`

Method Summary
`void` `droppedFragmentedMessage(long messageId, String status)`
`void` `droppedInboundMessage(long messageId, Hash from, String info)`
`void` `droppedOtherMessage(I2NPMessage message, Hash from)` We received another message we weren't waiting for and don't know how to handle
`void` `droppedTunnelDataMessageUnknown(long msgId, long tunnelId)`
`void` `droppedTunnelGatewayMessageUnknown(long msgId, long tunnelId)`
`void` `droppedTunnelMessage(TunnelId id, long msgId, Date expiration, Hash from)` We don't know about the given tunnel, so we are dropping a message sent to us by the given router
`void` `fragmentMessage(long messageId, int numFragments, int totalLength, List messageIds, Object tunnel, String msg)`
`void` `fragmentMessage(long messageId, int numFragments, int totalLength, List messageIds, String msg)`
`boolean` `getDoLog()`
`(package private) String` `getFilename()`
`void` `initialize(boolean forceReinitialize)` Initialize the message history according to the router's configuration.
`static void` `main(String[] args)`
`void` `messageProcessingError(long messageId, String messageType, String error)` There was an error processing the given message that was received
`void` `receiveMessage(String messageType, long messageId, long expiration, boolean isValid)`
`void` `receiveMessage(String messageType, long messageId, long expiration, Hash from, boolean isValid)` We just received a message from the peer
`void` `receivePayloadMessage(long messageId)` Receive a payload message to distribute to a client
`void` `receiveTunnelFragment(long messageId, int fragmentId, Object status)`
`void` `receiveTunnelFragmentComplete(long messageId)`
`void` `replyTimedOut(OutNetMessage sentMessage)` The message wanted a reply but no reply came in the time expected
`void` `sendMessage(String messageType, long messageId, long expiration, Hash peer, boolean sentOk, String info)` We just sent a message to the peer
`void` `sendPayloadMessage(long messageId, boolean successfullySent, long timeToSend)` Note that the sending of a payload message completed (successfully or as a failure)
`(package private) void` `setDoLog(boolean log)`
`(package private) void` `setPauseFlushes(boolean doPause)`
`void` `shitlist(Hash peer, String reason)` We shitlisted the peer
`void` `tunnelDispatched(long messageId, long tunnelId, long toTunnel, Hash toPeer, String type)`
`void` `tunnelDispatched(long messageId, long innerMessageId, long tunnelId, String type)`
`void` `tunnelDispatched(long messageId, long tunnelId, String type)`
`void` `tunnelDispatched(String info)`
`void` `tunnelFailed(TunnelId tunnel)` The local router has detected a failure in the given tunnel
`void` `tunnelJoined(String state, HopConfig tunnel)` The local router has joined the given tunnel operating in the given state.
`void` `tunnelJoined(String state, TunnelInfo tunnel)` The local router has joined the given tunnel operating in the given state.
`void` `tunnelParticipantRejected(Hash peer, String msg)`
`void` `tunnelRejected(Hash peer, TunnelId tunnel, Hash replyThrough, String reason)` The peer did not accept the tunnel join for the given reason
`void` `tunnelRequestTimedOut(Hash peer, TunnelId tunnel)` The peer did not accept the tunnel join for the given reason (this may be because of a timeout or an explicit refusal).
`void` `tunnelValid(TunnelInfo tunnel, long timeToTest)` Note that we have reason to believe that the given tunnel is valid, since we could do something through it in the given amount of time
`void` `unshitlist(Hash peer)` We unshitlisted the peer
`void` `wrap(String bodyMessageType, long bodyMessageId, String containerMessageType, long containerMessageId)` Note that we're wrapping the given message within another message (via tunnel/garlic)

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

Field Detail

### PROP_KEEP_MESSAGE_HISTORY

    public static final String PROP_KEEP_MESSAGE_HISTORY

  config property determining whether we want to debug with the message history - default false

  See Also:
    Constant Field Values

### PROP_MESSAGE_HISTORY_FILENAME

    public static final String PROP_MESSAGE_HISTORY_FILENAME

  config property determining where we want to log the message history, if we're keeping one

  See Also:
    Constant Field Values

### DEFAULT_MESSAGE_HISTORY_FILENAME

    public static final String DEFAULT_MESSAGE_HISTORY_FILENAME

See Also:
  Constant Field Values

Constructor Detail

### MessageHistory

    public MessageHistory(RouterContext context)

Method Detail

### setDoLog

    void setDoLog(boolean log)

### getDoLog

    public boolean getDoLog()

### setPauseFlushes

    void setPauseFlushes(boolean doPause)

### getFilename

    String getFilename()

### initialize

    public void initialize(boolean forceReinitialize)

  Initialize the message history according to the router's configuration. Call this whenever the router identity changes.

### tunnelJoined

    public void tunnelJoined(String state,
                             TunnelInfo tunnel)

  The local router has joined the given tunnel operating in the given state.

  Parameters:
    `state` - {"free inbound", "allocated inbound", "inactive inbound", "outbound", "participant", "pending"}
    `tunnel` - tunnel joined

### tunnelJoined

    public void tunnelJoined(String state,
                             HopConfig tunnel)

  The local router has joined the given tunnel operating in the given state.

  Parameters:
    `state` - {"free inbound", "allocated inbound", "inactive inbound", "outbound", "participant", "pending"}
    `tunnel` - tunnel joined

### tunnelDispatched

    public void tunnelDispatched(String info)

### tunnelDispatched

    public void tunnelDispatched(long messageId,
                                 long tunnelId,
                                 String type)

### tunnelDispatched

    public void tunnelDispatched(long messageId,
                                 long tunnelId,
                                 long toTunnel,
                                 Hash toPeer,
                                 String type)

### tunnelDispatched

    public void tunnelDispatched(long messageId,
                                 long innerMessageId,
                                 long tunnelId,
                                 String type)

### tunnelFailed

    public void tunnelFailed(TunnelId tunnel)

  The local router has detected a failure in the given tunnel

  Parameters:
    `tunnel` - tunnel failed

### tunnelValid

    public void tunnelValid(TunnelInfo tunnel,
                            long timeToTest)

  Note that we have reason to believe that the given tunnel is valid, since we could do something through it in the given amount of time

  Parameters:
    `tunnel` - tunnel in question
    `timeToTest` - milliseconds to verify the tunnel

### tunnelRejected

    public void tunnelRejected(Hash peer,
                               TunnelId tunnel,
                               Hash replyThrough,
                               String reason)

  The peer did not accept the tunnel join for the given reason

### tunnelParticipantRejected

    public void tunnelParticipantRejected(Hash peer,
                                          String msg)

### tunnelRequestTimedOut

    public void tunnelRequestTimedOut(Hash peer,
                                      TunnelId tunnel)

  The peer did not accept the tunnel join for the given reason (this may be because of a timeout or an explicit refusal).

### droppedTunnelMessage

    public void droppedTunnelMessage(TunnelId id,
                                     long msgId,
                                     Date expiration,
                                     Hash from)

  We don't know about the given tunnel, so we are dropping a message sent to us by the given router

  Parameters:
    `id` - tunnel ID we received a message for
    `from` - peer that sent us this message (if known)

### droppedOtherMessage

    public void droppedOtherMessage(I2NPMessage message,
                                    Hash from)

  We received another message we weren't waiting for and don't know how to handle

### droppedInboundMessage

    public void droppedInboundMessage(long messageId,
                                      Hash from,
                                      String info)

### replyTimedOut

    public void replyTimedOut(OutNetMessage sentMessage)

  The message wanted a reply but no reply came in the time expected

  Parameters:
    `sentMessage` - message sent that didn't receive a reply

### messageProcessingError

    public void messageProcessingError(long messageId,
                                       String messageType,
                                       String error)

  There was an error processing the given message that was received

  Parameters:
    `messageId` - message received
    `messageType` - type of message received
    `error` - error message related to the processing of the message

### shitlist

    public void shitlist(Hash peer,
                         String reason)

  We shitlisted the peer

### unshitlist

    public void unshitlist(Hash peer)

  We unshitlisted the peer

### sendMessage

    public void sendMessage(String messageType,
                            long messageId,
                            long expiration,
                            Hash peer,
                            boolean sentOk,
                            String info)

  We just sent a message to the peer

  Parameters:
    `messageType` - class name for the message object (e.g. DatabaseFindNearestMessage, TunnelMessage, etc)
    `messageId` - the unique message id of the message being sent (not including any tunnel or garlic wrapped message ids)
    `expiration` - the expiration for the message sent
    `peer` - router that the message was sent to
    `sentOk` - whether the message was sent successfully

### receiveMessage

    public void receiveMessage(String messageType,
                               long messageId,
                               long expiration,
                               Hash from,
                               boolean isValid)

  We just received a message from the peer

  Parameters:
    `messageType` - class name for the message object (e.g. DatabaseFindNearestMessage, TunnelMessage, etc)
    `messageId` - the unique message id of the message received (not including any tunnel or garlic wrapped message ids)
    `expiration` - the expiration for the message received
    `from` - router that the message was sent from (or null if we don't know)
    `isValid` - whether the message is valid (non duplicates, etc)

### receiveMessage

    public void receiveMessage(String messageType,
                               long messageId,
                               long expiration,
                               boolean isValid)

### wrap

    public void wrap(String bodyMessageType,
                     long bodyMessageId,
                     String containerMessageType,
                     long containerMessageId)

  Note that we're wrapping the given message within another message (via tunnel/garlic)

  Parameters:
    `bodyMessageType` - class name for the message contained (e.g. DatabaseFindNearestMessage, DataMessage, etc)
    `bodyMessageId` - the unique message id of the message
    `containerMessageType` - class name for the message containing the body message (e.g. TunnelMessage, GarlicMessage, etc)
    `containerMessageId` - the unique message id of the message

### receivePayloadMessage

    public void receivePayloadMessage(long messageId)

  Receive a payload message to distribute to a client

### sendPayloadMessage

    public void sendPayloadMessage(long messageId,
                                   boolean successfullySent,
                                   long timeToSend)

  Note that the sending of a payload message completed (successfully or as a failure)

  Parameters:
    `messageId` - message that the payload message was sent in
    `successfullySent` - whether the message was delivered to the peer successfully
    `timeToSend` - how long it took to send the message

### receiveTunnelFragment

    public void receiveTunnelFragment(long messageId,
                                      int fragmentId,
                                      Object status)

### receiveTunnelFragmentComplete

    public void receiveTunnelFragmentComplete(long messageId)

### droppedFragmentedMessage

    public void droppedFragmentedMessage(long messageId,
                                         String status)

### fragmentMessage

    public void fragmentMessage(long messageId,
                                int numFragments,
                                int totalLength,
                                List messageIds,
                                String msg)

### fragmentMessage

    public void fragmentMessage(long messageId,
                                int numFragments,
                                int totalLength,
                                List messageIds,
                                Object tunnel,
                                String msg)

### droppedTunnelDataMessageUnknown

    public void droppedTunnelDataMessageUnknown(long msgId,
                                                long tunnelId)

### droppedTunnelGatewayMessageUnknown

    public void droppedTunnelGatewayMessageUnknown(long msgId,
                                                   long tunnelId)

### main

    public static void main(String[] args)