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
    Modifier and Type | Method and Description
    --- | ---
    `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()

Copyright © 1998-2009 Bela Ban / Red Hat. All Rights Reserved.