package org.mentawai.db;
 
 import java.util.ArrayList;
 import org.neodatis.odb.ODB;
 import org.neodatis.odb.ODBFactory;
 
 /**
  *
  * @author navigo
  */
 public class ODBConnectionHandler
 {
 
 	private String host;
 	private int port;
 	private String dbName;
 	private int poolSize;
 	ArrayList<ODB> availableODB;
 	ArrayList<ODB> usedODB;
 
 	public ODBConnectionHandler(String host, int port, String dbName, int poolSize)
 	{
 		this.host = host;
 		this.port = port;
 		this.dbName = dbName;
 		this.poolSize = poolSize;
 		this.availableODB = new ArrayList<ODB>();
 		this.usedODB = new ArrayList<ODB>();
 
 		ODB odb;
 		for(int i = 0; i < this.poolSize; i++)
 		{
 			odb = ODBFactory.openClient(host, port, dbName);
 			availableODB.add(odb);
 		}
 	}
 
 	public ODB getConnection()
 	{
 		ODB odb;
 		if (availableODB.size() > 0)
 		{
 			odb = availableODB.remove(0);
 			if (odb.isClosed())
 			{
 				odb = ODBFactory.openClient(host, port, dbName);
 			}
 			usedODB.add(odb);
 		}
 		else
 		{
 			System.out.println("ODB Client pool exhausted; adding another client.");
 			odb = ODBFactory.openClient(host, port, dbName);
 			usedODB.add(odb);
 		}
 		return odb;
 	}
 
 	public void release(ODB odb)
 	{
 		if(odb != null)
 		{
 			if(! odb.isClosed())
 			{
 				usedODB.remove(odb);
 				availableODB.add(odb);
 			}
 			else
 			{
 				System.out.println("Returned ODB Client is closed; dropping.");
 			}
 		}
 	}
 
 	public void destroy()
 	{
 		for(ODB myODB : availableODB)
 		{
 			myODB.close();
 		}
 		for(ODB myODB : usedODB)
 		{
 			myODB.close();
 		}
 	}
 }
 

package org.mentawai.filter;
 
 import org.mentawai.core.Action;
 import org.mentawai.core.AfterConsequenceFilter;
 import org.mentawai.core.Consequence;
 import org.mentawai.core.InputWrapper;
 import org.mentawai.core.InvocationChain;
 import org.mentawai.db.ODBConnectionHandler;
 import org.neodatis.odb.ODB;
 
 /**
  *
  * @author navigo
  */
 public class NeoDatisFilter extends InputWrapper implements AfterConsequenceFilter
 {
 	public static final String KEY = "conn";
 	private String connKey;
 	private final ODBConnectionHandler odbConnectionHandler;
 	private ThreadLocal<ODB> odb = new ThreadLocal<ODB>();
 
 	public NeoDatisFilter(String connKey, ODBConnectionHandler odbConnectionHandler)
 	{
 		super();
 		this.connKey = connKey;
 		this.odbConnectionHandler = odbConnectionHandler;
 	}
 
 	public NeoDatisFilter(ODBConnectionHandler odbConnectionHandler)
 	{
 		this(KEY, odbConnectionHandler);
 	}
 
 	public NeoDatisFilter(ODBConnectionHandler odbConnectionHandler, String connKey)
 	{
 		this(connKey, odbConnectionHandler);
 	}
 
 	public String filter(InvocationChain chain) throws Exception
 	{
 		Action action = chain.getAction();
 		super.setInput(action.getInput());
 		action.setInput(this);
 		return chain.invoke();
 	}
 
 	public void destroy()
 	{
 		odbConnectionHandler.destroy();
 	}
 
 	public void afterConsequence(Action action, Consequence cnsqnc, boolean bln, boolean bln1, String string)
 	{
 		ODB myODB = this.odb.get();
 		if(myODB != null)
 		{
 			this.odb.set(null);
 			removeValue(connKey);
 			odbConnectionHandler.release(myODB);
 		}
 	}
 
 	@Override
 	public Object getValue(String key)
 	{
 		if(key.equals(connKey))
 		{
 			ODB myODB = odb.get();
 			if(myODB == null)
 			{
 				try
 				{
 					myODB = odbConnectionHandler.getConnection();
 					odb.set(myODB);
 					setValue(connKey, myODB);
 				}
 				catch(Exception e)
 				{
 					throw new RuntimeException("Error while getting the connection from the connection handler '" + odbConnectionHandler + "': " + e, e);
 				}
 			}
 			return myODB;
 		}
 		return super.getValue(key);
 	}
 }
 

public class ApplicationManager extends org.mentawai.core.ApplicationManager
 {
 
 	private ODBConnectionHandler odbch = null;
 
 	@Override
 	public void init(Context application)
 	{
 		setDebugMode(true);
 		odbch = new ODBConnectionHandler("localhost", 9090, "main", 1);
 	}
 .............snip
 		//Connection Pooling
 		filter(new NeoDatisFilter("odb", odbch));
 .............snip
 		//IoC components (DAOs)
 		ioc("userAccountDAO", NeoDatisUserAccountDAO.class);
 
 		//Auto-wiring
 		filter(new AutoWiringFilter());
 
 		//Dependencies
 		aw("odb", ODB.class); //DAOs depend on ODB
 .............snip