diff --git a/jetty-infinispan/src/main/java/org/eclipse/jetty/session/infinispan/InfinispanSessionIdManager.java b/jetty-infinispan/src/main/java/org/eclipse/jetty/session/infinispan/InfinispanSessionIdManager.java
index 257f6ba..7ca6a58 100644
--- a/jetty-infinispan/src/main/java/org/eclipse/jetty/session/infinispan/InfinispanSessionIdManager.java
+++ b/jetty-infinispan/src/main/java/org/eclipse/jetty/session/infinispan/InfinispanSessionIdManager.java
@@ -19,6 +19,7 @@
 package org.eclipse.jetty.session.infinispan;
 
 import java.util.Random;
+import java.util.concurrent.TimeUnit;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpSession;
@@ -52,18 +53,25 @@
  * </pre>
  * where [id] is the id of the session.
  * 
+ * If the first session to be added is not immortal (ie it has a timeout on it) then
+ * the corresponding session id is entered into infinispan with an idle expiry timeout
+ * equivalent to double the session's timeout (the multiplier is configurable).
+ * 
+ * 
  * Having one entry per in-use session id means that there is no contention on
  * cache entries (as would be the case if a single entry was kept containing a 
  * list of in-use session ids).
  * 
- * TODO synchronization
+ * 
  */
 public class InfinispanSessionIdManager extends AbstractSessionIdManager
 {
     private  final static Logger LOG = Log.getLogger("org.eclipse.jetty.server.session");
-    protected final static String ID_KEY = "__o.e.j.s.infinispanIdMgr__";
+    public final static String ID_KEY = "__o.e.j.s.infinispanIdMgr__";
+    public static final int DEFAULT_IDLE_EXPIRY_MULTIPLE = 2;
     protected BasicCache<String,Object> _cache;
     private Server _server;
+    private int _idleExpiryMultiple = DEFAULT_IDLE_EXPIRY_MULTIPLE;
 
     
     
@@ -132,7 +140,8 @@
         
         String clusterId = getClusterId(id);
         
-        //ask the cluster
+        //ask the cluster - this should also tickle the idle expiration timer on the sessionid entry
+        //keeping it valid
         try
         {
             return exists(clusterId);
@@ -155,13 +164,35 @@
     @Override
     public void addSession(HttpSession session)
     {
-       if (session == null)
-           return;
+        if (session == null)
+            return;
+
+        //insert into the cache and set an idle expiry on the entry that
+        //is based off the max idle time configured for the session. If the
+        //session is immortal, then there is no idle expiry on the corresponding
+        //session id
+        if (session.getMaxInactiveInterval() == 0)
+            insert (((AbstractSession)session).getClusterId());
+        else
+            insert (((AbstractSession)session).getClusterId(), session.getMaxInactiveInterval() * getIdleExpiryMultiple());
+    }
     
-       //insert into the cache
-       insert (((AbstractSession)session).getClusterId());
+    
+    public void setIdleExpiryMultiple (int multiplier)
+    {
+        if (multiplier <= 1)
+        {
+            LOG.warn("Idle expiry multiple of {} for session ids set to less than minimum. Using value of {} instead.", multiplier, DEFAULT_IDLE_EXPIRY_MULTIPLE);
+        }
+        _idleExpiryMultiple = multiplier;
     }
 
+    public int getIdleExpiryMultiple ()
+    {
+        return _idleExpiryMultiple;
+    }
+    
+    
     /** 
      * Remove a session id from the list of in-use ids.
      * 
@@ -246,16 +277,38 @@
 
     }
 
+    /**
+     * Get the cache.
+     * @return
+     */
     public BasicCache<String,Object> getCache() 
     {
         return _cache;
     }
 
+    /**
+     * Set the cache.
+     * @param cache
+     */
     public void setCache(BasicCache<String,Object> cache) 
     {
         this._cache = cache;
     }
     
+    
+    
+    /**
+     * Do any operation to the session id in the cache to
+     * ensure its idle expiry time moves forward
+     * @param id
+     */
+    public void touch (String id)
+    {
+        exists(id);
+    }
+    
+    
+    
     /**
      * Ask the cluster if a particular id exists.
      * 
@@ -267,10 +320,7 @@
         if (_cache == null)
             throw new IllegalStateException ("No cache");
         
-        Object key =_cache.get(makeKey(id));
-        if (key == null)
-            return false;
-        return true;
+        return _cache.containsKey(makeKey(id));
     }
     
 
@@ -288,6 +338,19 @@
     }
     
     
+    /**
+     * Put a session id into the cluster with an idle expiry.
+     * 
+     * @param id
+     */
+    protected void insert (String id, long idleTimeOutSec)
+    {
+        if (_cache == null)
+            throw new IllegalStateException ("No cache");
+        
+        _cache.putIfAbsent(makeKey(id),id,-1L, TimeUnit.SECONDS, idleTimeOutSec, TimeUnit.SECONDS);
+    }
+   
     
     /**
      * Remove a session id from the cluster.
diff --git a/jetty-infinispan/src/main/java/org/eclipse/jetty/session/infinispan/InfinispanSessionManager.java b/jetty-infinispan/src/main/java/org/eclipse/jetty/session/infinispan/InfinispanSessionManager.java
index 45778f3..6e79a2a 100644
--- a/jetty-infinispan/src/main/java/org/eclipse/jetty/session/infinispan/InfinispanSessionManager.java
+++ b/jetty-infinispan/src/main/java/org/eclipse/jetty/session/infinispan/InfinispanSessionManager.java
@@ -208,102 +208,6 @@
     
     
     /**
-     * SerializableSession
-     *
-     * Helper class that is responsible for de/serialization of the non-serializable session object.
-     */
-    public class SerializableSession implements Serializable
-    {
-        
-        /**
-         * 
-         */
-        private static final long serialVersionUID = -7603529353470249059L;
-        private transient Session _session;
-
-        
-        public SerializableSession ()
-        {
-            
-        }
-        
-        public SerializableSession (Session session)
-        {
-            setSession(session);
-        }
-        
-        /**
-         * Existing session
-         * @param session
-         */
-        public void setSession (Session session)
-        {
-            _session = session;
-        }
-        
-        public Session getSession ()
-        {
-            return _session;
-        }
-   
-        
-        private void writeObject(java.io.ObjectOutputStream out) throws IOException
-        {
-            if (_session == null)
-                throw new IOException ("No session to serialize");
-  
-            out.writeUTF(_session.getClusterId()); //session id
-            out.writeUTF(_session.getContextPath()); //context path
-            out.writeUTF(_session.getVHost()); //first vhost
-
-            out.writeLong(_session.getAccessed());//accessTime
-            out.writeLong(_session.getLastAccessedTime()); //lastAccessTime
-            out.writeLong(_session.getCreationTime()); //time created
-            out.writeLong(_session.getCookieSetTime());//time cookie was set
-            out.writeUTF(_session.getLastNode()); //name of last node managing
-      
-            out.writeLong(_session.getExpiry()); 
-            out.writeLong(_session.getMaxInactiveInterval());
-            out.writeObject(_session.getAttributeMap());
-        }
-        
-        
-        private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException
-        {
-            String clusterId = in.readUTF();
-            String context = in.readUTF();
-            String vhost = in.readUTF();
-            
-            Long accessed = in.readLong();//accessTime
-            Long lastAccessed = in.readLong(); //lastAccessTime
-            Long created = in.readLong(); //time created
-            Long cookieSet = in.readLong();//time cookie was set
-            String lastNode = in.readUTF(); //last managing node
-            Long expiry = in.readLong(); 
-            Long maxIdle = in.readLong();
-            HashMap<String,Object> attributes = (HashMap<String,Object>)in.readObject();
-            Session session = new Session(clusterId, created, accessed, maxIdle);
-            session.setCookieSetTime(cookieSet);
-            session.setLastAccessedTime(lastAccessed);
-            session.setLastNode(lastNode);
-            session.setContextPath(context);
-            session.setVHost(vhost);
-            session.setExpiry(expiry);
-            session.addAttributes(attributes);
-            setSession(session);
-        }
-        
-        
-        private void readObjectNoData() throws ObjectStreamException
-        {
-            setSession(null);
-        }
-
-        
-    }
-    
-    
-    /**
      * Session
      *
      * Representation of a session in local memory.
@@ -338,12 +242,24 @@
         private String _lastNode;
         
         
+        /**
+         * If dirty, session needs to be (re)sent to cluster
+         */
+        protected boolean _dirty=false;
         
+        
+     
 
         /**
          * Any virtual hosts for the context with which this session is associated
          */
         private String _vhost;
+
+        
+        /**
+         * Count of how many threads are active in this session
+         */
+        private AtomicInteger _activeThreads = new AtomicInteger(0);
         
         
         
@@ -361,6 +277,7 @@
             _lastNode = getSessionIdManager().getWorkerName();
            setVHost(InfinispanSessionManager.getVirtualHost(_context));
            setContextPath(InfinispanSessionManager.getContextPath(_context));
+           _activeThreads.incrementAndGet(); //access will not be called on a freshly created session so increment here
         }
         
         
@@ -403,14 +320,18 @@
             {
 
                 long now = System.currentTimeMillis();
+                //lock so that no other thread can call access or complete until the first one has refreshed the session object if necessary
                 _lock.lock();
-
-                //if the first thread, check that the session in memory is not stale, if we're checking for stale sessions
-                if (getStaleIntervalSec() > 0  && (now - getLastSyncTime()) >= (getStaleIntervalSec() * 1000L))
+                //a request thread is entering
+                if (_activeThreads.incrementAndGet() == 1)
                 {
-                    if (LOG.isDebugEnabled())
-                        LOG.debug("Acess session({}) for context {} on worker {} stale session. Reloading.", getId(), getContextPath(), getSessionIdManager().getWorkerName());
-                    refresh();
+                    //if the first thread, check that the session in memory is not stale, if we're checking for stale sessions
+                    if (getStaleIntervalSec() > 0  && (now - getLastSyncTime()) >= (getStaleIntervalSec() * 1000L))
+                    {
+                        if (LOG.isDebugEnabled())
+                            LOG.debug("Acess session({}) for context {} on worker {} stale session. Reloading.", getId(), getContextPath(), getSessionIdManager().getWorkerName());
+                        refresh();
+                    }
                 }
             }
             catch (Exception e)
@@ -441,32 +362,65 @@
         {
             super.complete();
 
+            //lock so that no other thread that might be calling access can proceed until this complete is done
+            _lock.lock();
+
             try
             {
-                //an invalid session will already have been removed from the
-                //local session map and deleted from the cluster. If its valid save
-                //it to the cluster.
-                //TODO consider doing only periodic saves if only the last access
-                //time to the session changes
-                if (isValid())
+                //if this is the last request thread to be in the session
+                if (_activeThreads.decrementAndGet() == 0)
                 {
-                    willPassivate();
                     try
                     {
-                        _lock.lock();
-                        save(this);
+                        //an invalid session will already have been removed from the
+                        //local session map and deleted from the cluster. If its valid save
+                        //it to the cluster.
+                        //TODO consider doing only periodic saves if only the last access
+                        //time to the session changes
+                        if (isValid())
+                        {
+                            //if session still valid && its dirty or stale or never been synced, write it to the cluster
+                            //otherwise, we just keep the updated last access time in memory
+                            if (_dirty || getLastSyncTime() == 0 || isStale(System.currentTimeMillis()))
+                            {
+                                willPassivate();
+                                save(this);
+                                didActivate();
+                            }
+                        }
                     }
+                    catch (Exception e)
+                    {
+                        LOG.warn("Problem saving session({})",getId(), e);
+                    } 
                     finally
                     {
-                        _lock.unlock();
+                        _dirty = false;
                     }
-                    didActivate();
                 }
             }
-            catch (Exception e)
+            finally
             {
-                LOG.warn("Problem saving session({})",getId(), e);
-            } 
+                _lock.unlock();
+            }
+        }
+        
+        /** Test if the session is stale
+         * @param atTime
+         * @return
+         */
+        protected boolean isStale (long atTime)
+        {
+            return (getStaleIntervalSec() > 0) && (atTime - getLastSyncTime() >= (getStaleIntervalSec()*1000L));
+        }
+        
+        
+        /** Test if the session is dirty
+         * @return
+         */
+        protected boolean isDirty ()
+        {
+            return _dirty;
         }
 
         /** 
@@ -480,6 +434,8 @@
             super.timeout();
         }
         
+      
+        
         /**
          * Reload the session from the cluster. If the node that
          * last managed the session from the cluster is ourself,
@@ -561,6 +517,7 @@
         
         public void swapId (String newId, String newNodeId)
         {
+            //TODO probably synchronize rather than use the access/complete lock?
             _lock.lock();
             setClusterId(newId);
             setNodeId(newNodeId);
@@ -574,7 +531,7 @@
             if (value == null && old == null)
                 return; //if same as remove attribute but attribute was already removed, no change
             
-           //TODO _dirty = true;
+           _dirty = true;
         }
         
         
@@ -716,7 +673,8 @@
             if (candidateSession != null)
             {
                 //double check the state of the session in the cache, as the
-                //session may have migrated to another node
+                //session may have migrated to another node. This leaves a window
+                //where the cached session may have been changed by another node
                 Session cachedSession = load(makeKey(candidateId, _context));
                 if (cachedSession == null)
                 {
@@ -752,8 +710,7 @@
     
     
     /**
-     * Set the interval between runs of the scavenger. As this will be a costly
-     * exercise (need to iterate over all cache entries) it should not be run too
+     * Set the interval between runs of the scavenger. It should not be run too
      * often.
      * 
      * 
@@ -951,8 +908,28 @@
     @Override
     protected void shutdownSessions() throws Exception
     {
-        //TODO if implementing period saves, if we might have un-saved changes, 
-        //then we need to write them back to the clustered cache
+        Set<String> keys = new HashSet<String>(_sessions.keySet());
+        for (String key:keys)
+        {
+            Session session = _sessions.remove(key); //take the session out of the session list
+            //If the session is dirty, then write it to the cluster.
+            //If the session is simply stale do NOT write it to the cluster, as some other node
+            //may have started managing that session - this means that the last accessed/expiry time
+            //will not be updated, meaning it may look like it can expire sooner than it should.
+            try
+            {
+                if (session.isDirty())
+                {
+                    if (LOG.isDebugEnabled())
+                        LOG.debug("Saving dirty session {} before exiting ", session.getId());
+                    save(session);
+                }
+            }
+            catch (Exception e)
+            {
+                LOG.warn(e);
+            }
+        }
     }
 
 
@@ -1057,7 +1034,20 @@
         if (LOG.isDebugEnabled()) LOG.debug("Writing session {} to cluster", session.getId());
     
         SerializableSessionData storableSession = new SerializableSessionData(session);
-        _cache.put(makeKey(session, _context), storableSession);
+
+        //Put an idle timeout on the cache entry if the session is not immortal - 
+        //if no requests arrive at any node before this timeout occurs, or no node 
+        //scavenges the session before this timeout occurs, the session will be removed.
+        //NOTE: that no session listeners can be called for this.
+        InfinispanSessionIdManager sessionIdManager = (InfinispanSessionIdManager)getSessionIdManager();
+        if (storableSession.maxInactive > 0)
+            _cache.put(makeKey(session, _context), storableSession, -1, TimeUnit.SECONDS, storableSession.maxInactive*sessionIdManager.getIdleExpiryMultiple(), TimeUnit.SECONDS);
+        else
+            _cache.put(makeKey(session, _context), storableSession);
+        
+        //tickle the session id manager to keep the sessionid entry for this session up-to-date
+        sessionIdManager.touch(session.getClusterId());
+        
         session.setLastSyncTime(System.currentTimeMillis());
     }
     
diff --git a/tests/test-sessions/test-hash-sessions/src/test/java/org/eclipse/jetty/server/session/LightLoadTest.java b/tests/test-sessions/test-hash-sessions/src/test/java/org/eclipse/jetty/server/session/ScatterGunLoadTest.java
similarity index 92%
rename from tests/test-sessions/test-hash-sessions/src/test/java/org/eclipse/jetty/server/session/LightLoadTest.java
rename to tests/test-sessions/test-hash-sessions/src/test/java/org/eclipse/jetty/server/session/ScatterGunLoadTest.java
index acff356..90e428c 100644
--- a/tests/test-sessions/test-hash-sessions/src/test/java/org/eclipse/jetty/server/session/LightLoadTest.java
+++ b/tests/test-sessions/test-hash-sessions/src/test/java/org/eclipse/jetty/server/session/ScatterGunLoadTest.java
@@ -21,9 +21,9 @@
 import org.junit.Test;
 
 /**
- * LightLoadTest
+ * ScatterGunLoadTest
  */
