[nikiroo-utils.git] / src / be / nikiroo / utils / serial / server / ServerBridge.java

package be.nikiroo.utils.serial.server;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Array;
import java.net.Socket;
import java.net.UnknownHostException;

import be.nikiroo.utils.StringUtils;
import be.nikiroo.utils.TraceHandler;
import be.nikiroo.utils.Version;
import be.nikiroo.utils.serial.Importer;

/**
 * This class implements a simple server that can bridge two other
 * {@link Server}s.
 * <p>
 * It can, of course, inspect the data that goes through it (by default, it
 * prints traces of the data).
 * <p>
 * Note: this {@link ServerBridge} has to be discarded after use (cannot be
 * started twice).
 * 
 * @author niki
 */
public class ServerBridge extends Server {
	private final String forwardToHost;
	private final int forwardToPort;
	private final String forwardToKey;

	/**
	 * Create a new server that will start listening on the network when
	 * {@link ServerBridge#start()} is called.
	 * 
	 * @param port
	 *            the port to listen on, or 0 to assign any unallocated port
	 *            found (which can later on be queried via
	 *            {@link ServerBridge#getPort()}
	 * @param key
	 *            an optional key to encrypt all the communications (if NULL,
	 *            everything will be sent in clear text)
	 * @param forwardToHost
	 *            the host server to forward the calls to
	 * @param forwardToPort
	 *            the host port to forward the calls to
	 * @param forwardToKey
	 *            an optional key to encrypt all the communications (if NULL,
	 *            everything will be sent in clear text)
	 * 
	 * @throws IOException
	 *             in case of I/O error
	 * @throws UnknownHostException
	 *             if the IP address of the host could not be determined
	 * @throws IllegalArgumentException
	 *             if the port parameter is outside the specified range of valid
	 *             port values, which is between 0 and 65535, inclusive
	 */
	public ServerBridge(int port, String key, String forwardToHost,
			int forwardToPort, String forwardToKey) throws IOException {
		super(port, key);
		this.forwardToHost = forwardToHost;
		this.forwardToPort = forwardToPort;
		this.forwardToKey = forwardToKey;
	}

	/**
	 * Create a new server that will start listening on the network when
	 * {@link ServerBridge#start()} is called.
	 * 
	 * @param name
	 *            the server name (only used for debug info and traces)
	 * @param port
	 *            the port to listen on
	 * @param key
	 *            an optional key to encrypt all the communications (if NULL,
	 *            everything will be sent in clear text)
	 * @param forwardToHost
	 *            the host server to forward the calls to
	 * @param forwardToPort
	 *            the host port to forward the calls to
	 * @param forwardToKey
	 *            an optional key to encrypt all the communications (if NULL,
	 *            everything will be sent in clear text) use an SSL connection
	 *            for the forward server or not
	 * 
	 * @throws IOException
	 *             in case of I/O error
	 * @throws UnknownHostException
	 *             if the IP address of the host could not be determined
	 * @throws IllegalArgumentException
	 *             if the port parameter is outside the specified range of valid
	 *             port values, which is between 0 and 65535, inclusive
	 */
	public ServerBridge(String name, int port, String key,
			String forwardToHost, int forwardToPort, String forwardToKey)
			throws IOException {
		super(name, port, key);
		this.forwardToHost = forwardToHost;
		this.forwardToPort = forwardToPort;
		this.forwardToKey = forwardToKey;
	}

	/**
	 * The traces handler for this {@link Server}.
	 * <p>
	 * The trace levels are handled as follow:
	 * <ul>
	 * <li>1: it will only print basic IN/OUT messages with length</li>
	 * <li>2: it will try to interpret it as an object (SLOW) and print the
	 * object class if possible</li>
	 * <li>3: it will try to print the {@link Object#toString()} value, or the
	 * data if it is not an object</li>
	 * <li>4: it will also print the unzipped serialised value if it is an
	 * object</li>
	 * </ul>
	 * 
	 * @param tracer
	 *            the new traces handler
	 */
	@Override
	public void setTraceHandler(TraceHandler tracer) {
		super.setTraceHandler(tracer);
	}

