SEQUENCER2

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

```
public class SEQUENCER2
extends Protocol
```
Implementation of total order protocol using a sequencer_uum. Todo 1: on a sequencer change, the new coordinator needs to determine the highest seqno from all members Todo 2: on a sequencer change, if a member has pendindg messages in the forward-queue, they need to be resent

Author:

Bela Ban

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class SEQUENCER2.SequencerHeader

Nested Classes
Modifier and Type	Class and Description
`static class`	`SEQUENCER2.SequencerHeader`

Field Summary

Fields
Modifier and Type	Field and Description
`protected long`	`bcast_msgs`
`protected long`	`broadcasts_sent`
`protected Address`	`coord`
`protected long`	`delivered_bcasts`
`protected java.util.concurrent.BlockingQueue<Message>`	`fwd_queue`
`protected boolean`	`is_coord`
`protected Address`	`local_addr`
`protected long`	`received_bcasts`
`protected Table<Message>`	`received_msgs`
`protected long`	`received_requests`
`protected long`	`received_responses`
`protected long`	`request_msgs`
`protected long`	`response_msgs`
`protected boolean`	`running`
`protected long`	`sent_requests`
`protected long`	`sent_responses`
`protected java.util.concurrent.atomic.AtomicLong`	`seqno`
`protected java.util.concurrent.atomic.AtomicInteger`	`seqno_reqs`
`protected View`	`view`

Fields inherited from class org.jgroups.stack.Protocol
after_creation_hook, down_prot, ergonomics, id, log, name, stack, stats, up_prot

Constructor Summary

Constructors
Constructor and Description

SEQUENCER2()

Constructors
Constructor and Description
`SEQUENCER2()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`broadcast(Message msg, long seqno)`
`protected void`	`deliver(Message msg, Event evt, SEQUENCER2.SequencerHeader hdr)`
`protected void`	`deliverBatch(MessageBatch batch)`
`java.lang.Object`	`down(Event evt)` An event is to be sent down the stack.
`java.util.Map<java.lang.String,java.lang.Object>`	`dumpStats()`
`long`	`getBroadcast()`
`long`	`getBroadcastsSent()`
`Address`	`getCoordinator()`
`int`	`getFwdQueueSize()`
`Address`	`getLocalAddress()`
`long`	`getReceivedBroadcasts()`
`long`	`getReceivedRequests()`
`protected void`	`handleViewChange(View v)`
`boolean`	`isCoordinator()`
`java.lang.String`	`printStats()`
`protected void`	`removeAndDeliver(java.util.concurrent.atomic.AtomicBoolean processing, Table<Message> win, Address sender)`
`void`	`resetStats()`
`protected void`	`sendSeqnoRequest(int num_seqnos)`
`protected void`	`sendSeqnoResponse(Address original_sender, long seqno, int num_seqnos)`
`void`	`start()` This method is called on a `Channel.connect(String)`.
`void`	`stop()` This method is called on a `Channel.disconnect()`.
`java.lang.Object`	`up(Event evt)` An event was received from the layer below.
`void`	`up(MessageBatch batch)` Sends up a multiple messages in a `MessageBatch`.

Methods inherited from class org.jgroups.stack.Protocol
accept, afterCreationHook, destroy, enableStats, getConfigurableObjects, getDownProtocol, getDownServices, getId, getIdsAbove, getLevel, getLog, getName, getProtocolStack, getSocketFactory, getThreadFactory, getTransport, getUpProtocol, getUpServices, getValue, init, isErgonomics, level, parse, providedDownServices, providedUpServices, requiredDownServices, requiredUpServices, resetStatistics, setDownProtocol, setErgonomics, setId, setLevel, setProtocolStack, setSocketFactory, setUpProtocol, setValue, setValues, statsEnabled

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - local_addr
```
protected Address local_addr
```
  - coord
```
protected volatile Address coord
```
  - view
```
protected volatile View view
```
  - is_coord
```
protected volatile boolean is_coord
```
  - seqno
```
protected final java.util.concurrent.atomic.AtomicLong seqno
```
  - fwd_queue
```
protected final java.util.concurrent.BlockingQueue<Message> fwd_queue
```
  - seqno_reqs
```
protected final java.util.concurrent.atomic.AtomicInteger seqno_reqs
```
  - running
```
protected volatile boolean running
```
  - request_msgs
```
protected long request_msgs
```
  - response_msgs
```
protected long response_msgs
```
  - bcast_msgs
```
protected long bcast_msgs
```
  - received_bcasts
```
protected long received_bcasts
```
  - delivered_bcasts
```
protected long delivered_bcasts
```
  - broadcasts_sent
```
protected long broadcasts_sent
```
  - sent_requests
```
protected long sent_requests
```
  - received_requests
```
protected long received_requests
```
  - sent_responses
```
protected long sent_responses
```
  - received_responses
```
protected long received_responses
```
  - received_msgs
```
protected Table<Message> received_msgs
```
- Constructor Detail
  - SEQUENCER2
```
public SEQUENCER2()
```
- Method Detail
  - isCoordinator
```
public boolean isCoordinator()
```
  - getCoordinator
```
public Address getCoordinator()
```
  - getLocalAddress
```
public Address getLocalAddress()
```
  - getBroadcast
```
public long getBroadcast()
```
  - getReceivedRequests
```
public long getReceivedRequests()
```
  - getReceivedBroadcasts
```
public long getReceivedBroadcasts()
```
  - getFwdQueueSize
```
public int getFwdQueueSize()
```
  - resetStats
```
public void resetStats()
```
    Overrides:
    
    resetStats in class Protocol
  - dumpStats
```
public java.util.Map<java.lang.String,java.lang.Object> dumpStats()
```
    Overrides:
    
    dumpStats in class Protocol
  - printStats
```
public java.lang.String printStats()
```
    Overrides:
    
    printStats in class Protocol
  - start
```
public void start()
           throws java.lang.Exception