-public class LightLoadTest extends AbstractLightLoadTest
+public class ScatterGunLoadTest extends AbstractScatterGunLoadTest
 {
 
     public AbstractTestServer createServer(int port)
diff --git a/tests/test-sessions/test-infinispan-sessions/src/test/java/org/eclipse/jetty/server/session/InfinispanTestSessionServer.java b/tests/test-sessions/test-infinispan-sessions/src/test/java/org/eclipse/jetty/server/session/InfinispanTestSessionServer.java
index 8d3479c..c6b2122 100644
--- a/tests/test-sessions/test-infinispan-sessions/src/test/java/org/eclipse/jetty/server/session/InfinispanTestSessionServer.java
+++ b/tests/test-sessions/test-infinispan-sessions/src/test/java/org/eclipse/jetty/server/session/InfinispanTestSessionServer.java
@@ -76,14 +76,34 @@
         return new SessionHandler(sessionManager);
     }
 
+    public boolean exists (String id)
+    {
+        BasicCache cache = ((InfinispanSessionIdManager)_sessionIdManager).getCache();
+        if (cache != null)
+        {
+            return cache.containsKey(id);      
+        }
+        
+        return false;
+    }
+    
+    public Object get (String id)
+    {
+        BasicCache cache = ((InfinispanSessionIdManager)_sessionIdManager).getCache();
+        if (cache != null)
+        {
+            return cache.get(id);      
+        }
+        
+        return null;
+    }
 
     public void dumpCache ()
     {
         BasicCache cache = ((InfinispanSessionIdManager)_sessionIdManager).getCache();
         if (cache != null)
         {
-            System.err.println(cache.getName()+" contains "+cache.size()+" entries");
-            
+            System.err.println(cache.getName()+" contains "+cache.size()+" entries");         
         }
     }
 
