How to use

STABLE

in

org.jgroups.protocols.pbcast

lock.lock();
try {
  int rank=getRank(sender, view);
  if(rank < 0 || votes.get(rank))  // already received gossip from sender; discard it
    return;
  num_stable_msgs_received++;
  updateLocalDigest(d, sender);
  if(addVote(rank)) {       // votes from all members have been received
    resetDigest();        // sets digest
  resetNumBytes();
  sendStabilityMessage(stable_digest, stable_view_id);

/**
 * Adds mbr to votes and returns true if we have all the votes, otherwise false.
 * @param rank
 */
@GuardedBy("lock")
protected boolean addVote(int rank) {
  try {
    return votes.set(rank) && allVotesReceived(votes);
  }
  catch(Throwable t) {
    return false;
  }
}

final MutableDigest d=new MutableDigest(current_view.getMembersRaw()).set(getDigest());
Address dest=send_stable_msgs_to_coord_only? coordinator : null;
if(d.allSet() || d.set(getDigest()).allSet()) // try once more if the first digest didn't match
  log.trace("%s: sending stable msg to %s: %s",
       local_addr, (send_stable_msgs_to_coord_only? coordinator : "cluster"), printDigest(d));
else {
  log.trace("%s: could not find matching digest for view %s, missing members: %s", local_addr, current_view, d.getNonSetMembers());
 .setFlag(Message.Flag.OOB,Message.Flag.INTERNAL,Message.Flag.NO_RELIABILITY)
 .putHeader(this.id, new StableHeader(StableHeader.STABLE_GOSSIP, current_view.getViewId()))
 .setBuffer(marshal(d));
try {
  if(!send_in_background) {
  timer.execute(r, getTransport() instanceof TCP);

protected void handleUpEvent(StableHeader hdr, Address sender, Digest digest) {
  switch(hdr.type) {
    case StableHeader.STABLE_GOSSIP:
      handleStableMessage(digest, sender, hdr.view_id);
      break;
    case StableHeader.STABILITY:
      handleStabilityMessage(digest, sender, hdr.view_id);
      break;
    default:
      log.error("%s: StableHeader type %s not known", local_addr, hdr.type);
  }
}

protected void resume() {
  lock.lock();
  try {
    resetDigest(); // start from scratch
    suspended=false;
  }
  finally {
    lock.unlock();
  }
  log.debug("resuming message garbage collection");
  stopResumeTask();
}

public Object up(Message msg) {
  StableHeader hdr=msg.getHeader(this.id);
  if(hdr == null) {
    handleRegularMessage(msg);
    return up_prot.up(msg);
  }
  handleUpEvent(hdr, msg.getSrc(), readDigest(msg.getRawBuffer(), msg.getOffset(), msg.getLength()));
  return null;  // don't pass STABLE or STABILITY messages up the stack
}

public Object down(Event evt) {
  switch(evt.getType()) {
    case Event.VIEW_CHANGE:
      Object retval=down_prot.down(evt);
      handleViewChange(evt.getArg());
      return retval;
    case Event.SUSPEND_STABLE:
      long timeout=MAX_SUSPEND_TIME;
      Object t=evt.getArg();
      if(t != null && t instanceof Long)
        timeout=(Long)t;
      suspend(timeout);
      break;
    case Event.RESUME_STABLE:
      resume();
      break;
    case Event.SET_LOCAL_ADDRESS:
      local_addr=evt.getArg();
      break;
  }
  return down_prot.down(evt);
}

hdr=(StableHeader)msg.getHeader(name);
if(hdr == null) {
  handleRegularMessage(msg);
  return up_prot.up(evt);
  handleStableMessage(msg.getSrc(), hdr.stableDigest);
  break;
case StableHeader.STABILITY:
  handleStabilityMessage(hdr.stableDigest, msg.getSrc());
  break;
default:
Object retval=up_prot.up(evt);
View view=(View)evt.getArg();
handleViewChange(view);
return retval;

stopStabilityTask();
  log.trace("%s: received stability msg from %s: %s", local_addr, sender, printDigest(stable_digest));
  resetDigest();
resetNumBytes();
down_prot.down(new Event(Event.STABLE, stable_digest)); // pass STABLE down, so NAKACK{2} can purge stable messages

  return;
num_stable_msgs_received++;
boolean success=updateLocalDigest(d, sender);
if(!success) // we can only add the sender to votes if *all* elements of my digest were updated
  return;
all_votes_received=addVote(sender);
if(all_votes_received)
  copy=digest.copy();
sendStabilityMessage(copy);

public void runMessageGarbageCollection() {
  Digest copy=getDigest();
  sendStableMessage(copy);
}

stopStabilityTask();
         this.digest + "): ignoring digest and re-initializing own digest");
   resetDigest();
   return;
 resetDigest();

protected void handleViewChange(View v) {
  lock.lock();
  try {
    this.view=v;
    coordinator=v.getCoord();
    resetDigest();
    if(!initialized)
      initialized=true;
  }
  finally {
    lock.unlock();
  }
}

public Object up(Event evt) {
  switch(evt.getType()) {
    case Event.VIEW_CHANGE:
      Object retval=up_prot.up(evt);
      handleViewChange(evt.getArg());
      return retval;
  }
  return up_prot.up(evt);
}

public void run() {
  if(suspended)
    log.warn("ResumeTask resumed message garbage collection - this should be done by a RESUME_STABLE event; " +
          "check why this event was not received (or increase max_suspend_time for large state transfers)");
  resume();
}
public String toString() {return STABLE.class.getSimpleName() + ": ResumeTask";}

@GuardedBy("lock")
private void resetDigest() {
  Digest tmp=getDigest();
  digest.replace(tmp);
  if(log.isTraceEnabled())
    log.trace("resetting digest from NAKACK: " + digest.printHighestDeliveredSeqnos());
  votes.clear();
}

public Object down(Event evt) {
  switch(evt.getType()) {
    case Event.VIEW_CHANGE:
      Object retval=down_prot.down(evt);
      View v=(View)evt.getArg();
      handleViewChange(v);
    return retval;
  case Event.SUSPEND_STABLE:
    long timeout=0;
    Object t=evt.getArg();
    if(t != null && t instanceof Long)
      timeout=(Long)t;
    suspend(timeout);
    break;
  case Event.RESUME_STABLE:
    resume();
    break;
  }
  return down_prot.down(evt);
}

stopStabilityTask();
  log.trace("%s: received stability msg from %s: %s", local_addr, sender, printDigest(stable_digest));
  resetDigest();
resetNumBytes();
down_prot.down(new Event(Event.STABLE, stable_digest)); // pass STABLE down, so NAKACK{2} can purge stable messages

private void resume() {
  lock.lock();
  try {
    resetDigest(); // start from scratch
    suspended=false;
  }
  finally {
    lock.unlock();
  }
  if(log.isDebugEnabled())
    log.debug("resuming message garbage collection");
  stopResumeTask();
}

public Object up(Message msg) {
  StableHeader hdr=msg.getHeader(this.id);
  if(hdr == null) {
    handleRegularMessage(msg);
    return up_prot.up(msg);
  }
  handleUpEvent(hdr, msg.getSrc(), readDigest(msg.getRawBuffer(), msg.getOffset(), msg.getLength()));
  return null;  // don't pass STABLE or STABILITY messages up the stack
}