providers/bundles/org.eclipse.ecf.provider.datashare.nio/src/org/eclipse/ecf/provider/datashare/nio/NIOChannel.java

/******************************************************************************
 * Copyright (c) 2009 Remy Chi Jian Suen 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:
 *     Remy Chi Jian Suen - initial API and implementation
 ******************************************************************************/
package org.eclipse.ecf.provider.datashare.nio;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.core.runtime.Status;
import org.eclipse.ecf.core.identity.ID;
import org.eclipse.ecf.core.util.ECFException;
import org.eclipse.ecf.datashare.IChannel;
import org.eclipse.ecf.datashare.IChannelListener;
import org.eclipse.ecf.datashare.events.IChannelConnectEvent;
import org.eclipse.ecf.datashare.events.IChannelDisconnectEvent;
import org.eclipse.ecf.datashare.events.IChannelEvent;
import org.eclipse.ecf.datashare.events.IChannelMessageEvent;

/**
 * An abstract implementation of <code>IChannel</code> that uses Java 1.4 NIO
 * APIs for sending and retrieving data.
 * <p>
 * This channel will inherently spawn multiple socket connections as messages
 * are sent to different remote clients via {@link #sendMessage(ID, byte[])}.
 * Please note that the current implementation does not handle repeated
 * invocations to that method well. Please refer to its javadoc for further
 * information.
 * </p>
 * <p>
 * Subclasses must implement the following:
 * <ul>
 * <li>For communicating local information for establishing a socket connection:
 * <ul>
 * <li>{@link #sendRequest(ID)}</li>
 * </ul>
 * </li>
 * <li>To facilitate the logging of statuses:
 * <ul>
 * <li>{@link #log(IStatus)}</li>
 * </ul>
 * </li>
 * </ul>
 * </p>
 * <p>
 * <b>Note:</b> This class/interface is part of an interim API that is still
 * under development and expected to change significantly before reaching
 * stability. It is being made available at this early stage to solicit feedback
 * from pioneering adopters on the understanding that any code that uses this
 * API will almost certainly be broken (repeatedly) as the API evolves.
 * </p>
 */
public abstract class NIOChannel implements IChannel {

	private NIODatashareContainer datashareContainer;

	/**
	 * The id of the originating owner container of the datashare container that
	 * created this channel.
	 */
	private final ID containerId;

	/**
	 * The ID of this channel.
	 */
	private final ID id;

	/**
	 * The server socket for listening to incoming connections. This channel is
	 * non-blocking.
	 */
	private ServerSocketChannel serverSocketChannel;

	/**
	 * The port that the server socket is listening on for incoming connections.
	 * 
	 * @see #serverSocketChannel
	 * @see #getLocalPort()
	 */
	private final int localPort;

	/**
	 * A map of <code>ID</code>s to their corresponding
	 * <code>SocketChannel</code>s.
	 */
	private Map connectedSockets;

	/**
	 * A list of sockets that is waiting to handshake with remote peers.
	 */
	private List pendingSockets;

	/**
	 * A queue of messages that needs to be sent to remote clients.
	 */
	private LinkedList messages;

	/**
	 * This channel's listener. May be <code>null</code>.
	 */
	private IChannelListener listener;

	/**
	 * The thread responsible for processing incoming messages and sending
	 * messages to remote peers.
	 */
	private Thread processingThread;

