public Object up(Event evt) {
switch (evt.getType()) {
case Event.MSG:
Message msg = (Message) evt.getArg();
ForkHeader hdr = (ForkHeader) msg.getHeader(id);
if (hdr == null) break;
if (hdr.fork_stack_id == null)
throw new IllegalArgumentException("header has a null fork_stack_id");
Protocol bottom_prot = get(hdr.fork_stack_id);
return bottom_prot != null
? bottom_prot.up(evt)
: this.unknownForkHandler.handleUnknownForkStack(msg, hdr.fork_stack_id);
case Event.VIEW_CHANGE:
for (Protocol bottom : fork_stacks.values()) bottom.up(evt);
break;
case Event.STATE_TRANSFER_OUTPUTSTREAM:
if (!process_state_events) break;
getStateFromMainAndForkChannels(evt);
return null;
case Event.STATE_TRANSFER_INPUTSTREAM:
if (!process_state_events) break;
setStateInMainAndForkChannels((InputStream) evt.getArg());
return null;
}
return up_prot.up(evt);
}
/**
* handle the UP event.
*
* @param evt - the event being send from the stack
*/
public void up(Event evt) {
passUp(evt);
switch (evt.getType()) {
case Event.CONFIG:
passUp(evt);
if (Trace.trace) {
Trace.info("UDP.up()", "received CONFIG event: " + evt.getArg());
}
handleConfigEvent((HashMap) evt.getArg());
return;
}
passUp(evt);
}
public Object down(Event evt) {
switch (evt.getType()) {
case Event.SET_LOCAL_ADDRESS:
local_addr = (Address) evt.getArg();
break;
}
return down_prot.down(evt);
}
/**
* Sends an event down the protocol stack. Note that - contrary to {@link #send(Message)}, if the
* event is a message, no checks are performed whether the channel is closed or disconnected.
*
* @param evt the message to send down, encapsulated in an event
*/
public Object down(Event evt) {
if (evt == null) return null;
if (stats && evt.getType() == Event.MSG) {
sent_msgs++;
sent_bytes += ((Message) evt.getArg()).getLength();
}
return prot_stack.down(evt);
}
public Object up(Event evt) {
switch (evt.getType()) {
case Event.VIEW_CHANGE:
handleView(evt.getArg());
break;
}
return up_prot.up(evt);
}
protected void _connect(Event connect_event) throws Exception {
try {
down(connect_event);
} catch (Throwable t) {
stopStack(true, false);
state = State.OPEN;
init();
throw new Exception("connecting to channel \"" + connect_event.getArg() + "\" failed", t);
}
}
public Object down(Event evt) {
switch (evt.getType()) {
case Event.MSG:
Message msg = (Message) evt.getArg();
if (msg.getLength() == 0 && !encrypt_entire_message) break;
try {
if (queue_down) {
log.trace("queueing down message as no session key established: %s", msg);
downMessageQueue.put(msg); // queue messages if we are waiting for a new key
} else {
// make sure the down queue is drained first to keep ordering
if (!suppliedKey) drainDownQueue();
encryptAndSend(msg);
}
} catch (Exception e) {
log.warn("unable to send message down", e);
}
return null;
case Event.VIEW_CHANGE:
View view = (View) evt.getArg();
log.debug("new view: " + view);
if (!suppliedKey) handleViewChange(view, false);
break;
case Event.SET_LOCAL_ADDRESS:
local_addr = (Address) evt.getArg();
log.debug("set local address to %s", local_addr);
break;
case Event.TMP_VIEW:
view = (View) evt.getArg();
if (!suppliedKey) {
// if a tmp_view then we are trying to become coordinator so
// make us keyserver
handleViewChange(view, true);
}
break;
}
return down_prot.down(evt);
}
void handleDownEvent(Event evt) {
switch (evt.getType()) {
case Event.TMP_VIEW:
case Event.VIEW_CHANGE:
synchronized (members) {
members.removeAllElements();
Vector tmpvec = ((View) evt.getArg()).getMembers();
for (int i = 0; i < tmpvec.size(); i++) {
members.addElement(tmpvec.elementAt(i));
}
}
break;
case Event.GET_LOCAL_ADDRESS: // return local address -> Event(SET_LOCAL_ADDRESS, local)
passUp(new Event(Event.SET_LOCAL_ADDRESS, local_addr));
break;
case Event.CONNECT:
group_addr = (String) evt.getArg();
udp_hdr = new UdpHeader(group_addr);
// removed March 18 2003 (bela), not needed (handled by GMS)
// changed July 2 2003 (bela): we discard CONNECT_OK at the GMS level anyway, this might
// be needed if we run without GMS though
passUp(new Event(Event.CONNECT_OK));
break;
case Event.DISCONNECT:
passUp(new Event(Event.DISCONNECT_OK));
break;
case Event.CONFIG:
if (Trace.trace) {
Trace.info("UDP.down()", "received CONFIG event: " + evt.getArg());
}
handleConfigEvent((HashMap) evt.getArg());
break;
}
}
public Object up(Event evt) {
switch (evt.getType()) {
case Event.VIEW_CHANGE:
View view = (View) evt.getArg();
log.debug("new view: " + view);
if (!suppliedKey) handleViewChange(view, false);
break;
case Event.TMP_VIEW:
view = (View) evt.getArg();
if (!suppliedKey) handleViewChange(view, true);
break;
// we try and decrypt all messages
case Event.MSG:
try {
return handleUpMessage(evt);
} catch (Exception e) {
log.warn("exception occurred decrypting message", e);
}
return null;
}
return up_prot.up(evt);
}
private Object handleUpMessage(Event evt) throws Exception {
Message msg = (Message) evt.getArg();
EncryptHeader hdr;
if (msg == null
|| (msg.getLength() == 0 && !encrypt_entire_message)
|| ((hdr = (EncryptHeader) msg.getHeader(this.id)) == null)) return up_prot.up(evt);
if (log.isTraceEnabled()) log.trace("header received %s", hdr);
switch (hdr.getType()) {
case EncryptHeader.ENCRYPT:
return handleEncryptedMessage(msg, evt, hdr);
default:
handleUpEvent(msg, hdr);
return null;
}
}
protected void getStateFromMainAndForkChannels(Event evt) {
final OutputStream out = (OutputStream) evt.getArg();
try (DataOutputStream dos = new DataOutputStream(out)) {
getStateFrom(null, up_prot, null, null, dos);
// now fetch state from all fork channels
for (Map.Entry<String, Protocol> entry : fork_stacks.entrySet()) {
String stack_name = entry.getKey();
Protocol prot = entry.getValue();
ForkProtocolStack fork_stack = getForkStack(prot);
for (Map.Entry<String, JChannel> en : fork_stack.getForkChannels().entrySet()) {
String fc_name = en.getKey();
JChannel fc = en.getValue();
getStateFrom(fc, null, stack_name, fc_name, dos);
}
}
} catch (Throwable ex) {
log.error("%s: failed fetching state from main channel", local_addr, ex);
}
}
protected Object handleUpEvent(Event evt) throws Exception {
switch (evt.getType()) {
case Event.MSG:
if (msg_listener != null) msg_listener.receive((Message) evt.getArg());
break;
case Event.GET_APPLSTATE: // reply with GET_APPLSTATE_OK
byte[] tmp_state = null;
if (msg_listener != null) {
ByteArrayOutputStream output = new ByteArrayOutputStream(1024);
msg_listener.getState(output);
tmp_state = output.toByteArray();
}
return new StateTransferInfo(null, 0L, tmp_state);
case Event.GET_STATE_OK:
if (msg_listener != null) {
StateTransferResult result = (StateTransferResult) evt.getArg();
if (result.hasBuffer()) {
ByteArrayInputStream input = new ByteArrayInputStream(result.getBuffer());
msg_listener.setState(input);
}
}
break;
case Event.STATE_TRANSFER_OUTPUTSTREAM:
OutputStream os = (OutputStream) evt.getArg();
if (msg_listener != null && os != null) {
msg_listener.getState(os);
}
break;
case Event.STATE_TRANSFER_INPUTSTREAM:
InputStream is = (InputStream) evt.getArg();
if (msg_listener != null && is != null) msg_listener.setState(is);
break;
case Event.VIEW_CHANGE:
View v = (View) evt.getArg();
List<Address> new_mbrs = v.getMembers();
setMembers(new_mbrs);
if (membership_listener != null) membership_listener.viewAccepted(v);
break;
case Event.SET_LOCAL_ADDRESS:
if (log.isTraceEnabled())
log.trace("setting local_addr (" + local_addr + ") to " + evt.getArg());
local_addr = (Address) evt.getArg();
break;
case Event.SUSPECT:
if (membership_listener != null) membership_listener.suspect((Address) evt.getArg());
break;
case Event.BLOCK:
if (membership_listener != null) membership_listener.block();
break;
case Event.UNBLOCK:
if (membership_listener != null) membership_listener.unblock();
break;
}
return null;
}
/**
* Caller by the layer above this layer. Usually we just put this Message into the send queue and
* let one or more worker threads handle it. A worker thread then removes the Message from the
* send queue, performs a conversion and adds the modified Message to the send queue of the layer
* below it, by calling Down).
*/
public void down(Event evt) {
Message msg;
Object dest_addr;
if (evt.getType() != Event.MSG) { // unless it is a message handle it and respond
handleDownEvent(evt);
return;
}
// ****************** profiling ******************
/*if(num_msgs == 0) {
start=System.currentTimeMillis();
num_msgs++;
}
else if(num_msgs >= 1000) {
stop=System.currentTimeMillis();
long total_time=stop-start;
double msgs_per_msec=num_msgs / (double)total_time;
if(Trace.trace)
Trace.info("UDP.down.profile()",
"total_time=" + total_time + ", msgs/ms=" + msgs_per_msec);
num_msgs=0;
}
else {
num_msgs++;
}*/
// ****************** profiling ******************
msg = (Message) evt.getArg();
if (udp_hdr != null && udp_hdr.group_addr != null) {
// added patch by Roland Kurmann (March 20 2003)
msg.putHeader(name, udp_hdr);
}
dest_addr = msg.getDest();
// Because we don't call Protocol.passDown(), we notify the observer directly (e.g.
// PerfObserver).
// This way, we still have performance numbers for UDP
if (observer != null) {
observer.passDown(evt);
}
if (dest_addr == null) { // 'null' means send to all group members
if (ip_mcast) {
if (mcast_addr == null) {
Trace.error(
"UDP.down()",
"dest address of message is null, and "
+ "sending to default address fails as mcast_addr is null, too !"
+ " Discarding message "
+ Util.printEvent(evt));
return;
}
// if we want to use IP multicast, then set the destination of the message
msg.setDest(mcast_addr);
} else {
// sends a separate UDP message to each address
sendMultipleUdpMessages(msg, members);
return;
}
}
try {
sendUdpMessage(msg);
} catch (Exception e) {
Trace.error("UDP.down()", "exception=" + e + ", msg=" + msg + ", mcast_addr=" + mcast_addr);
}
}
@SuppressWarnings("unchecked")
public Object up(Event evt) {
switch (evt.getType()) {
case Event.MSG:
Message msg = (Message) evt.getArg();
GmsHeader hdr = (GmsHeader) msg.getHeader(this.id);
if (hdr == null) break;
switch (hdr.type) {
case GmsHeader.JOIN_REQ:
view_handler.add(
new Request(Request.JOIN, hdr.mbr, false, null, hdr.useFlushIfPresent));
break;
case GmsHeader.JOIN_REQ_WITH_STATE_TRANSFER:
view_handler.add(
new Request(
Request.JOIN_WITH_STATE_TRANSFER, hdr.mbr, false, null, hdr.useFlushIfPresent));
break;
case GmsHeader.JOIN_RSP:
impl.handleJoinResponse(hdr.join_rsp);
break;
case GmsHeader.LEAVE_REQ:
if (hdr.mbr == null) return null;
view_handler.add(new Request(Request.LEAVE, hdr.mbr, false));
break;
case GmsHeader.LEAVE_RSP:
impl.handleLeaveResponse();
break;
case GmsHeader.VIEW:
View new_view = hdr.view;
if (new_view == null) return null;
Address coord = msg.getSrc();
if (!new_view.containsMember(coord)) {
sendViewAck(
coord); // we need to send the ack first, otherwise the connection is removed
impl.handleViewChange(new_view, hdr.my_digest);
} else {
impl.handleViewChange(new_view, hdr.my_digest);
sendViewAck(coord); // send VIEW_ACK to sender of view
}
break;
case GmsHeader.VIEW_ACK:
Address sender = msg.getSrc();
ack_collector.ack(sender);
return null; // don't pass further up
case GmsHeader.MERGE_REQ:
impl.handleMergeRequest(msg.getSrc(), hdr.merge_id, hdr.mbrs);
break;
case GmsHeader.MERGE_RSP:
MergeData merge_data =
new MergeData(msg.getSrc(), hdr.view, hdr.my_digest, hdr.merge_rejected);
if (log.isTraceEnabled()) {
log.trace(
local_addr
+ ": got merge response from "
+ msg.getSrc()
+ ", merge_id="
+ hdr.merge_id
+ ", merge data is "
+ merge_data);
}
impl.handleMergeResponse(merge_data, hdr.merge_id);
break;
case GmsHeader.INSTALL_MERGE_VIEW:
impl.handleMergeView(
new MergeData(msg.getSrc(), hdr.view, hdr.my_digest), hdr.merge_id);
break;
case GmsHeader.INSTALL_DIGEST:
Digest tmp = hdr.my_digest;
down_prot.down(new Event(Event.MERGE_DIGEST, tmp));
break;
case GmsHeader.INSTALL_MERGE_VIEW_OK:
// [JGRP-700] - FLUSH: flushing should span merge
merge_ack_collector.ack(msg.getSrc());
break;
case GmsHeader.CANCEL_MERGE:
// [JGRP-524] - FLUSH and merge: flush doesn't wrap entire merge process
impl.handleMergeCancelled(hdr.merge_id);
break;
case GmsHeader.GET_DIGEST_REQ:
// only handle this request if it was sent by the coordinator (or at least a member) of
// the current cluster
synchronized (members) {
if (!members.contains(msg.getSrc())) break;
}
// discard my own request:
if (msg.getSrc().equals(local_addr)) return null;
if (hdr.merge_id != null
&& !(merger.matchMergeId(hdr.merge_id) || merger.setMergeId(null, hdr.merge_id)))
return null;
// fetch only my own digest
Digest digest = (Digest) down_prot.down(new Event(Event.GET_DIGEST, local_addr));
if (digest != null) {
GmsHeader rsp_hdr = new GmsHeader(GmsHeader.GET_DIGEST_RSP);
rsp_hdr.my_digest = digest;
Message get_digest_rsp = new Message(msg.getSrc(), null, null);
get_digest_rsp.setFlag(Message.OOB);
get_digest_rsp.putHeader(this.id, rsp_hdr);
down_prot.down(new Event(Event.MSG, get_digest_rsp));
}
break;
case GmsHeader.GET_DIGEST_RSP:
Digest digest_rsp = hdr.my_digest;
impl.handleDigestResponse(msg.getSrc(), digest_rsp);
break;
default:
if (log.isErrorEnabled()) log.error("GmsHeader with type=" + hdr.type + " not known");
}
return null; // don't pass up
case Event.SUSPECT:
Object retval = up_prot.up(evt);
Address suspected = (Address) evt.getArg();
view_handler.add(new Request(Request.SUSPECT, suspected, true));
ack_collector.suspect(suspected);
merge_ack_collector.suspect(suspected);
return retval;
case Event.UNSUSPECT:
impl.unsuspect((Address) evt.getArg());
return null; // discard
case Event.MERGE:
view_handler.add(
new Request(Request.MERGE, null, false, (Map<Address, View>) evt.getArg()));
return null; // don't pass up
case Event.IS_MERGE_IN_PROGRESS:
return merger.isMergeInProgress();
}
return up_prot.up(evt);
}
@SuppressWarnings("unchecked")
public Object down(Event evt) {
int type = evt.getType();
switch (type) {
case Event.CONNECT:
case Event.CONNECT_USE_FLUSH:
case Event.CONNECT_WITH_STATE_TRANSFER:
case Event.CONNECT_WITH_STATE_TRANSFER_USE_FLUSH:
boolean use_flush =
type == Event.CONNECT_USE_FLUSH || type == Event.CONNECT_WITH_STATE_TRANSFER_USE_FLUSH;
boolean state_transfer =
type == Event.CONNECT_WITH_STATE_TRANSFER
|| type == Event.CONNECT_WITH_STATE_TRANSFER_USE_FLUSH;
if (print_local_addr) {
PhysicalAddress physical_addr =
print_physical_addrs
? (PhysicalAddress) down(new Event(Event.GET_PHYSICAL_ADDRESS, local_addr))
: null;
System.out.println(
"\n-------------------------------------------------------------------\n"
+ "GMS: address="
+ local_addr
+ ", cluster="
+ evt.getArg()
+ (physical_addr != null ? ", physical address=" + physical_addr : "")
+ "\n-------------------------------------------------------------------");
} else {
if (log.isDebugEnabled()) {
PhysicalAddress physical_addr =
print_physical_addrs
? (PhysicalAddress) down(new Event(Event.GET_PHYSICAL_ADDRESS, local_addr))
: null;
log.debug(
"address="
+ local_addr
+ ", cluster="
+ evt.getArg()
+ (physical_addr != null ? ", physical address=" + physical_addr : ""));
}
}
down_prot.down(evt);
if (local_addr == null) throw new IllegalStateException("local_addr is null");
try {
if (state_transfer) impl.joinWithStateTransfer(local_addr, use_flush);
else impl.join(local_addr, use_flush);
} catch (Throwable e) {
return e;
}
return null; // don't pass down: event has already been passed down
case Event.DISCONNECT:
impl.leave((Address) evt.getArg());
if (!(impl instanceof CoordGmsImpl)) {
initState(); // in case connect() is called again
}
down_prot.down(evt); // notify the other protocols, but ignore the result
return null;
case Event.CONFIG:
Map<String, Object> config = (Map<String, Object>) evt.getArg();
if ((config != null && config.containsKey("flush_supported"))) {
flushProtocolInStack = true;
}
break;
case Event.SET_LOCAL_ADDRESS:
local_addr = (Address) evt.getArg();
break;
}
return down_prot.down(evt);
}
public Object down(Event evt) {
switch (evt.getType()) {
case ExecutorEvent.TASK_SUBMIT:
Runnable runnable = evt.getArg();
// We are limited to a number of concurrent request id's
// equal to 2^63-1. This is quite large and if it
// overflows it will still be positive
long requestId = Math.abs(counter.getAndIncrement());
if (requestId == Long.MIN_VALUE) {
// TODO: need to fix this it isn't safe for concurrent modifications
counter.set(0);
requestId = Math.abs(counter.getAndIncrement());
}
// Need to make sure to put the requestId in our map before
// adding the runnable to awaiting consumer in case if
// coordinator sent a consumer found and their original task
// is no longer around
// see https://issues.jboss.org/browse/JGRP-1744
_requestId.put(runnable, requestId);
_awaitingConsumer.add(runnable);
sendToCoordinator(RUN_REQUEST, requestId, local_addr);
break;
case ExecutorEvent.CONSUMER_READY:
Thread currentThread = Thread.currentThread();
long threadId = currentThread.getId();
_consumerId.put(threadId, PRESENT);
try {
for (; ; ) {
CyclicBarrier barrier = new CyclicBarrier(2);
_taskBarriers.put(threadId, barrier);
// We only send to the coordinator that we are ready after
// making the barrier, wait for request to come and let
// us free
sendToCoordinator(Type.CONSUMER_READY, threadId, local_addr);
try {
barrier.await();
break;
} catch (BrokenBarrierException e) {
if (log.isDebugEnabled())
log.debug(
"Producer timed out before we picked up"
+ " the task, have to tell coordinator"
+ " we are still good.");
}
}
// This should always be non nullable since the latch
// was freed
runnable = _tasks.remove(threadId);
_runnableThreads.put(runnable, currentThread);
return runnable;
} catch (InterruptedException e) {
if (log.isDebugEnabled()) log.debug("Consumer " + threadId + " stopped via interrupt");
sendToCoordinator(Type.CONSUMER_UNREADY, threadId, local_addr);
Thread.currentThread().interrupt();
} finally {
// Make sure the barriers are cleaned up as well
_taskBarriers.remove(threadId);
_consumerId.remove(threadId);
}
break;
case ExecutorEvent.TASK_COMPLETE:
Object arg = evt.getArg();
Throwable throwable = null;
if (arg instanceof Object[]) {
Object[] array = (Object[]) arg;
runnable = (Runnable) array[0];
throwable = (Throwable) array[1];
} else {
runnable = (Runnable) arg;
}
Owner owner = _running.remove(runnable);
// This won't remove anything if owner doesn't come back
_runnableThreads.remove(runnable);
Object value = null;
boolean exception = false;
if (throwable != null) {
// InterruptedException is special telling us that
// we interrupted the thread while waiting but still got
// a task therefore we have to reject it.
if (throwable instanceof InterruptedException) {
if (log.isDebugEnabled())
log.debug("Run rejected due to interrupted exception returned");
sendRequest(owner.address, Type.RUN_REJECTED, owner.requestId, null);
break;
}
value = throwable;
exception = true;
} else if (runnable instanceof RunnableFuture<?>) {
RunnableFuture<?> future = (RunnableFuture<?>) runnable;
boolean interrupted = false;
boolean gotValue = false;
// We have the value, before we interrupt at least get it!
while (!gotValue) {
try {
value = future.get();
gotValue = true;
} catch (InterruptedException e) {
interrupted = true;
} catch (ExecutionException e) {
value = e.getCause();
exception = true;
gotValue = true;
}
}
if (interrupted) {
Thread.currentThread().interrupt();
}
}
if (owner != null) {
final Type type;
final Object valueToSend;
if (value == null) {
type = Type.RESULT_SUCCESS;
valueToSend = value;
}
// Both serializable values and exceptions would go in here
else if (value instanceof Serializable
|| value instanceof Externalizable
|| value instanceof Streamable) {
type = exception ? Type.RESULT_EXCEPTION : Type.RESULT_SUCCESS;
valueToSend = value;
}
// This would happen if the value wasn't serializable,
// so we have to send back to the client that the class
// wasn't serializable
else {
type = Type.RESULT_EXCEPTION;
valueToSend = new NotSerializableException(value.getClass().getName());
}
if (local_addr.equals(owner.getAddress())) {
if (log.isTraceEnabled())
log.trace(
"[redirect] <--> ["
+ local_addr
+ "] "
+ type.name()
+ " ["
+ value
+ (owner.requestId != -1 ? " request id: " + owner.requestId : "")
+ "]");
if (type == Type.RESULT_SUCCESS) {
handleValueResponse(local_addr, owner.requestId, valueToSend);
} else if (type == Type.RESULT_EXCEPTION) {
handleExceptionResponse(local_addr, owner.requestId, (Throwable) valueToSend);
}
} else {
sendRequest(owner.getAddress(), type, owner.requestId, valueToSend);
}
} else {
if (log.isTraceEnabled()) {
log.trace("Could not return result - most likely because it was interrupted");
}
}
break;
case ExecutorEvent.TASK_CANCEL:
Object[] array = evt.getArg();
runnable = (Runnable) array[0];
if (_awaitingConsumer.remove(runnable)) {
_requestId.remove(runnable);
ExecutorNotification notification = notifiers.remove(runnable);
if (notification != null) {
notification.interrupted(runnable);
}
if (log.isTraceEnabled())
log.trace("Cancelled task " + runnable + " before it was picked up");
return Boolean.TRUE;
}
// This is guaranteed to not be null so don't take cost of auto unboxing
else if (array[1] == Boolean.TRUE) {
owner = removeKeyForValue(_awaitingReturn, runnable);
if (owner != null) {
Long requestIdValue = _requestId.remove(runnable);
// We only cancel if the requestId is still available
// this means the result hasn't been returned yet and
// we still have a chance to interrupt
if (requestIdValue != null) {
if (requestIdValue != owner.getRequestId()) {
log.warn("Cancelling requestId didn't match waiting");
}
sendRequest(owner.getAddress(), Type.INTERRUPT_RUN, owner.getRequestId(), null);
}
} else {
if (log.isTraceEnabled()) log.warn("Couldn't interrupt server task: " + runnable);
}
ExecutorNotification notification = notifiers.remove(runnable);
if (notification != null) {
notification.interrupted(runnable);
}
return Boolean.TRUE;
} else {
return Boolean.FALSE;
}
case ExecutorEvent.ALL_TASK_CANCEL:
array = evt.getArg();
// This is a RunnableFuture<?> so this cast is okay
@SuppressWarnings("unchecked")
Set<Runnable> runnables = (Set<Runnable>) array[0];
Boolean booleanValue = (Boolean) array[1];
List<Runnable> notRan = new ArrayList<>();
for (Runnable cancelRunnable : runnables) {
// Removed from the consumer
if (!_awaitingConsumer.remove(cancelRunnable) && booleanValue == Boolean.TRUE) {
synchronized (_awaitingReturn) {
owner = removeKeyForValue(_awaitingReturn, cancelRunnable);
if (owner != null) {
Long requestIdValue = _requestId.remove(cancelRunnable);
if (requestIdValue != owner.getRequestId()) {
log.warn("Cancelling requestId didn't match waiting");
}
sendRequest(owner.getAddress(), Type.INTERRUPT_RUN, owner.getRequestId(), null);
}
ExecutorNotification notification = notifiers.remove(cancelRunnable);
if (notification != null) {
log.trace("Notifying listener");
notification.interrupted(cancelRunnable);
}
}
} else {
_requestId.remove(cancelRunnable);
notRan.add(cancelRunnable);
}
}
return notRan;
case Event.SET_LOCAL_ADDRESS:
local_addr = evt.getArg();
break;
case Event.VIEW_CHANGE:
handleView(evt.getArg());
break;
}
return down_prot.down(evt);
}
public Object up(Event evt) {
switch (evt.getType()) {
case Event.MSG:
Message msg = (Message) evt.getArg();
ExecutorHeader hdr = (ExecutorHeader) msg.getHeader(id);
if (hdr == null) break;
Request req = (Request) msg.getObject();
if (log.isTraceEnabled())
log.trace("[" + local_addr + "] <-- [" + msg.getSrc() + "] " + req);
switch (req.type) {
case RUN_REQUEST:
handleTaskRequest(req.request, (Address) req.object);
break;
case CONSUMER_READY:
handleConsumerReadyRequest(req.request, (Address) req.object);
break;
case CONSUMER_UNREADY:
handleConsumerUnreadyRequest(req.request, (Address) req.object);
break;
case CONSUMER_FOUND:
handleConsumerFoundResponse(req.request, (Address) req.object);
break;
case RUN_SUBMITTED:
RequestWithThread reqWT = (RequestWithThread) req;
Object objectToRun = reqWT.object;
Runnable runnable;
if (objectToRun instanceof Runnable) {
runnable = (Runnable) objectToRun;
} else if (objectToRun instanceof Callable) {
@SuppressWarnings("unchecked")
Callable<Object> callable = (Callable<Object>) objectToRun;
runnable = new FutureTask<>(callable);
} else {
log.error(
"Request of type "
+ req.type
+ " sent an object of "
+ objectToRun
+ " which is invalid");
break;
}
handleTaskSubmittedRequest(runnable, msg.getSrc(), req.request, reqWT.threadId);
break;
case RUN_REJECTED:
// We could make requests local for this, but is it really worth it
handleTaskRejectedResponse(msg.getSrc(), req.request);
break;
case RESULT_SUCCESS:
handleValueResponse(msg.getSrc(), req.request, req.object);
break;
case RESULT_EXCEPTION:
handleExceptionResponse(msg.getSrc(), req.request, (Throwable) req.object);
break;
case INTERRUPT_RUN:
// We could make requests local for this, but is it really worth it
handleInterruptRequest(msg.getSrc(), req.request);
break;
case CREATE_CONSUMER_READY:
Owner owner = new Owner((Address) req.object, req.request);
handleNewConsumer(owner);
break;
case CREATE_RUN_REQUEST:
owner = new Owner((Address) req.object, req.request);
handleNewRunRequest(owner);
break;
case DELETE_CONSUMER_READY:
owner = new Owner((Address) req.object, req.request);
handleRemoveConsumer(owner);
break;
case DELETE_RUN_REQUEST:
owner = new Owner((Address) req.object, req.request);
handleRemoveRunRequest(owner);
break;
default:
log.error("Request of type " + req.type + " not known");
break;
}
return null;
case Event.VIEW_CHANGE:
handleView((View) evt.getArg());
break;
}
return up_prot.up(evt);
}
/**
* Callback method <br>
* Called by the ProtocolStack when a message is received.
*
* @param evt the event carrying the message from the protocol stack
*/
public Object up(Event evt) {
switch (evt.getType()) {
case Event.MSG:
Message msg = (Message) evt.getArg();
if (stats) {
received_msgs++;
received_bytes += msg.getLength();
}
// discard local messages (sent by myself to me)
if (discard_own_messages
&& local_addr != null
&& msg.getSrc() != null
&& local_addr.equals(msg.getSrc())) return null;
break;
case Event.VIEW_CHANGE:
View tmp = (View) evt.getArg();
if (tmp instanceof MergeView) my_view = new View(tmp.getViewId(), tmp.getMembers());
else my_view = tmp;
// Bela&Vladimir Oct 27th,2006 (JGroups 2.4): we need to set connected=true because a client
// can
// call channel.getView() in viewAccepted() callback invoked on this thread (see
// Event.VIEW_CHANGE handling below)
// not good: we are only connected when we returned from connect() - bela June 22 2007
// Changed: when a channel gets a view of which it is a member then it should be
// connected even if connect() hasn't returned yet ! (bela Noc 2010)
if (state != State.CONNECTED) state = State.CONNECTED;
break;
case Event.CONFIG:
Map<String, Object> cfg = (Map<String, Object>) evt.getArg();
if (cfg != null) {
if (cfg.containsKey("state_transfer")) {
state_transfer_supported = (Boolean) cfg.get("state_transfer");
}
if (cfg.containsKey("flush_supported")) {
flush_supported = (Boolean) cfg.get("flush_supported");
}
}
break;
case Event.GET_STATE_OK:
StateTransferResult result = (StateTransferResult) evt.getArg();
if (up_handler != null) {
try {
Object retval = up_handler.up(evt);
state_promise.setResult(new StateTransferResult());
return retval;
} catch (Throwable t) {
state_promise.setResult(new StateTransferResult(t));
}
}
if (receiver != null) {
try {
if (result.hasBuffer()) {
byte[] tmp_state = result.getBuffer();
ByteArrayInputStream input = new ByteArrayInputStream(tmp_state);
receiver.setState(input);
}
state_promise.setResult(result);
} catch (Throwable t) {
state_promise.setResult(new StateTransferResult(t));
}
}
break;
case Event.STATE_TRANSFER_INPUTSTREAM_CLOSED:
state_promise.setResult((StateTransferResult) evt.getArg());
break;
case Event.STATE_TRANSFER_INPUTSTREAM:
// Oct 13,2006 moved to down() when Event.STATE_TRANSFER_INPUTSTREAM_CLOSED is received
// state_promise.setResult(is != null? Boolean.TRUE : Boolean.FALSE);
if (up_handler != null) return up_handler.up(evt);
InputStream is = (InputStream) evt.getArg();
if (is != null && receiver != null) {
try {
receiver.setState(is);
} catch (Throwable t) {
throw new RuntimeException("failed calling setState() in state requester", t);
}
}
break;
case Event.STATE_TRANSFER_OUTPUTSTREAM:
if (receiver != null && evt.getArg() != null) {
try {
receiver.getState((OutputStream) evt.getArg());
} catch (Exception e) {
throw new RuntimeException("failed calling getState() in state provider", e);
}
}
break;
case Event.GET_LOCAL_ADDRESS:
return local_addr;
default:
break;
}
// If UpHandler is installed, pass all events to it and return (UpHandler is e.g. a building
// block)
if (up_handler != null) return up_handler.up(evt);
if (receiver != null) return invokeCallback(evt.getType(), evt.getArg());
return null;
}