initial add of EbeanORM server based on v2.8.1

src/main/java/com/avaje/ebeaninternal/server/autofetch/AutoFetchManager.java

@@ -0,0 +1,263 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.autofetch;
+
+import java.util.Iterator;
+
+import com.avaje.ebean.Query;
+import com.avaje.ebean.bean.NodeUsageListener;
+import com.avaje.ebean.bean.ObjectGraphNode;
+import com.avaje.ebean.config.AutofetchMode;
+import com.avaje.ebean.config.ServerConfig;
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.api.SpiQuery;
+
+/**
+ * Collects and manages the the profile information.
+ * <p>
+ * The profile information is periodically converted into "tuned query details" -
+ * which is used to automatically tune the queries that use autoFetch.
+ * </p>
+ * <p>
+ * The "tuned query details" effectively are part of the query that has the
+ * select() and join() information (but not the where clause, order by, limits
+ * etc). These are applied to the query when tuneQuery() is called.
+ * </p>
+ */
+public interface AutoFetchManager extends NodeUsageListener {
+
+	/**
+	 * Set the owning ebean server.
+	 */
+	public void setOwner(SpiEbeanServer server, ServerConfig serverConfig);
+
+	/**
+	 * Clear the query execution statistics.
+	 */
+	public void clearQueryStatistics();
+	
+	/**
+	 * Clear all the tuned query info.
+	 * <p>
+	 * Should only need do this for testing and playing around.
+	 * </p>
+	 */
+	public int clearTunedQueryInfo();
+
+	/**
+	 * Clear all the profiling information.
+	 * <p>
+	 * This means the profiling information will need to be re-gathered.
+	 * </p>
+	 * <p>
+	 * Should only need do this for testing and playing around.
+	 * </p>
+	 */
+	public int clearProfilingInfo();
+
+	/**
+	 * On shutdown fire garbage collection and collect statistics. Note that
+	 * usually we add a little delay (100 milliseconds) to give the garbage
+	 * collector plenty of time to do its thing and collect the profile
+	 * information.
+	 */
+	public void shutdown();
+
+	/**
+	 * Return the current tuned fetch information for a given queryPoint key.
+	 */
+	public TunedQueryInfo getTunedQueryInfo(String queryPointKey);
+
+	/**
+	 * Return the current Statistics for a given queryPoint key.
+	 */
+	public Statistics getStatistics(String queryPointKey);
+
+	/**
+	 * Iterate the tuned fetch info.
+	 * <p>
+	 * This should be a read only iteration.
+	 * </p>
+	 */
+	public Iterator<TunedQueryInfo> iterateTunedQueryInfo();
+
+	/**
+	 * Iterate the node usage statistics.
+	 * <p>
+	 * This should be a read only iteration.
+	 * </p>
+	 */
+	public Iterator<Statistics> iterateStatistics();
+
+	/**
+	 * Return true if profiling is enabled.
+	 */
+	public boolean isProfiling();
+
+	/**
+	 * Set to true to enable profiling.
+	 * <p>
+	 * We rely on garbage collection to collect the profiling information. This
+	 * means there is a unknown delay between when a query is executed and when
+	 * we actually collect the usage profile information.
+	 * </p>
+	 * <p>
+	 * Due to this garbage collection delay, when turning off profiling while
+	 * the application is running you should consider calling
+	 * collectUsageViaGC() <em>BEFORE</em> setProfiling(false). This hints to
+	 * the JVM to perform garbage collection, and hopefully collects the
+	 * profiling information.
+	 * </p>
+	 */
+	public void setProfiling(boolean enable);
+
+	/**
+	 * Return true if automatic query tuning is enabled.
+	 */
+	public boolean isQueryTuning();
+
+	/**
+	 * Set to true to enable automatic query tuning.
+	 */
+	public void setQueryTuning(boolean enable);
+
+	/**
+	 * This controls whether autoFetch is used when it has not been explicitly
+	 * set on a query via {@link Query#setAutoFetch(boolean)}.
+	 */
+	public AutofetchMode getMode();
+
+	/**
+	 * Set the auto fetch mode used when a query has not had
+	 * {@link Query#setAutoFetch(boolean)}.
+	 */
+	public void setMode(AutofetchMode Mode);
+
+	/**
+	 * Return the profiling rate (int between 0 and 100).
+	 */
+	public double getProfilingRate();
+
+	/**
+	 * Set the profiling rate (int between 0 and 100).
+	 */
+	public void setProfilingRate(double rate);
+
+	/**
+	 * Return the max number of queries profiled (per query point).
+	 * <p>
+	 * The number of queries profiled is collected per query point. Once a query
+	 * point has profiled this number of queries it does not profile any more.
+	 * </p>
+	 */
+	public int getProfilingBase();
+
+	/**
+	 * Set a max number of queries to profile per query point.
+	 * <p>
+	 * This number should provide a level of confidence that no more profiling
+	 * is required for this query point.
+	 * </p>
+	 */
+	public void setProfilingBase(int profilingMax);
+
+	/**
+	 * Return the minimum number of queries profiled before autoFetch will start
+	 * automatically tuning the queries.
+	 * <p>
+	 * This could be one which means start autoFetch tuning after the first
+	 * profiling information is collected.
+	 * </p>
+	 */
+	public int getProfilingMin();
+
+	/**
+	 * Set the minimum number of queries profiled per query point before
+	 * autoFetch will automatically tune the queries.
+	 * <p>
+	 * Increasing this number will mean more profiling is collected before
+	 * autoFetch starts tuning the query.
+	 * </p>
+	 */
+	public void setProfilingMin(int autoFetchMinThreshold);
+
+	/**
+	 * Fire a garbage collection (hint to the JVM). Assuming garbage collection
+	 * fires this will gather the usage profiling information.
+	 */
+	public String collectUsageViaGC(long waitMillis);
+
+	/**
+	 * This will take the current profiling information and update the "tuned
+	 * query detail".
+	 * <p>
+	 * This is done periodically and can also be manually invoked.
+	 * </p>
+	 * <p>
+	 * This returns a string summary of the updates that occurred.
+	 * </p>
+	 */
+	public String updateTunedQueryInfo();
+
+	/**
+	 * Called when a query thinks it should be automatically tuned by autoFetch.
+	 * <p>
+	 * This internally checks that autoFetch is enabled, there is a "tuned query
+	 * detail" to tune the query with and that the autoFetchMinThreshold has
+	 * been reached.
+	 * </p>
+	 * <p>
+	 * This will also determine if the query should be profiled.
+	 * </p>
+	 */
+	public boolean tuneQuery(SpiQuery<?> query);
+
+	/**
+	 * Collect query profiling information.
+	 * <p>
+	 * This is for the original query as well as any subsequent lazy loading
+	 * queries that are required as the object graph is traversed.
+	 * </p>
+	 * 
+	 * @param node
+	 *            the node path in the object graph.
+	 * @param beans
+	 *            the number of beans loaded by the query.
+	 * @param micros
+	 *            the query executing time in microseconds
+	 */
+	public void collectQueryInfo(ObjectGraphNode node, int beans, int micros);
+
+	
+	/**
+	 * Return the number of queries tuned by AutoFetch.
+	 */
+	public int getTotalTunedQueryCount();
+	
+	/**
+	 * Return the size of the TuneQuery map.
+	 */
+	public int getTotalTunedQuerySize();
+	
+	/**
+	 * Return the size of the profile map.
+	 */
+	public int getTotalProfileSize();
+}

src/main/java/com/avaje/ebeaninternal/server/autofetch/AutoFetchManagerFactory.java

@@ -0,0 +1,97 @@
+package com.avaje.ebeaninternal.server.autofetch;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.ObjectInputStream;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.persistence.PersistenceException;
+
+import com.avaje.ebean.config.ServerConfig;
+import com.avaje.ebean.config.GlobalProperties;
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.server.resource.ResourceManager;
+
+public class AutoFetchManagerFactory {
+
+	private static final Logger logger = Logger.getLogger(AutoFetchManagerFactory.class.getName());
+	
+	
+	public static AutoFetchManager create(SpiEbeanServer server, ServerConfig serverConfig, ResourceManager resourceManager) {
+		
+		AutoFetchManagerFactory me = new AutoFetchManagerFactory();
+		return me.createAutoFetchManager(server, serverConfig, resourceManager);
+	}
+	
+	private AutoFetchManager createAutoFetchManager(SpiEbeanServer server, ServerConfig serverConfig, ResourceManager resourceManager){
+		
+		AutoFetchManager manager = createAutoFetchManager(server.getName(), resourceManager);
+		manager.setOwner(server, serverConfig);
+		
+		return manager;
+	}
+	
+	private AutoFetchManager createAutoFetchManager(String serverName, ResourceManager resourceManager) {
+
+		File autoFetchFile = getAutoFetchFile(serverName, resourceManager);
+
+		AutoFetchManager autoFetchManager = null;
+
+		boolean readFile = GlobalProperties.getBoolean("autofetch.readfromfile", true);
+		if (readFile) {
+			autoFetchManager = deserializeAutoFetch(autoFetchFile);
+		}
+
+		if (autoFetchManager == null) {
+			// not deserialized from file so create as empty
+			// It will be populated automatically by querying the
+			// database meta data
+			autoFetchManager = new DefaultAutoFetchManager(autoFetchFile.getAbsolutePath());
+		}
+		
+		return autoFetchManager;
+	}
+	
+	private AutoFetchManager deserializeAutoFetch(File autoFetchFile) {
+		try {
+			
+			if (!autoFetchFile.exists()) {
+				return null;
+			}
+			FileInputStream fi = new FileInputStream(autoFetchFile);
+			ObjectInputStream ois = new ObjectInputStream(fi);
+			AutoFetchManager profListener = (AutoFetchManager) ois.readObject();
+			
+			logger.info("AutoFetch deserialized from file ["+autoFetchFile.getAbsolutePath()+"]");
+			
+			return profListener;
+
+		} catch (Exception ex) {
+			logger.log(Level.SEVERE, "Error loading autofetch file "+autoFetchFile.getAbsolutePath(), ex);
+			return null;
+		}
+	}
+	
+	/**
+	 * Return the file name of the autoFetch meta data.
+	 */
+	private File getAutoFetchFile(String serverName, ResourceManager resourceManager) {
+
+		String fileName = ".ebean."+serverName+".autofetch";
+
+		File dir = resourceManager.getAutofetchDirectory();
+
+		if (!dir.exists()) {
+			// automatically create the directory if it does not exist.
+			// this is probably a fairly reasonable thing to do
+			if (!dir.mkdirs()) {
+				String m = "Unable to create directory [" + dir + "] for autofetch file ["+ fileName + "]";
+				throw new PersistenceException(m);
+			}
+		}
+
+		return new File(dir, fileName);
+	}
+
+}

src/main/java/com/avaje/ebeaninternal/server/autofetch/DefaultAutoFetchManager.java

@@ -0,0 +1,582 @@
+package com.avaje.ebeaninternal.server.autofetch;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.logging.Level;
+
+import javax.persistence.PersistenceException;
+
+import com.avaje.ebean.bean.CallStack;
+import com.avaje.ebean.bean.NodeUsageCollector;
+import com.avaje.ebean.bean.ObjectGraphNode;
+import com.avaje.ebean.bean.ObjectGraphOrigin;
+import com.avaje.ebean.config.AutofetchConfig;
+import com.avaje.ebean.config.AutofetchMode;
+import com.avaje.ebean.config.ServerConfig;
+import com.avaje.ebeaninternal.api.ClassUtil;
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.api.SpiQuery;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
+import com.avaje.ebeaninternal.server.querydefn.OrmQueryDetail;
+
+/**
+ * The manager of all the usage/query statistics as well as the tuned fetch
+ * information.
+ */
+public class DefaultAutoFetchManager implements AutoFetchManager, Serializable {
+
+	private static final long serialVersionUID = -6826119882781771722L;
+
+	private final String statisticsMonitor = new String();
+
+	private final String fileName;
+
+	/**
+	 * Map of the usage and query statistics gathered.
+	 */
+	private Map<String, Statistics> statisticsMap = new ConcurrentHashMap<String, Statistics>();
+
+	/**
+	 * Map of the tuned query details per profile query point.
+	 */
+	private Map<String, TunedQueryInfo> tunedQueryInfoMap = new ConcurrentHashMap<String, TunedQueryInfo>();
+
+	private transient long defaultGarbageCollectionWait = 100;
+
+	/**
+	 * Left without synchronized for now.
+	 */
+	private transient int tunedQueryCount;
+	
+	/**
+	 * Converted from a 0-100 int to a double. Effectively a percentage rate at
+	 * which to collect profiling information.
+	 */
+	private transient double profilingRate = 0.1d;
+
+	private transient int profilingBase = 10;
+
+	private transient int profilingMin = 1;
+
+	private transient boolean profiling;
+
+	private transient boolean queryTuning;
+
+	private transient boolean queryTuningAddVersion;
+
+	private transient AutofetchMode mode;
+
+	private transient boolean useFileLogging;
+	
+	/**
+	 * Server that owns this Profile Listener.
+	 */
+	private transient SpiEbeanServer server;
+
+	/**
+	 * The logger.
+	 */
+	private transient DefaultAutoFetchManagerLogging logging;
+
+	public DefaultAutoFetchManager(String fileName) {
+		this.fileName = fileName;
+	}
+
+	/**
+	 * Set up this profile listener before it is active.
+	 */
+	public void setOwner(SpiEbeanServer server, ServerConfig serverConfig) {
+		this.server = server;
+		this.logging = new DefaultAutoFetchManagerLogging(serverConfig, this);
+
+		AutofetchConfig autofetchConfig = serverConfig.getAutofetchConfig();
+		
+		useFileLogging = autofetchConfig.isUseFileLogging();
+		queryTuning = autofetchConfig.isQueryTuning();
+		queryTuningAddVersion = autofetchConfig.isQueryTuningAddVersion();
+		profiling = autofetchConfig.isProfiling();
+		profilingMin = autofetchConfig.getProfilingMin();
+		profilingBase = autofetchConfig.getProfilingBase();
+
+		setProfilingRate(autofetchConfig.getProfilingRate());
+				
+
+		defaultGarbageCollectionWait = (long) autofetchConfig.getGarbageCollectionWait();
+
+		// determine the mode to use when Query.setAutoFetch() was
+		// not explicitly set
+		mode = autofetchConfig.getMode();
+
+		if (profiling || queryTuning) {
+			// log the guts of the autoFetch setup
+			String msg = "AutoFetch queryTuning[" + queryTuning + "] profiling[" + profiling
+					+ "] mode[" + mode + "]  profiling rate[" + profilingRate
+					+ "] min[" + profilingMin + "] base[" + profilingBase + "]";
+			logging.logToJavaLogger(msg);
+		}
+	}
+
+	
+	
+	public void clearQueryStatistics() {
+		server.clearQueryStatistics();
+	}
+
+	/**
+	 * Return the number of queries tuned by AutoFetch.
+	 */
+	public int getTotalTunedQueryCount(){
+		return tunedQueryCount;
+	}
+	
+	/**
+	 * Return the size of the TuneQuery map.
+	 */
+	public int getTotalTunedQuerySize(){
+		return tunedQueryInfoMap.size();
+	}
+	
+	/**
+	 * Return the size of the profile map.
+	 */
+	public int getTotalProfileSize(){
+		return statisticsMap.size();
+	}
+	
+	public int clearTunedQueryInfo() {
+		
+		// reset the rough count as well
+		tunedQueryCount = 0;
+		
+		// clear the map...
+		int size = tunedQueryInfoMap.size();
+		tunedQueryInfoMap.clear();
+		return size;
+	}
+
+	public int clearProfilingInfo() {
+		int size = statisticsMap.size();
+		statisticsMap.clear();
+		return size;
+	}
+
+	
+	public void serialize() {
+
+		File autoFetchFile = new File(fileName);
+
+		try {
+			FileOutputStream fout = new FileOutputStream(autoFetchFile);
+
+			ObjectOutputStream oout = new ObjectOutputStream(fout);
+			oout.writeObject(this);
+			oout.flush();
+			oout.close();
+
+		} catch (Exception e) {
+			String msg = "Error serializing autofetch file";
+			logging.logError(Level.SEVERE, msg, e);
+		}
+	}
+
+	/**
+	 * Return the current Tuned query info for a given origin key.
+	 */
+	public TunedQueryInfo getTunedQueryInfo(String originKey) {
+		return tunedQueryInfoMap.get(originKey);
+	}
+
+	/**
+	 * Return the current Statistics for a given originKey key.
+	 */
+	public Statistics getStatistics(String originKey) {
+		return statisticsMap.get(originKey);
+	}
+
+	public Iterator<TunedQueryInfo> iterateTunedQueryInfo() {
+		return tunedQueryInfoMap.values().iterator();
+	}
+
+	public Iterator<Statistics> iterateStatistics() {
+		return statisticsMap.values().iterator();
+	}
+
+	public boolean isProfiling() {
+		return profiling;
+	}
+
+	/**
+	 * When the application is running, BEFORE turning off profiling you
+	 * probably should call collectUsageViaGC() as there is a delay (waiting for
+	 * garbage collection) collecting usage profiling information.
+	 */
+	public void setProfiling(boolean profiling) {
+		this.profiling = profiling;
+	}
+
+	public boolean isQueryTuning() {
+		return queryTuning;
+	}
+
+	public void setQueryTuning(boolean queryTuning) {
+		this.queryTuning = queryTuning;
+	}
+	
+	public double getProfilingRate() {
+		return profilingRate;
+	}
+
+	public AutofetchMode getMode() {
+		return mode;
+	}
+
+	public void setMode(AutofetchMode mode) {
+		this.mode = mode;
+	}
+
+	public void setProfilingRate(double rate) {
+		if (rate < 0) {
+			rate = 0d;
+		} else if (rate > 1) {
+			rate = 1d;
+		}
+		profilingRate = rate;
+	}
+
+	public int getProfilingBase() {
+		return profilingBase;
+	}
+
+	public void setProfilingBase(int profilingBase) {
+		this.profilingBase = profilingBase;
+	}
+
+	public int getProfilingMin() {
+		return profilingMin;
+	}
+
+	public void setProfilingMin(int profilingMin) {
+		this.profilingMin = profilingMin;
+	}
+
+	/**
+	 * Shutdown the listener.
+	 * <p>
+	 * We should try to collect the usage statistics by calling a System.gc().
+	 * This is necessary for use with short lived applications where garbage
+	 * collection may not otherwise occur at all.
+	 * </p>
+	 */
+	public void shutdown() {
+		if (useFileLogging) {
+		    collectUsageViaGC(-1);
+		    serialize();
+		}
+	}
+
+	/**
+	 * Ask for a System.gc() so that we gather node usage information.
+	 * <p>
+	 * Really only want to do this sparingly but useful just prior to shutdown
+	 * for short run application where garbage collection may otherwise not
+	 * occur at all.
+	 * </p>
+	 * <p>
+	 * waitMillis will do a thread sleep to give the garbage collection a little
+	 * time to do its thing assuming we are shutting down the VM.
+	 * </p>
+	 * <p>
+	 * If waitMillis is -1 then the defaultGarbageCollectionWait is used which
+	 * defaults to 100 milliseconds.
+	 * </p>
+	 */
+	public String collectUsageViaGC(long waitMillis) {
+		System.gc();
+		try {
+			if (waitMillis < 0) {
+				waitMillis = defaultGarbageCollectionWait;
+			}
+			Thread.sleep(waitMillis);
+		} catch (InterruptedException e) {
+			String msg = "Error while sleeping after System.gc() request.";
+			logging.logError(Level.SEVERE, msg, e);
+			return msg;
+		}
+		return updateTunedQueryInfo();
+	}
+
+	/**
+	 * Update the tuned fetch plans from the current usage information.
+	 */
+	public String updateTunedQueryInfo() {
+
+		if (!profiling) {
+			// we are not collecting any profiling information at
+			// the moment so don't try updating the tuned query plans.
+			return "Not profiling";
+		}
+
+		synchronized (statisticsMonitor) {
+
+		    Counters counters = new Counters();
+		    
+			Iterator<Statistics> it = statisticsMap.values().iterator();
+			while (it.hasNext()) {
+				Statistics queryPointStatistics = it.next();
+				if (!queryPointStatistics.hasUsage()){
+				    // no usage statistics collected yet...
+				    counters.incrementNoUsage();
+				} else {
+				    updateTunedQueryFromUsage(counters, queryPointStatistics);
+				}
+			}
+
+			String summaryInfo = counters.toString();
+
+			if (counters.isInteresting()){
+				// only log it if its interesting
+				logging.logSummary(summaryInfo);
+			}
+			
+			return summaryInfo;
+		}
+	}
+
+	private static class Counters {
+	    
+        int newPlan;
+        int modified;
+        int unchanged;
+        int noUsage;
+        
+        void incrementNoUsage(){
+            noUsage++;
+        }
+        void incrementNew(){
+            newPlan++;
+        }
+        void incrementModified(){
+            modified++;
+        }
+        void incrementUnchanged(){
+            unchanged++;
+        }
+        boolean isInteresting() {
+            return newPlan > 0 || modified > 0;
+        }
+        public String toString() {
+            return "new["+newPlan+"] modified["+modified+"] unchanged["+unchanged+"] nousage["+noUsage+"]";
+        }
+	}
+	
+	private void updateTunedQueryFromUsage(Counters counters, Statistics statistics) {
+	    
+	    ObjectGraphOrigin queryPoint = statistics.getOrigin();
+        String beanType = queryPoint.getBeanType();
+
+        try {
+            Class<?> beanClass = ClassUtil.forName(beanType, this.getClass());
+            BeanDescriptor<?> beanDescriptor = server.getBeanDescriptor(beanClass);
+            if (beanDescriptor == null){
+                // previously was an entity but not longer
+                
+            } else {
+                // Determine the fetch plan from the latest statistics.
+                // Use this to compare with current "tuned fetch plan".
+                OrmQueryDetail newFetchDetail = statistics.buildTunedFetch(beanDescriptor);
+                
+                // get the current tuned fetch info...
+                TunedQueryInfo currentFetch = tunedQueryInfoMap.get(queryPoint.getKey());
+
+                if (currentFetch == null) {
+                    // its a new fetch plan, add it.
+                    counters.incrementNew();
+
+                    currentFetch = statistics.createTunedFetch(newFetchDetail);
+                    logging.logNew(currentFetch);
+                    tunedQueryInfoMap.put(queryPoint.getKey(), currentFetch);
+
+                } else if (!currentFetch.isSame(newFetchDetail)) {
+                    // the fetch plan has changed, update it.
+                    counters.incrementModified();
+                    
+                    logging.logChanged(currentFetch, newFetchDetail);
+                    currentFetch.setTunedDetail(newFetchDetail);
+
+                } else {
+                    // the fetch plan has not changed...
+                    counters.incrementUnchanged();
+                }
+
+                currentFetch.setProfileCount(statistics.getCounter());
+            }
+
+        } catch (ClassNotFoundException e) {
+            // expected after renaming/moving an entity bean
+            String msg = e.toString()+" updating autoFetch tuned query for " + beanType
+                +". It isLikely this bean has been renamed or moved";
+            logging.logError(Level.INFO, msg, null);
+            statisticsMap.remove(statistics.getOrigin().getKey());
+        }
+	}
+	
+	/**
+	 * Return true if we should try to use autoFetch for this query.
+	 */
+	private boolean useAutoFetch(SpiQuery<?> query) {
+
+		if (query.isLoadBeanCache()){
+			// when loading the cache don't tune the query
+			// as we want full objects loaded into the cache
+			return false;
+		}
+		
+		Boolean autoFetch = query.isAutofetch();
+		if (autoFetch != null) {
+			// explicitly set...
+			return autoFetch.booleanValue();
+
+		} else {
+			// determine using implicit mode...
+			switch (mode) {
+			case DEFAULT_ON:
+				return true;
+
+			case DEFAULT_OFF:
+				return false;
+
+			case DEFAULT_ONIFEMPTY:
+				return query.isDetailEmpty();
+
+			default:
+				throw new PersistenceException("Invalid autoFetchMode " + mode);
+			}
+		}
+	}
+
+	/**
+	 * Auto tune the query and enable profiling.
+	 */
+	public boolean tuneQuery(SpiQuery<?> query) {
+
+		if (!queryTuning && !profiling) {
+			return false;
+		}
+
+		if (!useAutoFetch(query)) {
+			// not using autoFetch for this query
+			return false;
+		}
+
+		ObjectGraphNode parentAutoFetchNode = query.getParentNode();
+		if (parentAutoFetchNode != null) {
+			// This is a +lazy/+query query with profiling on.
+			// We continue to collect the profiling information.
+			query.setAutoFetchManager(this);
+			return true;
+		}
+
+		// create a query point to identify the query
+		CallStack stack = server.createCallStack();
+		ObjectGraphNode origin = query.setOrigin(stack);
+
+		// get current "tuned fetch" for this query point
+		TunedQueryInfo tunedFetch = tunedQueryInfoMap.get(origin.getOriginQueryPoint().getKey());
+
+		// get the number of times we have collected profiling information
+		int profileCount = tunedFetch == null ? 0 : tunedFetch.getProfileCount();
+
+		if (profiling) {
+			// we want more profiling information?
+			if (tunedFetch == null) {
+				query.setAutoFetchManager(this);
+
+			} else if (profileCount < profilingBase) {
+				query.setAutoFetchManager(this);
+
+			} else if (tunedFetch.isPercentageProfile(profilingRate)) {
+				query.setAutoFetchManager(this);
+			}
+		}
+		
+		if (queryTuning) {
+			if (tunedFetch != null && profileCount >= profilingMin) {
+				// deemed to have enough profiling 
+				// information for automatic tuning
+				if (tunedFetch.autoFetchTune(query)){
+					// tunedQueryCount++ not thread-safe, could use AtomicInteger.
+					// But I'm happy if this statistic is a little wrong
+					// and this is a VERY HOT method
+					tunedQueryCount++;
+				}	
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * Gather query execution statistics. This could either be the originating
+	 * query in which case the parentNode will be null, or a lazy loading query
+	 * resulting from traversal of the object graph.
+	 */
+	public void collectQueryInfo(ObjectGraphNode node, int beans, int micros) {
+
+		if (node != null){
+			ObjectGraphOrigin origin = node.getOriginQueryPoint();
+			if (origin != null){
+				Statistics stats = getQueryPointStats(origin);
+				stats.collectQueryInfo(node, beans, micros);				
+			}
+		}
+	}
+
+	/**
+	 * Collect usage statistics from a node in the object graph.
+	 * <p>
+	 * This is sent to use from a EntityBeanIntercept when the finalise method
+	 * is called on the bean.
+	 * </p>
+	 */
+	public void collectNodeUsage(NodeUsageCollector usageCollector) {
+
+		ObjectGraphOrigin origin = usageCollector.getNode().getOriginQueryPoint();
+
+		Statistics stats = getQueryPointStats(origin);
+
+		if (logging.isTraceUsageCollection()){
+			System.out.println("... NodeUsageCollector "+usageCollector);
+		}
+		
+		stats.collectUsageInfo(usageCollector);
+		
+		if (logging.isTraceUsageCollection()){
+            System.out.println("stats\n"+stats);
+        }
+	}
+
+	private Statistics getQueryPointStats(ObjectGraphOrigin originQueryPoint) {
+		synchronized (statisticsMonitor) {
+			Statistics stats = statisticsMap.get(originQueryPoint.getKey());
+			if (stats == null) {
+				stats = new Statistics(originQueryPoint, queryTuningAddVersion);
+				statisticsMap.put(originQueryPoint.getKey(), stats);
+			}
+			return stats;
+		}
+	}
+
+	public String toString() {
+		synchronized (statisticsMonitor) {
+			return statisticsMap.values().toString();
+		}
+	}
+
+
+}

src/main/java/com/avaje/ebeaninternal/server/autofetch/DefaultAutoFetchManagerLogging.java

@@ -0,0 +1,112 @@
+package com.avaje.ebeaninternal.server.autofetch;
+
+import java.util.logging.Level;
+
+import java.util.logging.Logger;
+
+import com.avaje.ebean.config.AutofetchConfig;
+import com.avaje.ebean.config.GlobalProperties;
+import com.avaje.ebean.config.ServerConfig;
+import com.avaje.ebeaninternal.server.lib.BackgroundThread;
+import com.avaje.ebeaninternal.server.querydefn.OrmQueryDetail;
+import com.avaje.ebeaninternal.server.transaction.log.SimpleLogger;
+
+/**
+ * Handles the logging aspects for the DefaultAutoFetchListener.
+ * <p>
+ * Note that java util logging loggers generally should not be serialised and
+ * that is one of the main reasons for pulling out the logging to this class.
+ * </p>
+ */
+public class DefaultAutoFetchManagerLogging {
+
+	private static final Logger logger = Logger.getLogger(DefaultAutoFetchManagerLogging.class.getName());
+
+	private final SimpleLogger fileLogger;
+
+	private final DefaultAutoFetchManager manager;
+
+	private final boolean useFileLogger;
+
+	private final boolean traceUsageCollection;
+
+	public DefaultAutoFetchManagerLogging(ServerConfig serverConfig, DefaultAutoFetchManager profileListener) {
+
+		this.manager = profileListener;
+
+		AutofetchConfig autofetchConfig = serverConfig.getAutofetchConfig();
+
+		traceUsageCollection = GlobalProperties.getBoolean("ebean.autofetch.traceUsageCollection", false);
+		useFileLogger = autofetchConfig.isUseFileLogging();
+
+		if (!useFileLogger) {
+			fileLogger = null;
+
+		} else {
+			// a separate log file just like the transaction logging
+			// for putting the profiling log messages. The benefit is that
+			// this doesn't pollute the main log with heaps of messages.
+			String baseDir = serverConfig.getLoggingDirectoryWithEval();
+			fileLogger = new SimpleLogger(baseDir, "autofetch", true, "csv");
+		}
+
+		int updateFreqInSecs = autofetchConfig.getProfileUpdateFrequency();
+
+		BackgroundThread.add(updateFreqInSecs, new UpdateProfile());
+	}
+
+	private final class UpdateProfile implements Runnable {
+		public void run() {
+			manager.updateTunedQueryInfo();
+		}
+	}
+
+	public void logError(Level level, String msg, Throwable e) {
+		if (useFileLogger) {
+			String errMsg = e == null ? "" : e.getMessage();
+			fileLogger.log("\"Error\",\"" + msg+" "+errMsg+"\",,,,");
+		}
+		logger.log(level, msg, e);
+	}
+
+	public void logToJavaLogger(String msg) {
+		logger.info(msg);
+	}
+
+	public void logSummary(String summaryInfo) {
+		
+		String msg = "\"Summary\",\""+summaryInfo+"\",,,,";
+		
+		if (useFileLogger) {
+			fileLogger.log(msg);
+		}
+		logger.fine(msg);
+	}
+
+	public void logChanged(TunedQueryInfo tunedFetch, OrmQueryDetail newQueryDetail) {
+		
+		String msg = tunedFetch.getLogOutput(newQueryDetail);
+		
+		if (useFileLogger) {
+			fileLogger.log(msg);
+		} else {
+			logger.fine(msg);
+		}
+	}
+
+	public void logNew(TunedQueryInfo tunedFetch) {
+
+		String msg = tunedFetch.getLogOutput(null);
+
+		if (useFileLogger) {
+			fileLogger.log(msg);
+		} else {
+			logger.fine(msg);
+		}
+	}
+
+	public boolean isTraceUsageCollection() {
+		return traceUsageCollection;
+	}
+	
+}

src/main/java/com/avaje/ebeaninternal/server/autofetch/Statistics.java

@@ -0,0 +1,207 @@
+package com.avaje.ebeaninternal.server.autofetch;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import com.avaje.ebean.bean.NodeUsageCollector;
+import com.avaje.ebean.bean.ObjectGraphNode;
+import com.avaje.ebean.bean.ObjectGraphOrigin;
+import com.avaje.ebean.meta.MetaAutoFetchStatistic;
+import com.avaje.ebean.meta.MetaAutoFetchStatistic.NodeUsageStats;
+import com.avaje.ebean.meta.MetaAutoFetchStatistic.QueryStats;
+import com.avaje.ebean.text.PathProperties;
+import com.avaje.ebean.text.PathProperties.Props;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
+import com.avaje.ebeaninternal.server.querydefn.OrmQueryDetail;
+
+public class Statistics implements Serializable {
+
+
+	private static final long serialVersionUID = -5586783791097230766L;
+
+	private final ObjectGraphOrigin origin;
+
+	private final boolean queryTuningAddVersion;
+	
+	private int counter;
+	
+	private Map<String, StatisticsQuery> queryStatsMap = new LinkedHashMap<String, StatisticsQuery>();
+
+	private Map<String, StatisticsNodeUsage> nodeUsageMap = new LinkedHashMap<String, StatisticsNodeUsage>();
+
+	private final String monitor = new String();
+
+	public Statistics(ObjectGraphOrigin origin, boolean queryTuningAddVersion) {
+		this.origin = origin;
+		this.queryTuningAddVersion = queryTuningAddVersion;
+	}
+	
+	public ObjectGraphOrigin getOrigin() {
+		return origin;
+	}
+
+	public TunedQueryInfo createTunedFetch(OrmQueryDetail newFetchDetail) {
+		synchronized (monitor) {
+			// NB: create a copy of queryPoint allowing garbage
+			// collection of source...
+			return new TunedQueryInfo(origin, newFetchDetail, counter);
+		}
+	}
+	
+	public MetaAutoFetchStatistic createPublicMeta() {
+		
+		synchronized (monitor) {
+			
+			StatisticsQuery[] sourceQueryStats = queryStatsMap.values().toArray(new StatisticsQuery[queryStatsMap.size()]);
+			List<QueryStats> destQueryStats = new ArrayList<QueryStats>(sourceQueryStats.length);
+			
+			// copy the query statistics
+			for (int i = 0; i < sourceQueryStats.length; i++) {
+				destQueryStats.add(sourceQueryStats[i].createPublicMeta());
+			}
+			
+			StatisticsNodeUsage[] sourceNodeUsage = nodeUsageMap.values().toArray(new StatisticsNodeUsage[nodeUsageMap.size()]);
+			List<NodeUsageStats> destNodeUsage = new ArrayList<NodeUsageStats>(sourceNodeUsage.length);
+
+			// copy the node usage statistics
+			for (int i = 0; i < sourceNodeUsage.length; i++) {
+				destNodeUsage.add(sourceNodeUsage[i].createPublicMeta());
+			}
+			
+			return new MetaAutoFetchStatistic(origin, counter, destQueryStats, destNodeUsage);
+		}
+	}
+	
+	/**
+	 * Return the number of times the root query has executed.
+	 * <p>
+	 * This tells us how much profiling we have done for this query.
+	 * For example, after 100 times we may stop collecting more profiling info.
+	 * </p>
+	 */
+	public int getCounter() {
+		return counter;
+	}
+	
+	/**
+	 * Return true if this has usage statistics.
+	 */
+	public boolean hasUsage() {
+        synchronized (monitor) {
+            return !nodeUsageMap.isEmpty();
+        }	    
+	}
+	
+	public OrmQueryDetail buildTunedFetch(BeanDescriptor<?> rootDesc){
+		
+		synchronized (monitor) {
+			if (nodeUsageMap.isEmpty()){
+			    return null;
+			}
+		    
+			PathProperties pathProps = new PathProperties();
+			
+			Iterator<StatisticsNodeUsage> it = nodeUsageMap.values().iterator();
+			while (it.hasNext()) {
+				StatisticsNodeUsage statsNode = it.next();
+				statsNode.buildTunedFetch(pathProps, rootDesc);
+			}
+
+	        OrmQueryDetail detail = new OrmQueryDetail();
+
+			Collection<Props> pathProperties = pathProps.getPathProps();
+			for (Props props : pathProperties) {
+			    if (!props.isEmpty()){
+			        detail.addFetch(props.getPath(), props.getPropertiesAsString(), null);
+			    }
+            }
+			
+			detail.sortFetchPaths(rootDesc);
+            return detail;
+		}
+	}
+
+	
+	public void collectQueryInfo(ObjectGraphNode node, int beansLoaded, int micros) {
+		
+		synchronized (monitor) {
+			String key = node.getPath();
+			if (key == null){
+				key = "";
+				// this is basically the number of times the root query
+				// has executed which gives us an indication of how
+				// much profiling information we have gathered.
+				counter++;
+			} 
+			
+			StatisticsQuery stats = queryStatsMap.get(key);
+			if (stats == null){
+				stats = new StatisticsQuery(key);
+				queryStatsMap.put(key, stats);
+			}
+			stats.add(beansLoaded, micros);
+		}
+	}
+
+
+	/**
+	 * Collect the usage information for from a instance for this node.
+	 */
+	public void collectUsageInfo(NodeUsageCollector profile) {
+
+	    if (profile.isEmpty()){
+	        // no usage was collected
+	    } else {
+    		ObjectGraphNode node = profile.getNode();
+    
+    		StatisticsNodeUsage nodeStats = getNodeStats(node.getPath());
+    		nodeStats.publish(profile);
+	    }
+	}
+
+	private StatisticsNodeUsage getNodeStats(String path) {
+		
+		synchronized (monitor) {
+			StatisticsNodeUsage nodeStats = nodeUsageMap.get(path);
+			if (nodeStats == null) {
+				nodeStats = new StatisticsNodeUsage(path, queryTuningAddVersion);
+				nodeUsageMap.put(path, nodeStats);
+			}
+			return nodeStats;
+		}
+	}
+
+    public String getUsageDebug() {
+        synchronized (monitor) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("root[").append(origin.getBeanType()).append("] ");
+            for (StatisticsNodeUsage node : nodeUsageMap.values()) {
+                sb.append(node.toString()).append("\n");
+            }
+            return sb.toString();
+        }
+    }
+
+    public String getQueryStatDebug() {
+        synchronized (monitor) {
+            StringBuilder sb = new StringBuilder();
+            for (StatisticsQuery queryStat : queryStatsMap.values()) {
+                sb.append(queryStat.toString()).append("\n");
+            }       
+            return sb.toString();
+        }
+    }
+
+	public String toString() {
+
+		synchronized (monitor) {
+		    return getUsageDebug();
+		}
+	}
+
+}

src/main/java/com/avaje/ebeaninternal/server/autofetch/StatisticsNodeUsage.java

@@ -0,0 +1,123 @@
+package com.avaje.ebeaninternal.server.autofetch;
+
+import java.io.Serializable;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import java.util.logging.Logger;
+
+import com.avaje.ebean.bean.NodeUsageCollector;
+import com.avaje.ebean.meta.MetaAutoFetchStatistic.NodeUsageStats;
+import com.avaje.ebean.text.PathProperties;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
+import com.avaje.ebeaninternal.server.deploy.BeanProperty;
+import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssoc;
+import com.avaje.ebeaninternal.server.el.ElPropertyValue;
+import com.avaje.ebeaninternal.server.query.SplitName;
+
+/**
+ * Collects usages statistics for a given node in the object graph.
+ */
+public class StatisticsNodeUsage implements Serializable {
+
+	private static final long serialVersionUID = -1663951463963779547L;
+
+	private static final Logger logger = Logger.getLogger(StatisticsNodeUsage.class.getName());
+
+	private final String monitor = new String();
+	
+	private final String path;
+	
+	private final boolean queryTuningAddVersion;
+	
+	private int profileCount;
+	
+	private int profileUsedCount;
+	
+	private boolean modified;
+	
+	private Set<String> aggregateUsed = new LinkedHashSet<String>();
+
+	public StatisticsNodeUsage(String path, boolean queryTuningAddVersion) {
+		this.path = path;
+		this.queryTuningAddVersion = queryTuningAddVersion;
+	}
+	
+	public NodeUsageStats createPublicMeta() {
+		synchronized(monitor){
+			String[] usedProps = aggregateUsed.toArray(new String[aggregateUsed.size()]);
+			return new NodeUsageStats(path, profileCount, profileUsedCount, usedProps);
+		}
+	}
+	
+	public void buildTunedFetch(PathProperties pathProps, BeanDescriptor<?> rootDesc) {
+		
+		synchronized(monitor){
+							
+			BeanDescriptor<?> desc = rootDesc;
+			if (path != null){
+				ElPropertyValue elGetValue = rootDesc.getElGetValue(path);
+				if (elGetValue == null){
+					desc = null;
+					logger.warning("Autofetch: Can't find join for path["+path+"] for "+rootDesc.getName());
+					
+				} else {
+					BeanProperty beanProperty = elGetValue.getBeanProperty();
+					if (beanProperty instanceof BeanPropertyAssoc<?>){
+						desc = ((BeanPropertyAssoc<?>) beanProperty).getTargetDescriptor();
+					}
+				}
+			}
+
+			for (String propName : aggregateUsed) {
+                BeanProperty beanProp = desc.getBeanPropertyFromPath(propName);
+                if (beanProp == null){
+                    logger.warning("Autofetch: Can't find property["+propName+"] for "+desc.getName());
+                    
+                } else {
+                    if (beanProp instanceof BeanPropertyAssoc<?>){
+                        BeanPropertyAssoc<?> assocProp = (BeanPropertyAssoc<?>)beanProp;
+                        String targetIdProp = assocProp.getTargetIdProperty();
+                        String manyPath = SplitName.add(path, assocProp.getName());
+                        pathProps.addToPath(manyPath, targetIdProp);
+                    } else {
+                    	if (beanProp.isLob() && !beanProp.isFetchEager()) {
+                    		// AutoFetch will not include Lob's marked FetchLazy 
+                    		// (which is the default for Lob's so typical). 
+                    	} else {
+                    		pathProps.addToPath(path, beanProp.getName());
+                    	}
+                    }
+                }
+            }
+
+            if ((modified || queryTuningAddVersion) && desc != null) {
+                BeanProperty[] versionProps = desc.propertiesVersion();
+                if (versionProps.length > 0) {
+                    pathProps.addToPath(path, versionProps[0].getName());
+                }
+            }
+		}
+	}
+	
+	public void publish(NodeUsageCollector profile) {
+		
+		synchronized(monitor){
+			
+			HashSet<String> used = profile.getUsed();
+			
+			profileCount++;
+			if (!used.isEmpty()){
+				profileUsedCount++;
+				aggregateUsed.addAll(used);
+			}
+			if (profile.isModified()){
+				modified = true;
+			}
+		}
+	}
+	
+	public String toString() {
+		return "path["+path+"] profileCount["+profileCount+"] used["+profileUsedCount+"] props"+aggregateUsed;
+	}
+}

src/main/java/com/avaje/ebeaninternal/server/autofetch/StatisticsQuery.java

@@ -0,0 +1,42 @@
+package com.avaje.ebeaninternal.server.autofetch;
+
+import java.io.Serializable;
+
+import com.avaje.ebean.meta.MetaAutoFetchStatistic.QueryStats;
+
+/**
+ * Used to accumulate query execution statistics.
+ */
+public class StatisticsQuery implements Serializable {
+	
+	private static final long serialVersionUID = -1133958958072778811L;
+
+	private final String path;
+	
+	private int exeCount;
+	
+	private int totalBeanLoaded;
+	
+	private int totalMicros;
+	
+	public StatisticsQuery(String path){
+		this.path = path;
+	}
+		
+	public QueryStats createPublicMeta() {
+		return new QueryStats(path, exeCount, totalBeanLoaded, totalMicros);
+	}
+	
+	public void add(int beansLoaded, int micros) {
+		exeCount++;
+		totalBeanLoaded += beansLoaded;
+		totalMicros += micros;
+	}
+	
+	public String toString() {
+		long avgMicros = exeCount == 0 ? 0 : totalMicros / exeCount;
+		
+		return	"queryExe path["+path+"] count[" + exeCount + "] totalBeansLoaded[" + totalBeanLoaded + "] avgMicros["
+					+ avgMicros + "] totalMicros[" + totalMicros + "]";
+	}
+}

src/main/java/com/avaje/ebeaninternal/server/autofetch/TunedQueryInfo.java

@@ -0,0 +1,193 @@
+package com.avaje.ebeaninternal.server.autofetch;
+
+import java.io.Serializable;
+
+import com.avaje.ebean.bean.ObjectGraphOrigin;
+import com.avaje.ebean.meta.MetaAutoFetchTunedQueryInfo;
+import com.avaje.ebeaninternal.api.SpiQuery;
+import com.avaje.ebeaninternal.server.querydefn.OrmQueryDetail;
+
+/**
+ * Holds tuned query information. Is immutable so this represents the tuning at
+ * a given point in time.
+ */
+public class TunedQueryInfo implements Serializable {
+
+	private static final long serialVersionUID = 7381493228797997282L;
+
+	private final ObjectGraphOrigin origin;
+
+	/**
+	 * The tuned query details with joins and properties.
+	 */
+	private OrmQueryDetail tunedDetail;
+
+	/**
+	 * The number of times profiling has been collected for this query point.
+	 */
+	private int profileCount;
+	
+	private Long lastTuneTime = Long.valueOf(0);
+
+	private final String rateMonitor = new String();
+
+	/**
+	 * The number of queries tuned by this object.
+	 * Could use AtomicInteger perhaps.
+	 */
+	private transient int tunedCount;
+
+	private transient int rateTotal;
+
+	private transient int rateHits;
+
+	private transient double lastRate;
+
+	public TunedQueryInfo(ObjectGraphOrigin queryPoint, OrmQueryDetail tunedDetail, int profileCount) {
+		this.origin = queryPoint;
+		this.tunedDetail = tunedDetail;
+		this.profileCount = profileCount;
+	}
+
+	/**
+	 * Return true if this query should be profiled based on a percentage rate.
+	 */
+	public boolean isPercentageProfile(double rate) {
+		
+		synchronized (rateMonitor) {
+
+			if (lastRate != rate) {
+				// the rate has changed so resetting
+				lastRate = rate;
+				rateTotal = 0;
+				rateHits = 0;
+			}
+
+			rateTotal++;
+			if (rate > (double) rateHits / rateTotal) {
+				rateHits++;
+				return true;
+			} else {
+				return false;
+			}
+		}
+	}
+
+	/**
+	 * Create a copy of this tuned fetch data for public consumption.
+	 */
+	public MetaAutoFetchTunedQueryInfo createPublicMeta() {
+		return new MetaAutoFetchTunedQueryInfo(origin, tunedDetail.toString(), profileCount, tunedCount, lastTuneTime);
+	}
+
+	/**
+	 * Set the number of times profiling has been collected for this query
+	 * point.
+	 */
+	public void setProfileCount(int profileCount) {
+		// int assignment is atomic
+		this.profileCount = profileCount;
+	}
+
+	/**
+	 * Set the tuned query detail.
+	 */
+	public void setTunedDetail(OrmQueryDetail tunedDetail) {
+		// assignment is atomic
+		this.tunedDetail = tunedDetail;
+		this.lastTuneTime = Long.valueOf(System.currentTimeMillis());
+	}
+
+	/**
+	 * Return true if the fetches are essentially the same.
+	 */
+	public boolean isSame(OrmQueryDetail newQueryDetail) {
+		if (tunedDetail == null) {
+			return false;
+		}
+		return tunedDetail.isAutoFetchEqual(newQueryDetail);
+	}
+
+	/**
+	 * Tune the query by replacing its OrmQueryDetail with a tuned one.
+	 * 
+	 * @return true if the query was tuned, otherwise false.
+	 */
+	public boolean autoFetchTune(SpiQuery<?> query) {
+		if (tunedDetail == null) {
+		    return false;
+		}
+		
+		boolean tuned = false;
+		//Note: tunedDetail is immutable by convention
+	    if (query.isDetailEmpty()) {
+            tuned = true;
+            // tune by 'replacement'
+            query.setDetail(tunedDetail.copy());  
+	    } else {
+	        // tune by 'addition'
+	        tuned = query.tuneFetchProperties(tunedDetail);
+	    }
+	    if (tuned){
+            query.setAutoFetchTuned(true);
+    		// a case for AtomicInteger but good enough for statistics
+    		tunedCount++;	
+	    }
+		return tuned;
+	}
+	
+	/**
+	 * Return the time of the last tune.
+	 */
+	public Long getLastTuneTime() {
+		return lastTuneTime;
+	}
+
+	/**
+	 * Return the number of queries tuned by this object.
+	 */
+	public int getTunedCount() {
+		return tunedCount;
+	}
+
+	/**
+	 * Return the number of times profiling has been collected for this query
+	 * point.
+	 */
+	public int getProfileCount() {
+		return profileCount;
+	}
+
+	public OrmQueryDetail getTunedDetail() {
+		return tunedDetail;
+	}
+
+	public ObjectGraphOrigin getOrigin() {
+		return origin;
+	}
+
+	public String getLogOutput(OrmQueryDetail newQueryDetail) {
+		
+		boolean changed = newQueryDetail != null;
+		
+		StringBuilder sb = new StringBuilder(150);
+		sb.append( changed ? "\"Changed\",":"\"New\",");
+		sb.append("\"").append(origin.getBeanType()).append("\",");
+		sb.append("\"").append(origin.getKey()).append("\",");
+		if (changed){
+			sb.append("\"to: ").append(newQueryDetail.toString()).append("\",");
+			sb.append("\"from: ").append(tunedDetail.toString()).append("\",");
+		} else {
+			sb.append("\"to: ").append(tunedDetail.toString()).append("\",");			
+			sb.append("\"\",");
+		}
+		sb.append("\"").append(origin.getFirstStackElement()).append("\"");
+		
+		return sb.toString();
+	}
+	
+	public String toString() {
+		return origin.getBeanType()+" "+origin.getKey()+" " + tunedDetail;
+	}
+
+}

src/main/java/com/avaje/ebeaninternal/server/autofetch/package.html

@@ -0,0 +1,8 @@
+<html>
+<head>
+<title>AutoFetch Implementation</title>
+</head>
+<body>
+AutoFetch Implementation
+</body>
+</html>

src/main/java/com/avaje/ebeaninternal/server/bean/BFAutoFetchStatisticFinder.java

@@ -0,0 +1,79 @@
+package com.avaje.ebeaninternal.server.bean;
+
+import java.util.Iterator;
+
+import javax.persistence.PersistenceException;
+
+import com.avaje.ebean.bean.BeanCollection;
+import com.avaje.ebean.common.BeanList;
+import com.avaje.ebean.event.BeanFinder;
+import com.avaje.ebean.event.BeanQueryRequest;
+import com.avaje.ebean.meta.MetaAutoFetchStatistic;
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.api.SpiQuery;
+import com.avaje.ebeaninternal.server.autofetch.AutoFetchManager;
+import com.avaje.ebeaninternal.server.autofetch.Statistics;
+
+/**
+ * Bean Finder for MetaAutoFetchStatistic.
+ * <p>
+ * This gets the meta data from the AutoFetchManager and creates a copy of that
+ * data to give back to the caller in the form of MetaAutoFetchStatistic beans.
+ * </p>
+ */
+public class BFAutoFetchStatisticFinder implements BeanFinder<MetaAutoFetchStatistic> {
+
+
+	public MetaAutoFetchStatistic find(BeanQueryRequest<MetaAutoFetchStatistic> request) {
+		SpiQuery<MetaAutoFetchStatistic> query = (SpiQuery<MetaAutoFetchStatistic>)request.getQuery();
+		try {
+			String queryPointKey = (String) query.getId();
+
+			SpiEbeanServer server = (SpiEbeanServer) request.getEbeanServer();
+			AutoFetchManager manager = server.getAutoFetchManager();
+
+			Statistics stats = manager.getStatistics(queryPointKey);
+			if (stats != null) {
+				return stats.createPublicMeta();
+			} else {
+				return null;
+			}
+
+		} catch (Exception e) {
+			throw new PersistenceException(e);
+		}
+	}
+
+	/**
+	 * Only returns Lists at this stage.
+	 */
+	public BeanCollection<MetaAutoFetchStatistic> findMany(BeanQueryRequest<MetaAutoFetchStatistic> request) {
+
+		SpiQuery.Type queryType = ((SpiQuery<?>)request.getQuery()).getType();
+		if (!queryType.equals(SpiQuery.Type.LIST)) {
+			throw new PersistenceException("Only findList() supported at this stage.");
+		}
+
+		SpiEbeanServer server = (SpiEbeanServer) request.getEbeanServer();
+		AutoFetchManager manager = server.getAutoFetchManager();
+
+		BeanList<MetaAutoFetchStatistic> list = new BeanList<MetaAutoFetchStatistic>();
+
+		Iterator<Statistics> it = manager.iterateStatistics();
+		while (it.hasNext()) {
+			Statistics stats = it.next();
+			// create a copy for public use
+			list.add(stats.createPublicMeta());
+		}
+		
+		String orderBy = request.getQuery().order().toStringFormat();
+		if (orderBy == null){
+			orderBy = "beanType";
+		}
+		server.sort(list, orderBy);
+
+
+		return list;
+	}
+
+}

src/main/java/com/avaje/ebeaninternal/server/bean/BFAutoFetchTunedFetchFinder.java

@@ -0,0 +1,76 @@
+package com.avaje.ebeaninternal.server.bean;
+
+import java.util.Iterator;
+
+import javax.persistence.PersistenceException;
+
+import com.avaje.ebean.bean.BeanCollection;
+import com.avaje.ebean.common.BeanList;
+import com.avaje.ebean.event.BeanFinder;
+import com.avaje.ebean.event.BeanQueryRequest;
+import com.avaje.ebean.meta.MetaAutoFetchTunedQueryInfo;
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.api.SpiQuery;
+import com.avaje.ebeaninternal.server.autofetch.AutoFetchManager;
+import com.avaje.ebeaninternal.server.autofetch.TunedQueryInfo;
+
+/**
+ * BeanFinder for MetaAutoFetchTunedFetch.
+ */
+public class BFAutoFetchTunedFetchFinder implements BeanFinder<MetaAutoFetchTunedQueryInfo> {
+
+
+	public MetaAutoFetchTunedQueryInfo find(BeanQueryRequest<MetaAutoFetchTunedQueryInfo> request) {
+		
+		SpiQuery<?> query = (SpiQuery<?>)request.getQuery();
+		try {
+			String queryPointKey = (String)query.getId();
+			
+			SpiEbeanServer server = (SpiEbeanServer) request.getEbeanServer();
+			AutoFetchManager manager = server.getAutoFetchManager();
+	
+			TunedQueryInfo tunedFetch = manager.getTunedQueryInfo(queryPointKey);
+			if (tunedFetch != null){
+				return tunedFetch.createPublicMeta();
+			} else {
+				return null;
+			}
+			
+		} catch (Exception e){
+			throw new PersistenceException(e);
+		}
+	}
+
+	/**
+	 * Only returns Lists at this stage.
+	 */
+	public BeanCollection<MetaAutoFetchTunedQueryInfo> findMany(BeanQueryRequest<MetaAutoFetchTunedQueryInfo> request) {
+
+		SpiQuery.Type queryType = ((SpiQuery<?>)request.getQuery()).getType();
+		if (!queryType.equals(SpiQuery.Type.LIST)){
+			throw new PersistenceException("Only findList() supported at this stage.");
+		}
+		
+		SpiEbeanServer server = (SpiEbeanServer) request.getEbeanServer();
+		AutoFetchManager manager = server.getAutoFetchManager();
+		
+		BeanList<MetaAutoFetchTunedQueryInfo> list = new BeanList<MetaAutoFetchTunedQueryInfo>();
+		
+		Iterator<TunedQueryInfo> it = manager.iterateTunedQueryInfo();
+		while (it.hasNext()) {
+			TunedQueryInfo tunedFetch = it.next();
+			// create a copy for public use
+			list.add(tunedFetch.createPublicMeta());
+		}
+		
+		String orderBy = request.getQuery().order().toStringFormat();
+		if (orderBy == null){
+			orderBy = "beanType, origQueryPlanHash";
+		}
+		server.sort(list, orderBy);
+
+
+		return list;
+	}
+
+}

src/main/java/com/avaje/ebeaninternal/server/bean/BFQueryStatisticFinder.java

@@ -0,0 +1,69 @@
+package com.avaje.ebeaninternal.server.bean;
+
+import java.util.Iterator;
+import java.util.List;
+
+import javax.persistence.PersistenceException;
+
+import com.avaje.ebean.bean.BeanCollection;
+import com.avaje.ebean.common.BeanList;
+import com.avaje.ebean.event.BeanFinder;
+import com.avaje.ebean.event.BeanQueryRequest;
+import com.avaje.ebean.meta.MetaQueryStatistic;
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.api.SpiQuery;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
+import com.avaje.ebeaninternal.server.query.CQueryPlan;
+
+/**
+ * BeanFinder for MetaQueryStatistic.
+ */
+public class BFQueryStatisticFinder implements BeanFinder<MetaQueryStatistic> {
+
+	
+	public MetaQueryStatistic find(BeanQueryRequest<MetaQueryStatistic> request) {
+		throw new RuntimeException("Not Supported yet");
+	}
+
+	/**
+	 * Only returns Lists at this stage.
+	 */
+	public BeanCollection<MetaQueryStatistic> findMany(BeanQueryRequest<MetaQueryStatistic> request) {
+
+		SpiQuery.Type queryType = ((SpiQuery<?>)request.getQuery()).getType();
+		if (!queryType.equals(SpiQuery.Type.LIST)){
+			throw new PersistenceException("Only findList() supported at this stage.");
+		}
+		
+		BeanList<MetaQueryStatistic> list = new BeanList<MetaQueryStatistic>();
+		
+		SpiEbeanServer server = (SpiEbeanServer) request.getEbeanServer();
+		build(list, server);
+		
+		String orderBy = request.getQuery().order().toStringFormat();
+		if (orderBy == null){
+			orderBy = "beanType, origQueryPlanHash, autofetchTuned";
+		}
+		server.sort(list, orderBy);
+
+		return list;
+	}
+
+	private void build(List<MetaQueryStatistic> list, SpiEbeanServer server) {
+
+		for (BeanDescriptor<?> desc : server.getBeanDescriptors()) {
+			desc.clearQueryStatistics();			
+			build(list, desc);
+		}		
+	}
+	
+	private void build(List<MetaQueryStatistic> list, BeanDescriptor<?> desc) {
+
+		Iterator<CQueryPlan> it = desc.queryPlans();
+		while (it.hasNext()) {
+			CQueryPlan queryPlan = (CQueryPlan) it.next();
+			list.add(queryPlan.createMetaQueryStatistic(desc.getFullName()));
+		}
+	}
+	
+}

src/main/java/com/avaje/ebeaninternal/server/bean/package.html

@@ -0,0 +1,8 @@
+<html>
+<head>
+<title>BeanFinders, BeanControllers etc for "meta" beans</title>
+</head>
+<body>
+BeanFinders, BeanControllers etc for "meta" beans
+</body>
+</html>

src/main/java/com/avaje/ebeaninternal/server/cache/CachedBeanData.java

@@ -0,0 +1,50 @@
+package com.avaje.ebeaninternal.server.cache;
+
+import java.util.Set;
+
+public class CachedBeanData {
+
+	private final Object sharableBean;
+    private final Set<String> loadedProperties;
+    private final Object[] data;
+    private final int naturalKeyUpdate;
+    
+    public CachedBeanData(Object sharableBean, Set<String> loadedProperties, Object[] data, int naturalKeyUpdate) {
+        this.sharableBean = sharableBean;
+    	this.loadedProperties= loadedProperties;
+        this.data = data;
+        this.naturalKeyUpdate = naturalKeyUpdate;
+    }
+    
+    public Object getSharableBean() {
+    	return sharableBean;
+    }
+
+	public boolean isNaturalKeyUpdate() {
+    	return naturalKeyUpdate > -1;
+    }
+    
+    public Object getNaturalKey() {
+    	return data[naturalKeyUpdate];
+    }
+
+	public boolean containsProperty(String propName) {
+        return loadedProperties == null || loadedProperties.contains(propName);
+    }
+    
+    public Object getData(int i){
+        return data[i];
+    }
+    
+	public Set<String> getLoadedProperties() {
+    	return loadedProperties;
+    }
+    
+	public Object[] copyData() {
+		Object[] dest = new Object[data.length];
+		System.arraycopy(data, 0, dest, 0, data.length);
+		return dest;
+	}
+	
+}
+

src/main/java/com/avaje/ebeaninternal/server/cache/CachedBeanDataFromBean.java

@@ -0,0 +1,103 @@
+package com.avaje.ebeaninternal.server.cache;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import com.avaje.ebean.bean.EntityBean;
+import com.avaje.ebean.bean.EntityBeanIntercept;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
+import com.avaje.ebeaninternal.server.deploy.BeanProperty;
+
+public class CachedBeanDataFromBean {
+
+    private final BeanDescriptor<?> desc;
+    private final Object bean;
+    private final EntityBeanIntercept ebi;
+    
+    private final Set<String> loadedProps;
+    private final Set<String> extractProps;
+
+    public static CachedBeanData extract(BeanDescriptor<?> desc, Object bean){
+    	if (bean instanceof EntityBean){
+        	return new CachedBeanDataFromBean(desc, bean, ((EntityBean)bean)._ebean_getIntercept()).extract();    		
+    		
+    	} else {
+        	return new CachedBeanDataFromBean(desc, bean, null).extract();    		
+    	}
+    }
+    
+    public static CachedBeanData extract(BeanDescriptor<?> desc, Object bean, EntityBeanIntercept ebi){
+    	return new CachedBeanDataFromBean(desc, bean, ebi).extract();
+    }
+    
+    private CachedBeanDataFromBean(BeanDescriptor<?> desc, Object bean, EntityBeanIntercept ebi) {
+        this.desc = desc;
+        this.bean = bean;
+        this.ebi = ebi;        
+        if (ebi != null){
+        	this.loadedProps = ebi.getLoadedProps(); 
+        	this.extractProps = (loadedProps == null) ? null : new HashSet<String>();
+        } else {
+        	this.extractProps = new HashSet<String>();
+        	this.loadedProps = null;
+        }
+    }
+    
+    private CachedBeanData extract(){
+
+        BeanProperty[] props = desc.propertiesNonMany();
+
+    	Object[] data = new Object[props.length];
+    	
+    	int naturalKeyUpdate = -1;
+        for (int i = 0; i < props.length; i++) {
+        	BeanProperty prop  = props[i];
+            if (includeNonManyProperty(prop.getName())){
+            	
+            	data[i] = prop.getCacheDataValue(bean);
+            	if (prop.isNaturalKey()) {
+            		naturalKeyUpdate = i;
+            	}
+            	if (ebi != null){
+            		if (extractProps != null){
+            			extractProps.add(prop.getName());
+            		}
+            	} else if (data[i] != null){
+            		if (extractProps != null){
+            			extractProps.add(prop.getName());
+            		}
+            	}
+            }
+        }
+        
+        Object sharableBean = null;
+        if (desc.isCacheSharableBeans() && ebi != null && loadedProps == null){
+        	if (ebi.isReadOnly()){
+        		sharableBean = bean;
+        	} else {
+        		// create a readOnly sharable instance by copying the data
+        		sharableBean = desc.createBean(false);
+        		BeanProperty[] propertiesId = desc.propertiesId();
+        		for (int i = 0; i < propertiesId.length; i++) {
+        			Object v = propertiesId[i].getValue(bean);
+        			propertiesId[i].setValue(sharableBean, v);
+                }
+        		BeanProperty[] propertiesNonTransient = desc.propertiesNonTransient();
+        		for (int i = 0; i < propertiesNonTransient.length; i++) {
+        			Object v = propertiesNonTransient[i].getValue(bean);
+        			propertiesNonTransient[i].setValue(sharableBean, v);
+                }
+        		EntityBeanIntercept ebi = ((EntityBean)sharableBean)._ebean_intercept();
+        		ebi.setReadOnly(true);
+        		ebi.setLoaded();
+        	}
+        }
+        
+        return new CachedBeanData(sharableBean, extractProps, data, naturalKeyUpdate);
+    }
+    
+    private boolean includeNonManyProperty(String name) {
+    	return loadedProps == null || loadedProps.contains(name);
+    }
+    
+}

src/main/java/com/avaje/ebeaninternal/server/cache/CachedBeanDataToBean.java

@@ -0,0 +1,117 @@
+package com.avaje.ebeaninternal.server.cache;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import com.avaje.ebean.bean.EntityBean;
+import com.avaje.ebean.bean.EntityBeanIntercept;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
+import com.avaje.ebeaninternal.server.deploy.BeanProperty;
+import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocMany;
+
+public class CachedBeanDataToBean {
+
+    private final BeanDescriptor<?> desc;
+    private final Object bean;
+    private final EntityBeanIntercept ebi;
+    private final CachedBeanData cacheBeandata;
+    private final Set<String> cacheLoadedProperties;
+    private final Set<String> loadedProps;
+    
+    private final Set<String> excludeProps;
+    private final Object oldValuesBean;
+    private final boolean readOnly;
+
+    public static void load(BeanDescriptor<?> desc, Object bean, CachedBeanData cacheBeandata) {
+    	if (bean instanceof EntityBean){
+    	    load(desc, bean, ((EntityBean)bean)._ebean_getIntercept(), cacheBeandata);
+    	} else {
+    	    load(desc, bean, null, cacheBeandata);
+    	}
+    }
+
+    public static void load(BeanDescriptor<?> desc, Object bean, EntityBeanIntercept ebi, CachedBeanData cacheBeandata) {
+    	new CachedBeanDataToBean(desc, bean, ebi, cacheBeandata).load();
+    }
+    
+    private CachedBeanDataToBean(BeanDescriptor<?> desc, Object bean, EntityBeanIntercept ebi, CachedBeanData cacheBeandata) {
+        this.desc = desc;
+        this.bean = bean;
+        this.ebi = ebi;
+        this.cacheBeandata = cacheBeandata;
+        this.cacheLoadedProperties = cacheBeandata.getLoadedProperties();
+        this.loadedProps = (cacheLoadedProperties == null) ? null : new HashSet<String>();
+       
+        if (ebi != null){
+        	this.excludeProps = ebi.getLoadedProps(); 
+        	this.oldValuesBean = ebi.getOldValues();
+        	this.readOnly = ebi.isReadOnly();
+        } else {
+        	this.excludeProps = null;
+        	this.oldValuesBean = null;
+        	this.readOnly = false;
+        }
+    }
+    
+    private boolean load(){
+        
+        BeanProperty[] propertiesNonTransient = desc.propertiesNonMany();
+        for (int i = 0; i < propertiesNonTransient.length; i++) {
+            BeanProperty prop = propertiesNonTransient[i];
+            if (includeNonManyProperty(prop.getName())){
+            	Object data = cacheBeandata.getData(i);
+                prop.setCacheDataValue(bean, data, oldValuesBean, readOnly);
+            }
+        }
+        BeanPropertyAssocMany<?>[] manys = desc.propertiesMany();
+		for (int i = 0; i < manys.length; i++) {
+			BeanPropertyAssocMany<?> prop = manys[i];
+			if (includeManyProperty(prop.getName())){
+				// set a lazy loading proxy
+				prop.createReference(bean);				
+			}
+		}
+        
+        if (ebi != null){
+        	if (loadedProps == null){
+            	ebi.setLoadedProps(null);
+        	} else {
+            	HashSet<String> mergeProps = new HashSet<String>();
+            	if (excludeProps != null) {
+            		mergeProps.addAll(excludeProps);
+            	}
+        		mergeProps.addAll(loadedProps);
+            	ebi.setLoadedProps(mergeProps);
+        	}   
+        	ebi.setLoadedLazy();
+        }
+
+        return true;
+    }
+    
+    private boolean includeManyProperty(String name) {
+        if (excludeProps != null && excludeProps.contains(name)){
+            // ignore this property (partial bean lazy loading)
+            return false;
+        }
+        if (loadedProps != null){
+            loadedProps.add(name);
+        }
+        return true;
+    }
+    
+    private boolean includeNonManyProperty(String name) {
+        if (excludeProps != null && excludeProps.contains(name)){
+            // ignore this property (partial bean lazy loading)
+            return false;
+        }
+        if (cacheLoadedProperties != null && !cacheLoadedProperties.contains(name)){
+            return false;
+        }
+        if (loadedProps != null){
+            loadedProps.add(name);
+        }
+        return true;
+    }
+    
+}

src/main/java/com/avaje/ebeaninternal/server/cache/CachedBeanDataUpdate.java

@@ -0,0 +1,49 @@
+package com.avaje.ebeaninternal.server.cache;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import com.avaje.ebeaninternal.server.core.PersistRequestBean;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
+import com.avaje.ebeaninternal.server.deploy.BeanProperty;
+
+public class CachedBeanDataUpdate {
+
+    public static CachedBeanData update(BeanDescriptor<?> desc, CachedBeanData data, PersistRequestBean<?> updateRequest){
+
+    	
+    	Set<String> loadedProperties = data.getLoadedProperties();
+    	Object[] copyOfData = data.copyData();
+    	
+    	Object updateBean = updateRequest.getBean();
+    	Set<String> updatedProperties = updateRequest.getUpdatedProperties();
+    	
+    	int naturalKeyUpdate = -1;
+    	boolean mergeProperties = false;
+    	BeanProperty[] props = desc.propertiesNonMany();
+    	for (int i = 0; i < props.length; i++) {
+	        if (updatedProperties.contains(props[i].getName())){
+	        	if (props[i].isNaturalKey()){
+	        		naturalKeyUpdate = i;
+	        	}
+	        	copyOfData[i] = props[i].getCacheDataValue(updateBean);
+	        	if (loadedProperties != null && !mergeProperties && !loadedProperties.contains(props[i].getName())){
+	        		mergeProperties = true;
+	        	}
+	        }
+        }
+    	
+    	if (mergeProperties){
+    		HashSet<String> mergeProps = new HashSet<String>();
+    		mergeProps.addAll(loadedProperties);
+    		mergeProps.addAll(updatedProperties);
+    		loadedProperties = mergeProps;
+    	}
+    	
+    	return new CachedBeanData(null, loadedProperties, copyOfData, naturalKeyUpdate);
+        
+    }
+    
+    
+
+}

src/main/java/com/avaje/ebeaninternal/server/cache/CachedManyIds.java

@@ -0,0 +1,17 @@
+package com.avaje.ebeaninternal.server.cache;
+
+import java.util.List;
+
+public class CachedManyIds {
+
+	private final List<Object> idList;
+	
+	public CachedManyIds(List<Object> idList) {
+		this.idList = idList;
+	}
+
+	public List<Object> getIdList() {
+    	return idList;
+    }
+
+}

src/main/java/com/avaje/ebeaninternal/server/cache/DefaultCacheHolder.java

@@ -0,0 +1,123 @@
+package com.avaje.ebeaninternal.server.cache;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.concurrent.ConcurrentHashMap;
+
+import com.avaje.ebean.annotation.CacheTuning;
+import com.avaje.ebean.cache.ServerCache;
+import com.avaje.ebean.cache.ServerCacheFactory;
+import com.avaje.ebean.cache.ServerCacheOptions;
+
+/**
+ * Manages the construction of caches.
+ */
+public class DefaultCacheHolder {
+
+	private final ConcurrentHashMap<String, ServerCache> concMap = new ConcurrentHashMap<String, ServerCache>();
+
+	private final HashMap<String, ServerCache> synchMap = new HashMap<String, ServerCache>();
+
+	private final Object monitor = new Object();
+
+	private final ServerCacheFactory cacheFactory;
+
+	private final ServerCacheOptions defaultOptions;
+
+	private final boolean useBeanTuning;
+
+	/**
+	 * Create with a cache factory and default cache options.
+	 * 
+	 * @param cacheFactory
+	 *            the factory for creating the cache
+	 * @param defaultOptions
+	 *            the default options for tuning the cache
+	 * @param useBeanTuning
+	 *            if true then use the bean class specific tuning. This is
+	 *            generally false for the query cache.
+	 */
+	public DefaultCacheHolder(ServerCacheFactory cacheFactory,
+			ServerCacheOptions defaultOptions, boolean useBeanTuning) {
+
+		this.cacheFactory = cacheFactory;
+		this.defaultOptions = defaultOptions;
+		this.useBeanTuning = useBeanTuning;
+	}
+
+	/**
+	 * Return the default cache options.
+	 */
+	public ServerCacheOptions getDefaultOptions() {
+		return defaultOptions;
+	}
+
+	/**
+	 * Return the cache for a given bean type.
+	 */
+	public ServerCache getCache(String cacheKey) {
+
+		ServerCache cache = concMap.get(cacheKey);
+		if (cache != null) {
+			return cache;
+		}
+		synchronized (monitor) {
+			cache = synchMap.get(cacheKey);
+			if (cache == null) {
+				ServerCacheOptions options = getCacheOptions(cacheKey);
+				cache = cacheFactory.createCache(cacheKey, options);
+				synchMap.put(cacheKey, cache);
+				concMap.put(cacheKey, cache);
+			}
+			return cache;
+		}
+	}
+
+	public void clearCache(String cacheKey) {
+
+		ServerCache cache = concMap.get(cacheKey);
+		if (cache != null) {
+			cache.clear();
+		}
+	}
+	
+	/**
+	 * Return true if there is an active cache for this bean type.
+	 */
+	public boolean isCaching(String beanType) {
+		return concMap.containsKey(beanType);
+	}
+
+	public void clearAll() {
+		Iterator<ServerCache> it = concMap.values().iterator();
+		while (it.hasNext()) {
+			ServerCache serverCache = it.next();
+			serverCache.clear();
+		}
+	}
+
+	/**
+	 * Return the cache options for a given bean type.
+	 */
+	private ServerCacheOptions getCacheOptions(String beanType) {
+
+		if (useBeanTuning) {
+			// read the deployment annotation
+			try {
+				Class<?> cls = Class.forName(beanType);
+				CacheTuning cacheTuning = cls.getAnnotation(CacheTuning.class);
+				if (cacheTuning != null) {
+					ServerCacheOptions o = new ServerCacheOptions(cacheTuning);
+					o.applyDefaults(defaultOptions);
+					return o;
+				}
+			} catch (ClassNotFoundException e){
+				// ignore
+			}
+		}
+
+		return defaultOptions.copy();
+
+	}
+
+}

src/main/java/com/avaje/ebeaninternal/server/cache/DefaultServerCache.java

@@ -0,0 +1,407 @@
+package com.avaje.ebeaninternal.server.cache;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import com.avaje.ebean.BackgroundExecutor;
+import com.avaje.ebean.EbeanServer;
+import com.avaje.ebean.cache.ServerCache;
+import com.avaje.ebean.cache.ServerCacheOptions;
+import com.avaje.ebean.cache.ServerCacheStatistics;
+
+
+/**
+ * The default cache implementation.
+ * <p>
+ * It is base on ConcurrentHashMap with periodic trimming using a TimerTask.
+ * The periodic trimming means that an LRU list does not have to be maintained.
+ * </p>
+ */
+public class DefaultServerCache implements ServerCache {
+
+	private static final Logger logger = Logger.getLogger(DefaultServerCache.class.getName());
+
+	private static final CacheEntryComparator comparator = new CacheEntryComparator();
+		
+	private final ConcurrentHashMap<Object, CacheEntry> map = new ConcurrentHashMap<Object, CacheEntry>();
+
+	private final AtomicInteger missCount = new AtomicInteger();
+	
+	private final AtomicInteger removedHitCount = new AtomicInteger();
+	
+	private final Object monitor = new Object();
+
+	private final String name;
+
+	private int maxSize;
+
+	private long trimFrequency;
+
+	private int maxIdleSecs;
+
+	private int maxSecsToLive;
+
+	public DefaultServerCache(String name, ServerCacheOptions options) {
+		this(name, options.getMaxSize(), options.getMaxIdleSecs(), options.getMaxSecsToLive());
+	}
+
+	public DefaultServerCache(String name, int maxSize, int maxIdleSecs, int maxSecsToLive) {
+		this.name = name;
+		this.maxSize = maxSize;
+		this.maxIdleSecs = maxIdleSecs;
+		this.maxSecsToLive = maxSecsToLive;
+		this.trimFrequency = 60;
+
+	}
+	
+	public void init(EbeanServer server) {
+		
+		TrimTask trim = new TrimTask();
+		
+		BackgroundExecutor executor = server.getBackgroundExecutor();
+		executor.executePeriodically(trim, trimFrequency, TimeUnit.SECONDS);
+	}
+	
+	
+	
+	
+	public ServerCacheStatistics getStatistics(boolean reset) {
+
+		ServerCacheStatistics s = new ServerCacheStatistics();
+		s.setCacheName(name);
+		s.setMaxSize(maxSize);
+
+		// these counters won't necessarily be consistent with
+		// respect to each other as activity can occur while
+		// they are being calculated
+		int mc = reset ? missCount.getAndSet(0) : missCount.get();
+		int hc = getHitCount(reset);
+		int size = size();
+		
+		s.setSize(size);
+		s.setHitCount(hc);
+		s.setMissCount(mc);
+		
+		return s;
+	}
+	
+	public int getHitRatio() {
+
+		int mc = missCount.get();
+		int hc = getHitCount(false);
+		
+		int totalCount = hc + mc;
+		if (totalCount == 0){
+			return 0;
+		} else {
+			return hc * 100 / totalCount;
+		}
+
+	}
+	
+	private int getHitCount(boolean reset) {
+		
+		int hc = reset ? removedHitCount.getAndSet(0) : removedHitCount.get();
+		
+		Iterator<CacheEntry> it = map.values().iterator();
+		while (it.hasNext()) {
+			CacheEntry cacheEntry = it.next();
+			hc += cacheEntry.getHitCount(reset);
+		}
+		
+		return hc;
+	}
+
+
+	public ServerCacheOptions getOptions() {
+		synchronized (monitor) {
+			ServerCacheOptions o = new ServerCacheOptions();
+			o.setMaxIdleSecs(maxIdleSecs);
+			o.setMaxSize(maxSize);
+			o.setMaxSecsToLive(maxSecsToLive);
+			return o;
+		}
+	}
+	
+	public void setOptions(ServerCacheOptions o) {
+		synchronized (monitor) {
+			maxIdleSecs = o.getMaxIdleSecs();
+			maxSize = o.getMaxSize();
+			maxSecsToLive = o.getMaxSecsToLive();
+		}
+	}
+	
+	
+	/**
+	 * Return the max cache size.
+	 */
+	public int getMaxSize() {
+		return maxSize;
+	}
+
+	/**
+	 * Set the max cache size.
+	 */
+	public void setMaxSize(int maxSize) {
+		synchronized (monitor) {
+			this.maxSize = maxSize;
+		}
+	}
+
+	/**
+	 * Return the max idle time.
+	 */
+	public long getMaxIdleSecs() {
+		return maxIdleSecs;
+	}
+
+	/**
+	 * Set the max idle time.
+	 */
+	public void setMaxIdleSecs(int maxIdleSecs) {
+		synchronized (monitor) {
+			this.maxIdleSecs = maxIdleSecs;
+		}
+	}
+
+	/**
+	 * Return the maximum time to live.
+	 */
+	public long getMaxSecsToLive() {
+		return maxSecsToLive;
+	}
+
+	/**
+	 * Set the maximum time to live.
+	 */
+	public void setMaxSecsToLive(int maxSecsToLive) {
+		synchronized (monitor) {
+			this.maxSecsToLive = maxSecsToLive;
+		}
+	}
+	
+	/**
+	 * Return the name of the cache.
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * Clear the cache.
+	 */
+	public void clear() {
+		map.clear();
+	}
+
+	/**
+	 * Return a value from the cache.
+	 */
+	public Object get(Object key) {
+		
+		CacheEntry entry = map.get(key);
+		
+		if (entry == null){
+			missCount.incrementAndGet();
+			return null;
+			
+		} else {
+			// get value incrementing last 
+			// access time and hitCount
+			return entry.getValue();
+		}
+	}
+
+	/**
+	 * Put a value into the cache.
+	 */
+	public Object put(Object key, Object value) {
+		// put new entry with create time
+		CacheEntry entry = map.put(key, new CacheEntry(key, value));
+		if (entry == null){
+			return null;
+		} else {
+			int removedHits = entry.getHitCount(true);
+			removedHitCount.addAndGet(removedHits);
+			return entry.getValue();
+		}
+	}
+
+	/**
+	 * Put a value into the cache but only if absent.
+	 */
+	public Object putIfAbsent(Object key, Object value) {
+		CacheEntry entry = map.putIfAbsent(key, new CacheEntry(key, value));
+		if (entry == null){
+			return null;
+		} else {
+			return entry.getValue();
+		}
+	}
+
+	/**
+	 * Remove an entry from the cache.
+	 */
+	public Object remove(Object key) {
+		CacheEntry entry = map.remove(key);
+		if (entry == null){
+			return null;
+		} else {
+			int removedHits = entry.getHitCount(true);
+			removedHitCount.addAndGet(removedHits);
+			return entry.getValue();
+		}
+	}
+
+	/**
+	 * Return the number of elements in the cache.
+	 */
+	public int size() {
+		return map.size();
+	}
+
+	private Iterator<CacheEntry> cacheEntries() {
+		return map.values().iterator();
+	}
+
+	/**
+	 * The task used to periodically trim the cache.
+	 */
+	private class TrimTask implements Runnable {
+
+		public void run() {
+
+			long startTime = System.currentTimeMillis();
+			
+			if (logger.isLoggable(Level.FINER)){
+				logger.finer("trimming cache " + name);
+			}
+			
+			int trimmedByIdle = 0;
+			int trimmedByTTL = 0;
+			int trimmedByLRU = 0;
+
+			boolean trimMaxSize = maxSize > 0 && maxSize < size();
+
+			ArrayList<CacheEntry> activeList = new ArrayList<CacheEntry>();
+
+			long idleExpire = System.currentTimeMillis() - (maxIdleSecs*1000);
+			long ttlExpire = System.currentTimeMillis() - (maxSecsToLive*1000);
+
+			Iterator<CacheEntry> it = cacheEntries();
+			while (it.hasNext()) {
+				CacheEntry cacheEntry = it.next();
+				if (maxIdleSecs > 0 && idleExpire > cacheEntry.getLastAccessTime()) {
+					it.remove();
+					trimmedByIdle++;
+
+				} else if (maxSecsToLive > 0 && ttlExpire > cacheEntry.getCreateTime()) {
+					it.remove();
+					trimmedByTTL++;
+
+				} else if (trimMaxSize) {
+					activeList.add(cacheEntry);
+				}
+			}
+
+			if (trimMaxSize) {
+				trimmedByLRU = activeList.size() - maxSize;
+
+				if (trimmedByLRU > 0) {
+					// sort into last access time ascending
+					Collections.sort(activeList, comparator);
+					for (int i = maxSize; i < activeList.size(); i++) {
+						// remove if still in the cache
+						map.remove(activeList.get(i).getKey());
+					}
+				}
+			}
+			
+			long exeTime = System.currentTimeMillis() - startTime;
+			
+			if (logger.isLoggable(Level.FINE)){
+				logger.fine("Executed trim of cache " + name + " in ["+exeTime
+					+"]millis  idle[" + trimmedByIdle + "] timeToLive[" 
+					+ trimmedByTTL + "] accessTime["
+					+ trimmedByLRU + "]");
+			}
+
+		}
+
+	}
+
+	/**
+	 * Comparator for sorting by last access time.
+	 */
+	private static class CacheEntryComparator implements Comparator<CacheEntry>, Serializable {
+
+		private static final long serialVersionUID = 1L;
+
+		public int compare(CacheEntry o1, CacheEntry o2) {
+			
+			return o1.getLastAccessLong().compareTo(o2.getLastAccessLong());
+		}
+	}
+	
+	/**
+	 * Wraps the values to additionally hold createTime and lastAccessTime.
+	 */
+	public static class CacheEntry {
+
+		private final Object key;
+		private final Object value;
+		private final long createTime;
+		private final AtomicInteger hitCount = new AtomicInteger();
+		private Long lastAccessTime;
+
+		public CacheEntry(Object key, Object value) {
+			this.key = key;
+			this.value = value;
+			this.createTime = System.currentTimeMillis();
+			this.lastAccessTime = Long.valueOf(createTime);
+		}
+
+		public Object getKey() {
+			return key;
+		}
+
+		public Object getValue() {
+			// object assignment is atomic
+			hitCount.incrementAndGet();
+			this.lastAccessTime = Long.valueOf(System.currentTimeMillis());
+			return value;
+		}
+
+		public long getCreateTime() {
+			return createTime;
+		}
+
+		public long getLastAccessTime() {
+			return lastAccessTime.longValue();
+		}
+
+		public Long getLastAccessLong() {
+			return lastAccessTime;
+		}
+
+		public int getHitCount(boolean reset) {
+			if (reset){
+				return hitCount.getAndSet(0);
+
+			} else {
+				return hitCount.get();				
+			}
+		}
+		public int getHitCount() {
+			return hitCount.get();
+		}
+	}
+}

src/main/java/com/avaje/ebeaninternal/server/cache/DefaultServerCacheFactory.java

@@ -0,0 +1,27 @@
+package com.avaje.ebeaninternal.server.cache;
+
+import com.avaje.ebean.EbeanServer;
+import com.avaje.ebean.cache.ServerCache;
+import com.avaje.ebean.cache.ServerCacheFactory;
+import com.avaje.ebean.cache.ServerCacheOptions;
+
+
+/**
+ * Default implementation of ServerCacheFactory.
+ */
+public class DefaultServerCacheFactory implements ServerCacheFactory {
+
+	private EbeanServer ebeanServer;
+	
+	public void init(EbeanServer ebeanServer){
+		this.ebeanServer = ebeanServer;
+	}
+	
+	public ServerCache createCache(String cacheKey, ServerCacheOptions cacheOptions) {
+		
+		ServerCache cache =  new DefaultServerCache(cacheKey, cacheOptions);	
+		cache.init(ebeanServer);
+		return cache;
+	}
+	
+}

src/main/java/com/avaje/ebeaninternal/server/cache/DefaultServerCacheManager.java

@@ -0,0 +1,112 @@
+package com.avaje.ebeaninternal.server.cache;
+
+import com.avaje.ebean.EbeanServer;
+import com.avaje.ebean.cache.ServerCache;
+import com.avaje.ebean.cache.ServerCacheFactory;
+import com.avaje.ebean.cache.ServerCacheManager;
+import com.avaje.ebean.cache.ServerCacheOptions;
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+
+
+/**
+ * Manages the bean and query caches. 
+ */
+public class DefaultServerCacheManager implements ServerCacheManager {
+
+	private final DefaultCacheHolder beanCache;
+
+	private final DefaultCacheHolder queryCache;
+
+	private final DefaultCacheHolder naturalKeyCache;
+
+	private final DefaultCacheHolder collectionIdsCache;
+
+	private final ServerCacheFactory cacheFactory;
+	
+	private SpiEbeanServer ebeanServer;
+	
+	/**
+	 * Create with a cache factory and default cache options.
+	 */
+	public DefaultServerCacheManager(ServerCacheFactory cacheFactory, ServerCacheOptions defaultBeanOptions, ServerCacheOptions defaultQueryOptions) {
+		this.cacheFactory = cacheFactory;
+		this.beanCache = new DefaultCacheHolder(cacheFactory, defaultBeanOptions, true);
+		this.queryCache = new DefaultCacheHolder(cacheFactory, defaultQueryOptions, false);
+		this.naturalKeyCache = new DefaultCacheHolder(cacheFactory, defaultQueryOptions, false);
+		this.collectionIdsCache = new DefaultCacheHolder(cacheFactory, defaultQueryOptions, false);
+	}	
+			
+	public void init(EbeanServer server) {
+		cacheFactory.init(server);
+		this.ebeanServer = (SpiEbeanServer)server;
+	}
+	
+    public void setCaching(Class<?> beanType, boolean useCache) {
+		ebeanServer.getBeanDescriptor(beanType).getCacheOptions().setUseCache(useCache);
+    }
+
+	/**
+	 * Clear both the bean cache and the query cache for a 
+	 * given bean type.
+	 */
+	public void clear(Class<?> beanType) {
+		String beanName = beanType.getName();
+		beanCache.clearCache(beanName);
+		naturalKeyCache.clearCache(beanName);
+		collectionIdsCache.clearCache(beanName);
+		queryCache.clearCache(beanName);
+	}
+
+
+	public void clearAll() {
+		beanCache.clearAll();
+		queryCache.clearAll();
+		naturalKeyCache.clearAll();
+		collectionIdsCache.clearAll();
+	}
+
+	
+    public ServerCache getCollectionIdsCache(Class<?> beanType, String propertyName) {
+	    return collectionIdsCache.getCache(beanType.getName()+"."+propertyName);
+    }
+
+	public boolean isCollectionIdsCaching(Class<?> beanType) {
+		return collectionIdsCache.isCaching(beanType.getName());
+	}
+	
+	public ServerCache getNaturalKeyCache(Class<?> beanType) {
+	    return naturalKeyCache.getCache(beanType.getName());
+    }
+	
+	public boolean isNaturalKeyCaching(Class<?> beanType) {
+		return naturalKeyCache.isCaching(beanType.getName());
+	}
+	
+	/**
+	 * Return the query cache for a given bean type.
+	 */
+	public ServerCache getQueryCache(Class<?> beanType) {
+		return queryCache.getCache(beanType.getName());
+	}
+	
+	/**
+	 * Return the bean cache for a given bean type.
+	 */
+	public ServerCache getBeanCache(Class<?> beanType) {
+		return beanCache.getCache(beanType.getName());
+	}
+
+	/**
+	 * Return true if there is an active cache for the given bean type.
+	 */
+	public boolean isBeanCaching(Class<?> beanType) {
+		return beanCache.isCaching(beanType.getName());
+	}
+
+
+	public boolean isQueryCaching(Class<?> beanType) {
+		return queryCache.isCaching(beanType.getName());
+	}
+	
+
+}

src/main/java/com/avaje/ebeaninternal/server/cache/package-info.java

@@ -0,0 +1,4 @@
+/**
+ * Default L2 server cache implementation.
+ */
+package com.avaje.ebeaninternal.server.cache;

src/main/java/com/avaje/ebeaninternal/server/cluster/BinaryMessage.java

@@ -0,0 +1,83 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster;
+
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+
+/**
+ * Represents a relatively small independent message.
+ * <p>
+ * In general terms we break up a potentially large object like
+ * RemoteTransactionEvent into many smaller BinaryMessages. This is so that if
+ * they don't all fit on a single Packet we can easily break them up and put
+ * them on multiple packets.
+ * </p>
+ * <p>
+ * Also note that for the Multicast approach a Packet will generally contain
+ * many messages each directed to different members of the cluster. So it would
+ * be common for many Ack, Resend and Control messages to all be contained in a
+ * single packet.
+ * </p>
+ * 
+ * @author rbygrave
+ * 
+ */
+public class BinaryMessage {
+
+    public static final int TYPE_MSGCONTROL = 0;
+    public static final int TYPE_BEANIUD = 1;
+    public static final int TYPE_TABLEIUD = 2;
+    public static final int TYPE_BEANDELTA = 3;
+    public static final int TYPE_BEANPATHUPDATE = 4;
+    public static final int TYPE_INDEX_INVALIDATE = 6;
+    public static final int TYPE_INDEX = 7;
+    public static final int TYPE_MSGACK = 8;
+    public static final int TYPE_MSGRESEND = 9;
+
+    private final ByteArrayOutputStream buffer;
+    private final DataOutputStream os;
+    private byte[] bytes;
+
+    /**
+     * Create with an estimated buffer size.
+     */
+    public BinaryMessage(int bufSize) {
+        this.buffer = new ByteArrayOutputStream(bufSize);
+        this.os = new DataOutputStream(buffer);
+    }
+
+    /**
+     * Return the DataOutputStream to write content to.
+     */
+    public DataOutputStream getOs() {
+        return os;
+    }
+
+    /**
+     * Return all the content as a byte array.
+     */
+    public byte[] getByteArray() {
+        if (bytes == null) {
+            bytes = buffer.toByteArray();
+        }
+        return bytes;
+    }
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/BinaryMessageList.java

@@ -0,0 +1,42 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Holds a List of BinaryMessage's.
+ * 
+ * @author rbygrave
+ */
+public class BinaryMessageList {
+
+    ArrayList<BinaryMessage> list = new ArrayList<BinaryMessage>();
+    
+    public void add(BinaryMessage msg) {
+        list.add(msg);
+    }
+
+    public List<BinaryMessage> getList() {
+        return list;
+    }
+    
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/ClusterBroadcast.java

@@ -0,0 +1,45 @@
+/**
+ *  Copyright (C) 2006  Robin Bygrave
+ *  
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *  
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *  
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+package com.avaje.ebeaninternal.server.cluster;
+
+import com.avaje.ebeaninternal.server.transaction.RemoteTransactionEvent;
+
+
+/**
+ * Sends messages to the cluster members.
+ */
+public interface ClusterBroadcast {
+
+    /**
+     * Inform the other cluster members that this instance has come online and
+     * start any listeners etc.
+     */
+    public void startup(ClusterManager clusterManager);
+
+    /**
+     * Inform the other cluster members that this instance is leaving and
+     * shutdown any listeners.
+     */
+    public void shutdown();
+    
+    /**
+     * Send a transaction event to all the members of the cluster.
+     */
+    public void broadcast(RemoteTransactionEvent remoteTransEvent);
+
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/ClusterManager.java

@@ -0,0 +1,122 @@
+/**
+ *  Copyright (C) 2006  Robin Bygrave
+ *  
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *  
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *  
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+package com.avaje.ebeaninternal.server.cluster;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import com.avaje.ebean.EbeanServer;
+import com.avaje.ebean.config.GlobalProperties;
+import com.avaje.ebeaninternal.api.ClassUtil;
+import com.avaje.ebeaninternal.server.cluster.mcast.McastClusterManager;
+import com.avaje.ebeaninternal.server.cluster.socket.SocketClusterBroadcast;
+import com.avaje.ebeaninternal.server.transaction.RemoteTransactionEvent;
+
+/**
+ * Manages the cluster service.
+ */
+public class ClusterManager {
+
+  private static final Logger logger = Logger.getLogger(ClusterManager.class.getName());
+
+  private final ConcurrentHashMap<String, EbeanServer> serverMap = new ConcurrentHashMap<String, EbeanServer>();
+
+  private final Object monitor = new Object();
+
+  private final ClusterBroadcast broadcast;
+
+  private boolean started;
+
+  public ClusterManager() {
+
+    String clusterType = GlobalProperties.get("ebean.cluster.type", null);
+    if (clusterType == null || clusterType.trim().length() == 0) {
+      // not clustering this instance
+      this.broadcast = null;
+
+    } else {
+
+      try {
+        if ("mcast".equalsIgnoreCase(clusterType)) {
+          this.broadcast = new McastClusterManager();
+
+        } else if ("socket".equalsIgnoreCase(clusterType)) {
+          this.broadcast = new SocketClusterBroadcast();
+
+        } else {
+          logger.info("Clustering using [" + clusterType + "]");
+          this.broadcast = (ClusterBroadcast) ClassUtil.newInstance(clusterType);
+        }
+
+      } catch (Exception e) {
+        String msg = "Error initialising ClusterManager type [" + clusterType + "]";
+        logger.log(Level.SEVERE, msg, e);
+        throw new RuntimeException(e);
+      }
+    }
+  }
+
+  public void registerServer(EbeanServer server) {
+    synchronized (monitor) {
+      if (!started) {
+        startup();
+      }
+      serverMap.put(server.getName(), server);
+    }
+  }
+
+  public EbeanServer getServer(String name) {
+    synchronized (monitor) {
+      return serverMap.get(name);
+    }
+  }
+
+  private void startup() {
+    started = true;
+    if (broadcast != null) {
+      broadcast.startup(this);
+    }
+  }
+
+  /**
+   * Return true if clustering is on.
+   */
+  public boolean isClustering() {
+    return broadcast != null;
+  }
+
+  /**
+   * Send the message headers and payload to every server in the cluster.
+   */
+  public void broadcast(RemoteTransactionEvent remoteTransEvent) {
+    if (broadcast != null) {
+      broadcast.broadcast(remoteTransEvent);
+    }
+  }
+
+  /**
+   * Shutdown the service and Deregister from the cluster.
+   */
+  public void shutdown() {
+    if (broadcast != null) {
+      logger.info("ClusterManager shutdown ");
+      broadcast.shutdown();
+    }
+  }
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/DataHolder.java

@@ -0,0 +1,43 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster;
+
+import java.io.Serializable;
+
+/**
+ * Simple holder of binary data.
+ * Used to use Packet based serialisation of RemoteTransactionEvent
+ * with simple Java Serialisation of the DataHolder.
+ */
+public class DataHolder implements Serializable {
+
+    private static final long serialVersionUID = 9090748723571322192L;
+
+    private final byte[] data;
+    
+    public DataHolder(byte[] data) {
+        this.data = data;
+    }
+
+    public byte[] getData() {
+        return data;
+    }
+    
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/Packet.java

@@ -0,0 +1,212 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster;
+
+import java.io.ByteArrayOutputStream;
+import java.io.DataInput;
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+/**
+ * Represents the contents sent as a single DatagramPacket.
+ * <p>
+ * The contents is typically multiple messages (ACK,PING etc) or all or part of
+ * a RemoteTransactionEvent.
+ * </p>
+ * <p>
+ * Due to the hard limit on the size of UDP packets a RemoteTransactionEvent
+ * with lots of information could be broken up into multiple packets.
+ * </p>
+ * 
+ * @author rbygrave
+ */
+public class Packet {
+    
+    /**
+     * A Packet that holds protocol messages like ACK, PING etc. 
+     */
+    public static final short TYPE_MESSAGES = 1;
+    
+    /**
+     * A Packet that holds TransactionEvent information such as Bean
+     * and or Table IUD information.
+     */
+    public static final short TYPE_TRANSEVENT = 2;
+
+    /**
+     * The type of Packet.
+     */
+    protected short packetType;
+    
+    /**
+     * The PacketId.
+     */
+    protected long packetId;
+    
+    /**
+     * The timestamp the Packet was created.
+     */
+    protected long timestamp;
+    
+    /**
+     * The EbeanServer name this relates to if relevant.
+     */
+    protected String serverName;
+    
+    protected ByteArrayOutputStream buffer;
+    protected DataOutputStream dataOut;
+    protected byte[] bytes;
+    
+    /**
+     * The number of messages in this Packet.
+     */
+    private int messageCount;
+    
+    /**
+     * The number of times this Packet was resent.
+     */
+    private int resendCount;
+
+    /**
+     * Create a Packet for writing messages to.
+     */
+    public static Packet forWrite(short packetType, long packetId, long timestamp, String serverName) throws IOException {
+        return new Packet(true, packetType, packetId, timestamp, serverName);
+    }
+    
+    /**
+     * Create a Packet just reading the Header information.
+     */
+    public static Packet readHeader(DataInput dataInput) throws IOException {
+        
+        short packetType = dataInput.readShort();
+        long packetId = dataInput.readLong();
+        long timestamp = dataInput.readLong();
+        String serverName = dataInput.readUTF();
+        
+        return new Packet(false, packetType, packetId, timestamp, serverName);
+    }
+    
+    protected Packet(boolean write, short packetType, long packetId, long timestamp, String serverName) throws IOException{
+        this.packetType = packetType;
+        this.packetId = packetId;
+        this.timestamp = timestamp;
+        this.serverName = serverName;
+        if (write){
+            this.buffer = new ByteArrayOutputStream();
+            this.dataOut = new DataOutputStream(buffer);
+            writeHeader();
+        } else {
+            this.buffer = null;
+            this.dataOut = null;
+        }
+    }
+
+    private void writeHeader() throws IOException {
+        dataOut.writeShort(packetType);
+        dataOut.writeLong(packetId);
+        dataOut.writeLong(timestamp);
+        dataOut.writeUTF(serverName);
+    }
+
+    public int incrementResendCount() {
+        return resendCount++;
+    }
+    
+    public short getPacketType() {
+        return packetType;
+    }
+
+    public long getPacketId() {
+        return packetId;
+    }
+    
+    public long getTimestamp() {
+        return timestamp;
+    }
+
+    public String getServerName() {
+        return serverName;
+    }
+    
+    public void writeEof() throws IOException {
+        dataOut.writeBoolean(false);
+    }
+    
+    public void read(DataInput dataInput) throws IOException {
+        boolean more = dataInput.readBoolean();
+        while (more){
+            int msgType = dataInput.readInt();
+            readMessage(dataInput, msgType);
+            // see if there is more information
+            more = dataInput.readBoolean();
+        }
+    }
+    
+    /**
+     * Overridden by more specific Packet implementations to read the messages.
+     */
+    protected void readMessage(DataInput dataInput, int msgType) throws IOException {
+        
+    }
+
+    /**
+     * Write a binary message to this packet returning true if there was
+     * enough room to do so. Return false if the message was too large for
+     * the remaining space left - in this case another Packet should be
+     * created to put that message into.
+     */
+    public boolean writeBinaryMessage(BinaryMessage msg, int maxPacketSize) throws IOException {
+        
+        byte[] bytes = msg.getByteArray();
+        
+        if (messageCount > 0 && (bytes.length + buffer.size() > maxPacketSize)){
+            // we are actually going to ignore the maxPacketSize iff we have one
+            // large message. 
+            
+            // false = no more messages
+            dataOut.writeBoolean(false);
+            return false;
+        }
+        ++messageCount;
+        // true = another message follows
+        dataOut.writeBoolean(true);
+        dataOut.write(bytes);
+        return true;
+    }
+
+    public int getSize() {
+        return getBytes().length;
+    }
+    
+    /**
+     * Return the Packet as raw bytes.
+     */
+    public byte[] getBytes() {
+        if (bytes == null){
+            bytes = buffer.toByteArray();
+            buffer = null;
+            dataOut = null;
+        }
+        return bytes;
+    }
+
+    
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/PacketMessages.java

@@ -0,0 +1,88 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster;
+
+import java.io.DataInput;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.avaje.ebeaninternal.server.cluster.mcast.Message;
+import com.avaje.ebeaninternal.server.cluster.mcast.MessageAck;
+import com.avaje.ebeaninternal.server.cluster.mcast.MessageControl;
+import com.avaje.ebeaninternal.server.cluster.mcast.MessageResend;
+
+/**
+ * A Packet that contains Ack, Resend and Control messages.
+ * 
+ * @author rbygrave
+ */
+public class PacketMessages extends Packet {
+
+    private final ArrayList<Message> messages;
+
+    public static PacketMessages forWrite(long packetId, long timestamp, String serverName) throws IOException {
+        return new PacketMessages(true, packetId, timestamp, serverName);
+    }
+    
+    public static PacketMessages forRead(Packet header) throws IOException {
+        return new PacketMessages(header);
+    }
+    
+    private PacketMessages(boolean write, long packetId, long timestamp, String serverName) throws IOException {
+        super(write, TYPE_MESSAGES, packetId, timestamp, serverName);
+        this.messages = null;
+    }
+
+    private PacketMessages(Packet header) throws IOException {
+        super(false, TYPE_MESSAGES, header.packetId, header.timestamp, header.serverName);
+        this.messages = new ArrayList<Message>();
+    }
+    
+    /**
+     * Return the messages contained in this Packet.
+     */
+    public List<Message> getMessages() {
+        return messages;
+    }
+
+    /**
+     * Read the messages (Ack, Resend or Control) contained in this packet.
+     */
+    protected void readMessage(DataInput dataInput, int msgType) throws IOException {
+        
+        switch (msgType) {
+        case BinaryMessage.TYPE_MSGCONTROL:
+            messages.add(MessageControl.readBinaryMessage(dataInput));
+            break;
+
+        case BinaryMessage.TYPE_MSGACK:
+            messages.add(MessageAck.readBinaryMessage(dataInput));
+            break;
+
+        case BinaryMessage.TYPE_MSGRESEND:
+            messages.add(MessageResend.readBinaryMessage(dataInput));
+            break;
+
+        default:
+            throw new RuntimeException("Invalid Transaction msgType "+msgType);
+        }
+    }
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/PacketTransactionEvent.java

@@ -0,0 +1,94 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster;
+
+import java.io.DataInput;
+import java.io.IOException;
+
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.api.TransactionEventTable.TableIUD;
+import com.avaje.ebeaninternal.server.transaction.BeanDelta;
+import com.avaje.ebeaninternal.server.transaction.BeanPersistIds;
+import com.avaje.ebeaninternal.server.transaction.IndexEvent;
+import com.avaje.ebeaninternal.server.transaction.RemoteTransactionEvent;
+
+/**
+ * A Packet holding TransactionEvent data.
+ * <p>
+ * Due to the hard limit for UDP packet sizes a RemoteTransactionEvent
+ * is actually broken up into smaller messages.
+ * </p>
+ * @author rbygrave
+ */
+public class PacketTransactionEvent extends Packet {
+
+    private final SpiEbeanServer server;
+    
+    private final RemoteTransactionEvent event;
+
+    public static PacketTransactionEvent forWrite(long packetId, long timestamp, String serverName) throws IOException {
+        return new PacketTransactionEvent(true, packetId, timestamp, serverName);
+    }
+    
+    private PacketTransactionEvent(boolean write, long packetId, long timestamp, String serverName) throws IOException {
+        super(write, TYPE_TRANSEVENT, packetId, timestamp, serverName);
+        this.server = null;
+        this.event = null;
+    }
+
+    private PacketTransactionEvent(Packet header, SpiEbeanServer server) throws IOException {
+        super(false, TYPE_TRANSEVENT, header.packetId, header.timestamp, header.serverName);
+        this.server = server;
+        this.event = new RemoteTransactionEvent(server);
+    }
+
+    public static PacketTransactionEvent forRead(Packet header, SpiEbeanServer server) throws IOException {
+        return new PacketTransactionEvent(header, server);
+    }
+ 
+    public RemoteTransactionEvent getEvent() {
+        return event;
+    }
+
+    protected void readMessage(DataInput dataInput, int msgType) throws IOException {
+        
+        switch (msgType) {
+        case BinaryMessage.TYPE_BEANIUD:
+            event.addBeanPersistIds(BeanPersistIds.readBinaryMessage(server, dataInput));
+            break;
+            
+        case BinaryMessage.TYPE_TABLEIUD:
+            event.addTableIUD(TableIUD.readBinaryMessage(dataInput));
+            break;
+
+        case BinaryMessage.TYPE_BEANDELTA:
+            event.addBeanDelta(BeanDelta.readBinaryMessage(server, dataInput));
+            break;
+
+        case BinaryMessage.TYPE_INDEX:
+            event.addIndexEvent(IndexEvent.readBinaryMessage(dataInput));
+            break;
+
+        default:
+            throw new RuntimeException("Invalid Transaction msgType "+msgType);
+        }
+    }
+    
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/PacketWriter.java

@@ -0,0 +1,179 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.avaje.ebeaninternal.server.cluster.mcast.Message;
+import com.avaje.ebeaninternal.server.transaction.RemoteTransactionEvent;
+
+/**
+ * Creates Packets for either RemoteTransactionEvents or Messages (Ping, ACK,
+ * Join, Leave etc).
+ * 
+ * @author rbygrave
+ */
+public class PacketWriter {
+
+    private final PacketIdGenerator idGenerator;
+    private final PacketBuilder messagesPacketBuilder;
+    private final PacketBuilder transEventPacketBuilder;
+
+    /**
+     * Create a PacketWriter with an expected max packet size.
+     * <p>
+     * In theory we would prefer to create packets up to the MTU size which for
+     * Ethernet will likely be 1500. Note that the maxPacketSize is ignored for
+     * large single messages.
+     * </p>
+     */
+    public PacketWriter(int maxPacketSize) {
+        this.idGenerator = new PacketIdGenerator();
+        this.messagesPacketBuilder = new PacketBuilder(maxPacketSize, idGenerator, new MessagesPacketFactory());
+        this.transEventPacketBuilder = new PacketBuilder(maxPacketSize, idGenerator, new TransPacketFactory());
+    }
+
+    /**
+     * Return the currentPacketId.
+     */
+    public long currentPacketId() {
+        return idGenerator.currentPacketId();
+    }
+    
+    /**
+     * Create Packets for a given list of messages.
+     * <p>
+     * Typically this creates a single Packet but there is a hard limit for UDP
+     * packet sizes.
+     * </p>
+     */
+    public List<Packet> write(boolean requiresAck, List<? extends Message> messages) throws IOException {
+
+        BinaryMessageList binaryMsgList = new BinaryMessageList();
+        for (int i = 0; i < messages.size(); i++) {
+            Message message = messages.get(i);
+            message.writeBinaryMessage(binaryMsgList);
+        }
+        return messagesPacketBuilder.write(requiresAck, binaryMsgList, "");
+    }
+
+    /**
+     * Create Packets for a given RemoteTransactionEvent.
+     * <p>
+     * Typically this creates a single Packet but there is a hard limit for UDP
+     * packet sizes.
+     * </p>
+     */
+    public List<Packet> write(RemoteTransactionEvent transEvent) throws IOException {
+
+        BinaryMessageList messageList = new BinaryMessageList();
+
+        // split into reasonably small independent messages
+        transEvent.writeBinaryMessage(messageList);
+
+        return transEventPacketBuilder.write(true, messageList, transEvent.getServerName());
+    }
+
+    /**
+     * Reuse the same packetIdCounter for building Packets for both Message and
+     * RemoteTransactionEvent
+     */
+    private static class PacketIdGenerator {
+
+        long packetIdCounter;
+
+        public long nextPacketId() {
+            return ++packetIdCounter;
+        }
+        
+        public long currentPacketId() {
+            return packetIdCounter;
+        }
+        
+    }
+
+    interface PacketFactory {
+
+        public Packet createPacket(long packetId, long timestamp, String serverName) throws IOException;
+    }
+
+    private static class TransPacketFactory implements PacketFactory {
+
+        public Packet createPacket(long packetId, long timestamp, String serverName) throws IOException {
+            return PacketTransactionEvent.forWrite(packetId, timestamp, serverName);
+        }
+    }
+
+    private static class MessagesPacketFactory implements PacketFactory {
+
+        public Packet createPacket(long packetId, long timestamp, String serverName) throws IOException {
+            return PacketMessages.forWrite(packetId, timestamp, serverName);
+        }
+    }
+
+    /**
+     * Helper class for building Packets from messages or
+     * RemoteTransactionEvents.
+     */
+    private static class PacketBuilder {
+
+        private final PacketIdGenerator idGenerator;
+        private final PacketFactory packetFactory;
+        private final int maxPacketSize;
+
+        private PacketBuilder(int maxPacketSize, PacketIdGenerator idGenerator, PacketFactory packetFactory) {
+            this.maxPacketSize = maxPacketSize;
+            this.idGenerator = idGenerator;
+            this.packetFactory = packetFactory;
+        }
+
+        private List<Packet> write(boolean requiresAck, BinaryMessageList messageList, String serverName)
+                throws IOException {
+
+            List<BinaryMessage> list = messageList.getList();
+
+            ArrayList<Packet> packets = new ArrayList<Packet>(1);
+
+            long timestamp = System.currentTimeMillis();
+
+            long packetId = requiresAck ? idGenerator.nextPacketId() : 0;
+            Packet p = packetFactory.createPacket(packetId, timestamp, serverName);
+
+            packets.add(p);
+
+            for (int i = 0; i < list.size(); i++) {
+                BinaryMessage binMsg = list.get(i);
+                if (!p.writeBinaryMessage(binMsg, maxPacketSize)) {
+                    // didn't fit into the package so put into another packet
+                    packetId = requiresAck ? idGenerator.nextPacketId() : 0;
+                    p = packetFactory.createPacket(packetId, timestamp, serverName);
+                    packets.add(p);
+                    p.writeBinaryMessage(binMsg, maxPacketSize);
+                }
+            }
+            p.writeEof();
+
+            return packets;
+
+        }
+    }
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/SerialiseTransactionHelper.java

@@ -0,0 +1,74 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster;
+
+import java.io.ByteArrayInputStream;
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.util.List;
+
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.server.transaction.RemoteTransactionEvent;
+
+/**
+ * Mechanism to convert RemoteTransactionEvent to/from byte[] content.
+ */
+public abstract class SerialiseTransactionHelper {
+
+    private final PacketWriter packetWriter;
+
+    public SerialiseTransactionHelper() {
+        packetWriter = new PacketWriter(Integer.MAX_VALUE);
+    }
+
+    public abstract SpiEbeanServer getEbeanServer(String serverName);
+
+    /**
+     * Convert the RemoteTransactionEvent to byte[] content.
+     */
+    public DataHolder createDataHolder(RemoteTransactionEvent transEvent) throws IOException {
+
+        List<Packet> packetList = packetWriter.write(transEvent);
+        if (packetList.size() != 1) {
+            throw new RuntimeException("Always expecting 1 Packet but got " + packetList.size());
+        }
+        byte[] data = packetList.get(0).getBytes();
+        return new DataHolder(data);
+    }
+
+    /**
+     * Convert the byte[] content to RemoteTransactionEvent.
+     */
+    public RemoteTransactionEvent read(DataHolder dataHolder) throws IOException {
+
+        ByteArrayInputStream bi = new ByteArrayInputStream(dataHolder.getData());
+        DataInputStream dataInput = new DataInputStream(bi);
+
+        Packet header = Packet.readHeader(dataInput);
+
+        SpiEbeanServer server = getEbeanServer(header.getServerName());
+
+        PacketTransactionEvent tranEventPacket = PacketTransactionEvent.forRead(header, server);
+        tranEventPacket.read(dataInput);
+
+        return tranEventPacket.getEvent();
+
+    }
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/mcast/AckResendMessages.java

@@ -0,0 +1,62 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster.mcast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Holds a list of ACK and RESEND messages that should be sent out.
+ * 
+ * @author rbygrave
+ */
+public class AckResendMessages {
+
+    ArrayList<Message> messages = new ArrayList<Message>();
+    
+    public String toString() {
+        return messages.toString();
+    }
+    
+    public int size() {
+        return messages.size();
+    }
+    
+    /**
+     * Add a ACK message to send.
+     */
+    public void add(MessageAck ack){
+        messages.add(ack);
+    }
+    
+    /**
+     * Add a RESEND message to send.
+     */
+    public void add(MessageResend resend){
+        messages.add(resend);
+    }
+    
+    /**
+     * Return all the messages to be sent out.
+     */
+    public List<Message> getMessages() {
+        return messages;
+    }
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/mcast/IncomingPacketsLastAck.java

@@ -0,0 +1,72 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster.mcast;
+
+import java.util.HashMap;
+import java.util.List;
+
+/**
+ * For this node this holds the ACK gotAllPoint for each member in the cluster.
+ * <p>
+ * As we receive messages from other members of the cluster periodically we need
+ * to send them ACK messages to say we got all the packets up to the gotAllPoint.
+ * </p>
+ * Thread Safety note: Object only used by McastClusterBroadcast Manager thread.
+ * So Single Threaded access.
+ * 
+ * @author rbygrave
+ */
+public class IncomingPacketsLastAck {
+
+    private HashMap<String,MessageAck> lastAckMap = new HashMap<String, MessageAck>();
+
+    public String toString() {
+        return lastAckMap.values().toString();
+    }
+    
+    /**
+     * Remove a member of the cluster who has left.
+     */
+    public void remove(String memberHostPort) {
+        lastAckMap.remove(memberHostPort);
+    }
+    
+    /**
+     * Get the last Ack point for a given member of the cluster.
+     */
+    public MessageAck getLastAck(String memberHostPort) {
+        return lastAckMap.get(memberHostPort);
+    }
+    
+    /**
+     * For the ACK messages in AckResendMessages update the
+     * last Ack packetId.
+     */
+    public void updateLastAck(AckResendMessages ackResendMessages) {
+        List<Message> messages = ackResendMessages.getMessages();
+        for (int i = 0; i < messages.size(); i++) {
+            Message msg = messages.get(i);
+            if (msg instanceof MessageAck){
+                MessageAck lastAck = (MessageAck)msg;
+                lastAckMap.put(lastAck.getToHostPort(), lastAck);
+            }
+        }
+    }
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/mcast/IncomingPacketsProcessed.java

@@ -0,0 +1,292 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster.mcast;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.logging.Logger;
+
+/**
+ * For Incoming Packets remembers the packets we have received and processed.
+ * <p>
+ * This determines the gotAllPoint per cluster member and identifies missing
+ * packets (gap between gotAllPoint and gotMaxPoint).
+ * </p>
+ * <p>
+ * This information is used by the managerThread so send ACK's for messages we
+ * have received and RESEND messages to fill the missing packets we have
+ * detected.
+ * </p>
+ * 
+ * @author rbygrave
+ * 
+ */
+public class IncomingPacketsProcessed {
+
+    private final ConcurrentHashMap<String, GotAllPoint> mapByMember = new ConcurrentHashMap<String, GotAllPoint>();
+
+    private final int maxResendIncoming;
+    
+    public IncomingPacketsProcessed(int maxResendIncoming) {
+        this.maxResendIncoming = maxResendIncoming;
+    }
+    
+    public void removeMember(String memberKey) {
+        mapByMember.remove(memberKey);
+    }
+
+    /**
+     * Return true if we should process this packet. Return false if we have
+     * already processed the packet.
+     */
+    public boolean isProcessPacket(String memberKey, long packetId) {
+
+        GotAllPoint memberPackets = getMemberPackets(memberKey);
+        return memberPackets.processPacket(packetId);
+    }
+
+    /**
+     * Build the list of ACK and RESEND messages that we should send out
+     * to the other members of the cluster.
+     */
+    public AckResendMessages getAckResendMessages(IncomingPacketsLastAck lastAck) {
+
+        // Called by the McastClusterBroadcast manager thread
+
+        AckResendMessages response = new AckResendMessages();
+
+        for (GotAllPoint member : mapByMember.values()) {
+
+            MessageAck lastAckMessage = lastAck.getLastAck(member.getMemberKey());
+
+            member.addAckResendMessages(response, lastAckMessage);
+        }
+
+        return response;
+    }
+
+    private GotAllPoint getMemberPackets(String memberKey) {
+
+        // This method is only called single threaded
+        // by the listener thread so I'm happy that this
+        // put into mapByMember is ok.
+        GotAllPoint memberGotAllPoint = mapByMember.get(memberKey);
+        if (memberGotAllPoint == null) {
+            memberGotAllPoint = new GotAllPoint(memberKey, maxResendIncoming);
+            mapByMember.put(memberKey, memberGotAllPoint);
+        }
+        return memberGotAllPoint;
+    }
+
+    /**
+     * Keeps track of packets received from a particular member of the cluster.
+     * <p>
+     * It notes the packetIds of the packets received and uses those to maintain
+     * the 'gotAllPoint'. The 'gotAllPoint' is the packetId which we know we
+     * received all the previous packets.
+     * </p>
+     */
+    public static class GotAllPoint {
+
+        private static final Logger logger = Logger.getLogger(GotAllPoint.class.getName());
+        
+        private final String memberKey;
+        private final int maxResendIncoming;
+
+        private long gotAllPoint;
+
+        private long gotMaxPoint;
+
+        /**
+         * Packets received out of order.
+         */
+        private ArrayList<Long> outOfOrderList = new ArrayList<Long>();
+
+        private HashMap<Long,Integer> resendCountMap = new HashMap<Long,Integer>();
+
+        public GotAllPoint(String memberKey, int maxResendIncoming) {
+            this.memberKey = memberKey;
+            this.maxResendIncoming = maxResendIncoming;
+        }
+
+        /**
+         * Add ACK and RESEND messages if required.
+         */
+        public void addAckResendMessages(AckResendMessages response, MessageAck lastAckMessage) {
+
+            synchronized (this) {
+                if (lastAckMessage != null && lastAckMessage.getGotAllPacketId() >= gotAllPoint) {
+                    // nothing has changed
+                } else {
+                    // ACK that we have got every packet up to gotAllPoint
+                    response.add(new MessageAck(memberKey, gotAllPoint));
+                }
+
+                if (getMissingPacketCount() > 0) {
+                    // Ask for these Packets to be RESENT
+                    List<Long> missingPackets = getMissingPackets();
+                    response.add(new MessageResend(memberKey, missingPackets));
+                }
+            }
+        }
+
+        public String getMemberKey() {
+            return memberKey;
+        }
+
+        public long getGotAllPoint() {
+            synchronized (this) {
+                return gotAllPoint;
+            }
+        }
+
+        public long getGotMaxPoint() {
+            synchronized (this) {
+                return gotMaxPoint;
+            }
+        }
+
+        private int getMissingPacketCount() {
+            if (gotMaxPoint <= gotAllPoint) {
+                if (!resendCountMap.isEmpty()) {
+                    resendCountMap.clear();
+                }
+                return 0;
+            }
+            return (int) (gotMaxPoint - gotAllPoint) - outOfOrderList.size();
+        }
+
+        public List<Long> getMissingPackets() {
+
+            synchronized (this) {
+                ArrayList<Long> missingList = new ArrayList<Long>();
+
+                // this is not particularly efficient but expecting
+                // the outOfOrderList to be relatively small
+
+                boolean lostPacket = false;
+                
+                for (long i = gotAllPoint + 1; i < gotMaxPoint; i++) {
+                    Long packetId = Long.valueOf(i);
+                    if (!outOfOrderList.contains(packetId)) {
+                        if (incrementResendCount(packetId)) {
+                            // request this packet be resent
+                            missingList.add(packetId);
+                        } else {
+                            lostPacket = true;    
+                        }
+                    }
+                }
+                
+                if (lostPacket){
+                    checkOutOfOrderList();
+                }
+
+                return missingList;
+            }
+        }
+                
+        /**
+         * Return true if this packet has not yet exceeded the maxResendCount.
+         */
+        private boolean incrementResendCount(Long packetId){
+            Integer resendCount = resendCountMap.get(packetId);
+            if (resendCount != null){
+                int i = resendCount.intValue() + 1;
+                if (i > maxResendIncoming){
+                    // we are going to give up trying to get this packet now
+                    logger.warning("Exceeded maxResendIncoming["+maxResendIncoming+"] for packet["+packetId+"]. Giving up on requesting it.");
+                    resendCountMap.remove(packetId);
+                    outOfOrderList.add(packetId);
+                    return false;
+                }
+                resendCount = Integer.valueOf(i);
+                resendCountMap.put(packetId, resendCount);
+            } else {
+                resendCountMap.put(packetId, ONE);   
+            }
+            return true;
+        }
+        
+        private static final Integer ONE = Integer.valueOf(1);
+
+        public boolean processPacket(long packetId) {
+            synchronized (this) {
+                
+                if (gotAllPoint == 0) {
+                    gotAllPoint = packetId;
+                    return true;
+                }
+                if (packetId <= gotAllPoint) {
+                    // already processed this packet
+                    return false;
+                }
+                
+                if (!resendCountMap.isEmpty()){
+                    resendCountMap.remove(Long.valueOf(packetId));
+                }
+                
+                if (packetId == gotAllPoint + 1) {
+                    gotAllPoint = packetId;
+                } else {
+                    if (packetId > gotMaxPoint) {
+                        gotMaxPoint = packetId;
+                    }
+                    outOfOrderList.add(Long.valueOf(packetId));
+                }
+                checkOutOfOrderList();
+                return true;
+            }
+        }
+
+        private void checkOutOfOrderList() {
+
+            if (outOfOrderList.size() == 0) {
+                return;
+            }
+
+            boolean continueCheck;
+            do {
+                continueCheck = false;
+                long nextPoint = gotAllPoint + 1;
+
+                Iterator<Long> it = outOfOrderList.iterator();
+                while (it.hasNext()) {
+                    Long id = it.next();
+                    if (id.longValue() == nextPoint) {
+                        // we found the next one in the outOfOrderList
+                        it.remove();
+                        gotAllPoint = nextPoint;
+                        continueCheck = true;
+                        break;
+                    }
+                }
+            } while (continueCheck);
+
+        }
+
+    }
+
+    
+     
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/mcast/McastClusterManager.java

@@ -0,0 +1,614 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster.mcast;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.TreeSet;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import com.avaje.ebean.config.GlobalProperties;
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.server.cluster.ClusterBroadcast;
+import com.avaje.ebeaninternal.server.cluster.ClusterManager;
+import com.avaje.ebeaninternal.server.cluster.Packet;
+import com.avaje.ebeaninternal.server.cluster.PacketWriter;
+import com.avaje.ebeaninternal.server.transaction.RemoteTransactionEvent;
+
+/**
+ * Overall Manager of the Multicast Cluster communication for this instance.
+ * <p>
+ * McastListener, McastSender and McastPacketControl are the main helpers to
+ * this object.
+ * </p>
+ * <p>
+ * This Manager (thread) periodically processes the ACK, Re-send and Control
+ * messages. The McastListener is handling all the incoming packets and informs
+ * this manager when interesting packets need to be processed by the Manager.
+ * </p>
+ * <p>
+ * Other threads call {@link #broadcast(RemoteTransactionEvent)} to send
+ * transaction even information.
+ * </p>
+ * 
+ * @author rbygrave
+ */
+public class McastClusterManager implements ClusterBroadcast, Runnable {
+
+    private static final Logger logger = Logger.getLogger(McastClusterManager.class.getName());
+
+    private ClusterManager clusterManager;
+
+    private final Thread managerThread;
+
+    /**
+     * Helps co-ordinate packet information (Acks, Missing Packets etc).
+     */
+    private final McastPacketControl packageControl;
+
+    /**
+     * Listeners for incoming packets.
+     */
+    private final McastListener listener;
+
+    /**
+     * Sends packets out to the cluster.
+     */
+    private final McastSender localSender;
+
+    /**
+     * The localSenderHostPort is used to identify this instance in the cluster.
+     */
+    private final String localSenderHostPort;
+    
+    /**
+     * Creates the Packets (byte[]) from Messages and RemoteTransactionEvent. 
+     */
+    private final PacketWriter packetWriter;
+    
+    /**
+     * List of Re-send messages that the managerThread needs to process.
+     */
+    private final ArrayList<MessageResend> resendMessages = new ArrayList<MessageResend>();
+
+    /**
+     * List of Control messages (Ping,PingResponse,Join,Leave) that the managerThread needs to process.
+     */
+    private final ArrayList<MessageControl> controlMessages = new ArrayList<MessageControl>();
+    
+    /**
+     * Cache of outgoing messages that have not been ACK'ed by the other cluster members yet.
+     */
+    private final OutgoingPacketsCache outgoingPacketsCache = new OutgoingPacketsCache();
+
+    /**
+     * The last ACK we sent out to other members of the cluster.
+     */
+    private final IncomingPacketsLastAck incomingPacketsLastAck = new IncomingPacketsLastAck();
+
+    /**
+     * A limit of the number of times we will try to send out a given packet.
+     * Once this is exceeded we will just drop that packet. Hopefully this does
+     * not happen but we don't want to keep trying forever producing network
+     * traffic.
+     */
+    private final int maxResendOutgoing;
+    
+    /**
+     * Instead of ACK'ing immediately we periodically wake up and in a single
+     * packet (typically) ACK all members of the cluster everything we got since
+     * the last sleep time. More frequent ACK's means less memory consumption as
+     * Packets are cleared from the outgoingPacketsCache quicker at the cost of
+     * sending more packets.
+     */
+    private long managerSleepMillis;
+
+    /**
+     * When true then packets are still sent out even when the cluster has no other online members.
+     */
+    private boolean sendWithNoMembers;
+
+    /**
+     * The current minAcked packetId processed by the managerThread.
+     * All packets before this have been ACK'ed by everyone in the cluster.
+     */
+    private long minAcked;
+    
+    /**
+     * The min packetId that has been ACKed by all the members of the cluster according
+     * to the McastListener. This will increase as the Listener receives ACK's and means
+     * we can trim out Packets from the sent cache.
+     */
+    private long minAckedFromListener;
+    
+    /**
+     * Start the groupSize at -1 so we have to wait until the Listener times out or gets 
+     * a control messages (Ping, PingResponse, Join, Leave etc) before we know how many
+     * members of the group the listener knows about.
+     * <p>
+     * Generally speaking we only care if the groupSize == 0 meaning there are no other 
+     * members of the cluster that are online. In this case we can potentially not send
+     * the packets out (depending on sendWithNoMembers) and not cache them (for re-sending
+     * if they where not ACK'ed).
+     * </p>
+     */
+    private int currentGroupSize = -1;
+    
+    /**
+     * The last time a packet was sent from this node.
+     */
+    private long lastSendTime;
+
+    /**
+     * The max time we go without sending any packets. 
+     */
+    private int lastSendTimeFreqMillis;
+
+    /**
+     * The last time the cluster status was logged.
+     */
+    private long lastStatusTime = System.currentTimeMillis();
+    
+    /**
+     * The max time we go before logging the cluster status.
+     */
+    private int lastStatusTimeFreqMillis;
+        
+    
+    private long totalTxnEventsSent;
+    private long totalTxnEventsReceived;
+    
+    private long totalPacketsSent;
+    private long totalBytesSent;
+    
+    private long totalPacketsResent;
+    private long totalBytesResent;
+    
+    private long totalPacketsReceived;
+    private long totalBytesReceived;
+
+
+    public McastClusterManager() {
+
+        this.managerSleepMillis = GlobalProperties.getInt("ebean.cluster.mcast.managerSleepMillis", 80);
+        this.lastSendTimeFreqMillis = 1000*GlobalProperties.getInt("ebean.cluster.mcast.pingFrequencySecs", 300);//5mins
+        this.lastStatusTimeFreqMillis = 1000*GlobalProperties.getInt("ebean.cluster.mcast.statusFrequencySecs", 600);//10mins
+        
+        // the maximum number of times we will try to re-send a given packet before giving up sending
+        this.maxResendOutgoing = GlobalProperties.getInt("ebean.cluster.mcast.maxResendOutgoing", 200);        
+        // the maximum number of times we will ask for a packet to be resent to us before giving up asking
+        int maxResendIncoming = GlobalProperties.getInt("ebean.cluster.mcast.maxResendIncoming", 50);
+            
+        
+        int port = GlobalProperties.getInt("ebean.cluster.mcast.listen.port", 0);
+        String addr = GlobalProperties.get("ebean.cluster.mcast.listen.address", null);
+
+        int sendPort = GlobalProperties.getInt("ebean.cluster.mcast.send.port", 0);
+        String sendAddr = GlobalProperties.get("ebean.cluster.mcast.send.address", null);
+
+        // Sender options
+        // Note 1500 is Ethernet MTU and this must be less than UDP max packet size of 65507
+        int maxSendPacketSize = GlobalProperties.getInt("ebean.cluster.mcast.send.maxPacketSize", 1500);
+        // Whether to send packets even when there are no other members online
+        this.sendWithNoMembers = GlobalProperties.getBoolean("ebean.cluster.mcast.send.sendWithNoMembers", true);
+        
+        // Listener options
+        // When multiple instances are on same box you need to broadcast back locally
+        boolean disableLoopback = GlobalProperties.getBoolean("ebean.cluster.mcast.listen.disableLoopback", false);
+        int ttl = GlobalProperties.getInt("ebean.cluster.mcast.listen.ttl", -1);
+        int timeout = GlobalProperties.getInt("ebean.cluster.mcast.listen.timeout", 1000);
+        int bufferSize = GlobalProperties.getInt("ebean.cluster.mcast.listen.bufferSize", 65500);
+        // For multihomed environment the address the listener should bind to
+        String mcastAddr = GlobalProperties.get("ebean.cluster.mcast.listen.mcastAddress", null);
+
+        InetAddress mcastAddress = null;
+        if (mcastAddr != null) {
+            try {
+                mcastAddress = InetAddress.getByName(mcastAddr);
+            } catch (UnknownHostException e) {
+                String msg = "Error getting Multicast InetAddress for " + mcastAddr;
+                throw new RuntimeException(msg, e);
+            }
+        }
+
+        if (port == 0 || addr == null) {
+            String msg = "One of these Multicast settings has not been set. " + "ebean.cluster.mcast.listen.port="
+                    + port + ", ebean.cluster.mcast.listen.address=" + addr;
+
+            throw new IllegalArgumentException(msg);
+        }
+
+        this.managerThread = new Thread(this, "EbeanClusterMcastManager");
+
+        this.packetWriter = new PacketWriter(maxSendPacketSize);
+        this.localSender = new McastSender(port, addr, sendPort, sendAddr);
+        this.localSenderHostPort = localSender.getSenderHostPort();
+
+        this.packageControl = new McastPacketControl(this, localSenderHostPort, maxResendIncoming);
+        
+        this.listener = new McastListener(this, packageControl, port, addr, bufferSize, timeout, localSenderHostPort,
+                disableLoopback, ttl, mcastAddress);
+    }
+
+
+    /**
+     * The McastListener tells us there are no other members of the cluster that
+     * are currently online.
+     */
+    protected void fromListenerTimeoutNoMembers() {
+        synchronized (managerThread) {
+            this.currentGroupSize = 0;
+        }
+    }
+        
+    /**
+     * McastListener calls this method to get the manager to process messages.
+     * 
+     * @param newMinAcked
+     *            the minAcked packetId according to the listener
+     * @param msgControl
+     *            a control message to process
+     * @param msgResend
+     *            a Please re-send message to process
+     * @param groupSize
+     *            the number of other online members
+     */
+    protected void fromListener(long newMinAcked, MessageControl msgControl, MessageResend msgResend, 
+            int groupSize, long totalPacketsReceived, long totalBytesReceived, long totalTxnEventsReceived) {
+        
+        synchronized (managerThread) {
+            if (newMinAcked > minAckedFromListener){
+                minAckedFromListener = newMinAcked;
+            }
+            if (msgControl != null){
+                controlMessages.add(msgControl);                
+            }
+            if (msgResend != null){
+                resendMessages.add(msgResend);                
+            }
+            // mostly interested when groupSize hits 0 (we are the only instance online).
+            this.currentGroupSize = groupSize;
+            
+            // and some stats so we know how busy the listener has been
+            this.totalPacketsReceived = totalPacketsReceived;
+            this.totalBytesReceived = totalBytesReceived;
+            this.totalTxnEventsReceived = totalTxnEventsReceived;
+        }
+    }
+    
+    /**
+     * Get the overall status and activity of this cluster node.
+     */
+    public McastStatus getStatus(boolean reset) {
+        synchronized (managerThread) {
+            
+            long currentPacketId = packetWriter.currentPacketId();
+            String lastAcks = incomingPacketsLastAck.toString();
+
+            return new McastStatus(currentGroupSize, outgoingPacketsCache.size(), currentPacketId, minAcked, lastAcks,
+                    totalTxnEventsSent, totalTxnEventsReceived, totalPacketsSent, totalPacketsResent, totalPacketsReceived,
+                    totalBytesSent, totalBytesResent, totalBytesReceived);
+
+        }
+    }    
+    
+    /**
+     * Periodically send out Ack, Re-send and Control messages. 
+     */
+    public void run() {
+        while (true) {
+            try {
+                // sleep for a little bit as we ACK packets periodically
+                // rather than immediately. We will typically ACK many 
+                // messages from all cluster members in a single Packet
+                Thread.sleep(managerSleepMillis);
+                
+                synchronized (managerThread) {
+                                                     
+                    handleControlMessages();
+
+                    handleResendMessages();
+
+                    if (currentGroupSize == 0){
+                        // no members online so trim the entire outgoing packets cache
+                        int trimmedCount = outgoingPacketsCache.trimAll();
+                        if (trimmedCount > 0){
+                            logger.fine("Cluster has no other members. Trimmed "+trimmedCount);
+                        }
+                        
+                    } else if (minAckedFromListener > minAcked){
+                        // ACKs have come back so trim send packets cache
+                        outgoingPacketsCache.trimAcknowledgedMessages(minAckedFromListener);
+                        minAcked = minAckedFromListener;
+                    }
+                    
+                    // Get list of all the ACK messages required to sent since the last time.
+                    // This is effectively one ACK message per member of the cluster. The ACK 
+                    // message covers all the packets received from the member up to 
+                    // the gotAllPoint. 
+                    // Also get any RESEND messages asking for packets that we have not
+                    // received between the gotAllPoint and the gotMaxPoint.
+                    AckResendMessages ackResendMessages = packageControl.getAckResendMessages(incomingPacketsLastAck);
+                    
+                    if (ackResendMessages.size() > 0){
+                        // send the ACK and RESEND messages for all members of the
+                        // cluster typically in a single Packet
+                        if (sendMessages(false, ackResendMessages.getMessages())) {
+                            // update the last Ack position
+                            incomingPacketsLastAck.updateLastAck(ackResendMessages);
+                        }
+                    }
+                    
+                    if (lastSendTime < System.currentTimeMillis() - lastSendTimeFreqMillis){
+                        // been quite for too long - send a Ping out
+                        sendPing();
+                    }         
+                    
+                    if (lastStatusTimeFreqMillis > 0){
+                        if (lastStatusTime < System.currentTimeMillis() - lastStatusTimeFreqMillis){
+                            McastStatus status = getStatus(false);
+                            logger.info("Cluster Status: "+status.getSummary());
+                            lastStatusTime = System.currentTimeMillis();
+                        }    
+                    }
+                    
+                }
+            } catch (Exception e){
+                String msg = "Error with Cluster Mcast Manager thread";
+                logger.log(Level.SEVERE, msg, e);
+            }
+        }
+    }
+
+    /**
+     * We have been asked to Re-send some packets.
+     */
+    private void handleResendMessages() {
+
+        if (resendMessages.size() > 0){
+            
+            TreeSet<Long> s = new TreeSet<Long>(); 
+            for (int i = 0; i < resendMessages.size(); i++) {
+                MessageResend resendMsg = resendMessages.get(i);
+                s.addAll(resendMsg.getResendPacketIds());
+            }
+            
+            totalPacketsResent += s.size();
+            
+            Iterator<Long> it = s.iterator();
+            while (it.hasNext()) {
+                Long resendPacketId = it.next();
+                Packet packet = outgoingPacketsCache.getPacket(resendPacketId);
+                if (packet == null){
+                    String msg = "Cluster unable to resend packet["+resendPacketId+"] as it is no longer in the outgoingPacketsCache";
+                    logger.log(Level.SEVERE, msg);
+                } else {
+                    int resendCount = packet.incrementResendCount();
+                    if (resendCount <= maxResendOutgoing) {
+                        resendPacket(packet);
+                    } else {                        
+                        String msg = "Cluster maxResendOutgoing ["+maxResendOutgoing+"] hit for packet "+resendPacketId
+                            +". We will not try to send it anymore, removing it from the outgoingPacketsCache.";
+                        logger.log(Level.SEVERE, msg);
+                        outgoingPacketsCache.remove(packet);
+                    }
+                }
+            }   
+        }
+    }
+    
+    /**
+     * Re-send a packet that a member didn't seem to receive.
+     */
+    private void resendPacket(Packet packet) {
+        try {
+            ++totalPacketsResent;
+             totalBytesResent += localSender.sendPacket(packet);
+        } catch (IOException e) {
+            String msg = "Error trying to resend packet "+packet.getPacketId();
+            logger.log(Level.SEVERE, msg, e);
+        }        
+    }
+        
+    /**
+     * Handle Control messages (Join, Leave, Ping).
+     */
+    private void handleControlMessages() {
+        
+        boolean pingReponse = false;
+        boolean joinReponse = false;
+        
+        for (int i = 0; i < controlMessages.size(); i++) {
+            MessageControl message = controlMessages.get(i);
+
+            short type = message.getControlType();
+            switch (type) {                
+            case MessageControl.TYPE_JOIN:
+                // a new member online, send back a Join Response
+                logger.info("Cluster member Joined ["+message.getFromHostPort()+"]");
+                joinReponse = true;                       
+                break;
+
+            case MessageControl.TYPE_JOINRESPONSE:
+                logger.info("Cluster member Online ["+message.getFromHostPort()+"]");
+                // do nothing                            
+                break;
+                
+            case MessageControl.TYPE_PING:
+                pingReponse = true;                       
+                break;
+
+            case MessageControl.TYPE_PINGRESPONSE:
+                // do nothing                            
+                break;
+
+            case MessageControl.TYPE_LEAVE:
+                // remove member. If/When that member comes back its 
+                // packetIds will have been reset 
+                incomingPacketsLastAck.remove(message.getFromHostPort());
+                break;
+
+            default:
+                break;
+            }
+        }
+        controlMessages.clear();
+        
+        if (joinReponse){
+            sendJoinResponse();
+        }
+        if (pingReponse){
+            sendPingResponse();
+        }
+    }
+
+    /**
+     * Say 'Leaving' and shutdown.
+     */
+    public void shutdown() {
+        sendLeave();
+        listener.shutdown();
+    }
+
+    /**
+     * Startup listeners and 'Join'.
+     */
+    public void startup(ClusterManager clusterManager) {
+        this.clusterManager = clusterManager;
+        listener.startListening();
+
+        this.managerThread.setDaemon(true);
+        this.managerThread.start();
+
+        sendJoin();
+    }
+
+    protected SpiEbeanServer getEbeanServer(String serverName) {
+        return (SpiEbeanServer) clusterManager.getServer(serverName);
+    }
+
+    private void sendJoin() {
+        sendControlMessage(true, MessageControl.TYPE_JOIN);
+    }
+
+    private void sendLeave() {
+        sendControlMessage(false, MessageControl.TYPE_LEAVE);
+    }
+
+    private void sendJoinResponse() {
+        sendControlMessage(true, MessageControl.TYPE_JOINRESPONSE);
+    }
+
+    private void sendPingResponse() {
+        sendControlMessage(true, MessageControl.TYPE_PINGRESPONSE);
+    }
+    
+    private void sendPing() {
+        sendControlMessage(true, MessageControl.TYPE_PING);
+    }
+
+    private void sendControlMessage(boolean requiresAck, short controlType) {
+        sendMessage(requiresAck, new MessageControl(controlType, localSenderHostPort));
+    }
+
+    private void sendMessage(boolean requiresAck, Message msg) {
+        ArrayList<Message> messages = new ArrayList<Message>(1);
+        messages.add(msg);
+        sendMessages(requiresAck, messages);
+    }
+    
+    private boolean sendMessages(boolean requiresAck, List<? extends Message> messages) {
+
+        synchronized (managerThread) {
+            try {
+
+                List<Packet> packets = packetWriter.write(requiresAck, messages);
+                sendPackets(requiresAck, packets);
+                return true;
+                
+            } catch (IOException e) {
+                String msg = "Error sending Messages " + messages;
+                logger.log(Level.SEVERE, msg, e);
+                return false;
+            }
+        }
+    }
+        
+    private boolean sendPackets(boolean requiresAck, List<Packet> packets) throws IOException {
+        if (currentGroupSize == 0 && !sendWithNoMembers) {
+            // no other members online so not sending packets
+            return false;
+            
+        } else {
+            if (requiresAck){
+                // cache them until they have been ACK'ed
+                outgoingPacketsCache.registerPackets(packets);
+            }
+            totalPacketsSent += packets.size();
+            totalBytesSent += localSender.sendPackets(packets);
+            
+            lastSendTime = System.currentTimeMillis();
+            
+            return true;
+        } 
+    }
+
+    /**
+     * Send the remoteTransEvent to all the other members of the cluster.
+     */
+    public void broadcast(RemoteTransactionEvent remoteTransEvent) {
+
+        synchronized (managerThread) {
+            try {
+                List<Packet> packets = packetWriter.write(remoteTransEvent);
+                if (sendPackets(true, packets)){
+                    ++totalTxnEventsSent;                    
+                }
+            } catch (IOException e) {
+                String msg = "Error sending RemoteTransactionEvent " + remoteTransEvent;
+                logger.log(Level.SEVERE, msg, e);
+            }
+        }
+    }
+    
+    /**
+     * Effectively set the frequency by which this manager will send out ACKs.
+     */
+    public void setManagerSleepMillis(long managerSleepMillis) {
+        synchronized (managerThread) {
+            this.managerSleepMillis = managerSleepMillis;
+        }
+    }
+
+    /**
+     * Return the frequency by which this manager will send out ACKs.
+     */
+    public long getManagerSleepMillis() {
+        synchronized (managerThread) {
+            return managerSleepMillis;
+        }
+    }
+    
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/mcast/McastListener.java

@@ -0,0 +1,263 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster.mcast;
+
+import java.io.ByteArrayInputStream;
+import java.io.DataInput;
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.MulticastSocket;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import com.avaje.ebean.config.GlobalProperties;
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.server.cluster.Packet;
+import com.avaje.ebeaninternal.server.cluster.PacketTransactionEvent;
+
+/**
+ * Listens for Incoming packets.
+ * 
+ * @author rbygrave
+ */
+public class McastListener implements Runnable {
+
+    private static final Logger logger = Logger.getLogger(McastListener.class.getName());
+
+    private final McastClusterManager owner;
+    
+    private final McastPacketControl packetControl;
+    
+    private final MulticastSocket sock;
+
+    private final Thread listenerThread;
+
+    private final String localSenderHostPort;
+
+    private final InetAddress group;
+
+    private final boolean debugIgnore;
+
+    private DatagramPacket pack;
+
+    private byte[] receiveBuffer;
+
+    private volatile boolean shutdown;
+    private volatile boolean shutdownComplete;
+    
+    private long totalPacketsReceived;
+    private long totalBytesReceived;
+    private long totalTxnEventsReceived;
+    
+    public McastListener(McastClusterManager owner, McastPacketControl packetControl, int port, String address, 
+            int bufferSize, int timeout, String localSenderHostPort, 
+            boolean disableLoopback, int ttl, InetAddress mcastBindAddress) {
+
+        this.debugIgnore = GlobalProperties.getBoolean("ebean.debug.mcast.ignore", false);
+
+        this.owner = owner;
+        this.packetControl = packetControl;
+        this.localSenderHostPort = localSenderHostPort;
+        this.receiveBuffer = new byte[bufferSize];
+        this.listenerThread = new Thread(this, "EbeanClusterMcastListener");
+
+        String msg = "Cluster Multicast Listening address["+address+"] port["+port+"] disableLoopback["+disableLoopback+"]";
+        if (ttl >= 0){
+            msg +=" ttl["+ttl+"]";
+        }
+        if (mcastBindAddress != null){
+            msg += " mcastBindAddress["+mcastBindAddress+"]";
+        }
+        logger.info(msg);
+
+        try {
+            this.group = InetAddress.getByName(address);
+            this.sock = new MulticastSocket(port);
+            this.sock.setSoTimeout(timeout);
+
+            if (disableLoopback){
+                sock.setLoopbackMode(disableLoopback);
+            }
+            
+            if (mcastBindAddress != null) {
+                // bind to a specific interface
+                sock.setInterface(mcastBindAddress);
+            }
+            
+            if (ttl >= 0) {
+                sock.setTimeToLive(ttl);
+            }
+            sock.setReuseAddress(true);
+            pack = new DatagramPacket(receiveBuffer, receiveBuffer.length);
+            sock.joinGroup(group);
+            
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void startListening() {
+        this.listenerThread.setDaemon(true);
+        this.listenerThread.start();
+        
+        logger.info("Cluster Multicast Listener up and joined Group");
+    }
+
+    /**
+     * Shutdown this listener.
+     */
+    public void shutdown() {
+        
+        shutdown = true;
+        synchronized (listenerThread) {
+            try {
+                // wait max 20 seconds 
+                listenerThread.wait(20000);                
+            } catch (InterruptedException e) {
+                logger.info("InterruptedException:"+e);
+            }
+        }
+        
+        if (!shutdownComplete){
+            String msg = "WARNING: Shutdown of McastListener did not complete?";
+            System.err.println(msg);
+            logger.warning(msg);
+        }
+        
+        try {
+            sock.leaveGroup(group);
+        } catch (IOException e) {
+            // send to syserr in case logging already shutdown 
+            e.printStackTrace();
+            String msg = "Error leaving Multicast group";
+            logger.log(Level.INFO, msg, e);
+        }
+        try {
+            sock.close();
+        } catch (Exception e) {
+            // send to syserr in case logging already shutdown 
+            e.printStackTrace();
+            String msg = "Error closing Multicast socket";
+            logger.log(Level.INFO, msg, e);
+        }
+    }
+    
+    public void run() {
+        while (!shutdown) {
+            try {
+                pack.setLength(receiveBuffer.length);
+                sock.receive(pack);
+
+                InetSocketAddress senderAddr = (InetSocketAddress)pack.getSocketAddress();
+
+                String senderHostPort = senderAddr.getAddress().getHostAddress()+":"+senderAddr.getPort();                    
+                
+                if (senderHostPort.equals(localSenderHostPort)){
+                    if (debugIgnore || logger.isLoggable(Level.FINE)){
+                        logger.info("Ignoring message as sent by localSender: "+localSenderHostPort);
+                    }
+                } else {
+                                               
+                    byte[] data = pack.getData();
+                    
+                    
+                    ByteArrayInputStream bi = new ByteArrayInputStream(data);
+                    DataInputStream dataInput = new DataInputStream(bi);
+                    
+                    ++totalPacketsReceived;
+                    totalBytesReceived += pack.getLength();
+                    
+                    Packet header = Packet.readHeader(dataInput);
+                    
+                    long packetId = header.getPacketId();
+                    boolean ackMsg = packetId == 0;
+                    
+                    boolean processThisPacket = ackMsg || packetControl.isProcessPacket(senderHostPort, header.getPacketId());
+                    
+                    if (!processThisPacket){
+                        if (debugIgnore || logger.isLoggable(Level.FINE)){
+                            logger.info("Already processed packet: "+header.getPacketId()+" type:"+header.getPacketType()+" len:"+data.length);
+                        }
+                    } else {
+                        if (logger.isLoggable(Level.FINER)){
+                            logger.info("Incoming packet:"+header.getPacketId()+" type:"+header.getPacketType()+" len:"+data.length);
+                        }    
+                        processPacket(senderHostPort, header, dataInput);                            
+                    }
+                }
+                
+            } catch (java.net.SocketTimeoutException e) {
+                if (logger.isLoggable(Level.FINE)) {
+                    logger.log(Level.FINE, "timeout", e);
+                }
+                packetControl.onListenerTimeout();
+                
+            } catch (IOException e) {
+                logger.log(Level.INFO, "error ?", e);  
+            } 
+        }
+        
+        shutdownComplete = true;
+        
+        synchronized (listenerThread) {
+            listenerThread.notifyAll();
+        }
+    }
+
+    protected void processPacket(String senderHostPort, Packet header, DataInput dataInput) {
+        try {
+            switch (header.getPacketType()) {
+            case Packet.TYPE_MESSAGES:
+                packetControl.processMessagesPacket(senderHostPort, header, dataInput, 
+                        totalPacketsReceived, totalBytesReceived, totalTxnEventsReceived);
+                break;
+                
+            case Packet.TYPE_TRANSEVENT:
+                ++totalTxnEventsReceived;
+                processTransactionEventPacket(header, dataInput);
+                break;
+                
+            default:
+                String msg = "Unknown Packet type:" + header.getPacketType();
+                logger.log(Level.SEVERE, msg);
+                break;
+            }
+        } catch (IOException e) {
+            // need to ask to get this packet resent...
+            String msg = "Error reading Packet " + header.getPacketId() + " type:" + header.getPacketType();
+            logger.log(Level.SEVERE, msg, e);
+        }
+    }
+    
+    private void processTransactionEventPacket(Packet header, DataInput dataInput) throws IOException {
+
+        SpiEbeanServer server = owner.getEbeanServer(header.getServerName());
+
+        PacketTransactionEvent tranEventPacket = PacketTransactionEvent.forRead(header, server);
+        tranEventPacket.read(dataInput);
+
+        server.remoteTransactionEvent(tranEventPacket.getEvent());
+    }
+
+
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/mcast/McastPacketControl.java

@@ -0,0 +1,144 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster.mcast;
+
+import java.io.DataInput;
+import java.io.IOException;
+import java.util.HashSet;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import com.avaje.ebeaninternal.server.cluster.Packet;
+import com.avaje.ebeaninternal.server.cluster.PacketMessages;
+
+/**
+ * Helps co-ordinate Packet information between the McastListener and the
+ * McastClusterManager.
+ * 
+ * @author rbygrave
+ */
+public class McastPacketControl {
+
+    private static final Logger logger = Logger.getLogger(McastPacketControl.class.getName());
+
+    private final String localSenderHostPort;
+
+    private final McastClusterManager owner;
+
+    private final HashSet<String> groupMembers = new HashSet<String>();
+
+    private final OutgoingPacketsAcked outgoingPacketsAcked = new OutgoingPacketsAcked();
+
+    private final IncomingPacketsProcessed incomingPacketsProcessed;
+
+    public McastPacketControl(McastClusterManager owner, String localSenderHostPort, int maxResendIncoming) {
+        this.owner = owner;
+        this.localSenderHostPort = localSenderHostPort;
+        this.incomingPacketsProcessed = new IncomingPacketsProcessed(maxResendIncoming);
+    }
+
+    /**
+     * Handle special case where cluster doesn't have any members and we don't
+     * get any responses. Need to tell the sender side that the group size is 0.
+     */
+    protected void onListenerTimeout() {
+        if (groupMembers.size() == 0) {
+            owner.fromListenerTimeoutNoMembers();
+        }
+    }
+
+    protected void processMessagesPacket(String senderHostPort, Packet header, DataInput dataInput, 
+            long totalPacketsReceived, long totalBytesReceived, long totalTransEventsReceived) throws IOException {
+
+        PacketMessages packetMessages = PacketMessages.forRead(header);
+        packetMessages.read(dataInput);
+        List<Message> messages = packetMessages.getMessages();
+
+        if (logger.isLoggable(Level.FINER)) {
+            logger.finer("INCOMING Messages " + messages);
+        }
+        // messages are for all nodes in the cluster so
+        // we need to filter looking for messages pertaining
+        // to this (senderHostPort)
+
+        MessageControl control = null;
+        MessageAck ack = null;
+        MessageResend resend = null;
+
+        // filter for relevant messages to this node
+        for (int i = 0; i < messages.size(); i++) {
+            Message message = messages.get(i);
+            if (message.isControlMessage()) {
+                // any 'control' message is interesting
+                control = (MessageControl) message;
+
+            } else if (localSenderHostPort.equals(message.getToHostPort())) {
+                if (message instanceof MessageAck) {
+                    ack = (MessageAck) message;
+                } else if (message instanceof MessageResend) {
+                    resend = (MessageResend) message;
+                } else {
+                    logger.log(Level.SEVERE, "Expecting a MessageAck or MessageResend but got a "
+                            + message.getClass().getName());
+                }
+            }
+        }
+
+        if (control != null) {
+            if (control.getControlType() == MessageControl.TYPE_LEAVE) {
+                groupMembers.remove(senderHostPort);
+                logger.info("Cluster member leaving [" + senderHostPort + "] " + groupMembers.size()
+                        + " other members left");
+                outgoingPacketsAcked.removeMember(senderHostPort);
+                incomingPacketsProcessed.removeMember(senderHostPort);
+            } else {
+                groupMembers.add(senderHostPort);
+            }
+        }
+
+        long newMin = 0;
+        if (ack != null) {
+            newMin = outgoingPacketsAcked.receivedAck(senderHostPort, ack);
+        }
+
+        if (newMin > 0 || control != null || resend != null) {
+            int groupSize = groupMembers.size();
+            // synchronised on the managerThread
+            owner.fromListener(newMin, control, resend, groupSize, 
+                    totalPacketsReceived, totalBytesReceived, totalTransEventsReceived);
+        }
+    }
+
+    /**
+     * Return true if we should process this packet. Return false if we have
+     * already processed the packet.
+     */
+    public boolean isProcessPacket(String memberKey, long packetId) {
+
+        return incomingPacketsProcessed.isProcessPacket(memberKey, packetId);
+    }
+
+    public AckResendMessages getAckResendMessages(IncomingPacketsLastAck lastAck) {
+
+        return incomingPacketsProcessed.getAckResendMessages(lastAck);
+    }
+
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/mcast/McastSender.java

@@ -0,0 +1,135 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster.mcast;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import com.avaje.ebeaninternal.server.cluster.Packet;
+
+/**
+ * Handles the sending of Packets via DatagramPacket.
+ * 
+ * @author rbygrave
+ */
+public class McastSender {
+
+    private static final Logger logger = Logger.getLogger(McastSender.class.getName());
+
+    private final int port;
+
+    private final InetAddress inetAddress;
+
+    private final DatagramSocket sock;
+
+    private final InetSocketAddress sendAddr;
+
+    private final String senderHostPort;
+
+    
+    public McastSender(int port, String address, int sendPort, String sendAddress) {
+
+        try {
+            this.port = port;
+            this.inetAddress = InetAddress.getByName(address);
+
+            InetAddress sendInetAddress = null;
+            if (sendAddress != null) {
+                sendInetAddress = InetAddress.getByName(sendAddress);
+            } else {
+                sendInetAddress = InetAddress.getLocalHost();
+            }
+
+            if (sendPort > 0) {
+                this.sock = new DatagramSocket(sendPort, sendInetAddress);
+            } else {
+                this.sock = new DatagramSocket(new InetSocketAddress(sendInetAddress, 0));
+            }
+
+            String msg = "Cluster Multicast Sender on["+sendInetAddress.getHostAddress()+":"+sock.getLocalPort()+"]";
+            logger.info(msg);
+
+            this.sendAddr = new InetSocketAddress(sendInetAddress, sock.getLocalPort());
+            this.senderHostPort = sendInetAddress.getHostAddress()+":"+sock.getLocalPort();
+            
+        } catch (Exception e) {
+            String msg = "McastSender port:" + port + " sendPort:" + sendPort + " " + address;
+            throw new RuntimeException(msg, e);
+        }
+    }
+
+    /**
+     * Return the send Address so that if we have loopback messages we can
+     * detect if they where sent by this local sender and hence should be
+     * ignored.
+     */
+    public InetSocketAddress getAddress() {
+        return sendAddr;
+    }
+
+    /**
+     * Return the Host and Port of the sender. This is used to uniquely identify
+     * this instance in the cluster.
+     */
+    public String getSenderHostPort() {
+        return senderHostPort;
+    }
+
+    /**
+     * Send the packet.
+     */
+    public int sendPacket(Packet packet) throws IOException {
+
+        byte[] pktBytes = packet.getBytes();
+
+        if (logger.isLoggable(Level.FINE)){
+            logger.fine("OUTGOING packet: " + packet.getPacketId() + " size:" + pktBytes.length);
+        }
+
+        if (pktBytes.length > 65507){
+            logger.warning("OUTGOING packet: " + packet.getPacketId() + " size:" + pktBytes.length
+                    +" likely to be truncated using UDP with a MAXIMUM length of 65507");
+        }
+        
+        DatagramPacket pack = new DatagramPacket(pktBytes, pktBytes.length, inetAddress, port);
+        sock.send(pack);
+        
+        return pktBytes.length;
+    }
+
+    /**
+     * Send the list of Packets.
+     */
+    public int sendPackets(List<Packet> packets) throws IOException {
+
+        int totalBytes = 0;
+        for (int i = 0; i < packets.size(); i++) {
+            totalBytes += sendPacket(packets.get(i));
+        }
+        return totalBytes;
+    }
+    
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/mcast/McastStatus.java

@@ -0,0 +1,155 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster.mcast;
+
+/**
+ * Gives an overall status of this Cluster instance.
+ * <p>
+ * Ideally you want to see relatively low Re-send statistics.
+ * </p>
+ * 
+ * @author rbygrave
+ *
+ */
+public class McastStatus {
+
+    private final long totalTxnEventsSent;
+    private final long totalTxnEventsReceived;
+    
+    private final long totalPacketsSent;
+    private final long totalPacketsResent;
+    private final long totalPacketsReceived;
+    
+    private final long totalBytesSent;
+    private final long totalBytesResent;
+    private final long totalBytesReceived;
+
+    private final int currentGroupSize;
+    private final int outgoingPacketsCacheSize;
+    
+    private final long currentPacketId;
+    private final long minAckedPacketId;
+    private final String lastOutgoingAcks;
+    
+    public String getSummary() {
+        
+        StringBuilder sb = new StringBuilder(80);
+        sb.append("txnOut:").append(totalTxnEventsSent).append("; ");
+        sb.append("txnIn:").append(totalTxnEventsReceived).append("; ");
+        sb.append("outPackets:").append(totalPacketsSent).append("; ");
+        sb.append("outBytes:").append(totalBytesSent).append("; ");
+        sb.append("inPackets:").append(totalPacketsReceived).append("; ");
+        sb.append("inBytes:").append(totalBytesReceived).append("; ");
+        sb.append("resentPackets:").append(totalPacketsResent).append("; ");
+        sb.append("resentBytes:").append(totalBytesResent).append("; ");
+        sb.append("groupSize:").append(currentGroupSize).append("; ");
+        sb.append("cache:").append(outgoingPacketsCacheSize).append("; ");
+        sb.append("currentPacket:").append(currentPacketId).append("; ");
+        sb.append("minAckedPacket:").append(minAckedPacketId).append("; ");
+        sb.append("lastAck:").append(lastOutgoingAcks).append("; ");
+
+        return sb.toString();
+    }
+    
+    public McastStatus(int currentGroupSize,
+            int outgoingPacketsCacheSize,
+            long currentPacketId,
+            long minAckedPacketId,
+            String lastOutgoingAcks,
+            long totalTransEventsSent,
+            long totalTransEventsReceived,
+            long totalPacketsSent,
+            long totalPacketsResent,
+            long totalPacketsReceived,
+            long totalBytesSent,
+            long totalBytesResent,
+            long totalBytesReceived) {
+        
+        this.currentGroupSize = currentGroupSize;
+        this.outgoingPacketsCacheSize = outgoingPacketsCacheSize;
+        this.currentPacketId = currentPacketId;
+        this.minAckedPacketId = minAckedPacketId;
+        this.lastOutgoingAcks = lastOutgoingAcks;
+        this.totalTxnEventsSent = totalTransEventsSent;
+        this.totalTxnEventsReceived = totalTransEventsReceived;
+        this.totalPacketsSent = totalPacketsSent;
+        this.totalPacketsResent = totalPacketsResent;
+        this.totalPacketsReceived = totalPacketsReceived;
+
+        this.totalBytesSent = totalBytesSent;
+        this.totalBytesResent = totalBytesResent;
+        this.totalBytesReceived = totalBytesReceived;
+
+    }
+
+    
+    public long getTotalTxnEventsReceived() {
+        return totalTxnEventsReceived;
+    }
+
+    public long getTotalPacketsReceived() {
+        return totalPacketsReceived;
+    }
+
+    public long getTotalBytesSent() {
+        return totalBytesSent;
+    }
+
+    public long getTotalBytesResent() {
+        return totalBytesResent;
+    }
+
+    public long getTotalBytesReceived() {
+        return totalBytesReceived;
+    }
+
+    public String getLastOutgoingAcks() {
+        return lastOutgoingAcks;
+    }
+
+    public int getOutgoingPacketsCacheSize() {
+        return outgoingPacketsCacheSize;
+    }
+
+    public long getCurrentPacketId() {
+        return currentPacketId;
+    }
+
+    public long getMinAckedPacketId() {
+        return minAckedPacketId;
+    }
+
+    public long getTotalTxnEventsSent() {
+        return totalTxnEventsSent;
+    }
+
+    public long getTotalPacketsSent() {
+        return totalPacketsSent;
+    }
+
+    public long getTotalPacketsResent() {
+        return totalPacketsResent;
+    }
+
+    public long getCurrentGroupSize() {
+        return currentGroupSize;
+    }
+    
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/mcast/Message.java

@@ -0,0 +1,33 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster.mcast;
+
+import java.io.IOException;
+
+import com.avaje.ebeaninternal.server.cluster.BinaryMessageList;
+
+public interface Message {
+
+    public void writeBinaryMessage(BinaryMessageList msgList) throws IOException;
+
+    public boolean isControlMessage();
+    
+    public String getToHostPort();
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/mcast/MessageAck.java

@@ -0,0 +1,76 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster.mcast;
+
+import java.io.DataInput;
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+import com.avaje.ebeaninternal.server.cluster.BinaryMessage;
+import com.avaje.ebeaninternal.server.cluster.BinaryMessageList;
+
+public class MessageAck implements Message {
+
+    private final String toHostPort;
+    
+    private final long gotAllPacketId;
+
+    public MessageAck(String toHostPort, long gotAllPacketId) {
+        this.toHostPort = toHostPort;
+        this.gotAllPacketId = gotAllPacketId;
+    }
+
+    public String toString() {
+        return "Ack "+toHostPort+" "+gotAllPacketId;
+    }
+    
+    public boolean isControlMessage() {
+        return false;
+    }
+
+    public String getToHostPort() {
+        return toHostPort;
+    }
+
+    public long getGotAllPacketId() {
+        return gotAllPacketId;
+    }
+    
+    
+    public static MessageAck readBinaryMessage(DataInput dataInput) throws IOException {
+
+        String hostPort = dataInput.readUTF();
+        long gotAllPacketId = dataInput.readLong();
+        return new MessageAck(hostPort, gotAllPacketId);
+    }
+
+    public void writeBinaryMessage(BinaryMessageList msgList) throws IOException {
+        
+        BinaryMessage m = new BinaryMessage(toHostPort.length() * 2 + 20);
+        
+        DataOutputStream os = m.getOs();
+        os.writeInt(BinaryMessage.TYPE_MSGACK);
+        os.writeUTF(toHostPort);
+        os.writeLong(gotAllPacketId);
+        os.flush();
+        
+        msgList.add(m);
+    }
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/mcast/MessageControl.java

@@ -0,0 +1,92 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster.mcast;
+
+import java.io.DataInput;
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+import com.avaje.ebeaninternal.server.cluster.BinaryMessage;
+import com.avaje.ebeaninternal.server.cluster.BinaryMessageList;
+
+public class MessageControl implements Message {
+
+    public static final short TYPE_JOIN = 1;
+    public static final short TYPE_LEAVE = 2;
+    public static final short TYPE_PING = 3;
+    public static final short TYPE_JOINRESPONSE = 7;
+    public static final short TYPE_PINGRESPONSE = 8;
+    
+    private final short controlType;
+    private final String fromHostPort;
+    
+    public static MessageControl readBinaryMessage(DataInput dataInput) throws IOException {
+        short controlType = dataInput.readShort();
+        String hostPort = dataInput.readUTF();
+        return new MessageControl(controlType, hostPort);
+    }
+    
+    public MessageControl(short controlType, String helloFromHostPort) {
+        this.controlType = controlType;
+        this.fromHostPort = helloFromHostPort;
+    }
+
+
+    public String toString() {
+        switch (controlType) {
+        case TYPE_JOIN: return "Join "+fromHostPort;
+        case TYPE_LEAVE: return "Leave "+fromHostPort;
+        case TYPE_PING: return "Ping "+fromHostPort;
+        case TYPE_PINGRESPONSE: return "PingResponse "+fromHostPort;            
+
+        default:
+            throw new RuntimeException("Invalid controlType "+controlType);
+        }
+    }
+    
+    public boolean isControlMessage() {
+        return true;
+    }
+
+    public short getControlType() {
+        return controlType;
+    }
+
+    public String getToHostPort() {
+        return "*";
+    }
+    
+    public String getFromHostPort() {
+        return fromHostPort;
+    }
+
+    public void writeBinaryMessage(BinaryMessageList msgList) throws IOException {
+        
+        BinaryMessage m = new BinaryMessage(fromHostPort.length() * 2 + 10);
+        
+        DataOutputStream os = m.getOs();
+        os.writeInt(BinaryMessage.TYPE_MSGCONTROL);
+        os.writeShort(controlType);
+        os.writeUTF(fromHostPort);
+        os.flush();
+        
+        msgList.add(m);
+    }
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/mcast/MessageResend.java

@@ -0,0 +1,96 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster.mcast;
+
+import java.io.DataInput;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.avaje.ebeaninternal.server.cluster.BinaryMessage;
+import com.avaje.ebeaninternal.server.cluster.BinaryMessageList;
+
+public class MessageResend implements Message {
+
+    private final String toHostPort;
+    
+    private final List<Long> resendPacketIds;
+
+    public MessageResend(String toHostPort, List<Long> resendPacketIds) {
+        this.toHostPort = toHostPort;
+        this.resendPacketIds = resendPacketIds;
+    }
+    
+    public MessageResend(String toHostPort) {
+        this(toHostPort, new ArrayList<Long>(4));
+    }
+
+    public String toString() {
+        return "Resend "+toHostPort+" "+resendPacketIds;
+    }
+    
+    public boolean isControlMessage() {
+        return false;
+    }
+
+    public String getToHostPort() {
+        return toHostPort;
+    }
+
+    public void add(long packetId){
+        resendPacketIds.add(Long.valueOf(packetId));
+    }
+    
+    public List<Long> getResendPacketIds() {
+        return resendPacketIds;
+    }
+
+    public static MessageResend readBinaryMessage(DataInput dataInput) throws IOException {
+
+        String hostPort = dataInput.readUTF();
+        
+        MessageResend msg = new MessageResend(hostPort);
+        
+        int numberOfPacketIds = dataInput.readInt();
+        for (int i = 0; i < numberOfPacketIds; i++) {
+            long packetId = dataInput.readLong();
+            msg.add(packetId);
+        }
+        
+        return msg;
+    }
+
+    public void writeBinaryMessage(BinaryMessageList msgList) throws IOException {
+        
+        BinaryMessage m = new BinaryMessage(toHostPort.length() * 2 + 20);
+        
+        DataOutputStream os = m.getOs();
+        os.writeInt(BinaryMessage.TYPE_MSGRESEND);
+        os.writeUTF(toHostPort);
+        os.writeInt(resendPacketIds.size());
+        for (int i = 0; i < resendPacketIds.size(); i++) {
+            Long packetId = resendPacketIds.get(i);
+            os.writeLong(packetId.longValue());
+        }
+        os.flush();
+        msgList.add(m);
+    }
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/mcast/OutgoingPacketsAcked.java

@@ -0,0 +1,125 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster.mcast;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class OutgoingPacketsAcked {
+
+    private long minimumGotAllPacketId;
+
+    private Map<String, GroupMemberAck> recievedByMap = new HashMap<String, GroupMemberAck>();
+
+    public int getGroupSize() {
+        synchronized (this) {
+            return recievedByMap.size();
+        }
+    }
+
+    public long getMinimumGotAllPacketId() {
+        synchronized (this) {
+            return minimumGotAllPacketId;
+        }
+    }
+    
+    public void removeMember(String groupMember){
+        synchronized (this) {
+            recievedByMap.remove(groupMember);
+            resetGotAllMin();
+        }
+    }
+
+    private boolean resetGotAllMin() {
+        
+        long tempMin;
+        if (recievedByMap.isEmpty()){
+            //System.out.println("       --  -- -- -- "+recievedByMap.isEmpty());
+            tempMin = Long.MAX_VALUE;
+        } else {
+            tempMin = Long.MAX_VALUE;
+        }
+        
+        for (GroupMemberAck groupMemAck : recievedByMap.values()) {
+            long memberMin = groupMemAck.getGotAllPacketId();
+            if (memberMin < tempMin){
+                //System.out.println("                                -- new tmpMin "+memberMin);
+                tempMin = memberMin;
+            }
+        }
+        
+        if (tempMin != minimumGotAllPacketId) {
+            minimumGotAllPacketId = tempMin;
+            return true;
+        } else {
+            return false;
+        }
+    }
+    
+    public long receivedAck(String groupMember, MessageAck ack) {
+        
+        synchronized (this) {
+            
+            boolean checkMin = false;
+            
+            GroupMemberAck groupMemberAck = recievedByMap.get(groupMember);
+            if (groupMemberAck == null) {
+                //System.out.println("                               -- new groupMemberAck");
+                groupMemberAck = new GroupMemberAck();
+                groupMemberAck.setIfBigger(ack.getGotAllPacketId());
+                recievedByMap.put(groupMember, groupMemberAck);
+                checkMin = true;
+            } else {
+                checkMin = groupMemberAck.getGotAllPacketId() == minimumGotAllPacketId; 
+                //System.out.println("                               -- existing groupMemberAck, checkMin:"+checkMin+" "+groupMemberAck.getGotAllPacketId());
+                groupMemberAck.setIfBigger(ack.getGotAllPacketId());
+            }
+            
+            boolean minChanged = false;
+            
+            //System.out.println("               -- checkMin:"+checkMin+" minimumGotAllPacketId:"+minimumGotAllPacketId);
+            if (checkMin || minimumGotAllPacketId == 0){
+                
+                minChanged = resetGotAllMin();
+                //System.out.println("               -- minChanged:"+minChanged+" minimumGotAllPacketId:"+minimumGotAllPacketId);
+            }
+            
+            return minChanged ? minimumGotAllPacketId : 0;
+        }
+    }
+
+    private static class GroupMemberAck {
+
+        private long gotAllPacketId;
+
+        private GroupMemberAck() {
+        }
+
+        private long getGotAllPacketId() {
+            return gotAllPacketId;
+        }
+
+        private void setIfBigger(long newGotAll) {
+            if (newGotAll > gotAllPacketId) {
+                gotAllPacketId = newGotAll;
+            }
+        }
+    }
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/mcast/OutgoingPacketsCache.java

@@ -0,0 +1,85 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster.mcast;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+import com.avaje.ebeaninternal.server.cluster.Packet;
+
+/**
+ * Cache of the outgoing packets.
+ * <p>
+ * These are held until we receive ACKs from the other members of the cluster to
+ * say they have received the packets.
+ * </p>
+ * 
+ * @author rbygrave
+ * 
+ */
+public class OutgoingPacketsCache {
+
+    private final Map<Long, Packet> packetMap = new TreeMap<Long, Packet>();
+
+    public int size() {
+        return packetMap.size();
+    }
+
+    public Packet getPacket(Long packetId) {
+        return packetMap.get(packetId);
+    }
+
+    public String toString() {
+        return packetMap.keySet().toString();
+    }
+
+    /**
+     * Remove the packet when we give up trying to send it out.
+     */
+    public void remove(Packet packet) {
+        packetMap.remove(packet.getPacketId());
+    }
+
+    public void registerPackets(List<Packet> packets) {
+        for (int i = 0; i < packets.size(); i++) {
+            Packet p = packets.get(i);
+            packetMap.put(p.getPacketId(), p);
+        }
+    }
+
+    public int trimAll() {
+        int size = packetMap.size();
+        packetMap.clear();
+        return size;
+    }
+
+    public void trimAcknowledgedMessages(long minAcked) {
+        Iterator<Long> it = packetMap.keySet().iterator();
+        while (it.hasNext()) {
+            Long pktId = it.next();
+            if (minAcked >= pktId.longValue()) {
+                it.remove();
+            }
+        }
+    }
+
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/package.html

@@ -0,0 +1,12 @@
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=iso-8859-1">
+	<TITLE>AvajeLib</TITLE>
+</HEAD>
+<Body BGCOLOR="#ffffff">
+Clustering service for an application.
+<P>
+A framework for supporting clustering of servers.
+</P>
+</Body>
+</HTML>

src/main/java/com/avaje/ebeaninternal/server/cluster/socket/RequestProcessor.java

@@ -0,0 +1,76 @@
+/**
+ *  Copyright (C) 2006  Robin Bygrave
+ *  
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *  
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *  
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+package com.avaje.ebeaninternal.server.cluster.socket;
+
+import java.io.IOException;
+import java.net.Socket;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * This parses and dispatches a request to the appropriate handler.
+ * <p>
+ * Looks up the appropriate RequestHandler 
+ * and then gets it to process the Client request.<P>
+ * </p>
+ * Note that this is a Runnable because it is assigned to the ThreadPool.
+ */
+class RequestProcessor implements Runnable {
+
+	private static final Logger logger = Logger.getLogger(RequestProcessor.class.getName());
+	
+    private final Socket clientSocket;
+    
+    private final SocketClusterBroadcast owner;
+    
+    /**
+	 *  Create including the Listener (used to lookup the Request Handler) and
+	 *  the socket itself. 
+	 */
+	public RequestProcessor(SocketClusterBroadcast owner, Socket clientSocket) {
+		this.clientSocket = clientSocket;
+		this.owner = owner;
+	}
+	
+	/**
+	 *  This will parse out the command.  Lookup the appropriate Handler and 
+	 *  pass the information to the handler for processing.
+	 *  <P>Dev Note: the command parsing is processed here so that it is preformed
+	 *  by the assigned thread rather than the listeners thread.</P>
+	 */
+	public void run() {
+		try {
+			SocketConnection sc = new SocketConnection(clientSocket);
+			
+			while(true){
+			    if (owner.process(sc)) {
+			        // got the offline message or timeout
+			        break;
+			    }
+			}
+			sc.disconnect();
+			
+		} catch (IOException e) {
+			logger.log(Level.SEVERE, null, e);
+		} catch (ClassNotFoundException e) {
+            logger.log(Level.SEVERE, null, e);
+        }
+	}
+
+
+}; 

src/main/java/com/avaje/ebeaninternal/server/cluster/socket/SocketClient.java

@@ -0,0 +1,151 @@
+/**
+ *  Copyright (C) 2006  Robin Bygrave
+ *  
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *  
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *  
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+package com.avaje.ebeaninternal.server.cluster.socket;
+
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+import java.io.OutputStream;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+
+/**
+ * The client side of the socket clustering.
+ */
+class SocketClient {
+
+    private static final Logger logger = Logger.getLogger(SocketClient.class.getName());
+    
+    private final InetSocketAddress address;
+    
+    private final String hostPort;
+    
+    private boolean online;
+
+    private Socket socket;
+    private OutputStream os;
+    private ObjectOutputStream oos;
+    
+    /**
+     * Construct with an IP address and port.
+     */
+    public SocketClient(InetSocketAddress address) {
+        this.address = address;
+        this.hostPort = address.getHostName()+":"+address.getPort();
+    }
+
+    public String getHostPort() {
+        return hostPort;
+    }
+    
+    public int getPort() {
+        return address.getPort();
+    }
+    
+    public boolean isOnline() {
+        return online;
+    }
+
+    public void setOnline(boolean online) throws IOException {
+        if (online){
+            setOnline();
+        } else {
+            disconnect();
+        }
+    }
+
+    
+    /**
+     * Set whether the client is thought to be online.
+     */
+    private void setOnline() throws IOException {
+        connect();
+        this.online = true;
+    }
+      
+    public void reconnect() throws IOException {
+        disconnect();
+        connect();
+    }
+    
+    private void connect() throws IOException {
+        if (socket != null){
+            throw new IllegalStateException("Already got a socket connection?");
+        }
+        Socket s = new Socket();
+        s.setKeepAlive(true);
+        s.connect(address);
+        
+        this.socket = s;
+        this.os = socket.getOutputStream();
+    }
+    
+    public void disconnect() {
+        this.online = false;
+        if (socket != null){
+            
+            try {
+                socket.close();
+            } catch (IOException e) {
+                String msg = "Error disconnecting from Cluster member "+hostPort;
+                logger.log(Level.INFO, msg, e);
+            }
+            
+            os = null;
+            oos = null;
+            socket = null;
+        }
+    }
+    
+    public boolean register(SocketClusterMessage registerMsg) {
+        
+        try {
+            setOnline();
+            send(registerMsg);
+            return true;
+        } catch (IOException e) {
+            disconnect();
+            return false;
+        }
+    }
+    
+    public boolean send(SocketClusterMessage msg) throws IOException {
+
+        if (online){
+            writeObject(msg);
+            return true;
+            
+        } else {
+            return false;
+        }
+        
+    }
+    
+    private void writeObject(Object object) throws IOException {
+        if (oos == null){
+            this.oos = new ObjectOutputStream(os);
+        }
+        oos.writeObject(object);
+        oos.flush();        
+    }
+    
+
+    
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/socket/SocketClusterBroadcast.java

@@ -0,0 +1,265 @@
+/**
+ *  Copyright (C) 2006  Robin Bygrave
+ *  
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *  
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *  
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+package com.avaje.ebeaninternal.server.cluster.socket;
+
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.net.InetSocketAddress;
+import java.util.HashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.persistence.PersistenceException;
+
+import com.avaje.ebean.config.GlobalProperties;
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.server.cluster.ClusterBroadcast;
+import com.avaje.ebeaninternal.server.cluster.ClusterManager;
+import com.avaje.ebeaninternal.server.cluster.DataHolder;
+import com.avaje.ebeaninternal.server.cluster.SerialiseTransactionHelper;
+import com.avaje.ebeaninternal.server.lib.util.StringHelper;
+import com.avaje.ebeaninternal.server.transaction.RemoteTransactionEvent;
+
+/**
+ * Broadcast messages across the cluster using sockets. 
+ */
+public class SocketClusterBroadcast implements ClusterBroadcast {
+
+	private static final Logger logger = Logger.getLogger(SocketClusterBroadcast.class.getName());
+	
+	private final SocketClient local;
+    
+	private final HashMap<String,SocketClient> clientMap;
+        
+    private final SocketClusterListener listener;
+	
+    private SocketClient[] members;
+
+    private ClusterManager clusterManager;
+
+    private final TxnSerialiseHelper txnSerialiseHelper = new TxnSerialiseHelper();    
+    
+    private final AtomicInteger txnOutgoing = new AtomicInteger();
+    private final AtomicInteger txnIncoming = new AtomicInteger();
+    
+    
+	public SocketClusterBroadcast( ){
+	    
+        String localHostPort = GlobalProperties.get("ebean.cluster.local", null);
+        String members = GlobalProperties.get("ebean.cluster.members", null);
+
+        logger.info("Clustering using Sockets local["+localHostPort+"] members["+members+"]");
+        
+        this.local = new SocketClient(parseFullName(localHostPort));
+        this.clientMap = new HashMap<String, SocketClient>();
+        
+        String[] memArray = StringHelper.delimitedToArray(members, ",", false);
+        for (int i = 0; i < memArray.length; i++) {
+            InetSocketAddress member = parseFullName(memArray[i]);
+            SocketClient client = new SocketClient(member);
+            if (!local.getHostPort().equalsIgnoreCase(client.getHostPort())) {
+                // don't add the local one ...
+                clientMap.put(client.getHostPort(), client);
+            }
+        }
+        
+        this.members = clientMap.values().toArray(new SocketClient[clientMap.size()]);
+        this.listener = new SocketClusterListener(this, local.getPort());
+	}
+	
+	/**
+	 * Return the current status of this instance.
+	 */
+	public SocketClusterStatus getStatus() {
+	    
+	    // count of online members
+	    int currentGroupSize = 0;
+        for (int i = 0; i < members.length; i++) {
+            if (members[i].isOnline()) {
+                ++currentGroupSize;
+            }            
+        }
+	    int txnIn = txnIncoming.get();
+	    int txnOut = txnOutgoing.get();
+	    
+	    return new SocketClusterStatus(currentGroupSize, txnIn, txnOut);
+	}
+		
+	public void startup(ClusterManager clusterManager) {
+	    
+	    this.clusterManager = clusterManager;
+        try {
+            listener.startListening();
+            register();
+
+        } catch (IOException e) {
+            throw new PersistenceException(e);
+        }
+    }
+
+    public void shutdown() {
+	    deregister();
+	    listener.shutdown();
+	}
+		
+    /**
+     * Register with all the other members of the Cluster.
+     */
+    private void register() {
+
+        SocketClusterMessage h = SocketClusterMessage.register(local.getHostPort(), true);
+        
+        for (int i = 0; i < members.length; i++) {
+            boolean online = members[i].register(h);
+            
+            String msg = "Cluster Member ["+members[i].getHostPort()+"] online["+online+"]";
+            logger.info(msg);
+        }
+    }
+
+    protected void setMemberOnline(String fullName, boolean online) throws IOException {
+        synchronized (clientMap) {
+            String msg = "Cluster Member ["+fullName+"] online["+online+"]";
+            logger.info(msg);
+            SocketClient member = clientMap.get(fullName);
+            member.setOnline(online);
+        }
+    }
+
+    private void send(SocketClient client, SocketClusterMessage msg) {
+
+        try {
+            // alternative would be to connect/disconnect here
+            // but prefer to use keepalive 
+            client.send(msg);
+            
+        } catch (Exception ex){
+            logger.log(Level.SEVERE, "Error sending message", ex);
+            try {
+                client.reconnect();
+            } catch (IOException e) {
+                logger.log(Level.SEVERE, "Error trying to reconnect", ex);
+            }
+        }
+    }
+
+    /**
+     * Send the payload to all the members of the cluster.
+     */
+    public void broadcast(RemoteTransactionEvent remoteTransEvent) {
+    	try {
+    	    
+    	    txnOutgoing.incrementAndGet();
+            DataHolder dataHolder = txnSerialiseHelper.createDataHolder(remoteTransEvent);
+            SocketClusterMessage msg = SocketClusterMessage.transEvent(dataHolder);
+            broadcast(msg);
+    	} catch (Exception e){
+    	    String msg = "Error sending RemoteTransactionEvent "+remoteTransEvent+" to cluster members.";
+    	    logger.log(Level.SEVERE, msg, e);
+    	}
+    }
+
+    protected void broadcast(SocketClusterMessage msg) {
+        
+        for (int i = 0; i < members.length; i++) {
+            send(members[i], msg);
+        }
+    }
+    
+    /**
+     * Leave the cluster.
+     */
+    private void deregister() {
+        
+        SocketClusterMessage h = SocketClusterMessage.register(local.getHostPort(), false);
+        broadcast(h);
+        
+        for (int i = 0; i < members.length; i++) {
+            members[i].disconnect();
+        }
+    }
+
+    /**
+     * Process a Cluster message.
+     */
+    protected boolean process(SocketConnection request) throws IOException, ClassNotFoundException {
+
+        try {
+            SocketClusterMessage h = (SocketClusterMessage)request.readObject();
+            
+            if (h.isRegisterEvent()){
+                setMemberOnline(h.getRegisterHost(), h.isRegister());
+            
+            } else {
+                txnIncoming.incrementAndGet();
+                DataHolder dataHolder = h.getDataHolder();
+                RemoteTransactionEvent transEvent = txnSerialiseHelper.read(dataHolder);
+                transEvent.run();
+            }
+            
+            if (h.isRegisterEvent() && !h.isRegister()){
+                // instance shutting down  
+                return true;
+            } else {
+                return false;
+            }
+        } catch (InterruptedIOException e) {
+            String msg = "Timeout waiting for message";
+            logger.log(Level.INFO, msg, e);
+            try {
+                request.disconnect();
+            } catch (IOException ex){
+                logger.log(Level.INFO, "Error disconnecting after timeout", ex);    
+            }
+            return true;
+        }
+    }
+    
+
+    /**
+     * Parse a host:port into a InetSocketAddress.
+     */
+    private InetSocketAddress parseFullName(String hostAndPort) {
+        
+        try {
+            hostAndPort = hostAndPort.trim();
+            int colonPos = hostAndPort.indexOf(":");
+            if (colonPos == -1) {
+                String msg = "No colon \":\" in "+hostAndPort;
+                throw new IllegalArgumentException(msg);
+            }
+            String host = hostAndPort.substring(0, colonPos);
+            String sPort = hostAndPort.substring(colonPos + 1, hostAndPort.length());
+            int port = Integer.parseInt(sPort);
+            
+            return new InetSocketAddress(host, port);
+            
+        } catch (Exception ex){
+            throw new RuntimeException("Error parsing ["+hostAndPort+"] for the form [host:port]", ex);
+        }
+    }
+    
+    class TxnSerialiseHelper extends SerialiseTransactionHelper {
+
+        @Override
+        public SpiEbeanServer getEbeanServer(String serverName) {
+            return (SpiEbeanServer)clusterManager.getServer(serverName);
+        }
+    }
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/socket/SocketClusterListener.java

@@ -0,0 +1,181 @@
+/**
+ *  Copyright (C) 2006  Robin Bygrave
+ *  
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *  
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *  
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+package com.avaje.ebeaninternal.server.cluster.socket;
+
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.SocketException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import com.avaje.ebeaninternal.server.lib.thread.ThreadPool;
+import com.avaje.ebeaninternal.server.lib.thread.ThreadPoolManager;
+
+/**
+ * Serverside multithreaded socket listener. Accepts connections and dispatches
+ * them to an appropriate handler.
+ * <p>
+ * This is designed as a single port listener, where part of the connection
+ * protocol determines which service the client is requesting (rather than a
+ * port per service).
+ * </p>
+ * <p>
+ * It has its own daemon background thread that handles the accept() loop on the
+ * ServerSocket.
+ * </p>
+ */
+class SocketClusterListener implements Runnable {
+
+	private static final Logger logger = Logger.getLogger(SocketClusterListener.class.getName());
+	
+    /**
+     * The port the SocketListener uses.
+     */
+	private final int port;
+
+    /**
+     * The length of the socket accept timeout.
+     */
+    private final int listenTimeout = 60000;
+
+    /**
+     * The server socket used to listen for requests.
+     */
+    private final ServerSocket serverListenSocket;
+
+    /**
+     * The listening thread.
+     */
+    private final Thread listenerThread;
+
+    /**
+     * The pool of threads that actually do the parsing execution of requests.
+     */
+    private final ThreadPool threadPool;
+
+    private final SocketClusterBroadcast owner;
+
+    /**
+     * shutting down flag.
+     */
+    boolean doingShutdown;
+
+    /**
+     * Whether the listening thread is busy assigning a request to a thread.
+     */
+    boolean isActive;
+
+    /**
+     * Construct with a given thread pool name.
+     */
+    public SocketClusterListener(SocketClusterBroadcast owner, int port) {
+        this.owner = owner;
+        this.threadPool = ThreadPoolManager.getThreadPool("EbeanClusterMember");
+        this.port = port;
+        
+        try {
+            this.serverListenSocket = new ServerSocket(port);
+            this.serverListenSocket.setSoTimeout(listenTimeout);
+            this.listenerThread = new Thread(this, "EbeanClusterListener");
+            
+        } catch (IOException e){
+            String msg = "Error starting cluster socket listener on port "+port;
+            throw new RuntimeException(msg,e);
+        }
+    }
+
+    /**
+     * Returns the port the listener is using.
+     */
+    public int getPort() {
+        return port;
+    }
+
+    /**
+     * Start listening for requests.
+     */
+    public void startListening() throws IOException {
+        this.listenerThread.setDaemon(true);
+        this.listenerThread.start();
+    }
+    
+    /**
+     * Shutdown this listener.
+     */
+    public void shutdown() {
+        doingShutdown = true;
+        try {
+            if (isActive) {
+                synchronized (listenerThread) {
+                    try {
+                        listenerThread.wait(1000);
+                    } catch (InterruptedException e) {
+                        // OK to ignore as expected to Interrupt for shutdown.
+                        ;
+                    }
+                }
+            }
+            listenerThread.interrupt();
+            serverListenSocket.close();
+        } catch (IOException e) {
+        	logger.log(Level.SEVERE, null, e);
+        }
+    }
+    
+    /**
+     * This is a runnable and so this must be public. Don't call this externally
+     * but rather call the startListening() method.
+     */
+    public void run() {
+        // run in loop until doingShutdown is true...
+        while (!doingShutdown) {
+            try {
+                synchronized (listenerThread) {
+                    Socket clientSocket = serverListenSocket.accept();
+
+                    isActive = true;
+                    
+                    Runnable request = new RequestProcessor(owner, clientSocket);
+                    threadPool.assign(request, true);
+
+                    isActive = false;
+                }
+            } catch (SocketException e) {
+                if (doingShutdown) {
+                    String msg = "doingShutdown and accept threw:"+ e.getMessage();
+                    logger.info(msg);
+
+                } else {
+                	logger.log(Level.SEVERE, null, e);
+                }
+
+            } catch (InterruptedIOException e) {
+                // this will happen when the server is very quiet.
+                // that is, no requests
+                logger.fine("Possibly expected due to accept timeout?" + e.getMessage());
+
+            } catch (IOException e) {
+                // log it and continue in the loop...
+            	logger.log(Level.SEVERE, null, e);
+            }
+        }
+    }
+
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/socket/SocketClusterMessage.java

@@ -0,0 +1,95 @@
+/**
+ *  Copyright (C) 2006  Robin Bygrave
+ *  
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *  
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *  
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+package com.avaje.ebeaninternal.server.cluster.socket;
+
+import java.io.Serializable;
+
+import com.avaje.ebeaninternal.server.cluster.DataHolder;
+import com.avaje.ebeaninternal.server.cluster.Packet;
+
+/**
+ * The messages broadcast around the cluster.
+ */
+public class SocketClusterMessage implements Serializable {
+
+    private static final long serialVersionUID = 2993350408394934473L;
+    
+    private final String registerHost;
+
+    private final boolean register;
+    
+    private final DataHolder dataHolder;
+    
+    public static SocketClusterMessage register(String registerHost, boolean register){
+        return new SocketClusterMessage(registerHost, register);
+    }
+
+    public static SocketClusterMessage transEvent(DataHolder transEvent){
+        return new SocketClusterMessage(transEvent);
+    }
+    
+    public static SocketClusterMessage packet(Packet packet){
+        DataHolder d = new DataHolder(packet.getBytes());
+        return new SocketClusterMessage(d);
+    }
+    
+    /**
+     * Used to construct a Child AttributeMap.
+     */
+    private SocketClusterMessage(String registerHost, boolean register) {
+        this.registerHost = registerHost;
+        this.register = register;
+        this.dataHolder = null;
+    }
+    
+    private SocketClusterMessage(DataHolder dataHolder) {
+        this.dataHolder = dataHolder;
+        this.registerHost = null;
+        this.register = false;
+    }
+
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        if (registerHost != null){
+            sb.append("register ");
+            sb.append(register);
+            sb.append(" ");
+            sb.append(registerHost);
+        } else {
+            sb.append("transEvent ");
+        }
+        return sb.toString();
+    }
+    
+    public boolean isRegisterEvent() {
+        return registerHost != null;
+    }
+
+    public String getRegisterHost() {
+        return registerHost;
+    }
+
+    public boolean isRegister() {
+        return register;
+    }
+
+    public DataHolder getDataHolder() {
+        return dataHolder;
+    }
+   
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/socket/SocketClusterStatus.java

@@ -0,0 +1,60 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.cluster.socket;
+
+/**
+ * The current state of this cluster member. 
+ * 
+ * @author rbygrave
+ */
+public class SocketClusterStatus {
+
+    private final int currentGroupSize;
+    private final int txnIncoming;
+    private final int txtOutgoing;
+    
+    public SocketClusterStatus(int currentGroupSize, int txnIncoming, int txnOutgoing) {
+        this.currentGroupSize = currentGroupSize;
+        this.txnIncoming = txnIncoming;
+        this.txtOutgoing = txnOutgoing;
+    }
+    
+    /**
+     * Return the number of members of the cluster currently online.
+     */
+    public int getCurrentGroupSize() {
+        return currentGroupSize;
+    }
+
+    /**
+     * Return the number of Remote transactions received.
+     */
+    public int getTxnIncoming() {
+        return txnIncoming;
+    }
+
+    /**
+     * Return the number of transactions sent to the cluster.
+     */
+    public int getTxtOutgoing() {
+        return txtOutgoing;
+    }
+    
+}

src/main/java/com/avaje/ebeaninternal/server/cluster/socket/SocketConnection.java

@@ -0,0 +1,146 @@
+/**
+ *  Copyright (C) 2006  Robin Bygrave
+ *  
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *  
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *  
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+package com.avaje.ebeaninternal.server.cluster.socket;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.OutputStream;
+import java.net.Socket;
+
+/**
+ * The client side of a TCP Sockect connection.
+ */
+class SocketConnection {
+
+    /**
+     * The object underlying objectOutputStream. 
+     */
+    ObjectOutputStream oos;
+    
+    /**
+     * The underlying ObjectInputStream.
+     */
+    ObjectInputStream ois;
+    
+    /**
+     * The underlying inputStream.
+     */
+    InputStream is;
+    
+    /**
+     * The underlying outputStream.
+     */
+    OutputStream os;
+    
+    /**
+     * The underlying socket.
+     */
+    Socket socket;
+   
+    /**
+     * Create for a given Socket.
+     */
+    public SocketConnection(Socket socket) throws IOException {
+        this.is = socket.getInputStream();
+        this.os = socket.getOutputStream();
+        this.socket = socket;
+    }
+    
+    /**
+     * Disconnect from the server. 
+     */
+    public void disconnect() throws IOException {
+        os.flush();
+        socket.close();
+    }
+    
+    /**
+     * Flush the outputStream.
+     */
+    public void flush() throws IOException {
+        os.flush();
+    }
+
+    /**
+     * Read an object from the object input stream.
+     */
+    public Object readObject() throws IOException, ClassNotFoundException {
+        return getObjectInputStream().readObject();
+    }
+
+    /**
+     * Write an object to the object output stream.
+     */
+    public ObjectOutputStream writeObject(Object object) throws IOException {
+        ObjectOutputStream oos = getObjectOutputStream(); 
+        oos.writeObject(object);
+        return oos;
+    }
+    
+    /**
+     * Get the object output stream.
+     */
+    public ObjectOutputStream getObjectOutputStream() throws IOException {
+        if (oos == null){
+            oos = new ObjectOutputStream(os);
+        }
+        return oos;
+    }
+    
+    /**
+     * Get the object input stream.
+     */
+    public ObjectInputStream getObjectInputStream() throws IOException {
+        if (ois == null){
+        	ois = new ObjectInputStream(is);
+        }
+        return ois;
+    }
+    
+    
+    /**
+     * Set the ObjectInputStream to use.
+     */
+    public void setObjectInputStream(ObjectInputStream ois) {
+		this.ois = ois;
+	}
+
+    /**
+     * Set the ObjectOutputStream to use.
+     */
+	public void setObjectOutputStream(ObjectOutputStream oos) {
+		this.oos = oos;
+	}
+
+	/**
+     * Return the underlying input stream.
+     */
+    public InputStream getInputStream() throws IOException  {
+        return is;
+    }
+    
+    /**
+     * Return the underlying output stream.
+     */
+    public OutputStream getOutputStream() throws IOException {
+        return os;
+    }
+
+}

src/main/java/com/avaje/ebeaninternal/server/core/BasicTypeConverter.java

@@ -0,0 +1,493 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.sql.Timestamp;
+import java.sql.Types;
+import java.util.Calendar;
+import java.util.UUID;
+
+
+/**
+ * Default implementation of TypeConverter.
+ * <p>
+ * Converts objects to the required type if required.
+ * </p>
+ */
+public final class BasicTypeConverter implements Serializable {
+
+	private static final long serialVersionUID = 7691463236204070311L;
+	
+	/**
+	 * Type code for java.util.Calendar.
+	 */
+	public static final int UTIL_CALENDAR = -999998986;
+
+	/**
+	 * Type code for java.util.Date.
+	 */
+	public static final int UTIL_DATE = -999998988;
+
+	/**
+	 * Type code for java.math.BigInteger.
+	 */
+	public static final int MATH_BIGINTEGER = -999998987;
+
+	/**
+	 * Type code for an Enum type.
+	 */
+	public static final int ENUM = -999998989;
+	
+	private BasicTypeConverter() {
+	}
+
+	/**
+	 * Convert the Object to the required data type.
+	 * 
+	 * @param value
+	 *            the Object value
+	 * @param toDataType
+	 *            the dataType as per java.sql.Types.
+	 */
+	public static Object convert(Object value, int toDataType) {
+
+		try {
+			switch (toDataType) {
+				case UTIL_DATE: {
+					return toUtilDate(value);
+				}
+				case UTIL_CALENDAR: {
+					return toCalendar(value);
+				}
+				case Types.BIGINT: {
+					return toLong(value);
+				}
+				case Types.INTEGER: {
+					return toInteger(value);
+				}
+				case Types.BIT: {
+					return toBoolean(value);
+				}
+				case Types.TINYINT: {
+					return toByte(value);
+				}
+				case Types.SMALLINT: {
+					return toShort(value);
+				}
+				case Types.NUMERIC: {
+					return toBigDecimal(value);
+				}
+				case Types.DECIMAL: {
+					return toBigDecimal(value);
+				}
+				case Types.REAL: {
+					return toFloat(value);
+				}
+				case Types.DOUBLE: {
+					return toDouble(value);
+				}
+				case Types.FLOAT: {
+					return toDouble(value);
+				}
+				case Types.BOOLEAN: {
+					return toBoolean(value);
+				}
+				case Types.TIMESTAMP: {
+					return toTimestamp(value);
+				}
+				case Types.DATE: {
+					return toDate(value);
+				}
+				case Types.VARCHAR: {
+					return toString(value);
+				}
+				case Types.CHAR: {
+					return toString(value);
+				}
+				case Types.OTHER: {
+					return value;
+				}
+				case Types.JAVA_OBJECT: {
+					return value;
+				}
+				case Types.BINARY:
+				case Types.LONGVARBINARY:
+				case Types.BLOB: {
+					return value;
+				}
+				case Types.LONGVARCHAR:
+				case Types.CLOB: {
+					return value;
+				}
+				default: {
+					String msg = "Unhandled data type [" + toDataType + "] converting [" + value + "]";
+					throw new RuntimeException(msg);
+				}
+			}
+		} catch (ClassCastException e) {
+			String m = "ClassCastException converting to data type [" + toDataType + "] value [" + value + "]";
+			throw new RuntimeException(m);
+		}
+	}
+
+	/**
+	 * Convert the value to a String.
+	 */
+	public static String toString(Object value) {
+
+		if (value == null) {
+			return null;
+		}
+		if (value instanceof String) {
+			return (String) value;
+		}
+		if (value instanceof char[]) {
+			return String.valueOf((char[]) value);
+		}
+
+		return value.toString();
+	}
+
+	
+    /**
+     * Convert the value to a Boolean with an explicit String true value.
+     */
+    public static Boolean toBoolean(Object value, String dbTrueValue) {
+
+        if (value == null) {
+            return null;
+        }
+        if (value instanceof Boolean) {
+            return (Boolean) value;
+        }
+        String s = value.toString();
+        return s.equalsIgnoreCase(dbTrueValue);
+	}
+    
+	/**
+	 * Convert the value to a Boolean. Can be a Boolean or the string values
+	 * "true" or "false".
+	 */
+	public static Boolean toBoolean(Object value) {
+
+		if (value == null) {
+			return null;
+		}
+		if (value instanceof Boolean) {
+			return (Boolean) value;
+		}
+
+		return Boolean.valueOf(value.toString());
+	}
+
+	/**
+	 * Convert the value to a UUID.
+	 */
+	public static UUID toUUID(Object value) {
+
+		if (value == null) {
+			return null;
+		}
+		if (value instanceof String) {
+			return UUID.fromString((String) value);
+		}
+		return (UUID) value;
+	}
+
+	/**
+	 * convert the passed in object to a BigDecimal. It should be another
+	 * numeric type.
+	 */
+	public static BigDecimal toBigDecimal(Object value) {
+
+		if (value == null) {
+			return null;
+		}
+		if (value instanceof BigDecimal) {
+			return (BigDecimal) value;
+		}
+		return new BigDecimal(value.toString());
+	}
+
+	public static Float toFloat(Object value) {
+
+		if (value == null) {
+			return null;
+		}
+		if (value instanceof Float) {
+			return (Float) value;
+		}
+		if (value instanceof Number) {
+			return Float.valueOf(((Number) value).floatValue());
+		}
+		return Float.valueOf(value.toString());
+	}
+
+	public static Short toShort(Object value) {
+
+		if (value == null) {
+			return null;
+		}
+		if (value instanceof Short) {
+			return (Short) value;
+		}
+		if (value instanceof Number) {
+			return Short.valueOf(((Number) value).shortValue());
+		}
+		return Short.valueOf(value.toString());
+	}
+
+	public static Byte toByte(Object value) {
+
+		if (value == null) {
+			return null;
+		}
+		if (value instanceof Byte) {
+			return (Byte) value;
+		}
+		return Byte.valueOf(value.toString());
+	}
+
+	/**
+	 * convert the passed in object to a Integer. It should be another numeric
+	 * type.
+	 */
+	public static Integer toInteger(Object value) {
+
+		if (value == null) {
+			return null;
+		}
+		if (value instanceof Integer) {
+			return (Integer) value;
+		}
+		if (value instanceof Number) {
+			return Integer.valueOf(((Number) value).intValue());
+		}
+		return Integer.valueOf(value.toString());
+	}
+
+	/**
+	 * Convert the object to a Long. It should be another numeric type.
+	 */
+	public static Long toLong(Object value) {
+
+		if (value == null) {
+			return null;
+		}
+		if (value instanceof Long) {
+			return (Long) value;
+		}
+		if (value instanceof String) {
+			return Long.valueOf((String) value);
+		}
+		if (value instanceof Number) {
+			return Long.valueOf(((Number) value).longValue());
+		}
+		if (value instanceof java.util.Date) {
+			return Long.valueOf(((java.util.Date) value).getTime());
+		}
+		if (value instanceof Calendar) {
+			return Long.valueOf(((Calendar) value).getTime().getTime());
+		}
+		return Long.valueOf(value.toString());
+	}
+
+	public static BigInteger toMathBigInteger(Object value) {
+
+		if (value == null) {
+			return null;
+		}
+		if (value instanceof BigInteger) {
+			return (BigInteger) value;
+		}
+		return new BigInteger(value.toString());
+	}
+
+	/**
+	 * Convert the object to a Double. It should be another numberic type.
+	 */
+	public static Double toDouble(Object value) {
+
+		if (value == null) {
+			return null;
+		}
+		if (value instanceof Double) {
+			return (Double) value;
+		}
+		if (value instanceof Number) {
+			return Double.valueOf(((Number) value).doubleValue());
+		}
+		return Double.valueOf(value.toString());
+	}
+
+	/**
+	 * convert the passed in object to a Timestamp. It is expected to be a
+	 * java.sql.Date really.
+	 */
+	public static Timestamp toTimestamp(Object value) {
+
+		if (value == null) {
+			return null;
+		}
+		if (value instanceof Timestamp) {
+			return (Timestamp) value;
+
+		} else if (value instanceof java.util.Date) {
+			// no nanos here... so hopefully ok
+			return new Timestamp(((java.util.Date) value).getTime());
+
+		} else if (value instanceof Calendar) {
+			return new Timestamp(((Calendar) value).getTime().getTime());
+
+		} else if (value instanceof String) {
+			return Timestamp.valueOf((String) value);
+
+		} else if (value instanceof Number) {
+			return new Timestamp(((Number) value).longValue());
+
+		} else {
+			String msg = "Unable to convert [" + value.getClass().getName() + "] into a Timestamp.";
+			throw new RuntimeException(msg);
+		}
+	}
+
+	public static java.sql.Time toTime(Object value) {
+
+		if (value == null) {
+			return null;
+		}
+		if (value instanceof java.sql.Time) {
+			return (java.sql.Time) value;
+
+		} else if (value instanceof String) {
+			return java.sql.Time.valueOf((String) value);
+
+		} else {
+			String m = "Unable to convert [" + value.getClass().getName() + "] into a java.sql.Date.";
+			throw new RuntimeException(m);
+		}
+	}
+
+	/**
+	 * convert the passed in object to a java sql Date.
+	 */
+	public static java.sql.Date toDate(Object value) {
+
+		if (value == null) {
+			return null;
+		}
+		if (value instanceof java.sql.Date) {
+			return (java.sql.Date) value;
+
+		} else if (value instanceof java.util.Date) {
+			return new java.sql.Date(((java.util.Date) value).getTime());
+
+		} else if (value instanceof Calendar) {
+			return new java.sql.Date(((Calendar) value).getTime().getTime());
+
+		} else if (value instanceof String) {
+			return java.sql.Date.valueOf((String) value);
+
+		} else if (value instanceof Number) {
+			return new java.sql.Date(((Number) value).longValue());
+
+		} else {
+			String m = "Unable to convert [" + value.getClass().getName() + "] into a java.sql.Date.";
+			throw new RuntimeException(m);
+		}
+	}
+
+	/**
+	 * convert the passed in object to a java sql Date.
+	 */
+	public static java.util.Date toUtilDate(Object value) {
+
+		if (value == null) {
+			return null;
+		}
+		if (value instanceof java.sql.Timestamp) {
+			// loss of nanos precision
+			return new java.util.Date(((java.sql.Timestamp) value).getTime());
+		}
+		// DEVNOTE: strictly speaking do I need to convert a java.sql.Date to
+		// java.util.Date? equals() is symmetrical so perhaps this is not
+		// really required?
+		if (value instanceof java.sql.Date) {
+			return new java.util.Date(((java.sql.Date) value).getTime());
+		}
+		if (value instanceof java.util.Date) {
+			return (java.util.Date) value;
+
+		} else if (value instanceof Calendar) {
+			return ((Calendar) value).getTime();
+
+		} else if (value instanceof String) {
+			return new java.util.Date(Timestamp.valueOf((String) value).getTime());
+
+		} else if (value instanceof Number) {
+			return new java.util.Date(((Number) value).longValue());
+
+		} else {
+			throw new RuntimeException("Unable to convert [" + value.getClass().getName() + "] into a java.util.Date");
+		}
+	}
+
+	/**
+	 * convert the passed in object to a java sql Date.
+	 */
+	public static Calendar toCalendar(Object value) {
+
+		if (value == null) {
+			return null;
+		}
+		if (value instanceof Calendar) {
+			return (Calendar) value;
+
+		} else if (value instanceof java.util.Date) {
+			java.util.Date date = ((java.util.Date) value);
+			return toCalendarFromDate(date);
+
+		} else if (value instanceof String) {
+			java.util.Date date = toUtilDate(value);
+			return toCalendarFromDate(date);
+
+		} else if (value instanceof Number) {
+			long timeMillis = ((Number) value).longValue();
+			java.util.Date date = new java.util.Date(timeMillis);
+			return toCalendarFromDate(date);
+
+		} else {
+			String m = "Unable to convert [" + value.getClass().getName() + "] into a java.util.Date";
+			throw new RuntimeException(m);
+		}
+	}
+
+	private static Calendar toCalendarFromDate(java.util.Date date) {
+
+		Calendar cal = Calendar.getInstance();
+		cal.setTime(date);
+
+		return cal;
+	}
+
+}

src/main/java/com/avaje/ebeaninternal/server/core/BeanRequest.java

@@ -0,0 +1,146 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.sql.Connection;
+
+import com.avaje.ebean.EbeanServer;
+import com.avaje.ebean.LogLevel;
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.api.SpiTransaction;
+
+/**
+ * Base class for find and persist requests.
+ */
+public abstract class BeanRequest {
+
+	/**
+	 * The server processing the request.
+	 */
+	final SpiEbeanServer ebeanServer;
+
+	final String serverName;
+
+	/**
+	 * The transaction this is part of.
+	 */
+	SpiTransaction transaction;
+
+	boolean createdTransaction;
+
+	boolean readOnly;
+
+	public BeanRequest(SpiEbeanServer ebeanServer, SpiTransaction t) {
+		this.ebeanServer = ebeanServer;
+		this.serverName = ebeanServer.getName();
+		this.transaction = t;
+	}
+
+	/**
+	 * initialise an implicit transaction if one is not currently supplied.
+	 * <p>
+	 * A transaction may have been passed in or active in the thread local. If
+	 * not then create one implicitly to handle the request.
+	 * </p>
+	 */
+	public abstract void initTransIfRequired();
+
+	/**
+	 * A helper method for creating an implicit transaction is it is required.
+	 * <p>
+	 * A transaction may have been passed in or active in the thread local. If
+	 * not then create one implicitly to handle the request.
+	 * </p>
+	 */
+	public void createImplicitTransIfRequired(boolean readOnlyTransaction) {
+		if (transaction == null) {
+			transaction = ebeanServer.getCurrentServerTransaction();
+			if (transaction == null || !transaction.isActive()) {
+				// create an implicit transaction to execute this query
+				transaction = ebeanServer.createServerTransaction(false, -1);
+				// commented out for performance reasons...
+				// TODO: review performance of trans.setReadOnly(true)
+				//if (readOnlyTransaction) {
+				//	readOnly = true;
+				//	transaction.setReadOnly(true);
+				//}
+				createdTransaction = true;
+			}
+		}
+	}
+
+	/**
+	 * Commit this transaction if it was created for this request.
+	 */
+	public void commitTransIfRequired() {
+		if (createdTransaction) {
+			if (readOnly) {
+				transaction.rollback();
+			} else {
+				transaction.commit();
+			}
+		}
+	}
+
+	/**
+	 * Rollback the transaction if it was created for this request.
+	 */
+	public void rollbackTransIfRequired() {
+		if (createdTransaction) {
+			transaction.rollback();
+		}
+	}
+
+	/**
+	 * Return the server processing the request. Made available for
+	 * BeanController and BeanFinder.
+	 */
+	public EbeanServer getEbeanServer() {
+		return ebeanServer;
+	}
+
+	/**
+	 * Return the Transaction associated with this request.
+	 */
+	public SpiTransaction getTransaction() {
+		return transaction;
+	}
+
+	/**
+	 * Returns the connection from the Transaction.
+	 */
+	public Connection getConnection() {
+		return transaction.getInternalConnection();
+	}
+
+    /**
+     * Return true if SQL should be logged for this transaction.
+     */
+    public boolean isLogSql() {
+        return transaction.getLogLevel().ordinal() >= LogLevel.SQL.ordinal();
+    }
+    
+    /**
+     * Return true if SUMMARY information should be logged for this transaction.
+     */
+    public boolean isLogSummary() {
+        return transaction.getLogLevel().ordinal() >= LogLevel.SUMMARY.ordinal();
+    }
+}

src/main/java/com/avaje/ebeaninternal/server/core/BootupClassPathSearch.java

@@ -0,0 +1,117 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.util.List;
+import java.util.Set;
+import java.util.logging.Logger;
+
+import com.avaje.ebeaninternal.server.util.ClassPathSearch;
+import com.avaje.ebeaninternal.server.util.ClassPathSearchFilter;
+
+/**
+ * Searches for interesting classes such as Entities, Embedded and ScalarTypes.
+ */
+public class BootupClassPathSearch {
+
+	private static final Logger logger = Logger.getLogger(BootupClassPathSearch.class.getName());
+
+	private final Object monitor = new Object();
+
+	private final ClassLoader classLoader;
+
+	private final List<String> packages;
+    private final List<String> jars;
+	
+	private BootupClasses bootupClasses;
+
+	/**
+	 * Construct and search for interesting classes.
+	 */
+	public BootupClassPathSearch(ClassLoader classLoader, List<String> packages, List<String> jars) {
+		this.classLoader = (classLoader == null) ? getClass().getClassLoader() : classLoader;
+		this.packages = packages;
+		this.jars = jars;
+	}
+
+	public BootupClasses getBootupClasses() {
+		synchronized (monitor) {
+			
+			if (bootupClasses == null){
+				bootupClasses = search();
+			}
+			
+			return bootupClasses;
+		}
+	}
+
+	/**
+	 * Search the classPath for the classes we are interested in.
+	 */
+	private BootupClasses search() {
+		synchronized (monitor) {
+			try {
+				
+				BootupClasses bc = new BootupClasses();
+
+				long st = System.currentTimeMillis();
+
+				ClassPathSearchFilter filter = createFilter();
+
+				ClassPathSearch finder = new ClassPathSearch(classLoader, filter, bc);
+
+				finder.findClasses();
+				Set<String> jars = finder.getJarHits();
+				Set<String> pkgs = finder.getPackageHits();
+
+				long searchTime = System.currentTimeMillis() - st;
+
+				String msg = "Classpath search hits in jars" + jars + " pkgs" + pkgs + "  searchTime[" + searchTime+ "]";
+				logger.info(msg);
+
+				return bc;
+
+			} catch (Exception ex) {
+				String msg = "Error in classpath search (looking for entities etc)";
+				throw new RuntimeException(msg, ex);
+			}
+		}
+	}
+
+	private ClassPathSearchFilter createFilter() {
+
+		ClassPathSearchFilter filter = new ClassPathSearchFilter();
+		filter.addDefaultExcludePackages();
+
+        if (packages != null) {
+            for (String packageName : packages) {
+                filter.includePackage(packageName);
+            }
+        }
+
+        if (jars != null) {
+            for (String jarName : jars) {
+                filter.includeJar(jarName);
+            }
+        }
+
+		return filter;
+	}
+}

src/main/java/com/avaje/ebeaninternal/server/core/BootupClasses.java

@@ -0,0 +1,460 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.lang.annotation.Annotation;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.persistence.Embeddable;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlType;
+
+import com.avaje.ebean.annotation.LdapDomain;
+import com.avaje.ebean.config.CompoundType;
+import com.avaje.ebean.config.ScalarTypeConverter;
+import com.avaje.ebean.config.ServerConfig;
+import com.avaje.ebean.event.BeanFinder;
+import com.avaje.ebean.event.BeanPersistController;
+import com.avaje.ebean.event.BeanPersistListener;
+import com.avaje.ebean.event.BeanQueryAdapter;
+import com.avaje.ebean.event.ServerConfigStartup;
+import com.avaje.ebean.event.TransactionEventListener;
+import com.avaje.ebeaninternal.server.type.ScalarType;
+import com.avaje.ebeaninternal.server.util.ClassPathSearchMatcher;
+
+/**
+ * Interesting classes for a EbeanServer such as Embeddable, Entity,
+ * ScalarTypes, Finders, Listeners and Controllers.
+ */
+public class BootupClasses implements ClassPathSearchMatcher {
+
+    private static final Logger logger = Logger.getLogger(BootupClasses.class.getName());
+
+    private ArrayList<Class<?>> xmlBeanList = new ArrayList<Class<?>>();
+
+    private ArrayList<Class<?>> embeddableList = new ArrayList<Class<?>>();
+
+    private ArrayList<Class<?>> entityList = new ArrayList<Class<?>>();
+
+    private ArrayList<Class<?>> scalarTypeList = new ArrayList<Class<?>>();
+
+    private ArrayList<Class<?>> scalarConverterList = new ArrayList<Class<?>>();
+
+    private ArrayList<Class<?>> compoundTypeList = new ArrayList<Class<?>>();
+    
+    private ArrayList<Class<?>> beanControllerList = new ArrayList<Class<?>>();
+
+    private ArrayList<Class<?>> transactionEventListenerList = new ArrayList<Class<?>>();
+
+    private ArrayList<Class<?>> beanFinderList = new ArrayList<Class<?>>();
+
+    private ArrayList<Class<?>> beanListenerList = new ArrayList<Class<?>>();
+
+    private ArrayList<Class<?>> beanQueryAdapterList = new ArrayList<Class<?>>();
+
+    private ArrayList<Class<?>> luceneIndexList = new ArrayList<Class<?>>();
+
+    private ArrayList<Class<?>> serverConfigStartupList = new ArrayList<Class<?>>();
+    private ArrayList<ServerConfigStartup> serverConfigStartupInstances = new ArrayList<ServerConfigStartup>();
+
+    private List<BeanPersistController> persistControllerInstances = new ArrayList<BeanPersistController>();
+    private List<BeanPersistListener<?>> persistListenerInstances = new ArrayList<BeanPersistListener<?>>();
+    private List<BeanQueryAdapter> queryAdapterInstances = new ArrayList<BeanQueryAdapter>();
+    private List<TransactionEventListener> transactionEventListenerInstances = new ArrayList<TransactionEventListener>();
+
+    public BootupClasses() {
+    }
+
+    public BootupClasses(List<Class<?>> list) {
+        if (list != null) {
+            process(list.iterator());
+        }
+    }
+
+    private BootupClasses(BootupClasses parent) {
+        this.xmlBeanList.addAll(parent.xmlBeanList);
+        this.embeddableList.addAll(parent.embeddableList);
+        this.entityList.addAll(parent.entityList);
+        this.scalarTypeList.addAll(parent.scalarTypeList);
+        this.scalarConverterList.addAll(parent.scalarConverterList);
+        this.compoundTypeList.addAll(parent.compoundTypeList);
+        this.beanControllerList.addAll(parent.beanControllerList);
+        this.transactionEventListenerList.addAll(parent.transactionEventListenerList);
+        this.beanFinderList.addAll(parent.beanFinderList);
+        this.beanListenerList.addAll(parent.beanListenerList);
+        this.beanQueryAdapterList.addAll(parent.beanQueryAdapterList);
+        this.luceneIndexList.addAll(parent.luceneIndexList);
+        this.serverConfigStartupList.addAll(parent.serverConfigStartupList);
+    }
+
+    private void process(Iterator<Class<?>> it) {
+        while (it.hasNext()) {
+            Class<?> cls = it.next();
+            isMatch(cls);
+        }
+    }
+
+    /**
+     * Create a copy of this object so that classes can be added to it.
+     */
+    public BootupClasses createCopy() {
+        return new BootupClasses(this);
+    }
+
+    /**
+     * Run any ServerConfigStartup listeners.
+     */
+    public void runServerConfigStartup(ServerConfig serverConfig) {
+    	
+        for (Class<?> cls : serverConfigStartupList) {
+            try {
+            	ServerConfigStartup newInstance = (ServerConfigStartup) cls.newInstance();
+            	newInstance.onStart(serverConfig);
+            	
+            } catch (Exception e) {
+                String msg = "Error creating BeanQueryAdapter " + cls;
+                logger.log(Level.SEVERE, msg, e);
+            }
+        }
+    }
+        
+    public void addQueryAdapters(List<BeanQueryAdapter> queryAdapterInstances) {
+        if (queryAdapterInstances != null) {
+            for (BeanQueryAdapter a : queryAdapterInstances) {
+            	this.queryAdapterInstances.add(a);
+            	// don't automatically instantiate
+            	this.beanQueryAdapterList.remove(a.getClass());
+            }
+        }
+    }
+
+    /**
+     * Add BeanPersistController instances.
+     */
+    public void addPersistControllers(List<BeanPersistController> beanControllerInstances) {
+        if (beanControllerInstances != null) {
+        	for (BeanPersistController c : beanControllerInstances) {
+        		this.persistControllerInstances.add(c);
+        		// don't automatically instantiate
+        		this.beanControllerList.remove(c.getClass());
+            }
+        }
+    }
+
+    /**
+     * Add TransactionEventListeners instances.
+     */
+    public void addTransactionEventListeners(List<TransactionEventListener> transactionEventListeners) {
+        if (transactionEventListeners != null) {
+        	for (TransactionEventListener c : transactionEventListeners) {
+        		this.transactionEventListenerInstances.add(c);
+        		// don't automatically instantiate
+        		this.transactionEventListenerList.remove(c.getClass());
+            }
+        }
+    }
+
+    public void addPersistListeners(List<BeanPersistListener<?>> listenerInstances) {
+        if (listenerInstances != null) {
+            for (BeanPersistListener<?> l : listenerInstances) {
+                this.persistListenerInstances.add(l);
+        		// don't automatically instantiate
+	            this.beanListenerList.remove(l.getClass());
+            }
+        }
+    }    
+
+    public void addServerConfigStartup(List<ServerConfigStartup> startupInstances) {
+        if (startupInstances != null) {
+            for (ServerConfigStartup l : startupInstances) {
+                this.serverConfigStartupInstances.add(l);
+        		// don't automatically instantiate
+	            this.serverConfigStartupList.remove(l.getClass());
+            }
+        }
+    }
+    
+    public List<BeanQueryAdapter> getBeanQueryAdapters() {
+        // add class registered BeanQueryAdapter to the
+        // already created instances
+        for (Class<?> cls : beanQueryAdapterList) {
+            try {
+                BeanQueryAdapter newInstance = (BeanQueryAdapter) cls.newInstance();
+                queryAdapterInstances.add(newInstance);
+            } catch (Exception e) {
+                String msg = "Error creating BeanQueryAdapter " + cls;
+                logger.log(Level.SEVERE, msg, e);
+            }
+        }
+
+        return queryAdapterInstances;
+    }
+
+    public List<BeanPersistListener<?>> getBeanPersistListeners() {
+        // add class registered BeanPersistController to the
+        // already created instances
+        for (Class<?> cls : beanListenerList) {
+            try {
+                BeanPersistListener<?> newInstance = (BeanPersistListener<?>) cls.newInstance();
+                persistListenerInstances.add(newInstance);
+            } catch (Exception e) {
+                String msg = "Error creating BeanPersistController " + cls;
+                logger.log(Level.SEVERE, msg, e);
+            }
+        }
+
+        return persistListenerInstances;
+    }
+
+    public List<BeanPersistController> getBeanPersistControllers() {
+        // add class registered BeanPersistController to the
+        // already created instances
+        for (Class<?> cls : beanControllerList) {
+            try {
+                BeanPersistController newInstance = (BeanPersistController) cls.newInstance();
+                persistControllerInstances.add(newInstance);
+            } catch (Exception e) {
+                String msg = "Error creating BeanPersistController " + cls;
+                logger.log(Level.SEVERE, msg, e);
+            }
+        }
+
+        return persistControllerInstances;
+    }
+
+    public List<TransactionEventListener> getTransactionEventListeners() {
+        // add class registered TransactionEventListener to the
+        // already created instances
+        for (Class<?> cls : transactionEventListenerList) {
+            try {
+                TransactionEventListener newInstance = (TransactionEventListener) cls.newInstance();
+                transactionEventListenerInstances.add(newInstance);
+            } catch (Exception e) {
+                String msg = "Error creating TransactionEventListener " + cls;
+                logger.log(Level.SEVERE, msg, e);
+            }
+        }
+
+        return transactionEventListenerInstances;
+    }
+    
+    /**
+     * Return the list of Embeddable classes.
+     */
+    public ArrayList<Class<?>> getEmbeddables() {
+        return embeddableList;
+    }
+
+    /**
+     * Return the list of entity classes.
+     */
+    public ArrayList<Class<?>> getEntities() {
+        return entityList;
+    }
+
+    /**
+     * Return the list of ScalarTypes found.
+     */
+    public ArrayList<Class<?>> getScalarTypes() {
+        return scalarTypeList;
+    }
+
+    /**
+     * Return the list of ScalarConverters found.
+     */
+    public ArrayList<Class<?>> getScalarConverters() {
+        return scalarConverterList;
+    }
+
+    /**
+     * Return the list of ScalarConverters found.
+     */
+    public ArrayList<Class<?>> getCompoundTypes() {
+        return compoundTypeList;
+    }
+    
+    /**
+     * Return the list of BeanControllers found.
+     */
+    public ArrayList<Class<?>> getBeanControllers() {
+        return beanControllerList;
+    }
+
+    /**
+     * Return the list of TransactionEventListeners found
+     */
+    public ArrayList<Class<?>> getTransactionEventListenerList() {
+        return transactionEventListenerList;
+    }
+
+    /**
+     * Return the list of BeanFinders found.
+     */
+    public ArrayList<Class<?>> getBeanFinders() {
+        return beanFinderList;
+    }
+
+    /**
+     * Return the list of BeanListeners found.
+     */
+    public ArrayList<Class<?>> getBeanListeners() {
+        return beanListenerList;
+    }
+
+    /**
+     * Return the list of XML Beans.
+     */
+    public ArrayList<Class<?>> getXmlBeanList() {
+        return xmlBeanList;
+    }
+
+    public void add(Iterator<Class<?>> it) {
+        while (it.hasNext()) {
+            Class<?> clazz = it.next();
+            isMatch(clazz);
+        }
+    }
+
+    public boolean isMatch(Class<?> cls) {
+
+        if (isEmbeddable(cls)) {
+            embeddableList.add(cls);
+
+        } else if (isEntity(cls)) {
+            entityList.add(cls);
+
+        } else if (isXmlBean(cls)){
+            entityList.add(cls);
+            //xmlBeanList.add(cls);
+            
+        } else if (isInterestingInterface(cls)) {
+            return true;
+
+        } else {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Look for interesting interfaces.
+     * <p>
+     * This includes ScalarType, BeanController, BeanFinder and BeanListener.
+     * </p>
+     */
+    private boolean isInterestingInterface(Class<?> cls) {
+
+        boolean interesting = false;
+
+        if (BeanPersistController.class.isAssignableFrom(cls)) {
+            beanControllerList.add(cls);
+            interesting = true;
+        }
+
+        if (TransactionEventListener.class.isAssignableFrom(cls)) {
+            transactionEventListenerList.add(cls);
+            interesting = true;
+        }
+
+        if (ScalarType.class.isAssignableFrom(cls)) {
+            scalarTypeList.add(cls);
+            interesting = true;
+        }
+
+        if (ScalarTypeConverter.class.isAssignableFrom(cls)) {
+            scalarConverterList.add(cls);
+            interesting = true;
+        }
+
+        if (CompoundType.class.isAssignableFrom(cls)) {
+            compoundTypeList.add(cls);
+            interesting = true;
+        }
+
+        if (BeanFinder.class.isAssignableFrom(cls)) {
+            beanFinderList.add(cls);
+            interesting = true;
+        }
+
+        if (BeanPersistListener.class.isAssignableFrom(cls)) {
+            beanListenerList.add(cls);
+            interesting = true;
+        }
+
+        if (BeanQueryAdapter.class.isAssignableFrom(cls)) {
+            beanQueryAdapterList.add(cls);
+            interesting = true;
+        }
+        
+        if (ServerConfigStartup.class.isAssignableFrom(cls)){
+        	serverConfigStartupList.add(cls);
+        	interesting = true;
+        }
+        
+        return interesting;
+    }
+
+    private boolean isEntity(Class<?> cls) {
+
+        Annotation ann = cls.getAnnotation(Entity.class);
+        if (ann != null) {
+            return true;
+        }
+        ann = cls.getAnnotation(Table.class);
+        if (ann != null) {
+            return true;
+        }
+        ann = cls.getAnnotation(LdapDomain.class);
+        if (ann != null) {
+            return true;
+        }
+        return false;
+    }
+
+    private boolean isEmbeddable(Class<?> cls) {
+
+        Annotation ann = cls.getAnnotation(Embeddable.class);
+        if (ann != null) {
+            return true;
+        }
+        return false;
+    }
+    
+    private boolean isXmlBean(Class<?> cls) {
+
+        Annotation ann = cls.getAnnotation(XmlRootElement.class);
+        if (ann != null) {
+            return true;
+        }
+        ann = cls.getAnnotation(XmlType.class);
+        if (ann != null) {
+            // Only looking for Beans and not Enums
+            return !cls.isEnum();
+        }
+        return false;
+    }
+}

src/main/java/com/avaje/ebeaninternal/server/core/CacheOptions.java

@@ -0,0 +1,90 @@
+package com.avaje.ebeaninternal.server.core;
+
+/**
+ * Options for controlling cache behaviour for a given type.
+ */
+public class CacheOptions {
+	
+	private boolean useCache;
+
+	private boolean readOnly;
+	
+	private String naturalKey;
+	
+	private String warmingQuery;
+	
+	/**
+	 * Construct with options.
+	 */
+	public CacheOptions() {
+	}
+	
+	/**
+	 * Return true if this should use a cache for lazy loading.
+	 */
+	public boolean isUseCache() {
+		return useCache;
+	}
+	
+	/**
+	 * Set whether to use the bean cache for the associated type.
+	 */
+	public void setUseCache(boolean useCache) {
+    	this.useCache = useCache;
+    }
+
+	/**
+	 * Return the readOnly default setting.
+	 */
+	public boolean isReadOnly() {
+    	return readOnly;
+    }
+
+	/**
+	 * Set read Only default setting.
+	 */
+	public void setReadOnly(boolean readOnly) {
+    	this.readOnly = readOnly;
+    }
+
+	/**
+	 * Return the query used to warm the cache.
+	 */
+	public String getWarmingQuery() {
+		return warmingQuery;
+	}
+
+	/**
+	 * Set the cache warming query.
+	 */
+	public void setWarmingQuery(String warmingQuery) {
+    	this.warmingQuery = warmingQuery;
+    }	
+
+
+	/**
+	 * Return true if a natural key is set.
+	 */
+	public boolean isUseNaturalKeyCache() {
+		return naturalKey != null;
+	}
+	
+	/**
+	 * Return the natural key property.
+	 */
+	public String getNaturalKey() {
+    	return naturalKey;
+    }
+
+	/**
+	 * Set the natural key property.
+	 */
+	public void setNaturalKey(String naturalKey) {
+		if (naturalKey == null || naturalKey.length() == 0){
+			naturalKey = null;
+		} else {
+			this.naturalKey = naturalKey.trim();
+		}
+    }
+	
+}

src/main/java/com/avaje/ebeaninternal/server/core/ConcurrencyMode.java

@@ -0,0 +1,22 @@
+package com.avaje.ebeaninternal.server.core;
+
+/**
+ * Optimistic concurrency mode used for updates and deletes.
+ */
+public enum ConcurrencyMode {
+
+	/**
+	 * No concurrency checking.
+	 */
+	NONE,
+	
+	/**
+	 * Use a version column.
+	 */
+	VERSION,
+	
+	/**
+	 * Use all the columns (except Lobs).
+	 */
+	ALL
+}

src/main/java/com/avaje/ebeaninternal/server/core/ConfigBuilder.java

@@ -0,0 +1,25 @@
+package com.avaje.ebeaninternal.server.core;
+
+import com.avaje.ebean.config.ServerConfig;
+
+
+/**
+ * Build a ServerConfig from ebean.properties.
+ */
+public class ConfigBuilder {
+
+	/**
+	 * Create a ServerConfig and load it from ebean.properties.
+	 */
+	public ServerConfig build(String serverName) {
+		
+		ServerConfig config = new ServerConfig();
+		config.setName(serverName);	
+		
+		config.loadFromProperties();
+		
+		return config;
+	}
+	
+	
+}

src/main/java/com/avaje/ebeaninternal/server/core/DatabasePlatformFactory.java

@@ -0,0 +1,191 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.SQLException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.persistence.PersistenceException;
+import javax.sql.DataSource;
+
+import com.avaje.ebean.config.ServerConfig;
+import com.avaje.ebean.config.dbplatform.DatabasePlatform;
+import com.avaje.ebean.config.dbplatform.H2Platform;
+import com.avaje.ebean.config.dbplatform.HsqldbPlatform;
+import com.avaje.ebean.config.dbplatform.MsSqlServer2000Platform;
+import com.avaje.ebean.config.dbplatform.MsSqlServer2005Platform;
+import com.avaje.ebean.config.dbplatform.MySqlPlatform;
+import com.avaje.ebean.config.dbplatform.Oracle10Platform;
+import com.avaje.ebean.config.dbplatform.Oracle9Platform;
+import com.avaje.ebean.config.dbplatform.PostgresPlatform;
+import com.avaje.ebean.config.dbplatform.SQLitePlatform;
+import com.avaje.ebean.config.dbplatform.SqlAnywherePlatform;
+
+/**
+ * Create a DatabasePlatform from the configuration.
+ * <p>
+ * Will used platform name or use the meta data from the JDBC driver to
+ * determine the platform automatically.
+ * </p>
+ */
+public class DatabasePlatformFactory {
+
+  private static final Logger logger = Logger.getLogger(DatabasePlatformFactory.class.getName());
+
+  /**
+   * Create the appropriate database specific platform.
+   */
+  public DatabasePlatform create(ServerConfig serverConfig) {
+
+    try {
+
+      if (serverConfig.getDatabasePlatformName() != null) {
+        // choose based on dbName
+        return byDatabaseName(serverConfig.getDatabasePlatformName());
+
+      }
+      if (serverConfig.getDataSourceConfig().isOffline()) {
+        String m = "You must specify a DatabasePlatformName when you are offline";
+        throw new PersistenceException(m);
+      }
+      // guess using meta data from driver
+      return byDataSource(serverConfig.getDataSource());
+
+    } catch (Exception ex) {
+      throw new PersistenceException(ex);
+    }
+  }
+
+  /**
+   * Lookup the platform by name.
+   */
+  private DatabasePlatform byDatabaseName(String dbName) throws SQLException {
+
+    dbName = dbName.toLowerCase();
+    if (dbName.equals("postgres83")) {
+      return new PostgresPlatform();
+    }
+    if (dbName.equals("oracle9")) {
+      return new Oracle9Platform();
+    }
+    if (dbName.equals("oracle10")) {
+      return new Oracle10Platform();
+    }
+    if (dbName.equals("oracle")) {
+      return new Oracle10Platform();
+    }
+    if (dbName.equals("sqlserver2005")) {
+      return new MsSqlServer2005Platform();
+    }
+    if (dbName.equals("sqlserver2000")) {
+      return new MsSqlServer2000Platform();
+    }
+    if (dbName.equals("sqlanywhere")) {
+      return new SqlAnywherePlatform();
+    }
+
+    if (dbName.equals("mysql")) {
+      return new MySqlPlatform();
+    }
+
+    if (dbName.equals("sqlite")) {
+      return new SQLitePlatform();
+    }
+
+    throw new RuntimeException("database platform " + dbName + " is not known?");
+  }
+
+  /**
+   * Use JDBC DatabaseMetaData to determine the platform.
+   */
+  private DatabasePlatform byDataSource(DataSource dataSource) {
+
+    Connection conn = null;
+    try {
+      conn = dataSource.getConnection();
+      DatabaseMetaData metaData = conn.getMetaData();
+
+      return byDatabaseMeta(metaData);
+
+    } catch (SQLException ex) {
+      throw new PersistenceException(ex);
+
+    } finally {
+      try {
+        if (conn != null) {
+          conn.close();
+        }
+      } catch (SQLException ex) {
+        logger.log(Level.SEVERE, null, ex);
+      }
+    }
+  }
+
+  /**
+   * Find the platform by the metaData.getDatabaseProductName().
+   */
+  private DatabasePlatform byDatabaseMeta(DatabaseMetaData metaData) throws SQLException {
+
+    String dbProductName = metaData.getDatabaseProductName();
+    dbProductName = dbProductName.toLowerCase();
+
+    int majorVersion = metaData.getDatabaseMajorVersion();
+
+    if (dbProductName.indexOf("oracle") > -1) {
+      if (majorVersion > 9) {
+        return new Oracle10Platform();
+      } else {
+        return new Oracle9Platform();
+      }
+    }
+    if (dbProductName.indexOf("microsoft") > -1) {
+      if (majorVersion > 8) {
+        return new MsSqlServer2005Platform();
+      } else {
+        return new MsSqlServer2000Platform();
+      }
+    }
+
+    if (dbProductName.indexOf("mysql") > -1) {
+      return new MySqlPlatform();
+    }
+    if (dbProductName.indexOf("h2") > -1) {
+      return new H2Platform();
+    }
+    if (dbProductName.indexOf("hsql database engine") > -1) {
+      return new HsqldbPlatform();
+    }
+    if (dbProductName.indexOf("postgres") > -1) {
+      return new PostgresPlatform();
+    }
+    if (dbProductName.indexOf("sqlite") > -1) {
+      return new SQLitePlatform();
+    }
+    if (dbProductName.indexOf("sql anywhere") > -1) {
+      return new SqlAnywherePlatform();
+    }
+    
+    // use the standard one
+    return new DatabasePlatform();
+  }
+}

src/main/java/com/avaje/ebeaninternal/server/core/DebugLazyLoad.java

@@ -0,0 +1,111 @@
+package com.avaje.ebeaninternal.server.core;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.avaje.ebean.config.GlobalProperties;
+
+/**
+ * Helper used in producing debug output on lazy loading.
+ */
+public class DebugLazyLoad {
+
+	private final String[] ignoreList;
+	
+	private final boolean debug;
+
+	public DebugLazyLoad(boolean lazyLoadDebug) {
+		ignoreList = buildLazyLoadIgnoreList();
+		debug = lazyLoadDebug;
+	}
+
+	/**
+	 * Return true if debugging is on.
+	 */
+	public boolean isDebug() {
+		return debug;
+	}
+
+	/**
+	 * Return the StackTraceElement that is believed to be the line of code that
+	 * triggered the lazy loading.
+	 * <p>
+	 * This is determined by going up the stack trace ignoring all the sections
+	 * of java and Ebean code etc until you find code not in the ignore list -
+	 * this is assumed to be your application code that triggered the lazy
+	 * loading (it could be a third party layer such as a web template).
+	 * </p>
+	 */
+	public StackTraceElement getStackTraceElement(Class<?> beanType) {
+
+		StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
+		for (int i = 0; i < stackTrace.length; i++) {
+			if (isStackLine(stackTrace[i], beanType)) {
+				return stackTrace[i];
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Return true if the code is expected to be application code.
+	 */
+	private boolean isStackLine(StackTraceElement element, Class<?> beanType) {
+		
+		String stackClass = element.getClassName();
+		
+		if (isBeanClass(beanType, stackClass)) {
+			return false;
+		}
+		
+		for (int i = 0; i < ignoreList.length; i++) {
+			if (stackClass.startsWith(ignoreList[i])) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * Recurse up the inheritance checking to see if the stackClass is 
+	 * this beanType (or a parent type).
+	 */
+	private boolean isBeanClass(Class<?> beanType, String stackClass) {
+		if (stackClass.startsWith(beanType.getName())) {
+			return true;
+		}
+		Class<?> superCls = beanType.getSuperclass();
+		if (superCls.equals(Object.class)){
+			return false;
+		} else {
+			return isBeanClass(superCls, stackClass);
+		}
+	}
+	
+
+	/**
+	 * Build list of prefixes used to find the application code that triggered
+	 * the lazy loading.
+	 */
+	private String[] buildLazyLoadIgnoreList() {
+
+		List<String> ignore = new ArrayList<String>();
+
+		// code that should be ignored when searching
+		// the stack trace elements 
+		ignore.add("com.avaje.ebean");
+		ignore.add("java");
+		ignore.add("sun.reflect");
+		ignore.add("org.codehaus.groovy.runtime.");
+
+		String extraIgnore = GlobalProperties.get("debug.lazyload.ignore", null);
+		if (extraIgnore != null) {
+			String[] split = extraIgnore.split(",");
+			for (int i = 0; i < split.length; i++) {
+				ignore.add(split[i].trim());
+			}
+		}
+
+		return ignore.toArray(new String[ignore.size()]);
+	}
+}

src/main/java/com/avaje/ebeaninternal/server/core/DefaultBackgroundExecutor.java

@@ -0,0 +1,71 @@
+/**
+ * Copyright (C) 2009  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.util.concurrent.TimeUnit;
+
+import com.avaje.ebeaninternal.api.SpiBackgroundExecutor;
+import com.avaje.ebeaninternal.server.lib.DaemonScheduleThreadPool;
+import com.avaje.ebeaninternal.server.lib.DaemonThreadPool;
+
+/**
+ * The default implementation of the BackgroundExecutor.
+ * 
+ * @author rbygrave
+ */
+public class DefaultBackgroundExecutor implements SpiBackgroundExecutor {
+
+	private final DaemonThreadPool pool;
+	
+	private final DaemonScheduleThreadPool schedulePool;
+
+	/**
+	 * Construct the default implementation of BackgroundExecutor.
+	 * 
+	 * @param mainPoolSize
+	 *            the core size of the thread pool.
+	 * @param keepAliveSecs
+	 *            the time in seconds idle threads are keep alive
+	 * @param shutdownWaitSeconds
+	 *            the time in seconds allowed for the pool to shutdown nicely.
+	 *            After this the pool is forced to shutdown.
+	 */
+	public DefaultBackgroundExecutor(int mainPoolSize, int schedulePoolSize, long keepAliveSecs,int shutdownWaitSeconds, String namePrefix) {
+		this.pool = new DaemonThreadPool(mainPoolSize, keepAliveSecs, shutdownWaitSeconds, namePrefix);
+		this.schedulePool = new DaemonScheduleThreadPool(schedulePoolSize, shutdownWaitSeconds, namePrefix+"-periodic-");
+	}
+
+	/**
+	 * Execute a Runnable using a background thread.
+	 */
+	public void execute(Runnable r) {
+		pool.execute(r);
+	}
+
+	public void executePeriodically(Runnable r, long delay, TimeUnit unit) {
+		schedulePool.scheduleWithFixedDelay(r, delay, delay, unit);
+	}
+
+	public void shutdown() {
+		pool.shutdown();
+		schedulePool.shutdown();
+	}
+	
+}

src/main/java/com/avaje/ebeaninternal/server/core/DefaultBeanLoader.java

@@ -0,0 +1,478 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.persistence.EntityNotFoundException;
+
+import com.avaje.ebean.ExpressionList;
+import com.avaje.ebean.Transaction;
+import com.avaje.ebean.bean.BeanCollection;
+import com.avaje.ebean.bean.EntityBean;
+import com.avaje.ebean.bean.EntityBeanIntercept;
+import com.avaje.ebean.bean.ObjectGraphNode;
+import com.avaje.ebean.bean.PersistenceContext;
+import com.avaje.ebeaninternal.api.LoadBeanContext;
+import com.avaje.ebeaninternal.api.LoadBeanRequest;
+import com.avaje.ebeaninternal.api.LoadManyContext;
+import com.avaje.ebeaninternal.api.LoadManyRequest;
+import com.avaje.ebeaninternal.api.SpiQuery;
+import com.avaje.ebeaninternal.api.SpiQuery.Mode;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
+import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocMany;
+import com.avaje.ebeaninternal.server.transaction.DefaultPersistenceContext;
+
+/**
+ * Helper to handle lazy loading and refreshing of beans.
+ * 
+ * @author rbygrave
+ */
+public class DefaultBeanLoader {
+
+  private static final Logger logger = Logger.getLogger(DefaultBeanLoader.class.getName());
+
+  private final DebugLazyLoad debugLazyLoad;
+
+  private final DefaultServer server;
+
+  protected DefaultBeanLoader(DefaultServer server, DebugLazyLoad debugLazyLoad) {
+    this.server = server;
+    this.debugLazyLoad = debugLazyLoad;
+  }
+
+	  /**
+   * Return a batch size that might be less than the requestedBatchSize.
+   * <p>
+   * This means we can have large and variable requestedBatchSizes.
+   * </p>
+   * <p>
+   * We want to restrict the number of different batch sizes as we want to
+   * re-use the query plan cache and get DB statement re-use.
+   * </p>
+   */
+  private int getBatchSize(int batchListSize, int requestedBatchSize) {
+    if (batchListSize == requestedBatchSize) {
+      return batchListSize;
+    }
+    if (batchListSize == 1) {
+      // there is only one bean/collection to load
+      return 1;
+    }
+    if (requestedBatchSize <= 5) {
+      // anything less than 5 becomes 5
+      return 5;
+    }
+    if (batchListSize <= 10 || requestedBatchSize <= 10) {
+      // 10 or less to load
+      // ... or we wanted a batch size between 6 and 10
+      return 10;
+    }
+    if (batchListSize <= 20 || requestedBatchSize <= 20) {
+      // 20 or less to load
+      // ... or we wanted a batch size between 11 and 20
+      return 20;
+    }
+    if (batchListSize <= 50) {
+      return 50;
+    }
+    return requestedBatchSize;
+  }
+	
+	public void refreshMany(Object parentBean, String propertyName) {
+		refreshMany(parentBean, propertyName, null);
+	}
+
+  public void loadMany(LoadManyRequest loadRequest) {
+
+    List<BeanCollection<?>> batch = loadRequest.getBatch();
+
+    int batchSize = getBatchSize(batch.size(), loadRequest.getBatchSize());
+
+    LoadManyContext ctx = loadRequest.getLoadContext();
+    BeanPropertyAssocMany<?> many = ctx.getBeanProperty();
+
+    PersistenceContext pc = ctx.getPersistenceContext();
+
+    ArrayList<Object> idList = new ArrayList<Object>(batchSize);
+
+    for (int i = 0; i < batch.size(); i++) {
+      BeanCollection<?> bc = batch.get(i);
+      Object ownerBean = bc.getOwnerBean();
+      Object id = many.getParentId(ownerBean);
+      idList.add(id);
+    }
+    int extraIds = batchSize - batch.size();
+    if (extraIds > 0) {
+      Object firstId = idList.get(0);
+      for (int i = 0; i < extraIds; i++) {
+        idList.add(firstId);
+      }
+    }
+
+    BeanDescriptor<?> desc = ctx.getBeanDescriptor();
+
+    String idProperty = desc.getIdBinder().getIdProperty();
+
+    SpiQuery<?> query = (SpiQuery<?>) server.createQuery(desc.getBeanType());
+    query.setMode(Mode.LAZYLOAD_MANY);
+    query.setLazyLoadManyPath(many.getName());
+    query.setPersistenceContext(pc);
+    query.select(idProperty);
+    query.fetch(many.getName());
+
+    if (idList.size() == 1) {
+      query.where().idEq(idList.get(0));
+    } else {
+      query.where().idIn(idList);
+    }
+
+    String mode = loadRequest.isLazy() ? "+lazy" : "+query";
+    query.setLoadDescription(mode, loadRequest.getDescription());
+
+    // potentially changes the joins and selected properties
+    ctx.configureQuery(query);
+
+    if (loadRequest.isOnlyIds()) {
+      // override to just select the Id values
+      query.fetch(many.getName(), many.getTargetIdProperty());
+    }
+
+    server.findList(query, loadRequest.getTransaction());
+
+    // check for BeanCollection's that where never processed
+    // in the +query or +lazy load due to no rows (predicates)
+    for (int i = 0; i < batch.size(); i++) {
+      BeanCollection<?> bc = batch.get(i);
+      if (bc.checkEmptyLazyLoad()) {
+        if (logger.isLoggable(Level.FINE)) {
+          logger.fine("BeanCollection after load was empty. Owner:" + batch.get(i).getOwnerBean());
+        }
+      } else if (loadRequest.isLoadCache()) {
+        Object parentId = desc.getId(bc.getOwnerBean());
+        desc.cachePutMany(many, bc, parentId);
+      }
+    }
+  }
+
+  public void loadMany(BeanCollection<?> bc, LoadManyContext ctx, boolean onlyIds) {
+
+    Object parentBean = bc.getOwnerBean();
+    String propertyName = bc.getPropertyName();
+
+    ObjectGraphNode node = ctx == null ? null : ctx.getObjectGraphNode();
+
+    loadManyInternal(parentBean, propertyName, null, false, node, onlyIds);
+
+    if (server.getAdminLogging().isDebugLazyLoad()) {
+
+      Class<?> cls = parentBean.getClass();
+      BeanDescriptor<?> desc = server.getBeanDescriptor(cls);
+      BeanPropertyAssocMany<?> many = (BeanPropertyAssocMany<?>) desc.getBeanProperty(propertyName);
+
+      StackTraceElement cause = debugLazyLoad.getStackTraceElement(cls);
+
+      String msg = "debug.lazyLoad " + many.getManyType() + " [" + desc + "][" + propertyName + "]";
+      if (cause != null) {
+        msg += " at: " + cause;
+      }
+      System.err.println(msg);
+    }
+  }
+
+	public void refreshMany(Object parentBean, String propertyName, Transaction t) {
+		loadManyInternal(parentBean, propertyName, t, true, null, false);
+	}
+
+	private void loadManyInternal(Object parentBean, String propertyName, Transaction t, boolean refresh, ObjectGraphNode node, boolean onlyIds) {
+
+    boolean vanilla = (parentBean instanceof EntityBean == false);
+
+    EntityBeanIntercept ebi = null;
+    PersistenceContext pc = null;
+    BeanCollection<?> beanCollection = null;
+    ExpressionList<?> filterMany = null;
+
+    if (!vanilla) {
+      ebi = ((EntityBean) parentBean)._ebean_getIntercept();
+      pc = ebi.getPersistenceContext();
+    }
+
+    BeanDescriptor<?> parentDesc = server.getBeanDescriptor(parentBean.getClass());
+    BeanPropertyAssocMany<?> many = (BeanPropertyAssocMany<?>) parentDesc.getBeanProperty(propertyName);
+
+    Object currentValue = many.getValueUnderlying(parentBean);
+    if (currentValue instanceof BeanCollection<?>) {
+      beanCollection = (BeanCollection<?>) currentValue;
+      filterMany = beanCollection.getFilterMany();
+    }
+
+    Object parentId = parentDesc.getId(parentBean);
+
+    if (pc == null) {
+      pc = new DefaultPersistenceContext();
+      pc.put(parentId, parentBean);
+    }
+
+    boolean useManyIdCache = !vanilla && beanCollection != null && parentDesc.cacheIsUseManyId();
+    if (useManyIdCache) {
+      Boolean readOnly = null;
+      if (ebi != null && ebi.isReadOnly()) {
+        readOnly = Boolean.TRUE;
+      }
+      if (parentDesc.cacheLoadMany(many, beanCollection, parentId, readOnly, false)) {
+        return;
+      }
+    }
+
+    SpiQuery<?> query = (SpiQuery<?>) server.createQuery(parentDesc.getBeanType());
+
+    if (refresh) {
+      // populate a new collection
+      Object emptyCollection = many.createEmpty(vanilla);
+      many.setValue(parentBean, emptyCollection);
+      query.setLoadDescription("+refresh", null);
+    } else {
+      query.setLoadDescription("+lazy", null);
+    }
+
+    if (node != null) {
+      // so we can hook back to the root query
+      query.setParentNode(node);
+    }
+
+    String idProperty = parentDesc.getIdBinder().getIdProperty();
+    query.select(idProperty);
+
+    if (onlyIds) {
+      query.fetch(many.getName(), many.getTargetIdProperty());
+    } else {
+      query.fetch(many.getName());
+    }
+    if (filterMany != null) {
+      query.setFilterMany(many.getName(), filterMany);
+    }
+
+    query.where().idEq(parentId);
+    query.setUseCache(false);
+    query.setMode(Mode.LAZYLOAD_MANY);
+    query.setLazyLoadManyPath(many.getName());
+    query.setPersistenceContext(pc);
+    query.setVanillaMode(vanilla);
+
+    if (ebi != null) {
+      if (ebi.isReadOnly()) {
+        query.setReadOnly(true);
+      }
+    }
+
+    server.findUnique(query, t);
+
+    if (beanCollection != null) {
+      if (beanCollection.checkEmptyLazyLoad()) {
+        if (logger.isLoggable(Level.FINE)) {
+          logger.fine("BeanCollection after load was empty. Owner:" + beanCollection.getOwnerBean());
+        }
+      } else if (useManyIdCache) {
+        parentDesc.cachePutMany(many, beanCollection, parentId);
+      }
+    }
+  }
+
+
+  /**
+   * Load a batch of beans for +query or +lazy loading.
+   */
+  public void loadBean(LoadBeanRequest loadRequest) {
+
+    List<EntityBeanIntercept> batch = loadRequest.getBatch();
+
+    if (batch.isEmpty()) {
+      throw new RuntimeException("Nothing in batch?");
+    }
+
+    int batchSize = getBatchSize(batch.size(), loadRequest.getBatchSize());
+
+    LoadBeanContext ctx = loadRequest.getLoadContext();
+    BeanDescriptor<?> desc = ctx.getBeanDescriptor();
+
+    Class<?> beanType = desc.getBeanType();
+
+    EntityBeanIntercept[] ebis = batch.toArray(new EntityBeanIntercept[batch.size()]);
+    ArrayList<Object> idList = new ArrayList<Object>(batchSize);
+
+    for (int i = 0; i < batch.size(); i++) {
+      EntityBeanIntercept ebi = batch.get(i);
+      Object bean = ebi.getOwner();
+      Object id = desc.getId(bean);
+      idList.add(id);
+    }
+
+    if (idList.isEmpty()) {
+      // everything was loaded from cache
+      return;
+    }
+
+    int extraIds = batchSize - batch.size();
+    if (extraIds > 0) {
+      // for performance make up the Id's to the batch size
+      // so we get the same query (for Ebean and the db)
+      Object firstId = idList.get(0);
+      for (int i = 0; i < extraIds; i++) {
+        // just add the first Id again
+        idList.add(firstId);
+      }
+    }
+
+    PersistenceContext persistenceContext = ctx.getPersistenceContext();
+
+    // query the database
+    for (int i = 0; i < ebis.length; i++) {
+      Object parentBean = ebis[i].getParentBean();
+      if (parentBean != null) {
+        // Special case for OneToOne
+        BeanDescriptor<?> parentDesc = server.getBeanDescriptor(parentBean.getClass());
+        Object parentId = parentDesc.getId(parentBean);
+        persistenceContext.put(parentId, parentBean);
+      }
+    }
+
+    SpiQuery<?> query = (SpiQuery<?>) server.createQuery(beanType);
+
+    query.setMode(Mode.LAZYLOAD_BEAN);
+    query.setPersistenceContext(persistenceContext);
+
+    String mode = loadRequest.isLazy() ? "+lazy" : "+query";
+    query.setLoadDescription(mode, loadRequest.getDescription());
+
+    ctx.configureQuery(query, loadRequest.getLazyLoadProperty());
+
+    // make sure the query doesn't use the cache
+    // query.setUseCache(false);
+    if (idList.size() == 1) {
+      query.where().idEq(idList.get(0));
+    } else {
+      query.where().idIn(idList);
+    }
+
+    List<?> list = server.findList(query, loadRequest.getTransaction());
+
+    if (loadRequest.isLoadCache()) {
+      for (int i = 0; i < list.size(); i++) {
+        desc.cachePutBeanData(list.get(i));
+      }
+    }
+
+    for (int i = 0; i < ebis.length; i++) {
+      if (ebis[i].isReference()) {
+        // The underlying row in DB was deleted. Mark this bean as 'failed'
+        // but allow processing to continue until it is accessed by client code
+        ebis[i].setLazyLoadFailure();
+      }
+    }
+
+  }
+
+	public void refresh(Object bean) {
+		refreshBeanInternal(bean, SpiQuery.Mode.REFRESH_BEAN);
+	}
+	
+	public void loadBean(EntityBeanIntercept ebi) {
+		refreshBeanInternal(ebi.getOwner(), SpiQuery.Mode.LAZYLOAD_BEAN);
+	}
+
+  private void refreshBeanInternal(Object bean, SpiQuery.Mode mode) {
+
+    boolean vanilla = (bean instanceof EntityBean == false);
+
+    EntityBeanIntercept ebi = null;
+    PersistenceContext pc = null;
+
+    if (!vanilla) {
+      ebi = ((EntityBean) bean)._ebean_getIntercept();
+      pc = ebi.getPersistenceContext();
+    }
+
+    BeanDescriptor<?> desc = server.getBeanDescriptor(bean.getClass());
+    Object id = desc.getId(bean);
+
+    if (pc == null) {
+      // a reference with no existing persistenceContext
+      pc = new DefaultPersistenceContext();
+      pc.put(id, bean);
+      if (ebi != null) {
+        ebi.setPersistenceContext(pc);
+      }
+    }
+
+    if (ebi != null) {
+      if (SpiQuery.Mode.LAZYLOAD_BEAN.equals(mode) && desc.isBeanCaching()) {
+        // lazy loading and the bean cache is active 
+        if (desc.loadFromCache(bean, ebi, id)) {
+          return;
+        }
+      }
+      if (desc.lazyLoadMany(ebi)) {
+        return;
+      }
+    }
+
+    SpiQuery<?> query = (SpiQuery<?>) server.createQuery(desc.getBeanType());
+    if (ebi != null) {
+      Object parentBean = ebi.getParentBean();
+      if (parentBean != null) {
+        // Special case for OneToOne
+        BeanDescriptor<?> parentDesc = server.getBeanDescriptor(parentBean.getClass());
+        Object parentId = parentDesc.getId(parentBean);
+        pc.putIfAbsent(parentId, parentBean);
+      }
+
+      query.setLazyLoadProperty(ebi.getLazyLoadProperty());
+    }
+
+    // don't collect autoFetch usage profiling information
+    // as we just copy the data out of these fetched beans
+    // and put the data into the original bean
+    query.setUsageProfiling(false);
+    query.setPersistenceContext(pc);
+
+    query.setMode(mode);
+    query.setId(id);
+    // make sure the query doesn't use the cache
+    if (mode.equals(SpiQuery.Mode.REFRESH_BEAN)) {
+      query.setUseCache(false);
+    }
+    query.setVanillaMode(vanilla);
+
+    if (ebi != null && ebi.isReadOnly()) {
+      query.setReadOnly(true);
+    }
+
+    Object dbBean = query.findUnique();
+    if (dbBean == null) {
+      String msg = "Bean not found during lazy load or refresh." + " id[" + id + "] type[" + desc.getBeanType() + "]";
+      throw new EntityNotFoundException(msg);
+    }
+
+  }
+}

src/main/java/com/avaje/ebeaninternal/server/core/DefaultBeanState.java

@@ -0,0 +1,77 @@
+package com.avaje.ebeaninternal.server.core;
+
+import java.beans.PropertyChangeListener;
+import java.util.Collections;
+import java.util.Set;
+
+import com.avaje.ebean.BeanState;
+import com.avaje.ebean.bean.EntityBean;
+import com.avaje.ebean.bean.EntityBeanIntercept;
+
+/**
+ * Default implementation of BeanState.
+ */
+public class DefaultBeanState implements BeanState {
+
+	final EntityBean entityBean;
+	
+	final EntityBeanIntercept intercept;
+	
+	public DefaultBeanState(EntityBean  entityBean){
+		this.entityBean = entityBean;
+		this.intercept = entityBean._ebean_getIntercept();
+	}
+
+	public boolean isReference() {
+		return intercept.isReference();
+	}
+
+	public boolean isNew() {
+		return intercept.isNew();
+	}
+
+	public boolean isNewOrDirty() {
+		return intercept.isNewOrDirty();
+	}
+
+	public boolean isDirty() {
+		return intercept.isDirty();
+	}
+	
+	public Set<String> getLoadedProps() {
+	    Set<String> props = intercept.getLoadedProps();
+	    return props == null ? null : Collections.unmodifiableSet(props);
+	}
+	
+	public Set<String> getChangedProps() {
+	    Set<String> props = intercept.getChangedProps();
+        return props == null ? null : Collections.unmodifiableSet(props);
+    }
+	
+	public boolean isReadOnly() {
+		return intercept.isReadOnly();
+	}
+	
+	public void setReadOnly(boolean readOnly){
+		intercept.setReadOnly(readOnly);
+	}
+	
+	public void addPropertyChangeListener(PropertyChangeListener listener) {
+		entityBean.addPropertyChangeListener(listener);
+	}
+	
+	public void removePropertyChangeListener(PropertyChangeListener listener) {
+		entityBean.removePropertyChangeListener(listener);
+	}
+
+	public void setLoaded(Set<String> loadedProperties) {
+		intercept.setLoadedProps(loadedProperties);
+		intercept.setLoaded();
+	}
+
+	public void setReference() {
+		intercept.setReference();
+	}
+	
+	
+}

src/main/java/com/avaje/ebeaninternal/server/core/DefaultCallableSql.java

@@ -0,0 +1,143 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.io.Serializable;
+import java.sql.CallableStatement;
+import java.sql.SQLException;
+
+import com.avaje.ebean.CallableSql;
+import com.avaje.ebean.EbeanServer;
+import com.avaje.ebeaninternal.api.BindParams;
+import com.avaje.ebeaninternal.api.SpiCallableSql;
+import com.avaje.ebeaninternal.api.TransactionEventTable;
+import com.avaje.ebeaninternal.api.BindParams.Param;
+
+
+public class DefaultCallableSql implements Serializable, SpiCallableSql {
+
+	private static final long serialVersionUID = 8984272253185424701L;
+
+	private transient final EbeanServer server;
+	
+	/**
+	 * The callable sql.
+	 */
+	private String sql;
+
+	/**
+	 * To display in the transaction log to help identify the procedure.
+	 */
+	private String label;
+
+	private int timeout;
+	
+	/**
+	 * Holds the table modification information. On commit this information is
+	 * used to manage the cache etc.
+	 */
+	private TransactionEventTable transactionEvent = new TransactionEventTable();
+
+	private BindParams bindParameters = new BindParams();
+
+	/**
+	 * Create with callable sql.
+	 */
+	public DefaultCallableSql(EbeanServer server, String sql) {
+		this.server = server;
+		this.sql = sql;
+	}
+
+	public void execute() {
+		server.execute(this, null);
+	}
+
+	public String getLabel() {
+		return label;
+	}
+
+	public CallableSql setLabel(String label) {
+		this.label = label;
+		return this;
+	}
+
+	public int getTimeout() {
+		return timeout;
+	}
+
+	public String getSql() {
+		return sql;
+	}
+
+	public CallableSql setTimeout(int secs) {
+		this.timeout = secs;
+		return this;
+	}
+
+	public CallableSql setSql(String sql) {
+		this.sql = sql;
+		return this;
+	}
+
+	public CallableSql bind(int position, Object value) {
+		bindParameters.setParameter(position, value);
+		return this;
+	}
+
+	public CallableSql setParameter(int position, Object value) {
+		bindParameters.setParameter(position, value);
+		return this;
+	}
+
+	public CallableSql registerOut(int position, int type) {
+		bindParameters.registerOut(position, type);
+		return this;
+	}
+
+	public Object getObject(int position) {
+		Param p = bindParameters.getParameter(position);
+		return p.getOutValue();
+	}
+	
+	public boolean executeOverride(CallableStatement cstmt) throws SQLException {
+		return false;
+	}
+
+	public CallableSql addModification(String tableName, boolean inserts, boolean updates,
+			boolean deletes) {
+
+		transactionEvent.add(tableName, inserts, updates, deletes);
+		return this;
+	}
+
+	/**
+	 * Return the TransactionEvent which holds the table modification
+	 * information for this CallableSql. This information is merged into the
+	 * transaction after the transaction is commited.
+	 */
+	public TransactionEventTable getTransactionEventTable() {
+		return transactionEvent;
+	}
+
+	public BindParams getBindParams() {
+		return bindParameters;
+	}
+
+}

src/main/java/com/avaje/ebeaninternal/server/core/DefaultServerFactory.java

@@ -0,0 +1,518 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import com.avaje.ebean.EbeanServer;
+import com.avaje.ebean.cache.ServerCacheFactory;
+import com.avaje.ebean.cache.ServerCacheManager;
+import com.avaje.ebean.cache.ServerCacheOptions;
+import com.avaje.ebean.common.BootupEbeanManager;
+import com.avaje.ebean.config.DataSourceConfig;
+import com.avaje.ebean.config.GlobalProperties;
+import com.avaje.ebean.config.PstmtDelegate;
+import com.avaje.ebean.config.ServerConfig;
+import com.avaje.ebean.config.UnderscoreNamingConvention;
+import com.avaje.ebean.config.dbplatform.DatabasePlatform;
+import com.avaje.ebeaninternal.api.SpiBackgroundExecutor;
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.server.cache.DefaultServerCacheFactory;
+import com.avaje.ebeaninternal.server.cache.DefaultServerCacheManager;
+import com.avaje.ebeaninternal.server.cluster.ClusterManager;
+import com.avaje.ebeaninternal.server.jdbc.OraclePstmtBatch;
+import com.avaje.ebeaninternal.server.jdbc.StandardPstmtDelegate;
+import com.avaje.ebeaninternal.server.lib.ShutdownManager;
+import com.avaje.ebeaninternal.server.lib.sql.DataSourceGlobalManager;
+import com.avaje.ebeaninternal.server.lib.sql.DataSourcePool;
+import com.avaje.ebeaninternal.server.lib.thread.ThreadPool;
+import com.avaje.ebeaninternal.server.lib.thread.ThreadPoolManager;
+
+import javax.management.MBeanServer;
+import javax.management.MBeanServerFactory;
+import javax.persistence.PersistenceException;
+import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Default Server side implementation of ServerFactory.
+ */
+public class DefaultServerFactory implements BootupEbeanManager {
+
+  private static final Logger logger = Logger.getLogger(DefaultServerFactory.class.getName());
+
+  private final ClusterManager clusterManager;
+
+  private final JndiDataSourceLookup jndiDataSourceFactory;
+
+  private final BootupClassPathSearch bootupClassSearch;
+
+  private final AtomicInteger serverId = new AtomicInteger(1);
+
+  private final XmlConfigLoader xmlConfigLoader;
+
+  private final XmlConfig xmlConfig;
+
+  public DefaultServerFactory() {
+
+    this.clusterManager = new ClusterManager();
+    this.jndiDataSourceFactory = new JndiDataSourceLookup();
+
+    List<String> packages = getSearchJarsPackages(GlobalProperties.get("ebean.search.packages", null));
+    List<String> jars = getSearchJarsPackages(GlobalProperties.get("ebean.search.jars", null));
+
+    this.bootupClassSearch = new BootupClassPathSearch(null, packages, jars);
+    this.xmlConfigLoader = new XmlConfigLoader(null);
+
+    this.xmlConfig = xmlConfigLoader.load();
+
+    // register so that we can shutdown any Ebean wide
+    // resources such as clustering
+    ShutdownManager.registerServerFactory(this);
+  }
+
+  private List<String> getSearchJarsPackages(String searchPackages) {
+
+    List<String> hitList = new ArrayList<String>();
+
+    if (searchPackages != null) {
+
+      String[] entries = searchPackages.split("[ ,;]");
+      for (int i = 0; i < entries.length; i++) {
+        hitList.add(entries[i].trim());
+      }
+    }
+    return hitList;
+  }
+
+  public void shutdown() {
+    clusterManager.shutdown();
+  }
+
+  /**
+   * Create the server reading configuration information from ebean.properties.
+   */
+  public SpiEbeanServer createServer(String name) {
+
+    ConfigBuilder b = new ConfigBuilder();
+    ServerConfig config = b.build(name);
+
+    return createServer(config);
+  }
+
+  private SpiBackgroundExecutor createBackgroundExecutor(ServerConfig serverConfig, int uniqueServerId) {
+
+    String namePrefix = "Ebean-" + serverConfig.getName();
+
+    // the size of the pool for executing periodic tasks (such as cache
+    // flushing)
+    int schedulePoolSize = GlobalProperties.getInt("backgroundExecutor.schedulePoolsize", 1);
+
+    // the side of the main pool for immediate background task execution
+    int minPoolSize = GlobalProperties.getInt("backgroundExecutor.minPoolSize", 1);
+    int poolSize = GlobalProperties.getInt("backgroundExecutor.poolsize", 20);
+    int maxPoolSize = GlobalProperties.getInt("backgroundExecutor.maxPoolSize", poolSize);
+
+    int idleSecs = GlobalProperties.getInt("backgroundExecutor.idlesecs", 60);
+    int shutdownSecs = GlobalProperties.getInt("backgroundExecutor.shutdownSecs", 30);
+
+    boolean useTrad = GlobalProperties.getBoolean("backgroundExecutor.traditional", true);
+
+    if (useTrad) {
+      // this pool will use Idle seconds between min and max so I think it is
+      // better
+      // as it will let the thread count float between the min and max
+      ThreadPool pool = ThreadPoolManager.getThreadPool(namePrefix);
+      pool.setMinSize(minPoolSize);
+      pool.setMaxSize(maxPoolSize);
+      pool.setMaxIdleTime(idleSecs * 1000);
+      return new TraditionalBackgroundExecutor(pool, schedulePoolSize, shutdownSecs, namePrefix);
+    } else {
+      return new DefaultBackgroundExecutor(poolSize, schedulePoolSize, idleSecs, shutdownSecs, namePrefix);
+    }
+  }
+
+  /**
+   * Create the implementation from the configuration.
+   */
+  public SpiEbeanServer createServer(ServerConfig serverConfig) {
+
+    synchronized (this) {
+      setNamingConvention(serverConfig);
+
+      BootupClasses bootupClasses = getBootupClasses(serverConfig);
+
+      setDataSource(serverConfig);
+      // check the autoCommit and Transaction Isolation
+      boolean online = checkDataSource(serverConfig);
+
+      // determine database platform (Oracle etc)
+      setDatabasePlatform(serverConfig);
+      if (serverConfig.getDbEncrypt() != null) {
+        // use a configured DbEncrypt rather than the platform default
+        serverConfig.getDatabasePlatform().setDbEncrypt(serverConfig.getDbEncrypt());
+      }
+
+      DatabasePlatform dbPlatform = serverConfig.getDatabasePlatform();
+
+      PstmtBatch pstmtBatch = null;
+
+      if (dbPlatform.getName().startsWith("oracle")) {
+        PstmtDelegate pstmtDelegate = serverConfig.getPstmtDelegate();
+        if (pstmtDelegate == null) {
+          // try to provide the
+          pstmtDelegate = getOraclePstmtDelegate(serverConfig.getDataSource());
+        }
+        if (pstmtDelegate != null) {
+          // We can support JDBC batching with Oracle
+          // via OraclePreparedStatement
+          pstmtBatch = new OraclePstmtBatch(pstmtDelegate);
+        }
+        if (pstmtBatch == null) {
+          // We can not support JDBC batching with Oracle
+          logger.warning("Can not support JDBC batching with Oracle without a PstmtDelegate");
+          serverConfig.setPersistBatching(false);
+        }
+      }
+
+      // inform the NamingConvention of the associated DatabasePlaform
+      serverConfig.getNamingConvention().setDatabasePlatform(serverConfig.getDatabasePlatform());
+
+      ServerCacheManager cacheManager = getCacheManager(serverConfig);
+
+      int uniqueServerId = serverId.incrementAndGet();
+      SpiBackgroundExecutor bgExecutor = createBackgroundExecutor(serverConfig, uniqueServerId);
+
+      InternalConfiguration c = new InternalConfiguration(xmlConfig, clusterManager, cacheManager, bgExecutor, serverConfig, bootupClasses,
+          pstmtBatch);
+
+      DefaultServer server = new DefaultServer(c, cacheManager);
+
+      cacheManager.init(server);
+
+      MBeanServer mbeanServer;
+      ArrayList<?> list = MBeanServerFactory.findMBeanServer(null);
+      if (list.size() == 0) {
+        // probably not running in a server
+        mbeanServer = MBeanServerFactory.createMBeanServer();
+      } else {
+        // use the first MBeanServer
+        mbeanServer = (MBeanServer) list.get(0);
+      }
+
+      server.registerMBeans(mbeanServer, uniqueServerId);
+
+      // generate and run DDL if required
+      executeDDL(server, online);
+
+      // initialise prior to registering with clusterManager
+      server.initialise();
+
+      if (online) {
+        if (clusterManager.isClustering()) {
+          // register the server once it has been created
+          clusterManager.registerServer(server);
+        }
+
+        // warm the cache in 30 seconds
+        int delaySecs = GlobalProperties.getInt("ebean.cacheWarmingDelay", 30);
+        long sleepMillis = 1000 * delaySecs;
+
+        if (sleepMillis > 0) {
+          Timer t = new Timer("EbeanCacheWarmer", true);
+          t.schedule(new CacheWarmer(sleepMillis, server), sleepMillis);
+        }
+      }
+
+      // start any services after registering with clusterManager
+      server.start();
+      return server;
+    }
+  }
+
+  private PstmtDelegate getOraclePstmtDelegate(DataSource ds) {
+
+    if (ds instanceof DataSourcePool) {
+      // Using Ebean's own DataSource implementation
+      return new StandardPstmtDelegate();
+    }
+
+    return null;
+  }
+
+  /**
+   * Create and return the CacheManager.
+   */
+  private ServerCacheManager getCacheManager(ServerConfig serverConfig) {
+
+    ServerCacheManager serverCacheManager = serverConfig.getServerCacheManager();
+    if (serverCacheManager != null) {
+      return serverCacheManager;
+    }
+
+    // reasonable default settings are for a cache per bean type
+    ServerCacheOptions beanOptions = new ServerCacheOptions();
+    beanOptions.setMaxSize(GlobalProperties.getInt("cache.maxSize", 1000));
+    // maxIdleTime 10 minutes
+    beanOptions.setMaxIdleSecs(GlobalProperties.getInt("cache.maxIdleTime", 60 * 10));
+    // maxTimeToLive 6 hrs
+    beanOptions.setMaxSecsToLive(GlobalProperties.getInt("cache.maxTimeToLive", 60 * 60 * 6));
+
+    // reasonable default settings for the query cache per bean type
+    ServerCacheOptions queryOptions = new ServerCacheOptions();
+    queryOptions.setMaxSize(GlobalProperties.getInt("querycache.maxSize", 100));
+    // maxIdleTime 10 minutes
+    queryOptions.setMaxIdleSecs(GlobalProperties.getInt("querycache.maxIdleTime", 60 * 10));
+    // maxTimeToLive 6 hours
+    queryOptions.setMaxSecsToLive(GlobalProperties.getInt("querycache.maxTimeToLive", 60 * 60 * 6));
+
+    ServerCacheFactory cacheFactory = serverConfig.getServerCacheFactory();
+    if (cacheFactory == null) {
+      cacheFactory = new DefaultServerCacheFactory();
+    }
+
+    return new DefaultServerCacheManager(cacheFactory, beanOptions, queryOptions);
+  }
+
+  /**
+   * Get the entities, scalarTypes, Listeners etc combining the class registered
+   * ones with the already created instances.
+   */
+  private BootupClasses getBootupClasses(ServerConfig serverConfig) {
+
+    BootupClasses bootupClasses = getBootupClasses1(serverConfig);
+    bootupClasses.addPersistControllers(serverConfig.getPersistControllers());
+    bootupClasses.addTransactionEventListeners(serverConfig.getTransactionEventListeners());
+    bootupClasses.addPersistListeners(serverConfig.getPersistListeners());
+    bootupClasses.addQueryAdapters(serverConfig.getQueryAdapters());
+    bootupClasses.addServerConfigStartup(serverConfig.getServerConfigStartupListeners());
+
+    // run any ServerConfigStartup instances
+    bootupClasses.runServerConfigStartup(serverConfig);
+    return bootupClasses;
+  }
+
+  /**
+   * Get the class based entities, scalarTypes, Listeners etc.
+   */
+  private BootupClasses getBootupClasses1(ServerConfig serverConfig) {
+
+    List<Class<?>> entityClasses = serverConfig.getClasses();
+    if (entityClasses != null && entityClasses.size() > 0) {
+      // use classes we explicitly added via configuration
+      return new BootupClasses(serverConfig.getClasses());
+    }
+
+    List<String> jars = serverConfig.getJars();
+    List<String> packages = serverConfig.getPackages();
+
+    if ((packages != null && !packages.isEmpty()) || (jars != null && !jars.isEmpty())) {
+      // filter by package name
+      BootupClassPathSearch search = new BootupClassPathSearch(null, packages, jars);
+      return search.getBootupClasses();
+    }
+
+    // just use classes we can find via class path search
+    return bootupClassSearch.getBootupClasses().createCopy();
+  }
+
+  /**
+   * Execute the DDL if required.
+   */
+  private void executeDDL(SpiEbeanServer server, boolean online) {
+
+    server.getDdlGenerator().execute(online);
+  }
+
+  /**
+   * Set the naming convention to underscore if it has not already been set.
+   */
+  private void setNamingConvention(ServerConfig config) {
+    if (config.getNamingConvention() == null) {
+      UnderscoreNamingConvention nc = new UnderscoreNamingConvention();
+      config.setNamingConvention(nc);
+
+      String v = config.getProperty("namingConvention.useForeignKeyPrefix");
+      if (v != null) {
+        boolean useForeignKeyPrefix = Boolean.valueOf(v);
+        nc.setUseForeignKeyPrefix(useForeignKeyPrefix);
+      }
+
+      String sequenceFormat = config.getProperty("namingConvention.sequenceFormat");
+      if (sequenceFormat != null) {
+        nc.setSequenceFormat(sequenceFormat);
+      }
+    }
+  }
+
+  /**
+   * Set the DatabasePlatform if it has not already been set.
+   */
+  private void setDatabasePlatform(ServerConfig config) {
+
+    DatabasePlatform dbPlatform = config.getDatabasePlatform();
+    if (dbPlatform == null) {
+
+      DatabasePlatformFactory factory = new DatabasePlatformFactory();
+
+      DatabasePlatform db = factory.create(config);
+      config.setDatabasePlatform(db);
+      logger.info("DatabasePlatform name:" + config.getName() + " platform:" + db.getName());
+    }
+  }
+
+  /**
+   * Set the DataSource if it has not already been set.
+   */
+  private void setDataSource(ServerConfig config) {
+    if (config.getDataSource() == null) {
+      DataSource ds = getDataSourceFromConfig(config);
+      config.setDataSource(ds);
+    }
+  }
+
+  private DataSource getDataSourceFromConfig(ServerConfig config) {
+
+    DataSource ds = null;
+
+    if (config.getDataSourceJndiName() != null) {
+      ds = jndiDataSourceFactory.lookup(config.getDataSourceJndiName());
+      if (ds == null) {
+        String m = "JNDI lookup for DataSource " + config.getDataSourceJndiName() + " returned null.";
+        throw new PersistenceException(m);
+      } else {
+        return ds;
+      }
+    }
+
+    DataSourceConfig dsConfig = config.getDataSourceConfig();
+    if (dsConfig == null) {
+      String m = "No DataSourceConfig definded for " + config.getName();
+      throw new PersistenceException(m);
+    }
+
+    if (dsConfig.isOffline()) {
+      if (config.getDatabasePlatformName() == null) {
+        String m = "You MUST specify a DatabasePlatformName on ServerConfig when offline";
+        throw new PersistenceException(m);
+      }
+      return null;
+    }
+
+    if (dsConfig.getHeartbeatSql() == null) {
+      // use default heartbeatSql from the DatabasePlatform
+      String heartbeatSql = getHeartbeatSql(dsConfig.getDriver());
+      dsConfig.setHeartbeatSql(heartbeatSql);
+    }
+
+    return DataSourceGlobalManager.getDataSource(config.getName(), dsConfig);
+  }
+
+  /**
+   * Return a heartbeatSql depending on the jdbc driver name.
+   */
+  private String getHeartbeatSql(String driver) {
+    if (driver != null) {
+      String d = driver.toLowerCase();
+      if (d.contains("oracle")) {
+        return "select 'x' from dual";
+      }
+      if (d.contains(".h2.") || d.contains(".mysql.") || d.contains("postgre")) {
+        return "select 1";
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Check the autoCommit and Transaction Isolation levels of the DataSource.
+   * <p>
+   * If autoCommit is true this could be a real problem.
+   * </p>
+   * <p>
+   * If the Isolation level is not READ_COMMITED then optimistic concurrency
+   * checking may not work as expected.
+   * </p>
+   */
+  private boolean checkDataSource(ServerConfig serverConfig) {
+
+    if (serverConfig.getDataSource() == null) {
+      if (serverConfig.getDataSourceConfig().isOffline()) {
+        // this is ok - offline DDL generation etc
+        return false;
+      }
+      throw new RuntimeException("DataSource not set?");
+    }
+
+    Connection c = null;
+    try {
+      c = serverConfig.getDataSource().getConnection();
+
+      if (c.getAutoCommit()) {
+        String m = "DataSource [" + serverConfig.getName() + "] has autoCommit defaulting to true!";
+        logger.warning(m);
+      }
+
+      return true;
+
+    } catch (SQLException ex) {
+      throw new PersistenceException(ex);
+
+    } finally {
+      if (c != null) {
+        try {
+          c.close();
+        } catch (SQLException ex) {
+          logger.log(Level.SEVERE, null, ex);
+        }
+      }
+    }
+  }
+
+  private static class CacheWarmer extends TimerTask {
+
+    private static final Logger log = Logger.getLogger(CacheWarmer.class.getName());
+
+    private final long sleepMillis;
+    private final EbeanServer server;
+
+    CacheWarmer(long sleepMillis, EbeanServer server) {
+      this.sleepMillis = sleepMillis;
+      this.server = server;
+    }
+
+    public void run() {
+      try {
+        Thread.sleep(sleepMillis);
+      } catch (InterruptedException e) {
+        String msg = "Error while sleeping prior to cache warming";
+        log.log(Level.SEVERE, msg, e);
+      }
+      server.runCacheWarming();
+    }
+
+  }
+}

src/main/java/com/avaje/ebeaninternal/server/core/DefaultSqlUpdate.java

@@ -0,0 +1,246 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.io.Serializable;
+
+import com.avaje.ebean.Ebean;
+import com.avaje.ebean.EbeanServer;
+import com.avaje.ebean.SqlUpdate;
+import com.avaje.ebean.Update;
+import com.avaje.ebeaninternal.api.BindParams;
+import com.avaje.ebeaninternal.api.SpiSqlUpdate;
+
+/**
+ * A SQL Update Delete or Insert statement that can be executed. For the times
+ * when you want to use Sql DML rather than a ORM bean approach. Refer to the
+ * Ebean execute() method.
+ * <p>
+ * There is also {@link Update} which is similar except should use logical bean and
+ * property names rather than physical table and column names.
+ * </p>
+ * <p>
+ * SqlUpdate is designed for general DML sql and CallableSql is
+ * designed for use with stored procedures.
+ * </p>
+ * 
+ * <pre class="code">
+ * // String sql = &quot;update f_topic set post_count = :count where id = :topicId&quot;;
+ * 
+ * SqlUpdate update = new SqlUpdate(sql);
+ * update.setParameter(&quot;count&quot;, 1);
+ * update.setParameter(&quot;topicId&quot;, 50);
+ * 
+ * int modifiedCount = Ebean.execute(update);
+ * </pre>
+ * 
+ * <p>
+ * Note that when the SqlUpdate is executed via Ebean.execute() the sql is
+ * parsed to determine if it is an update, delete or insert. In addition the
+ * table modified is deduced. If <em>isAutoTableMod()</em> is true, then this
+ * is then added to the TransactionEvent and cache invalidation etc is
+ * maintained. This means you don't need to use the Ebean.externalModification()
+ * method as this has already been done.
+ * </p>
+ * <p>
+ * You can sql.setAutoTableMod(false); to stop the automatic table modification
+ * </p>
+ * <p>
+ * EXAMPLE: Using JDBC batching with SqlUpdate
+ * </p>
+ * <pre class="code">
+ * 
+ * String data = &quot;This is a simple test of the batch processing&quot;
+ * 		+ &quot; mode and the transaction execute batch method&quot;;
+ * 
+ * String[] da = data.split(&quot; &quot;);
+ * 
+ * String sql = &quot;insert into junk (word) values (?)&quot;;
+ * 
+ * SqlUpdate sqlUpdate = Ebean.createSqlUpdate(sql);
+ * 
+ * Transaction t = Ebean.beginTransaction();
+ * t.setBatchMode(true);
+ * t.setBatchSize(3);
+ * try {
+ * 	for (int i = 0; i &lt; da.length; i++) {
+ * 
+ * 		sqlUpdate.setParameter(1, da[i]);
+ * 		sqlUpdate.execute();
+ * 	}
+ * 
+ * 	// NB: commit implicitly flushes the batch 
+ * 	Ebean.commitTransaction();
+ * 
+ * } finally {
+ * 	Ebean.endTransaction();
+ * }
+ * </pre> 
+ * @see com.avaje.ebean.CallableSql
+ * @see com.avaje.ebean.Ebean#execute(SqlUpdate)
+ */
+public final class DefaultSqlUpdate implements Serializable, SpiSqlUpdate {
+
+	private static final long serialVersionUID = -6493829438421253102L;
+
+	private transient final EbeanServer server;
+
+	/**
+	 * The parameters used to bind to the sql.
+	 */
+	private final BindParams bindParams;
+
+	/**
+	 * The sql update or delete statement.
+	 */
+	private final String sql;
+
+	/**
+	 * Some descriptive text that can be put into the transaction log.
+	 */
+	private String label = "";
+
+	/**
+	 * The statement execution timeout.
+	 */
+	private int timeout;
+
+	/**
+	 * Automatically detect the table being modified by this sql. This will
+	 * register this information so that eBean invalidates cached objects if
+	 * required.
+	 */
+	private boolean isAutoTableMod = true;
+
+	/**
+	 * Helper to add positioned parameters in order.
+	 */
+	private int addPos;
+
+	/**
+	 * Create with server sql and bindParams object.
+	 * <p>
+	 * Useful if you are building the sql and binding parameters at the
+	 * same time. 
+	 * </p>
+	 */
+	public DefaultSqlUpdate(EbeanServer server, String sql, BindParams bindParams) {
+		this.server = server;
+		this.sql = sql;
+		this.bindParams = bindParams;
+	}
+	
+	/**
+	 * Create with a specific server. This means you can use the
+	 * SqlUpdate.execute() method.
+	 */
+	public DefaultSqlUpdate(EbeanServer server, String sql) {
+		this(server, sql, new BindParams());
+	}
+
+	/**
+	 * Create with some sql.
+	 */
+	public DefaultSqlUpdate(String sql) {
+		this(null, sql, new BindParams());
+	}
+
+	public int execute() {
+		if (server != null) {
+			return server.execute(this);
+		} else {
+			// Hopefully this doesn't catch anyone out...
+			return Ebean.execute(this);
+		}
+	}
+
+	public boolean isAutoTableMod() {
+		return isAutoTableMod;
+	}
+
+	public SqlUpdate setAutoTableMod(boolean isAutoTableMod) {
+		this.isAutoTableMod = isAutoTableMod;
+		return this;
+	}
+
+	public String getLabel() {
+		return label;
+	}
+
+	public SqlUpdate setLabel(String label) {
+		this.label = label;
+		return this;
+	}
+
+	public String getSql() {
+		return sql;
+	}
+
+	public int getTimeout() {
+		return timeout;
+	}
+
+	public SqlUpdate setTimeout(int secs) {
+		this.timeout = secs;
+		return this;
+	}
+    
+	public SqlUpdate addParameter(Object value) {
+        return setParameter(++addPos, value);
+    }
+    
+	public SqlUpdate setParameter(int position, Object value) {
+		bindParams.setParameter(position, value);
+		return this;
+	}
+
+	public SqlUpdate setNull(int position, int jdbcType) {
+		bindParams.setNullParameter(position, jdbcType);
+		return this;
+	}
+
+	public SqlUpdate setNullParameter(int position, int jdbcType) {
+		bindParams.setNullParameter(position, jdbcType);
+		return this;
+	}
+
+	public SqlUpdate setParameter(String name, Object param) {
+		bindParams.setParameter(name, param);
+		return this;
+	}
+
+	public SqlUpdate setNull(String name, int jdbcType) {
+		bindParams.setNullParameter(name, jdbcType);
+		return this;
+	}
+
+	public SqlUpdate setNullParameter(String name, int jdbcType) {
+		bindParams.setNullParameter(name, jdbcType);
+		return this;
+	}
+
+	/**
+	 * Return the bind parameters.
+	 */
+	public BindParams getBindParams() {
+		return bindParams;
+	}
+
+}

src/main/java/com/avaje/ebeaninternal/server/core/DiffHelp.java

@@ -0,0 +1,177 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import com.avaje.ebean.ValuePair;
+import com.avaje.ebean.bean.EntityBean;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
+import com.avaje.ebeaninternal.server.deploy.BeanProperty;
+import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocOne;
+import com.avaje.ebeaninternal.util.ValueUtil;
+
+/**
+ * Helper to perform a diff given two beans of the same type.
+ * <p>
+ * This intentionally does not include any OneToMany or ManyToMany properties.
+ * </p>
+ */
+public class DiffHelp {
+
+	
+	/**
+	 * Return a map of the differences between a and b.
+	 * <p>
+	 * A and B must be of the same type. B can be null, in which case the
+	 * 'OldValues' of a is used to compare with (as B).
+	 * </p>
+	 * <p>
+	 * This intentionally does not include as OneToMany or ManyToMany
+	 * properties.
+	 * </p>
+	 */
+	public Map<String, ValuePair> diff(Object a, Object b, BeanDescriptor<?> desc) {
+
+		boolean oldValues = false;
+		if (b == null) {
+			// get the old values from a
+			if (a instanceof EntityBean) {
+				EntityBean eb = (EntityBean) a;
+				b = eb._ebean_getIntercept().getOldValues();
+				oldValues = true;
+			}
+		}
+
+		Map<String, ValuePair> map = new LinkedHashMap<String, ValuePair>();
+
+		if (b == null) {
+			return map;
+		}
+
+		// check the simple properties
+		BeanProperty[] base = desc.propertiesBaseScalar();
+		for (int i = 0; i < base.length; i++) {
+			
+			Object aval = base[i].getValue(a);
+			Object bval = base[i].getValue(b);
+			if (!ValueUtil.areEqual(aval, bval)) {
+				map.put(base[i].getName(), new ValuePair(aval, bval));
+			}
+		}
+
+		diffAssocOne(a, b, desc, map);
+		diffEmbedded(a, b, desc, map, oldValues);
+
+		return map;
+	}
+
+	/**
+	 * Check the Embedded bean properties for differences.
+	 * <p>
+	 * If ANY of the properties are different then the whole Embedded bean is
+	 * determined to be different as is added to the map.
+	 * </p>
+	 */
+	private void diffEmbedded(Object a, Object b, BeanDescriptor<?> desc, Map<String, ValuePair> map,
+			boolean oldValues) {
+
+		BeanPropertyAssocOne<?>[] emb = desc.propertiesEmbedded();
+
+		for (int i = 0; i < emb.length; i++) {
+			Object aval = emb[i].getValue(a);
+			Object bval = emb[i].getValue(b);
+			if (oldValues) {
+				bval = ((EntityBean) bval)._ebean_getIntercept().getOldValues();
+				if (bval == null) {
+					continue;
+				}
+			}
+
+			if (!isBothNull(aval, bval)) {
+				if (isDiffNull(aval, bval)) {
+					// one of the embedded beans is null
+					map.put(emb[i].getName(), new ValuePair(aval, bval));
+
+				} else {
+					// if ANY of the properties in an Embedded bean is
+					// different, treat the whole bean as being different
+					BeanProperty[] props = emb[i].getProperties();
+					for (int j = 0; j < props.length; j++) {
+						Object aEmbPropVal = props[j].getValue(aval);
+						Object bEmbPropVal = props[j].getValue(bval);
+						if (!ValueUtil.areEqual(aEmbPropVal, bEmbPropVal)) {
+
+							// if one prop is different put the
+							// embedded bean in the map
+							map.put(emb[i].getName(), new ValuePair(aval, bval));
+						}
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * If the properties are different by null OR if the id value is different,
+	 * then add the Assoc One bean to the map.
+	 */
+	private void diffAssocOne(Object a, Object b, BeanDescriptor<?> desc, Map<String, ValuePair> map) {
+
+		BeanPropertyAssocOne<?>[] ones = desc.propertiesOne();
+
+		for (int i = 0; i < ones.length; i++) {
+			Object aval = ones[i].getValue(a);
+			Object bval = ones[i].getValue(b);
+
+			if (!isBothNull(aval, bval)) {
+				if (isDiffNull(aval, bval)) {
+					// one of them is/was null
+					map.put(ones[i].getName(), new ValuePair(aval, bval));
+
+				} else {
+					// check to see if the Id properties
+					// are different
+					BeanDescriptor<?> oneDesc = ones[i].getTargetDescriptor();
+					Object aOneId = oneDesc.getId(aval);
+					Object bOneId = oneDesc.getId(bval);
+
+					if (!ValueUtil.areEqual(aOneId, bOneId)) {
+						// the ids are different
+						map.put(ones[i].getName(), new ValuePair(aval, bval));
+					}
+				}
+			}
+		}
+	}
+
+	private boolean isBothNull(Object aval, Object bval) {
+		return aval == null && bval == null;
+	}
+
+	private boolean isDiffNull(Object aval, Object bval) {
+		if (aval == null) {
+			return bval != null;
+		} else {
+			return bval == null;
+		}
+	}
+}

src/main/java/com/avaje/ebeaninternal/server/core/InternString.java

@@ -0,0 +1,37 @@
+package com.avaje.ebeaninternal.server.core;
+
+import java.util.HashMap;
+
+/**
+ * Used to reduce memory consumption of strings used in deployment processing.
+ * <p>
+ * Using this for now instead of String.intern() to avoid any unexpected 
+ * increase in PermGen space.
+ * </p>
+ */
+public final class InternString {
+
+	private static HashMap<String,String> map = new HashMap<String,String>();
+	
+	
+	/**
+	 * Return the shared instance of this string.
+	 */
+	public static String intern(String s){
+		
+		if (s == null){
+			return null;
+		}
+		
+		synchronized (map) {
+			String v = map.get(s);
+			if (v != null){
+				return v;
+			} else {
+				map.put(s, s);
+				return s;
+			}
+			
+		}
+	}
+}

src/main/java/com/avaje/ebeaninternal/server/core/InternalConfiguration.java

@@ -0,0 +1,295 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.util.logging.Logger;
+
+import com.avaje.ebean.ExpressionFactory;
+import com.avaje.ebean.cache.ServerCacheManager;
+import com.avaje.ebean.config.ExternalTransactionManager;
+import com.avaje.ebean.config.ServerConfig;
+import com.avaje.ebean.config.dbplatform.DatabasePlatform;
+import com.avaje.ebean.config.ldap.LdapConfig;
+import com.avaje.ebean.config.ldap.LdapContextFactory;
+import com.avaje.ebean.text.json.JsonContext;
+import com.avaje.ebean.text.json.JsonValueAdapter;
+import com.avaje.ebeaninternal.api.ClassUtil;
+import com.avaje.ebeaninternal.api.SpiBackgroundExecutor;
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.server.autofetch.AutoFetchManager;
+import com.avaje.ebeaninternal.server.autofetch.AutoFetchManagerFactory;
+import com.avaje.ebeaninternal.server.cluster.ClusterManager;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptorManager;
+import com.avaje.ebeaninternal.server.deploy.DeployOrmXml;
+import com.avaje.ebeaninternal.server.deploy.parse.DeployCreateProperties;
+import com.avaje.ebeaninternal.server.deploy.parse.DeployInherit;
+import com.avaje.ebeaninternal.server.deploy.parse.DeployUtil;
+import com.avaje.ebeaninternal.server.expression.DefaultExpressionFactory;
+import com.avaje.ebeaninternal.server.jmx.MAdminLogging;
+import com.avaje.ebeaninternal.server.persist.Binder;
+import com.avaje.ebeaninternal.server.persist.DefaultPersister;
+import com.avaje.ebeaninternal.server.query.CQueryEngine;
+import com.avaje.ebeaninternal.server.query.DefaultOrmQueryEngine;
+import com.avaje.ebeaninternal.server.query.DefaultRelationalQueryEngine;
+import com.avaje.ebeaninternal.server.resource.ResourceManager;
+import com.avaje.ebeaninternal.server.resource.ResourceManagerFactory;
+import com.avaje.ebeaninternal.server.subclass.SubClassManager;
+import com.avaje.ebeaninternal.server.text.json.DJsonContext;
+import com.avaje.ebeaninternal.server.text.json.DefaultJsonValueAdapter;
+import com.avaje.ebeaninternal.server.transaction.DefaultTransactionScopeManager;
+import com.avaje.ebeaninternal.server.transaction.ExternalTransactionScopeManager;
+import com.avaje.ebeaninternal.server.transaction.JtaTransactionManager;
+import com.avaje.ebeaninternal.server.transaction.TransactionManager;
+import com.avaje.ebeaninternal.server.transaction.TransactionScopeManager;
+import com.avaje.ebeaninternal.server.type.DefaultTypeManager;
+import com.avaje.ebeaninternal.server.type.TypeManager;
+
+/**
+ * Used to extend the ServerConfig with additional objects used to configure and
+ * construct an EbeanServer.
+ * 
+ * @author rbygrave
+ */
+public class InternalConfiguration {
+
+  private static final Logger logger = Logger.getLogger(InternalConfiguration.class.getName());
+
+  private final ServerConfig serverConfig;
+
+  private final BootupClasses bootupClasses;
+
+  private final SubClassManager subClassManager;
+
+  private final DeployInherit deployInherit;
+
+  private final ResourceManager resourceManager;
+
+  private final DeployOrmXml deployOrmXml;
+
+  private final TypeManager typeManager;
+
+  private final Binder binder;
+
+  private final DeployCreateProperties deployCreateProperties;
+
+  private final DeployUtil deployUtil;
+
+  private final BeanDescriptorManager beanDescriptorManager;
+
+  private final MAdminLogging logControl;
+
+  private final DebugLazyLoad debugLazyLoad;
+
+  private final TransactionManager transactionManager;
+
+  private final TransactionScopeManager transactionScopeManager;
+
+  private final CQueryEngine cQueryEngine;
+
+  private final ClusterManager clusterManager;
+
+  private final ServerCacheManager cacheManager;
+
+  private final ExpressionFactory expressionFactory;
+
+  private final SpiBackgroundExecutor backgroundExecutor;
+
+  private final PstmtBatch pstmtBatch;
+
+  private final XmlConfig xmlConfig;
+
+  public InternalConfiguration(XmlConfig xmlConfig, ClusterManager clusterManager, ServerCacheManager cacheManager,
+      SpiBackgroundExecutor backgroundExecutor, ServerConfig serverConfig, BootupClasses bootupClasses, PstmtBatch pstmtBatch) {
+
+    this.xmlConfig = xmlConfig;
+    this.pstmtBatch = pstmtBatch;
+    this.clusterManager = clusterManager;
+    this.backgroundExecutor = backgroundExecutor;
+    this.cacheManager = cacheManager;
+    this.serverConfig = serverConfig;
+    this.bootupClasses = bootupClasses;
+    this.expressionFactory = new DefaultExpressionFactory();
+
+    this.subClassManager = new SubClassManager(serverConfig);
+
+    this.typeManager = new DefaultTypeManager(serverConfig, bootupClasses);
+    this.binder = new Binder(typeManager);
+
+    this.resourceManager = ResourceManagerFactory.createResourceManager(serverConfig);
+    this.deployOrmXml = new DeployOrmXml(resourceManager.getResourceSource());
+    this.deployInherit = new DeployInherit(bootupClasses);
+
+    this.deployCreateProperties = new DeployCreateProperties(typeManager);
+    this.deployUtil = new DeployUtil(typeManager, serverConfig);
+
+    this.beanDescriptorManager = new BeanDescriptorManager(this);
+    beanDescriptorManager.deploy();
+
+    this.debugLazyLoad = new DebugLazyLoad(serverConfig.isDebugLazyLoad());
+
+    this.transactionManager = new TransactionManager(clusterManager, backgroundExecutor, serverConfig, beanDescriptorManager,
+        this.getBootupClasses());
+
+    this.logControl = new MAdminLogging(serverConfig, transactionManager);
+
+    this.cQueryEngine = new CQueryEngine(serverConfig.getDatabasePlatform(), logControl, binder, backgroundExecutor);
+
+    ExternalTransactionManager externalTransactionManager = serverConfig.getExternalTransactionManager();
+    if (externalTransactionManager == null && serverConfig.isUseJtaTransactionManager()) {
+      externalTransactionManager = new JtaTransactionManager();
+    }
+    if (externalTransactionManager != null) {
+      externalTransactionManager.setTransactionManager(transactionManager);
+      this.transactionScopeManager = new ExternalTransactionScopeManager(transactionManager, externalTransactionManager);
+      logger.info("Using Transaction Manager [" + externalTransactionManager.getClass() + "]");
+    } else {
+      this.transactionScopeManager = new DefaultTransactionScopeManager(transactionManager);
+    }
+
+  }
+
+  public JsonContext createJsonContext(SpiEbeanServer server) {
+
+    String s = serverConfig.getProperty("json.pretty", "false");
+    boolean dfltPretty = "true".equalsIgnoreCase(s);
+
+    s = serverConfig.getProperty("json.jsonValueAdapter", null);
+
+    JsonValueAdapter va = new DefaultJsonValueAdapter();
+    if (s != null) {
+      va = (JsonValueAdapter) ClassUtil.newInstance(s, this.getClass());
+    }
+    return new DJsonContext(server, va, dfltPretty);
+  }
+
+  public XmlConfig getXmlConfig() {
+    return xmlConfig;
+  }
+
+  public AutoFetchManager createAutoFetchManager(SpiEbeanServer server) {
+    return AutoFetchManagerFactory.create(server, serverConfig, resourceManager);
+  }
+
+  public RelationalQueryEngine createRelationalQueryEngine() {
+    return new DefaultRelationalQueryEngine(logControl, binder, serverConfig.getDatabaseBooleanTrue());
+  }
+
+  public OrmQueryEngine createOrmQueryEngine() {
+    return new DefaultOrmQueryEngine(beanDescriptorManager, cQueryEngine);
+  }
+
+  public Persister createPersister(SpiEbeanServer server) {
+    LdapContextFactory ldapCtxFactory = null;
+    LdapConfig ldapConfig = serverConfig.getLdapConfig();
+    if (ldapConfig != null) {
+      ldapCtxFactory = ldapConfig.getContextFactory();
+    }
+    return new DefaultPersister(server, serverConfig.isValidateOnSave(), binder, beanDescriptorManager, pstmtBatch, ldapCtxFactory);
+  }
+
+  public PstmtBatch getPstmtBatch() {
+    return pstmtBatch;
+  }
+
+  public ServerCacheManager getCacheManager() {
+    return cacheManager;
+  }
+
+  public BootupClasses getBootupClasses() {
+    return bootupClasses;
+  }
+
+  public DatabasePlatform getDatabasePlatform() {
+    return serverConfig.getDatabasePlatform();
+  }
+
+  public ServerConfig getServerConfig() {
+    return serverConfig;
+  }
+
+  public ExpressionFactory getExpressionFactory() {
+    return expressionFactory;
+  }
+
+  public TypeManager getTypeManager() {
+    return typeManager;
+  }
+
+  public Binder getBinder() {
+    return binder;
+  }
+
+  public BeanDescriptorManager getBeanDescriptorManager() {
+    return beanDescriptorManager;
+  }
+
+  public SubClassManager getSubClassManager() {
+    return subClassManager;
+  }
+
+  public DeployInherit getDeployInherit() {
+    return deployInherit;
+  }
+
+  public ResourceManager getResourceManager() {
+    return resourceManager;
+  }
+
+  public DeployOrmXml getDeployOrmXml() {
+    return deployOrmXml;
+  }
+
+  public DeployCreateProperties getDeployCreateProperties() {
+    return deployCreateProperties;
+  }
+
+  public DeployUtil getDeployUtil() {
+    return deployUtil;
+  }
+
+  public MAdminLogging getLogControl() {
+    return logControl;
+  }
+
+  public TransactionManager getTransactionManager() {
+    return transactionManager;
+  }
+
+  public TransactionScopeManager getTransactionScopeManager() {
+    return transactionScopeManager;
+  }
+
+  public CQueryEngine getCQueryEngine() {
+    return cQueryEngine;
+  }
+
+  public ClusterManager getClusterManager() {
+    return clusterManager;
+  }
+
+  public DebugLazyLoad getDebugLazyLoad() {
+    return debugLazyLoad;
+  }
+
+  public SpiBackgroundExecutor getBackgroundExecutor() {
+    return backgroundExecutor;
+  }
+
+}

src/main/java/com/avaje/ebeaninternal/server/core/JndiDataSourceLookup.java

@@ -0,0 +1,68 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import javax.naming.Context;
+import javax.naming.InitialContext;
+import javax.naming.NamingException;
+import javax.persistence.PersistenceException;
+import javax.sql.DataSource;
+
+import com.avaje.ebean.config.GlobalProperties;
+
+
+/**
+ * Helper to lookup a DataSource from JNDI.
+ */
+public class JndiDataSourceLookup {
+
+	private static final String DEFAULT_PREFIX = "java:comp/env/jdbc/";
+
+	String jndiPrefix = GlobalProperties.get("ebean.datasource.jndi.prefix", DEFAULT_PREFIX);
+	
+	public JndiDataSourceLookup() {
+	}
+	
+	/**
+	 * Return the DataSource by JNDI lookup.
+	 * <p>
+	 * If name is null the 'default' dataSource is returned.
+	 * </p>
+	 */
+	public DataSource lookup(String jndiName) {
+
+		try {
+			
+			if (!jndiName.startsWith("java:")){
+				jndiName = jndiPrefix + jndiName;
+			}
+			
+			Context ctx = new InitialContext();
+			DataSource ds = (DataSource) ctx.lookup(jndiName);
+			if (ds == null) {
+				throw new PersistenceException("JNDI DataSource [" + jndiName + "] not found?");
+			}
+			return ds;
+
+		} catch (NamingException ex) {
+			throw new PersistenceException(ex);
+		}
+	}
+}

src/main/java/com/avaje/ebeaninternal/server/core/Message.java

@@ -0,0 +1,83 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.text.MessageFormat;
+import java.util.MissingResourceException;
+import java.util.ResourceBundle;
+
+/**
+ * Utility object used for internationalising log messages.
+ */
+public class Message {
+
+    private static final String bundle = "com.avaje.ebeaninternal.api.message";
+
+    /**
+     * Return a message that has a single argument.
+     */
+    public static String msg(String key, Object arg) {
+        Object[] args = new Object[1];
+        args[0] = arg;
+        return MessageFormat.format(getPattern(key), args);
+    }
+
+    /**
+     * Return a message that has a two arguments.
+     */
+    public static String msg(String key, Object arg, Object arg2) {
+        Object[] args = new Object[2];
+        args[0] = arg;
+        args[1] = arg2;
+        return MessageFormat.format(getPattern(key), args);
+    }
+
+    public static String msg(String key, Object arg, Object arg2, Object arg3) {
+        Object[] args = new Object[3];
+        args[0] = arg;
+        args[1] = arg2;
+        args[2] = arg3;
+        return MessageFormat.format(getPattern(key), args);
+    }
+
+    /**
+     * Return a message that has an array of arguments.
+     */
+    public static String msg(String key, Object[] args) {
+        return MessageFormat.format(getPattern(key), args);
+    }
+
+    /**
+     * Return a message that has a no arguments.
+     */
+    public static String msg(String key) {
+        return MessageFormat.format(getPattern(key), new Object[0]);
+    }
+
+    private static String getPattern(String key) {
+        try {
+            ResourceBundle myResources = ResourceBundle.getBundle(bundle);
+            return myResources.getString(key);
+        } catch (MissingResourceException e) {
+            return "MissingResource " + bundle + ":" + key;
+        }
+    }
+   
+}

src/main/java/com/avaje/ebeaninternal/server/core/OnBootupClassSearchMatcher.java

@@ -0,0 +1,41 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import com.avaje.ebeaninternal.server.util.ClassPathSearchMatcher;
+
+/**
+ * Matcher used for searching for Embeddable, Entity and ScalarTypes in the
+ * class path.
+ */
+public class OnBootupClassSearchMatcher implements ClassPathSearchMatcher {
+
+	BootupClasses classes = new BootupClasses();
+	
+	public boolean isMatch(Class<?> cls) {
+
+		return classes.isMatch(cls);
+	}
+	
+	public BootupClasses getOnBootupClasses() {
+		return classes;
+	}
+
+}

src/main/java/com/avaje/ebeaninternal/server/core/OrmQueryEngine.java

@@ -0,0 +1,57 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import com.avaje.ebean.QueryIterator;
+import com.avaje.ebean.bean.BeanCollection;
+import com.avaje.ebeaninternal.api.BeanIdList;
+
+/**
+ * The Object Relational query execution API.
+ */
+public interface OrmQueryEngine {
+
+	/**
+	 * Execute the 'find by id' query returning a single bean.
+	 */
+    public <T> T findId(OrmQueryRequest<T> request);
+
+    /**
+     * Execute the findList, findSet, findMap query returning an appropriate BeanCollection.
+     */
+    public <T> BeanCollection<T> findMany(OrmQueryRequest<T> request);
+
+    /**
+     * Execute the query using a QueryIterator.
+     */
+    public <T> QueryIterator<T> findIterate(OrmQueryRequest<T> request);
+    
+    /**
+     * Execute the row count query.
+     */
+    public <T> int findRowCount(OrmQueryRequest<T> request);
+    
+    /**
+     * Execute the find id's query.
+     */
+    public <T> BeanIdList findIds(OrmQueryRequest<T> request);
+
+
+}

src/main/java/com/avaje/ebeaninternal/server/core/OrmQueryRequest.java

@@ -0,0 +1,429 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.persistence.PersistenceException;
+
+import com.avaje.ebean.QueryIterator;
+import com.avaje.ebean.QueryResultVisitor;
+import com.avaje.ebean.RawSql;
+import com.avaje.ebean.bean.BeanCollection;
+import com.avaje.ebean.bean.PersistenceContext;
+import com.avaje.ebean.event.BeanFinder;
+import com.avaje.ebean.event.BeanQueryRequest;
+import com.avaje.ebeaninternal.api.BeanIdList;
+import com.avaje.ebeaninternal.api.LoadContext;
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.api.SpiQuery;
+import com.avaje.ebeaninternal.api.SpiQuery.Type;
+import com.avaje.ebeaninternal.api.SpiTransaction;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
+import com.avaje.ebeaninternal.server.deploy.BeanProperty;
+import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocMany;
+import com.avaje.ebeaninternal.server.deploy.DeployParser;
+import com.avaje.ebeaninternal.server.deploy.DeployPropertyParserMap;
+import com.avaje.ebeaninternal.server.loadcontext.DLoadContext;
+import com.avaje.ebeaninternal.server.query.CQueryPlan;
+import com.avaje.ebeaninternal.server.query.CancelableQuery;
+
+/**
+ * Wraps the objects involved in executing a Query.
+ */
+public final class OrmQueryRequest<T> extends BeanRequest implements BeanQueryRequest<T>, SpiOrmQueryRequest<T> {
+
+  private final BeanDescriptor<T> beanDescriptor;
+
+  private final OrmQueryEngine queryEngine;
+
+  private final SpiQuery<T> query;
+
+  private final boolean vanillaMode;
+
+  private final BeanFinder<T> finder;
+
+  private final LoadContext graphContext;
+
+  private final Boolean readOnly;
+
+  private final RawSql rawSql;
+
+  private PersistenceContext persistenceContext;
+
+  private Integer cacheKey;
+
+  private int queryPlanHash;
+
+  /**
+   * Flag set if background fetching taking place. In this case the transaction
+   * is rolled back by the background fetching thread. Background fetching
+   * always takes place in its own transaction.
+   */
+  private boolean backgroundFetching;
+
+  /**
+   * Create the InternalQueryRequest.
+   */
+  public OrmQueryRequest(SpiEbeanServer server, OrmQueryEngine queryEngine, SpiQuery<T> query, BeanDescriptor<T> desc, SpiTransaction t) {
+
+    super(server, t);
+
+    this.beanDescriptor = desc;
+    this.rawSql = query.getRawSql();
+    this.finder = beanDescriptor.getBeanFinder();
+    this.queryEngine = queryEngine;
+    this.query = query;
+    this.vanillaMode = query.isVanillaMode(server.isVanillaMode());
+    this.readOnly = query.isReadOnly();
+
+    this.graphContext = new DLoadContext(ebeanServer, beanDescriptor, readOnly, query);
+    graphContext.registerSecondaryQueries(query);
+  }
+
+  public void setTotalHits(int totalHits) {
+    query.setTotalHits(totalHits);
+  }
+
+  public void executeSecondaryQueries(int defaultQueryBatch) {
+    graphContext.executeSecondaryQueries(this, defaultQueryBatch);
+  }
+
+  /**
+   * For use with QueryIterator and secondary queries this returns the minimum
+   * batch size that should be loaded before executing the secondary queries.
+   * <p>
+   * If -1 is returned then NO secondary queries are registered and simple
+   * iteration is fine.
+   * </p>
+   */
+  public int getSecondaryQueriesMinBatchSize(int defaultQueryBatch) {
+    return graphContext.getSecondaryQueriesMinBatchSize(this, defaultQueryBatch);
+  }
+
+  /**
+   * Return the Normal, sharedInstance, ReadOnly state of this query.
+   */
+  public Boolean isReadOnly() {
+    return readOnly;
+  }
+
+  /**
+   * Return the BeanDescriptor for the associated bean.
+   */
+  public BeanDescriptor<T> getBeanDescriptor() {
+    return beanDescriptor;
+  }
+
+  /**
+   * Return the graph context for this query.
+   */
+  public LoadContext getGraphContext() {
+    return graphContext;
+  }
+
+  /**
+   * Calculate the query plan hash AFTER any potential AutoFetch tuning.
+   */
+  public void calculateQueryPlanHash() {
+    this.queryPlanHash = query.queryPlanHash(this);
+  }
+
+  public boolean isRawSql() {
+    return rawSql != null;
+  }
+
+  public DeployParser createDeployParser() {
+    if (rawSql != null) {
+      return new DeployPropertyParserMap(rawSql.getColumnMapping().getMapping());
+    } else {
+      return beanDescriptor.createDeployPropertyParser();
+    }
+  }
+
+  /**
+   * Return true if this is a query using generated sql. If false this query
+   * will use raw sql (Entity bean based on raw sql select).
+   */
+  public boolean isSqlSelect() {
+    return query.isSqlSelect() && query.getRawSql() == null;
+  }
+
+  /**
+   * Return the PersistenceContext used for this request.
+   */
+  public PersistenceContext getPersistenceContext() {
+    return persistenceContext;
+  }
+
+  /**
+   * This will create a local (readOnly) transaction if no current transaction
+   * exists.
+   * <p>
+   * A transaction may have been passed in explicitly or currently be active in
+   * the thread local. If not, then a readOnly transaction is created to execute
+   * this query.
+   * </p>
+   */
+  @Override
+  public void initTransIfRequired() {
+    // first check if the query requires its own transaction
+    if (query.createOwnTransaction()) {
+      // using background fetch or query listener etc
+      transaction = ebeanServer.createQueryTransaction();
+      createdTransaction = true;
+
+    } else if (transaction == null) {
+      // maybe a current one
+      transaction = ebeanServer.getCurrentServerTransaction();
+      if (transaction == null) {
+        // create an implicit transaction to execute this query
+        transaction = ebeanServer.createQueryTransaction();
+        createdTransaction = true;
+      }
+    }
+    this.persistenceContext = getPersistenceContext(query, transaction);
+    this.graphContext.setPersistenceContext(persistenceContext);
+  }
+
+  /**
+   * Get the TransactionContext either explicitly set on the query or
+   * transaction scoped.
+   */
+  private PersistenceContext getPersistenceContext(SpiQuery<?> query, SpiTransaction t) {
+
+    PersistenceContext ctx = query.getPersistenceContext();
+    if (ctx == null) {
+      ctx = t.getPersistenceContext();
+    }
+    return ctx;
+  }
+
+  /**
+   * Will end a locally created transaction.
+   * <p>
+   * It ends the transaction by using a rollback() as the transaction is known
+   * to be readOnly.
+   * </p>
+   */
+  public void endTransIfRequired() {
+    if (createdTransaction && !backgroundFetching) {
+      // we can rollback as readOnly transaction
+      transaction.rollback();
+    }
+  }
+
+  /**
+   * This query is using background fetching.
+   */
+  public void setBackgroundFetching() {
+    backgroundFetching = true;
+  }
+
+  /**
+   * Return true if this is a find by id (rather than List Set or Map).
+   */
+  public boolean isFindById() {
+    return query.getType() == Type.BEAN;
+  }
+
+  public boolean isVanillaMode() {
+    return vanillaMode;
+  }
+
+  /**
+   * Execute the query as findById.
+   */
+  public Object findId() {
+    return queryEngine.findId(this);
+  }
+
+  public int findRowCount() {
+    return queryEngine.findRowCount(this);
+  }
+
+  public List<Object> findIds() {
+    BeanIdList idList = queryEngine.findIds(this);
+    return idList.getIdList();
+  }
+
+  public void findVisit(QueryResultVisitor<T> visitor) {
+    QueryIterator<T> it = queryEngine.findIterate(this);
+    try {
+      while (it.hasNext()) {
+        if (!visitor.accept(it.next())) {
+          break;
+        }
+      }
+    } finally {
+      it.close();
+    }
+  }
+
+  public QueryIterator<T> findIterate() {
+    return queryEngine.findIterate(this);
+  }
+
+  /**
+   * Execute the query as findList.
+   */
+  @SuppressWarnings("unchecked")
+  public List<T> findList() {
+    BeanCollection<T> bc = queryEngine.findMany(this);
+    return (List<T>) (vanillaMode ? bc.getActualCollection() : bc);
+  }
+
+  /**
+   * Execute the query as findSet.
+   */
+  @SuppressWarnings("unchecked")
+  public Set<?> findSet() {
+    BeanCollection<T> bc = queryEngine.findMany(this);
+    return (Set<T>) (vanillaMode ? bc.getActualCollection() : bc);
+  }
+
+  /**
+   * Execute the query as findMap.
+   */
+  public Map<?, ?> findMap() {
+    String mapKey = query.getMapKey();
+    if (mapKey == null) {
+      BeanProperty[] ids = beanDescriptor.propertiesId();
+      if (ids.length == 1) {
+        query.setMapKey(ids[0].getName());
+      } else {
+        String msg = "No mapKey specified for query";
+        throw new PersistenceException(msg);
+      }
+    }
+    BeanCollection<T> bc = queryEngine.findMany(this);
+    return (Map<?, ?>) (vanillaMode ? bc.getActualCollection() : bc);
+  }
+
+  public SpiQuery.Type getQueryType() {
+    return query.getType();
+  }
+
+  /**
+   * Return a bean specific finder if one has been set.
+   */
+  public BeanFinder<T> getBeanFinder() {
+    return finder;
+  }
+
+  /**
+   * Return the find that is to be performed.
+   */
+  public SpiQuery<T> getQuery() {
+    return query;
+  }
+
+  /**
+   * Return the many property that is fetched in the query or null if there is
+   * not one.
+   */
+  public BeanPropertyAssocMany<?> getManyProperty() {
+    return beanDescriptor.getManyProperty(query);
+  }
+
+  /**
+   * Return a queryPlan for the current query if one exists. Returns null if no
+   * query plan for this query exists.
+   */
+  public CQueryPlan getQueryPlan() {
+    return beanDescriptor.getQueryPlan(queryPlanHash);
+  }
+
+  /**
+   * Return the queryPlanHash.
+   * <p>
+   * This identifies the query plan for a given bean type. It effectively
+   * matches a SQL statement with ? bind variables. A query plan can be reused
+   * with just the bind variables changing.
+   * </p>
+   */
+  public int getQueryPlanHash() {
+    return queryPlanHash;
+  }
+
+  /**
+   * Put the QueryPlan into the cache.
+   */
+  public void putQueryPlan(CQueryPlan queryPlan) {
+    beanDescriptor.putQueryPlan(queryPlanHash, queryPlan);
+  }
+
+  public boolean isUseBeanCache() {
+    return beanDescriptor.calculateUseCache(query.isUseBeanCache());
+  }
+
+  /**
+   * Try to get the query result from the query cache.
+   */
+  public BeanCollection<T> getFromQueryCache() {
+
+    if (!query.isUseQueryCache()) {
+      return null;
+    }
+
+    if (query.getType() == null) {
+      // the query plan and bind values must be the same
+      cacheKey = Integer.valueOf(query.queryHash());
+
+    } else {
+      // additionally the return type (List/Set/Map) must be the same
+      cacheKey = Integer.valueOf(31 * query.queryHash() + query.getType().hashCode());
+    }
+
+    // TODO: Sort out returning BeanCollection from L2 cache
+    return null;
+
+    // BeanCollection<T> bc = beanDescriptor.queryCacheGet(cacheKey);
+    // if (bc != null && Boolean.FALSE.equals(query.isReadOnly())) {
+    // // Explicit readOnly=false for query cache
+    // CopyContext ctx = new CopyContext(vanillaMode, false);
+    // return new CopyBeanCollection<T>(bc, beanDescriptor, ctx, 5).copy();
+    // }
+    // return bc;
+  }
+
+  public void putToQueryCache(BeanCollection<T> queryResult) {
+    beanDescriptor.queryCachePut(cacheKey, queryResult);
+  }
+
+  /**
+   * Set an Query object that owns the PreparedStatement that can be cancelled.
+   */
+  public void setCancelableQuery(CancelableQuery cancelableQuery) {
+    query.setCancelableQuery(cancelableQuery);
+  }
+
+  /**
+   * Log the SQL if the logLevel is appropriate.
+   */
+  public void logSql(String sql) {
+    if (transaction.isLogSql()) {
+      transaction.logInternal(sql);
+    }
+  }
+
+}

src/main/java/com/avaje/ebeaninternal/server/core/PersistRequest.java

@@ -0,0 +1,127 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.api.SpiTransaction;
+import com.avaje.ebeaninternal.server.persist.BatchControl;
+import com.avaje.ebeaninternal.server.persist.BatchPostExecute;
+import com.avaje.ebeaninternal.server.persist.PersistExecute;
+
+/**
+ * Wraps all the objects used to persist a bean.
+ */
+public abstract class PersistRequest extends BeanRequest implements BatchPostExecute {
+
+	public enum Type {
+		INSERT, UPDATE, DELETE, ORMUPDATE, UPDATESQL, CALLABLESQL
+	};
+
+	boolean persistCascade;
+	
+	/**
+	 * One of INSERT, UPDATE, DELETE, UPDATESQL or CALLABLESQL.
+	 */
+	Type type;
+	
+	final PersistExecute persistExecute;
+
+	/**
+	 * Used by CallableSqlRequest and UpdateSqlRequest.
+	 */
+	public PersistRequest(SpiEbeanServer server, SpiTransaction t, PersistExecute persistExecute) {
+		super(server, t);
+		this.persistExecute = persistExecute;
+	}
+
+	/**
+	 * Execute a the request or queue/batch it for later execution.
+	 */
+	public abstract int executeOrQueue();
+
+	/**
+	 * Execute the request right now.
+	 */
+	public abstract int executeNow();
+		   
+    public PstmtBatch getPstmtBatch() {
+    	return ebeanServer.getPstmtBatch();
+    }
+ 
+    public boolean isLogSql() {
+        return transaction.isLogSql();
+    }
+    
+    public boolean isLogSummary() {
+        return transaction.isLogSummary();
+    }
+    
+	/**
+	 * Execute the Callable statement.
+	 */
+	public int executeStatement() {
+		
+		boolean batch = transaction.isBatchThisRequest();
+
+		int rows;
+		BatchControl control = transaction.getBatchControl();
+		if (control != null) {
+			rows = control.executeStatementOrBatch(this, batch);
+		
+		} else if (batch) {
+			// need to create the BatchControl
+			control = persistExecute.createBatchControl(transaction);
+			rows = control.executeStatementOrBatch(this, batch);
+		} else {
+			rows = executeNow();
+		}
+				
+		return rows;
+	}
+	
+	public void initTransIfRequired() {
+		createImplicitTransIfRequired(false);
+		persistCascade = transaction.isPersistCascade();
+	}
+
+	/**
+	 * Return the type of this request. One of INSERT, UPDATE, DELETE, UPDATESQL
+	 * or CALLABLESQL.
+	 */
+	public Type getType() {
+		return type;
+	}
+
+	/**
+	 * Set the type of this request. One of INSERT, UPDATE, DELETE, UPDATESQL or
+	 * CALLABLESQL.
+	 */
+	public void setType(Type type) {
+		this.type = type;
+	}
+
+	/**
+	 * Return true if save and delete should cascade.
+	 */
+	public boolean isPersistCascade() {
+		return persistCascade;
+	}
+	
+}

src/main/java/com/avaje/ebeaninternal/server/core/PersistRequestBean.java

@@ -0,0 +1,708 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.sql.SQLException;
+import java.util.List;
+import java.util.Set;
+
+import javax.persistence.OptimisticLockException;
+
+import com.avaje.ebean.InvalidValue;
+import com.avaje.ebean.ValidationException;
+import com.avaje.ebean.bean.EntityBean;
+import com.avaje.ebean.bean.EntityBeanIntercept;
+import com.avaje.ebean.event.BeanPersistController;
+import com.avaje.ebean.event.BeanPersistListener;
+import com.avaje.ebean.event.BeanPersistRequest;
+import com.avaje.ebeaninternal.api.DerivedRelationshipData;
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.api.SpiTransaction;
+import com.avaje.ebeaninternal.api.TransactionEvent;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
+import com.avaje.ebeaninternal.server.deploy.BeanManager;
+import com.avaje.ebeaninternal.server.deploy.BeanProperty;
+import com.avaje.ebeaninternal.server.persist.BatchControl;
+import com.avaje.ebeaninternal.server.persist.PersistExecute;
+import com.avaje.ebeaninternal.server.persist.dml.GenerateDmlRequest;
+import com.avaje.ebeaninternal.server.transaction.BeanDelta;
+import com.avaje.ebeaninternal.server.transaction.BeanPersistIdMap;
+
+/**
+ * PersistRequest for insert update or delete of a bean.
+ */
+public class PersistRequestBean<T> extends PersistRequest implements BeanPersistRequest<T> {
+
+	protected final BeanManager<T> beanManager;
+
+	protected final BeanDescriptor<T> beanDescriptor;
+
+	protected final BeanPersistListener<T> beanPersistListener;
+
+	/**
+	 * For per post insert update delete control.
+	 */
+	protected final BeanPersistController controller;
+
+	/**
+	 * The associated intercept.
+	 */
+	protected final EntityBeanIntercept intercept;
+
+	/**
+	 * The parent bean for unidirectional save.
+	 */
+	protected final Object parentBean;
+
+	protected final boolean isDirty;
+
+	/**
+	 * True if this is a vanilla bean.
+	 */
+	protected final boolean vanilla;
+
+	/**
+	 * The bean being persisted.
+	 */
+	protected final T bean;
+
+	/**
+	 * Old values used for concurrency checking.
+	 */
+	protected T oldValues;
+
+	/**
+	 * The concurrency mode used for update or delete.
+	 */
+	protected ConcurrencyMode concurrencyMode;
+
+	protected final Set<String> loadedProps;
+
+	/**
+	 * The unique id used for logging summary.
+	 */
+	protected Object idValue;
+
+	/**
+	 * Hash value used to handle cascade delete both ways in a relationship.
+	 */
+	protected Integer beanHash;
+	protected Integer beanIdentityHash;
+
+	protected final Set<String> changedProps;
+
+	protected boolean notifyCache;
+
+	private boolean statelessUpdate;
+	private boolean deleteMissingChildren;
+	private boolean updateNullProperties;
+
+	/**
+	 * Used for forced update of a bean.
+	 */
+	public PersistRequestBean(SpiEbeanServer server, T bean, Object parentBean, BeanManager<T> mgr, SpiTransaction t,
+	        PersistExecute persistExecute, Set<String> updateProps, ConcurrencyMode concurrencyMode) {
+
+		super(server, t, persistExecute);
+		this.beanManager = mgr;
+		this.beanDescriptor = mgr.getBeanDescriptor();
+		this.beanPersistListener = beanDescriptor.getPersistListener();
+		this.bean = bean;
+		this.parentBean = parentBean;
+		
+		this.controller = beanDescriptor.getPersistController();
+		this.concurrencyMode = beanDescriptor.getConcurrencyMode();
+
+		this.concurrencyMode = concurrencyMode;
+		this.loadedProps = updateProps;
+		this.changedProps = updateProps;
+
+		this.vanilla = true;
+		this.isDirty = true;
+		this.oldValues = bean;
+		if (bean instanceof EntityBean) {
+			this.intercept = ((EntityBean) bean)._ebean_getIntercept();
+		} else {
+			this.intercept = null;
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	public PersistRequestBean(SpiEbeanServer server, T bean, Object parentBean, BeanManager<T> mgr,
+	        SpiTransaction t, PersistExecute persistExecute) {
+
+		super(server, t, persistExecute);
+		this.beanManager = mgr;
+		this.beanDescriptor = mgr.getBeanDescriptor();
+		this.beanPersistListener = beanDescriptor.getPersistListener();
+		this.bean = bean;
+		this.parentBean = parentBean;
+
+		this.controller = beanDescriptor.getPersistController();
+		this.concurrencyMode = beanDescriptor.getConcurrencyMode();
+
+		if (bean instanceof EntityBean) {
+			this.intercept = ((EntityBean) bean)._ebean_getIntercept();
+			if (intercept.isReference()) {
+				// allowed to delete reference objects
+				// with no concurrency checking
+				this.concurrencyMode = ConcurrencyMode.NONE;
+			}
+			// this is ok to not use isNewOrDirty() as used for updates only
+			this.isDirty = intercept.isDirty();
+			if (!isDirty) {
+				this.changedProps = intercept.getChangedProps();
+			} else {
+				// merge changed properties on the bean with changed embedded beans
+				Set<String> beanChangedProps = intercept.getChangedProps();
+				Set<String> dirtyEmbedded = beanDescriptor.getDirtyEmbeddedProperties(bean);
+				this.changedProps = mergeChangedProperties(beanChangedProps, dirtyEmbedded);
+			}
+			this.loadedProps = intercept.getLoadedProps();
+			this.oldValues = (T) intercept.getOldValues();
+			this.vanilla = false;
+
+		} else {
+			// have to assume the vanilla bean is dirty
+			this.vanilla = true;
+			this.isDirty = true;
+			this.loadedProps = null;
+			this.changedProps = null;
+			this.intercept = null;
+
+			// degrade concurrency checking to none for vanilla bean
+			if (concurrencyMode.equals(ConcurrencyMode.ALL)) {
+				this.concurrencyMode = ConcurrencyMode.NONE;
+			}
+		}
+	}
+
+	/**
+	 * Merge the changed properties for the bean and embedded beans.
+	 */
+	private Set<String> mergeChangedProperties(Set<String> beanChangedProps, Set<String> embChanged) {
+		if (embChanged == null) {
+			return beanChangedProps;
+		} else if (beanChangedProps == null) {
+			return embChanged;
+		} else {
+			beanChangedProps.addAll(embChanged);
+			return beanChangedProps;
+		}
+	}
+
+	public boolean isNotify(TransactionEvent txnEvent) {
+		return notifyCache || isNotifyPersistListener();
+	}
+
+	public boolean isNotifyCache() {
+		return notifyCache;
+	}
+
+	public boolean isNotifyPersistListener() {
+		return beanPersistListener != null;
+	}
+
+	public void notifyCache() {
+		if (notifyCache) {
+			switch (type) {
+            case INSERT:
+				beanDescriptor.cacheInsert(idValue, this);
+				break;
+            case UPDATE:
+				beanDescriptor.cacheUpdate(idValue, this);
+	            break;
+            case DELETE:
+				beanDescriptor.cacheDelete(idValue, this);
+	            break;
+            default:
+	            throw new IllegalStateException("Invalid type "+type);
+            }
+		}
+	}
+
+	public void addToPersistMap(BeanPersistIdMap beanPersistMap) {
+
+		beanPersistMap.add(beanDescriptor, type, idValue);
+	}
+
+	public boolean notifyLocalPersistListener() {
+		if (beanPersistListener == null) {
+			return false;
+
+		} else {
+			switch (type) {
+			case INSERT:
+				return beanPersistListener.inserted(bean);
+
+			case UPDATE:
+				return beanPersistListener.updated(bean, getUpdatedProperties());
+
+			case DELETE:
+				return beanPersistListener.deleted(bean);
+
+			default:
+				return false;
+			}
+		}
+	}
+
+	public boolean isParent(Object o) {
+		return o == parentBean;
+	}
+
+	/**
+	 * Return true if this bean has been already been persisted 
+	 * (inserted/updated or deleted) in this transaction.
+	 */
+	public boolean isRegisteredBean() {
+		return transaction.isRegisteredBean(bean);
+	}
+	
+	public void unRegisterBean() {
+		transaction.unregisterBean(bean);
+	}
+	
+	/**
+	 * The hash used to register the bean with the transaction.
+	 * <p>
+	 * Takes into account the class type and id value.
+	 * </p>
+	 */
+	private Integer getBeanHash() {
+		if (beanHash == null) {
+			Object id = beanDescriptor.getId(bean);
+			int hc = 31 * bean.getClass().getName().hashCode();
+			if (id != null) {
+				hc += id.hashCode();
+			}
+			beanHash = Integer.valueOf(hc);
+		}
+		return beanHash;
+	}
+	
+	public void registerDeleteBean() {
+		Integer hash = getBeanHash();
+		transaction.registerDeleteBean(hash);
+	}
+	
+	public void unregisterDeleteBean() {
+		Integer hash = getBeanHash();
+		transaction.unregisterDeleteBean(hash);
+	}
+	
+	public boolean isRegisteredForDeleteBean() {
+		if (transaction == null){
+			return false;
+		} else {
+			Integer hash = getBeanHash();
+			return transaction.isRegisteredDeleteBean(hash);
+		}
+	}
+
+	/**
+	 * Set the type of this request. One of INSERT, UPDATE, DELETE, UPDATESQL or
+	 * CALLABLESQL.
+	 */
+	@Override
+	public void setType(Type type) {
+		this.type = type;
+		notifyCache = beanDescriptor.isCacheNotify();
+		if (type == Type.DELETE || type == Type.UPDATE) {
+			if (oldValues == null) {
+				oldValues = bean;
+			}
+		} 
+	}
+
+	public BeanManager<T> getBeanManager() {
+		return beanManager;
+	}
+
+	/**
+	 * Return the BeanDescriptor for the associated bean.
+	 */
+	public BeanDescriptor<T> getBeanDescriptor() {
+		return beanDescriptor;
+	}
+
+	/**
+	 * Return true if this is a stateless update.
+	 */
+	public boolean isStatelessUpdate() {
+		return statelessUpdate;
+	}
+
+	/**
+	 * Return true if a stateless update should also delete any missing details
+	 * beans.
+	 */
+	public boolean isDeleteMissingChildren() {
+		return deleteMissingChildren;
+	}
+
+	/**
+	 * Return true if null properties should be updated (treated as loaded) for
+	 * stateless updates.
+	 */
+	public boolean isUpdateNullProperties() {
+		return updateNullProperties;
+	}
+
+	/**
+	 * Set to true if this is a stateless update.
+	 * <p>
+	 * By Stateless it means that the bean was not previously fetched (and so
+	 * does not have it's previous state) so we are doing an update on a bean
+	 * that was probably created from JSON or XML.
+	 * </p>
+	 */
+	public void setStatelessUpdate(boolean statelessUpdate, boolean deleteMissingChildren, boolean updateNullProperties) {
+		this.statelessUpdate = statelessUpdate;
+		this.deleteMissingChildren = deleteMissingChildren;
+		this.updateNullProperties = updateNullProperties;
+	}
+
+	/**
+	 * Used to skip updates if we know the bean is not dirty. This is the case
+	 * for EntityBeans that have not been modified.
+	 */
+	public boolean isDirty() {
+		return isDirty;
+	}
+
+	/**
+	 * Return the concurrency mode used for this persist.
+	 */
+	public ConcurrencyMode getConcurrencyMode() {
+		return concurrencyMode;
+	}
+
+	/**
+	 * Set loaded properties when generated values has added properties such as
+	 * created and updated timestamps.
+	 */
+	public void setLoadedProps(Set<String> additionalProps) {
+		if (intercept != null) {
+			intercept.setLoadedProps(additionalProps);
+		}
+	}
+
+	public Set<String> getLoadedProperties() {
+		return loadedProps;
+	}
+
+	/**
+	 * Returns a description of the request. This is typically the bean class
+	 * name or the base table for MapBeans.
+	 * <p>
+	 * Used to determine common persist requests for queueing and statement
+	 * batching.
+	 * </p>
+	 */
+	public String getFullName() {
+		return beanDescriptor.getFullName();
+	}
+
+	/**
+	 * Return the bean associated with this request.
+	 */
+	public T getBean() {
+		return bean;
+	}
+
+	/**
+	 * Return the Id value for the bean.
+	 */
+	public Object getBeanId() {
+		return beanDescriptor.getId(bean);
+	}
+
+	public BeanDelta createDeltaBean() {
+		return new BeanDelta(beanDescriptor, getBeanId());
+	}
+
+	/**
+	 * Get the old values bean. This is used to perform optimistic concurrency
+	 * checking on updates and deletes.
+	 */
+	public T getOldValues() {
+		return oldValues;
+	}
+
+	/**
+	 * Return the parent bean for cascading save with unidirectional
+	 * relationship.
+	 */
+	public Object getParentBean() {
+		return parentBean;
+	}
+
+	/**
+	 * Return the controller if there is one associated with this type of bean.
+	 * This returns null if there is no controller associated.
+	 */
+	public BeanPersistController getBeanController() {
+		return controller;
+	}
+
+	/**
+	 * Return the intercept if there is one.
+	 */
+	public EntityBeanIntercept getEntityBeanIntercept() {
+		return intercept;
+	}
+
+	/**
+	 * Validate the bean. This is not recursive and only runs the 'local'
+	 * validation rules.
+	 */
+	public void validate() {
+		InvalidValue errs = beanDescriptor.validate(false, bean);
+		if (errs != null) {
+			throw new ValidationException(errs);
+		}
+	}
+
+	/**
+	 * Return true if this property is loaded (full bean or included in partial
+	 * bean).
+	 */
+	public boolean isLoadedProperty(BeanProperty prop) {
+		if (loadedProps == null) {
+			return true;
+		} else {
+			return loadedProps.contains(prop.getName());
+		}
+	}
+
+	@Override
+	public int executeNow() {
+		switch (type) {
+		case INSERT:
+			persistExecute.executeInsertBean(this);
+			return -1;
+
+		case UPDATE:
+			persistExecute.executeUpdateBean(this);
+			return -1;
+
+		case DELETE:
+			persistExecute.executeDeleteBean(this);
+			return -1;
+
+		default:
+			throw new RuntimeException("Invalid type " + type);
+		}
+	}
+
+	@Override
+	public int executeOrQueue() {
+
+		boolean batch = transaction.isBatchThisRequest();
+
+		BatchControl control = transaction.getBatchControl();
+		if (control != null) {
+			return control.executeOrQueue(this, batch);
+		}
+		if (batch) {
+			control = persistExecute.createBatchControl(transaction);
+			return control.executeOrQueue(this, batch);
+
+		} else {
+			return executeNow();
+		}
+	}
+
+	/**
+	 * Set the generated key back to the bean. Only used for inserts with
+	 * getGeneratedKeys.
+	 */
+	public void setGeneratedKey(Object idValue) {
+		if (idValue != null) {
+
+			// set back to the bean so that we can use the same bean later
+			// for update [refer ebeanIntercept.setLoaded(true)].
+			idValue = beanDescriptor.convertSetId(idValue, bean);
+
+			// remember it for logging summary
+			this.idValue = idValue;
+		}
+	}
+
+	/**
+	 * Set the Id value that was bound. Used for the purposes of logging summary
+	 * information on this request.
+	 */
+	public void setBoundId(Object idValue) {
+		this.idValue = idValue;
+	}
+
+	/**
+	 * Check for optimistic concurrency exception.
+	 */
+	public final void checkRowCount(int rowCount) throws SQLException {
+		if (rowCount != 1) {
+			String m = Message.msg("persist.conc2", "" + rowCount);
+			throw new OptimisticLockException(m, null, bean);
+		}
+	}
+
+	/**
+	 * Post processing.
+	 */
+	public void postExecute() throws SQLException {
+
+		if (controller != null) {
+			controllerPost();
+		}
+
+		if (intercept != null) {
+			// if bean persisted again then should result in an update
+			intercept.setLoaded();
+		}
+
+		addEvent();
+
+		if (isLogSummary()) {
+			logSummary();
+		}
+	}
+
+	private void controllerPost() {
+		switch (type) {
+		case INSERT:
+			controller.postInsert(this);
+			break;
+		case UPDATE:
+			controller.postUpdate(this);
+			break;
+		case DELETE:
+			controller.postDelete(this);
+			break;
+		default:
+			break;
+		}
+	}
+
+	private void logSummary() {
+
+		String name = beanDescriptor.getName();
+		switch (type) {
+		case INSERT:
+			transaction.logInternal("Inserted [" + name + "] [" + idValue + "]");
+			break;
+		case UPDATE:
+			transaction.logInternal("Updated [" + name + "] [" + idValue + "]");
+			break;
+		case DELETE:
+			transaction.logInternal("Deleted [" + name + "] [" + idValue + "]");
+			break;
+		default:
+			break;
+		}
+	}
+
+	/**
+	 * Add the bean to the TransactionEvent. This will be used by
+	 * TransactionManager to synch Cache, Cluster and text indexes.
+	 */
+	private void addEvent() {
+
+		TransactionEvent event = transaction.getEvent();
+		if (event != null) {
+			event.add(this);
+		}
+	}
+
+	/**
+	 * Determine the concurrency mode depending on fully/partially populated
+	 * bean.
+	 * <p>
+	 * Specifically with version concurrency we want to check that the version
+	 * property was one of the loaded properties.
+	 * </p>
+	 */
+	public ConcurrencyMode determineConcurrencyMode() {
+		if (loadedProps != null) {
+			// 'partial bean' update/delete...
+			if (concurrencyMode.equals(ConcurrencyMode.VERSION)) {
+				// check the version property was loaded
+				BeanProperty prop = beanDescriptor.firstVersionProperty();
+				if (prop != null && loadedProps.contains(prop.getName())) {
+					// OK to use version property
+				} else {
+					concurrencyMode = ConcurrencyMode.ALL;
+				}
+			}
+		}
+		return concurrencyMode;
+	}
+
+	/**
+	 * Return true if the update DML/SQL must be dynamically generated.
+	 * <p>
+	 * This is the case for updates/deletes of partially populated beans.
+	 * </p>
+	 */
+	public boolean isDynamicUpdateSql() {
+		return !vanilla && beanDescriptor.isUpdateChangesOnly() || (loadedProps != null);
+	}
+
+	/**
+	 * Create a GenerateDmlRequest used to generate the DML.
+	 * <p>
+	 * Will used changed properties or loaded properties depending on the
+	 * BeanDescriptor.isUpdateChangesOnly() value.
+	 * </p>
+	 */
+	public GenerateDmlRequest createGenerateDmlRequest(boolean emptyStringAsNull) {
+		if (beanDescriptor.isUpdateChangesOnly()) {
+			return new GenerateDmlRequest(emptyStringAsNull, changedProps, loadedProps, oldValues);
+		} else {
+			return new GenerateDmlRequest(emptyStringAsNull, loadedProps, loadedProps, oldValues);
+		}
+	}
+
+	/**
+	 * Return the updated properties. If this returns null then all the
+	 * properties on the bean where updated.
+	 */
+	public Set<String> getUpdatedProperties() {
+		if (changedProps != null) {
+			return changedProps;
+		}
+		return loadedProps;
+	}
+
+	/**
+	 * Test if the property value has changed and if so include it in the
+	 * update.
+	 */
+	public boolean hasChanged(BeanProperty prop) {
+
+		return changedProps.contains(prop.getName());
+	}
+
+	public List<DerivedRelationshipData> getDerivedRelationships() {
+	    return transaction.getDerivedRelationship(bean);
+    }
+
+}

src/main/java/com/avaje/ebeaninternal/server/core/PersistRequestCallableSql.java

@@ -0,0 +1,171 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.sql.CallableStatement;
+import java.sql.SQLException;
+import java.util.List;
+
+import com.avaje.ebean.CallableSql;
+import com.avaje.ebeaninternal.api.BindParams;
+import com.avaje.ebeaninternal.api.SpiCallableSql;
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.api.SpiTransaction;
+import com.avaje.ebeaninternal.api.TransactionEventTable;
+import com.avaje.ebeaninternal.api.BindParams.Param;
+import com.avaje.ebeaninternal.server.persist.PersistExecute;
+
+/**
+ * Persist request specifically for CallableSql.
+ */
+public final class PersistRequestCallableSql extends PersistRequest {
+
+	private final SpiCallableSql callableSql;
+
+	private int rowCount;
+
+	private String bindLog;
+
+	private CallableStatement cstmt;
+
+	private BindParams bindParam;
+
+	/**
+	 * Create.
+	 */
+	public PersistRequestCallableSql(SpiEbeanServer server,
+			CallableSql cs, SpiTransaction t, PersistExecute persistExecute) {
+		
+		super(server, t, persistExecute);
+		this.type = PersistRequest.Type.CALLABLESQL;
+		this.callableSql = (SpiCallableSql)cs;
+	}
+	
+	@Override
+	public int executeOrQueue() {
+		return executeStatement();
+	}
+
+	@Override
+	public int executeNow() {
+		return persistExecute.executeSqlCallable(this);
+	}
+
+	/**
+	 * Return the CallableSql.
+	 */
+	public SpiCallableSql getCallableSql() {
+		return callableSql;
+	}
+
+	/**
+	 * The the log of bind values.
+	 */
+	public void setBindLog(String bindLog) {
+		this.bindLog = bindLog;
+	}
+
+	/**
+	 * Note the rowCount of the execution.
+	 */
+	public void checkRowCount(int count) throws SQLException {
+		this.rowCount = count;
+	}
+
+	/**
+	 * Only called for insert with generated keys.
+	 */
+	public void setGeneratedKey(Object idValue) {
+	}
+
+	/**
+	 * False for CallableSql.
+	 */
+	public boolean useGeneratedKeys() {
+		return false;
+	}
+
+	/**
+	 * Perform post execute processing for the CallableSql.
+	 */
+	public void postExecute() throws SQLException {
+
+		if (transaction.isLogSummary()) {
+			String m = "CallableSql label[" + callableSql.getLabel() + "]" + " rows[" + rowCount+ "]" + " bind[" + bindLog + "]";
+			transaction.logInternal(m);
+		}
+
+		// register table modifications with the transaction event
+		TransactionEventTable tableEvents = callableSql.getTransactionEventTable();
+		
+		if (tableEvents != null && !tableEvents.isEmpty()) {
+			transaction.getEvent().add(tableEvents);
+		}
+
+	}
+
+	/**
+	 * These need to be set for use with Non-batch execution. Specifically to
+	 * read registered out parameters and potentially handle the
+	 * executeOverride() method.
+	 */
+	public void setBound(BindParams bindParam, CallableStatement cstmt) {
+		this.bindParam = bindParam;
+		this.cstmt = cstmt;
+	}
+
+	/**
+	 * Execute the statement in normal non batch mode.
+	 */
+	public int executeUpdate() throws SQLException {
+
+		// check to see if the execution has been overridden
+		// only works in non-batch mode
+		if (callableSql.executeOverride(cstmt)) {
+			return -1;
+			// // been overridden so just return the rowCount
+			// rowCount = callableSql.getRowCount();
+			// return rowCount;
+		}
+
+		rowCount = cstmt.executeUpdate();
+
+		// only read in non-batch mode
+		readOutParams();
+
+		return rowCount;
+	}
+
+	private void readOutParams() throws SQLException {
+
+		List<Param> list = bindParam.positionedParameters();
+		int pos = 0;
+
+		for (int i = 0; i < list.size(); i++) {
+			pos++;
+			BindParams.Param param = (BindParams.Param) list.get(i);
+			if (param.isOutParam()) {
+				Object outValue = cstmt.getObject(pos);
+				param.setOutValue(outValue);
+			}
+		}
+	}
+
+}

src/main/java/com/avaje/ebeaninternal/server/core/PersistRequestOrmUpdate.java

@@ -0,0 +1,138 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.sql.SQLException;
+
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.api.SpiTransaction;
+import com.avaje.ebeaninternal.api.SpiUpdate;
+import com.avaje.ebeaninternal.api.SpiUpdate.OrmUpdateType;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
+import com.avaje.ebeaninternal.server.deploy.BeanManager;
+import com.avaje.ebeaninternal.server.persist.PersistExecute;
+
+/**
+ * Persist request specifically for CallableSql.
+ */
+public final class PersistRequestOrmUpdate extends PersistRequest {
+
+	private final BeanDescriptor<?> beanDescriptor;
+	
+	private SpiUpdate<?> ormUpdate;
+
+	private int rowCount;
+
+	private String bindLog;
+
+	/**
+	 * Create.
+	 */
+	public PersistRequestOrmUpdate(SpiEbeanServer server, BeanManager<?> mgr, SpiUpdate<?> ormUpdate, 
+			SpiTransaction t, PersistExecute persistExecute) {
+		
+		super(server, t, persistExecute);
+		this.beanDescriptor = mgr.getBeanDescriptor();
+		this.ormUpdate = ormUpdate;
+	}
+	
+	public BeanDescriptor<?> getBeanDescriptor() {
+		return beanDescriptor;
+	}
+	
+	@Override
+	public int executeNow() {
+		return persistExecute.executeOrmUpdate(this);
+	}
+
+	@Override
+	public int executeOrQueue() {
+		return executeStatement();
+	}
+
+
+	/**
+	 * Return the UpdateSql.
+	 */
+	public SpiUpdate<?> getOrmUpdate() {
+		return ormUpdate;
+	}
+
+	/**
+	 * No concurrency checking so just note the rowCount.
+	 */
+	public void checkRowCount(int count) throws SQLException {
+		this.rowCount = count;
+	}
+
+	/**
+	 * Always false.
+	 */
+	public boolean useGeneratedKeys() {
+		return false;
+	}
+
+	/**
+	 * Not called for this type of request.
+	 */
+	public void setGeneratedKey(Object idValue) {
+	}
+
+	/**
+	 * Set the bound values.
+	 */
+	public void setBindLog(String bindLog) {
+		this.bindLog = bindLog;
+	}
+
+	/**
+	 * Perform post execute processing.
+	 */
+	public void postExecute() throws SQLException {
+
+		OrmUpdateType ormUpdateType = ormUpdate.getOrmUpdateType();
+		String tableName = ormUpdate.getBaseTable();
+		
+		if (transaction.isLogSummary()) {
+			String m = ormUpdateType + " table[" + tableName + "] rows["+ rowCount + "] bind[" + bindLog + "]";
+			transaction.logInternal(m);
+		}
+		
+		if (ormUpdate.isNotifyCache()) {
+						
+			// add the modification info to the TransactionEvent
+			// this is used to invalidate cached objects etc
+			switch (ormUpdateType) {
+			case INSERT:
+				transaction.getEvent().add(tableName, true, false, false);
+				break;
+			case UPDATE:
+				transaction.getEvent().add(tableName, false, true, false);
+				break;
+			case DELETE:
+				transaction.getEvent().add(tableName, false, false, true);
+				break;
+			default:
+				break;
+			}
+		}
+	}
+
+}

src/main/java/com/avaje/ebeaninternal/server/core/PersistRequestUpdateSql.java

@@ -0,0 +1,145 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.sql.SQLException;
+
+import com.avaje.ebean.SqlUpdate;
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.api.SpiSqlUpdate;
+import com.avaje.ebeaninternal.api.SpiTransaction;
+import com.avaje.ebeaninternal.server.persist.PersistExecute;
+
+/**
+ * Persist request specifically for CallableSql.
+ */
+public final class PersistRequestUpdateSql extends PersistRequest {
+
+	public enum SqlType {
+		SQL_UPDATE, SQL_DELETE, SQL_INSERT, SQL_UNKNOWN
+	};
+
+	private final SpiSqlUpdate updateSql;
+
+	private int rowCount;
+
+	private String bindLog;
+
+	private SqlType sqlType;
+
+	private String tableName;
+
+	private String description;
+
+	/**
+	 * Create.
+	 */
+	public PersistRequestUpdateSql(SpiEbeanServer server, SqlUpdate updateSql,
+			SpiTransaction t, PersistExecute persistExecute) {
+		super(server, t, persistExecute);
+		this.type = Type.UPDATESQL;
+		this.updateSql = (SpiSqlUpdate)updateSql;
+	}
+
+	@Override
+	public int executeNow() {
+		return persistExecute.executeSqlUpdate(this);
+	}
+
+	@Override
+	public int executeOrQueue() {
+		return executeStatement();
+	}
+
+	/**
+	 * Return the UpdateSql.
+	 */
+	public SpiSqlUpdate getUpdateSql() {
+		return updateSql;
+	}
+
+	/**
+	 * No concurrency checking so just note the rowCount.
+	 */
+	public void checkRowCount(int count) throws SQLException {
+		this.rowCount = count;
+	}
+
+	/**
+	 * Always false.
+	 */
+	public boolean useGeneratedKeys() {
+		return false;
+	}
+
+	/**
+	 * Not called for this type of request.
+	 */
+	public void setGeneratedKey(Object idValue) {
+	}
+
+	/**
+	 * Specify the type of statement executed. Used to automatically register
+	 * with the transaction event.
+	 */
+	public void setType(SqlType sqlType, String tableName, String description) {
+		this.sqlType = sqlType;
+		this.tableName = tableName;
+		this.description = description;
+	}
+
+	/**
+	 * Set the bound values.
+	 */
+	public void setBindLog(String bindLog) {
+		this.bindLog = bindLog;
+	}
+
+	/**
+	 * Perform post execute processing.
+	 */
+	public void postExecute() throws SQLException {
+
+		if (transaction.isLogSummary()) {
+			String m = description + " table[" + tableName + "] rows["+ rowCount + "] bind[" + bindLog + "]";
+			transaction.logInternal(m);
+		}
+
+		if (updateSql.isAutoTableMod()) {
+			// add the modification info to the TransactionEvent
+			// this is used to invalidate cached objects etc
+			switch (sqlType) {
+			case SQL_INSERT:
+				transaction.getEvent().add(tableName, true, false, false);
+				break;
+			case SQL_UPDATE:
+				transaction.getEvent().add(tableName, false, true, false);
+				break;
+			case SQL_DELETE:
+				transaction.getEvent().add(tableName, false, false, true);
+				break;
+								
+			default:
+				break;
+			}
+		}
+	}
+
+}

src/main/java/com/avaje/ebeaninternal/server/core/Persister.java

@@ -0,0 +1,107 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.util.Collection;
+import java.util.Set;
+
+import com.avaje.ebean.CallableSql;
+import com.avaje.ebean.SqlUpdate;
+import com.avaje.ebean.Transaction;
+import com.avaje.ebean.Update;
+
+
+/**
+ * API for persisting a bean.
+ */
+public interface Persister {
+
+    /**
+     * Force an Update using the given bean.
+     */
+    public void forceUpdate(Object entityBean, Set<String> updateProps, Transaction t, boolean deleteMissingChildren, boolean updateNullProperties);
+
+    /**
+     * Force an Insert using the given bean.
+     */
+    public void forceInsert(Object entityBean, Transaction t);
+
+    /**
+     * Insert or update the bean depending on its state.
+     */
+    public void save(Object entityBean, Transaction t);
+
+    /**
+     * Save the associations of a ManyToMany given the owner bean and the
+     * propertyName of the ManyToMany collection.
+     */
+    public void saveManyToManyAssociations(Object ownerBean, String propertyName, Transaction t);
+
+    /**
+     * Save an association (OneToMany, ManyToOne, OneToOne or ManyToMany).
+     * 
+     * @param parentBean
+     *            the bean that owns the association.
+     * @param propertyName
+     *            the name of the property to save.
+     * @param t
+     *            the transaction to use.
+     */
+    public void saveAssociation(Object parentBean, String propertyName, Transaction t);
+
+    /**
+     * Delete the associations of a ManyToMany given the owner bean and the property name of the ManyToMany.
+     */
+    public int deleteManyToManyAssociations(Object ownerBean, String propertyName, Transaction t);
+
+    /**
+     * Delete a bean given it's type and id value.
+     * <p>
+     * This will also cascade delete one level of children.
+     * </p>
+     */
+    public int delete(Class<?> beanType, Object id, Transaction transaction);
+
+    /**
+     * Delete the bean.
+     */
+    public void delete(Object entityBean, Transaction t);
+
+    /**
+     * Delete multiple beans given a collection of Id values.
+     */
+    public void deleteMany(Class<?> beanType, Collection<?> ids, Transaction transaction);
+
+    /**
+     * Execute the Update.
+     */
+    public int executeOrmUpdate(Update<?> update, Transaction t);
+    
+    /**
+     * Execute the UpdateSql.
+     */
+    public int executeSqlUpdate(SqlUpdate update, Transaction t);
+    
+    /**
+     * Execute the CallableSql.
+     */
+    public int executeCallable(CallableSql callable, Transaction t);
+    
+}

src/main/java/com/avaje/ebeaninternal/server/core/ProxyBeanObjectInputStream.java

@@ -0,0 +1,111 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectStreamClass;
+
+import com.avaje.ebean.EbeanServer;
+import com.avaje.ebean.bean.SerializeControl;
+import com.avaje.ebeaninternal.api.ClassUtil;
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
+import com.avaje.ebeaninternal.server.subclass.SubClassUtil;
+
+/**
+ * Read an ObjectInputStream potentially containing "proxy" / "subclassed"
+ * entity objects.
+ * <p>
+ * This does not need to be used for "Enhanced" beans... but if you want to
+ * deserialise "proxy" / "subclassed" beans you need to use this
+ * ProxyBeanObjectInputStream. The reason is because it is required to resolve
+ * the class (The class with the $$EntityBean suffix). As this class is in
+ * another class loader typically as plain ObjectInputStream is unable to resolve
+ * the class - and hence we need to use this ProxyBeanObjectInputStream.
+ * </p>
+ */
+public class ProxyBeanObjectInputStream extends ObjectInputStream {
+
+	private final SpiEbeanServer ebeanServer;
+
+	/**
+	 * Create with a given InputStream and EbeanServer.
+	 * <p>
+	 * The EbeanServer should be the one that created the 'proxy' classes that
+	 * were serialised.
+	 * </p>
+	 */
+	public ProxyBeanObjectInputStream(InputStream in, EbeanServer ebeanServer)
+			throws IOException {
+		
+		super(in);
+		this.ebeanServer = (SpiEbeanServer) ebeanServer;
+		SerializeControl.setVanilla(false);
+	}
+
+	/**
+	 * close and reset the serialization mode.
+	 * <p>
+	 * uses SerializeControl.resetToDefault().
+	 * </p>
+	 */
+	public void close() throws IOException {
+		super.close();
+		SerializeControl.resetToDefault();
+	}
+
+	/**
+	 * Resolve the generated Class potentially using reading the embedded
+	 * MethodInfo.
+	 */
+	protected Class<?> resolveGenerated(ObjectStreamClass desc)
+			throws IOException, ClassNotFoundException {
+
+		String className = desc.getName();
+
+		String vanillaClassName = SubClassUtil.getSuperClassName(className);
+		Class<?> vanillaClass = ClassUtil.forName(vanillaClassName, this.getClass());
+
+		BeanDescriptor<?> d = ebeanServer.getBeanDescriptor(vanillaClass);
+		if (d == null) {
+			String msg = "Could not find BeanDescriptor for "+ vanillaClassName;
+			throw new IOException(msg);
+		} else {
+			return d.getFactoryType();
+		}
+	}
+
+	/**
+	 * checks for generated subclasses and handles them appropriately.
+	 */
+	protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException,
+			ClassNotFoundException {
+
+		String className = desc.getName();
+		if (SubClassUtil.isSubClass(className)) {
+			return resolveGenerated(desc);
+		}
+
+		return super.resolveClass(desc);
+	}
+
+}

src/main/java/com/avaje/ebeaninternal/server/core/PstmtBatch.java

@@ -0,0 +1,36 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+/**
+ * If Oracle supported the JDBC api fully this would not be required.
+ */
+public interface PstmtBatch {
+
+	public void setBatchSize(PreparedStatement pstmt, int batchSize);
+
+	public void addBatch(PreparedStatement pstmt) throws SQLException;
+
+    public int executeBatch(PreparedStatement pstmt, int expectedRows, String sql, boolean occCheck) throws SQLException;
+
+}

src/main/java/com/avaje/ebeaninternal/server/core/RefreshHelp.java

@@ -0,0 +1,234 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+
+/**
+ * Helper for performing a 'refresh' on an Entity bean.
+ * <p>
+ * Note that this does not 'refresh' any OnetoMany or ManyToMany properties. It
+ * refreshes all the other properties though.
+ * </p>
+ */
+public class RefreshHelp {
+//
+//	/**
+//	 * Helper for debug of lazy loading.
+//	 */
+//	private final DebugLazyLoad debugLazyLoad;
+//	
+//	private final MAdminLoggingMBean logControl;
+//	
+//	public RefreshHelp(MAdminLoggingMBean logControl, boolean debugLazyLoad){
+//		this.logControl = logControl;
+//		this.debugLazyLoad = new DebugLazyLoad(debugLazyLoad);
+//	}
+//
+//	/**
+//	 * Refresh the bean from property values in dbBean.
+//	 */
+//	public void refresh(Object o, Object dbBean, BeanDescriptor<?> desc, EntityBeanIntercept ebi, Object id, boolean isLazyLoad) {
+//
+//		Object originalOldValues = null;
+//		boolean setOriginalOldValues = false;
+//
+//		// set of properties to exclude from the refresh because it is
+//		// not a refresh but rather a lazyLoading event.
+//		Set<String> excludes = null;
+//					
+//		// turn off intercepting so lazy loading is
+//		// not invoked when populating the bean
+//		// with PropertyChangeSupport
+//		ebi.setIntercepting(false);
+//		
+//		boolean readOnly = ebi.isReadOnly();
+//		boolean sharedInstance = ebi.isSharedInstance();
+//		
+//		if (isLazyLoad){
+//			excludes = ebi.getLoadedProps();
+//			if (excludes != null){
+//				// lazy loading a "Partial Object"... which already
+//				// contains some properties and perhaps some oldValues
+//				// and these will need to be maintained...
+//				originalOldValues = ebi.getOldValues();
+//				setOriginalOldValues = originalOldValues != null;					
+//			}
+//			
+//			if (logControl.isDebugLazyLoad()){
+//				debug(desc, ebi, id, excludes);
+//			}				
+//		}
+//	
+//				
+//		BeanProperty[] props = desc.propertiesBaseScalar();
+//		for (int i = 0; i < props.length; i++) {
+//			BeanProperty prop = props[i];
+//			if (excludes != null && excludes.contains(prop.getName())){
+//				// ignore this property (partial bean lazy loading)
+//				
+//			} else {
+//				Object dbVal = prop.getValue(dbBean);
+//				if (isLazyLoad) {
+//					prop.setValue(o, dbVal);
+//				} else {			
+//					prop.setValueIntercept(o, dbVal);
+//				}
+//				if (setOriginalOldValues){
+//					// maintain original oldValues for partially loaded bean
+//					prop.setValue(originalOldValues, dbVal);
+//				}
+//			}
+//		}
+//
+//		BeanPropertyAssocOne<?>[] ones = desc.propertiesOne();
+//		for (int i = 0; i < ones.length; i++) {
+//			BeanProperty prop = ones[i];
+//			if (excludes != null && excludes.contains(prop.getName())){
+//				 // ignore this property (partial bean lazy loading)
+//				
+//			} else {
+//				Object dbVal = prop.getValue(dbBean);
+//				if (isLazyLoad){
+//					prop.setValue(o, dbVal);					
+//				} else {
+//					prop.setValueIntercept(o, dbVal);
+//				}
+//				if (setOriginalOldValues){
+//					// maintain original oldValues for partially loaded bean
+//					prop.setValue(originalOldValues, dbVal);
+//				}
+//				if (dbVal != null){
+//					if (sharedInstance){
+//						// propagate sharedInstance status to associated beans
+//						((EntityBean)dbVal)._ebean_getIntercept().setSharedInstance();
+//					} else if (readOnly) {
+//						// propagate readOnly status to associated beans
+//						((EntityBean)dbVal)._ebean_getIntercept().setReadOnly(true);						
+//					}
+//				}
+//				
+//			}
+//		}
+//
+//		refreshEmbedded(o, dbBean, desc, excludes, readOnly);
+//
+//		// set a lazy loading many proxy if required
+//		BeanPropertyAssocMany<?>[] manys = desc.propertiesMany();
+//		for (int i = 0; i < manys.length; i++) {
+//			BeanPropertyAssocMany<?> prop = manys[i];
+//			if (excludes != null && excludes.contains(prop.getName())){
+//				// the many already existed on the bean
+//				
+//			} else {
+//				// set a lazy loading proxy
+//				prop.createReference(o, null, readOnly, sharedInstance);				
+//			}
+//		}
+//		
+//		// the refreshed/lazy loaded bean is always fully
+//		// populated so set loadedProps to null
+//		ebi.setLoadedProps(null);
+//		
+//		
+//		// reset the loaded status
+//		ebi.setLoaded();		
+//	}
+//
+//	/**
+//	 * Refresh the Embedded beans.
+//	 */
+//	private void refreshEmbedded(Object o, Object dbBean, BeanDescriptor<?> desc, Set<String> excludes, boolean propagateReadOnly) {
+//
+//		BeanPropertyAssocOne<?>[] embeds = desc.propertiesEmbedded();
+//		for (int i = 0; i < embeds.length; i++) {
+//			BeanPropertyAssocOne<?> prop = embeds[i];
+//			if (excludes != null && excludes.contains(prop.getName())){
+//				// ignore this property
+//			} else {
+//				// the original embedded bean
+//				Object oEmb = prop.getValue(o);
+//				
+//				// the new one from the database
+//				Object dbEmb = prop.getValue(dbBean);
+//	
+//				if (oEmb == null){
+//					// original embedded bean was null
+//					// so just replace the entire embedded bean
+//					prop.setValueIntercept(o, dbEmb);
+//					if (propagateReadOnly && dbEmb != null){
+//						// propagate readOnly status to embedded beans
+//						((EntityBean)dbEmb)._ebean_getIntercept().setReadOnly(true);
+//					}
+//					
+//				} else {
+//					// refresh each property of the original
+//					// embedded bean
+//					if (oEmb instanceof EntityBean){
+//						// turn off interception to stop invoking lazy loading
+//						// but allow PropertyChangeSupport
+//						((EntityBean) oEmb)._ebean_getIntercept().setIntercepting(false);
+//					}
+//					
+//					BeanProperty[] props = prop.getProperties();
+//					for (int j = 0; j < props.length; j++) {
+//						Object v = props[j].getValue(dbEmb);
+//						props[j].setValueIntercept(oEmb, v);
+//					}
+//		
+//					// No longer calling setLoaded() on embedded bean
+//					// as the EntityBean itself
+//					// .. calls setEmbeddedLoaded() on each of
+//					// .. its embedded beans itself.					
+//				}
+//			}
+//		}
+//	}
+//	
+//
+//	/**
+//	 * Output some debug to describe the lazy loading event.
+//	 */
+//	private void debug(BeanDescriptor<?> desc, EntityBeanIntercept ebi, Object id, Set<String> excludes) {
+//		
+//				
+//		Class<?> beanType = desc.getBeanType();
+//		
+//		StackTraceElement cause = debugLazyLoad.getStackTraceElement(beanType);
+//		
+//		String lazyLoadProperty = ebi.getLazyLoadProperty();
+//		String msg = "debug.lazyLoad ["+desc+"] id["+id+"] lazyLoadProperty["+lazyLoadProperty+"]";
+//		if (excludes != null){
+//			msg += " partialProps"+excludes;
+//		} 
+//		if (cause != null){
+//			String causeLine = cause.toString();
+//			if (causeLine.indexOf(".groovy:") > -1){
+//				// eclipse console does not like finding groovy source at the moment
+//				causeLine = StringHelper.replaceString(causeLine, ".groovy:", ".groovy :");
+//			}
+//			msg += " at: "+causeLine;
+//		}
+//		System.err.println(msg);		
+//	}
+//	
+//
+//	
+
+}

src/main/java/com/avaje/ebeaninternal/server/core/RelationalQueryEngine.java

@@ -0,0 +1,11 @@
+package com.avaje.ebeaninternal.server.core;
+
+
+public interface RelationalQueryEngine {
+
+	/**
+	 * Find a list of beans using relational query.
+	 */
+	public abstract Object findMany(RelationalQueryRequest request);
+
+}

src/main/java/com/avaje/ebeaninternal/server/core/RelationalQueryRequest.java

@@ -0,0 +1,147 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import com.avaje.ebean.EbeanServer;
+import com.avaje.ebean.SqlQuery;
+import com.avaje.ebean.SqlRow;
+import com.avaje.ebean.Transaction;
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.api.SpiQuery;
+import com.avaje.ebeaninternal.api.SpiSqlQuery;
+import com.avaje.ebeaninternal.api.SpiTransaction;
+
+/**
+ * Wraps the objects involved in executing a SqlQuery.
+ */
+public final class RelationalQueryRequest {
+
+    private final SpiSqlQuery query;
+
+    private final RelationalQueryEngine queryEngine;
+
+    private final SpiEbeanServer ebeanServer;
+
+    private SpiTransaction trans;
+
+    private boolean createdTransaction;
+
+    private SpiQuery.Type queryType;
+
+    /**
+     * Create the BeanFindRequest.
+     */
+    public RelationalQueryRequest(SpiEbeanServer server, RelationalQueryEngine engine, SqlQuery q, Transaction t) {
+        this.ebeanServer = server;
+        this.queryEngine = engine;
+        this.query = (SpiSqlQuery) q;
+        this.trans = (SpiTransaction) t;
+    }
+
+    /**
+     * Rollback the transaction if it was created for this request.
+     */
+    public void rollbackTransIfRequired() {
+        if (createdTransaction) {
+            trans.rollback();
+        }
+    }
+
+    /**
+     * Create a transaction if none currently exists.
+     */
+    public void initTransIfRequired() {
+        if (trans == null) {
+            trans = ebeanServer.getCurrentServerTransaction();
+            if (trans == null || !trans.isActive()) {
+                // create a local readOnly transaction
+                trans = ebeanServer.createServerTransaction(false, -1);
+
+                // commented out for performance reasons...
+                // TODO: review performance of trans.setReadOnly(true)
+                // trans.setReadOnly(true);
+                createdTransaction = true;
+            }
+        }
+    }
+
+    /**
+     * End the transaction if it was locally created.
+     */
+    public void endTransIfRequired() {
+        if (createdTransaction) {
+            // we can rollback as a readOnly transaction.
+            trans.rollback();
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public List<SqlRow> findList() {
+        queryType = SpiQuery.Type.LIST;
+        return (List<SqlRow>) queryEngine.findMany(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    public Set<SqlRow> findSet() {
+        queryType = SpiQuery.Type.SET;
+        return (Set<SqlRow>) queryEngine.findMany(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    public Map<?, SqlRow> findMap() {
+        queryType = SpiQuery.Type.MAP;
+        return (Map<?, SqlRow>) queryEngine.findMany(this);
+    }
+
+    /**
+     * Return the find that is to be performed.
+     */
+    public SpiSqlQuery getQuery() {
+        return query;
+    }
+
+    /**
+     * Return the type (List, Set or Map) that this fetch returns.
+     */
+    public SpiQuery.Type getQueryType() {
+        return queryType;
+    }
+
+    public EbeanServer getEbeanServer() {
+        return ebeanServer;
+    }
+
+    public SpiTransaction getTransaction() {
+        return trans;
+    }
+
+    public boolean isLogSql() {
+        return trans.isLogSql();
+    }
+
+    public boolean isLogSummary() {
+        return trans.isLogSummary();
+    }
+
+}

src/main/java/com/avaje/ebeaninternal/server/core/ServletContextListener.java

@@ -0,0 +1,76 @@
+/**
+ * Copyright (C) 2006  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.util.logging.Logger;
+
+import javax.servlet.ServletContext;
+import javax.servlet.ServletContextEvent;
+
+import com.avaje.ebean.Ebean;
+import com.avaje.ebean.config.GlobalProperties;
+import com.avaje.ebeaninternal.server.lib.ShutdownManager;
+
+/**
+ * Listens for webserver server starting and stopping events.
+ * 
+ * <p>
+ * Register this listener in the web.xml configuration file. This will listen
+ * for startup and shutdown events.
+ * </p>
+ */
+public class ServletContextListener implements javax.servlet.ServletContextListener {
+
+    private static final Logger logger = Logger.getLogger(ServletContextListener.class.getName());
+
+    /**
+     * The servlet container is stopping.
+     */
+    public void contextDestroyed(ServletContextEvent event) {
+    	ShutdownManager.shutdown();
+    }
+
+    /**
+     * The servlet container is starting. 
+     * <p>
+     * Initialise the properties file using SystemProperties.initWebapp();
+     * and start Ebean.
+     * </p>
+     */
+    public void contextInitialized(ServletContextEvent event) {
+
+        try {
+            ServletContext servletContext = event.getServletContext();
+            GlobalProperties.setServletContext(servletContext);
+
+            if (servletContext != null) {
+                String servletRealPath = servletContext.getRealPath("");
+                GlobalProperties.put("servlet.realpath", servletRealPath);
+                logger.info("servlet.realpath=[" + servletRealPath + "]");
+            }            
+ 
+            Ebean.getServer(null);
+            
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        }
+    }
+    
+}

src/main/java/com/avaje/ebeaninternal/server/core/SpiOrmQueryRequest.java

@@ -0,0 +1,119 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import com.avaje.ebean.QueryIterator;
+import com.avaje.ebean.QueryResultVisitor;
+import com.avaje.ebean.bean.BeanCollection;
+import com.avaje.ebeaninternal.api.SpiQuery;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
+
+/**
+ * Defines the ORM query request api.
+ */
+public interface SpiOrmQueryRequest<T> {
+
+    /**
+     * Return the query.
+     */
+    public SpiQuery<T> getQuery();
+
+    /**
+     * Return the associated BeanDescriptor.
+     */
+    public BeanDescriptor<?> getBeanDescriptor();
+
+    /**
+     * This will create a local (readOnly) transaction if no current transaction
+     * exists.
+     * <p>
+     * A transaction may have been passed in explicitly or currently be active
+     * in the thread local. If not, then a readOnly transaction is created to
+     * execute this query.
+     * </p>
+     */
+    public void initTransIfRequired();
+
+    /**
+     * Will end a locally created transaction.
+     * <p>
+     * It ends the transaction by using a rollback() as the transaction is known
+     * to be readOnly.
+     * </p>
+     */
+    public void endTransIfRequired();
+
+    public void rollbackTransIfRequired();
+
+    /**
+     * Execute the query as findById.
+     */
+    public Object findId();
+
+    /**
+     * Execute the find row count query.
+     */
+    public int findRowCount();
+
+    /**
+     * Execute the find ids query.
+     */
+    public List<Object> findIds();
+
+    /**
+     * Execute the find returning a QueryIterator and visitor pattern.
+     */
+    public void findVisit(QueryResultVisitor<T> visitor);
+
+    /**
+     * Execute the find returning a QueryIterator.
+     */
+    public QueryIterator<T> findIterate();
+    
+    /**
+     * Execute the query as findList.
+     */
+    public List<T> findList();
+
+    /**
+     * Execute the query as findSet.
+     */
+    public Set<?> findSet();
+
+    /**
+     * Execute the query as findMap.
+     */
+    public Map<?, ?> findMap();
+
+    /**
+     * Try to get the object out of the persistence context.
+     */
+    //public T getFromPersistenceContextOrCache();
+
+    /**
+     * Try to get the query result from the query cache.
+     */
+    public BeanCollection<T> getFromQueryCache();
+
+}

src/main/java/com/avaje/ebeaninternal/server/core/TraditionalBackgroundExecutor.java

@@ -0,0 +1,63 @@
+/**
+ * Copyright (C) 2009  Robin Bygrave
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.util.concurrent.TimeUnit;
+
+import com.avaje.ebeaninternal.api.SpiBackgroundExecutor;
+import com.avaje.ebeaninternal.server.lib.DaemonScheduleThreadPool;
+import com.avaje.ebeaninternal.server.lib.thread.ThreadPool;
+
+/**
+ * BackgroundExecutor using my traditional ThreadPool that will grow and trim.
+ * 
+ * @author rbygrave
+ */
+public class TraditionalBackgroundExecutor implements SpiBackgroundExecutor {
+
+	private final ThreadPool pool;
+	
+	private final DaemonScheduleThreadPool schedulePool;
+
+	/**
+	 * Construct the default implementation of BackgroundExecutor.
+	 */
+	public TraditionalBackgroundExecutor(ThreadPool pool, int schedulePoolSize, int shutdownWaitSeconds, String namePrefix) {
+		this.pool = pool;
+		this.schedulePool = new DaemonScheduleThreadPool(schedulePoolSize, shutdownWaitSeconds, namePrefix+"-periodic-");
+	}
+
+	/**
+	 * Execute a Runnable using a background thread.
+	 */
+	public void execute(Runnable r) {
+	    pool.assign(r, true);
+	}
+
+	public void executePeriodically(Runnable r, long delay, TimeUnit unit) {
+		schedulePool.scheduleWithFixedDelay(r, delay, delay, unit);
+	}
+
+	public void shutdown() {
+		// the pool is shutdown automatically by the ThreadPoolManager
+		schedulePool.shutdown();
+	}
+	
+}

src/main/java/com/avaje/ebeaninternal/server/core/TransWrapper.java

@@ -0,0 +1,46 @@
+package com.avaje.ebeaninternal.server.core;
+
+import com.avaje.ebeaninternal.api.SpiTransaction;
+
+/**
+ * Used to temporarily wrap a thread local based transaction.
+ * <p>
+ * Additionally notes if the transaction was created by the request in which
+ * case it needs to be commited after the request has been processed.
+ * </p>
+ */
+final class TransWrapper {
+
+	final SpiTransaction transaction;
+
+	private final boolean wasCreated;
+
+	/**
+	 * Wrap the transaction indicating if it was just created.
+	 */
+	TransWrapper(SpiTransaction t, boolean created) {
+		transaction = t;
+		wasCreated = created;
+	}
+
+	void commitIfCreated() {
+		if (wasCreated){
+			transaction.commit();
+		}
+	}
+	
+	void rollbackIfCreated() {
+		if (wasCreated){
+			transaction.rollback();
+		}
+	}
+	
+	/**
+	 * Return true if the transaction was just created. If true it should be
+	 * committed after the request has been processed.
+	 */
+	boolean wasCreated() {
+		return wasCreated;
+	}
+
+}

src/main/java/com/avaje/ebeaninternal/server/core/XmlConfig.java

@@ -0,0 +1,83 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.avaje.ebeaninternal.server.lib.util.Dnode;
+
+/**
+ * Holds the orm.xml and ebean-orm.xml deployment information.
+ * 
+ * @author rbygrave
+ */
+public class XmlConfig {
+
+    private final List<Dnode> ebeanOrmXml;
+    private final List<Dnode> ormXml;
+    private final List<Dnode> allXml;
+    
+    public XmlConfig(List<Dnode> ormXml, List<Dnode> ebeanOrmXml){
+        this.ormXml = ormXml;
+        this.ebeanOrmXml = ebeanOrmXml;
+        this.allXml = new ArrayList<Dnode>(ormXml.size() + ebeanOrmXml.size());
+        allXml.addAll(ormXml);
+        allXml.addAll(ebeanOrmXml);
+    }
+    
+    public List<Dnode> getEbeanOrmXml() {
+        return ebeanOrmXml;
+    }
+    
+    public List<Dnode> getOrmXml() {
+        return ormXml;
+    }
+
+    public List<Dnode> find(List<Dnode> entityXml, String element) {
+        ArrayList<Dnode> hits = new ArrayList<Dnode>();
+        for (int i = 0; i < entityXml.size(); i++) {
+            hits.addAll(entityXml.get(i).findAll(element, 1));
+        }
+        return hits;
+    }
+    
+    /**
+     * Find the deployment xml for a given entity.
+     * <p>
+     * This searches all the orm.xml and ebean-orm.xml files.
+     * </p>
+     */
+    public List<Dnode> findEntityXml(String className) {
+
+        ArrayList<Dnode> hits = new ArrayList<Dnode>(2);
+        
+        for (Dnode ormXml : allXml) {
+            Dnode entityMappings = ormXml.find("entity-mappings");
+
+            List<Dnode> entities = entityMappings.findAll("entity", "class", className, 1);
+            if (entities.size() == 1) {
+                hits.add(entities.get(0));
+            }
+        }
+
+        return hits;
+    }
+}

src/main/java/com/avaje/ebeaninternal/server/core/XmlConfigLoader.java

@@ -0,0 +1,192 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.core;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.net.URL;
+import java.net.URLDecoder;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.jar.JarFile;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.zip.ZipEntry;
+
+import com.avaje.ebean.config.GlobalProperties;
+import com.avaje.ebeaninternal.api.ClassUtil;
+import com.avaje.ebeaninternal.server.lib.util.Dnode;
+import com.avaje.ebeaninternal.server.lib.util.DnodeReader;
+import com.avaje.ebeaninternal.server.util.ClassPathReader;
+import com.avaje.ebeaninternal.server.util.DefaultClassPathReader;
+
+/**
+ * Used to read the orm.xml and ebean-orm.xml configuration files.
+ * 
+ * @author rbygrave
+ */
+public class XmlConfigLoader {
+
+    private static final Logger logger = Logger.getLogger(XmlConfigLoader.class.getName());
+    
+    private final ClassPathReader classPathReader;
+
+    private final Object[] classPaths;
+  
+    
+    public XmlConfigLoader(ClassLoader classLoader){
+        
+        if (classLoader == null) {
+            classLoader = getClass().getClassLoader();
+        }
+        
+        String cn = GlobalProperties.get("ebean.classpathreader", null);
+        if (cn != null){
+            // use a user defined classPathReader
+            logger.info("Using ["+cn+"] to read the searchable class path");
+            this.classPathReader = (ClassPathReader)ClassUtil.newInstance(cn, this.getClass());
+        } else {
+            this.classPathReader = new DefaultClassPathReader();
+        }
+        
+        this.classPaths = classPathReader.readPath(classLoader);
+    }
+    
+    public XmlConfig load() {
+        List<Dnode> ormXml = search("META-INF/orm.xml");
+        List<Dnode> ebeanOrmXml = search("META-INF/ebean-orm.xml");
+        
+        return new XmlConfig(ormXml, ebeanOrmXml);
+    }
+    
+    public List<Dnode> search(String searchFor) {
+        
+        ArrayList<Dnode> xmlList = new ArrayList<Dnode>();
+
+        String charsetName = Charset.defaultCharset().name();
+
+        for (int h = 0; h < classPaths.length; h++) {
+
+            try {
+                // for each class path ...
+                File classPath;
+                if (URL.class.isInstance(classPaths[h])) {
+                    classPath = new File(((URL) classPaths[h]).getFile());
+                } else {
+                    classPath = new File(classPaths[h].toString());
+                }
+
+                // URL Decode the path replacing %20 to space characters.
+                String path = URLDecoder.decode(classPath.getAbsolutePath(), charsetName);
+
+                classPath = new File(path);
+
+                if (classPath.isDirectory()) {
+                    checkDir(searchFor, xmlList, classPath);
+
+                } else if (classPath.getName().endsWith(".jar")) {
+                    checkJar(searchFor, xmlList, classPath);
+
+                } else {
+                    // this is not expected
+                    String msg = "Not a Jar or Directory? " + classPath.getAbsolutePath();
+                    logger.log(Level.SEVERE, msg);
+                }
+
+            } catch (UnsupportedEncodingException e) {
+                throw new RuntimeException(e);
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        return xmlList;
+        
+    }
+
+    private void processInputStream(ArrayList<Dnode> xmlList, InputStream is) throws IOException {
+      
+        DnodeReader reader = new DnodeReader();
+        Dnode xmlDoc = reader.parseXml(is);
+        is.close();
+        
+        xmlList.add(xmlDoc);
+    }
+    
+    private void checkFile(String searchFor, ArrayList<Dnode> xmlList, File dir) throws IOException {
+
+        File f = new File(dir, searchFor);
+        if (f.exists()){
+            FileInputStream fis = new FileInputStream(f);
+            BufferedInputStream is = new BufferedInputStream(fis);
+            processInputStream(xmlList, is);
+        }
+    }
+    
+    private void checkDir(String searchFor, ArrayList<Dnode> xmlList, File dir) throws IOException {
+
+        checkFile(searchFor, xmlList, dir);
+        
+        if (dir.getPath().endsWith("classes")) {
+            // see if this is part of webapp and look for META-INF/searchFor
+            // relative to the WEB-INF/classes directory
+            File parent = dir.getParentFile();
+            if (parent != null && parent.getPath().endsWith("WEB-INF")){
+                parent = parent.getParentFile();
+                if (parent != null){
+                    File metaInf = new File(parent, "META-INF");
+                    if (metaInf.exists()){
+                        checkFile(searchFor, xmlList, metaInf);
+                    }
+                }
+            }
+        }
+    }
+    
+    private void checkJar(String searchFor, ArrayList<Dnode> xmlList, File classPath) throws IOException {
+        
+        String fileName = classPath.getName();
+        if (fileName.toLowerCase().startsWith("surefire")){
+            return;
+        }
+        JarFile module = null;
+        try {
+            module = new JarFile(classPath);
+            ZipEntry entry = module.getEntry(searchFor);
+            if (entry != null){
+                InputStream is = module.getInputStream(entry); 
+                processInputStream(xmlList, is);
+            }
+        } catch (Exception e) {
+            logger.info("Unable to check jar file "+fileName+" for ebean-orm.xml");
+        } finally {
+            if (module != null){
+                module.close();
+            }
+        }
+    }
+
+    
+}

src/main/java/com/avaje/ebeaninternal/server/core/package.html

@@ -0,0 +1,11 @@
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=iso-8859-1">
+	<TITLE>Core implementation objects</TITLE>
+</HEAD>
+<Body BGCOLOR="#ffffff">
+Core implementation objects
+
+
+</Body>
+</HTML>

src/main/java/com/avaje/ebeaninternal/server/ddl/AbstractBeanVisitor.java

@@ -0,0 +1,65 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebeaninternal.server.ddl;
+
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
+import com.avaje.ebeaninternal.server.deploy.BeanProperty;
+import com.avaje.ebeaninternal.server.deploy.InheritInfo;
+import com.avaje.ebeaninternal.server.deploy.InheritInfoVisitor;
+
+/**
+ * Base BeanVisitor that can help visiting inherited properties.
+ * 
+ * @author rbygrave
+ */
+public abstract class AbstractBeanVisitor implements BeanVisitor {
+    
+    /**
+     * Visit all the other inheritance properties that are not on the root.
+     */
+    public void visitInheritanceProperties(BeanDescriptor<?> descriptor, PropertyVisitor pv) {
+
+        InheritInfo inheritInfo = descriptor.getInheritInfo();
+        if (inheritInfo != null && inheritInfo.isRoot()){
+            // add all properties on the children objects
+            InheritChildVisitor childVisitor = new InheritChildVisitor(pv);
+            inheritInfo.visitChildren(childVisitor);
+        }
+    }
+    
+
+    /**
+     * Helper used to visit all the inheritInfo/BeanDescriptor in
+     * the inheritance hierarchy (to add their 'local' properties).
+     */
+    protected static class InheritChildVisitor implements InheritInfoVisitor {
+
+        final PropertyVisitor pv;
+        
+        protected InheritChildVisitor(PropertyVisitor pv) {
+            this.pv = pv;
+        }
+        
+        public void visit(InheritInfo inheritInfo) {
+            BeanProperty[] propertiesLocal = inheritInfo.getBeanDescriptor().propertiesLocal();
+            VisitorUtil.visit(propertiesLocal, pv);         
+        }
+    }
+}

src/main/java/com/avaje/ebeaninternal/server/ddl/AbstractPropertyVisitor.java

@@ -0,0 +1,41 @@
+package com.avaje.ebeaninternal.server.ddl;
+
+import com.avaje.ebeaninternal.server.deploy.BeanProperty;
+import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocMany;
+import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocOne;
+import com.avaje.ebeaninternal.server.deploy.BeanPropertyCompound;
+
+/**
+ * Has no implementation. Can be used as a base object so that
+ * selective methods can be implemented. 
+ */
+public abstract class AbstractPropertyVisitor implements PropertyVisitor {
+
+	public void visitEmbedded(BeanPropertyAssocOne<?> p) {
+	}
+
+	public void visitEmbeddedScalar(BeanProperty p, BeanPropertyAssocOne<?> embedded) {
+	}
+
+	public void visitMany(BeanPropertyAssocMany<?> p) {	
+	}
+
+	public void visitOneExported(BeanPropertyAssocOne<?> p) {
+	}
+
+	public void visitOneImported(BeanPropertyAssocOne<?> p) {	
+	}
+
+	public void visitScalar(BeanProperty p) {
+	}
+
+    public void visitCompound(BeanPropertyCompound p) {    
+    }
+
+    public void visitCompoundScalar(BeanPropertyCompound compound, BeanProperty p) {
+    }
+
+	
+	
+	
+}

src/main/java/com/avaje/ebeaninternal/server/ddl/AddForeignKeysVisitor.java

@@ -0,0 +1,149 @@
+package com.avaje.ebeaninternal.server.ddl;
+
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
+import com.avaje.ebeaninternal.server.deploy.BeanProperty;
+import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocOne;
+import com.avaje.ebeaninternal.server.deploy.BeanPropertyCompound;
+import com.avaje.ebeaninternal.server.deploy.TableJoin;
+import com.avaje.ebeaninternal.server.deploy.TableJoinColumn;
+
+/**
+ * Used to generate the foreign key DDL and related indexes.
+ */
+public class AddForeignKeysVisitor extends AbstractBeanVisitor {
+
+	final DdlGenContext ctx;
+
+	final FkeyPropertyVisitor pv;
+
+	public AddForeignKeysVisitor(DdlGenContext ctx) {
+		this.ctx = ctx;
+		this.pv = new FkeyPropertyVisitor(this, ctx);
+	}
+
+	public boolean visitBean(BeanDescriptor<?> descriptor) {
+		if (!descriptor.isInheritanceRoot()){
+			// ignore/skip if not a top level BeanDescriptor
+			return false;
+		}
+		return true;
+	}
+    
+    public void visitBeanEnd(BeanDescriptor<?> descriptor) {
+
+        visitInheritanceProperties(descriptor, pv);
+    }
+
+	public void visitBegin() {
+	}
+
+	public void visitEnd() {
+		ctx.addIntersectionFkeys();
+	}
+
+	public PropertyVisitor visitProperty(BeanProperty p) {
+		return pv;
+	}
+
+
+	public static class FkeyPropertyVisitor extends BaseTablePropertyVisitor {
+
+		final DdlGenContext ctx;
+
+		final AddForeignKeysVisitor parent;
+
+		public FkeyPropertyVisitor(AddForeignKeysVisitor parent, DdlGenContext ctx) {
+			this.parent = parent;
+			this.ctx = ctx;
+		}
+
+		@Override
+		public void visitEmbeddedScalar(BeanProperty p, BeanPropertyAssocOne<?> embedded) {
+			// not interested
+		}
+
+		@Override
+		public void visitOneImported(BeanPropertyAssocOne<?> p) {
+
+			// alter table {basetable} add foreign key (...) references {} (...) on delete restrict on update restrict;
+			// Alter table o_address add Foreign Key (country_code) references o_country (code) on delete  restrict on update  restrict;
+
+			String baseTable = p.getBeanDescriptor().getBaseTable();
+
+			TableJoin tableJoin = p.getTableJoin();
+
+			TableJoinColumn[] columns = tableJoin.columns();
+
+
+			String tableName = p.getBeanDescriptor().getBaseTable();
+			String fkName = ctx.getDdlSyntax().getForeignKeyName(tableName, p.getName(), ctx.incrementFkCount());
+	
+			ctx.write("alter table ").write(baseTable).write(" add ");
+			if (fkName != null) {
+				ctx.write("constraint ").write(fkName).write(" ");
+			}
+			ctx.write("foreign key (");
+			for (int i = 0; i < columns.length; i++) {
+				if (i > 0){
+					ctx.write(",");
+				}
+				ctx.write(columns[i].getLocalDbColumn());
+			}
+			ctx.write(")");
+
+			ctx.write(" references ");
+			ctx.write(tableJoin.getTable());
+			ctx.write(" (");
+			for (int i = 0; i < columns.length; i++) {
+				if (i > 0){
+					ctx.write(",");
+				}
+				ctx.write(columns[i].getForeignDbColumn());
+			}
+			ctx.write(")");
+
+			String fkeySuffix = ctx.getDdlSyntax().getForeignKeySuffix();
+			if (fkeySuffix != null){
+				ctx.write(" ").write(fkeySuffix);
+			}
+			ctx.write(";").writeNewLine();
+
+			if (ctx.getDdlSyntax().isRenderIndexForFkey()){
+
+				//create index idx_fk_o_address_ctry on o_address(country_code);
+				ctx.write("create index ");
+
+				String idxName = ctx.getDdlSyntax().getIndexName(tableName, p.getName(), ctx.incrementIxCount());
+				if (idxName != null){
+					ctx.write(idxName);
+				}
+
+				ctx.write(" on ").write(baseTable).write(" (");
+				for (int i = 0; i < columns.length; i++) {
+					if (i > 0){
+						ctx.write(",");
+					}
+					ctx.write(columns[i].getLocalDbColumn());
+				}
+				ctx.write(");").writeNewLine();
+			}
+		}
+
+		@Override
+		public void visitScalar(BeanProperty p) {
+			// not interested
+		}
+
+		@Override
+        public void visitCompound(BeanPropertyCompound p) {
+            // not interested
+        }
+
+        @Override
+        public void visitCompoundScalar(BeanPropertyCompound compound, BeanProperty p) {
+            // not interested
+        }
+		
+	}
+
+}