Eclipse
/
jetty.project
mirror of https://github.com/jetty/jetty.project.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Renaming from temporary session.x package

This commit is contained in:
Jan Bartel 2015-10-23 14:10:42 +11:00
parent 305b7bb776
commit c5489bd7b2
45 changed files with 499 additions and 6538 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
jetty-infinispan/src/main/java/org/eclipse/jetty/session/infinispan/InfinispanSessionIdManager.java
View File

@ -138,7 +138,7 @@ public class InfinispanSessionIdManager extends AbstractSessionIdManager
if (id == null)
return false;
String clusterId = getClusterId(id);
String clusterId = getId(id);
//ask the cluster - this should also tickle the idle expiration timer on the sessionid entry
//keeping it valid

4
jetty-nosql/src/main/java/org/eclipse/jetty/nosql/mongodb/jmx/MongoSessionManagerMBean.java
View File

@ -22,11 +22,11 @@ import org.eclipse.jetty.nosql.mongodb.MongoSessionManager;
import org.eclipse.jetty.server.handler.AbstractHandlerContainer;
import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.server.session.SessionHandler;
import org.eclipse.jetty.server.session.jmx.AbstractSessionManagerMBean;
import org.eclipse.jetty.server.session.jmx.SessionManagerMBean;
import org.eclipse.jetty.util.annotation.ManagedObject;
@ManagedObject("Mongo Session Manager MBean")
public class MongoSessionManagerMBean extends AbstractSessionManagerMBean
public class MongoSessionManagerMBean extends SessionManagerMBean
{
public MongoSessionManagerMBean(Object managedObject)

20
jetty-security/src/main/java/org/eclipse/jetty/security/authentication/LoginAuthenticator.java
View File

@ -29,7 +29,7 @@ import org.eclipse.jetty.security.LoginService;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.Response;
import org.eclipse.jetty.server.UserIdentity;
import org.eclipse.jetty.server.session.AbstractSession;
import org.eclipse.jetty.server.session.Session;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
@ -109,17 +109,17 @@ public abstract class LoginAuthenticator implements Authenticator
{
//if we should renew sessions, and there is an existing session that may have been seen by non-authenticated users
//(indicated by SESSION_SECURED not being set on the session) then we should change id
if (httpSession.getAttribute(AbstractSession.SESSION_CREATED_SECURE)!=Boolean.TRUE)
if (httpSession.getAttribute(Session.SESSION_CREATED_SECURE)!=Boolean.TRUE)
{
if (httpSession instanceof AbstractSession)
if (httpSession instanceof Session)
{
AbstractSession abstractSession = (AbstractSession)httpSession;
String oldId = abstractSession.getId();
abstractSession.renewId(request);
abstractSession.setAttribute(AbstractSession.SESSION_CREATED_SECURE, Boolean.TRUE);
if (abstractSession.isIdChanged() && response != null && (response instanceof Response))
((Response)response).addCookie(abstractSession.getSessionManager().getSessionCookie(abstractSession, request.getContextPath(), request.isSecure()));
LOG.debug("renew {}->{}",oldId,abstractSession.getId());
Session s = (Session)httpSession;
String oldId = s.getId();
s.renewId(request);
s.setAttribute(Session.SESSION_CREATED_SECURE, Boolean.TRUE);
if (s.isIdChanged() && response != null && (response instanceof Response))
((Response)response).addCookie(s.getSessionManager().getSessionCookie(s, request.getContextPath(), request.isSecure()));
LOG.debug("renew {}->{}",oldId,s.getId());
}
else
LOG.warn("Unable to renew session "+httpSession);

4
jetty-security/src/main/java/org/eclipse/jetty/security/authentication/SessionAuthentication.java
View File

@ -33,7 +33,7 @@ import org.eclipse.jetty.security.AbstractUserAuthentication;
import org.eclipse.jetty.security.LoginService;
import org.eclipse.jetty.security.SecurityHandler;
import org.eclipse.jetty.server.UserIdentity;
import org.eclipse.jetty.server.session.AbstractSession;
import org.eclipse.jetty.server.session.Session;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
@ -89,7 +89,7 @@ public class SessionAuthentication extends AbstractUserAuthentication implements
if (security!=null)
security.logout(this);
if (_session!=null)
_session.removeAttribute(AbstractSession.SESSION_CREATED_SECURE);
_session.removeAttribute(Session.SESSION_CREATED_SECURE);
}
@Override

16
jetty-server/src/main/java/org/eclipse/jetty/server/Request.java
View File

@ -76,7 +76,7 @@ import org.eclipse.jetty.http.MetaData;
import org.eclipse.jetty.http.MimeTypes;
import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.server.handler.ContextHandler.Context;
import org.eclipse.jetty.server.session.AbstractSession;
import org.eclipse.jetty.server.session.Session;
import org.eclipse.jetty.util.Attributes;
import org.eclipse.jetty.util.AttributesMap;
import org.eclipse.jetty.util.IO;
@ -1494,14 +1494,14 @@ public class Request implements HttpServletRequest
if (session == null)
throw new IllegalStateException("No session");
if (session instanceof AbstractSession)
if (session instanceof Session)
{
AbstractSession abstractSession = ((AbstractSession)session);
abstractSession.renewId(this);
Session s = ((Session)session);
s.renewId(this);
if (getRemoteUser() != null)
abstractSession.setAttribute(AbstractSession.SESSION_CREATED_SECURE, Boolean.TRUE);
if (abstractSession.isIdChanged())
_channel.getResponse().addCookie(_sessionManager.getSessionCookie(abstractSession, getContextPath(), isSecure()));
s.setAttribute(Session.SESSION_CREATED_SECURE, Boolean.TRUE);
if (s.isIdChanged())
_channel.getResponse().addCookie(_sessionManager.getSessionCookie(s, getContextPath(), isSecure()));
}
return session.getId();
@ -1697,7 +1697,7 @@ public class Request implements HttpServletRequest
return false;
HttpSession session = getSession(false);
return (session != null && _sessionManager.getSessionIdManager().getClusterId(_requestedSessionId).equals(_sessionManager.getClusterId(session)));
return (session != null && _sessionManager.getSessionIdManager().getId(_requestedSessionId).equals(_sessionManager.getId(session)));
}
/* ------------------------------------------------------------ */

2
jetty-server/src/main/java/org/eclipse/jetty/server/Response.java
View File

@ -449,7 +449,7 @@ public class Response implements HttpServletResponse
if (!sessionManager.isValid(session))
return url;
String id = sessionManager.getNodeId(session);
String id = sessionManager.getExtendedId(session);
if (uri == null)
uri = new HttpURI(url);

8
jetty-server/src/main/java/org/eclipse/jetty/server/SessionManager.java
View File

@ -216,17 +216,17 @@ public interface SessionManager extends LifeCycle
/**
* @param session the session object
* @return the unique id of the session within the cluster, extended with an optional node id.
* @see #getClusterId(HttpSession)
* @see #getId(HttpSession)
*/
public String getNodeId(HttpSession session);
public String getExtendedId(HttpSession session);
/* ------------------------------------------------------------ */
/**
* @param session the session object
* @return the unique id of the session within the cluster (without a node id extension)
* @see #getNodeId(HttpSession)
* @see #getExtendedId(HttpSession)
*/
public String getClusterId(HttpSession session);
public String getId(HttpSession session);
/* ------------------------------------------------------------ */
/**

664
jetty-server/src/main/java/org/eclipse/jetty/server/session/AbstractSession.java
View File

@ -1,664 +0,0 @@
//
// ========================================================================
// 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 java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSessionActivationListener;
import javax.servlet.http.HttpSessionBindingEvent;
import javax.servlet.http.HttpSessionBindingListener;
import javax.servlet.http.HttpSessionContext;
import javax.servlet.http.HttpSessionEvent;
import org.eclipse.jetty.server.SessionManager;
import org.eclipse.jetty.util.log.Logger;
/**
*
* <p>
* Implements {@link javax.servlet.http.HttpSession} from the <code>javax.servlet</code> package.
* </p>
*
*/
@SuppressWarnings("deprecation")
public abstract class AbstractSession implements AbstractSessionManager.SessionIf
{
final static Logger LOG = SessionHandler.LOG;
public final static String SESSION_CREATED_SECURE="org.eclipse.jetty.security.sessionCreatedSecure";
private String _clusterId; // ID without any node (ie "worker") id appended
private String _nodeId; // ID of session with node(ie "worker") id appended
private final AbstractSessionManager _manager;
private boolean _idChanged;
private final long _created;
private long _cookieSet;
private long _accessed; // the time of the last access
private long _lastAccessed; // the time of the last access excluding this one
private boolean _invalid;
private boolean _doInvalidate;
private long _maxIdleMs;
private boolean _newSession;
private int _requests;
/* ------------------------------------------------------------- */
protected AbstractSession(AbstractSessionManager abstractSessionManager, HttpServletRequest request)
{
_manager = abstractSessionManager;
_newSession=true;
_created=System.currentTimeMillis();
_clusterId=_manager._sessionIdManager.newSessionId(request,_created);
_nodeId=_manager._sessionIdManager.getExtendedId(_clusterId,request);
_accessed=_created;
_lastAccessed=_created;
_requests=1;
_maxIdleMs=_manager._dftMaxIdleSecs>0?_manager._dftMaxIdleSecs*1000L:-1;
if (LOG.isDebugEnabled())
LOG.debug("new session & id "+_nodeId+" "+_clusterId);
}
/* ------------------------------------------------------------- */
protected AbstractSession(AbstractSessionManager abstractSessionManager, long created, long accessed, String clusterId)
{
_manager = abstractSessionManager;
_created=created;
_clusterId=clusterId;
_nodeId=_manager._sessionIdManager.getExtendedId(_clusterId,null);
_accessed=accessed;
_lastAccessed=accessed;
_requests=1;
_maxIdleMs=_manager._dftMaxIdleSecs>0?_manager._dftMaxIdleSecs*1000L:-1;
if (LOG.isDebugEnabled())
LOG.debug("new session "+_nodeId+" "+_clusterId);
}
/* ------------------------------------------------------------- */
/**
* asserts that the session is valid
* @throws IllegalStateException if the sesion is invalid
*/
protected void checkValid() throws IllegalStateException
{
if (_invalid)
throw new IllegalStateException();
}
/* ------------------------------------------------------------- */
/** Check to see if session has expired as at the time given.
* @param time the time in milliseconds
* @return true if expired
*/
protected boolean checkExpiry(long time)
{
if (_maxIdleMs>0 && _lastAccessed>0 && _lastAccessed + _maxIdleMs < time)
return true;
return false;
}
/* ------------------------------------------------------------- */
@Override
public AbstractSession getSession()
{
return this;
}
/* ------------------------------------------------------------- */
public long getAccessed()
{
synchronized (this)
{
return _accessed;
}
}
/* ------------------------------------------------------------- */
public abstract Map<String,Object> getAttributeMap();
/* ------------------------------------------------------------ */
public abstract int getAttributes();
/* ------------------------------------------------------------ */
public abstract Set<String> getNames();
/* ------------------------------------------------------------- */
public long getCookieSetTime()
{
return _cookieSet;
}
/* ------------------------------------------------------------- */
public void setCookieSetTime(long time)
{
_cookieSet = time;
}
/* ------------------------------------------------------------- */
@Override
public long getCreationTime() throws IllegalStateException
{
checkValid();
return _created;
}
/* ------------------------------------------------------------ */
@Override
public String getId() throws IllegalStateException
{
return _manager._nodeIdInSessionId?_nodeId:_clusterId;
}
/* ------------------------------------------------------------- */
public String getNodeId()
{
return _nodeId;
}
/* ------------------------------------------------------------- */
public String getClusterId()
{
return _clusterId;
}
/* ------------------------------------------------------------- */
@Override
public long getLastAccessedTime() throws IllegalStateException
{
checkValid();
return _lastAccessed;
}
/* ------------------------------------------------------------- */
public void setLastAccessedTime(long time)
{
_lastAccessed = time;
}
/* ------------------------------------------------------------- */
@Override
public int getMaxInactiveInterval()
{
return (int)(_maxIdleMs/1000);
}
/* ------------------------------------------------------------ */
/*
* @see javax.servlet.http.HttpSession#getServletContext()
*/
@Override
public ServletContext getServletContext()
{
return _manager._context;
}
/* ------------------------------------------------------------- */
@Deprecated
@Override
public HttpSessionContext getSessionContext() throws IllegalStateException
{
checkValid();
return AbstractSessionManager.__nullSessionContext;
}
/* ------------------------------------------------------------- */
/**
* @deprecated As of Version 2.2, this method is replaced by
* {@link #getAttribute}
*/
@Deprecated
@Override
public Object getValue(String name) throws IllegalStateException
{
return getAttribute(name);
}
/* ------------------------------------------------------------ */
public void renewId(HttpServletRequest request)
{
_manager._sessionIdManager.renewSessionId(getClusterId(), getNodeId(), request);
setIdChanged(true);
}
/* ------------------------------------------------------------- */
public SessionManager getSessionManager()
{
return _manager;
}
/* ------------------------------------------------------------ */
protected void setClusterId (String clusterId)
{
_clusterId = clusterId;
}
/* ------------------------------------------------------------ */
protected void setNodeId (String nodeId)
{
_nodeId = nodeId;
}
/* ------------------------------------------------------------ */
protected boolean access(long time)
{
synchronized(this)
{
if (_invalid)
return false;
_newSession=false;
_lastAccessed=_accessed;
_accessed=time;
if (checkExpiry(time))
{
invalidate();
return false;
}
_requests++;
return true;
}
}
/* ------------------------------------------------------------ */
protected void complete()
{
synchronized(this)
{
_requests--;
if (_doInvalidate && _requests<=0 )
doInvalidate();
}
}
/* ------------------------------------------------------------- */
protected void timeout() throws IllegalStateException
{
// remove session from context and invalidate other sessions with same ID.
_manager.removeSession(this,true);
// Notify listeners and unbind values
boolean do_invalidate=false;
synchronized (this)
{
if (!_invalid)
{
if (_requests<=0)
do_invalidate=true;
else
_doInvalidate=true;
}
}
if (do_invalidate)
doInvalidate();
}
/* ------------------------------------------------------------- */
@Override
public void invalidate() throws IllegalStateException
{
checkValid();
// remove session from context and invalidate other sessions with same ID.
_manager.removeSession(this,true);
doInvalidate();
}
/* ------------------------------------------------------------- */
protected void doInvalidate() throws IllegalStateException
{
try
{
if (LOG.isDebugEnabled())
LOG.debug("invalidate {}",_clusterId);
if (isValid())
clearAttributes();
}
finally
{
synchronized (this)
{
// mark as invalid
_invalid=true;
}
}
}
/* ------------------------------------------------------------- */
public abstract void clearAttributes();
/* ------------------------------------------------------------- */
public boolean isIdChanged()
{
return _idChanged;
}
/* ------------------------------------------------------------- */
@Override
public boolean isNew() throws IllegalStateException
{
checkValid();
return _newSession;
}
/* ------------------------------------------------------------- */
/**
* @deprecated As of Version 2.2, this method is replaced by
* {@link #setAttribute}
*/
@Deprecated
@Override
public void putValue(java.lang.String name, java.lang.Object value) throws IllegalStateException
{
changeAttribute(name,value);
}
/* ------------------------------------------------------------ */
@Override
public void removeAttribute(String name)
{
setAttribute(name,null);
}
/* ------------------------------------------------------------- */
/**
* @deprecated As of Version 2.2, this method is replaced by
* {@link #removeAttribute}
*/
@Deprecated
@Override
public void removeValue(java.lang.String name) throws IllegalStateException
{
removeAttribute(name);
}
/* ------------------------------------------------------------ */
@Override
public Enumeration<String> getAttributeNames()
{
synchronized (this)
{
checkValid();
return doGetAttributeNames();
}
}
/* ------------------------------------------------------------- */
/**
* @deprecated As of Version 2.2, this method is replaced by
* {@link #getAttributeNames}
*/
@Deprecated
@Override
public String[] getValueNames() throws IllegalStateException
{
synchronized(this)
{
checkValid();
Enumeration<String> anames = doGetAttributeNames();
if (anames == null)
return new String[0];
ArrayList<String> names = new ArrayList<String>();
while (anames.hasMoreElements())
names.add(anames.nextElement());
return names.toArray(new String[names.size()]);
}
}
/* ------------------------------------------------------------ */
public abstract Object doPutOrRemove(String name, Object value);
/* ------------------------------------------------------------ */
public abstract Object doGet(String name);
/* ------------------------------------------------------------ */
public abstract Enumeration<String> doGetAttributeNames();
/* ------------------------------------------------------------ */
@Override
public Object getAttribute(String name)
{
synchronized (this)
{
checkValid();
return doGet(name);
}
}
/* ------------------------------------------------------------ */
@Override
public void setAttribute(String name, Object value)
{
changeAttribute(name,value);
}
/* ------------------------------------------------------------ */
/**
* @param name the name of the attribute
* @param value the value of the attribute
* @return true if attribute changed
* @deprecated use changeAttribute(String,Object) instead
*/
@Deprecated
protected boolean updateAttribute (String name, Object value)
{
Object old=null;
synchronized (this)
{
checkValid();
old=doPutOrRemove(name,value);
}
if (value==null || !value.equals(old))
{
if (old!=null)
unbindValue(name,old);
if (value!=null)
bindValue(name,value);
_manager.doSessionAttributeListeners(this,name,old,value);
return true;
}
return false;
}
/* ------------------------------------------------------------ */
/**
* Either set (perhaps replace) or remove the value of the attribute
* in the session. The appropriate session attribute listeners are
* also called.
*
* @param name the name of the attribute
* @param value the value of the attribute
* @return the old value for the attribute
*/
protected Object changeAttribute (String name, Object value)
{
Object old=null;
synchronized (this)
{
checkValid();
old=doPutOrRemove(name,value);
}
callSessionAttributeListeners(name, value, old);
return old;
}
/* ------------------------------------------------------------ */
/**
* Call binding and attribute listeners based on the new and old
* values of the attribute.
*
* @param name name of the attribute
* @param newValue new value of the attribute
* @param oldValue previous value of the attribute
*/
protected void callSessionAttributeListeners (String name, Object newValue, Object oldValue)
{
if (newValue==null || !newValue.equals(oldValue))
{
if (oldValue!=null)
unbindValue(name,oldValue);
if (newValue!=null)
bindValue(name,newValue);
_manager.doSessionAttributeListeners(this,name,oldValue,newValue);
}
}
/* ------------------------------------------------------------- */
public void setIdChanged(boolean changed)
{
_idChanged=changed;
}
/* ------------------------------------------------------------- */
@Override
public void setMaxInactiveInterval(int secs)
{
_maxIdleMs=(long)secs*1000L;
}
/* ------------------------------------------------------------- */
@Override
public String toString()
{
return this.getClass().getName()+":"+getId()+"@"+hashCode();
}
/* ------------------------------------------------------------- */
/**
* Bind value if value implements {@link HttpSessionBindingListener} (calls {@link HttpSessionBindingListener#valueBound(HttpSessionBindingEvent)})
* @param name the name with which the object is bound or unbound
* @param value the bound value
*/
public void bindValue(java.lang.String name, Object value)
{
if (value!=null&&value instanceof HttpSessionBindingListener)
((HttpSessionBindingListener)value).valueBound(new HttpSessionBindingEvent(this,name));
}
/* ------------------------------------------------------------ */
public boolean isValid()
{
return !_invalid;
}
/* ------------------------------------------------------------- */
protected void cookieSet()
{
synchronized (this)
{
_cookieSet=_accessed;
}
}
/* ------------------------------------------------------------ */
public int getRequests()
{
synchronized (this)
{
return _requests;
}
}
/* ------------------------------------------------------------ */
public void setRequests(int requests)
{
synchronized (this)
{
_requests=requests;
}
}
/* ------------------------------------------------------------- */
/**
* Unbind value if value implements {@link HttpSessionBindingListener} (calls {@link HttpSessionBindingListener#valueUnbound(HttpSessionBindingEvent)})
* @param name the name with which the object is bound or unbound
* @param value the bound value
*/
public void unbindValue(java.lang.String name, Object value)
{
if (value!=null&&value instanceof HttpSessionBindingListener)
((HttpSessionBindingListener)value).valueUnbound(new HttpSessionBindingEvent(this,name));
}
/* ------------------------------------------------------------- */
public void willPassivate()
{
synchronized(this)
{
HttpSessionEvent event = new HttpSessionEvent(this);
for (Iterator<Object> iter = getAttributeMap().values().iterator(); iter.hasNext();)
{
Object value = iter.next();
if (value instanceof HttpSessionActivationListener)
{
HttpSessionActivationListener listener = (HttpSessionActivationListener) value;
listener.sessionWillPassivate(event);
}
}
}
}
/* ------------------------------------------------------------- */
public void didActivate()
{
synchronized(this)
{
HttpSessionEvent event = new HttpSessionEvent(this);
for (Iterator<Object> iter = getAttributeMap().values().iterator(); iter.hasNext();)
{
Object value = iter.next();
if (value instanceof HttpSessionActivationListener)
{
HttpSessionActivationListener listener = (HttpSessionActivationListener) value;
listener.sessionDidActivate(event);
}
}
}
}
}

4
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/AbstractSessionDataStore.java → jetty-server/src/main/java/org/eclipse/jetty/server/session/AbstractSessionDataStore.java
View File

@ -17,7 +17,7 @@
//
package org.eclipse.jetty.server.session.x;
package org.eclipse.jetty.server.session;
import org.eclipse.jetty.server.handler.ContextHandler.Context;
import org.eclipse.jetty.util.component.AbstractLifeCycle;
@ -60,7 +60,7 @@ public abstract class AbstractSessionDataStore extends AbstractLifeCycle impleme
/**
* @see org.eclipse.jetty.server.session.x.SessionDataStore#store(java.lang.String, org.eclipse.jetty.server.session.x.SessionData)
* @see org.eclipse.jetty.server.session.SessionDataStore#store(java.lang.String, org.eclipse.jetty.server.session.SessionData)
*/
@Override
public void store(SessionKey key, SessionData data) throws Exception

113
jetty-server/src/main/java/org/eclipse/jetty/server/session/AbstractSessionIdManager.java
View File

@ -23,7 +23,10 @@ import java.util.Random;
import javax.servlet.http.HttpServletRequest;
import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.SessionIdManager;
import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.util.component.AbstractLifeCycle;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
@ -39,6 +42,8 @@ public abstract class AbstractSessionIdManager extends AbstractLifeCycle impleme
protected String _workerName;
protected String _workerAttr;
protected long _reseed=100000L;
protected Server _server;
protected SessionScavenger _scavenger;
/* ------------------------------------------------------------ */
public AbstractSessionIdManager()
@ -52,10 +57,23 @@ public abstract class AbstractSessionIdManager extends AbstractLifeCycle impleme
}
public void setServer (Server server)
{
_server = server;
}
public Server getServer ()
{
return _server;
}
/* ------------------------------------------------------------ */
@Override
public abstract void renewSessionId(String oldClusterId, String oldNodeId, HttpServletRequest request);
public void setSessionScavenger (SessionScavenger scavenger)
{
_scavenger = scavenger;
_scavenger.setSessionIdManager(this);
}
/* ------------------------------------------------------------ */
@ -212,14 +230,26 @@ public abstract class AbstractSessionIdManager extends AbstractLifeCycle impleme
@Override
protected void doStart() throws Exception
{
if (_server == null)
throw new IllegalStateException("No Server for SessionIdManager");
initRandom();
_workerAttr=(_workerName!=null && _workerName.startsWith("$"))?_workerName.substring(1):null;
if (_scavenger == null)
{
LOG.warn("No SessionScavenger set, using defaults");
_scavenger = new SessionScavenger();
_scavenger.setSessionIdManager(this);
}
_scavenger.start();
}
/* ------------------------------------------------------------ */
@Override
protected void doStop() throws Exception
{
_scavenger.stop();
}
/* ------------------------------------------------------------ */
@ -281,5 +311,82 @@ public abstract class AbstractSessionIdManager extends AbstractLifeCycle impleme
return (dot>0)?extendedId.substring(0,dot):extendedId;
}
/**
* Remove an id from use by telling all contexts to remove a session with this id.
*
* @see org.eclipse.jetty.server.SessionIdManager#expireAll(java.lang.String)
*/
@Override
public void expireAll(String id)
{
//take the id out of the list of known sessionids for this node
removeId(id);
//tell all contexts that may have a session object with this id to
//get rid of them
Handler[] contexts = _server.getChildHandlersByClass(ContextHandler.class);
for (int i=0; contexts!=null && i<contexts.length; i++)
{
SessionHandler sessionHandler = ((ContextHandler)contexts[i]).getChildHandlerByClass(SessionHandler.class);
if (sessionHandler != null)
{
SessionManager manager = (SessionManager)sessionHandler.getSessionManager();
if (manager != null)
{
manager.invalidate(id);
}
}
}
}
public void invalidateAll (String id)
{
//take the id out of the list of known sessionids for this node
removeId(id);
//tell all contexts that may have a session object with this id to
//get rid of them
Handler[] contexts = _server.getChildHandlersByClass(ContextHandler.class);
for (int i=0; contexts!=null && i<contexts.length; i++)
{
SessionHandler sessionHandler = ((ContextHandler)contexts[i]).getChildHandlerByClass(SessionHandler.class);
if (sessionHandler != null)
{
SessionManager manager = (SessionManager)sessionHandler.getSessionManager();
if (manager != null)
{
manager.invalidate(id);
}
}
}
}
/**
* @see org.eclipse.jetty.server.SessionIdManager#renewSessionId(java.lang.String, java.lang.String, javax.servlet.http.HttpServletRequest)
*/
@Override
public void renewSessionId (String oldClusterId, String oldNodeId, HttpServletRequest request)
{
//generate a new id
String newClusterId = newSessionId(request.hashCode());
removeId(oldClusterId);//remove the old one from the list (and database)
//tell all contexts to update the id
Handler[] contexts = _server.getChildHandlersByClass(ContextHandler.class);
for (int i=0; contexts!=null && i<contexts.length; i++)
{
SessionHandler sessionHandler = ((ContextHandler)contexts[i]).getChildHandlerByClass(SessionHandler.class);
if (sessionHandler != null)
{
SessionManager manager = (SessionManager)sessionHandler.getSessionManager();
if (manager != null)
{
manager.renewSessionId(oldClusterId, oldNodeId, newClusterId, getExtendedId(newClusterId, request));
}
}
}
}
}

