Java Event.MSG属性代码示例

@Test
public void recorderHandlesRejectedExecution() throws Exception {
  Message msg = mock(Message.class);
  when(msg.getHeader(any(Short.class))).thenReturn(Header.createDataHeader(1L, (short) 1, true));
  when(msg.size()).thenReturn(150L);

  // GEODE-1178, the TP protocol may throw a RejectedExecutionException & StatRecorder should
  // retry
  when(mockDownProtocol.down(any(Event.class))).thenThrow(new RejectedExecutionException());

  // after the first down() throws an exception we want StatRecorder to retry, so
  // we set the Manager to say no shutdown is in progress the first time and then say
  // one IS in progress so we can break out of the StatRecorder exception handling loop
  when(services.getCancelCriterion()).thenReturn(new Services().getCancelCriterion());
  Manager manager = mock(Manager.class);
  when(services.getManager()).thenReturn(manager);
  when(manager.shutdownInProgress()).thenReturn(Boolean.FALSE, Boolean.TRUE);

  verify(mockDownProtocol, never()).down(isA(Event.class));

  Event evt = new Event(Event.MSG, msg);
  recorder.down(evt);

  verify(mockDownProtocol, times(2)).down(isA(Event.class));
}
 

@Override
public Object up(Event event) {

    int type = event.getType();

    if (displayUpMessages) {

        if (type == Event.MSG) {

            Message msg = (Message) event.getArg();

            if (msg != null) {

                byte[] buffer = msg.getBuffer();

                if (buffer != null) {
                    log.info(">>>" + new String(buffer));
                }
            }
        }
    }
    return up_prot.up(event);
}
 

public Object down(Event evt) {
    switch(evt.getType()) {
        case Event.MSG:
            Message msg=(Message)evt.getArg();
            FORK.ForkHeader hdr=(FORK.ForkHeader)msg.getHeader(FORK.ID);
            if(hdr == null)
                msg.putHeader(FORK.ID, hdr=new FORK.ForkHeader(fork_stack_id, null));
            else
                hdr.setForkStackId(fork_stack_id);
            break;
        case Event.SET_LOCAL_ADDRESS:
        case Event.VIEW_CHANGE:
        case Event.CONNECT:
        case Event.CONNECT_USE_FLUSH:
        case Event.CONNECT_WITH_STATE_TRANSFER:
        case Event.CONNECT_WITH_STATE_TRANSFER_USE_FLUSH:
        case Event.DISCONNECT:
            return null; // don't propagate further down, this is only important for the main stack
    }
    return down_prot.down(evt);
}
 

/**
   * 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 <code>down_prot.down()</code> or c) the event (or another event) is sent up
   * the stack using <code>up_prot.up()</code>.
   */
  public Object up(Event evt) {
switch(evt.getType()) {
          case Event.MSG:
		Message message = (Message)evt.getArg();
		if ( message.isFlagSet( Message.Flag.OOB ) ) {
			return up_prot.up(evt);
		}
		else {
			PrioHeader hdr=(PrioHeader)message.getHeader(id);
			if(hdr != null) {
				log.trace("%s: adding priority message %d to UP queue", local_addr, hdr.getPriority());
				upMessageQueue.add( new PriorityMessage( evt, hdr.getPriority() ) );
				// send with hdr.prio
				return null;
			}
      			return up_prot.up(evt);
              }
          default:
      		return up_prot.up(evt);
      }
  }
 

/**
 * Fragment a packet if larger than frag_size (add a header). Otherwise just pass down. Only
 * add a header if fragmentation is needed !
 */
public Object down(Event evt) {
    switch(evt.getType()) {

        case Event.MSG:
            Message msg=(Message)evt.getArg();
            long size=msg.getLength();
            if(size > frag_size) {
                fragment(msg);  // Fragment and pass down
                return null;
            }
            break;

        case Event.VIEW_CHANGE:
            handleViewChange((View)evt.getArg());
            break;

        case Event.SET_LOCAL_ADDRESS:
            local_addr=(Address)evt.getArg();
            break;
    }

    return down_prot.down(evt);  // Pass on to the layer below us
}
 

@SuppressWarnings("unchecked")
public Object down(Event evt) {
    switch(evt.getType()) {
        case Event.MSG:
            Message msg=(Message)evt.getArg();
            if(msg.isFlagSet(Message.Flag.NO_FC))
                break;
            int length=msg.getLength();
            if(length == 0)
                break;
            return handleDownMessage(evt, msg, length);
        case Event.CONFIG:
            handleConfigEvent((Map<String,Object>)evt.getArg()); 
            break;
        case Event.VIEW_CHANGE:
            handleViewChange(((View)evt.getArg()).getMembers());
            break;
    }
    return down_prot.down(evt); // this could potentially use the lower protocol's thread which may block
}
 

public Object up(Event evt) {
    if(!up)
        return up_prot.up(evt);
    if(evt.getType() != Event.MSG)
        return up_prot.up(evt);
    Message msg=(Message)evt.getArg();
    synchronized(up_msgs) {
        up_msgs.add(msg);
    }
    if(up_msgs.size() >= max_size) {
        shuffleAndSendMessages();
    }
    else
        startTask();
    return null;
}
 

/**
 * If there is no header, we pass the message up. Otherwise we uncompress the payload to its original size.
 * @param evt
 */