	/**
	 * Instantiates a new channel for sending and receiving messages in a
	 * non-blocking manner via sockets.
	 * 
	 * @param datashareContainer
	 *            the source NIODatashareContainer that created this channel,
	 *            cannot be <code>null</code>
	 * @param containerId
	 *            the id of the originating owner container, this should
	 *            <b>not</b> be the id of the datashare container that created
	 *            this channel but the parent container of the datashare
	 *            container, may not be <code>null</code>
	 * @param id
	 *            the id of this channel, may not be <code>null</code>
	 * @param listener
	 *            the channel listener for this channel, may be
	 *            <code>null</code> if no notification is required
	 * @throws ECFException
	 *             if an error occurred while creating this channel
	 */
	public NIOChannel(NIODatashareContainer datashareContainer, ID containerId,
			ID id, IChannelListener listener) throws ECFException {
		Assert.isNotNull(datashareContainer,
				"Datashare container cannot be null"); //$NON-NLS-1$
		Assert.isNotNull(containerId, "Container id cannot be null"); //$NON-NLS-1$
		Assert.isNotNull(id, "Channel id cannot be null"); //$NON-NLS-1$

		this.datashareContainer = datashareContainer;
		this.containerId = containerId;
		this.id = id;
		this.listener = listener;

		try {
			// open a server socket
			serverSocketChannel = ServerSocketChannel.open();
			serverSocketChannel.configureBlocking(false);
		} catch (IOException e) {
			throw new ECFException(new Status(IStatus.ERROR, Util.PLUGIN_ID,
					"Could not create server socket", e)); //$NON-NLS-1$
		}

		try {
			// bind to a local port
			ServerSocket socket = serverSocketChannel.socket();
			socket.bind(getBindAddress(), getBackLog());
		} catch (IOException e) {
			throw new ECFException(new Status(IStatus.ERROR, Util.PLUGIN_ID,
					"Could not bind server socket", e)); //$NON-NLS-1$
		}

		localPort = serverSocketChannel.socket().getLocalPort();

		connectedSockets = new HashMap();
		pendingSockets = new ArrayList();
		messages = new LinkedList();

		processingThread = new Thread(new ProcessingRunnable(), getClass()
				.getName()
				+ "Thread-" + id.toString()); //$NON-NLS-1$
		processingThread.start();
	}

	/**
	 * Fires a channel connected event to this channel's listener if there is
	 * one attached.
	 * 
	 * @param containerId
	 *            the target ID of the container has connected to
	 */
	void fireChannelConnectEvent(final ID containerId) {
		IChannelListener listener = getListener();
		if (listener != null) {
			fireChannelEvent(listener, new IChannelConnectEvent() {
				public ID getChannelID() {
					return id;
				}

				public ID getTargetID() {
					return containerId;
				}

				public String toString() {
					StringBuffer buffer = new StringBuffer();
					buffer.append("IChannelConnectEvent["); //$NON-NLS-1$
					buffer.append("channel=").append(id); //$NON-NLS-1$
					buffer.append(",target=").append(containerId).append(']'); //$NON-NLS-1$
					return buffer.toString();
				}
			});
		}
	}

	/**
	 * Fires a channel disconnected event to this channel's listener if there is
	 * one attached.
	 * 
	 * @param containerId
	 *            the target ID of the container has disconnected from
	 */
	void fireChannelDisconnectEvent(final ID containerId) {
		IChannelListener listener = getListener();
		if (listener != null) {
			fireChannelEvent(listener, new IChannelDisconnectEvent() {
				public ID getChannelID() {
					return id;
				}

				public ID getTargetID() {
					return containerId;
				}

				public String toString() {
					StringBuffer buffer = new StringBuffer();
					buffer.append("IChannelDisconnectEvent["); //$NON-NLS-1$
					buffer.append("channel=").append(id); //$NON-NLS-1$
					buffer.append(",target=").append(containerId).append(']'); //$NON-NLS-1$
					return buffer.toString();
				}
			});
		}
	}

	protected abstract void log(IStatus status);

	/**
	 * Returns the address that this channel's server socket should bind to. If
	 * <code>null</code>, a default port and valid local address will be used.
	 * 
	 * @return this channel's server socket's bind address, may be
	 *         <code>null</code> if a default should be used
	 */
	protected SocketAddress getBindAddress() {
		return null;
	}

	/**
	 * Retrieves the listen backlog length of this channel's server socket. If
	 * the value is less than or equal to zero, the default length is used.
	 * 
	 * @return this channel's server socket's listen backlog length
	 */
	protected int getBackLog() {
		return 0;
	}