diff --git a/tests/test-sessions/test-infinispan-sessions/src/test/java/org/eclipse/jetty/server/session/SameNodeLoadTest.java b/tests/test-sessions/test-infinispan-sessions/src/test/java/org/eclipse/jetty/server/session/SameNodeLoadTest.java
new file mode 100644
index 0000000..44a9c17
--- /dev/null
+++ b/tests/test-sessions/test-infinispan-sessions/src/test/java/org/eclipse/jetty/server/session/SameNodeLoadTest.java
@@ -0,0 +1,66 @@
+//
+//  ========================================================================
+//  Copyright (c) 1995-2015 Mort Bay Consulting Pty. Ltd.
+//  ------------------------------------------------------------------------
+//  All rights reserved. This program and the accompanying materials
+//  are made available under the terms of the Eclipse Public License v1.0
+//  and Apache License v2.0 which accompanies this distribution.
+//
+//      The Eclipse Public License is available at
+//      http://www.eclipse.org/legal/epl-v10.html
+//
+//      The Apache License v2.0 is available at
+//      http://www.opensource.org/licenses/apache2.0.php
+//
+//  You may elect to redistribute this code under either of these licenses.
+//  ========================================================================
+//
+
+
+package org.eclipse.jetty.server.session;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+
+/**
+ * SameNodeLoadTest
+ *
+ *
+ */
+public class SameNodeLoadTest extends AbstractSameNodeLoadTest
+{
+
+    public static InfinispanTestSupport __testSupport;
+
+    
+    
+    @BeforeClass
+    public static void setup () throws Exception
+    {
+        __testSupport = new InfinispanTestSupport();
+        __testSupport.setup();
+    }
+    
+    @AfterClass
+    public static void teardown () throws Exception
+    {
+       __testSupport.teardown();
+    }
+    
+    /** 
+     * @see org.eclipse.jetty.server.session.AbstractSameNodeLoadTest#createServer(int)
+     */
+    @Override
+    public AbstractTestServer createServer(int port)
+    {
+        InfinispanTestSessionServer server = new InfinispanTestSessionServer(port, __testSupport.getCache());
+        return server;
+    }
+
+    @Override
+    public void testLoad() throws Exception
+    {
+        super.testLoad();
+    }
+
+}
diff --git a/tests/test-sessions/test-infinispan-sessions/src/test/java/org/eclipse/jetty/server/session/remote/RemoteSameNodeLoadTest.java b/tests/test-sessions/test-infinispan-sessions/src/test/java/org/eclipse/jetty/server/session/remote/RemoteSameNodeLoadTest.java
new file mode 100644
index 0000000..ea98f0f
--- /dev/null
+++ b/tests/test-sessions/test-infinispan-sessions/src/test/java/org/eclipse/jetty/server/session/remote/RemoteSameNodeLoadTest.java
@@ -0,0 +1,69 @@
+//
+//  ========================================================================
+//  Copyright (c) 1995-2015 Mort Bay Consulting Pty. Ltd.
+//  ------------------------------------------------------------------------
+//  All rights reserved. This program and the accompanying materials
+//  are made available under the terms of the Eclipse Public License v1.0
+//  and Apache License v2.0 which accompanies this distribution.
+//
+//      The Eclipse Public License is available at
+//      http://www.eclipse.org/legal/epl-v10.html
+//
+//      The Apache License v2.0 is available at
+//      http://www.opensource.org/licenses/apache2.0.php
+//
+//  You may elect to redistribute this code under either of these licenses.
+//  ========================================================================
+//
+
+
+package org.eclipse.jetty.server.session.remote;
+
+import org.eclipse.jetty.server.session.AbstractSameNodeLoadTest;
+import org.eclipse.jetty.server.session.AbstractTestServer;
+import org.eclipse.jetty.server.session.InfinispanTestSessionServer;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+
+/**
+ * SameNodeLoadTest
+ *
+ *
+ */
+public class RemoteSameNodeLoadTest extends AbstractSameNodeLoadTest
+{
+
+    public static RemoteInfinispanTestSupport __testSupport;
+
+    
+    
+    @BeforeClass
+    public static void setup () throws Exception
+    {
+        __testSupport = new RemoteInfinispanTestSupport("remote-session-test");
+        __testSupport.setup();
+    }
+    
+    @AfterClass
+    public static void teardown () throws Exception
+    {
+       __testSupport.teardown();
+    }
+    
+    /** 
+     * @see org.eclipse.jetty.server.session.AbstractSameNodeLoadTest#createServer(int)
+     */
+    @Override
+    public AbstractTestServer createServer(int port)
+    {
+        InfinispanTestSessionServer server = new InfinispanTestSessionServer(port, __testSupport.getCache());
+        return server;
+    }
+
+    @Override
+    public void testLoad() throws Exception
+    {
+        super.testLoad();
+    }
+
+}
diff --git a/tests/test-sessions/test-mongodb-sessions/src/test/java/org/eclipse/jetty/nosql/mongodb/LightLoadTest.java b/tests/test-sessions/test-mongodb-sessions/src/test/java/org/eclipse/jetty/nosql/mongodb/ScatterGunLoadTest.java
similarity index 88%
rename from tests/test-sessions/test-mongodb-sessions/src/test/java/org/eclipse/jetty/nosql/mongodb/LightLoadTest.java
rename to tests/test-sessions/test-mongodb-sessions/src/test/java/org/eclipse/jetty/nosql/mongodb/ScatterGunLoadTest.java
index 9d241e0..34d7d07 100644
--- a/tests/test-sessions/test-mongodb-sessions/src/test/java/org/eclipse/jetty/nosql/mongodb/LightLoadTest.java
+++ b/tests/test-sessions/test-mongodb-sessions/src/test/java/org/eclipse/jetty/nosql/mongodb/ScatterGunLoadTest.java
@@ -18,15 +18,15 @@
 
 package org.eclipse.jetty.nosql.mongodb;
 
