public void up(MessageBatch batch) {
// Sort fork messages by fork-stack-id
Map<String, List<Message>> map = new HashMap<>();
for (Message msg : batch) {
ForkHeader hdr = (ForkHeader) msg.getHeader(id);
if (hdr != null) {
batch.remove(msg);
List<Message> list = map.get(hdr.fork_stack_id);
if (list == null) {
list = new ArrayList<>();
map.put(hdr.fork_stack_id, list);
}
list.add(msg);
}
}
// Now pass fork messages up, batched by fork-stack-id
for (Map.Entry<String, List<Message>> entry : map.entrySet()) {
String fork_stack_id = entry.getKey();
List<Message> list = entry.getValue();
Protocol bottom_prot = get(fork_stack_id);
if (bottom_prot == null) continue;
MessageBatch mb =
new MessageBatch(
batch.dest(), batch.sender(), batch.clusterName(), batch.multicast(), list);
try {
bottom_prot.up(mb);
} catch (Throwable t) {
log.error(Util.getMessage("FailedPassingUpBatch"), t);
}
}
if (!batch.isEmpty()) up_prot.up(batch);
}
public int size() {
int retval = Global.BYTE_SIZE * 2; // type + merge_rejected
retval += Global.BYTE_SIZE; // presence view
retval += Global.BYTE_SIZE; // MergeView or View
if (view != null) retval += view.serializedSize();
retval += Util.size(mbr);
retval += Util.size(mbrs);
retval += Global.BYTE_SIZE; // presence of join_rsp
if (join_rsp != null) retval += join_rsp.serializedSize();
retval += Global.BYTE_SIZE; // presence for my_digest
if (my_digest != null) retval += my_digest.serializedSize();
retval += Global.BYTE_SIZE; // presence for merge_id
if (merge_id != null) retval += merge_id.size();
retval += Global.BYTE_SIZE; // boolean useFlushIfPresent
return retval;
}
public void readFrom(DataInput in) throws Exception {
type = in.readByte();
boolean isMergeView = in.readBoolean();
if (isMergeView) view = (View) Util.readStreamable(MergeView.class, in);
else view = (View) Util.readStreamable(View.class, in);
mbr = Util.readAddress(in);
mbrs = Util.readAddresses(in, ArrayList.class);
join_rsp = (JoinRsp) Util.readStreamable(JoinRsp.class, in);
my_digest = (Digest) Util.readStreamable(Digest.class, in);
merge_id = (MergeId) Util.readStreamable(MergeId.class, in);
merge_rejected = in.readBoolean();
useFlushIfPresent = in.readBoolean();
}
public void writeTo(DataOutput out) throws Exception {
out.writeByte(type);
boolean isMergeView = view != null && view instanceof MergeView;
out.writeBoolean(isMergeView);
Util.writeStreamable(view, out);
Util.writeAddress(mbr, out);
Util.writeAddresses(mbrs, out);
Util.writeStreamable(join_rsp, out);
Util.writeStreamable(my_digest, out);
Util.writeStreamable(merge_id, out);
out.writeBoolean(merge_rejected);
out.writeBoolean(useFlushIfPresent);
}
protected boolean _startFlush(
final View new_view, int maxAttempts, long randomFloor, long randomCeiling) {
if (!flushProtocolInStack) return true;
if (flushInvokerClass != null) {
try {
Callable<Boolean> invoker =
flushInvokerClass.getDeclaredConstructor(View.class).newInstance(new_view);
return invoker.call();
} catch (Throwable e) {
return false;
}
}
try {
boolean successfulFlush = false;
boolean validView = new_view != null && new_view.size() > 0;
if (validView && flushProtocolInStack) {
int attemptCount = 0;
while (attemptCount < maxAttempts) {
try {
up_prot.up(new Event(Event.SUSPEND, new ArrayList<Address>(new_view.getMembers())));
successfulFlush = true;
break;
} catch (Exception e) {
Util.sleepRandom(randomFloor, randomCeiling);
attemptCount++;
}
}
if (successfulFlush) {
if (log.isTraceEnabled()) log.trace(local_addr + ": successful GMS flush by coordinator");
} else {
if (log.isWarnEnabled()) log.warn(local_addr + ": GMS flush by coordinator failed");
}
}
return successfulFlush;
} catch (Exception e) {
return false;
}
}
public void run() {
long end_time, wait_time;
List<Request> requests = new LinkedList<Request>();
while (Thread.currentThread().equals(thread) && !suspended) {
try {
boolean keepGoing = false;
end_time = System.currentTimeMillis() + max_bundling_time;
do {
Request firstRequest =
(Request)
queue.remove(INTERVAL); // throws a TimeoutException if it runs into timeout
requests.add(firstRequest);
if (!view_bundling) break;
if (queue.size() > 0) {
Request nextReq = (Request) queue.peek();
keepGoing = view_bundling && firstRequest.canBeProcessedTogether(nextReq);
} else {
wait_time = end_time - System.currentTimeMillis();
if (wait_time > 0)
queue.waitUntilClosed(
wait_time); // misnomer: waits until element has been added or q closed
keepGoing =
queue.size() > 0 && firstRequest.canBeProcessedTogether((Request) queue.peek());
}
} while (keepGoing && System.currentTimeMillis() < end_time);
try {
process(requests);
} finally {
requests.clear();
}
} catch (QueueClosedException e) {
break;
} catch (TimeoutException e) {
break;
} catch (Throwable catchall) {
Util.sleep(50);
}
}
}
public static InputStream getForkStream(String config) throws IOException {
InputStream configStream = null;
try {
configStream = new FileInputStream(config);
} catch (FileNotFoundException
| AccessControlException
fnfe) { // catching ACE fixes http://jira.jboss.com/jira/browse/JGRP-94
}
// Check to see if the properties string is a URL.
if (configStream == null) {
try {
configStream = new URL(config).openStream();
} catch (MalformedURLException mre) {
}
}
// Check to see if the properties string is the name of a resource, e.g. udp.xml.
if (configStream == null)
configStream = Util.getResourceAsStream(config, ConfiguratorFactory.class);
return configStream;
}
public int size() {
return Util.size(fork_stack_id) + Util.size(fork_channel_id);
}
