org.jgroups.protocols

## Class FRAG

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

    public class FRAG
    extends Protocol

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

Contrary to `FRAG2`, FRAG marshals the entire message (including the headers) into a byte[] buffer and the fragments that buffer. Because `Message.size()` is called rather than `Message.getLength()`, and because of the overhead of marshalling, this will be slower than FRAG2.

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 FRAG 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.

Author:
  Bela Ban, Filip Hanik

### 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
`FRAG()`

### Method Summary

Methods
`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()`
`void` `init()` Called after instance has been created (null constructor) and before protocol is started.
`void` `resetStats()`
`void` `setFragSize(int s)`
`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

#### FRAG

    public FRAG()

### Method Detail

#### getFragSize

    public int getFragSize()

#### setFragSize

    public void setFragSize(int s)

#### 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 framentation 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`