```
    Description copied from class: Protocol
    
    This method is called on a Channel.connect(String). Starts work. Protocols are connected and queues are ready to receive events. Will be called from bottom to top. This call will replace the START and START_OK events.
    
    Overrides:
    
    start in class Protocol
    
    Throws:
    
    java.lang.Exception - Thrown if protocol cannot be started successfully. This will cause the ProtocolStack to fail, so Channel.connect(String) will throw an exception
  - stop
```
public void stop()
```
    Description copied from class: Protocol
    
    This method is called on a Channel.disconnect(). Stops work (e.g. by closing multicast socket). Will be called from top to bottom. This means that at the time of the method invocation the neighbor protocol below is still working. This method will replace the STOP, STOP_OK, CLEANUP and CLEANUP_OK events. The ProtocolStack guarantees that when this method is called all messages in the down queue will have been flushed
    
    Overrides:
    
    stop in class Protocol
  - getBroadcastsSent
```
public long getBroadcastsSent()
```
  - down
```
public java.lang.Object down(Event evt)
```
    Description copied from class: Protocol
    
    An event is to be sent down the stack. The layer may want to examine its type and perform some action on it, depending on the event's type. If the event is a message MSG, then the layer may need to add a header to it (or do nothing at all) before sending it down the stack using down_prot.down(). In case of a GET_ADDRESS event (which tries to retrieve the stack's address from one of the bottom layers), the layer may need to send a new response event back up the stack using up_prot.up().
    
    Overrides:
    
    down in class Protocol
  - up
```
public java.lang.Object up(Event evt)
```
    Description copied from class: Protocol
    
    An event was received from the layer below. Usually the current layer will want to examine the event type and - depending on its type - perform some computation (e.g. removing headers from a MSG event type, or updating the internal membership list when receiving a VIEW_CHANGE event). Finally the event is either a) discarded, or b) an event is sent down the stack using down_prot.down() or c) the event (or another event) is sent up the stack using up_prot.up().
    
    Overrides:
    
    up in class Protocol
  - up
```
public void up(MessageBatch batch)
```
    Description copied from class: Protocol
    
    Sends up a multiple messages in a MessageBatch. The sender of the batch is always the same, and so is the destination (null == multicast messages). Messages in a batch can be OOB messages, regular messages, or mixed messages, although the transport itself will create initial MessageBatches that contain only either OOB or regular messages.
    The default processing below sends messages up the stack individually, based on a matching criteria (calling Protocol.accept(org.jgroups.Message)), and - if true - calls Protocol.up(org.jgroups.Event) for that message and removes the message. If the batch is not empty, it is passed up, or else it is dropped.
    Subclasses should check if there are any messages destined for them (e.g. using MessageBatch.getMatchingMessages(short,boolean)), then possibly remove and process them and finally pass the batch up to the next protocol. Protocols can also modify messages in place, e.g. ENCRYPT could decrypt all encrypted messages in the batch, not remove them, and pass the batch up when done.
    
    Overrides:
    
    up in class Protocol
    
    Parameters:
    
    batch - The message batch
  - handleViewChange
```
protected void handleViewChange(View v)
```
  - sendSeqnoRequest
```
protected void sendSeqnoRequest(int num_seqnos)
```
  - sendSeqnoResponse
```
protected void sendSeqnoResponse(Address original_sender,
                                 long seqno,
                                 int num_seqnos)
```
  - broadcast
```
protected void broadcast(Message msg,
                         long seqno)
```
  - deliver
```
protected void deliver(Message msg,
                       Event evt,
                       SEQUENCER2.SequencerHeader hdr)
```
  - removeAndDeliver
```
protected void removeAndDeliver(java.util.concurrent.atomic.AtomicBoolean processing,
                                Table<Message> win,
                                Address sender)
```
  - deliverBatch
```
protected void deliverBatch(MessageBatch batch)
```

Class SEQUENCER2

Nested Class Summary

Field Summary

Fields inherited from class org.jgroups.stack.Protocol

Constructor Summary

Method Summary

Methods inherited from class org.jgroups.stack.Protocol

Methods inherited from class java.lang.Object

Field Detail

local_addr

coord

view

is_coord

seqno

fwd_queue

seqno_reqs

running

request_msgs

response_msgs

bcast_msgs

received_bcasts

delivered_bcasts

broadcasts_sent

sent_requests

received_requests

sent_responses

received_responses

received_msgs

Constructor Detail

SEQUENCER2

Method Detail

isCoordinator

getCoordinator

getLocalAddress

getBroadcast

getReceivedRequests

getReceivedBroadcasts

getFwdQueueSize

resetStats

dumpStats

printStats

start

stop

getBroadcastsSent

down

up

up

handleViewChange

sendSeqnoRequest

sendSeqnoResponse

broadcast

deliver

removeAndDeliver

deliverBatch