## 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
`static interface` `OutboundMessageFragments.ActiveThrottle`

Field Summary
`(package private) static int` `MAX_VOLLEYS` if we can handle more messages explicitly, set this to true

Constructor Summary
`OutboundMessageFragments(RouterContext ctx, UDPTransport transport, OutboundMessageFragments.ActiveThrottle throttle)`

Method Summary
`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)