	/**
	 * Sends any pending messages we may have queued up.
	 */
	private void sendPendingMessages() {
		Collection deadSockets = null;
		Collection processedMessages = null;

		for (Iterator it = messages.iterator(); it.hasNext();) {
			ChannelMessage message = (ChannelMessage) it.next();
			ID id = message.getId();
			SocketChannel channel = (SocketChannel) connectedSockets.get(id);
			// check if we have a socket for the target of this message
			if (channel != null) {
				byte[] data = message.getData();

				try {
					// flush the data directly with regular IO, this method
					// saves us the extra work of having to constantly flip and
					// clear a ByteBuffer and in a way ensures the message is
					// sent in one piece instead of chunks
					channel.configureBlocking(true);
					channel.socket().getOutputStream().write(data);
					channel.socket().getOutputStream().flush();
					// turn off blocking
					channel.configureBlocking(false);
				} catch (IOException e) {
					log(new Status(IStatus.ERROR, Util.PLUGIN_ID,
							"Error occurred while sending message", e)); //$NON-NLS-1$
					if (deadSockets == null) {
						deadSockets = new HashSet();
					}
					deadSockets.add(id);
				}

				if (processedMessages == null) {
					processedMessages = new LinkedList();
				}
				// store the processed message
				processedMessages.add(message);
			}
		}

		// remove all messages that have been processed
		if (processedMessages != null) {
			messages.removeAll(processedMessages);
		}

		if (deadSockets != null) {
			for (Iterator it = deadSockets.iterator(); it.hasNext();) {
				ID id = (ID) it.next();
				SocketChannel channel = (SocketChannel) connectedSockets
						.remove(id);
				Util.closeChannel(channel);
			}
		}
	}

	/**
	 * Reads in any incoming messages from remote clients.
	 * 
	 * @param buffer
	 *            the buffer to use for reading the socket
	 * @throws IOException
	 *             if an error occurs while reading from the socket
	 */
	private void processIncomingMessages(ByteBuffer buffer) throws IOException {
		Collection deadSockets = null;

		for (Iterator it = connectedSockets.entrySet().iterator(); it.hasNext();) {
			Map.Entry entry = (Map.Entry) it.next();
			SocketChannel socketChannel = (SocketChannel) entry.getValue();

			try {
				if (!processIncomingMessages(socketChannel, buffer)) {
					if (deadSockets == null) {
						deadSockets = new HashSet();
					}
					deadSockets.add(entry.getKey());
				}
			} catch (IOException e) {
				log(new Status(IStatus.ERROR, Util.PLUGIN_ID,
						"Error occurred while sending message", e)); //$NON-NLS-1$
				if (deadSockets == null) {
					deadSockets = new HashSet();
				}
				deadSockets.add(entry.getKey());
			}
		}

		if (deadSockets != null) {
			for (Iterator it = deadSockets.iterator(); it.hasNext();) {
				ID id = (ID) it.next();
				SocketChannel channel = (SocketChannel) connectedSockets
						.remove(id);
				Util.closeChannel(channel);
			}
		}
	}

	/**
	 * Processes any incoming messages from the specified channel by reading it
	 * into the specified buffer and returns whether the channel has reached
	 * end-of-stream.
	 * 
	 * @param socketChannel
	 *            the channel to read messages from
	 * @param buffer
	 *            the buffer to use to read the messages into
	 * @return <code>true</code> if the channel is still active,
	 *         <code>false</code> has reached end-of-stream
	 * @throws IOException
	 *             if an error occurred while trying to read from the channel
	 */
	private boolean processIncomingMessages(SocketChannel socketChannel,
			ByteBuffer buffer) throws IOException {
		ChannelData channelData = Util.read(socketChannel, buffer);
		byte[] message = channelData.getData();

		if (message != null) {
			processIncomingMessage(socketChannel, message);
		}
		return channelData.isOpen();
	}

	/**
	 * Processes the message that has been received from the specified channel.
	 * 
	 * @param socketChannel
	 *            the channel that the message was from
	 * @param message
	 *            the message that was received
	 */
	void processIncomingMessage(SocketChannel socketChannel, byte[] message) {
		// we read something, need to notify
		IChannelListener listener = getListener();
		if (listener != null) {
			// we have a listener, convert our data and then notify
			byte[][] messages = convert(message);
			if (messages != null) {
				fireMessageEvents(listener, socketChannel, messages);
			}
		}
	}