public Object up(Event evt) {
    if(evt.getType() == Event.MSG) {
        Message msg=(Message)evt.getArg();
        CompressHeader hdr=(CompressHeader)msg.getHeader(this.id);
        if(hdr != null) {
            Message uncompressed_msg=uncompress(msg, hdr.original_size);
            if(uncompressed_msg != null) {
                if(log.isTraceEnabled())
                    log.trace("up(): uncompressed " + msg.getLength() + " bytes to " + uncompressed_msg.getLength() + " bytes");
                return up_prot.up(new Event(Event.MSG, uncompressed_msg));
            }
        }
    }
    return up_prot.up(evt);
}
 

/**
 * Fragment a packet if larger than frag_size (add a header). Otherwise just pass down. Only
 * add a header if framentation is needed !
 */
public Object down(Event evt) {
    switch(evt.getType()) {

        case Event.MSG:
            Message msg=(Message)evt.getArg();
            long size=msg.size();
            num_sent_msgs++;
            if(size > frag_size) {
                if(log.isTraceEnabled()) {
                    StringBuilder sb=new StringBuilder("message size is ");
                    sb.append(size).append(", will fragment (frag_size=").append(frag_size).append(')');
                    log.trace(sb.toString());
                }
                fragment(msg, size);  // Fragment and pass down
                return null;
            }
            break;

        case Event.VIEW_CHANGE:
            handleViewChange((View)evt.getArg());
            break;
    }

    return down_prot.down(evt);  // Pass on to the layer below us
}
 

/**
 * If event is a message, if it is fragmented, re-assemble fragments into big message and pass up the stack.
 */
public Object up(Event evt) {
    switch(evt.getType()) {
        case Event.MSG:
            Message msg=(Message)evt.getArg();
            FragHeader hdr=(FragHeader)msg.getHeader(this.id);
            if(hdr != null) { // needs to be defragmented
                Message assembled_msg=unfragment(msg, hdr);
                if(assembled_msg != null)
                    up_prot.up(new Event(Event.MSG, assembled_msg));
                return null;
            }
            else {
                num_received_msgs++;
            }
            break;

        case Event.VIEW_CHANGE:
            handleViewChange((View)evt.getArg());
            break;
    }

    return up_prot.up(evt); // Pass up to the layer above us by default
}
 

@Override
public Object up(Event evt) {
  switch (evt.getType()) {
    case Event.MSG:
      Message msg = (Message) evt.getArg();
      processForMulticast(msg, INCOMING);
      processForUnicast(msg, INCOMING);
      filter(msg, INCOMING);
  }
  return up_prot.up(evt);
}
 

@Override
public Object down(Event evt) {
  switch (evt.getType()) {
    case Event.MSG:
      Message msg = (Message) evt.getArg();
      processForMulticast(msg, OUTGOING);
      processForUnicast(msg, OUTGOING);
      filter(msg, OUTGOING);
      break;
  }
  do {
    try {
      return down_prot.down(evt);
    } catch (RejectedExecutionException e) {
      logger
          .debug("retrying JGroups message transmission due to rejected execution (GEODE-1178)");
      try {
        Thread.sleep(10);
      } catch (InterruptedException ie) {
        // down() does not throw InterruptedException so we can only set the interrupt flag and
        // return
        Thread.currentThread().interrupt();
        return null;
      }
    }
  } while (services != null && !services.getManager().shutdownInProgress()
      && !services.getCancelCriterion().isCancelInProgress());
  return null;
}
 

@Override
public Object down(Event evt) {
  switch (evt.getType()) {
    case Event.MSG:
      handleMessage((Message) evt.getArg());
      return null;
    case Event.SET_LOCAL_ADDRESS:
      uuid = (UUID) evt.getArg();
      break;
  }
  return down_prot.down(evt);
}
 

public Object down(Event evt) {
    if(evt.getType() == Event.MSG) {
        Message msg=(Message)evt.getArg();
        if(msg.getLength() > 0) {
            try {
                Long payload=(Long)msg.getObject();
                if(payload != null) {
                    if(payload == seqno) {
                        synchronized(this) {
                            if(num_discards < 3) {
                                num_discards++;
                                return null;
                            }
                        }
                    }
                    if(payload == duplicate) { // inject a duplicate message
                        super.down(evt); // pass it down, will passed down a second time by the default down_prot.down(evt)
                    }
                }
            }
            catch(Throwable t) {
                ;
            }
        }
    }
    return down_prot.down(evt);
}
 

@SuppressWarnings("unchecked")
public Object up(Event evt) {
    switch(evt.getType()) {

        case Event.MSG:
            Message msg=(Message)evt.getArg();
            if(msg.isFlagSet(Message.Flag.NO_FC))
                break;

            Address dest=msg.getDest();
            boolean multicast=dest == null;
            boolean handle_multicasts=handleMulticastMessage();
            FcHeader hdr=(FcHeader)msg.getHeader(this.id);
            boolean process=(handle_multicasts && multicast) || (!handle_multicasts && !multicast) || hdr != null;
            if(!process)
                break;
            
            if(hdr != null) {
                handleUpEvent(msg, hdr);
                return null; // don't pass message up
            }

            Address sender=msg.getSrc();
            long new_credits=adjustCredit(received, sender, msg.getLength());
            
            try {
                return up_prot.up(evt);
            }
            finally {
                if(new_credits > 0)
                    sendCredit(sender, new_credits);
            }

        case Event.VIEW_CHANGE:
            handleViewChange(((View)evt.getArg()).getMembers());
            break;
    }
    return up_prot.up(evt);
}