Java Message.copy方法代码示例

import org.jgroups.Message; //导入方法依赖的package包/类
public static void testCopyWithOffset() {
    byte[] buf={'b', 'e', 'l', 'a', 'b', 'a', 'n'};
    Message m1=new Message(null, null, buf, 0, 4);
    Message m2=new Message(null, null, buf, 4, 3);

    Message m3, m4;
    m3=m1.copy();
    m4=m2.copy();

    Assert.assertEquals(0, m3.getOffset());
    Assert.assertEquals(4, m3.getLength());
    Assert.assertEquals(4, m3.getBuffer().length);

    Assert.assertEquals(4, m4.getOffset());
    Assert.assertEquals(3, m4.getLength());
    Assert.assertEquals(3, m4.getBuffer().length);
}
 

import org.jgroups.Message; //导入方法依赖的package包/类
public MessageInfo(MessageID messageID, Message message, long sequenceNumber) {
    if (messageID == null) {
        throw new NullPointerException("Message ID can't be null");
    }
    this.messageID = messageID;
    this.message = message.copy(true, true);
    this.sequenceNumber = sequenceNumber;
    this.readyToDeliver = false;
    this.message.setSrc(messageID.getAddress());
}
 

import org.jgroups.Message; //导入方法依赖的package包/类
private void loopback(Message msg) {
    final Message rsp=msg.copy(true);
    if(rsp.getSrc() == null)
        rsp.setSrc(localAddress());

    // pretty inefficient: creates one thread per message, okay for testing only
    Thread thread=new Thread(new Runnable() {
        public void run() {
            up_prot.up(new Event(Event.MSG, rsp));
        }
    });
    thread.start();
}
 

import org.jgroups.Message; //导入方法依赖的package包/类
/** Send all fragments as separate messages (with same ID !).
 Example:
 <pre>
 Given the generated ID is 2344, number of fragments=3, message {dst,src,buf}
 would be fragmented into:

 [2344,3,0]{dst,src,buf1},
 [2344,3,1]{dst,src,buf2} and
 [2344,3,2]{dst,src,buf3}
 </pre>
 */
protected void fragment(Message msg) {
    try {
        byte[] buffer=msg.getRawBuffer();
        final List<Range> fragments=Util.computeFragOffsets(msg.getOffset(), msg.getLength(), frag_size);
        int num_frags=fragments.size();
        num_frags_sent.addAndGet(num_frags);

        if(log.isTraceEnabled()) {
            Address dest=msg.getDest();
            log.trace("%s: fragmenting message to %s (size=%d) into %d fragment(s) [frag_size=%d]",
                      local_addr, dest != null ? dest : "<all>", msg.getLength(), num_frags, frag_size);
        }

        long frag_id=getNextId(); // used as a seqno
        for(int i=0; i < num_frags; i++) {
            Range r=fragments.get(i);
            // don't copy the buffer, only src, dest and headers. Only copy the headers one time !
            Message frag_msg=msg.copy(false, i == 0);
            frag_msg.setBuffer(buffer, (int)r.low, (int)r.high);
            FragHeader hdr=new FragHeader(frag_id, i, num_frags);
            frag_msg.putHeader(this.id, hdr);
            down_prot.down(new Event(Event.MSG, frag_msg));
        }
    }
    catch(Exception e) {
        log.error("%s: fragmentation failure: %s", local_addr, e);
    }
}
 

import org.jgroups.Message; //导入方法依赖的package包/类
/**
 * Sends all messages currently in forward_table to the new target (changing the dest field).
 * This needs to be done, so the underlying reliable unicast protocol (e.g. UNICAST) adds these messages
 * to its retransmission mechanism<br/>
 * Note that we need to resend the messages in order of their seqnos ! We also need to prevent other message
 * from being inserted until we're done, that's why there's synchronization.<br/>
 * Access to the forward_table doesn't need to be synchronized as there won't be any insertions during flushing
 * (all down-threads are blocked)
 */
protected void flushMessagesInForwardTable(Address target) {
    // for forwarded messages, we need to receive the forwarded message from the coordinator, to prevent this case:
    // - V1={A,B,C}
    // - A crashes
    // - C installs V2={B,C}
    // - C forwards messages 3 and 4 to B (the new coord)
    // - B drops 3 because its view is still V1
    // - B installs V2
    // - B receives message 4 and broadcasts it
    // ==> C's message 4 is delivered *before* message 3 !
    // ==> By resending 3 until it is received, then resending 4 until it is received, we make sure this won't happen
    // (see https://issues.jboss.org/browse/JGRP-1449)

    // Forward the first entry and wait for the ack
    Map.Entry<Long,Message> first=forward_table.firstEntry();
    if(first == null)
        return;
    Long key=first.getKey();
    Message val=first.getValue();
    Message forward_msg;

    while(flushing && running && !forward_table.isEmpty()) {
        forward_msg=val.copy();
        forward_msg.setDest(target);
        forward_msg.setFlag(Message.Flag.DONT_BUNDLE);
        if(log.isTraceEnabled())
            log.trace(local_addr + ": flushing (forwarding) " + "::" + key + " to target " + target);
        ack_promise.reset();
        down_prot.down(new Event(Event.MSG, forward_msg));
        Long ack=ack_promise.getResult(500);
        if((ack != null && ack.equals(key)) || !forward_table.containsKey(key))
            break;
    }

    for(Map.Entry<Long,Message> entry: forward_table.entrySet()) {
        key=entry.getKey();
        val=entry.getValue();
        if(flushing && running) {
            forward_msg=val.copy();
            forward_msg.setDest(target);
            forward_msg.setFlag(Message.Flag.DONT_BUNDLE);
            if(log.isTraceEnabled())
                log.trace(local_addr + ": flushing (forwarding) " + "::" + key + " to target " + target);
            down_prot.down(new Event(Event.MSG, forward_msg));
        }
    }
}