//
   //  ========================================================================
   //  Copyright (c) 1995-2014 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 java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.InputStream;
  import java.io.ObjectOutputStream;
  import java.sql.Connection;
  import java.sql.PreparedStatement;
  import java.sql.ResultSet;
  import java.sql.SQLException;
  import java.util.ArrayList;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Set;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.TimeUnit;
  import java.util.concurrent.atomic.AtomicReference;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpSessionEvent;
  import javax.servlet.http.HttpSessionListener;
  
  import org.eclipse.jetty.server.SessionIdManager;
  import org.eclipse.jetty.server.handler.ContextHandler;
  import org.eclipse.jetty.server.session.JDBCSessionIdManager.SessionTableSchema;
  import org.eclipse.jetty.util.ClassLoadingObjectInputStream;
  import org.eclipse.jetty.util.log.Log;
  import org.eclipse.jetty.util.log.Logger;
  
  /**
   * JDBCSessionManager
   *
   * SessionManager that persists sessions to a database to enable clustering.
   *
   * Session data is persisted to the JettySessions table:
   *
   * rowId (unique in cluster: webapp name/path + virtualhost + sessionId)
   * contextPath (of the context owning the session)
   * sessionId (unique in a context)
   * lastNode (name of node last handled session)
   * accessTime (time in milliseconds session was accessed)
   * lastAccessTime (previous time in milliseconds session was accessed)
   * createTime (time in milliseconds session created)
   * cookieTime (time in milliseconds session cookie created)
   * lastSavedTime (last time in milliseconds session access times were saved)
   * expiryTime (time in milliseconds that the session is due to expire)
   * map (attribute map)
   *
   * As an optimization, to prevent thrashing the database, we do not persist
   * the accessTime and lastAccessTime every time the session is accessed. Rather,
   * we write it out every so often. The frequency is controlled by the saveIntervalSec
   * field.
   */
  public class JDBCSessionManager extends AbstractSessionManager
  {
      private static final Logger LOG = Log.getLogger(JDBCSessionManager.class);
  
      private ConcurrentHashMap<String, Session> _sessions;
      protected JDBCSessionIdManager _jdbcSessionIdMgr = null;
      protected long _saveIntervalSec = 60; //only persist changes to session access times every 60 secs
      protected SessionTableSchema _sessionTableSchema;
  
     
  
  
      /**
       * Session
       *
       * Session instance.
       */
      public class Session extends AbstractSession
      {
          private static final long serialVersionUID = 5208464051134226143L;
          
          /**
           * If dirty, session needs to be (re)persisted
           */
          protected boolean _dirty=false;
          
         
         /**
          * Time in msec since the epoch that a session cookie was set for this session
          */
         protected long _cookieSet;
         
         
         /**
          * Time in msec since the epoch that the session will expire
          */
         protected long _expiryTime;
         
         
         /**
          * Time in msec since the epoch that the session was last persisted
          */
         protected long _lastSaved;
         
         
         /**
          * Unique identifier of the last node to host the session
          */
         protected String _lastNode;
         
         
         /**
          * Virtual host for context (used to help distinguish 2 sessions with same id on different contexts)
          */
         protected String _virtualHost;
         
         
         /**
          * Unique row in db for session
          */
         protected String _rowId;
         
         
         /**
          * Mangled context name (used to help distinguish 2 sessions with same id on different contexts)
          */
         protected String _canonicalContext;
         
    
         /**
          * Session from a request.
          *
          * @param request
          */
         protected Session (HttpServletRequest request)
         {
             super(JDBCSessionManager.this,request);
             int maxInterval=getMaxInactiveInterval();
             _expiryTime = (maxInterval <= 0 ? 0 : (System.currentTimeMillis() + maxInterval*1000L));
             _virtualHost = JDBCSessionManager.getVirtualHost(_context);
             _canonicalContext = canonicalize(_context.getContextPath());
             _lastNode = getSessionIdManager().getWorkerName();
         }
         
         
         /**
          * Session restored from database
          * @param sessionId
          * @param rowId
          * @param created
          * @param accessed
          */
         protected Session (String sessionId, String rowId, long created, long accessed, long maxInterval)
         {
             super(JDBCSessionManager.this, created, accessed, sessionId);
             _rowId = rowId;
             super.setMaxInactiveInterval((int)maxInterval); //restore the session's previous inactivity interval setting
             _expiryTime = (maxInterval <= 0 ? 0 : (System.currentTimeMillis() + maxInterval*1000L));
         }
         
         
         protected synchronized String getRowId()
         {
             return _rowId;
         }
         
         protected synchronized void setRowId(String rowId)
         {
             _rowId = rowId;
         }
         
         public synchronized void setVirtualHost (String vhost)
         {
             _virtualHost=vhost;
         }
 
         public synchronized String getVirtualHost ()
         {
             return _virtualHost;
         }
         
         public synchronized long getLastSaved ()
         {
             return _lastSaved;
         }
 
         public synchronized void setLastSaved (long time)
         {
             _lastSaved=time;
         }
 
         public synchronized void setExpiryTime (long time)
         {
             _expiryTime=time;
         }
 
         public synchronized long getExpiryTime ()
         {
             return _expiryTime;
         }
         
 
         public synchronized void setCanonicalContext(String str)
         {
             _canonicalContext=str;
         }
 
         public synchronized String getCanonicalContext ()
         {
             return _canonicalContext;
         }
         
         public void setCookieSet (long ms)
         {
             _cookieSet = ms;
         }
 
         public synchronized long getCookieSet ()
         {
             return _cookieSet;
         }
 
         public synchronized void setLastNode (String node)
         {
             _lastNode=node;
         }
 
         public synchronized String getLastNode ()
         {
             return _lastNode;
         }
 
         @Override
         public void setAttribute (String name, Object value)
         {
             updateAttribute(name, value);
             _dirty = true;
         }
 
         @Override
         public void removeAttribute (String name)
         {
             super.removeAttribute(name);
             _dirty=true;
         }
 
         @Override
         protected void cookieSet()
         {
             _cookieSet = getAccessed();
         }
 
         /**
          * Entry to session.
          * Called by SessionHandler on inbound request and the session already exists in this node's memory.
          *
          * @see org.eclipse.jetty.server.session.AbstractSession#access(long)
          */
         @Override
         protected boolean access(long time)
         {
             synchronized (this)
             {
                 if (super.access(time))
                 {
                     int maxInterval=getMaxInactiveInterval();
                     _expiryTime = (maxInterval <= 0 ? 0 : (time + maxInterval*1000L));
                     return true;
                 }
                 return false;
             }
         }
         
         
         
 
 
         /** 
          * Change the max idle time for this session. This recalculates the expiry time.
          * @see org.eclipse.jetty.server.session.AbstractSession#setMaxInactiveInterval(int)
          */
         @Override
         public void setMaxInactiveInterval(int secs)
         {
             synchronized (this)
             {
                 super.setMaxInactiveInterval(secs);
                 int maxInterval=getMaxInactiveInterval();
                 _expiryTime = (maxInterval <= 0 ? 0 : (System.currentTimeMillis() + maxInterval*1000L));
                 //force the session to be written out right now
                 try
                 {
                     updateSessionAccessTime(this);
                 }
                 catch (Exception e)
                 {
                     LOG.warn("Problem saving changed max idle time for session "+ this, e);
                 }
             }
         }
 
 
         /**
          * Exit from session
          * @see org.eclipse.jetty.server.session.AbstractSession#complete()
          */
         @Override
         protected void complete()
         {
             synchronized (this)
             {
                 super.complete();
                 try
                 {
                     if (isValid())
                     {
                         if (_dirty)
                         {
                             //The session attributes have changed, write to the db, ensuring
                             //http passivation/activation listeners called
                             save(true);
                         }
                         else if ((getAccessed() - _lastSaved) >= (getSaveInterval() * 1000L))
                         {
                             updateSessionAccessTime(this);
                         }
                     }
                 }
                 catch (Exception e)
                 {
                     LOG.warn("Problem persisting changed session data id="+getId(), e);
                 }
                 finally
                 {
                     _dirty=false;
                 }
             }
         }
 
         protected void save() throws Exception
         {
             synchronized (this)
             {
                 try
                 {
                     updateSession(this);
                 }
                 finally
                 {
                     _dirty = false;
                 }
             }
         }
 
         protected void save (boolean reactivate) throws Exception
         {
             synchronized (this)
             {
                 if (_dirty)
                 {
                     //The session attributes have changed, write to the db, ensuring
                     //http passivation/activation listeners called
                     willPassivate();                      
                     updateSession(this);
                     if (reactivate)
                         didActivate();  
                 }
             }
         }
 
         
         @Override
         protected void timeout() throws IllegalStateException
         {
             if (LOG.isDebugEnabled())
                 LOG.debug("Timing out session id="+getClusterId());
             super.timeout();
         }
         
         
         @Override
         public String toString ()
         {
             return "Session rowId="+_rowId+",id="+getId()+",lastNode="+_lastNode+
                             ",created="+getCreationTime()+",accessed="+getAccessed()+
                             ",lastAccessed="+getLastAccessedTime()+",cookieSet="+_cookieSet+
                             ",maxInterval="+getMaxInactiveInterval()+",lastSaved="+_lastSaved+",expiry="+_expiryTime;
         }
     }
 
 
 
 
     /**
      * Set the time in seconds which is the interval between
      * saving the session access time to the database.
      *
      * This is an optimization that prevents the database from
      * being overloaded when a session is accessed very frequently.
      *
      * On session exit, if the session attributes have NOT changed,
      * the time at which we last saved the accessed
      * time is compared to the current accessed time. If the interval
      * is at least saveIntervalSecs, then the access time will be
      * persisted to the database.
      *
      * If any session attribute does change, then the attributes and
      * the accessed time are persisted.
      *
      * @param sec
      */
     public void setSaveInterval (long sec)
     {
         _saveIntervalSec=sec;
     }
 
     public long getSaveInterval ()
     {
         return _saveIntervalSec;
     }
 
 
 
     /**
      * A method that can be implemented in subclasses to support
      * distributed caching of sessions. This method will be
      * called whenever the session is written to the database
      * because the session data has changed.
      *
      * This could be used eg with a JMS backplane to notify nodes
      * that the session has changed and to delete the session from
      * the node's cache, and re-read it from the database.
      * @param session
      */
     public void cacheInvalidate (Session session)
     {
 
     }
 
 
     /**
      * A session has been requested by its id on this node.
      *
      * Load the session by id AND context path from the database.
      * Multiple contexts may share the same session id (due to dispatching)
      * but they CANNOT share the same contents.
      *
      * Check if last node id is my node id, if so, then the session we have
      * in memory cannot be stale. If another node used the session last, then
      * we need to refresh from the db.
      *
      * NOTE: this method will go to the database, so if you only want to check
      * for the existence of a Session in memory, use _sessions.get(id) instead.
      *
      * @see org.eclipse.jetty.server.session.AbstractSessionManager#getSession(java.lang.String)
      */
     @Override
     public Session getSession(String idInCluster)
     {
         Session session = null;
         
         synchronized (this)
         {
             Session memSession = (Session)_sessions.get(idInCluster);
             
             //check if we need to reload the session -
             //as an optimization, don't reload on every access
             //to reduce the load on the database. This introduces a window of
             //possibility that the node may decide that the session is local to it,
             //when the session has actually been live on another node, and then
             //re-migrated to this node. This should be an extremely rare occurrence,
             //as load-balancers are generally well-behaved and consistently send
             //sessions to the same node, changing only iff that node fails.
             //Session data = null;
             long now = System.currentTimeMillis();
             if (LOG.isDebugEnabled())
             {
                 if (memSession==null)
                     LOG.debug("getSession("+idInCluster+"): not in session map,"+
                             " now="+now+
                             " lastSaved="+(memSession==null?0:memSession._lastSaved)+
                             " interval="+(_saveIntervalSec * 1000L));
                 else
                     LOG.debug("getSession("+idInCluster+"): in session map, "+
                             " hashcode="+memSession.hashCode()+
                             " now="+now+
                             " lastSaved="+(memSession==null?0:memSession._lastSaved)+
                             " interval="+(_saveIntervalSec * 1000L)+
                             " lastNode="+memSession._lastNode+
                             " thisNode="+getSessionIdManager().getWorkerName()+
                             " difference="+(now - memSession._lastSaved));
             }
 
             try
             {
                 if (memSession==null)
                 {
                     LOG.debug("getSession("+idInCluster+"): no session in session map. Reloading session data from db.");
                     session = loadSession(idInCluster, canonicalize(_context.getContextPath()), getVirtualHost(_context));
                 }
                 else if ((now - memSession._lastSaved) >= (_saveIntervalSec * 1000L))
                 {
                     LOG.debug("getSession("+idInCluster+"): stale session. Reloading session data from db.");
                     session = loadSession(idInCluster, canonicalize(_context.getContextPath()), getVirtualHost(_context));
                 }
                 else
                 {
                     LOG.debug("getSession("+idInCluster+"): session in session map");
                     session = memSession;
                 }
             }
             catch (Exception e)
             {
                 LOG.warn("Unable to load session "+idInCluster, e);
                 return null;
             }
 
 
             //If we have a session
             if (session != null)
             {
                 //If the session was last used on a different node, or session doesn't exist on this node
                 if (!session.getLastNode().equals(getSessionIdManager().getWorkerName()) || memSession==null)
                 {
                     //if session doesn't expire, or has not already expired, update it and put it in this nodes' memory
                     if (session._expiryTime <= 0 || session._expiryTime > now)
                     {
                         if (LOG.isDebugEnabled()) 
                             LOG.debug("getSession("+idInCluster+"): lastNode="+session.getLastNode()+" thisNode="+getSessionIdManager().getWorkerName());
 
                         session.setLastNode(getSessionIdManager().getWorkerName());                            
                         _sessions.put(idInCluster, session);
 
                         //update in db
                         try
                         {
                             updateSessionNode(session);
                             session.didActivate();
                         }
                         catch (Exception e)
                         {
                             LOG.warn("Unable to update freshly loaded session "+idInCluster, e);
                             return null;
                         }
                     }
                     else
                     {
                         LOG.debug("getSession ({}): Session has expired", idInCluster);  
                         //ensure that the session id for the expired session is deleted so that a new session with the 
                         //same id cannot be created (because the idInUse() test would succeed)
                         _jdbcSessionIdMgr.removeSession(idInCluster);
                         session=null;
                     }
 
                 }
                 else
                 {
                     //the session loaded from the db and the one in memory are the same, so keep using the one in memory
                     session = memSession;
                     LOG.debug("getSession({}): Session not stale {}", idInCluster,session);
                 }
             }
             else
             {
                 //No session in db with matching id and context path.
                 LOG.debug("getSession({}): No session in database matching id={}",idInCluster,idInCluster);
             }
 
             return session;
         }
     }
     
 
     /**
      * Get the number of sessions.
      *
      * @see org.eclipse.jetty.server.session.AbstractSessionManager#getSessions()
      */
     @Override
     public int getSessions()
     {
         return _sessions.size();
     }
 
 
     /**
      * Start the session manager.
      *
      * @see org.eclipse.jetty.server.session.AbstractSessionManager#doStart()
      */
     @Override
     public void doStart() throws Exception
     {
         if (_sessionIdManager==null)
             throw new IllegalStateException("No session id manager defined");
 
         _jdbcSessionIdMgr = (JDBCSessionIdManager)_sessionIdManager;
         _sessionTableSchema = _jdbcSessionIdMgr.getSessionTableSchema();
 
         _sessions = new ConcurrentHashMap<String, Session>();
 
         super.doStart();
     }
 
 
     /**
      * Stop the session manager.
      *
      * @see org.eclipse.jetty.server.session.AbstractSessionManager#doStop()
      */
     @Override
     public void doStop() throws Exception
     {
         super.doStop();
         _sessions.clear();
         _sessions = null;
     }
 
     @Override
     protected void shutdownSessions()
     {
         //Save the current state of all of our sessions,
         //do NOT delete them (so other nodes can manage them)
         long gracefulStopMs = getContextHandler().getServer().getStopTimeout();
         long stopTime = 0;
         if (gracefulStopMs > 0)
             stopTime = System.nanoTime() + (TimeUnit.NANOSECONDS.convert(gracefulStopMs, TimeUnit.MILLISECONDS));        
 
         ArrayList<Session> sessions = (_sessions == null? new ArrayList<Session>() :new ArrayList<Session>(_sessions.values()) );
 
         // loop while there are sessions, and while there is stop time remaining, or if no stop time, just 1 loop
         while (sessions.size() > 0 && ((stopTime > 0 && (System.nanoTime() < stopTime)) || (stopTime == 0)))
         {
             for (Session session : sessions)
             {
                 try
                 {
                     session.save(false);
                 }
                 catch (Exception e)
                 {
                     LOG.warn(e);
                 }
                 _sessions.remove(session.getClusterId());
             }
 
             //check if we should terminate our loop if we're not using the stop timer
             if (stopTime == 0)
                 break;
             
             // Get any sessions that were added by other requests during processing and go around the loop again
             sessions=new ArrayList<Session>(_sessions.values());
         }
     }
 
     
     /**
      * 
      * @see org.eclipse.jetty.server.SessionManager#renewSessionId(java.lang.String, java.lang.String, java.lang.String, java.lang.String)
      */
     public void renewSessionId (String oldClusterId, String oldNodeId, String newClusterId, String newNodeId)
     {
         Session session = null;
         try
         {
             session = (Session)_sessions.remove(oldClusterId);
             if (session != null)
             {
                 synchronized (session)
                 {
                     session.setClusterId(newClusterId); //update ids
                     session.setNodeId(newNodeId);
                     _sessions.put(newClusterId, session); //put it into list in memory
                     updateSession(session); //update database
                 }
             }
         }
         catch (Exception e)
         {
             LOG.warn(e);
         }
 
         super.renewSessionId(oldClusterId, oldNodeId, newClusterId, newNodeId);
     }
 
     
 
     /**
      * Invalidate a session.
      *
      * @param idInCluster
      */
     protected void invalidateSession (String idInCluster)
     {
         Session session = (Session)_sessions.get(idInCluster);
 
         if (session != null)
         {
             session.invalidate();
         }
     }
 
     /**
      * Delete an existing session, both from the in-memory map and
      * the database.
      *
      * @see org.eclipse.jetty.server.session.AbstractSessionManager#removeSession(java.lang.String)
      */
     @Override
     protected boolean removeSession(String idInCluster)
     {
         Session session = (Session)_sessions.remove(idInCluster);
         try
         {
             if (session != null)
                 deleteSession(session);
         }
         catch (Exception e)
         {
             LOG.warn("Problem deleting session id="+idInCluster, e);
         }
         return session!=null;
     }
 
 
     /**
      * Add a newly created session to our in-memory list for this node and persist it.
      *
      * @see org.eclipse.jetty.server.session.AbstractSessionManager#addSession(org.eclipse.jetty.server.session.AbstractSession)
      */
     @Override
     protected void addSession(AbstractSession session)
     {
         if (session==null)
             return;
 
         _sessions.put(session.getClusterId(), (Session)session);
 
         try
         {
             synchronized (session)
             {
                 session.willPassivate();
                 storeSession(((JDBCSessionManager.Session)session));
                 session.didActivate();
             }
         }
         catch (Exception e)
         {
             LOG.warn("Unable to store new session id="+session.getId() , e);
         }
     }
 
 
     /**
      * Make a new Session.
      *
      * @see org.eclipse.jetty.server.session.AbstractSessionManager#newSession(javax.servlet.http.HttpServletRequest)
      */
     @Override
     protected AbstractSession newSession(HttpServletRequest request)
     {
         return new Session(request);
     }
     
     
     /**
      * @param sessionId
      * @param rowId
      * @param created
      * @param accessed
      * @param maxInterval
      * @return
      */
     protected AbstractSession newSession (String sessionId, String rowId, long created, long accessed, long maxInterval)
     {
         return new Session(sessionId, rowId, created, accessed, maxInterval);
     }
 
     /* ------------------------------------------------------------ */
     /** Remove session from manager
      * @param session The session to remove
      * @param invalidate True if {@link HttpSessionListener#sessionDestroyed(HttpSessionEvent)} and
      * {@link SessionIdManager#invalidateAll(String)} should be called.
      */
     @Override
     public boolean removeSession(AbstractSession session, boolean invalidate)
     {
         // Remove session from context and global maps
         boolean removed = super.removeSession(session, invalidate);
 
         if (removed)
         {
             if (!invalidate)
             {
                 session.willPassivate();
             }
         }
         
         return removed;
     }
 
 
     /**
      * Expire any Sessions we have in memory matching the list of
      * expired Session ids.
      *
      * @param sessionIds
      */
     protected Set<String> expire (Set<String> sessionIds)
     {
         //don't attempt to scavenge if we are shutting down
         if (isStopping() || isStopped())
             return null;
 
         
         Thread thread=Thread.currentThread();
         ClassLoader old_loader=thread.getContextClassLoader();
         
         Set<String> successfullyExpiredIds = new HashSet<String>();
         try
         {
             Iterator<?> itor = sessionIds.iterator();
             while (itor.hasNext())
             {
                 String sessionId = (String)itor.next();
                 if (LOG.isDebugEnabled())
                     LOG.debug("Expiring session id "+sessionId);
 
                 Session session = (Session)_sessions.get(sessionId);
 
                 //if session is not in our memory, then fetch from db so we can call the usual listeners on it
                 if (session == null)
                 {
                     if (LOG.isDebugEnabled())LOG.debug("Force loading session id "+sessionId);
                     session = loadSession(sessionId, canonicalize(_context.getContextPath()), getVirtualHost(_context));
                     if (session != null)
                     {
                         //loaded an expired session last managed on this node for this context, add it to the list so we can 
                         //treat it like a normal expired session
                         _sessions.put(session.getClusterId(), session);
                     }
                     else
                     {
                         if (LOG.isDebugEnabled())
                             LOG.debug("Unrecognized session id="+sessionId);
                         continue;
                     }
                 }
 
                 if (session != null)
                 {
                     session.timeout();
                     successfullyExpiredIds.add(session.getClusterId());
                 }
             }
             return successfullyExpiredIds;
         }
         catch (Throwable t)
         {
             LOG.warn("Problem expiring sessions", t);
             return successfullyExpiredIds;
         }
         finally
         {
             thread.setContextClassLoader(old_loader);
         }
     }
     
   
     /**
      * Load a session from the database
      * @param id
      * @return the session data that was loaded
      * @throws Exception
      */
     protected Session loadSession (final String id, final String canonicalContextPath, final String vhost)
     throws Exception
     {
         final AtomicReference<Session> _reference = new AtomicReference<Session>();
         final AtomicReference<Exception> _exception = new AtomicReference<Exception>();
         Runnable load = new Runnable()
         {
             /** 
              * @see java.lang.Runnable#run()
              */
             @SuppressWarnings("unchecked")
             public void run()
             {
                 try (Connection connection = getConnection();
                         PreparedStatement statement = _sessionTableSchema.getLoadStatement(connection, id, canonicalContextPath, vhost);
                         ResultSet result = statement.executeQuery())
                 {
                     Session session = null;
                     if (result.next())
                     {                    
                         long maxInterval = result.getLong(_sessionTableSchema.getMaxIntervalColumn());
                         if (maxInterval == JDBCSessionIdManager.MAX_INTERVAL_NOT_SET)
                         {
                             maxInterval = getMaxInactiveInterval(); //if value not saved for maxInactiveInterval, use current value from sessionmanager
                         }
                         session = (Session)newSession(id, result.getString(_sessionTableSchema.getRowIdColumn()), 
                                                   result.getLong(_sessionTableSchema.getCreateTimeColumn()), 
                                                   result.getLong(_sessionTableSchema.getAccessTimeColumn()), 
                                                   maxInterval);
                         session.setCookieSet(result.getLong(_sessionTableSchema.getCookieTimeColumn()));
                         session.setLastAccessedTime(result.getLong(_sessionTableSchema.getLastAccessTimeColumn()));
                         session.setLastNode(result.getString(_sessionTableSchema.getLastNodeColumn()));
                         session.setLastSaved(result.getLong(_sessionTableSchema.getLastSavedTimeColumn()));
                         session.setExpiryTime(result.getLong(_sessionTableSchema.getExpiryTimeColumn()));
                         session.setCanonicalContext(result.getString(_sessionTableSchema.getContextPathColumn()));
                         session.setVirtualHost(result.getString(_sessionTableSchema.getVirtualHostColumn()));
                                            
                         try (InputStream is = ((JDBCSessionIdManager)getSessionIdManager())._dbAdaptor.getBlobInputStream(result, _sessionTableSchema.getMapColumn());
                                 ClassLoadingObjectInputStream ois = new ClassLoadingObjectInputStream(is))
                         {
                             Object o = ois.readObject();
                             session.addAttributes((Map<String,Object>)o);
                         }
 
                         if (LOG.isDebugEnabled())
                             LOG.debug("LOADED session "+session);
                     }
                     else
                         if (LOG.isDebugEnabled())
                             LOG.debug("Failed to load session "+id);
                     _reference.set(session);
                 }
                 catch (Exception e)
                 {
                     _exception.set(e);
                 }
             }
         };
 
         if (_context==null)
             load.run();
         else
             _context.getContextHandler().handle(load);
 
         if (_exception.get()!=null)
         {
             //if the session could not be restored, take its id out of the pool of currently-in-use
             //session ids
             _jdbcSessionIdMgr.removeSession(id);
             throw _exception.get();
         }
 
         return _reference.get();
     }
 
     /**
      * Insert a session into the database.
      *
      * @param session
      * @throws Exception
      */
     protected void storeSession (Session session)
     throws Exception
     {
         if (session==null)
             return;
 
         //put into the database
         try (Connection connection = getConnection();
                 PreparedStatement statement = connection.prepareStatement(_jdbcSessionIdMgr._insertSession))
         {
             String rowId = calculateRowId(session);
 
             long now = System.currentTimeMillis();
             connection.setAutoCommit(true);
             statement.setString(1, rowId); //rowId
             statement.setString(2, session.getClusterId()); //session id
             statement.setString(3, session.getCanonicalContext()); //context path
             statement.setString(4, session.getVirtualHost()); //first vhost
             statement.setString(5, getSessionIdManager().getWorkerName());//my node id
             statement.setLong(6, session.getAccessed());//accessTime
             statement.setLong(7, session.getLastAccessedTime()); //lastAccessTime
             statement.setLong(8, session.getCreationTime()); //time created
             statement.setLong(9, session.getCookieSet());//time cookie was set
             statement.setLong(10, now); //last saved time
             statement.setLong(11, session.getExpiryTime());
             statement.setLong(12, session.getMaxInactiveInterval());
 
             ByteArrayOutputStream baos = new ByteArrayOutputStream();
             ObjectOutputStream oos = new ObjectOutputStream(baos);
             oos.writeObject(session.getAttributeMap());
             oos.flush();
             byte[] bytes = baos.toByteArray();
 
             ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
             statement.setBinaryStream(13, bais, bytes.length);//attribute map as blob
            
 
             statement.executeUpdate();
             session.setRowId(rowId); //set it on the in-memory data as well as in db
             session.setLastSaved(now);
         }
         if (LOG.isDebugEnabled())
             LOG.debug("Stored session "+session);
     }
 
 
     /**
      * Update data on an existing persisted session.
      *
      * @param data the session
      * @throws Exception
      */
     protected void updateSession (Session data)
     throws Exception
     {
         if (data==null)
             return;
 
         try (Connection connection = getConnection();
                 PreparedStatement statement = connection.prepareStatement(_jdbcSessionIdMgr._updateSession))
         {
             long now = System.currentTimeMillis();
             connection.setAutoCommit(true);
             statement.setString(1, data.getClusterId());
             statement.setString(2, getSessionIdManager().getWorkerName());//my node id
             statement.setLong(3, data.getAccessed());//accessTime
             statement.setLong(4, data.getLastAccessedTime()); //lastAccessTime
             statement.setLong(5, now); //last saved time
             statement.setLong(6, data.getExpiryTime());
             statement.setLong(7, data.getMaxInactiveInterval());
 
             ByteArrayOutputStream baos = new ByteArrayOutputStream();
             ObjectOutputStream oos = new ObjectOutputStream(baos);
             oos.writeObject(data.getAttributeMap());
             oos.flush();
             byte[] bytes = baos.toByteArray();
             ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
 
             statement.setBinaryStream(8, bais, bytes.length);//attribute map as blob
             statement.setString(9, data.getRowId()); //rowId
             statement.executeUpdate();
 
             data.setLastSaved(now);
         }
         if (LOG.isDebugEnabled())
             LOG.debug("Updated session "+data);
     }
 
 
     /**
      * Update the node on which the session was last seen to be my node.
      *
      * @param data the session
      * @throws Exception
      */
     protected void updateSessionNode (Session data)
     throws Exception
     {
         String nodeId = getSessionIdManager().getWorkerName();
         try (Connection connection = getConnection();
                 PreparedStatement statement = connection.prepareStatement(_jdbcSessionIdMgr._updateSessionNode))
         {
             connection.setAutoCommit(true);
             statement.setString(1, nodeId);
             statement.setString(2, data.getRowId());
             statement.executeUpdate();
         }
         if (LOG.isDebugEnabled())
             LOG.debug("Updated last node for session id="+data.getId()+", lastNode = "+nodeId);
     }
 
     /**
      * Persist the time the session was last accessed.
      *
      * @param data the session
      * @throws Exception
      */
     private void updateSessionAccessTime (Session data)
     throws Exception
     {
         try (Connection connection = getConnection();
                 PreparedStatement statement = connection.prepareStatement(_jdbcSessionIdMgr._updateSessionAccessTime))
         {
             long now = System.currentTimeMillis();
             connection.setAutoCommit(true);
             statement.setString(1, getSessionIdManager().getWorkerName());
             statement.setLong(2, data.getAccessed());
             statement.setLong(3, data.getLastAccessedTime());
             statement.setLong(4, now);
             statement.setLong(5, data.getExpiryTime());
             statement.setLong(6, data.getMaxInactiveInterval());
             statement.setString(7, data.getRowId());
           
             statement.executeUpdate();
             data.setLastSaved(now);
         }
         if (LOG.isDebugEnabled())
             LOG.debug("Updated access time session id="+data.getId()+" with lastsaved="+data.getLastSaved());
     }
 
 
 
 
     /**
      * Delete a session from the database. Should only be called
      * when the session has been invalidated.
      *
      * @param data
      * @throws Exception
      */
     protected void deleteSession (Session data)
     throws Exception
     {
         try (Connection connection = getConnection();
                 PreparedStatement statement = connection.prepareStatement(_jdbcSessionIdMgr._deleteSession))
         {
             connection.setAutoCommit(true);
             statement.setString(1, data.getRowId());
             statement.executeUpdate();
             if (LOG.isDebugEnabled())
                 LOG.debug("Deleted Session "+data);
         }
     }
 
 
 
     /**
      * Get a connection from the driver.
      * @return
      * @throws SQLException
      */
     private Connection getConnection ()
     throws SQLException
     {
         return ((JDBCSessionIdManager)getSessionIdManager()).getConnection();
     }
 
     /**
      * Calculate a unique id for this session across the cluster.
      *
      * Unique id is composed of: contextpath_virtualhost0_sessionid
      * @param data
      * @return
      */
     private String calculateRowId (Session data)
     {
         String rowId = canonicalize(_context.getContextPath());
         rowId = rowId + "_" + getVirtualHost(_context);
         rowId = rowId+"_"+data.getId();
         return rowId;
     }
 
     /**
      * Get the first virtual host for the context.
      *
      * Used to help identify the exact session/contextPath.
      *
      * @return 0.0.0.0 if no virtual host is defined
      */
     private static String getVirtualHost (ContextHandler.Context context)
     {
         String vhost = "0.0.0.0";
 
         if (context==null)
             return vhost;
 
         String [] vhosts = context.getContextHandler().getVirtualHosts();
         if (vhosts==null || vhosts.length==0 || vhosts[0]==null)
             return vhost;
 
         return vhosts[0];
     }
 
     /**
      * Make an acceptable file name from a context path.
      *
      * @param path
      * @return
      */
     private static String canonicalize (String path)
     {
         if (path==null)
             return "";
 
         return path.replace('/', '_').replace('.','_').replace('\\','_');
     }
 }