org.jgroups.protocols

## Class FRAG2

- java.lang.Object
- - org.jgroups.stack.Protocol
  - - org.jgroups.protocols.FRAG2

    public class FRAG2
    extends Protocol

Fragmentation layer. Fragments messages larger than frag_size into smaller packets. Reassembles fragmented packets into bigger ones. The fragmentation number is prepended to the messages as a header (and removed at the receiving side).

Each fragment is identified by (a) the sender (part of the message to which the header is appended), (b) the fragmentation ID (which is unique per FRAG2 layer (monotonically increasing) and (c) the fragement ID which ranges from 0 to number_of_fragments-1.

Requirement: lossless delivery (e.g. NAK, ACK). No requirement on ordering. Works for both unicast and multicast messages.
Compared to FRAG, this protocol does not need to serialize the message in order to break it into smaller fragments: it looks only at the message's buffer, which is a byte[] array anyway. We assume that the size addition for headers and src and dest address is minimal when the transport finally has to serialize the message, so we add a constant (200 bytes).

Author:
  Bela Ban

### Field Summary

### Fields inherited from class org.jgroups.stack.Protocol

`down_prot, ergonomics, id, log, name, stack, stats, up_prot`

### Constructor Summary

Constructors
Constructor and Description
`FRAG2()`

### Method Summary

Methods
`void` `clearAllFragments()`
`void` `clearFragmentsFor(Address mbr)`
`java.lang.Object` `down(Event evt)` Fragment a packet if larger than frag_size (add a header).
`int` `getFragSize()`
`long` `getNumberOfReceivedFragments()`
`long` `getNumberOfReceivedMessages()`
`long` `getNumberOfSentFragments()`
`long` `getNumberOfSentMessages()`
`int` `getOverhead()` Deprecated. overhead was removed in 2.6.10
`void` `init()` Called after instance has been created (null constructor) and before protocol is started.
`void` `resetStats()`
`void` `setFragSize(int s)`
`void` `setOverhead(int o)` Deprecated. overhead was removed in 2.6.10
`java.lang.Object` `up(Event evt)` If event is a message, if it is fragmented, re-assemble fragments into big message and pass up the stack.

### Methods inherited from class org.jgroups.stack.Protocol

`destroy, downThreadEnabled, dumpStats, enableStats, getConfigurableObjects, getDownProtocol, getId, getLevel, getName, getProperties, getProtocolStack, getSocketFactory, getThreadFactory, getTransport, getUpProtocol, getValue, isErgonomics, printStats, providedDownServices, providedUpServices, requiredDownServices, requiredUpServices, setDownProtocol, setErgonomics, setId, setLevel, setProperties, setPropertiesInternal, setProperty, setProtocolStack, setSocketFactory, setUpProtocol, setValue, setValues, start, statsEnabled, stop, upThreadEnabled`

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

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

### Constructor Detail

#### FRAG2

    public FRAG2()

### Method Detail

#### getFragSize

    public int getFragSize()

#### setFragSize

    public void setFragSize(int s)

#### getOverhead

    public int getOverhead()

Deprecated. overhead was removed in 2.6.10

#### setOverhead

    public void setOverhead(int o)

Deprecated. overhead was removed in 2.6.10

#### getNumberOfSentMessages

    public long getNumberOfSentMessages()

#### getNumberOfSentFragments

    public long getNumberOfSentFragments()

#### getNumberOfReceivedMessages

    public long getNumberOfReceivedMessages()

#### getNumberOfReceivedFragments

    public long getNumberOfReceivedFragments()

#### init

    public void init()
              throws java.lang.Exception

Description copied from class: `Protocol`
Called after instance has been created (null constructor) and before protocol is started. Properties are already set. Other protocols are not yet connected and events cannot yet be sent.

Overrides:
  `init` in class `Protocol`
Throws:
  `java.lang.Exception` - Thrown if protocol cannot be initialized successfully. This will cause the ProtocolStack to fail, so the channel constructor will throw an exception

#### resetStats

    public void resetStats()

Overrides:
  `resetStats` in class `Protocol`

#### down

    public java.lang.Object down(Event evt)

Fragment a packet if larger than frag_size (add a header). Otherwise just pass down. Only add a header if fragmentation is needed !

Overrides:
  `down` in class `Protocol`

#### up

    public java.lang.Object up(Event evt)

If event is a message, if it is fragmented, re-assemble fragments into big message and pass up the stack.

Overrides:
  `up` in class `Protocol`

#### clearFragmentsFor

    public void clearFragmentsFor(Address mbr)

#### clearAllFragments

    public void clearAllFragments()