	/**
	 * Converts the data that has been read from the socket into separate byte[]
	 * instances.
	 * 
	 * @param message
	 *            the data read from the socket
	 * @return a byte[][] containing the individual messages
	 */
	private byte[][] convert(byte[] message) {
		try {
			// back the read in data with a ByteArrayInputStream
			ByteArrayInputStream bais = new ByteArrayInputStream(message);
			// instantiate an ObjectInputStream and read the individual
			// byte[]
			byte[] bytes = (byte[]) new ObjectInputStream(bais).readObject();

			if (bais.available() == 0) {
				return new byte[][] { bytes };
			}

			Collection c = new ArrayList();
			c.add(bytes);

			while (bais.available() != 0) {
				// instantiate an ObjectInputStream and read the individual
				// byte[]
				bytes = (byte[]) new ObjectInputStream(bais).readObject();
				// store it
				c.add(bytes);
			}

			// return all the individual byte[]s
			return (byte[][]) c.toArray(new byte[c.size()][]);
		} catch (IOException e) {
			return null;
		} catch (ClassNotFoundException e) {
			return null;
		}
	}

	/**
	 * Fires message events to the specified listener for each of the message
	 * that was received.
	 * 
	 * @param listener
	 *            the listener to notify
	 * @param socketChannel
	 *            the socket that the message was read from
	 * @param messages
	 *            the messages that have been received
	 */
	private void fireMessageEvents(IChannelListener listener,
			SocketChannel socketChannel, byte[][] messages) {
		for (int i = 0; i < messages.length; i++) {
			IChannelEvent event = createMessageEvent(socketChannel, messages[i]);
			if (event != null) {
				fireChannelEvent(listener, event);
			}
		}
	}

	/**
	 * Notifies the specified listener of the given channel event. The code is
	 * run within a SafeRunner to ensure that the program flow is not affected
	 * in the event of errors during notification.
	 * 
	 * @param listener
	 *            the listener to notify
	 * @param event
	 *            the event to fire
	 */
	private void fireChannelEvent(final IChannelListener listener,
			final IChannelEvent event) {
		// use a SafeRunner to send out the notification to ensure that
		// client-side failures do not cause the channel to die
		SafeRunner.run(new ISafeRunnable() {
			public void run() throws Exception {
				listener.handleChannelEvent(event);
			}

			public void handleException(Throwable t) {
				log(new Status(IStatus.ERROR, Util.PLUGIN_ID,
						"Error handling channel event", t)); //$NON-NLS-1$
			}
		});
	}

	/**
	 * Creates and returns a message event corresponding to the specified
	 * channel and the data that was read.
	 * 
	 * @param channel
	 *            the socket channel that the message was from
	 * @param data
	 *            the message from the remote peer
	 * @return a message event describing the received message, may be
	 *         <code>null</code> if the channel could not be identified
	 */
	private IChannelEvent createMessageEvent(SocketChannel channel,
			final byte[] data) {
		// search for the id of the corresponding channel
		for (Iterator it = connectedSockets.entrySet().iterator(); it.hasNext();) {
			Map.Entry entry = (Map.Entry) it.next();
			if (channel == entry.getValue()) {
				final ID fromId = (ID) entry.getKey();

				return new IChannelMessageEvent() {
					public byte[] getData() {
						return data;
					}

					public ID getFromContainerID() {
						return fromId;
					}

					public ID getChannelID() {
						return id;
					}

					public String toString() {
						StringBuffer buffer = new StringBuffer();
						buffer.append("IChannelMessageEvent["); //$NON-NLS-1$
						buffer.append("container=").append(fromId); //$NON-NLS-1$
						buffer.append(",channel=").append(id); //$NON-NLS-1$
						buffer.append(",data=").append(data).append(']'); //$NON-NLS-1$
						return buffer.toString();
					}
				};
			}
		}
		return null;
	}

	/**
	 * Stores the specified ID with its corresponding socket into this channel.
	 * The socket will now be actively used for reading and sending messages.
	 * 
	 * @param id
	 *            the target that the socket is connected with
	 * @param socketChannel
	 *            the socket channel to be stored
	 */
	void put(ID id, SocketChannel socketChannel) {
		connectedSockets.put(id, socketChannel);
	}

	/**
	 * Accept the socket as a potential client and attempt to handshake with it.
	 * 
	 * @param socketChannel
	 *            the socket to establish a connection with
	 * @throws ClassNotFoundException
	 *             if the class of an object being deserialized could not be
	 *             found
	 * @throws IOException
	 *             if a networking error occurs with the socket while
	 *             reading/sending messages
	 */
	// private boolean accept2(SocketChannel socketChannel, ByteBuffer buffer)
	// throws ClassNotFoundException, IOException {
	// int read = socketChannel.read(buffer);
	// buffer.flip();
	// byte[] bytes = new byte[read];
	// buffer.get(bytes);
	// buffer.clear();
	//
	// ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(
	// bytes));
	// Object object = ois.readObject();
	//
	// if (object instanceof ID) {
	// bytes = serialize(id);
	// socketChannel.socket().getOutputStream().write(bytes);
	//
	// bytes = serialize(containerId);
	// socketChannel.socket().getOutputStream().write(bytes);
	// socketChannel.socket().getOutputStream().flush();
	//
	// socketChannel.configureBlocking(false);
	// put((ID) object, socketChannel);
	// }
	// return true;
	// }