1054
jetty-server/src/main/java/org/eclipse/jetty/server/session/AbstractSessionManager.java
View File

File diff suppressed because it is too large Load Diff

12
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/AbstractSessionStore.java → jetty-server/src/main/java/org/eclipse/jetty/server/session/AbstractSessionStore.java
View File

@ -17,7 +17,7 @@
//
package org.eclipse.jetty.server.session.x;
package org.eclipse.jetty.server.session;
import java.util.Collections;
import java.util.Map;
@ -123,7 +123,7 @@ public abstract class AbstractSessionStore extends AbstractLifeCycle implements
* the data for it from a SessionDataStore associated with the
* session manager.
*
* @see org.eclipse.jetty.server.session.x.SessionStore#get(java.lang.String)
* @see org.eclipse.jetty.server.session.SessionStore#get(java.lang.String)
*/
@Override
public Session get(SessionKey key) throws Exception
@ -147,7 +147,7 @@ public abstract class AbstractSessionStore extends AbstractLifeCycle implements
* If the session manager supports a session data store, write the
* session data through to the session data store.
*
* @see org.eclipse.jetty.server.session.x.SessionStore#put(java.lang.String, org.eclipse.jetty.server.session.x.Session)
* @see org.eclipse.jetty.server.session.SessionStore#put(java.lang.String, org.eclipse.jetty.server.session.Session)
*/
@Override
public void put(SessionKey key, Session session) throws Exception
@ -187,7 +187,7 @@ public abstract class AbstractSessionStore extends AbstractLifeCycle implements
*
* TODO should this check through to the backing store?
*
* @see org.eclipse.jetty.server.session.x.SessionStore#exists(java.lang.String)
* @see org.eclipse.jetty.server.session.SessionStore#exists(java.lang.String)
*/
@Override
public boolean exists(SessionKey key)
@ -199,7 +199,7 @@ public abstract class AbstractSessionStore extends AbstractLifeCycle implements
/**
* Remove a session object from this store and from any backing store.
*
* @see org.eclipse.jetty.server.session.x.SessionStore#delete(java.lang.String)
* @see org.eclipse.jetty.server.session.SessionStore#delete(java.lang.String)
*/
@Override
public boolean delete(SessionKey key) throws Exception
@ -221,7 +221,7 @@ public abstract class AbstractSessionStore extends AbstractLifeCycle implements
/**
* @see org.eclipse.jetty.server.session.x.SessionStore#getExpired()
* @see org.eclipse.jetty.server.session.SessionStore#getExpired()
*/
@Override
public Set<SessionKey> getExpired()

