package org.xvsm.core;
   
   import java.lang.reflect.Constructor;
   import java.net.URI;
   import java.util.ArrayList;
   import java.util.List;
   import java.util.Properties;
   import java.util.StringTokenizer;
   import java.util.UUID;
  
  import org.apache.log4j.Logger;
  import org.xvsm.configuration.ConfigurationManager;
  import org.xvsm.coordinators.FifoCoordinator;
  import org.xvsm.coordinators.RandomCoordinator;
  import org.xvsm.core.aspect.GlobalAspect;
  import org.xvsm.core.aspect.IPoint;
  import org.xvsm.core.aspect.LocalAspect;
  import org.xvsm.core.aspect.LocalIPoint;
  import org.xvsm.core.notifications.NotificationAspect;
  import org.xvsm.core.notifications.Operation;
  import org.xvsm.interfaces.ICapi;
  import org.xvsm.interfaces.ICoordinator;
  import org.xvsm.interfaces.NotificationListener;
  import org.xvsm.internal.EventProcessingPool;
  import org.xvsm.internal.ReplySenderPool;
  import org.xvsm.internal.TimeoutSchedulerPool;
  import org.xvsm.internal.exceptions.ContainerFullException;
  import org.xvsm.internal.exceptions.ContainerNameOccupiedException;
  import org.xvsm.internal.exceptions.CountNotMetException;
  import org.xvsm.internal.exceptions.FatalException;
  import org.xvsm.internal.exceptions.InvalidContainerException;
  import org.xvsm.internal.exceptions.InvalidTransactionException;
  import org.xvsm.internal.exceptions.XCoreException;
  import org.xvsm.internal.tasks.AspectTask;
  import org.xvsm.internal.tasks.AspectTaskType;
  import org.xvsm.internal.tasks.ClearTask;
  import org.xvsm.internal.tasks.ContainerTask;
  import org.xvsm.internal.tasks.ContainerTaskType;
  import org.xvsm.internal.tasks.OperationTask;
  import org.xvsm.internal.tasks.OperationTaskType;
  import org.xvsm.internal.tasks.ShutdownTask;
  import org.xvsm.internal.tasks.Task;
  import org.xvsm.internal.tasks.TransactionTask;
  import org.xvsm.internal.tasks.TransactionTaskType;
  import org.xvsm.remote.TransportHandler;
  import org.xvsm.selectors.KeySelector;
  import org.xvsm.selectors.LindaSelector;
  import org.xvsm.selectors.RandomSelector;
  import org.xvsm.selectors.Selector;
  import org.xvsm.transactions.Transaction;
  
  /***
   * 
   * @author Christian Schreiber, Michael Proestler
   * 
   */
  public class Capi implements ICapi {
  
  	/***
  	 * The logger for this Class.
  	 */
  	private static Logger logger = Logger.getLogger(Capi.class);
  
  	/***
  	 * This property will be passed within every operation to the aspects.
  	 */
  	private Properties aspectContext;
  
  	/***
  	 * Used to create the virtual answer to container reference.
  	 */
  	private ThreadLocal<VirtualAnswerContainer> answerContainer = new ThreadLocal<VirtualAnswerContainer>();
  
  	/***
  	 * Default Constructor.
  	 * 
  	 * @throws XCoreException
  	 *             thrown if there problems initializing the capi.
  	 */
  	public Capi() throws XCoreException {
  		// initialize the core
  		TransportHandler.getInstance().init();
  		EventProcessingPool.getInstance();
  		TimeoutSchedulerPool.init();
  		ReplySenderPool.init();
  	}
  
  	/***
  	 * {@inheritDoc}
  	 */
  	public void clearSpace(URI site) throws XCoreException {
  		if (logger.isDebugEnabled()) {
  			logger.debug("clearSpace(" + site + ")");
  		}
  
  		Task task = new ClearTask();
  		task.setAspectContext(this.aspectContext);
  		this.send(site, task);
  		task.waitUntilFinished();
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	public void commitTransaction(Transaction txn) throws XCoreException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("commitTransaction(" + txn + ")");
 		}
 		TransactionTask task = new TransactionTask(TransactionTaskType.COMMIT,
 				txn);
 		task.setAspectContext(this.aspectContext);
 		this.send(txn.getSite(), task);
 		task.waitUntilFinished();
 		try {
 			this.throwException(task);
 		} catch (InvalidTransactionException e) {
 			throw e;
 		} catch (Exception e) {
 			throw new FatalException(e);
 		}
 
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	// @Override
 	public ContainerRef createContainer(Transaction tx, URI site, String name,
 			int size, ICoordinator... coordinators) throws XCoreException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("createContainer(" + tx + ", " + site + ", " + size
 					+ ", " + java.util.Arrays.toString(coordinators));
 		}
 		Task task;
 		if (coordinators != null && coordinators.length > 0
 				&& coordinators[0] != null) {
 			task = new ContainerTask(tx, ContainerTaskType.CREATE, size,
 					coordinators);
 		} else {
 			task = new ContainerTask(tx, ContainerTaskType.CREATE, size,
 					new RandomCoordinator());
 		}
 		task.setAspectContext(this.aspectContext);
 		this.send(site, task);
 		this.throwException(task);
 		// ContainerRef result = new ContainerRef((String) task.readResult());
 		Object o = task.readResult();
 		ContainerRef result = null;
 		if (o instanceof URI) {
 			// embedded:
 			result = new ContainerRef((URI) o);
 		} else {
 			// remote;
 			result = new ContainerRef((URI) ((AtomicEntry<?>) ((List<?>) o)
 					.get(0)).getValue());
 		}
 
 		result.setSite(site);
 		if (name != null) {
 			ContainerRef cref = new ContainerRef("lookup");
 			cref.setSite(site);
 			try {
 				this.write(cref, 0, tx, new AtomicEntry<URI>(result.asURI(),
 						URI.class, new KeySelector<String>("lookup", name)));
 			} catch (ContainerFullException e) {
 				throw new ContainerNameOccupiedException(name
 						+ " already exists");
 			}
 		}
 		return result;
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	public Transaction createTransaction(URI site, long timeout)
 			throws XCoreException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("createTransaction(" + site + ", " + timeout + ")");
 		}
 		TransactionTask task = new TransactionTask();
 		task.setTimeout(timeout);
 		task.setAspectContext(this.aspectContext);
 		this.send(site, task);
 
 		Object o = task.readResult();
 		Transaction tx;
 		if (o instanceof URI) {
 			// embedded:
 			tx = new Transaction((URI) o);
 		} else {
 			// remote;
 			tx = new Transaction((URI) ((AtomicEntry<?>) ((List<?>) o).get(0))
 					.getValue());
 		}
 		tx.setSite(site);
 
 		return tx;
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	public void destroy(ContainerRef cref, long timeout, Transaction tx,
 			Selector... sel) throws XCoreException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("destroy(" + cref + ", " + timeout + ", " + tx + ", "
 					+ java.util.Arrays.toString(sel));
 		}
 		List<Selector> selectors = null;
 		if (sel == null) {
 			selectors = new ArrayList<Selector>();
 		} else {
 			selectors = java.util.Arrays.asList(sel);
 		}
 		OperationTask task = new OperationTask(OperationTaskType.DESTROY, null,
 				cref, tx, selectors, timeout);
 		task.setAspectContext(this.aspectContext);
 		this.send(cref.getSite(), task);
 		this.throwException(task);
 		task.waitUntilFinished();
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	// @Override
 	public void destroyContainer(Transaction tx, ContainerRef cref)
 			throws XCoreException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("destroyContainer(" + tx + "," + cref + ")");
 		}
 		Task task = new ContainerTask(tx, ContainerTaskType.DELETE, cref);
 		task.setAspectContext(this.aspectContext);
 		this.send(cref.getSite(), task);
 
 		try {
 			this.throwException(task);
 			// TODO implement UnknownContainerException!!!
 		} catch (Exception e) {
 			throw new FatalException(e);
 		}
 		try {
 			// check whether the container was named, if so remove it from the
 			// lookup container
 			ContainerRef lookupC = new ContainerRef("lookup");
 			lookupC.setSite(cref.getSite());
 			this.destroy(lookupC, 0, null, new LindaSelector(
 					new AtomicEntry<URI>(cref.asURI())));
 		} catch (CountNotMetException e) {
 			// ignore
 			// the container was not named!
 		} catch (ContainerFullException e) {
 			// FIXME this exception is thrown when XML is used
 			// ==> we have to align the exceptions!
 		}
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	// @Override
 	public ContainerRef lookupContainer(Transaction tx, URI site,
 			String containerName) throws XCoreException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("getNamedContainer(" + tx + ", " + site + ","
 					+ containerName + ")");
 		}
 		Entry[] entries;
 		try {
 			ContainerRef cref = new ContainerRef("lookup");
 			cref.setSite(site);
 			entries = this.read(cref, 0, tx, new KeySelector<String>("lookup",
 					containerName));
 		} catch (XCoreException e1) {
 			throw new InvalidContainerException(containerName
 					+ " does not exist");
 		}
 		if (entries.length < 1) {
 			throw new InvalidContainerException(containerName
 					+ " does not exist");
 		}
 		ContainerRef cref = new ContainerRef(
 				(URI) ((AtomicEntry<?>) entries[0]).getValue());
 		cref.setSite(site);
 		return cref;
 
 	}
 
 	/***
 	 * {@inheritDoc}
 	 * 
 	 */
 	@SuppressWarnings("unchecked")
 	public Entry[] read(ContainerRef cref, long timeout, Transaction tx,
 			Selector... sel) throws XCoreException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("read(" + cref + ", " + timeout + ", " + tx + ", "
 					+ java.util.Arrays.toString(sel));
 		}
 		List<Selector> selectors = null;
 		if (sel == null) {
 			selectors = new ArrayList<Selector>();
 		} else {
 			selectors = java.util.Arrays.asList(sel);
 		}
 
 		OperationTask task = new OperationTask(OperationTaskType.READ, null,
 				cref, tx, selectors, timeout);
 		task.setAspectContext(this.aspectContext);
 		this.send(cref.getSite(), task);
 		this.throwException(task);
 		return ((List<Entry>) task.readResult()).toArray(new Entry[0]);
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	public void rollbackTransaction(Transaction txn) throws XCoreException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("rollbackTransaction(" + txn + ")");
 		}
 		TransactionTask task = new TransactionTask(
 				TransactionTaskType.ROLLBACK, txn);
 		task.setAspectContext(this.aspectContext);
 		this.send(txn.getSite(), task);
 		try {
 			this.throwException(task);
 		} catch (InvalidTransactionException e) {
 			throw e;
 		} catch (Exception e) {
 			throw new FatalException(e);
 		}
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	public void shift(ContainerRef cref, Transaction tx, Entry... entries)
 			throws XCoreException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("shift(" + cref + ", "
 					+ java.util.Arrays.toString(entries) + ")");
 		}
 		OperationTask task = new OperationTask(OperationTaskType.SHIFT,
 				java.util.Arrays.asList(entries), cref, tx, null, 0);
 		task.setAspectContext(this.aspectContext);
 		this.send(cref.getSite(), task);
 		this.throwException(task);
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	public void shutdown(URI site, boolean clearSpace) throws XCoreException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("shutdown(" + site + "," + clearSpace + ")");
 		}
 		if (clearSpace) {
 			this.clearSpace(site);
 		}
 		Task task = new ShutdownTask();
 		task.setAspectContext(this.aspectContext);
 		this.send(site, task);
 		task.waitUntilFinished();
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	@SuppressWarnings("unchecked")
 	public Entry[] take(ContainerRef cref, long timeout, Transaction tx,
 			Selector... sel) throws XCoreException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("take(" + cref + ", " + timeout + ", " + tx + ", "
 					+ java.util.Arrays.toString(sel));
 		}
 		List<Selector> selectors = null;
 		if (sel == null) {
 			selectors = new ArrayList<Selector>();
 		} else {
 			selectors = java.util.Arrays.asList(sel);
 		}
 		OperationTask task = new OperationTask(OperationTaskType.TAKE, null,
 				cref, tx, selectors, timeout);
 		task.setAspectContext(this.aspectContext);
 		this.send(cref.getSite(), task);
 		this.throwException(task);
 		return ((List<Entry>) task.readResult()).toArray(new Entry[0]);
 		// return (Entry[]) task.readResult();
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	public void write(ContainerRef cref, long timeout, Transaction tx,
 			Entry... entries) throws XCoreException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("write(" + cref + ", " + timeout + ", " + tx + ", "
 					+ java.util.Arrays.toString(entries));
 		}
 		OperationTask task = new OperationTask(OperationTaskType.WRITE,
 				java.util.Arrays.asList(entries), cref, tx, null, timeout);
 		task.setAspectContext(this.aspectContext);
 		this.send(cref.getSite(), task);
 		this.throwException(task);
 		// task.waitUntilFinished();
 	}
 
 	/***
 	 * Method blocks till the result of the task is available and checks if the
 	 * result is an exception. If it is an exception it will be thrown.<br>
 	 * If the answer is a Throwable which does not inherit from
 	 * {@link XCoreException} a {@link XCoreException} is thrown.
 	 * 
 	 * @param task
 	 *            the task to check.
 	 * @throws XCoreException
 	 *             thrown if the answer of the task is an exception.
 	 */
 	@SuppressWarnings("unchecked")
 	private void throwException(Task task) throws XCoreException {
 		Object xx = task.readResult();
 
 		if (xx instanceof Throwable) {
 			Throwable t = (Throwable) xx;
 			if (t instanceof XCoreException) {
 				throw (XCoreException) t;
 			}
 			throw new FatalException(t);
 		}
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	public URI addAspect(ContainerRef cref, List<LocalIPoint> p,
 			LocalAspect aspect) throws XCoreException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("addAspect(" + cref + ", " + p + ", " + aspect + ")");
 		}
 		List<IPoint> points = new ArrayList<IPoint>();
 		for (IPoint pp : p) {
 			points.add(pp);
 		}
 		AspectTask task = new AspectTask(AspectTaskType.ADD, cref, aspect,
 				points);
 		task.setAspectContext(this.aspectContext);
 		this.send(cref.getSite(), task);
 		task.waitUntilFinished();
 		URI result;
 
 		if (task.getResult() instanceof URI) {
 			result = (URI) task.getResult();
 		} else {
 			result = (URI) ((AtomicEntry<?>) ((List<?>) task.getResult())
 					.get(0)).getValue();
 		}
 
 		return result;
 
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	@Deprecated
 	public void removeAspect(ContainerRef cref, List<LocalIPoint> p,
 			LocalAspect aspect) throws XCoreException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("addAspect(" + cref + ", " + p + ", " + aspect + ")");
 		}
 
 		List<IPoint> points = new ArrayList<IPoint>();
 		for (IPoint pp : p) {
 			points.add(pp);
 		}
 		AspectTask task = new AspectTask(AspectTaskType.DELETE, cref, aspect,
 				points);
 		task.setAspectContext(this.aspectContext);
 		this.send(cref.getSite(), task);
 		task.waitUntilFinished();
 	}
 
 	/***
 	 * 
 	 * {@inheritDoc}.
 	 */
 	@Deprecated
 	public void removeAspect(URI site, List<IPoint> p, GlobalAspect aspect)
 			throws XCoreException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("removeAspect(" + site + ", " + p + ", " + aspect
 					+ ")");
 		}
 		AspectTask task = new AspectTask(AspectTaskType.DELETE, aspect, p);
 		task.setAspectContext(this.aspectContext);
 		this.send(site, task);
 		task.waitUntilFinished();
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	public void removeAspect(ContainerRef cref, List<LocalIPoint> p, URI auri)
 			throws XCoreException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("addAspect(" + cref + ", " + p + ", " + auri + ")");
 		}
 
 		List<IPoint> points = new ArrayList<IPoint>();
 		for (IPoint pp : p) {
 			points.add(pp);
 		}
 		AspectTask task = new AspectTask(AspectTaskType.DELETE, cref, auri,
 				points);
 		task.setAspectContext(this.aspectContext);
 		this.send(cref.getSite(), task);
 		task.waitUntilFinished();
 	}
 
 	/***
 	 * 
 	 * {@inheritDoc}.
 	 */
 	public void removeAspect(URI site, List<IPoint> p, URI auri)
 			throws XCoreException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("removeAspect(" + site + ", " + p + ", " + auri + ")");
 		}
 		AspectTask task = new AspectTask(AspectTaskType.DELETE, auri, p);
 		task.setAspectContext(this.aspectContext);
 		this.send(site, task);
 		task.waitUntilFinished();
 	}
 
 	/***
 	 * 
 	 * {@inheritDoc}.
 	 */
 	public URI addAspect(URI site, List<IPoint> p, GlobalAspect aspect)
 			throws XCoreException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("addAspect(" + site + ", " + p + ", " + aspect + ")");
 		}
 		AspectTask task = new AspectTask(AspectTaskType.ADD, aspect, p);
 		task.setAspectContext(this.aspectContext);
 		this.send(site, task);
 		task.waitUntilFinished();
 		URI result;
 		if (task.getResult() instanceof URI) {
 			result = (URI) task.getResult();
 		} else {
 			result = (URI) ((AtomicEntry<?>) ((List<?>) task.getResult())
 					.get(0)).getValue();
 		}
 		return result;
 	}
 
 	public URI createNotification(ContainerRef cref,
 			final NotificationListener listener, Operation... operations) {
 		List<LocalIPoint> ipoints = new ArrayList<LocalIPoint>();
 		for (Operation o : operations) {
 			switch (o) {
 			case Write:
 				ipoints.add(LocalIPoint.PostWrite);
 				break;
 			case Read:
 				ipoints.add(LocalIPoint.PostRead);
 				break;
 			case Take:
 				ipoints.add(LocalIPoint.PostTake);
 				break;
 			case Destroy:
 				ipoints.add(LocalIPoint.PostDestroy);
 				break;
 			case Shift:
 				ipoints.add(LocalIPoint.PostShift);
 				break;
 			}
 		}
 		try {
 			final ContainerRef ncref = this.createContainer(null, cref
 					.getSite(), null, -1, new FifoCoordinator());
 			new Thread() {
 				public void run() {
 					try {
 						while (true) {
 							Entry[] entries = take(ncref, -1, null,
 									new RandomSelector(1));
 							Tuple t = (Tuple) entries[0];
 							Operation o = Operation
 									.valueOf((String) (((AtomicEntry<?>) t
 											.getEntryAt(0)).getValue()));
 							listener.handleNotification(o, ((Tuple) t
 									.getEntryAt(1)).toArray());
 						}
 					} catch (InvalidContainerException e) {
 						// ignore
 					} catch (XCoreException e) {
 						throw new FatalException(e);
 					}
 				}
 			}.start();
 			return this.addAspect(cref, ipoints, new NotificationAspect(cref,
 					ncref));
 		} catch (XCoreException e) {
 			throw new FatalException(e);
 		}
 	}
 
 	/***
 	 * Sends the task t to the url. If the URI is <code>null</code> it will be
 	 * written in the local core.
 	 * 
 	 * @param url
 	 *            the URI of the remote core or <code>null</code> for the local
 	 *            core.
 	 * @param t
 	 *            the task which has to be send.
 	 */
 	private void send(URI url, Task t) {
 		// if the url is null we use the embedded core.
 
 		boolean local = false;
 		// check if "we" are listening to the uri ... if this is one of our uris
 		// we don't have do use the network.
 		ConfigurationManager cm = ConfigurationManager.getInstance();
 		if (url != null) {
 			String p = cm.getStringSetting("RemoteProtocols");
 			StringTokenizer st = new StringTokenizer(p, "|");
 			TransportHandler tm = TransportHandler.getInstance();
 			while (st.hasMoreTokens()) {
 				String s = st.nextToken();
 				String sproto = tm.getListener(s).getUri().toASCIIString();
 				local = url.toString().equalsIgnoreCase(sproto);
 				if (local) {
 					break;
 				}
 			}
 		} else {
 			// the url is null -> we are local.
 			local = true;
 		}
 
 		if (local) {
 			EventProcessingPool.getInstance().execute(t);
 		} else {
 			try {
 				URI answerToUri = null;
 				if (this.answerContainer.get() == null) {
 					answerToUri = this.getAnswerContainerURI();
 					this.answerContainer.set(VirtualAnswerContainer
 							.getOrCreateInstance(answerToUri));
 				} else {
 					answerToUri = this.answerContainer.get().getContainerURI();
 				}
 
 				t.setAnswerToContainer(answerToUri);
 				TransportHandler.getInstance().send(url, t);
 
 				Entry[] result = this.answerContainer.get().wait(answerToUri);
 
 				// we have to set the answertocontainer to null otherwise
 				// the answer would be sent again (and again, and again,
 				// ...).
 				t.setAnswerToContainer(null);
 				if (result[0].getEntryType().equals(Entry.EntryTypes.VOID)) {
 					// VoidEntry is written when CNT_ALL is used for reading and
 					// no entries are available.
 					t.setResult(new ArrayList<Entry>());
 				} else if (result[0].getEntryType().equals(
 						Entry.EntryTypes.EXCEPTION)) {
 					// ExceptionEntry is returned when an exception has been
 					// thrown on the server.
 					ExceptionEntry exceptionEntry = (ExceptionEntry) result[0];
 					Class<?> ec;
 					try {
 						ec = Class.forName("org.xvsm.internal.exceptions."
 								+ exceptionEntry.getName());
 					} catch (ClassNotFoundException e) {
 						ec = FatalException.class;
 					}
 					Constructor<?> constructor = ec
 							.getConstructor(String.class);
 					Throwable ex = (Throwable) constructor
 							.newInstance(exceptionEntry.getDesription());
 					t.setResult(ex);
 				} else {
 					t.setResult(java.util.Arrays.asList(result));
 				}
 			} catch (Exception e) {
 				throw new FatalException(e);
 			}
 		}
 	}
 
 	/***
 	 * @return the aspectContext
 	 */
 	public Properties getAspectContext() {
 		return aspectContext;
 	}
 
 	/***
 	 * @param aspectContext
 	 *            the aspectContext to set
 	 */
 	public void setAspectContext(Properties aspectContext) {
 		this.aspectContext = aspectContext;
 	}
 
 	/***
 	 * Get the URI of the answertoContainer used by this thread.
 	 * 
 	 * @return the uri of the virtual answer to container
 	 */
 	public URI getAnswerContainerURI() {
 		String uri = TransportHandler.getInstance().getListener(
 				ConfigurationManager.getInstance().getStringSetting(
 						"DefaultAnswerToProtocol")).getUri().toString();
 
 		if (uri.charAt(uri.length() - 1) != '/') {
 			// the uri has to end with /
 			uri += '/';
 		}
 		try {
 			return new URI(uri + "containers/" + UUID.randomUUID().toString());
 		} catch (Exception e) {
 			throw new FatalException(e);
 		}
 	}
 }