/*******************************************************************************
* Copyright (c) 2001, 2005 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jem.internal.proxy.remote;
/*
*/
import java.io.*;
import java.net.Socket;
import java.util.logging.Level;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jem.internal.proxy.common.remote.Commands;
import org.eclipse.jem.internal.proxy.common.remote.TransmitableArray;
import org.eclipse.jem.internal.proxy.core.*;
/**
* This thread handles the actual callback.
* It is package protected because no one else should access it.
*/
class REMCallbackThread extends Thread {
final REMConnection fConnection; // A connection to use
final REMCallbackRegistry fServer;
final REMStandardBeanProxyFactory fFactory;
final REMStandardBeanTypeProxyFactory fTypeFactory;
final REMProxyFactoryRegistry registry;
protected boolean shuttingDown;
protected boolean inTransaction; // Is this thread currently participating in a transaction, (i.e. reading/writing), if so then we can't use it for another transaction.
/**
* Is this callback thread currently participating in a transaction (reading/writing). If so then it can't be used for an
* independent new transaction. In other words you can't write/read data using this callback thread's
* connection because it is being used by someone else expecting to have exclusive read/write on this connection.
*
* @return
*
* @since 1.1.0
*/
public boolean inTransaction() {
return inTransaction;
}
/**
* Set whether this callback thread is in a transaction or not. If it is in a transaction it cannot be used
* for an independent new transaction. In other words you can't write/read data using this callback thread's
* connection because it is being used by someone else expecting to have exclusive read/write on this connection.
* @param inTransaction
*
* @since 1.1.0
*/
public void setIntransaction(boolean inTransaction) {
this.inTransaction = inTransaction;
}
// Kludge: Bug in Linux 1.3.xxx of JVM. Closing a socket while the socket is being read/accept will not interrupt the
// wait. Need to timeout to the socket read/accept before the socket close will be noticed. This has been fixed
// in Linux 1.4. So on Linux 1.3 need to put timeouts in on those sockets that can be separately closed while reading/accepting.
static boolean LINUX_1_3 = "linux".equalsIgnoreCase(System.getProperty("os.name")) && System.getProperty("java.version","").startsWith("1.3"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
public REMCallbackThread(Socket socket, REMCallbackRegistry server, String name, REMProxyFactoryRegistry registry, boolean noTimeouts) {
super(name);
fConnection = new REMConnection(socket, true); // No timeouts since this is a server thread.
this.registry = registry;
fServer = server;
fFactory = (REMStandardBeanProxyFactory) registry.getBeanProxyFactory();
fTypeFactory = (REMStandardBeanTypeProxyFactory) registry.getBeanTypeProxyFactory();
}
/**
* Request the thread to close down.
*/
public void close() {
try {
shuttingDown = true; // So that if this is a forced close then it will know not to print error msgs.
if (fConnection.fSocket != null)
fConnection.fSocket.close();
} catch (Exception e) {
}
}
/*
* Return the IREMConnection associated with this callback. Used by
* the connection server to return this connection for any requests
* made on this thread.
* <package-protected> so that only remote proxy can access.
*/
IREMConnection getConnection() {
return fConnection;
}
public void run() {
DataInputStream in = fConnection.in;
DataOutputStream out = fConnection.out;
InputStream ins = null;
boolean shutdown = false;
Commands.ValueObject valueObject = new Commands.ValueObject(); // Working value object so not continually recreated.
BeanProxyValueSender valueSender = new BeanProxyValueSender(this.fFactory); // Working valuesender so not continually recreated.
try {
boolean doLoop = true;
/**
* Note: In the cases below you will see a lot of finally clauses that null variables out.
* This is because this is a long running loop, and variables declared within blocks are not
* garbage collected until the method is terminated, so these variables once set would never
* be GC'd. The nulling at the end of the case makes sure that any of those objects set are
* now available for garbage collection when necessary.
*/
while(doLoop) {
byte cmd = 0;
try {
if (LINUX_1_3)
fConnection.fSocket.setSoTimeout(1000); // Linux 1.3 bug, see static LINUX_1_3 above
cmd = in.readByte();
if (LINUX_1_3)
fConnection.fSocket.setSoTimeout(0); // Linux 1.3 bug, see static LINUX_1_3 above
} catch (InterruptedIOException e) {
continue; // Timed out, try again
}
switch (cmd) {
case Commands.QUIT_CONNECTION:
doLoop = false;
break; // Close this connection
case Commands.TERMINATE_SERVER:
doLoop = false;
shutdown = true; // Shutdown everything
break;
case Commands.CALLBACK:
int callID = in.readInt(); // The id of the registered callback to call.
int msgID = in.readInt(); // The id of the message to call.
Object parm = null;
Object result = null;
ICallback cb = null;
try {
// The register callback handler will know how to handle the parm,
// it will know if it is an array of proxies, or an object of some kind.
fFactory.startTransaction(); // Start a transaction.
setIntransaction(true); // Also tell ourselves that we are in a transaction.
boolean isProxies = true;
try {
Commands.readValue(in, valueObject);
if (valueObject.type == Commands.ARRAY_IDS) {
// It is an array containing IDs, as it normally would be.
// However it will become IBeanProxy[]. That is because if ID's
// they must be proxies over here.
valueSender.initialize(valueObject);
Commands.readArray(in, valueObject.anInt, valueSender, valueObject, false);
if (valueSender.getException() != null) {
close(); // Something wrong, close the thread so next time we get a new one.
}
parm = valueSender.getArray();
} else {
// It is object or null. It could be an array of objects, or one object.
isProxies = false;
parm = valueObject.getAsObject();
}
} finally {
setIntransaction(false);
fFactory.stopTransaction();
}
// Now perform the callback.
cb = fServer.getRegisteredCallback(callID);
if (cb != null) {
// Callback still registered. If proxies, then if first entry is just a proxy,
// then we are sending only one. A convienence factor for callbacks.
// If not a single entry of IBeanProxy, then send whole array.
try {
if (isProxies)
if (((Object[]) parm).length == 1 && (((Object[]) parm)[0] == null || ((Object[]) parm)[0] instanceof IBeanProxy))
result = cb.calledBack(msgID, (IBeanProxy) ((Object[]) parm)[0]);
else
result = cb.calledBack(msgID, (Object[]) parm);
else
result = cb.calledBack(msgID, parm);
// We only accept null, IREMBeanProxies, and Object[], where
// contents of Object[] are bean proxies.
valueObject.set();
if (result instanceof IREMBeanProxy)
((IREMBeanProxy) result).renderBean(valueObject);
else if (result instanceof Object[]) {
class Retriever implements Commands.ValueRetrieve {
int index = 0;
Object[] array;
Commands.ValueObject worker = new Commands.ValueObject();
public Retriever(Object[] anArray) {
array = anArray;
}
public Commands.ValueObject nextValue() {
Object retParm = array[index++];
if (retParm != null)
if (retParm instanceof IREMBeanProxy)
((IREMBeanProxy) retParm).renderBean(worker);
else if (retParm instanceof TransmitableArray) {
// It is another array, create a new
// retriever.
worker.setArrayIDS(
new Retriever(((TransmitableArray) retParm).array),
((TransmitableArray) retParm).array.length,
((TransmitableArray) retParm).componentTypeID);
} else {
// It's an object. Need to get bean
// type so that we can send it.
IREMBeanProxy type =
(IREMBeanProxy) fTypeFactory.getBeanTypeProxy(retParm.getClass().getName());
if (type == null)
throw new IllegalArgumentException();
int classID = type.getID().intValue();
worker.setAsObject(retParm, classID);
}
else
worker.set();
return worker;
}
};
valueObject.setArrayIDS(
new Retriever((Object[]) result),
((Object[]) result).length,
Commands.OBJECT_CLASS);
}
Commands.sendCallbackDoneCommand(out, valueObject, Commands.NO_ERROR);
} catch (RuntimeException e) {
// Something happened, turn it into an error object
// to send back.
valueObject.set(e.getClass().getName() + ':' + e.getLocalizedMessage());
Commands.sendCallbackDoneCommand(out, valueObject, Commands.CALLBACK_RUNTIME_EXCEPTION);
ProxyPlugin.getPlugin().getLogger().log(e, Level.INFO); // Just log it, but assume safe enough to just go back and wait for next callback request.
}
} else {
valueObject.set();
Commands.sendCallbackDoneCommand(out, valueObject, Commands.CALLBACK_NOT_REGISTERED); // Send error msg back to indicate we weren't registered.
}
} finally {
parm = null; // Clear out for GC to work
result = null;
cb = null;
valueObject.set();
valueSender.clear();
}
break;
case Commands.CALLBACK_STREAM:
// A request for a stream
callID = in.readInt(); // The id of the registered callback to call.
msgID = in.readInt(); // The id of the message to call.
cb = null;
try {
// Now perform the callback.
cb = fServer.getRegisteredCallback(callID);
if (cb != null) {
// Callback still registered
valueObject.set();
Commands.sendCallbackDoneCommand(out, valueObject, Commands.NO_ERROR); // Send null to let it know we've accepted the stream
ins = new REMCallbackInputStream(in, out);
try {
cb.calledBackStream(msgID, ins);
} finally {
try {
ins.close(); // Make sure it's closed.
} catch (IOException e) {
// Exception while closing, just log it and then mark to end the loop so we close connection too.
doLoop = false;
ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "In REMCallbackThread", e)); //$NON-NLS-1$
}
}
} else {
valueObject.set();
Commands.sendCallbackDoneCommand(out, valueObject, Commands.CALLBACK_NOT_REGISTERED); // Send error msg back to indicate we weren't registered.
}
} finally {
cb = null; // Clear out for GC to work
ins = null;
valueObject.set();
}
break;
default:
// Unknown command. We don't know how long the command is, so we need to close the connection.
ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "REMCallback: Invalid cmd sent="+cmd, null)); //$NON-NLS-1$
doLoop = false;
break;
}
}
} catch (EOFException e) {
// This is ok. It means that the connection on the other side was terminated.
// So just accept this and go down.
} catch (Exception e) {
if (!shuttingDown)
ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "In REMCallbackThread", e)); //$NON-NLS-1$
} finally {
if (in != null)
try {
in.close();
} catch (Exception e) {
}
if (out != null)
try {
out.close();
} catch (Exception e) {
}
close();
}
fServer.removeCallbackThread(this);
if (shutdown)
fServer.requestShutdown();
}
}