4
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/AlwaysStaleStrategy.java → jetty-server/src/main/java/org/eclipse/jetty/server/session/AlwaysStaleStrategy.java
View File

@ -17,7 +17,7 @@
//
package org.eclipse.jetty.server.session.x;
package org.eclipse.jetty.server.session;
/**
* AlwaysStale
@ -28,7 +28,7 @@ public class AlwaysStaleStrategy implements StalenessStrategy
{
/**
* @see org.eclipse.jetty.server.session.x.StalenessStrategy#isStale(org.eclipse.jetty.server.session.x.Session)
* @see org.eclipse.jetty.server.session.StalenessStrategy#isStale(org.eclipse.jetty.server.session.Session)
*/
@Override
public boolean isStale(Session session)

2
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/DatabaseAdaptor.java → jetty-server/src/main/java/org/eclipse/jetty/server/session/DatabaseAdaptor.java
View File

@ -17,7 +17,7 @@
//
package org.eclipse.jetty.server.session.x;
package org.eclipse.jetty.server.session;
import java.io.ByteArrayInputStream;
import java.io.InputStream;

12
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/FileSessionDataStore.java → jetty-server/src/main/java/org/eclipse/jetty/server/session/FileSessionDataStore.java
View File

@ -17,7 +17,7 @@
//
package org.eclipse.jetty.server.session.x;
package org.eclipse.jetty.server.session;
import java.io.DataInputStream;
import java.io.DataOutputStream;
@ -87,7 +87,7 @@ public class FileSessionDataStore extends AbstractSessionDataStore
}
/**
* @see org.eclipse.jetty.server.session.x.SessionDataStore#newSessionData(org.eclipse.jetty.server.session.x.SessionKey, long, long, long, long)
* @see org.eclipse.jetty.server.session.SessionDataStore#newSessionData(org.eclipse.jetty.server.session.SessionKey, long, long, long, long)
*/
@Override
public SessionData newSessionData(SessionKey key, long created, long accessed, long lastAccessed, long maxInactiveMs)
@ -96,7 +96,7 @@ public class FileSessionDataStore extends AbstractSessionDataStore
}
/**
* @see org.eclipse.jetty.server.session.x.SessionDataStore#delete(org.eclipse.jetty.server.session.x.SessionKey)
* @see org.eclipse.jetty.server.session.SessionDataStore#delete(org.eclipse.jetty.server.session.SessionKey)
*/
@Override
public boolean delete(SessionKey key) throws Exception
@ -116,7 +116,7 @@ public class FileSessionDataStore extends AbstractSessionDataStore
}
/**
* @see org.eclipse.jetty.server.session.x.SessionDataStore#getExpired()
* @see org.eclipse.jetty.server.session.SessionDataStore#getExpired()
*/
@Override
public Set<SessionKey> getExpired(Set<SessionKey> candidates)
@ -127,7 +127,7 @@ public class FileSessionDataStore extends AbstractSessionDataStore
/**
* @see org.eclipse.jetty.server.session.x.SessionDataStore#load(org.eclipse.jetty.server.session.x.SessionKey)
* @see org.eclipse.jetty.server.session.SessionDataStore#load(org.eclipse.jetty.server.session.SessionKey)
*/
@Override
public SessionData load(SessionKey key) throws Exception
@ -226,7 +226,7 @@ public class FileSessionDataStore extends AbstractSessionDataStore
/**
* @see org.eclipse.jetty.server.session.x.AbstractSessionDataStore#doStore(org.eclipse.jetty.server.session.x.SessionKey, org.eclipse.jetty.server.session.x.SessionData)
* @see org.eclipse.jetty.server.session.AbstractSessionDataStore#doStore(org.eclipse.jetty.server.session.SessionKey, org.eclipse.jetty.server.session.SessionData)
*/
@Override
public void doStore(SessionKey key, SessionData data) throws Exception

164
jetty-server/src/main/java/org/eclipse/jetty/server/session/HashSessionIdManager.java
View File

