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

### Field Summary

Fields
`(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
`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)