-import org.eclipse.jetty.server.session.AbstractLightLoadTest;
+import org.eclipse.jetty.server.session.AbstractScatterGunLoadTest;
 import org.eclipse.jetty.server.session.AbstractTestServer;
 import org.junit.Ignore;
 import org.junit.Test;
 
 /**
- * LightLoadTest
+ * ScatterGunLoadTest
  */
-public class LightLoadTest extends AbstractLightLoadTest
+public class ScatterGunLoadTest extends AbstractScatterGunLoadTest
 {
 
     public AbstractTestServer createServer(int port)
diff --git a/tests/test-sessions/test-sessions-common/src/main/java/org/eclipse/jetty/server/session/AbstractSameNodeLoadTest.java b/tests/test-sessions/test-sessions-common/src/main/java/org/eclipse/jetty/server/session/AbstractSameNodeLoadTest.java
new file mode 100644
index 0000000..999858f
--- /dev/null
+++ b/tests/test-sessions/test-sessions-common/src/main/java/org/eclipse/jetty/server/session/AbstractSameNodeLoadTest.java
@@ -0,0 +1,231 @@
+//
+//  ========================================================================
+//  Copyright (c) 1995-2015 Mort Bay Consulting Pty. Ltd.
+//  ------------------------------------------------------------------------
+//  All rights reserved. This program and the accompanying materials
+//  are made available under the terms of the Eclipse Public License v1.0
+//  and Apache License v2.0 which accompanies this distribution.
+//
+//      The Eclipse Public License is available at
+//      http://www.eclipse.org/legal/epl-v10.html
+//
+//      The Apache License v2.0 is available at
+//      http://www.opensource.org/licenses/apache2.0.php
+//
+//  You may elect to redistribute this code under either of these licenses.
+//  ========================================================================
+//
+
+package org.eclipse.jetty.server.session;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertNotNull;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.Random;
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpSession;
+
+import org.eclipse.jetty.client.HttpClient;
+import org.eclipse.jetty.client.api.ContentResponse;
+import org.eclipse.jetty.client.api.Request;
+import org.junit.Test;
+
+
+/**
+ * AbstractSameNodeLoadTest
+ * 
+ * This test performs multiple concurrent requests for the same session on the same node.
+ * 
+ */
+public abstract class AbstractSameNodeLoadTest
+{
+    protected boolean _stress = Boolean.getBoolean( "STRESS" );
+
+    public abstract AbstractTestServer createServer(int port);
+
+    @Test
+    public void testLoad() throws Exception
+    {
+        if ( _stress )
+        {
+            String contextPath = "";
+            String servletMapping = "/server";
+            AbstractTestServer server1 = createServer( 0 );
+            server1.addContext( contextPath ).addServlet( TestServlet.class, servletMapping );
+
+            try
+            {
+                server1.start();
+                int port1 = server1.getPort();
+
+                HttpClient client = new HttpClient();
+                client.start();
+                try
+                {
+                    String url = "http://localhost:" + port1 + contextPath + servletMapping;
+
+
+                    //create session via first server
+                    ContentResponse response1 = client.GET(url + "?action=init");
+                    assertEquals(HttpServletResponse.SC_OK,response1.getStatus());
+                    String sessionCookie = response1.getHeaders().getStringField( "Set-Cookie" );
+                    assertTrue(sessionCookie != null);
+                    // Mangle the cookie, replacing Path with $Path, etc.
+                    sessionCookie = sessionCookie.replaceFirst("(\\W)(P|p)ath=", "$1\\$Path=");
+
+                    //simulate 10 clients making 100 requests each
+                    ExecutorService executor = Executors.newCachedThreadPool();
+                    int clientsCount = 10;
+                    CyclicBarrier barrier = new CyclicBarrier( clientsCount + 1 );
+                    int requestsCount = 100;
+                    Worker[] workers = new Worker[clientsCount];
+                    for ( int i = 0; i < clientsCount; ++i )
+                    {
+                        workers[i] = new Worker(barrier, client, requestsCount, sessionCookie, url);
+                        executor.execute( workers[i] );
+                    }
+                    // Wait for all workers to be ready
+                    barrier.await();
+                    long start = System.nanoTime();
+
+                    // Wait for all workers to be done
+                    barrier.await();
+                    long end = System.nanoTime();
+                    long elapsed = TimeUnit.NANOSECONDS.toMillis( end - start );
+                    System.out.println( "elapsed ms: " + elapsed );
+
+                    executor.shutdownNow();
+
+                    // Perform one request to get the result
+                    Request request = client.newRequest( url + "?action=result" );
+                    request.header("Cookie", sessionCookie);
+                    ContentResponse response2 = request.send();
+                    assertEquals(HttpServletResponse.SC_OK,response2.getStatus());
+                    String response = response2.getContentAsString();
+                    System.out.println( "get = " + response );
+                    assertEquals(response.trim(), String.valueOf( clientsCount * requestsCount ) );
+                }
+                finally
+                {
+                    client.stop();
+                }
+            }
+            finally
+            {
+                server1.stop();
+            }
+        }
+    }
+
+    public static class Worker implements Runnable
+    {
+        public static int COUNT = 0;
+        
+        private final HttpClient client;
+
+        private final CyclicBarrier barrier;
+
+        private final int requestsCount;
+
+        private final String sessionCookie;
+
+        private final String url;
+        
+        private final String name;
+
+
+        public Worker(CyclicBarrier barrier, HttpClient client, int requestsCount, String sessionCookie, String url)
+        {
+            this.client = client;
+            this.barrier = barrier;
+            this.requestsCount = requestsCount;
+            this.sessionCookie = sessionCookie;
+            this.url = url;
+            this.name = ""+(COUNT++);
+        }
+
+
+        public void run()
+        {
+            try
+            {
+                // Wait for all workers to be ready
+                barrier.await();
+
+                Random random = new Random( System.nanoTime() );
+
+                for ( int i = 0; i < requestsCount; ++i )
+                {
+                    int pauseMsec = random.nextInt(1000);
+
+                    //wait a random number of milliseconds between requests up to 1 second
+                    if (pauseMsec > 0)
+                    {
+                        Thread.currentThread().sleep(pauseMsec);
+                    }
+                    Request request = client.newRequest(url + "?action=increment");
+                    request.header("Cookie", sessionCookie);
+                    ContentResponse response = request.send();
+                    assertEquals(HttpServletResponse.SC_OK,response.getStatus());
+                }
+
+                // Wait for all workers to be done
+                barrier.await();
+            }
+            catch ( Exception x )
+            {
+                throw new RuntimeException( x );
+            }
+        }
+    }
+
+    public static class TestServlet
+        extends HttpServlet
+    {
+        @Override
+        protected void doGet( HttpServletRequest request, HttpServletResponse response )
+            throws ServletException, IOException
+        {
+            String action = request.getParameter( "action" );
+            if ( "init".equals( action ) )
+            {
+                HttpSession session = request.getSession( true );
+                session.setAttribute( "value", 0 );
+            }
+            else if ( "increment".equals( action ) )
+            {
+                HttpSession session = request.getSession( false );
+                assertNotNull(session);
+                synchronized(session)
+                {
+                    int value = (Integer) session.getAttribute( "value" );
+                    session.setAttribute( "value", value + 1 );
+                }
+            }
+            else if ( "result".equals( action ) )
+            {
+                HttpSession session = request.getSession( false );
+                assertNotNull(session);
+                Integer value = null;
+                synchronized (session)
+                {
+                    value = (Integer) session.getAttribute( "value" );
+                }
+                PrintWriter writer = response.getWriter();
+                writer.println( value );
+                writer.flush();
+            }
+        }
+    }
+}
diff --git a/tests/test-sessions/test-sessions-common/src/main/java/org/eclipse/jetty/server/session/AbstractLightLoadTest.java b/tests/test-sessions/test-sessions-common/src/main/java/org/eclipse/jetty/server/session/AbstractScatterGunLoadTest.java
similarity index 98%
rename from tests/test-sessions/test-sessions-common/src/main/java/org/eclipse/jetty/server/session/AbstractLightLoadTest.java
rename to tests/test-sessions/test-sessions-common/src/main/java/org/eclipse/jetty/server/session/AbstractScatterGunLoadTest.java
index d9b798b..ed24b60 100644
--- a/tests/test-sessions/test-sessions-common/src/main/java/org/eclipse/jetty/server/session/AbstractLightLoadTest.java
+++ b/tests/test-sessions/test-sessions-common/src/main/java/org/eclipse/jetty/server/session/AbstractScatterGunLoadTest.java
@@ -42,7 +42,7 @@
 
 
 /**
- * AbstractLightLoadTest
+ * AbstractScatterGunLoadTest
  * 
  * This is an unrealistic test. It takes a scatter-gun approach to smearing a
  * single session across 2 different nodes at once. 
@@ -50,7 +50,7 @@
  * In the real world, we must have a load balancer that uses sticky sessions
  * to keep the session pinned to a particular node.
  */
-public abstract class AbstractLightLoadTest
+public abstract class AbstractScatterGunLoadTest
 {
     protected boolean _stress = Boolean.getBoolean( "STRESS" );
 
diff --git a/tests/test-sessions/test-sessions-common/src/main/java/org/eclipse/jetty/server/session/AbstractStopSessionManagerPreserveSessionTest.java b/tests/test-sessions/test-sessions-common/src/main/java/org/eclipse/jetty/server/session/AbstractStopSessionManagerPreserveSessionTest.java
index de4c44d..b67f4d7 100644
--- a/tests/test-sessions/test-sessions-common/src/main/java/org/eclipse/jetty/server/session/AbstractStopSessionManagerPreserveSessionTest.java
+++ b/tests/test-sessions/test-sessions-common/src/main/java/org/eclipse/jetty/server/session/AbstractStopSessionManagerPreserveSessionTest.java
@@ -36,6 +36,11 @@
 import org.eclipse.jetty.servlet.ServletHolder;
 import org.junit.Test;
 
+/**
+ * AbstractStopSessionManagerPreserveSessionTest
+ *
+ *
+ */
 public abstract class AbstractStopSessionManagerPreserveSessionTest
 {
     public String _id;