@ -16,166 +16,64 @@
// ========================================================================
//
package org.eclipse.jetty.server.session;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.SessionIdManager;
import org.eclipse.jetty.server.SessionManager;
import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.util.ConcurrentHashSet;
/* ------------------------------------------------------------ */
/**
* HashSessionIdManager. An in-memory implementation of the session ID manager.
* HashSessionIdManager
*
*
*/
public class HashSessionIdManager extends AbstractSessionIdManager
{
private final Set<String> _ids = new ConcurrentHashSet<String>();
private Server _server;
/* ------------------------------------------------------------ */
public HashSessionIdManager()
{
}
/* ------------------------------------------------------------ */
public HashSessionIdManager(Random random)
{
super(random);
}
public void setServer (Server server)
{
_server = server;
}
/* ------------------------------------------------------------ */
/**
* @return Collection of String session IDs
*/
public Collection<String> getSessions()
{
return Collections.unmodifiableCollection(_ids);
}
/* ------------------------------------------------------------ */
@Override
protected void doStart() throws Exception
{
if (_server == null)
throw new IllegalStateException ("No server set on HashSessionIdManager");
super.doStart();
}
/* ------------------------------------------------------------ */
@Override
protected void doStop() throws Exception
{
_ids.clear();
super.doStop();
}
/* ------------------------------------------------------------ */
/**
* @see SessionIdManager#isIdInUse(String)
/**
* @see org.eclipse.jetty.server.SessionIdManager#isIdInUse(java.lang.String)
*/
@Override
public boolean isIdInUse(String id)
{
return _ids.contains(id);
{
return _ids.contains(id);
}
/* ------------------------------------------------------------ */
/**
* @see SessionIdManager#addSession(HttpSession)
/**
* @see org.eclipse.jetty.server.session.AbstractSessionIdManager#newSessionId(long)
*/
@Override
public String newSessionId(long seedTerm)
{
String id = super.newSessionId(seedTerm);
useId(id);
return id;
}
/**
* @see org.eclipse.jetty.server.SessionIdManager#useId(java.lang.String)
*/
@Override
public void useId(String id)
{
_ids.add(id);
if (id == null)
return;
_ids.add(id);
}
/**
* @see org.eclipse.jetty.server.SessionIdManager#removeId(java.lang.String)
*/
@Override
public void removeId(String id)
{
_ids.remove(id);
}
/* ------------------------------------------------------------ */
/**
* @see SessionIdManager#expireAll(String)
*/
@Override
public void expireAll(String id)
{
//take the id out of the list of known sessionids for this node
removeId(id);
synchronized (_ids)
{
//tell all contexts that may have a session object with this id to
//get rid of them
Handler[] contexts = _server.getChildHandlersByClass(ContextHandler.class);
for (int i=0; contexts!=null && i<contexts.length; i++)
{
SessionHandler sessionHandler = ((ContextHandler)contexts[i]).getChildHandlerByClass(SessionHandler.class);
if (sessionHandler != null)
{
SessionManager manager = sessionHandler.getSessionManager();
if (manager != null)
manager.expire(id);
}
}
}
}
/* ------------------------------------------------------------ */
@Override
public void renewSessionId (String oldClusterId, String oldNodeId, HttpServletRequest request)
{
//generate a new id
String newClusterId = newSessionId(request.hashCode());
synchronized (_ids)
{
removeId(oldClusterId);//remove the old one from the list (and database)
//tell all contexts to update the id
Handler[] contexts = _server.getChildHandlersByClass(ContextHandler.class);
for (int i=0; contexts!=null && i<contexts.length; i++)
{
SessionHandler sessionHandler = ((ContextHandler)contexts[i]).getChildHandlerByClass(SessionHandler.class);
if (sessionHandler != null)
{
SessionManager manager = sessionHandler.getSessionManager();
if (manager != null)
manager.renewSessionId(oldClusterId, oldNodeId, newClusterId, getExtendedId(newClusterId, request));
}
}
}
_ids.remove(id);
}
}

669
jetty-server/src/main/java/org/eclipse/jetty/server/session/HashSessionManager.java
View File

@ -16,688 +16,41 @@
// ========================================================================
//
package org.eclipse.jetty.server.session;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.util.ClassLoadingObjectInputStream;
import org.eclipse.jetty.util.log.Logger;
import org.eclipse.jetty.util.thread.ScheduledExecutorScheduler;
import org.eclipse.jetty.util.thread.Scheduler;
/* ------------------------------------------------------------ */
/**
/**
* HashSessionManager
*
* An in-memory implementation of SessionManager.
* <p>
* This manager supports saving sessions to disk, either periodically or at shutdown.
* Sessions can also have their content idle saved to disk to reduce the memory overheads of large idle sessions.
* <p>
* This manager will create it's own Timer instance to scavenge threads, unless it discovers a shared Timer instance
* set as the "org.eclipse.jetty.server.session.timer" attribute of the ContextHandler.
*
*
*/
public class HashSessionManager extends AbstractSessionManager
public class HashSessionManager extends SessionManager
{
final static Logger LOG = SessionHandler.LOG;
protected final ConcurrentMap<String,HashedSession> _sessions=new ConcurrentHashMap<String,HashedSession>();
private Scheduler _timer;
private Scheduler.Task _task;
long _scavengePeriodMs=30000;
long _savePeriodMs=0; //don't do period saves by default
long _idleSavePeriodMs = 0; // don't idle save sessions by default.
private Scheduler.Task _saveTask;
File _storeDir;
private boolean _lazyLoad=false;
private volatile boolean _sessionsLoaded=false;
private boolean _deleteUnrestorableSessions=false;
protected FileSessionDataStore _sessionDataStore = new FileSessionDataStore();
/**
* Scavenger
*
*/
protected class Scavenger implements Runnable
{
@Override
public void run()
{
try
{
scavenge();
}
finally
{
if (_timer != null && _timer.isRunning()) {
_task = _timer.schedule(this, _scavengePeriodMs, TimeUnit.MILLISECONDS);
}
}
}
}
/**
* Saver
*
*/
protected class Saver implements Runnable
{
@Override
public void run()
{
try
{
saveSessions(true);
}
catch (Exception e)
{
LOG.warn(e);
}
finally
{
if (_timer != null && _timer.isRunning())
_saveTask = _timer.schedule(this, _savePeriodMs, TimeUnit.MILLISECONDS);
}
}
}
/* ------------------------------------------------------------ */
public HashSessionManager()
{
super();
}
/* ------------------------------------------------------------ */
/**
* @see AbstractSessionManager#doStart()
*/
@Override
public void doStart() throws Exception
{
//try shared scheduler from Server first
_timer = getSessionHandler().getServer().getBean(Scheduler.class);
if (_timer == null)
{
//try one passed into the context
ServletContext context = ContextHandler.getCurrentContext();
if (context!=null)
_timer = (Scheduler)context.getAttribute("org.eclipse.jetty.server.session.timer");
}
if (_timer == null)
{
//make a scheduler if none useable
_timer=new ScheduledExecutorScheduler(toString()+"Timer",true);
addBean(_timer,true);
}
else
addBean(_timer,false);
_sessionStore = new MemorySessionStore();
((AbstractSessionStore)_sessionStore).setSessionDataStore(_sessionDataStore);
super.doStart();
setScavengePeriod(getScavengePeriod());
if (_storeDir!=null)
{
if (!_storeDir.exists())
_storeDir.mkdirs();
if (!_lazyLoad)
restoreSessions();
}
setSavePeriod(getSavePeriod());
}
/* ------------------------------------------------------------ */
/**
* @see AbstractSessionManager#doStop()
*/
@Override
public void doStop() throws Exception
{
// stop the scavengers
synchronized(this)
{
if (_saveTask!=null)
_saveTask.cancel();
_saveTask=null;
if (_task!=null)
_task.cancel();
_task=null;
_timer=null;
}
// This will callback invalidate sessions - where we decide if we will save
super.doStop();
_sessions.clear();
}
/* ------------------------------------------------------------ */
/**
* @return the period in seconds at which a check is made for sessions to be invalidated.
*/
public int getScavengePeriod()
{
return (int)(_scavengePeriodMs/1000);
}
/* ------------------------------------------------------------ */
@Override
public int getSessions()
{
int sessions=super.getSessions();
if (LOG.isDebugEnabled())
{
if (_sessions.size()!=sessions)
LOG.warn("sessions: "+_sessions.size()+"!="+sessions);
}
return sessions;
}
/* ------------------------------------------------------------ */
/**
* @return seconds Idle period after which a session is saved
*/
public int getIdleSavePeriod()
{
if (_idleSavePeriodMs <= 0)
return 0;
return (int)(_idleSavePeriodMs / 1000);
}
/* ------------------------------------------------------------ */
/**
* Configures the period in seconds after which a session is deemed idle and saved
* to save on session memory.
*
* The session is persisted, the values attribute map is cleared and the session set to idled.
*
* @param seconds Idle period after which a session is saved
*/
public void setIdleSavePeriod(int seconds)
{
_idleSavePeriodMs = seconds * 1000L;
}
/* ------------------------------------------------------------ */
@Override
public void setMaxInactiveInterval(int seconds)
{
super.setMaxInactiveInterval(seconds);
if (_dftMaxIdleSecs>0&&_scavengePeriodMs>_dftMaxIdleSecs*1000L)
setScavengePeriod((_dftMaxIdleSecs+9)/10);
}
/* ------------------------------------------------------------ */
/**
* @param seconds the period is seconds at which sessions are periodically saved to disk
*/
public void setSavePeriod (int seconds)
{
long period = (seconds * 1000L);
if (period < 0)
period=0;
_savePeriodMs=period;
if (_timer!=null)
{
synchronized (this)
{
if (_saveTask!=null)
_saveTask.cancel();
_saveTask = null;
if (_savePeriodMs > 0 && _storeDir!=null) //only save if we have a directory configured
{
_saveTask = _timer.schedule(new Saver(),_savePeriodMs,TimeUnit.MILLISECONDS);
}
}
}
}
/* ------------------------------------------------------------ */
/**
* @return the period in seconds at which sessions are periodically saved to disk
*/
public int getSavePeriod ()
{
if (_savePeriodMs<=0)
return 0;
return (int)(_savePeriodMs/1000);
}
/* ------------------------------------------------------------ */
/**
* @param seconds the period in seconds at which a check is made for sessions to be invalidated.
*/
public void setScavengePeriod(int seconds)
{
if (seconds==0)
seconds=60;
long old_period=_scavengePeriodMs;
long period=seconds*1000L;
if (period>60000)
period=60000;
if (period<1000)
period=1000;
_scavengePeriodMs=period;
synchronized (this)
{
if (_timer!=null && (period!=old_period || _task==null))
{
if (_task!=null)
{
_task.cancel();
_task = null;
}
_task = _timer.schedule(new Scavenger(),_scavengePeriodMs, TimeUnit.MILLISECONDS);
}
}
}
/* -------------------------------------------------------------- */
/**
* Find sessions that have timed out and invalidate them. This runs in the
* SessionScavenger thread.
*/
protected void scavenge()
{
//don't attempt to scavenge if we are shutting down
if (isStopping() || isStopped())
return;
Thread thread=Thread.currentThread();
ClassLoader old_loader=thread.getContextClassLoader();
try
{
if (_loader!=null)
thread.setContextClassLoader(_loader);
// For each session
long now=System.currentTimeMillis();
__log.debug("Scavenging sessions at {}", now);
for (Iterator<HashedSession> i=_sessions.values().iterator(); i.hasNext();)
{
HashedSession session=i.next();
long idleTime=session.getMaxInactiveInterval()*1000L;
if (idleTime>0&&session.getAccessed()+idleTime<now)
{
// Found a stale session, add it to the list
try
{
session.timeout();
}
catch (Exception e)
{
__log.warn("Problem scavenging sessions", e);
}
}
else if (_idleSavePeriodMs > 0 && session.getAccessed()+_idleSavePeriodMs < now)
{
try
{
session.idle();
}
catch (Exception e)
{
__log.warn("Problem idling session "+ session.getId(), e);
}
}
}
}
finally
{
thread.setContextClassLoader(old_loader);
}
}
/* ------------------------------------------------------------ */
@Override
protected void addSession(AbstractSession session)
{
if (isRunning())
_sessions.put(session.getClusterId(),(HashedSession)session);
}
/* ------------------------------------------------------------ */
@Override
public AbstractSession getSession(String idInCluster)
{
if ( _lazyLoad && !_sessionsLoaded)
{
try
{
restoreSessions();
}
catch(Exception e)
{
LOG.warn(e);
}
}
Map<String,HashedSession> sessions=_sessions;
if (sessions==null)
return null;
HashedSession session = sessions.get(idInCluster);
if (session == null && _lazyLoad)
session=restoreSession(idInCluster);
if (session == null)
return null;
if (_idleSavePeriodMs!=0)
session.deIdle();
return session;
}
/* ------------------------------------------------------------ */
@Override
protected void shutdownSessions() throws Exception
{
// Invalidate all sessions to cause unbind events
ArrayList<HashedSession> sessions=new ArrayList<HashedSession>(_sessions.values());
int loop=100;
while (sessions.size()>0 && loop-->0)
{
// If we are called from doStop
if (isStopping() && _storeDir != null && _storeDir.exists() && _storeDir.canWrite())
{
// Then we only save and remove the session from memory- it is not invalidated.
for (HashedSession session : sessions)
{
session.save(false);
_sessions.remove(session.getClusterId());
}
}
else
{
for (HashedSession session : sessions)
session.invalidate();
}
// check that no new sessions were created while we were iterating
sessions=new ArrayList<HashedSession>(_sessions.values());
}
}
/* ------------------------------------------------------------ */
/**
* @see org.eclipse.jetty.server.SessionManager#renewSessionId(java.lang.String, java.lang.String, java.lang.String, java.lang.String)
* Get the SessionDataStore to configure it
* @return
*/
@Override
public void renewSessionId(String oldClusterId, String oldNodeId, String newClusterId, String newNodeId)
public FileSessionDataStore getSessionDataStore()
{
try
{
Map<String,HashedSession> sessions=_sessions;
if (sessions == null)
return;
HashedSession session = sessions.remove(oldClusterId);
if (session == null)
return;
session.remove(); //delete any previously saved session
session.setClusterId(newClusterId); //update ids
session.setNodeId(newNodeId);
session.save(); //save updated session: TODO consider only saving file if idled
sessions.put(newClusterId, session);
super.renewSessionId(oldClusterId, oldNodeId, newClusterId, newNodeId);
}
catch (Exception e)
{
LOG.warn(e);
}
}
@Override
public void invalidateSession(String id)
{
// TODO Auto-generated method stub
//Called from SessionIdManager when invalidating all sessions with the same id
//across contexts
return _sessionDataStore;
}
/* ------------------------------------------------------------ */
@Override
protected AbstractSession newSession(HttpServletRequest request)
{
return new HashedSession(this, request);
}
/* ------------------------------------------------------------ */
protected AbstractSession newSession(long created, long accessed, String clusterId)
{
return new HashedSession(this, created,accessed, clusterId);
}
/* ------------------------------------------------------------ */
@Override
protected boolean removeSession(String clusterId)
{
return _sessions.remove(clusterId)!=null;
}
/* ------------------------------------------------------------ */
public void setStoreDirectory (File dir) throws IOException
{
// CanonicalFile is used to capture the base store directory in a way that will
// work on Windows. Case differences may through off later checks using this directory.
_storeDir=dir.getCanonicalFile();
}
/* ------------------------------------------------------------ */
public File getStoreDirectory ()
{
return _storeDir;
}
/* ------------------------------------------------------------ */
public void setLazyLoad(boolean lazyLoad)
{
_lazyLoad = lazyLoad;
}
/* ------------------------------------------------------------ */
public boolean isLazyLoad()
{
return _lazyLoad;
}
/* ------------------------------------------------------------ */
public boolean isDeleteUnrestorableSessions()
{
return _deleteUnrestorableSessions;
}
/* ------------------------------------------------------------ */
public void setDeleteUnrestorableSessions(boolean deleteUnrestorableSessions)
{
_deleteUnrestorableSessions = deleteUnrestorableSessions;
}
/* ------------------------------------------------------------ */
public void restoreSessions () throws Exception
{
_sessionsLoaded = true;
if (_storeDir==null || !_storeDir.exists())
{
return;
}
if (!_storeDir.canRead())
{
LOG.warn ("Unable to restore Sessions: Cannot read from Session storage directory "+_storeDir.getAbsolutePath());
return;
}
String[] files = _storeDir.list();
for (int i=0;files!=null&&i<files.length;i++)
{
restoreSession(files[i]);
}
}
/* ------------------------------------------------------------ */
protected synchronized HashedSession restoreSession(String idInCuster)
{
File file = new File(_storeDir,idInCuster);
Exception error = null;
if (!file.exists())
{
if (LOG.isDebugEnabled())
{
LOG.debug("Not loading: {}",file);
}
return null;
}
try (FileInputStream in = new FileInputStream(file))
{
HashedSession session = restoreSession(in,null);
addSession(session,false);
session.didActivate();
return session;
}
catch (Exception e)
{
error = e;
}
finally
{
if (error != null)
{
if (isDeleteUnrestorableSessions() && file.exists() && file.getParentFile().equals(_storeDir) )
{
file.delete();
LOG.warn("Deleting file for unrestorable session {} {}",idInCuster,error);
__log.debug(error);
}
else
{
__log.warn("Problem restoring session {} {}",idInCuster, error);
__log.debug(error);
}
}
else
{
// delete successfully restored file
file.delete();
}
}
return null;
}
/* ------------------------------------------------------------ */
public void saveSessions(boolean reactivate) throws Exception
{
if (_storeDir==null || !_storeDir.exists())
{
return;
}
if (!_storeDir.canWrite())
{
LOG.warn ("Unable to save Sessions: Session persistence storage directory "+_storeDir.getAbsolutePath()+ " is not writeable");
return;
}
for (HashedSession session : _sessions.values())
session.save(reactivate);
}
/* ------------------------------------------------------------ */
public HashedSession restoreSession (InputStream is, HashedSession session) throws Exception
{
DataInputStream di = new DataInputStream(is);
String clusterId = di.readUTF();
di.readUTF(); // nodeId
long created = di.readLong();
long accessed = di.readLong();
int requests = di.readInt();
if (session == null)
session = (HashedSession)newSession(created, accessed, clusterId);
session.setRequests(requests);
// Attributes
int size = di.readInt();
restoreSessionAttributes(di, size, session);
try
{
int maxIdle = di.readInt();
session.setMaxInactiveInterval(maxIdle);
}
catch (IOException e)
{
LOG.debug("No maxInactiveInterval persisted for session "+clusterId);
LOG.ignore(e);
}
return session;
}
@SuppressWarnings("resource")
private void restoreSessionAttributes (InputStream is, int size, HashedSession session)
throws Exception
{
if (size>0)
{
// input stream should not be closed here
ClassLoadingObjectInputStream ois = new ClassLoadingObjectInputStream(is);
for (int i=0; i<size;i++)
{
String key = ois.readUTF();
Object value = ois.readObject();
session.setAttribute(key,value);
}
}
}
}

286
jetty-server/src/main/java/org/eclipse/jetty/server/session/HashedSession.java
View File

@ -1,286 +0,0 @@
//
// ========================================================================
// 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 java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.util.Enumeration;
import javax.servlet.http.HttpServletRequest;
import org.eclipse.jetty.util.IO;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
public class HashedSession extends MemSession
{
private static final Logger LOG = Log.getLogger(HashedSession.class);
private final HashSessionManager _hashSessionManager;
/** Whether the session has been saved because it has been deemed idle;
* in which case its attribute map will have been saved and cleared. */
private transient boolean _idled = false;
/** Whether there has already been an attempt to save this session
* which has failed. If there has, there will be no more save attempts
* for this session. This is to stop the logs being flooded with errors
* due to serialization failures that are most likely caused by user
* data stored in the session that is not serializable. */
private transient boolean _saveFailed = false;
/**
* True if an attempt has been made to de-idle a session and it failed. Once
* true, the session will not be attempted to be de-idled again.
*/
private transient boolean _deIdleFailed = false;
/* ------------------------------------------------------------- */
protected HashedSession(HashSessionManager hashSessionManager, HttpServletRequest request)
{
super(hashSessionManager,request);
_hashSessionManager = hashSessionManager;
}
/* ------------------------------------------------------------- */
protected HashedSession(HashSessionManager hashSessionManager, long created, long accessed, String clusterId)
{
super(hashSessionManager,created, accessed, clusterId);
_hashSessionManager = hashSessionManager;
}
/* ------------------------------------------------------------- */
protected void checkValid()
{
if (!_deIdleFailed && _hashSessionManager._idleSavePeriodMs!=0)
deIdle();
super.checkValid();
}
/* ------------------------------------------------------------- */
@Override
public void setMaxInactiveInterval(int secs)
{
super.setMaxInactiveInterval(secs);
if (getMaxInactiveInterval()>0&&(getMaxInactiveInterval()*1000L/10)<_hashSessionManager._scavengePeriodMs)
_hashSessionManager.setScavengePeriod((secs+9)/10);
}
/* ------------------------------------------------------------ */
@Override
protected void doInvalidate()
throws IllegalStateException
{
super.doInvalidate();
remove();
}
/* ------------------------------------------------------------ */
/**
* Remove from the disk
*/
synchronized void remove ()
{
if (_hashSessionManager._storeDir!=null && getId()!=null)
{
String id=getId();
File f = new File(_hashSessionManager._storeDir, id);
f.delete();
}
}
/* ------------------------------------------------------------ */
synchronized void save(boolean reactivate)
throws Exception
{
// Only idle the session if not already idled and no previous save/idle has failed
if (!isIdled() && !_saveFailed)
{
if (LOG.isDebugEnabled())
LOG.debug("Saving {} {}",super.getId(),reactivate);
try
{
willPassivate();
save();
if (reactivate)
didActivate();
else
clearAttributes();
}
catch (Exception e)
{
LOG.warn("Problem saving session " + super.getId(), e);
_idled=false; // assume problem was before _values.clear();
}
}
}
synchronized void save ()
throws Exception
{
File file = null;
if (!_saveFailed && _hashSessionManager._storeDir != null)
{
file = new File(_hashSessionManager._storeDir, super.getId());
if (file.exists())
{
file.delete();
}
try(FileOutputStream fos = new FileOutputStream(file,false))
{
save(fos);
}
catch (Exception e)
{
saveFailed(); // We won't try again for this session
if (file != null)
file.delete(); // No point keeping the file if we didn't save the whole session
throw e;
}
}
}
/* ------------------------------------------------------------ */
public synchronized void save(OutputStream os) throws IOException
{
DataOutputStream out = new DataOutputStream(os);
out.writeUTF(getClusterId());
out.writeUTF(getNodeId());
out.writeLong(getCreationTime());
out.writeLong(getAccessed());
/* Don't write these out, as they don't make sense to store because they
* either they cannot be true or their value will be restored in the
* Session constructor.
*/
//out.writeBoolean(_invalid);
//out.writeBoolean(_doInvalidate);
//out.writeBoolean( _newSession);
out.writeInt(getRequests());
out.writeInt(getAttributes());
ObjectOutputStream oos = new ObjectOutputStream(out);
Enumeration<String> e=getAttributeNames();
while(e.hasMoreElements())
{
String key=e.nextElement();
oos.writeUTF(key);
oos.writeObject(doGet(key));
}
out.writeInt(getMaxInactiveInterval());
}
/* ------------------------------------------------------------ */
public synchronized void deIdle()
{
if (isIdled() && !_deIdleFailed)
{
// Access now to prevent race with idling period
access(System.currentTimeMillis());
if (LOG.isDebugEnabled())
LOG.debug("De-idling " + super.getId());
FileInputStream fis = null;
try
{
File file = new File(_hashSessionManager._storeDir, super.getId());
if (!file.exists() || !file.canRead())
throw new FileNotFoundException(file.getName());
fis = new FileInputStream(file);
_idled = false;
_hashSessionManager.restoreSession(fis, this);
IO.close(fis);
didActivate();
// If we are doing period saves, then there is no point deleting at this point
if (_hashSessionManager._savePeriodMs == 0)
file.delete();
}
catch (Exception e)
{
deIdleFailed();
LOG.warn("Problem de-idling session " + super.getId(), e);
if (fis != null) IO.close(fis);//Must ensure closed before invalidate
invalidate();
}
}
}
/* ------------------------------------------------------------ */
/**
* Idle the session to reduce session memory footprint.
*
* The session is idled by persisting it, then clearing the session values attribute map and finally setting
* it to an idled state.
* @throws Exception if unable to save session
*/
public synchronized void idle()
throws Exception
{
save(false);
_idled = true;
}
/* ------------------------------------------------------------ */
public synchronized boolean isIdled()
{
return _idled;
}
/* ------------------------------------------------------------ */
public synchronized boolean isSaveFailed()
{
return _saveFailed;
}
/* ------------------------------------------------------------ */
public synchronized void saveFailed()
{
_saveFailed = true;
}
/* ------------------------------------------------------------ */
public synchronized void deIdleFailed()
{
_deIdleFailed = true;
}
/* ------------------------------------------------------------ */
public synchronized boolean isDeIdleFailed()
{
return _deIdleFailed;
}
}

12
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/JDBCSessionDataStore.java → jetty-server/src/main/java/org/eclipse/jetty/server/session/JDBCSessionDataStore.java
View File

@ -17,7 +17,7 @@
//
package org.eclipse.jetty.server.session.x;
package org.eclipse.jetty.server.session;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
@ -522,7 +522,7 @@ public class JDBCSessionDataStore extends AbstractSessionDataStore
/**
* @see org.eclipse.jetty.server.session.x.SessionDataStore#newSessionData(org.eclipse.jetty.server.session.x.SessionKey, long, long, long, long)
* @see org.eclipse.jetty.server.session.SessionDataStore#newSessionData(org.eclipse.jetty.server.session.SessionKey, long, long, long, long)
*/
@Override
public SessionData newSessionData(SessionKey key, long created, long accessed, long lastAccessed, long maxInactiveMs)
@ -576,7 +576,7 @@ public class JDBCSessionDataStore extends AbstractSessionDataStore
/**
* @see org.eclipse.jetty.server.session.x.SessionDataStore#load(org.eclipse.jetty.server.session.x.SessionKey)
* @see org.eclipse.jetty.server.session.SessionDataStore#load(org.eclipse.jetty.server.session.SessionKey)
*/
@Override
public SessionData load(SessionKey key) throws Exception
@ -645,7 +645,7 @@ public class JDBCSessionDataStore extends AbstractSessionDataStore
/**
* @see org.eclipse.jetty.server.session.x.SessionDataStore#delete(java.lang.String)
* @see org.eclipse.jetty.server.session.SessionDataStore#delete(java.lang.String)
*/
@Override
public boolean delete(SessionKey key) throws Exception
@ -665,7 +665,7 @@ public class JDBCSessionDataStore extends AbstractSessionDataStore
/**
* @see org.eclipse.jetty.server.session.x.AbstractSessionDataStore#doStore()
* @see org.eclipse.jetty.server.session.AbstractSessionDataStore#doStore()
*/
@Override
public void doStore(SessionKey key, SessionData data) throws Exception
@ -776,7 +776,7 @@ public class JDBCSessionDataStore extends AbstractSessionDataStore
/**
* @see org.eclipse.jetty.server.session.x.SessionDataStore#getExpired()
* @see org.eclipse.jetty.server.session.SessionDataStore#getExpired()
*/
@Override
public Set<SessionKey> getExpired(Set<SessionKey> candidates)

1333
jetty-server/src/main/java/org/eclipse/jetty/server/session/JDBCSessionIdManager.java
View File

File diff suppressed because it is too large Load Diff

1151
jetty-server/src/main/java/org/eclipse/jetty/server/session/JDBCSessionManager.java
View File

File diff suppressed because it is too large Load Diff

146
jetty-server/src/main/java/org/eclipse/jetty/server/session/MemSession.java
View File

@ -1,146 +0,0 @@
//
// ========================================================================
// 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 java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.servlet.http.HttpServletRequest;
/**
* MemSession
*
* A session whose data is kept in memory
*/
public class MemSession extends AbstractSession
{
private final Map<String,Object> _attributes=new HashMap<String, Object>();
protected MemSession(AbstractSessionManager abstractSessionManager, HttpServletRequest request)
{
super(abstractSessionManager, request);
}
public MemSession(AbstractSessionManager abstractSessionManager, long created, long accessed, String clusterId)
{
super(abstractSessionManager, created, accessed, clusterId);
}
/* ------------------------------------------------------------- */
@Override
public Map<String,Object> getAttributeMap()
{
return _attributes;
}
/* ------------------------------------------------------------ */
@Override
public int getAttributes()
{
synchronized (this)
{
checkValid();
return _attributes.size();
}
}
/* ------------------------------------------------------------ */
@SuppressWarnings({ "unchecked" })
@Override
public Enumeration<String> doGetAttributeNames()
{
List<String> names=_attributes==null?Collections.EMPTY_LIST:new ArrayList<String>(_attributes.keySet());
return Collections.enumeration(names);
}
/* ------------------------------------------------------------ */
@Override
public Set<String> getNames()
{
synchronized (this)
{
return new HashSet<String>(_attributes.keySet());
}
}
/* ------------------------------------------------------------- */
@Override
public void clearAttributes()
{
while (_attributes!=null && _attributes.size()>0)
{
ArrayList<String> keys;
synchronized(this)
{
keys=new ArrayList<String>(_attributes.keySet());
}
Iterator<String> iter=keys.iterator();
while (iter.hasNext())
{
String key=(String)iter.next();
Object value;
synchronized(this)
{
value=doPutOrRemove(key,null);
}
unbindValue(key,value);
((AbstractSessionManager)getSessionManager()).doSessionAttributeListeners(this,key,value,null);
}
}
if (_attributes!=null)
_attributes.clear();
}
/* ------------------------------------------------------------ */
public void addAttributes(Map<String,Object> map)
{
_attributes.putAll(map);
}
/* ------------------------------------------------------------ */
@Override
public Object doPutOrRemove(String name, Object value)
{
return value==null?_attributes.remove(name):_attributes.put(name,value);
}
/* ------------------------------------------------------------ */
@Override
public Object doGet(String name)
{
return _attributes.get(name);
}
}

14
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/MemorySessionStore.java → jetty-server/src/main/java/org/eclipse/jetty/server/session/MemorySessionStore.java
View File

@ -17,7 +17,7 @@
//
package org.eclipse.jetty.server.session.x;
package org.eclipse.jetty.server.session;
import java.util.HashSet;
import java.util.Set;
@ -82,7 +82,7 @@ public class MemorySessionStore extends AbstractSessionStore
/**
* @see org.eclipse.jetty.server.session.x.AbstractSessionStore#doGet(java.lang.String)
* @see org.eclipse.jetty.server.session.AbstractSessionStore#doGet(java.lang.String)
*/
@Override
public Session doGet(SessionKey key)
@ -101,7 +101,7 @@ public class MemorySessionStore extends AbstractSessionStore
/**
* @see org.eclipse.jetty.server.session.x.AbstractSessionStore#doPut(java.lang.String, org.eclipse.jetty.server.session.x.Session)
* @see org.eclipse.jetty.server.session.AbstractSessionStore#doPut(java.lang.String, org.eclipse.jetty.server.session.Session)
*/
@Override
public void doPut(SessionKey key, Session session)
@ -110,7 +110,7 @@ public class MemorySessionStore extends AbstractSessionStore
}
/**
* @see org.eclipse.jetty.server.session.x.AbstractSessionStore#doExists(java.lang.String)
* @see org.eclipse.jetty.server.session.AbstractSessionStore#doExists(java.lang.String)
*/
@Override
public boolean doExists(SessionKey key)
@ -119,7 +119,7 @@ public class MemorySessionStore extends AbstractSessionStore
}
/**
* @see org.eclipse.jetty.server.session.x.AbstractSessionStore#doDelete(java.lang.String)
* @see org.eclipse.jetty.server.session.AbstractSessionStore#doDelete(java.lang.String)
*/
@Override
public void doDelete(SessionKey key)
@ -194,7 +194,7 @@ public class MemorySessionStore extends AbstractSessionStore
/**
* @see org.eclipse.jetty.server.session.x.SessionStore#newSession(java.lang.String)
* @see org.eclipse.jetty.server.session.SessionStore#newSession(java.lang.String)
*/
@Override
public Session newSession(SessionKey key, long created, long accessed, long lastAccessed, long maxInactiveMs)
@ -206,7 +206,7 @@ public class MemorySessionStore extends AbstractSessionStore
/**
* @see org.eclipse.jetty.server.session.x.AbstractSessionStore#newSession(org.eclipse.jetty.server.session.x.SessionData)
* @see org.eclipse.jetty.server.session.AbstractSessionStore#newSession(org.eclipse.jetty.server.session.SessionData)
*/
@Override
public Session newSession(SessionData data)