	@Override
	protected ConnectActionServer createConnectActionServer(Socket s) {
		// Bad impl, not up to date (should work, but not efficient)
		return new ConnectActionServerString(s, key) {
			@Override
			public void action(Version clientVersion) throws Exception {
				onClientContact(clientVersion);
				final ConnectActionServerString bridge = this;

				try {
					new ConnectActionClientString(forwardToHost, forwardToPort,
							forwardToKey) {
						@Override
						public void action(Version serverVersion)
								throws Exception {
							onServerContact(serverVersion);

							for (String fromClient = bridge.rec(); fromClient != null; fromClient = bridge
									.rec()) {
								onRec(fromClient);
								String fromServer = send(fromClient);
								onSend(fromServer);
								bridge.send(fromServer);
							}

							getTraceHandler().trace("=== DONE", 1);
							getTraceHandler().trace("", 1);
						}

						@Override
						protected void onError(Exception e) {
							ServerBridge.this.onError(e);
						}
					}.connect();
				} catch (Exception e) {
					ServerBridge.this.onError(e);
				}
			}
		};
	}

	/**
	 * This is the method that is called each time a client contact us.
	 */
	protected void onClientContact(Version clientVersion) {
		getTraceHandler().trace(">>> CLIENT " + clientVersion);
	}

	/**
	 * This is the method that is called each time a client contact us.
	 */
	protected void onServerContact(Version serverVersion) {
		getTraceHandler().trace("<<< SERVER " + serverVersion);
		getTraceHandler().trace("");
	}

	/**
	 * This is the method that is called each time a client contact us.
	 * 
	 * @param data
	 *            the data sent by the client
	 */
	protected void onRec(String data) {
		trace(">>> CLIENT", data);
	}

	/**
	 * This is the method that is called each time the forwarded server contact
	 * us.
	 * 
	 * @param data
	 *            the data sent by the client
	 */
	protected void onSend(String data) {
		trace("<<< SERVER", data);
	}

	@Override
	protected ConnectActionClient getConnectionToMe()
			throws UnknownHostException, IOException {
		return new ConnectActionClientString(new Socket((String) null,
				getPort()), key);
	}

	@Override
	public void run() {
		getTraceHandler().trace(
				getName() + ": will forward to " + forwardToHost + ":"
						+ forwardToPort + " ("
						+ (forwardToKey != null ? "encrypted" : "plain text")
						+ ")");
		super.run();
	}

