net.i2p.router.transport.udp

## Class OutboundMessageFragments

- java.lang.Object
- - net.i2p.router.transport.udp.OutboundMessageFragments

-      class OutboundMessageFragments
      extends Object

  Coordinate the outbound fragments and select the next one to be built. This pool contains messages we are actively trying to send, essentially doing a round robin across each message to send one fragment, as implemented in `getNextVolley()`. This also honors per-peer throttling, taking note of each peer's allocations. If a message has each of its fragments sent more than a certain number of times, it is failed out. In addition, this instance also receives notification of message ACKs from the `InboundMessageFragments`, signaling that we can stop sending a message.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static interface` | `OutboundMessageFragments.ActiveThrottle`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `(package private) static int` | `MAX_VOLLEYS` if we can handle more messages explicitly, set this to true

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `OutboundMessageFragments(RouterContext ctx, UDPTransport transport, OutboundMessageFragments.ActiveThrottle throttle)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `acked(ACKBitfield bitfield, Hash ackedBy)`
    `int` | `acked(long messageId, Hash ackedBy)` We received an ACK of the given messageId from the given peer, so if it is still unacked, mark it as complete.
    `void` | `add(OutboundMessageState state)` short circuit the OutNetMessage, letting us send the establish complete message reliably
    `void` | `add(OutNetMessage msg)` Add a new message to the active pool
    `(package private) void` | `dropPeer(PeerState peer)`
    `UDPPacket[]` | `getNextVolley()` Fetch all the packets for a message volley, blocking until there is a message which can be fully transmitted (or the transport is shut down).
    `void` | `shutdown()`
    `void` | `startup()`
    `boolean` | `waitForMoreAllowed()` Block until we allow more messages to be admitted to the active pool.

    - ### Methods inherited from class java.lang.Object

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

- - ### Field Detail

    - #### MAX_VOLLEYS

          static final int MAX_VOLLEYS

      if we can handle more messages explicitly, set this to true
      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### OutboundMessageFragments

          public OutboundMessageFragments(RouterContext ctx,
                                  UDPTransport transport,
                                  OutboundMessageFragments.ActiveThrottle throttle)

  - ### Method Detail

    - #### startup

          public void startup()

    - #### shutdown

          public void shutdown()

    - #### dropPeer

          void dropPeer(PeerState peer)

    - #### waitForMoreAllowed

          public boolean waitForMoreAllowed()

      Block until we allow more messages to be admitted to the active pool. This is called by the `OutboundRefiller`
      Returns:
        true if more messages are allowed

    - #### add

          public void add(OutNetMessage msg)

      Add a new message to the active pool

    - #### add

          public void add(OutboundMessageState state)

      short circuit the OutNetMessage, letting us send the establish complete message reliably

    - #### getNextVolley

          public UDPPacket[] getNextVolley()

      Fetch all the packets for a message volley, blocking until there is a message which can be fully transmitted (or the transport is shut down). The returned array may be sparse, with null packets taking the place of already ACKed fragments.

    - #### acked

          public int acked(long messageId,
                  Hash ackedBy)

      We received an ACK of the given messageId from the given peer, so if it is still unacked, mark it as complete.
      Returns:
        fragments acked

    - #### acked

          public void acked(ACKBitfield bitfield,
                   Hash ackedBy)