4
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/NeverStaleStrategy.java → jetty-server/src/main/java/org/eclipse/jetty/server/session/NeverStaleStrategy.java
View File

@ -17,7 +17,7 @@
//
package org.eclipse.jetty.server.session.x;
package org.eclipse.jetty.server.session;
/**
* NeverStale
@ -28,7 +28,7 @@ public class NeverStaleStrategy implements StalenessStrategy
{
/**
* @see org.eclipse.jetty.server.session.x.StalenessStrategy#isStale(org.eclipse.jetty.server.session.x.Session)
* @see org.eclipse.jetty.server.session.StalenessStrategy#isStale(org.eclipse.jetty.server.session.Session)
*/
@Override
public boolean isStale(Session session)

13
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/NullSessionDataStore.java → jetty-server/src/main/java/org/eclipse/jetty/server/session/NullSessionDataStore.java
View File

@ -17,9 +17,8 @@
//
package org.eclipse.jetty.server.session.x;
package org.eclipse.jetty.server.session;
import java.util.Collections;
import java.util.Set;
/**
@ -31,7 +30,7 @@ public class NullSessionDataStore extends AbstractSessionDataStore
{
/**
* @see org.eclipse.jetty.server.session.x.SessionDataStore#load(java.lang.String)
* @see org.eclipse.jetty.server.session.SessionDataStore#load(java.lang.String)
*/
@Override
public SessionData load(SessionKey key) throws Exception
@ -41,7 +40,7 @@ public class NullSessionDataStore extends AbstractSessionDataStore
/**
* @see org.eclipse.jetty.server.session.x.SessionDataStore#newSessionData(org.eclipse.jetty.server.session.x.SessionKey, long, long, long, long)
* @see org.eclipse.jetty.server.session.SessionDataStore#newSessionData(org.eclipse.jetty.server.session.SessionKey, long, long, long, long)
*/
@Override
public SessionData newSessionData(SessionKey key, long created, long accessed, long lastAccessed, long maxInactiveMs)
@ -50,7 +49,7 @@ public class NullSessionDataStore extends AbstractSessionDataStore
}
/**
* @see org.eclipse.jetty.server.session.x.SessionDataStore#delete(java.lang.String)
* @see org.eclipse.jetty.server.session.SessionDataStore#delete(java.lang.String)
*/
@Override
public boolean delete(SessionKey key) throws Exception
@ -59,7 +58,7 @@ public class NullSessionDataStore extends AbstractSessionDataStore
}
/**
* @see org.eclipse.jetty.server.session.x.AbstractSessionDataStore#doStore()
* @see org.eclipse.jetty.server.session.AbstractSessionDataStore#doStore()
*/
@Override
public void doStore(SessionKey key, SessionData data) throws Exception
@ -68,7 +67,7 @@ public class NullSessionDataStore extends AbstractSessionDataStore
}
/**
* @see org.eclipse.jetty.server.session.x.SessionDataStore#getExpired()
* @see org.eclipse.jetty.server.session.SessionDataStore#getExpired()
*/
@Override
public Set<SessionKey> getExpired(Set<SessionKey> candidates)