	/**
	 * Performs a handshake with a remote peer via the provided socket channel
	 * and returns whether <code>true</code> if no further attempts are
	 * required. Note that <code>true</code> does not indicate that the
	 * handshake has been successful.
	 * <p>
	 * For example, if the remote peer has closed this channel then
	 * <code>true</code> would be returned as no further attempts should be
	 * attempted.
	 * </p>
	 * 
	 * @param socketChannel
	 *            the channel to use to handshake with the remote peer
	 * @param buffer
	 *            the buffer to use for reading and writing data from the
	 *            channel
	 * @return <code>true</code> if no further handshake attempts are required,
	 *         <code>false</code> otherwise
	 * @throws ClassNotFoundException
	 *             if deserialization failed during the handshake
	 * @throws IOException
	 *             if an IO error occurred while performing the handshake
	 */
	private boolean handshake(SocketChannel socketChannel, ByteBuffer buffer)
			throws ClassNotFoundException, IOException {
		ChannelData data = Util.read(socketChannel, buffer);
		if (!data.isOpen()) {
			// this channel is dead, close it
			Util.closeChannel(socketChannel);
			return true;
		}

		byte[] bytes = data.getData();
		if (bytes == null) {
			return false;
		}

		ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(
				bytes));
		Object object = ois.readObject();