	/**
	 * Trace the data with the given prefix.
	 * 
	 * @param prefix
	 *            the prefix (client, server, version...)
	 * @param data
	 *            the data to trace
	 */
	private void trace(String prefix, String data) {
		int size = data == null ? 0 : data.length();
		String ssize = StringUtils.formatNumber(size) + "bytes";

		getTraceHandler().trace(prefix + ": " + ssize, 1);

		if (getTraceHandler().getTraceLevel() >= 2) {
			try {
				while (data.startsWith("ZIP:") || data.startsWith("B64:")) {
					if (data.startsWith("ZIP:")) {
						data = StringUtils.unzip64s(data.substring(4));
					} else if (data.startsWith("B64:")) {
						data = StringUtils.unzip64s(data.substring(4));
					}
				}

				InputStream stream = new ByteArrayInputStream(
						StringUtils.getBytes(data));
				try {
					Object obj = new Importer().read(stream).getValue();
					if (obj == null) {
						getTraceHandler().trace("NULL", 2);
						getTraceHandler().trace("NULL", 3);
						getTraceHandler().trace("NULL", 4);
					} else {
						if (obj.getClass().isArray()) {
							getTraceHandler().trace(
									"(" + obj.getClass() + ") with "
											+ Array.getLength(obj)
											+ "element(s)", 3);
						} else {
							getTraceHandler().trace("(" + obj.getClass() + ")",
									2);
						}
						getTraceHandler().trace("" + obj.toString(), 3);
						getTraceHandler().trace(data, 4);
					}
				} finally {
					stream.close();
				}
			} catch (NoSuchMethodException e) {
				getTraceHandler().trace("(not an object)", 2);
				getTraceHandler().trace(data, 3);
				getTraceHandler().trace("", 4);
			} catch (NoSuchFieldException e) {
				getTraceHandler().trace(
						"(incompatible: " + e.getMessage() + ")", 2);
				getTraceHandler().trace(data, 3);
				getTraceHandler().trace("", 4);
			} catch (ClassNotFoundException e) {
				getTraceHandler().trace(
						"(unknown object: " + e.getMessage() + ")", 2);
				getTraceHandler().trace(data, 3);
				getTraceHandler().trace("", 4);
			} catch (Exception e) {
				getTraceHandler().trace(
						"(decode error: " + e.getMessage() + ")", 2);
				getTraceHandler().trace(data, 3);
				getTraceHandler().trace("", 4);
			}

			getTraceHandler().trace("", 2);
		}
	}
}
Commit	Line	Data
	1	package be.nikiroo.utils.serial.server;
	2
	3	import java.io.ByteArrayInputStream;
	4	import java.io.IOException;
	5	import java.io.InputStream;
	6	import java.lang.reflect.Array;
	7	import java.net.Socket;
	8	import java.net.UnknownHostException;
	9
	10	import be.nikiroo.utils.StringUtils;
	11	import be.nikiroo.utils.TraceHandler;
	12	import be.nikiroo.utils.Version;
	13	import be.nikiroo.utils.serial.Importer;
	14
	15	/**
	16	* This class implements a simple server that can bridge two other
	17	* {@link Server}s.
	18	* <p>
	19	* It can, of course, inspect the data that goes through it (by default, it
	20	* prints traces of the data).
	21	* <p>
	22	* Note: this {@link ServerBridge} has to be discarded after use (cannot be
	23	* started twice).
	24	*
	25	* @author niki
	26	*/
	27	public class ServerBridge extends Server {
	28	private final String forwardToHost;
	29	private final int forwardToPort;
	30	private final String forwardToKey;
	31
	32	/**
	33	* Create a new server that will start listening on the network when
	34	* {@link ServerBridge#start()} is called.
	35	*
	36	* @param port
	37	* the port to listen on, or 0 to assign any unallocated port
	38	* found (which can later on be queried via
	39	* {@link ServerBridge#getPort()}
	40	* @param key
	41	* an optional key to encrypt all the communications (if NULL,
	42	* everything will be sent in clear text)
	43	* @param forwardToHost
	44	* the host server to forward the calls to
	45	* @param forwardToPort
	46	* the host port to forward the calls to
	47	* @param forwardToKey
	48	* an optional key to encrypt all the communications (if NULL,
	49	* everything will be sent in clear text)
	50	*
	51	* @throws IOException
	52	* in case of I/O error
	53	* @throws UnknownHostException
	54	* if the IP address of the host could not be determined
	55	* @throws IllegalArgumentException
	56	* if the port parameter is outside the specified range of valid
	57	* port values, which is between 0 and 65535, inclusive
	58	*/
	59	public ServerBridge(int port, String key, String forwardToHost,
	60	int forwardToPort, String forwardToKey) throws IOException {
	61	super(port, key);
	62	this.forwardToHost = forwardToHost;
	63	this.forwardToPort = forwardToPort;
	64	this.forwardToKey = forwardToKey;
	65	}
	66
	67	/**
	68	* Create a new server that will start listening on the network when
	69	* {@link ServerBridge#start()} is called.
	70	*
	71	* @param name
	72	* the server name (only used for debug info and traces)
	73	* @param port
	74	* the port to listen on
	75	* @param key
	76	* an optional key to encrypt all the communications (if NULL,
	77	* everything will be sent in clear text)
	78	* @param forwardToHost
	79	* the host server to forward the calls to
	80	* @param forwardToPort
	81	* the host port to forward the calls to
	82	* @param forwardToKey
	83	* an optional key to encrypt all the communications (if NULL,
	84	* everything will be sent in clear text) use an SSL connection
	85	* for the forward server or not
	86	*
	87	* @throws IOException
	88	* in case of I/O error
	89	* @throws UnknownHostException
	90	* if the IP address of the host could not be determined
	91	* @throws IllegalArgumentException
	92	* if the port parameter is outside the specified range of valid
	93	* port values, which is between 0 and 65535, inclusive
	94	*/
	95	public ServerBridge(String name, int port, String key,
	96	String forwardToHost, int forwardToPort, String forwardToKey)
	97	throws IOException {
	98	super(name, port, key);
	99	this.forwardToHost = forwardToHost;
	100	this.forwardToPort = forwardToPort;
	101	this.forwardToKey = forwardToKey;
	102	}
	103
	104	/**
	105	* The traces handler for this {@link Server}.
	106	* <p>
	107	* The trace levels are handled as follow:
	108	* <ul>
	109	* <li>1: it will only print basic IN/OUT messages with length</li>
	110	* <li>2: it will try to interpret it as an object (SLOW) and print the
	111	* object class if possible</li>
	112	* <li>3: it will try to print the {@link Object#toString()} value, or the
	113	* data if it is not an object</li>
	114	* <li>4: it will also print the unzipped serialised value if it is an
	115	* object</li>
	116	* </ul>
	117	*
	118	* @param tracer
	119	* the new traces handler
	120	*/
	121	@Override
	122	public void setTraceHandler(TraceHandler tracer) {
	123	super.setTraceHandler(tracer);
	124	}
	125
	126	@Override
	127	protected ConnectActionServer createConnectActionServer(Socket s) {
	128	// Bad impl, not up to date (should work, but not efficient)
	129	return new ConnectActionServerString(s, key) {
	130	@Override
	131	public void action(Version clientVersion) throws Exception {
	132	onClientContact(clientVersion);
	133	final ConnectActionServerString bridge = this;
	134
	135	try {
	136	new ConnectActionClientString(forwardToHost, forwardToPort,
	137	forwardToKey) {
	138	@Override
	139	public void action(Version serverVersion)
	140	throws Exception {
	141	onServerContact(serverVersion);
	142
	143	for (String fromClient = bridge.rec(); fromClient != null; fromClient = bridge
	144	.rec()) {
	145	onRec(fromClient);
	146	String fromServer = send(fromClient);
	147	onSend(fromServer);
	148	bridge.send(fromServer);
	149	}
	150
	151	getTraceHandler().trace("=== DONE", 1);
	152	getTraceHandler().trace("", 1);
	153	}
	154
	155	@Override
	156	protected void onError(Exception e) {
	157	ServerBridge.this.onError(e);
	158	}
	159	}.connect();
	160	} catch (Exception e) {
	161	ServerBridge.this.onError(e);
	162	}
	163	}
	164	};
	165	}
	166
	167	/**
	168	* This is the method that is called each time a client contact us.
	169	*/
	170	protected void onClientContact(Version clientVersion) {
	171	getTraceHandler().trace(">>> CLIENT " + clientVersion);
	172	}
	173
	174	/**
	175	* This is the method that is called each time a client contact us.
	176	*/
	177	protected void onServerContact(Version serverVersion) {
	178	getTraceHandler().trace("<<< SERVER " + serverVersion);
	179	getTraceHandler().trace("");
	180	}
	181
	182	/**
	183	* This is the method that is called each time a client contact us.
	184	*
	185	* @param data
	186	* the data sent by the client
	187	*/
	188	protected void onRec(String data) {
	189	trace(">>> CLIENT", data);
	190	}
	191
	192	/**
	193	* This is the method that is called each time the forwarded server contact
	194	* us.
	195	*
	196	* @param data
	197	* the data sent by the client
	198	*/
	199	protected void onSend(String data) {
	200	trace("<<< SERVER", data);
	201	}
	202
	203	@Override
	204	protected ConnectActionClient getConnectionToMe()
	205	throws UnknownHostException, IOException {
	206	return new ConnectActionClientString(new Socket((String) null,
	207	getPort()), key);
	208	}
	209
	210	@Override
	211	public void run() {
	212	getTraceHandler().trace(
	213	getName() + ": will forward to " + forwardToHost + ":"
	214	+ forwardToPort + " ("
	215	+ (forwardToKey != null ? "encrypted" : "plain text")
	216	+ ")");
	217	super.run();
	218	}
	219
	220	/**
	221	* Trace the data with the given prefix.
	222	*
	223	* @param prefix
	224	* the prefix (client, server, version...)
	225	* @param data
	226	* the data to trace
	227	*/
	228	private void trace(String prefix, String data) {
	229	int size = data == null ? 0 : data.length();
	230	String ssize = StringUtils.formatNumber(size) + "bytes";
	231
	232	getTraceHandler().trace(prefix + ": " + ssize, 1);
	233
	234	if (getTraceHandler().getTraceLevel() >= 2) {
	235	try {
	236	while (data.startsWith("ZIP:") \|\| data.startsWith("B64:")) {
	237	if (data.startsWith("ZIP:")) {
	238	data = StringUtils.unzip64s(data.substring(4));
	239	} else if (data.startsWith("B64:")) {
	240	data = StringUtils.unzip64s(data.substring(4));
	241	}
	242	}
	243
	244	InputStream stream = new ByteArrayInputStream(
	245	StringUtils.getBytes(data));
	246	try {
	247	Object obj = new Importer().read(stream).getValue();
	248	if (obj == null) {
	249	getTraceHandler().trace("NULL", 2);
	250	getTraceHandler().trace("NULL", 3);
	251	getTraceHandler().trace("NULL", 4);
	252	} else {
	253	if (obj.getClass().isArray()) {
	254	getTraceHandler().trace(
	255	"(" + obj.getClass() + ") with "
	256	+ Array.getLength(obj)
	257	+ "element(s)", 3);
	258	} else {
	259	getTraceHandler().trace("(" + obj.getClass() + ")",
	260	2);
	261	}
	262	getTraceHandler().trace("" + obj.toString(), 3);
	263	getTraceHandler().trace(data, 4);
	264	}
	265	} finally {
	266	stream.close();
	267	}
	268	} catch (NoSuchMethodException e) {
	269	getTraceHandler().trace("(not an object)", 2);
	270	getTraceHandler().trace(data, 3);
	271	getTraceHandler().trace("", 4);
	272	} catch (NoSuchFieldException e) {
	273	getTraceHandler().trace(
	274	"(incompatible: " + e.getMessage() + ")", 2);
	275	getTraceHandler().trace(data, 3);
	276	getTraceHandler().trace("", 4);
	277	} catch (ClassNotFoundException e) {
	278	getTraceHandler().trace(
	279	"(unknown object: " + e.getMessage() + ")", 2);
	280	getTraceHandler().trace(data, 3);
	281	getTraceHandler().trace("", 4);
	282	} catch (Exception e) {
	283	getTraceHandler().trace(
	284	"(decode error: " + e.getMessage() + ")", 2);
	285	getTraceHandler().trace(data, 3);
	286	getTraceHandler().trace("", 4);
	287	}
	288
	289	getTraceHandler().trace("", 2);
	290	}
	291	}
	292	}