10
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/Session.java → jetty-server/src/main/java/org/eclipse/jetty/server/session/Session.java
View File

@ -17,7 +17,7 @@
//
package org.eclipse.jetty.server.session.x;
package org.eclipse.jetty.server.session;
import java.util.ArrayList;
import java.util.Enumeration;
@ -32,6 +32,7 @@ import javax.servlet.http.HttpSessionBindingListener;
import javax.servlet.http.HttpSessionContext;
import javax.servlet.http.HttpSessionEvent;
import org.eclipse.jetty.server.session.SessionManager.SessionIf;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
@ -387,6 +388,13 @@ public class Session implements SessionManager.SessionIf
return SessionManager.__nullSessionContext;
}
public SessionManager getSessionManager()
{
return _manager;
}
/* ------------------------------------------------------------- */
/**
* asserts that the session is valid

2
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/SessionData.java → jetty-server/src/main/java/org/eclipse/jetty/server/session/SessionData.java
View File

@ -17,7 +17,7 @@
//
package org.eclipse.jetty.server.session.x;
package org.eclipse.jetty.server.session;
import java.io.IOException;
import java.io.Serializable;

2
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/SessionDataStore.java → jetty-server/src/main/java/org/eclipse/jetty/server/session/SessionDataStore.java
View File

@ -17,7 +17,7 @@
//
package org.eclipse.jetty.server.session.x;
package org.eclipse.jetty.server.session;
import java.util.Set;

2
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/SessionKey.java → jetty-server/src/main/java/org/eclipse/jetty/server/session/SessionKey.java
View File

@ -17,7 +17,7 @@
//
package org.eclipse.jetty.server.session.x;
package org.eclipse.jetty.server.session;
import org.eclipse.jetty.server.handler.ContextHandler.Context;

10
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/SessionManager.java → jetty-server/src/main/java/org/eclipse/jetty/server/session/SessionManager.java
View File

@ -17,7 +17,7 @@
//
package org.eclipse.jetty.server.session.x;
package org.eclipse.jetty.server.session;
import static java.lang.Math.round;
@ -46,8 +46,6 @@ import org.eclipse.jetty.http.HttpCookie;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.SessionIdManager;
import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.server.session.HashSessionIdManager;
import org.eclipse.jetty.server.session.SessionHandler;
import org.eclipse.jetty.util.StringUtil;
import org.eclipse.jetty.util.annotation.ManagedAttribute;
import org.eclipse.jetty.util.annotation.ManagedOperation;
@ -507,7 +505,7 @@ public class SessionManager extends ContainerLifeCycle implements org.eclipse.je
{
String sessionPath = (_cookieConfig.getPath()==null) ? contextPath : _cookieConfig.getPath();
sessionPath = (sessionPath==null||sessionPath.length()==0) ? "/" : sessionPath;
String id = getNodeId(session);
String id = getExtendedId(session);
HttpCookie cookie = null;
if (_sessionComment == null)
{
@ -596,7 +594,7 @@ public class SessionManager extends ContainerLifeCycle implements org.eclipse.je
/* ------------------------------------------------------------ */
@Override
public String getClusterId(HttpSession session)
public String getId(HttpSession session)
{
Session s = ((SessionIf)session).getSession();
return s.getId();
@ -604,7 +602,7 @@ public class SessionManager extends ContainerLifeCycle implements org.eclipse.je
/* ------------------------------------------------------------ */
@Override
public String getNodeId(HttpSession session)
public String getExtendedId(HttpSession session)
{
Session s = ((SessionIf)session).getSession();
return s.getExtendedId();

4
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/SessionScavenger.java → jetty-server/src/main/java/org/eclipse/jetty/server/session/SessionScavenger.java
View File

@ -17,16 +17,14 @@
//
package org.eclipse.jetty.server.session.x;
package org.eclipse.jetty.server.session;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.SessionIdManager;
import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.server.session.SessionHandler;
import org.eclipse.jetty.util.component.AbstractLifeCycle;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;

2
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/SessionStore.java → jetty-server/src/main/java/org/eclipse/jetty/server/session/SessionStore.java
View File

@ -17,7 +17,7 @@
//
package org.eclipse.jetty.server.session.x;
package org.eclipse.jetty.server.session;
import java.util.Set;

4
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/StalePeriodStrategy.java → jetty-server/src/main/java/org/eclipse/jetty/server/session/StalePeriodStrategy.java
View File

@ -17,7 +17,7 @@
//
package org.eclipse.jetty.server.session.x;
package org.eclipse.jetty.server.session;
/**
* StalePeriodStrategy
@ -29,7 +29,7 @@ public class StalePeriodStrategy implements StalenessStrategy
protected long _staleMs = 0;
/**
* @see org.eclipse.jetty.server.session.x.StalenessStrategy#isStale(org.eclipse.jetty.server.session.x.Session)
* @see org.eclipse.jetty.server.session.StalenessStrategy#isStale(org.eclipse.jetty.server.session.Session)
*/
@Override
public boolean isStale (Session session)

2
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/StalenessStrategy.java → jetty-server/src/main/java/org/eclipse/jetty/server/session/StalenessStrategy.java
View File

@ -17,7 +17,7 @@
//
package org.eclipse.jetty.server.session.x;
package org.eclipse.jetty.server.session;
/**
* StalenessStrategy

2
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/UnreadableSessionDataException.java → jetty-server/src/main/java/org/eclipse/jetty/server/session/UnreadableSessionDataException.java
View File

@ -17,7 +17,7 @@
//
package org.eclipse.jetty.server.session.x;
package org.eclipse.jetty.server.session;
/**
* UnreadableSessionData

2
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/UnwriteableSessionDataException.java → jetty-server/src/main/java/org/eclipse/jetty/server/session/UnwriteableSessionDataException.java
View File

@ -17,7 +17,7 @@
//
package org.eclipse.jetty.server.session.x;
package org.eclipse.jetty.server.session;
/**
* UnwriteableSessionDataException

10
jetty-server/src/main/java/org/eclipse/jetty/server/session/jmx/AbstractSessionManagerMBean.java → jetty-server/src/main/java/org/eclipse/jetty/server/session/jmx/SessionManagerMBean.java
View File

@ -21,12 +21,12 @@ package org.eclipse.jetty.server.session.jmx;
import org.eclipse.jetty.server.handler.AbstractHandlerContainer;
import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.server.handler.jmx.AbstractHandlerMBean;
import org.eclipse.jetty.server.session.AbstractSessionManager;
import org.eclipse.jetty.server.session.SessionManager;
import org.eclipse.jetty.server.session.SessionHandler;
public class AbstractSessionManagerMBean extends AbstractHandlerMBean
public class SessionManagerMBean extends AbstractHandlerMBean
{
public AbstractSessionManagerMBean(Object managedObject)
public SessionManagerMBean(Object managedObject)
{
super(managedObject);
}
@ -34,9 +34,9 @@ public class AbstractSessionManagerMBean extends AbstractHandlerMBean
/* ------------------------------------------------------------ */
public String getObjectContextBasis()
{
if (_managed != null && _managed instanceof AbstractSessionManager)
if (_managed != null && _managed instanceof SessionManager)
{
AbstractSessionManager manager = (AbstractSessionManager)_managed;
SessionManager manager = (SessionManager)_managed;
String basis = null;
SessionHandler handler = manager.getSessionHandler();

393
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/AbstractSessionIdManager.java
View File

@ -1,393 +0,0 @@
//
// ========================================================================
// 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.x;
import java.security.SecureRandom;
import java.util.Random;
import javax.servlet.http.HttpServletRequest;
import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.SessionIdManager;
import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.server.session.SessionHandler;
import org.eclipse.jetty.util.component.AbstractLifeCycle;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
public abstract class AbstractSessionIdManager extends AbstractLifeCycle implements SessionIdManager
{
private static final Logger LOG = Log.getLogger(AbstractSessionIdManager.class);
private final static String __NEW_SESSION_ID="org.eclipse.jetty.server.newSessionId";
protected Random _random;
protected boolean _weakRandom;
protected String _workerName;
protected String _workerAttr;
protected long _reseed=100000L;
protected Server _server;
protected SessionScavenger _scavenger;
/* ------------------------------------------------------------ */
public AbstractSessionIdManager()
{
}
/* ------------------------------------------------------------ */
public AbstractSessionIdManager(Random random)
{
_random=random;
}
public void setServer (Server server)
{
_server = server;
}
public Server getServer ()
{
return _server;
}
public void setSessionScavenger (SessionScavenger scavenger)
{
_scavenger = scavenger;
_scavenger.setSessionIdManager(this);
}
/* ------------------------------------------------------------ */
/**
* Get the workname. If set, the workername is dot appended to the session
* ID and can be used to assist session affinity in a load balancer.
*
* @return String or null
*/
@Override
public String getWorkerName()
{
return _workerName;
}
/* ------------------------------------------------------------ */
/**
* Set the workername. If set, the workername is dot appended to the session
* ID and can be used to assist session affinity in a load balancer.
* A worker name starting with $ is used as a request attribute name to
* lookup the worker name that can be dynamically set by a request
* Customizer.
*
* @param workerName the name of the worker
*/
public void setWorkerName(String workerName)
{
if (isRunning())
throw new IllegalStateException(getState());
if (workerName.contains("."))
throw new IllegalArgumentException("Name cannot contain '.'");
_workerName=workerName;
}
/* ------------------------------------------------------------ */
public Random getRandom()
{
return _random;
}
/* ------------------------------------------------------------ */
public synchronized void setRandom(Random random)
{
_random=random;
_weakRandom=false;
}
/* ------------------------------------------------------------ */
/**
* @return the reseed probability
*/
public long getReseed()
{
return _reseed;
}
/* ------------------------------------------------------------ */
/** Set the reseed probability.
* @param reseed If non zero then when a random long modulo the reseed value == 1, the {@link SecureRandom} will be reseeded.
*/
public void setReseed(long reseed)
{
_reseed = reseed;
}
/* ------------------------------------------------------------ */
/**
* Create a new session id if necessary.
*
* @see org.eclipse.jetty.server.SessionIdManager#newSessionId(javax.servlet.http.HttpServletRequest, long)
*/
@Override
public String newSessionId(HttpServletRequest request, long created)
{
synchronized (this)
{
if (request==null)
return newSessionId(created);
// A requested session ID can only be used if it is in use already.
String requested_id=request.getRequestedSessionId();
if (requested_id!=null)
{
String cluster_id=getId(requested_id);
if (isIdInUse(cluster_id))
return cluster_id;
}
// Else reuse any new session ID already defined for this request.
String new_id=(String)request.getAttribute(__NEW_SESSION_ID);
if (new_id!=null&&isIdInUse(new_id))
return new_id;
// pick a new unique ID!
String id = newSessionId(request.hashCode());
request.setAttribute(__NEW_SESSION_ID,id);
return id;
}
}
/* ------------------------------------------------------------ */
public String newSessionId(long seedTerm)
{
// pick a new unique ID!
String id=null;
while (id==null||id.length()==0||isIdInUse(id))
{
long r0=_weakRandom
?(hashCode()^Runtime.getRuntime().freeMemory()^_random.nextInt()^((seedTerm)<<32))
:_random.nextLong();
if (r0<0)
r0=-r0;
// random chance to reseed
if (_reseed>0 && (r0%_reseed)== 1L)
{
if (LOG.isDebugEnabled())
LOG.debug("Reseeding {}",this);
if (_random instanceof SecureRandom)
{
SecureRandom secure = (SecureRandom)_random;
secure.setSeed(secure.generateSeed(8));
}
else
{
_random.setSeed(_random.nextLong()^System.currentTimeMillis()^seedTerm^Runtime.getRuntime().freeMemory());
}
}
long r1=_weakRandom
?(hashCode()^Runtime.getRuntime().freeMemory()^_random.nextInt()^((seedTerm)<<32))
:_random.nextLong();
if (r1<0)
r1=-r1;
id=Long.toString(r0,36)+Long.toString(r1,36);
//add in the id of the node to ensure unique id across cluster
//NOTE this is different to the node suffix which denotes which node the request was received on
if (_workerName!=null)
id=_workerName + id;
}
return id;
}
/* ------------------------------------------------------------ */
@Override
protected void doStart() throws Exception
{
if (_server == null)
throw new IllegalStateException("No Server for SessionIdManager");
initRandom();
_workerAttr=(_workerName!=null && _workerName.startsWith("$"))?_workerName.substring(1):null;
if (_scavenger == null)
{
LOG.warn("No SessionScavenger set, using defaults");
_scavenger = new SessionScavenger();
_scavenger.setSessionIdManager(this);
}
_scavenger.start();
}
/* ------------------------------------------------------------ */
@Override
protected void doStop() throws Exception
{
_scavenger.stop();
}
/* ------------------------------------------------------------ */
/**
* Set up a random number generator for the sessionids.
*
* By preference, use a SecureRandom but allow to be injected.
*/
public void initRandom ()
{
if (_random==null)
{
try
{
_random=new SecureRandom();
}
catch (Exception e)
{
LOG.warn("Could not generate SecureRandom for session-id randomness",e);
_random=new Random();
_weakRandom=true;
}
}
else
_random.setSeed(_random.nextLong()^System.currentTimeMillis()^hashCode()^Runtime.getRuntime().freeMemory());
}
/** Get the session ID with any worker ID.
*
* @param clusterId the cluster id
* @param request the request
* @return sessionId plus any worker ID.
*/
@Override
public String getExtendedId(String clusterId, HttpServletRequest request)
{
if (_workerName!=null)
{
if (_workerAttr==null)
return clusterId+'.'+_workerName;
String worker=(String)request.getAttribute(_workerAttr);
if (worker!=null)
return clusterId+'.'+worker;
}
return clusterId;
}
/** Get the session ID without any worker ID.
*
* @param extendedId the session id with the worker extension
* @return sessionId without any worker ID.
*/
@Override
public String getId(String extendedId)
{
int dot=extendedId.lastIndexOf('.');
return (dot>0)?extendedId.substring(0,dot):extendedId;
}
/**
* Remove an id from use by telling all contexts to remove a session with this id.
*
* @see org.eclipse.jetty.server.SessionIdManager#expireAll(java.lang.String)
*/
@Override
public void expireAll(String id)
{
//take the id out of the list of known sessionids for this node
removeId(id);
//tell all contexts that may have a session object with this id to
//get rid of them
Handler[] contexts = _server.getChildHandlersByClass(ContextHandler.class);
for (int i=0; contexts!=null && i<contexts.length; i++)
{
SessionHandler sessionHandler = ((ContextHandler)contexts[i]).getChildHandlerByClass(SessionHandler.class);
if (sessionHandler != null)
{
SessionManager manager = (SessionManager)sessionHandler.getSessionManager();
if (manager != null)
{
manager.invalidate(id);
}
}
}
}
public void invalidateAll (String id)
{
//take the id out of the list of known sessionids for this node
removeId(id);
//tell all contexts that may have a session object with this id to
//get rid of them
Handler[] contexts = _server.getChildHandlersByClass(ContextHandler.class);
for (int i=0; contexts!=null && i<contexts.length; i++)
{
SessionHandler sessionHandler = ((ContextHandler)contexts[i]).getChildHandlerByClass(SessionHandler.class);
if (sessionHandler != null)
{
SessionManager manager = (SessionManager)sessionHandler.getSessionManager();
if (manager != null)
{
manager.invalidate(id);
}
}
}
}
/**
* @see org.eclipse.jetty.server.SessionIdManager#renewSessionId(java.lang.String, java.lang.String, javax.servlet.http.HttpServletRequest)
*/
@Override
public void renewSessionId (String oldClusterId, String oldNodeId, HttpServletRequest request)
{
//generate a new id
String newClusterId = newSessionId(request.hashCode());
removeId(oldClusterId);//remove the old one from the list (and database)
//tell all contexts to update the id
Handler[] contexts = _server.getChildHandlersByClass(ContextHandler.class);
for (int i=0; contexts!=null && i<contexts.length; i++)
{
SessionHandler sessionHandler = ((ContextHandler)contexts[i]).getChildHandlerByClass(SessionHandler.class);
if (sessionHandler != null)
{
SessionManager manager = (SessionManager)sessionHandler.getSessionManager();
if (manager != null)
{
manager.renewSessionId(oldClusterId, oldNodeId, newClusterId, getExtendedId(newClusterId, request));
}
}
}
}
}

79
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/HashSessionIdManager.java
View File

@ -1,79 +0,0 @@
//
// ========================================================================
// 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.x;
import java.util.Set;
import org.eclipse.jetty.util.ConcurrentHashSet;
/**
* HashSessionIdManager
*
*
*/
public class HashSessionIdManager extends AbstractSessionIdManager
{
private final Set<String> _ids = new ConcurrentHashSet<String>();
/**
* @see org.eclipse.jetty.server.SessionIdManager#isIdInUse(java.lang.String)
*/
@Override
public boolean isIdInUse(String id)
{
return _ids.contains(id);
}
/**
* @see org.eclipse.jetty.server.session.x.AbstractSessionIdManager#newSessionId(long)
*/
@Override
public String newSessionId(long seedTerm)
{
String id = super.newSessionId(seedTerm);
useId(id);
return id;
}
/**
* @see org.eclipse.jetty.server.SessionIdManager#useId(java.lang.String)
*/
@Override
public void useId(String id)
{
if (id == null)
return;
_ids.add(id);
}
/**
* @see org.eclipse.jetty.server.SessionIdManager#removeId(java.lang.String)
*/
@Override
public void removeId(String id)
{
_ids.remove(id);
}
}

56
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/HashSessionManager.java
View File

@ -1,56 +0,0 @@
//
// ========================================================================
// 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.x;
/**
* HashSessionManager
*
*
*/
public class HashSessionManager extends SessionManager
{
protected FileSessionDataStore _sessionDataStore = new FileSessionDataStore();
@Override
public void doStart() throws Exception
{
_sessionStore = new MemorySessionStore();
((AbstractSessionStore)_sessionStore).setSessionDataStore(_sessionDataStore);
super.doStart();
}
@Override
public void doStop() throws Exception
{
super.doStop();
}
/**
* Get the SessionDataStore to configure it
* @return
*/
public FileSessionDataStore getSessionDataStore()
{
return _sessionDataStore;
}
}

439
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/JDBCSessionIdManager.java
View File

@ -1,439 +0,0 @@
//
// ========================================================================
// 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.x;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.sql.Blob;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.HashSet;
import java.util.Locale;
import java.util.Random;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import javax.naming.InitialContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import javax.sql.DataSource;
import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.SessionManager;
import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.server.session.SessionHandler;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
import org.eclipse.jetty.util.thread.ScheduledExecutorScheduler;
import org.eclipse.jetty.util.thread.Scheduler;
/**
* JDBCSessionIdManager
*
* SessionIdManager implementation that uses a database to store in-use session ids,
* to support distributed sessions.
*
*/
public class JDBCSessionIdManager extends org.eclipse.jetty.server.session.x.AbstractSessionIdManager
{
private final static Logger LOG = Log.getLogger("org.eclipse.jetty.server.session");
public final static int MAX_INTERVAL_NOT_SET = -999;
protected final HashSet<String> _sessionIds = new HashSet<String>();
protected Server _server;
protected SessionScavenger _scavenger;
private DatabaseAdaptor _dbAdaptor = new DatabaseAdaptor();
protected SessionIdTableSchema _sessionIdTableSchema = new SessionIdTableSchema();
/**
* SessionIdTableSchema
*
*/
public static class SessionIdTableSchema
{
protected String _tableName = "JettySessionIds";
protected String _idColumn = "id";
protected DatabaseAdaptor _jdbc;
public String getIdColumn()
{
return _idColumn;
}
public void setIdColumn(String idColumn)
{
checkNotNull(idColumn);
_idColumn = idColumn;
}
public String getTableName()
{
return _tableName;
}
public void setTableName(String tableName)
{
checkNotNull(tableName);
_tableName = tableName;
}
public String getInsertStatementAsString ()
{
return "insert into "+_tableName+" ("+_idColumn+") values (?)";
}
public String getDeleteStatementAsString ()
{
return "delete from "+_tableName+" where "+_idColumn+" = ?";
}
public String getSelectStatementAsString ()
{
return "select * from "+_tableName+" where "+_idColumn+" = ?";
}
public String getCreateStatementAsString ()
{
return "create table "+_tableName+" ("+_idColumn+" varchar(120), primary key("+_idColumn+"))";
}
protected void prepareTables (DatabaseAdaptor jdbc)
throws Exception
{
_jdbc = jdbc;
try (Connection connection = _jdbc.getConnection();
Statement statement = connection.createStatement())
{
//make the id table
connection.setAutoCommit(true);
DatabaseMetaData metaData = connection.getMetaData();
_jdbc.adaptTo(metaData);
//checking for table existence is case-sensitive, but table creation is not
String tableName = _jdbc.convertIdentifier(getTableName());
try (ResultSet result = metaData.getTables(null, null, tableName, null))
{
if (!result.next())
{
//table does not exist, so create it
statement.executeUpdate(getCreateStatementAsString());
}
}
}
}
private void checkNotNull(String s)
{
if (s == null)
throw new IllegalArgumentException(s);
}
}
public JDBCSessionIdManager(Server server)
{
super();
_server=server;
}
public JDBCSessionIdManager(Server server, Random random)
{
super(random);
_server=server;
}
public SessionIdTableSchema getSessionIdTableSchema()
{
return _sessionIdTableSchema;
}
@Override
public String newSessionId(long seedTerm)
{
String id = super.newSessionId(seedTerm);
useId(id);
return id;
}
/**
* Record the session id as being in use
*
* @see org.eclipse.jetty.server.SessionIdManager#useId(java.lang.String)
*/
public void useId (String id)
{
if (id == null)
return;
synchronized (_sessionIds)
{
try
{
insert(id);
_sessionIds.add(id);
}
catch (Exception e)
{
LOG.warn("Problem storing session id="+id, e);
}
}
}
/**
* Remove the id from in-use set
*
* Prevents another context from using this id
*
* @see org.eclipse.jetty.server.SessionIdManager#removeId(java.lang.String)
*/
@Override
public void removeId (String id)
{
if (id == null)
return;
synchronized (_sessionIds)
{
if (LOG.isDebugEnabled())
LOG.debug("Removing sessionid="+id);
try
{
_sessionIds.remove(id);
delete(id);
}
catch (Exception e)
{
LOG.warn("Problem removing session id="+id, e);
}
}
}
/**
* Insert a new used session id into the table.
*
* @param id
* @throws SQLException
*/
private void insert (String id)
throws SQLException
{
try (Connection connection = _dbAdaptor.getConnection();
PreparedStatement query = connection.prepareStatement(_sessionIdTableSchema.getSelectStatementAsString()))
{
connection.setAutoCommit(true);
query.setString(1, id);
try (ResultSet result = query.executeQuery())
{
//only insert the id if it isn't in the db already
if (!result.next())
{
try (PreparedStatement statement = connection.prepareStatement(_sessionIdTableSchema.getInsertStatementAsString()))
{
statement.setString(1, id);
statement.executeUpdate();
}
}
}
}
}
/**
* Remove a session id from the table.
*
* @param id
* @throws SQLException
*/
private void delete (String id)
throws SQLException
{
try (Connection connection = _dbAdaptor.getConnection();
PreparedStatement statement = connection.prepareStatement(_sessionIdTableSchema.getDeleteStatementAsString()))
{
connection.setAutoCommit(true);
statement.setString(1, id);
statement.executeUpdate();
}
}
/**
* Check if a session id exists.
*
* @param id
* @return
* @throws SQLException
*/
private boolean exists (String id)
throws SQLException
{
try (Connection connection = _dbAdaptor.getConnection();
PreparedStatement statement = connection.prepareStatement(_sessionIdTableSchema.getSelectStatementAsString()))
{
connection.setAutoCommit(true);
statement.setString(1, id);
try (ResultSet result = statement.executeQuery())
{
return result.next();
}
}
}
@Override
public boolean isIdInUse(String id)
{
if (id == null)
return false;
String sessionId = getId(id);
boolean inUse = false;
synchronized (_sessionIds)
{
inUse = _sessionIds.contains(sessionId);
}
if (inUse)
return true; //optimisation - if this session is one we've been managing, we can check locally
//otherwise, we need to go to the database to check
try
{
return exists(sessionId);
}
catch (Exception e)
{
LOG.warn("Problem checking inUse for id="+sessionId, e);
return false;
}
}
/**
* Invalidate the session matching the id on all contexts.
*
* @see org.eclipse.jetty.server.SessionIdManager#expireAll(java.lang.String)
*/
@Override
public void expireAll(String id)
{
synchronized (_sessionIds)
{
super.expireAll(id);
}
}
@Override
public void renewSessionId(String oldClusterId, String oldNodeId, HttpServletRequest request)
{
synchronized (_sessionIds)
{
super.renewSessionId(oldClusterId, oldNodeId, request);
}
}
/**
* Get the database adaptor in order to configure it
* @return
*/
public DatabaseAdaptor getDatabaseAdaptor ()
{
return _dbAdaptor;
}
/**
* Start up the id manager.
*
* Makes necessary database tables and starts a Session
* scavenger thread.
*/
@Override
public void doStart()
throws Exception
{
_dbAdaptor.initialize();
_sessionIdTableSchema.prepareTables(_dbAdaptor);
super.doStart();
}
/**
* Stop
*/
@Override
public void doStop ()
throws Exception
{
_sessionIds.clear();
super.doStop();
}
/**
*
* @param sql
* @param atoms
* @throws Exception
*/
private String fillInClause (String sql, String[] literals, int start, int end)
throws Exception
{
StringBuffer buff = new StringBuffer();
buff.append(sql);
buff.append("(");
for (int i=start; i<end; i++)
{
buff.append("'"+(literals[i])+"'");
if (i+1<end)
buff.append(",");
}
buff.append(")");
return buff.toString();
}
}

71
jetty-server/src/main/java/org/eclipse/jetty/server/session/x/JDBCSessionManager.java
View File

@ -1,71 +0,0 @@
//
// ========================================================================
// 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.x;
/**
* JDBCSessionManager
*
*
*/
public class JDBCSessionManager extends SessionManager
{
protected DatabaseAdaptor _db = new DatabaseAdaptor();
protected JDBCSessionDataStore _sessionDataStore = new JDBCSessionDataStore();
@Override
public void doStart() throws Exception
{
_sessionStore = new MemorySessionStore();
_sessionDataStore.setDatabaseAdaptor(_db);
((AbstractSessionStore)_sessionStore).setSessionDataStore(_sessionDataStore);
super.doStart();
}
@Override
public void doStop() throws Exception
{
super.doStop();
}
/**
* Get the db adaptor to configure jdbc settings
* @return
*/
public DatabaseAdaptor getDatabaseAdaptor()
{
return _db;
}
/**
* Get the SessionDataStore to configure it
* @return
*/
public JDBCSessionDataStore getSessionDataStore ()
{
return _sessionDataStore;
}
}

8
jetty-server/src/test/java/org/eclipse/jetty/server/ResponseTest.java
View File

@ -55,7 +55,8 @@ import org.eclipse.jetty.server.handler.AbstractHandler;
import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.server.session.HashSessionIdManager;
import org.eclipse.jetty.server.session.HashSessionManager;
import org.eclipse.jetty.server.session.HashedSession;
import org.eclipse.jetty.server.session.Session;
import org.eclipse.jetty.server.session.SessionData;
import org.eclipse.jetty.util.Callback;
import org.eclipse.jetty.util.thread.Scheduler;
import org.eclipse.jetty.util.thread.TimerScheduler;
@ -835,11 +836,12 @@ public class ResponseTest
return new Response(_channel, _channel.getResponse().getHttpOutput());
}
private static class TestSession extends HashedSession
private static class TestSession extends Session
{
protected TestSession(HashSessionManager hashSessionManager, String id)
{
super(hashSessionManager, 0L, 0L, id);
super(new SessionData(id, "", "0.0.0.0", 0, 0, 0, 300));
setSessionManager(hashSessionManager);
}
}
}

21
jetty-server/src/test/java/org/eclipse/jetty/server/session/HashSessionManagerTest.java
View File

@ -34,11 +34,11 @@ public class HashSessionManagerTest
public void testDangerousSessionIdRemoval() throws Exception
{
final HashSessionManager manager = new HashSessionManager();
manager.setDeleteUnrestorableSessions(true);
manager.setLazyLoad(true);
manager.getSessionDataStore().setDeleteUnrestorableFiles(true);
//manager.setLazyLoad(true);
File testDir = MavenTestingUtils.getTargetTestingDir("hashes");
testDir.mkdirs();
manager.setStoreDirectory(testDir);
manager.getSessionDataStore().setStoreDir(testDir);
MavenTestingUtils.getTargetFile("dangerFile.session").createNewFile();
@ -54,12 +54,12 @@ public class HashSessionManagerTest
public void testValidSessionIdRemoval() throws Exception
{
final HashSessionManager manager = new HashSessionManager();
manager.setDeleteUnrestorableSessions(true);
manager.setLazyLoad(true);
manager.getSessionDataStore().setDeleteUnrestorableFiles(true);
// manager.setLazyLoad(true);
File testDir = MavenTestingUtils.getTargetTestingDir("hashes");
FS.ensureEmpty(testDir);
manager.setStoreDirectory(testDir);
manager.getSessionDataStore().setStoreDir(testDir);
Assert.assertTrue(new File(testDir, "validFile.session").createNewFile());
@ -81,7 +81,7 @@ public class HashSessionManagerTest
SessionHandler handler = new SessionHandler();
handler.setServer(server);
HashSessionManager manager = new HashSessionManager();
manager.setStoreDirectory(testDir);
manager.getSessionDataStore().setStoreDir(testDir);
manager.setMaxInactiveInterval(5);
Assert.assertTrue(testDir.exists());
Assert.assertTrue(testDir.canWrite());
@ -95,7 +95,7 @@ public class HashSessionManagerTest
server.start();
manager.start();
HashedSession session = (HashedSession)manager.newHttpSession(new Request(null, null));
Session session = (Session)manager.newHttpSession(new Request(null, null));
String sessionId = session.getId();
session.setAttribute("one", new Integer(1));
@ -107,10 +107,11 @@ public class HashSessionManagerTest
Assert.assertTrue("File should exist!", new File(testDir, session.getId()).exists());
//start will restore sessions
manager.start();
HashedSession restoredSession = (HashedSession)manager.getSession(sessionId);
//restore session
Session restoredSession = (Session)manager.getSession(sessionId);
Assert.assertNotNull(restoredSession);
Object o = restoredSession.getAttribute("one");

205
jetty-server/src/test/java/org/eclipse/jetty/server/session/SessionCookieTest.java
View File

@ -37,102 +37,95 @@ import org.junit.Test;
*/
public class SessionCookieTest
{
public class MockSession extends AbstractSession
public class MockSessionStore extends AbstractSessionStore
{
protected MockSession(AbstractSessionManager abstractSessionManager, long created, long accessed, String clusterId)
{
super(abstractSessionManager, created, accessed, clusterId);
}
/**
* @see javax.servlet.http.HttpSession#getAttribute(java.lang.String)
* @see org.eclipse.jetty.server.session.SessionStore#newSession(org.eclipse.jetty.server.session.SessionKey, long, long, long, long)
*/
@Override
public Object getAttribute(String name)
public Session newSession(SessionKey key, long created, long accessed, long lastAccessed, long maxInactiveMs)
{
// TODO Auto-generated method stub
return null;
}
/**
* @see javax.servlet.http.HttpSession#getAttributeNames()
* @see org.eclipse.jetty.server.session.SessionStore#shutdown()
*/
@Override
public Enumeration<String> getAttributeNames()
{
return null;
}
@Override
public String[] getValueNames()
{
return null;
}
/**
* @see org.eclipse.jetty.server.session.AbstractSession#getAttributeMap()
*/
@Override
public Map<String, Object> getAttributeMap()
{
return null;
}
/**
* @see org.eclipse.jetty.server.session.AbstractSession#getAttributes()
*/
@Override
public int getAttributes()
{
return 0;
}
/**
* @see org.eclipse.jetty.server.session.AbstractSession#getNames()
*/
@Override
public Set<String> getNames()
{
return null;
}
/**
* @see org.eclipse.jetty.server.session.AbstractSession#clearAttributes()
*/
@Override
public void clearAttributes()
public void shutdown()
{
// TODO Auto-generated method stub
}
/**
* @see org.eclipse.jetty.server.session.AbstractSession#doPutOrRemove(java.lang.String, java.lang.Object)
* @see org.eclipse.jetty.server.session.AbstractSessionStore#newSession(org.eclipse.jetty.server.session.SessionData)
*/
@Override
public Object doPutOrRemove(String name, Object value)
public Session newSession(SessionData data)
{
// TODO Auto-generated method stub
return null;
}
/**
* @see org.eclipse.jetty.server.session.AbstractSession#doGet(java.lang.String)
* @see org.eclipse.jetty.server.session.AbstractSessionStore#doGet(org.eclipse.jetty.server.session.SessionKey)
*/
@Override
public Object doGet(String name)
public Session doGet(SessionKey key)
{
// TODO Auto-generated method stub
return null;
}
/**
* @see org.eclipse.jetty.server.session.AbstractSession#doGetAttributeNames()
* @see org.eclipse.jetty.server.session.AbstractSessionStore#doPut(org.eclipse.jetty.server.session.SessionKey, org.eclipse.jetty.server.session.Session)
*/
@Override
public Enumeration<String> doGetAttributeNames()
public void doPut(SessionKey key, Session session)
{
return null;
// TODO Auto-generated method stub
}
/**
* @see org.eclipse.jetty.server.session.AbstractSessionStore#doExists(org.eclipse.jetty.server.session.SessionKey)
*/
@Override
public boolean doExists(SessionKey key)
{
// TODO Auto-generated method stub
return false;
}
/**
* @see org.eclipse.jetty.server.session.AbstractSessionStore#doDelete(org.eclipse.jetty.server.session.SessionKey)
*/
@Override
public void doDelete(SessionKey key)
{
// TODO Auto-generated method stub
}
/**
* @see org.eclipse.jetty.server.session.AbstractSessionStore#doGetExpiredCandidates()
*/
@Override
public Set<SessionKey> doGetExpiredCandidates()
{
// TODO Auto-generated method stub
return null;
}
}
public class MockSessionIdManager extends AbstractSessionIdManager
{
@ -145,24 +138,6 @@ public class SessionCookieTest
return false;
}
/**
* @see org.eclipse.jetty.server.SessionIdManager#addSession(javax.servlet.http.HttpSession)
*/
@Override
public void addSession(HttpSession session)
{
}
/**
* @see org.eclipse.jetty.server.SessionIdManager#removeSession(javax.servlet.http.HttpSession)
*/
@Override
public void removeSession(HttpSession session)
{
}
/**
* @see org.eclipse.jetty.server.SessionIdManager#expireAll(java.lang.String)
*/
@ -179,64 +154,37 @@ public class SessionCookieTest
}
}
public class MockSessionManager extends AbstractSessionManager
{
/**
* @see org.eclipse.jetty.server.session.AbstractSessionManager#addSession(org.eclipse.jetty.server.session.AbstractSession)
/**
* @see org.eclipse.jetty.server.SessionIdManager#useId(java.lang.String)
*/
@Override
protected void addSession(AbstractSession session)
{
}
/**
* @see org.eclipse.jetty.server.session.AbstractSessionManager#getSession(java.lang.String)
*/
@Override
public AbstractSession getSession(String idInCluster)
{
return null;
}
/**
* @see org.eclipse.jetty.server.session.AbstractSessionManager#shutdownSessions()
*/
@Override
protected void shutdownSessions() throws Exception
{
}
/**
* @see org.eclipse.jetty.server.session.AbstractSessionManager#newSession(javax.servlet.http.HttpServletRequest)
*/
@Override
protected AbstractSession newSession(HttpServletRequest request)
{
return null;
}
/**
* @see org.eclipse.jetty.server.session.AbstractSessionManager#removeSession(java.lang.String)
*/
@Override
protected boolean removeSession(String idInCluster)
{
return false;
}
@Override
public void renewSessionId(String oldClusterId, String oldNodeId, String newClusterId, String newNodeId)
public void useId(String id)
{
// TODO Auto-generated method stub
}
/**
* @see org.eclipse.jetty.server.SessionIdManager#removeId(java.lang.String)
*/
@Override
public void removeId(String id)
{
// TODO Auto-generated method stub
}
}
public class MockSessionManager extends SessionManager
{
public MockSessionManager()
{
_sessionStore = new MockSessionStore();
((AbstractSessionStore)_sessionStore).setSessionDataStore(new NullSessionDataStore());
}
}
@Test
public void testSecureSessionCookie () throws Exception
@ -245,7 +193,10 @@ public class SessionCookieTest
idMgr.setWorkerName("node1");
MockSessionManager mgr = new MockSessionManager();
mgr.setSessionIdManager(idMgr);
MockSession session = new MockSession(mgr, System.currentTimeMillis(), System.currentTimeMillis(), "node1123"); //clusterId
long now = System.currentTimeMillis();
Session session = new Session(new SessionData("123", "_foo", "0.0.0.0", now, now, now, 30));
SessionCookieConfig sessionCookieConfig = mgr.getSessionCookieConfig();
sessionCookieConfig.setSecure(true);