public void event(Handler handler, Event event) {
try {
eventQueue.put(Pair.<Handler, Message>of(handler, event));
} catch (InterruptedException e) {
throw Util.newError(e, "Exception while executing " + event);
}
}
public void run() {
try {
for (; ; ) {
final Pair<Handler, Message> entry = eventQueue.take();
final Handler handler = entry.left;
final Message message = entry.right;
try {
// A message is either a command or an event.
// A command returns a value that must be read by
// the caller.
if (message instanceof Command<?>) {
Command<?> command = (Command<?>) message;
try {
Locus.push(command.getLocus());
Object result = command.call();
responseQueue.put(command, Pair.of(result, (Throwable) null));
} catch (PleaseShutdownException e) {
responseQueue.put(command, Pair.of(null, (Throwable) null));
return; // exit event loop
} catch (Throwable e) {
responseQueue.put(command, Pair.of(null, e));
} finally {
Locus.pop(command.getLocus());
}
} else {
Event event = (Event) message;
event.acceptWithoutResponse(handler);
// Broadcast the event to anyone who is interested.
RolapUtil.MONITOR_LOGGER.debug(message);
}
} catch (Throwable e) {
// REVIEW: Somewhere better to send it?
e.printStackTrace();
}
}
} catch (InterruptedException e) {
// REVIEW: Somewhere better to send it?
e.printStackTrace();
} catch (Throwable e) {
e.printStackTrace();
}
}
Object execute(Handler handler, Command command) {
try {
eventQueue.put(Pair.<Handler, Message>of(handler, command));
} catch (InterruptedException e) {
throw Util.newError(e, "Interrupted while sending " + command);
}
try {
return responseMap.get(command);
} catch (InterruptedException e) {
throw Util.newError(e, "Interrupted while awaiting " + command);
}
}
public void sendEvent(Event event) {
// The implementation does not need to take any locks.
try {
if (Thread.interrupted()) {
// Interrupt should not happen. Mondrian uses cancel without
// setting interrupt. But if interrupts are happening, it's
// best to know now, rather than failing next time we make a
// blocking system call.
throw new AssertionError();
}
ACTOR.eventQueue.put(Pair.<Handler, Message>of(handler, event));
} catch (InterruptedException e) {
throw Util.newError(e, "Exception while sending event " + event);
}
}
<T> T execute(Handler handler, Command<T> command) {
try {
eventQueue.put(Pair.<Handler, Message>of(handler, command));
} catch (InterruptedException e) {
throw Util.newError(e, "Exception while executing " + command);
}
try {
final Pair<Object, Throwable> pair = responseQueue.take(command);
if (pair.right != null) {
if (pair.right instanceof RuntimeException) {
throw (RuntimeException) pair.right;
} else if (pair.right instanceof Error) {
throw (Error) pair.right;
} else {
throw new RuntimeException(pair.right);
}
} else {
return (T) pair.left;
}
} catch (InterruptedException e) {
throw Util.newError(e, "Exception while executing " + command);
}
}
/**
* Places a (request, response) pair onto the queue.
*
* @param k Request
* @param v Response
* @throws InterruptedException if interrupted while waiting
*/
public void put(K k, V v) throws InterruptedException {
queue.put(Pair.of(k, v));
}