		if (object instanceof ID) {
			socketChannel.configureBlocking(true);
			byte[] one = Util.serialize(id);
			byte[] two = Util.serialize(containerId);
			bytes = new byte[one.length + two.length];
			System.arraycopy(one, 0, bytes, 0, one.length);
			System.arraycopy(two, 0, bytes, one.length, two.length);

			socketChannel.socket().getOutputStream().write(bytes);
			socketChannel.socket().getOutputStream().flush();

			socketChannel.configureBlocking(false);
			put((ID) object, socketChannel);
		}
		return true;
	}

	/**
	 * Returns the port that is currently open for incoming socket connections.
	 * 
	 * @return the open port for socket connections
	 * @see #sendRequest(ID)
	 * @see NIODatashareContainer#enqueue(SocketAddress)
	 */
	protected final int getLocalPort() {
		return localPort;
	}

	/**
	 * Sends a request to the receiver to notify them that a socket is open and
	 * waiting for incoming connections to establish a channel connection. It is
	 * up to the client to decide how this request should be sent as the
	 * communication channel between one client and another is entirely
	 * dependent on the underlying provider's networking protocol.
	 * <p>
	 * This method will be invoked when a socket corresponding to the receiver's
	 * ID cannot be found.
	 * </p>
	 * 
	 * @param receiver
	 *            the receiver to contact, will not be <code>null</code>
	 * @throws ECFException
	 *             if an error occurred while attempting to send the request
	 * @see #getLocalPort()
	 * @see NIODatashareContainer#enqueue(SocketAddress)
	 */
	protected abstract void sendRequest(ID receiver) throws ECFException;

	public void sendMessage(byte[] message) throws ECFException {
		throw new ECFException(new Status(IStatus.ERROR, Util.PLUGIN_ID,"A receiver must be specified, see sendMessage(ID, byte[])"));
	}

	/**
	 * Sends a message to a remote instance of this channel of the target peer.
	 * <p>
	 * <b>Note:</b> The current implementation does not handle repeated
	 * invocations of this method in succession prior to a socket connection
	 * established. For optimal performance and some assurance of success, there
	 * needs to be a time lag between the first message that is sent and the
	 * ones that follow it. This lag should hopefully allow the provider
	 * sufficient time for establishing a socket connection with the remote
	 * peer. Otherwise, there may be multiple invocations of
	 * {@link #sendRequest(ID)} and clients are responsible for handling this
	 * individually.
	 * </p>
	 * 
	 * @param receiver
	 *            the receiver to send the message to, must not be
	 *            <code>null</code>
	 * @param message
	 *            the message to send, must not be <code>null</code>
	 */
	public void sendMessage(ID receiver, byte[] message) throws ECFException {
		Assert.isNotNull(receiver, "A receiver must be specified"); //$NON-NLS-1$
		Assert.isNotNull(message, "Message cannot be null"); //$NON-NLS-1$

		// check if we already have a socket for this receiver
		if (!connectedSockets.containsKey(receiver)) {
			// send a request to the receiver for establishing a socket
			// connection
			sendRequest(receiver);
		}

		synchronized (messages) {
			// enqueue the message for processing
			messages.add(new ChannelMessage(receiver, message));
		}
	}

	/**
	 * Disposes of this channel. Clients may extend to perform additional
	 * clean-up but <b>must</b> call <code>super.dispose()</code> before the
	 * method returns.
	 */
	public void dispose() {
		processingThread.interrupt();

		try {
			// turn off the server to prevent and deny incoming connections
			if (serverSocketChannel != null) {
				serverSocketChannel.close();
				serverSocketChannel = null;
			}
		} catch (IOException e) {
			// ignored
			serverSocketChannel = null;
		}

		synchronized (connectedSockets) {
			// close all connections
			for (Iterator it = connectedSockets.values().iterator(); it
					.hasNext();) {
				SocketChannel socket = (SocketChannel) it.next();
				Util.closeChannel(socket);
			}

			connectedSockets.clear();
		}

		datashareContainer.fireChannelContainerDeactivatedEvent(id);
	}

	public IChannelListener getListener() {
		return listener;
	}

	public IChannelListener setListener(IChannelListener listener) {
		IChannelListener previous = this.listener;
		this.listener = listener;
		return previous;
	}

	public Object getAdapter(Class adapter) {
		if (adapter != null && adapter.isInstance(this)) {
			return this;
		}
		return null;
	}

	public ID getID() {
		return id;
	}

	private final class ProcessingRunnable implements Runnable {

		public void run() {
			ByteBuffer buffer = ByteBuffer.allocate(1024);
			while (true) {
				try {
					Thread.sleep(50);

					if (Thread.currentThread().isInterrupted()) {
						return;
					}

					// perform handshaking for any pending sockets
					for (int i = 0; i < pendingSockets.size(); i++) {
						SocketChannel channel = (SocketChannel) pendingSockets
								.get(i);
						if (handshake(channel, buffer)) {
							// remove if handled
							pendingSockets.remove(i);
							i--;
						}
					}

					processIncomingMessages(buffer);

					// check if we have pending messages to send
					synchronized (messages) {
						if (!messages.isEmpty()) {
							sendPendingMessages();
						}
					}

					SocketChannel socketChannel = serverSocketChannel.accept();
					if (socketChannel != null) {
						socketChannel.configureBlocking(false);
						pendingSockets.add(socketChannel);
					}
				} catch (InterruptedException e) {
					Thread.interrupted();
					return;
				} catch (ClassNotFoundException e) {
					log(new Status(IStatus.ERROR, Util.PLUGIN_ID,
							"Could not deserialize", e)); //$NON-NLS-1$
				} catch (IOException e) {
					log(new Status(IStatus.ERROR, Util.PLUGIN_ID,
							"An IO error occurred", e)); //$NON-NLS-1$
				} catch (RuntimeException e) {
					log(new Status(IStatus.ERROR, Util.PLUGIN_ID,
							"A runtime error occurred", e)); //$NON-NLS-1$
				}
			}
		}
	}

	private final class ChannelMessage {

		private ID fromId;
		private byte[] data;

		ChannelMessage(ID fromId, byte[] data) throws ECFException {
			this.fromId = fromId;
			this.data = convert(data);
		}

		private byte[] convert(byte[] data) throws ECFException {
			try {
				ByteArrayOutputStream baos = new ByteArrayOutputStream();
				ObjectOutputStream oos = new ObjectOutputStream(baos);
				oos.writeObject(data);
				return baos.toByteArray();
			} catch (IOException e) {
				throw new ECFException(e);
			}
		}

		public ID getId() {
			return fromId;
		}

		public byte[] getData() {
			return data;
		}

	}

}