| // |
| // ======================================================================== |
| // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. |
| // ------------------------------------------------------------------------ |
| // All rights reserved. This program and the accompanying materials |
| // are made available under the terms of the Eclipse Public License v1.0 |
| // and Apache License v2.0 which accompanies this distribution. |
| // |
| // The Eclipse Public License is available at |
| // http://www.eclipse.org/legal/epl-v10.html |
| // |
| // The Apache License v2.0 is available at |
| // http://www.opensource.org/licenses/apache2.0.php |
| // |
| // You may elect to redistribute this code under either of these licenses. |
| // ======================================================================== |
| // |
| |
| package org.eclipse.jetty.server.session; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.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.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 AbstractSessionIdManager |
| { |
| final static Logger LOG = SessionHandler.LOG; |
| public final static int MAX_INTERVAL_NOT_SET = -999; |
| |
| protected final HashSet<String> _sessionIds = new HashSet<String>(); |
| protected Server _server; |
| protected Driver _driver; |
| protected String _driverClassName; |
| protected String _connectionUrl; |
| protected DataSource _datasource; |
| protected String _jndiName; |
| |
| protected int _deleteBlockSize = 10; //number of ids to include in where 'in' clause |
| |
| protected Scheduler.Task _task; //scavenge task |
| protected Scheduler _scheduler; |
| protected Scavenger _scavenger; |
| protected boolean _ownScheduler; |
| protected long _lastScavengeTime; |
| protected long _scavengeIntervalMs = 1000L * 60 * 10; //10mins |
| |
| |
| protected String _createSessionIdTable; |
| protected String _createSessionTable; |
| |
| protected String _selectBoundedExpiredSessions; |
| private String _selectExpiredSessions; |
| |
| protected String _insertId; |
| protected String _deleteId; |
| protected String _queryId; |
| |
| protected String _insertSession; |
| protected String _deleteSession; |
| protected String _updateSession; |
| protected String _updateSessionNode; |
| protected String _updateSessionAccessTime; |
| |
| protected DatabaseAdaptor _dbAdaptor = new DatabaseAdaptor(); |
| protected SessionIdTableSchema _sessionIdTableSchema = new SessionIdTableSchema(); |
| protected SessionTableSchema _sessionTableSchema = new SessionTableSchema(); |
| |
| |
| |
| |
| /** |
| * SessionTableSchema |
| * |
| */ |
| public static class SessionTableSchema |
| { |
| protected DatabaseAdaptor _dbAdaptor; |
| protected String _tableName = "JettySessions"; |
| protected String _rowIdColumn = "rowId"; |
| protected String _idColumn = "sessionId"; |
| protected String _contextPathColumn = "contextPath"; |
| protected String _virtualHostColumn = "virtualHost"; |
| protected String _lastNodeColumn = "lastNode"; |
| protected String _accessTimeColumn = "accessTime"; |
| protected String _lastAccessTimeColumn = "lastAccessTime"; |
| protected String _createTimeColumn = "createTime"; |
| protected String _cookieTimeColumn = "cookieTime"; |
| protected String _lastSavedTimeColumn = "lastSavedTime"; |
| protected String _expiryTimeColumn = "expiryTime"; |
| protected String _maxIntervalColumn = "maxInterval"; |
| protected String _mapColumn = "map"; |
| |
| |
| protected void setDatabaseAdaptor(DatabaseAdaptor dbadaptor) |
| { |
| _dbAdaptor = dbadaptor; |
| } |
| |
| |
| public String getTableName() |
| { |
| return _tableName; |
| } |
| public void setTableName(String tableName) |
| { |
| checkNotNull(tableName); |
| _tableName = tableName; |
| } |
| public String getRowIdColumn() |
| { |
| if ("rowId".equals(_rowIdColumn) && _dbAdaptor.isRowIdReserved()) |
| _rowIdColumn = "srowId"; |
| return _rowIdColumn; |
| } |
| public void setRowIdColumn(String rowIdColumn) |
| { |
| checkNotNull(rowIdColumn); |
| if (_dbAdaptor == null) |
| throw new IllegalStateException ("DbAdaptor is null"); |
| |
| if (_dbAdaptor.isRowIdReserved() && "rowId".equals(rowIdColumn)) |
| throw new IllegalArgumentException("rowId is reserved word for Oracle"); |
| |
| _rowIdColumn = rowIdColumn; |
| } |
| public String getIdColumn() |
| { |
| return _idColumn; |
| } |
| public void setIdColumn(String idColumn) |
| { |
| checkNotNull(idColumn); |
| _idColumn = idColumn; |
| } |
| public String getContextPathColumn() |
| { |
| return _contextPathColumn; |
| } |
| public void setContextPathColumn(String contextPathColumn) |
| { |
| checkNotNull(contextPathColumn); |
| _contextPathColumn = contextPathColumn; |
| } |
| public String getVirtualHostColumn() |
| { |
| return _virtualHostColumn; |
| } |
| public void setVirtualHostColumn(String virtualHostColumn) |
| { |
| checkNotNull(virtualHostColumn); |
| _virtualHostColumn = virtualHostColumn; |
| } |
| public String getLastNodeColumn() |
| { |
| return _lastNodeColumn; |
| } |
| public void setLastNodeColumn(String lastNodeColumn) |
| { |
| checkNotNull(lastNodeColumn); |
| _lastNodeColumn = lastNodeColumn; |
| } |
| public String getAccessTimeColumn() |
| { |
| return _accessTimeColumn; |
| } |
| public void setAccessTimeColumn(String accessTimeColumn) |
| { |
| checkNotNull(accessTimeColumn); |
| _accessTimeColumn = accessTimeColumn; |
| } |
| public String getLastAccessTimeColumn() |
| { |
| return _lastAccessTimeColumn; |
| } |
| public void setLastAccessTimeColumn(String lastAccessTimeColumn) |
| { |
| checkNotNull(lastAccessTimeColumn); |
| _lastAccessTimeColumn = lastAccessTimeColumn; |
| } |
| public String getCreateTimeColumn() |
| { |
| return _createTimeColumn; |
| } |
| public void setCreateTimeColumn(String createTimeColumn) |
| { |
| checkNotNull(createTimeColumn); |
| _createTimeColumn = createTimeColumn; |
| } |
| public String getCookieTimeColumn() |
| { |
| return _cookieTimeColumn; |
| } |
| public void setCookieTimeColumn(String cookieTimeColumn) |
| { |
| checkNotNull(cookieTimeColumn); |
| _cookieTimeColumn = cookieTimeColumn; |
| } |
| public String getLastSavedTimeColumn() |
| { |
| return _lastSavedTimeColumn; |
| } |
| public void setLastSavedTimeColumn(String lastSavedTimeColumn) |
| { |
| checkNotNull(lastSavedTimeColumn); |
| _lastSavedTimeColumn = lastSavedTimeColumn; |
| } |
| public String getExpiryTimeColumn() |
| { |
| return _expiryTimeColumn; |
| } |
| public void setExpiryTimeColumn(String expiryTimeColumn) |
| { |
| checkNotNull(expiryTimeColumn); |
| _expiryTimeColumn = expiryTimeColumn; |
| } |
| public String getMaxIntervalColumn() |
| { |
| return _maxIntervalColumn; |
| } |
| public void setMaxIntervalColumn(String maxIntervalColumn) |
| { |
| checkNotNull(maxIntervalColumn); |
| _maxIntervalColumn = maxIntervalColumn; |
| } |
| public String getMapColumn() |
| { |
| return _mapColumn; |
| } |
| public void setMapColumn(String mapColumn) |
| { |
| checkNotNull(mapColumn); |
| _mapColumn = mapColumn; |
| } |
| |
| public String getCreateStatementAsString () |
| { |
| if (_dbAdaptor == null) |
| throw new IllegalStateException ("No DBAdaptor"); |
| |
| String blobType = _dbAdaptor.getBlobType(); |
| String longType = _dbAdaptor.getLongType(); |
| |
| return "create table "+_tableName+" ("+getRowIdColumn()+" varchar(120), "+_idColumn+" varchar(120), "+ |
| _contextPathColumn+" varchar(60), "+_virtualHostColumn+" varchar(60), "+_lastNodeColumn+" varchar(60), "+_accessTimeColumn+" "+longType+", "+ |
| _lastAccessTimeColumn+" "+longType+", "+_createTimeColumn+" "+longType+", "+_cookieTimeColumn+" "+longType+", "+ |
| _lastSavedTimeColumn+" "+longType+", "+_expiryTimeColumn+" "+longType+", "+_maxIntervalColumn+" "+longType+", "+ |
| _mapColumn+" "+blobType+", primary key("+getRowIdColumn()+"))"; |
| } |
| |
| public String getCreateIndexOverExpiryStatementAsString (String indexName) |
| { |
| return "create index "+indexName+" on "+getTableName()+" ("+getExpiryTimeColumn()+")"; |
| } |
| |
| public String getCreateIndexOverSessionStatementAsString (String indexName) |
| { |
| return "create index "+indexName+" on "+getTableName()+" ("+getIdColumn()+", "+getContextPathColumn()+")"; |
| } |
| |
| public String getAlterTableForMaxIntervalAsString () |
| { |
| if (_dbAdaptor == null) |
| throw new IllegalStateException ("No DBAdaptor"); |
| String longType = _dbAdaptor.getLongType(); |
| return "alter table "+getTableName()+" add "+getMaxIntervalColumn()+" "+longType+" not null default "+MAX_INTERVAL_NOT_SET; |
| } |
| |
| private void checkNotNull(String s) |
| { |
| if (s == null) |
| throw new IllegalArgumentException(s); |
| } |
| public String getInsertSessionStatementAsString() |
| { |
| return "insert into "+getTableName()+ |
| " ("+getRowIdColumn()+", "+getIdColumn()+", "+getContextPathColumn()+", "+getVirtualHostColumn()+", "+getLastNodeColumn()+ |
| ", "+getAccessTimeColumn()+", "+getLastAccessTimeColumn()+", "+getCreateTimeColumn()+", "+getCookieTimeColumn()+ |
| ", "+getLastSavedTimeColumn()+", "+getExpiryTimeColumn()+", "+getMaxIntervalColumn()+", "+getMapColumn()+") "+ |
| " values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"; |
| } |
| public String getDeleteSessionStatementAsString() |
| { |
| return "delete from "+getTableName()+ |
| " where "+getRowIdColumn()+" = ?"; |
| } |
| public String getUpdateSessionStatementAsString() |
| { |
| return "update "+getTableName()+ |
| " set "+getIdColumn()+" = ?, "+getLastNodeColumn()+" = ?, "+getAccessTimeColumn()+" = ?, "+ |
| getLastAccessTimeColumn()+" = ?, "+getLastSavedTimeColumn()+" = ?, "+getExpiryTimeColumn()+" = ?, "+ |
| getMaxIntervalColumn()+" = ?, "+getMapColumn()+" = ? where "+getRowIdColumn()+" = ?"; |
| } |
| public String getUpdateSessionNodeStatementAsString() |
| { |
| return "update "+getTableName()+ |
| " set "+getLastNodeColumn()+" = ? where "+getRowIdColumn()+" = ?"; |
| } |
| public String getUpdateSessionAccessTimeStatementAsString() |
| { |
| return "update "+getTableName()+ |
| " set "+getLastNodeColumn()+" = ?, "+getAccessTimeColumn()+" = ?, "+getLastAccessTimeColumn()+" = ?, "+ |
| getLastSavedTimeColumn()+" = ?, "+getExpiryTimeColumn()+" = ?, "+getMaxIntervalColumn()+" = ? where "+getRowIdColumn()+" = ?"; |
| } |
| |
| public String getBoundedExpiredSessionsStatementAsString() |
| { |
| return "select * from "+getTableName()+" where "+getLastNodeColumn()+" = ? and "+getExpiryTimeColumn()+" >= ? and "+getExpiryTimeColumn()+" <= ?"; |
| } |
| |
| public String getSelectExpiredSessionsStatementAsString() |
| { |
| return "select * from "+getTableName()+" where "+getExpiryTimeColumn()+" >0 and "+getExpiryTimeColumn()+" <= ?"; |
| } |
| |
| public PreparedStatement getLoadStatement (Connection connection, String rowId, String contextPath, String virtualHosts) |
| throws SQLException |
| { |
| if (_dbAdaptor == null) |
| throw new IllegalStateException("No DB adaptor"); |
| |
| |
| if (contextPath == null || "".equals(contextPath)) |
| { |
| if (_dbAdaptor.isEmptyStringNull()) |
| { |
| PreparedStatement statement = connection.prepareStatement("select * from "+getTableName()+ |
| " where "+getIdColumn()+" = ? and "+ |
| getContextPathColumn()+" is null and "+ |
| getVirtualHostColumn()+" = ?"); |
| statement.setString(1, rowId); |
| statement.setString(2, virtualHosts); |
| |
| return statement; |
| } |
| } |
| |
| PreparedStatement statement = connection.prepareStatement("select * from "+getTableName()+ |
| " where "+getIdColumn()+" = ? and "+getContextPathColumn()+ |
| " = ? and "+getVirtualHostColumn()+" = ?"); |
| statement.setString(1, rowId); |
| statement.setString(2, contextPath); |
| statement.setString(3, virtualHosts); |
| |
| return statement; |
| } |
| } |
| |
| |
| |
| /** |
| * SessionIdTableSchema |
| * |
| */ |
| public static class SessionIdTableSchema |
| { |
| protected DatabaseAdaptor _dbAdaptor; |
| protected String _tableName = "JettySessionIds"; |
| protected String _idColumn = "id"; |
| |
| public void setDatabaseAdaptor(DatabaseAdaptor dbAdaptor) |
| { |
| _dbAdaptor = dbAdaptor; |
| } |
| 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+"))"; |
| } |
| |
| private void checkNotNull(String s) |
| { |
| if (s == null) |
| throw new IllegalArgumentException(s); |
| } |
| } |
| |
| |
| /** |
| * DatabaseAdaptor |
| * |
| * Handles differences between databases. |
| * |
| * Postgres uses the getBytes and setBinaryStream methods to access |
| * a "bytea" datatype, which can be up to 1Gb of binary data. MySQL |
| * is happy to use the "blob" type and getBlob() methods instead. |
| * |
| * TODO if the differences become more major it would be worthwhile |
| * refactoring this class. |
| */ |
| public static class DatabaseAdaptor |
| { |
| String _dbName; |
| boolean _isLower; |
| boolean _isUpper; |
| |
| protected String _blobType; //if not set, is deduced from the type of the database at runtime |
| protected String _longType; //if not set, is deduced from the type of the database at runtime |
| |
| |
| public DatabaseAdaptor () |
| { |
| } |
| |
| |
| public void adaptTo(DatabaseMetaData dbMeta) |
| throws SQLException |
| { |
| _dbName = dbMeta.getDatabaseProductName().toLowerCase(Locale.ENGLISH); |
| if (LOG.isDebugEnabled()) |
| LOG.debug ("Using database {}",_dbName); |
| _isLower = dbMeta.storesLowerCaseIdentifiers(); |
| _isUpper = dbMeta.storesUpperCaseIdentifiers(); |
| } |
| |
| |
| public void setBlobType(String blobType) |
| { |
| _blobType = blobType; |
| } |
| |
| public String getBlobType () |
| { |
| if (_blobType != null) |
| return _blobType; |
| |
| if (_dbName.startsWith("postgres")) |
| return "bytea"; |
| |
| return "blob"; |
| } |
| |
| |
| public void setLongType(String longType) |
| { |
| _longType = longType; |
| } |
| |
| |
| public String getLongType () |
| { |
| if (_longType != null) |
| return _longType; |
| |
| if (_dbName == null) |
| throw new IllegalStateException ("DbAdaptor missing metadata"); |
| |
| if (_dbName.startsWith("oracle")) |
| return "number(20)"; |
| |
| return "bigint"; |
| } |
| |
| |
| /** |
| * Convert a camel case identifier into either upper or lower |
| * depending on the way the db stores identifiers. |
| * |
| * @param identifier |
| * @return the converted identifier |
| */ |
| public String convertIdentifier (String identifier) |
| { |
| if (_dbName == null) |
| throw new IllegalStateException ("DbAdaptor missing metadata"); |
| |
| if (_isLower) |
| return identifier.toLowerCase(Locale.ENGLISH); |
| if (_isUpper) |
| return identifier.toUpperCase(Locale.ENGLISH); |
| |
| return identifier; |
| } |
| |
| public String getDBName () |
| { |
| return _dbName; |
| } |
| |
| |
| public InputStream getBlobInputStream (ResultSet result, String columnName) |
| throws SQLException |
| { |
| if (_dbName == null) |
| throw new IllegalStateException ("DbAdaptor missing metadata"); |
| |
| if (_dbName.startsWith("postgres")) |
| { |
| byte[] bytes = result.getBytes(columnName); |
| return new ByteArrayInputStream(bytes); |
| } |
| |
| Blob blob = result.getBlob(columnName); |
| return blob.getBinaryStream(); |
| } |
| |
| |
| public boolean isEmptyStringNull () |
| { |
| if (_dbName == null) |
| throw new IllegalStateException ("DbAdaptor missing metadata"); |
| |
| return (_dbName.startsWith("oracle")); |
| } |
| |
| /** |
| * rowId is a reserved word for Oracle, so change the name of this column |
| * @return true if db in use is oracle |
| */ |
| public boolean isRowIdReserved () |
| { |
| if (_dbName == null) |
| throw new IllegalStateException ("DbAdaptor missing metadata"); |
| |
| return (_dbName != null && _dbName.startsWith("oracle")); |
| } |
| } |
| |
| |
| /** |
| * Scavenger |
| * |
| */ |
| protected class Scavenger implements Runnable |
| { |
| |
| @Override |
| public void run() |
| { |
| try |
| { |
| scavenge(); |
| } |
| finally |
| { |
| if (_scheduler != null && _scheduler.isRunning()) |
| _scheduler.schedule(this, _scavengeIntervalMs, TimeUnit.MILLISECONDS); |
| } |
| } |
| } |
| |
| |
| public JDBCSessionIdManager(Server server) |
| { |
| super(); |
| _server=server; |
| } |
| |
| public JDBCSessionIdManager(Server server, Random random) |
| { |
| super(random); |
| _server=server; |
| } |
| |
| /** |
| * Configure jdbc connection information via a jdbc Driver |
| * |
| * @param driverClassName |
| * @param connectionUrl |
| */ |
| public void setDriverInfo (String driverClassName, String connectionUrl) |
| { |
| _driverClassName=driverClassName; |
| _connectionUrl=connectionUrl; |
| } |
| |
| /** |
| * Configure jdbc connection information via a jdbc Driver |
| * |
| * @param driverClass |
| * @param connectionUrl |
| */ |
| public void setDriverInfo (Driver driverClass, String connectionUrl) |
| { |
| _driver=driverClass; |
| _connectionUrl=connectionUrl; |
| } |
| |
| |
| public void setDatasource (DataSource ds) |
| { |
| _datasource = ds; |
| } |
| |
| public DataSource getDataSource () |
| { |
| return _datasource; |
| } |
| |
| public String getDriverClassName() |
| { |
| return _driverClassName; |
| } |
| |
| public String getConnectionUrl () |
| { |
| return _connectionUrl; |
| } |
| |
| public void setDatasourceName (String jndi) |
| { |
| _jndiName=jndi; |
| } |
| |
| public String getDatasourceName () |
| { |
| return _jndiName; |
| } |
| |
| /** |
| * @param name |
| * @deprecated see DbAdaptor.setBlobType |
| */ |
| public void setBlobType (String name) |
| { |
| _dbAdaptor.setBlobType(name); |
| } |
| |
| public DatabaseAdaptor getDbAdaptor() |
| { |
| return _dbAdaptor; |
| } |
| |
| public void setDbAdaptor(DatabaseAdaptor dbAdaptor) |
| { |
| if (dbAdaptor == null) |
| throw new IllegalStateException ("DbAdaptor cannot be null"); |
| |
| _dbAdaptor = dbAdaptor; |
| } |
| |
| /** |
| * @return |
| * @deprecated see DbAdaptor.getBlobType |
| */ |
| public String getBlobType () |
| { |
| return _dbAdaptor.getBlobType(); |
| } |
| |
| /** |
| * @return |
| * @deprecated see DbAdaptor.getLogType |
| */ |
| public String getLongType() |
| { |
| return _dbAdaptor.getLongType(); |
| } |
| |
| /** |
| * @param longType |
| * @deprecated see DbAdaptor.setLongType |
| */ |
| public void setLongType(String longType) |
| { |
| _dbAdaptor.setLongType(longType); |
| } |
| |
| public SessionIdTableSchema getSessionIdTableSchema() |
| { |
| return _sessionIdTableSchema; |
| } |
| |
| public void setSessionIdTableSchema(SessionIdTableSchema sessionIdTableSchema) |
| { |
| if (sessionIdTableSchema == null) |
| throw new IllegalArgumentException("Null SessionIdTableSchema"); |
| |
| _sessionIdTableSchema = sessionIdTableSchema; |
| } |
| |
| public SessionTableSchema getSessionTableSchema() |
| { |
| return _sessionTableSchema; |
| } |
| |
| public void setSessionTableSchema(SessionTableSchema sessionTableSchema) |
| { |
| _sessionTableSchema = sessionTableSchema; |
| } |
| |
| public void setDeleteBlockSize (int bsize) |
| { |
| this._deleteBlockSize = bsize; |
| } |
| |
| public int getDeleteBlockSize () |
| { |
| return this._deleteBlockSize; |
| } |
| |
| public void setScavengeInterval (long sec) |
| { |
| if (sec<=0) |
| sec=60; |
| |
| long old_period=_scavengeIntervalMs; |
| long period=sec*1000L; |
| |
| _scavengeIntervalMs=period; |
| |
| //add a bit of variability into the scavenge time so that not all |
| //nodes with the same scavenge time sync up |
| long tenPercent = _scavengeIntervalMs/10; |
| if ((System.currentTimeMillis()%2) == 0) |
| _scavengeIntervalMs += tenPercent; |
| |
| if (LOG.isDebugEnabled()) |
| LOG.debug("Scavenging every "+_scavengeIntervalMs+" ms"); |
| |
| synchronized (this) |
| { |
| //if (_timer!=null && (period!=old_period || _task==null)) |
| if (_scheduler != null && (period!=old_period || _task==null)) |
| { |
| if (_task!=null) |
| _task.cancel(); |
| if (_scavenger == null) |
| _scavenger = new Scavenger(); |
| _task = _scheduler.schedule(_scavenger,_scavengeIntervalMs,TimeUnit.MILLISECONDS); |
| } |
| } |
| } |
| |
| public long getScavengeInterval () |
| { |
| return _scavengeIntervalMs/1000; |
| } |
| |
| |
| @Override |
| public void addSession(HttpSession session) |
| { |
| if (session == null) |
| return; |
| |
| synchronized (_sessionIds) |
| { |
| String id = ((JDBCSessionManager.Session)session).getClusterId(); |
| try |
| { |
| insert(id); |
| _sessionIds.add(id); |
| } |
| catch (Exception e) |
| { |
| LOG.warn("Problem storing session id="+id, e); |
| } |
| } |
| } |
| |
| |
| public void addSession(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); |
| } |
| } |
| } |
| |
| |
| |
| @Override |
| public void removeSession(HttpSession session) |
| { |
| if (session == null) |
| return; |
| |
| removeSession(((JDBCSessionManager.Session)session).getClusterId()); |
| } |
| |
| |
| |
| public void removeSession (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); |
| } |
| } |
| |
| } |
| |
| |
| @Override |
| public boolean idInUse(String id) |
| { |
| if (id == null) |
| return false; |
| |
| String clusterId = getClusterId(id); |
| boolean inUse = false; |
| synchronized (_sessionIds) |
| { |
| inUse = _sessionIds.contains(clusterId); |
| } |
| |
| |
| 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(clusterId); |
| } |
| catch (Exception e) |
| { |
| LOG.warn("Problem checking inUse for id="+clusterId, e); |
| return false; |
| } |
| } |
| |
| /** |
| * Invalidate the session matching the id on all contexts. |
| * |
| * @see org.eclipse.jetty.server.SessionIdManager#invalidateAll(java.lang.String) |
| */ |
| @Override |
| public void invalidateAll(String id) |
| { |
| //take the id out of the list of known sessionids for this node |
| removeSession(id); |
| |
| synchronized (_sessionIds) |
| { |
| //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 instanceof JDBCSessionManager) |
| { |
| ((JDBCSessionManager)manager).invalidateSession(id); |
| } |
| } |
| } |
| } |
| } |
| |
| |
| @Override |
| public void renewSessionId (String oldClusterId, String oldNodeId, HttpServletRequest request) |
| { |
| //generate a new id |
| String newClusterId = newSessionId(request.hashCode()); |
| |
| synchronized (_sessionIds) |
| { |
| removeSession(oldClusterId);//remove the old one from the list (and database) |
| addSession(newClusterId); //add in the new session id to 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 instanceof JDBCSessionManager) |
| { |
| ((JDBCSessionManager)manager).renewSessionId(oldClusterId, oldNodeId, newClusterId, getNodeId(newClusterId, request)); |
| } |
| } |
| } |
| } |
| } |
| |
| |
| /** |
| * Start up the id manager. |
| * |
| * Makes necessary database tables and starts a Session |
| * scavenger thread. |
| */ |
| @Override |
| public void doStart() |
| throws Exception |
| { |
| initializeDatabase(); |
| prepareTables(); |
| super.doStart(); |
| if (LOG.isDebugEnabled()) |
| LOG.debug("Scavenging interval = "+getScavengeInterval()+" sec"); |
| |
| //try and use a common scheduler, fallback to own |
| _scheduler =_server.getBean(Scheduler.class); |
| if (_scheduler == null) |
| { |
| _scheduler = new ScheduledExecutorScheduler(); |
| _ownScheduler = true; |
| _scheduler.start(); |
| } |
| |
| setScavengeInterval(getScavengeInterval()); |
| } |
| |
| /** |
| * Stop the scavenger. |
| */ |
| @Override |
| public void doStop () |
| throws Exception |
| { |
| synchronized(this) |
| { |
| if (_task!=null) |
| _task.cancel(); |
| _task=null; |
| if (_ownScheduler && _scheduler !=null) |
| _scheduler.stop(); |
| _scheduler=null; |
| } |
| _sessionIds.clear(); |
| super.doStop(); |
| } |
| |
| /** |
| * Get a connection from the driver or datasource. |
| * |
| * @return the connection for the datasource |
| * @throws SQLException |
| */ |
| protected Connection getConnection () |
| throws SQLException |
| { |
| if (_datasource != null) |
| return _datasource.getConnection(); |
| else |
| return DriverManager.getConnection(_connectionUrl); |
| } |
| |
| |
| |
| |
| |
| |
| /** |
| * Set up the tables in the database |
| * @throws SQLException |
| */ |
| /** |
| * @throws SQLException |
| */ |
| private void prepareTables() |
| throws SQLException |
| { |
| if (_sessionIdTableSchema == null) |
| throw new IllegalStateException ("No SessionIdTableSchema"); |
| |
| if (_sessionTableSchema == null) |
| throw new IllegalStateException ("No SessionTableSchema"); |
| |
| try (Connection connection = getConnection(); |
| Statement statement = connection.createStatement()) |
| { |
| //make the id table |
| connection.setAutoCommit(true); |
| DatabaseMetaData metaData = connection.getMetaData(); |
| _dbAdaptor.adaptTo(metaData); |
| _sessionTableSchema.setDatabaseAdaptor(_dbAdaptor); |
| _sessionIdTableSchema.setDatabaseAdaptor(_dbAdaptor); |
| |
| _createSessionIdTable = _sessionIdTableSchema.getCreateStatementAsString(); |
| _insertId = _sessionIdTableSchema.getInsertStatementAsString(); |
| _deleteId = _sessionIdTableSchema.getDeleteStatementAsString(); |
| _queryId = _sessionIdTableSchema.getSelectStatementAsString(); |
| |
| //checking for table existence is case-sensitive, but table creation is not |
| String tableName = _dbAdaptor.convertIdentifier(_sessionIdTableSchema.getTableName()); |
| try (ResultSet result = metaData.getTables(null, null, tableName, null)) |
| { |
| if (!result.next()) |
| { |
| //table does not exist, so create it |
| statement.executeUpdate(_createSessionIdTable); |
| } |
| } |
| |
| //make the session table if necessary |
| tableName = _dbAdaptor.convertIdentifier(_sessionTableSchema.getTableName()); |
| try (ResultSet result = metaData.getTables(null, null, tableName, null)) |
| { |
| if (!result.next()) |
| { |
| //table does not exist, so create it |
| _createSessionTable = _sessionTableSchema.getCreateStatementAsString(); |
| statement.executeUpdate(_createSessionTable); |
| } |
| else |
| { |
| //session table exists, check it has maxinterval column |
| ResultSet colResult = null; |
| try |
| { |
| colResult = metaData.getColumns(null, null, |
| _dbAdaptor.convertIdentifier(_sessionTableSchema.getTableName()), |
| _dbAdaptor.convertIdentifier(_sessionTableSchema.getMaxIntervalColumn())); |
| } |
| catch (SQLException s) |
| { |
| LOG.warn("Problem checking if "+_sessionTableSchema.getTableName()+ |
| " table contains "+_sessionTableSchema.getMaxIntervalColumn()+" column. Ensure table contains column definition: \"" |
| +_sessionTableSchema.getMaxIntervalColumn()+" long not null default -999\""); |
| throw s; |
| } |
| try |
| { |
| if (!colResult.next()) |
| { |
| try |
| { |
| //add the maxinterval column |
| statement.executeUpdate(_sessionTableSchema.getAlterTableForMaxIntervalAsString()); |
| } |
| catch (SQLException s) |
| { |
| LOG.warn("Problem adding "+_sessionTableSchema.getMaxIntervalColumn()+ |
| " column. Ensure table contains column definition: \""+_sessionTableSchema.getMaxIntervalColumn()+ |
| " long not null default -999\""); |
| throw s; |
| } |
| } |
| } |
| finally |
| { |
| colResult.close(); |
| } |
| } |
| } |
| //make some indexes on the JettySessions table |
| String index1 = "idx_"+_sessionTableSchema.getTableName()+"_expiry"; |
| String index2 = "idx_"+_sessionTableSchema.getTableName()+"_session"; |
| |
| boolean index1Exists = false; |
| boolean index2Exists = false; |
| try (ResultSet result = metaData.getIndexInfo(null, null, tableName, false, false)) |
| { |
| while (result.next()) |
| { |
| String idxName = result.getString("INDEX_NAME"); |
| if (index1.equalsIgnoreCase(idxName)) |
| index1Exists = true; |
| else if (index2.equalsIgnoreCase(idxName)) |
| index2Exists = true; |
| } |
| } |
| if (!index1Exists) |
| statement.executeUpdate(_sessionTableSchema.getCreateIndexOverExpiryStatementAsString(index1)); |
| if (!index2Exists) |
| statement.executeUpdate(_sessionTableSchema.getCreateIndexOverSessionStatementAsString(index2)); |
| |
| //set up some strings representing the statements for session manipulation |
| _insertSession = _sessionTableSchema.getInsertSessionStatementAsString(); |
| _deleteSession = _sessionTableSchema.getDeleteSessionStatementAsString(); |
| _updateSession = _sessionTableSchema.getUpdateSessionStatementAsString(); |
| _updateSessionNode = _sessionTableSchema.getUpdateSessionNodeStatementAsString(); |
| _updateSessionAccessTime = _sessionTableSchema.getUpdateSessionAccessTimeStatementAsString(); |
| _selectBoundedExpiredSessions = _sessionTableSchema.getBoundedExpiredSessionsStatementAsString(); |
| _selectExpiredSessions = _sessionTableSchema.getSelectExpiredSessionsStatementAsString(); |
| } |
| } |
| |
| /** |
| * Insert a new used session id into the table. |
| * |
| * @param id |
| * @throws SQLException |
| */ |
| private void insert (String id) |
| throws SQLException |
| { |
| try (Connection connection = getConnection(); |
| PreparedStatement query = connection.prepareStatement(_queryId)) |
| { |
| 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(_insertId)) |
| { |
| 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 = getConnection(); |
| PreparedStatement statement = connection.prepareStatement(_deleteId)) |
| { |
| 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 = getConnection(); |
| PreparedStatement statement = connection.prepareStatement(_queryId)) |
| { |
| connection.setAutoCommit(true); |
| statement.setString(1, id); |
| try (ResultSet result = statement.executeQuery()) |
| { |
| return result.next(); |
| } |
| } |
| } |
| |
| /** |
| * Look for sessions in the database that have expired. |
| * |
| * We do this in the SessionIdManager and not the SessionManager so |
| * that we only have 1 scavenger, otherwise if there are n SessionManagers |
| * there would be n scavengers, all contending for the database. |
| * |
| * We look first for sessions that expired in the previous interval, then |
| * for sessions that expired previously - these are old sessions that no |
| * node is managing any more and have become stuck in the database. |
| */ |
| private void scavenge () |
| { |
| Connection connection = null; |
| try |
| { |
| if (LOG.isDebugEnabled()) |
| LOG.debug(getWorkerName()+"- Scavenge sweep started at "+System.currentTimeMillis()); |
| if (_lastScavengeTime > 0) |
| { |
| connection = getConnection(); |
| connection.setAutoCommit(true); |
| Set<String> expiredSessionIds = new HashSet<String>(); |
| |
| |
| //Pass 1: find sessions for which we were last managing node that have just expired since last pass |
| long lowerBound = (_lastScavengeTime - _scavengeIntervalMs); |
| long upperBound = _lastScavengeTime; |
| if (LOG.isDebugEnabled()) |
| LOG.debug (getWorkerName()+"- Pass 1: Searching for sessions expired between "+lowerBound + " and "+upperBound); |
| |
| try (PreparedStatement statement = connection.prepareStatement(_selectBoundedExpiredSessions)) |
| { |
| statement.setString(1, getWorkerName()); |
| statement.setLong(2, lowerBound); |
| statement.setLong(3, upperBound); |
| try (ResultSet result = statement.executeQuery()) |
| { |
| while (result.next()) |
| { |
| String sessionId = result.getString(_sessionTableSchema.getIdColumn()); |
| expiredSessionIds.add(sessionId); |
| if (LOG.isDebugEnabled()) LOG.debug ("Found expired sessionId="+sessionId); |
| } |
| } |
| } |
| scavengeSessions(expiredSessionIds, false); |
| |
| |
| //Pass 2: find sessions that have expired a while ago for which this node was their last manager |
| try (PreparedStatement selectExpiredSessions = connection.prepareStatement(_selectExpiredSessions)) |
| { |
| expiredSessionIds.clear(); |
| upperBound = _lastScavengeTime - (2 * _scavengeIntervalMs); |
| if (upperBound > 0) |
| { |
| if (LOG.isDebugEnabled()) LOG.debug(getWorkerName()+"- Pass 2: Searching for sessions expired before "+upperBound); |
| selectExpiredSessions.setLong(1, upperBound); |
| try (ResultSet result = selectExpiredSessions.executeQuery()) |
| { |
| while (result.next()) |
| { |
| String sessionId = result.getString(_sessionTableSchema.getIdColumn()); |
| String lastNode = result.getString(_sessionTableSchema.getLastNodeColumn()); |
| if ((getWorkerName() == null && lastNode == null) || (getWorkerName() != null && getWorkerName().equals(lastNode))) |
| expiredSessionIds.add(sessionId); |
| if (LOG.isDebugEnabled()) LOG.debug ("Found expired sessionId="+sessionId+" last managed by "+getWorkerName()); |
| } |
| } |
| scavengeSessions(expiredSessionIds, false); |
| } |
| |
| |
| //Pass 3: |
| //find all sessions that have expired at least a couple of scanIntervals ago |
| //if we did not succeed in loading them (eg their related context no longer exists, can't be loaded etc) then |
| //they are simply deleted |
| upperBound = _lastScavengeTime - (3 * _scavengeIntervalMs); |
| expiredSessionIds.clear(); |
| if (upperBound > 0) |
| { |
| if (LOG.isDebugEnabled()) LOG.debug(getWorkerName()+"- Pass 3: searching for sessions expired before "+upperBound); |
| selectExpiredSessions.setLong(1, upperBound); |
| try (ResultSet result = selectExpiredSessions.executeQuery()) |
| { |
| while (result.next()) |
| { |
| String sessionId = result.getString(_sessionTableSchema.getIdColumn()); |
| expiredSessionIds.add(sessionId); |
| if (LOG.isDebugEnabled()) LOG.debug ("Found expired sessionId="+sessionId); |
| } |
| } |
| scavengeSessions(expiredSessionIds, true); |
| } |
| } |
| } |
| } |
| catch (Exception e) |
| { |
| if (isRunning()) |
| LOG.warn("Problem selecting expired sessions", e); |
| else |
| LOG.ignore(e); |
| } |
| finally |
| { |
| _lastScavengeTime=System.currentTimeMillis(); |
| if (LOG.isDebugEnabled()) LOG.debug(getWorkerName()+"- Scavenge sweep ended at "+_lastScavengeTime); |
| if (connection != null) |
| { |
| try |
| { |
| connection.close(); |
| } |
| catch (SQLException e) |
| { |
| LOG.warn(e); |
| } |
| } |
| } |
| } |
| |
| |
| /** |
| * @param expiredSessionIds |
| */ |
| private void scavengeSessions (Set<String> expiredSessionIds, boolean forceDelete) |
| { |
| Set<String> remainingIds = new HashSet<String>(expiredSessionIds); |
| 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 instanceof JDBCSessionManager) |
| { |
| Set<String> successfullyExpiredIds = ((JDBCSessionManager)manager).expire(expiredSessionIds); |
| if (successfullyExpiredIds != null) |
| remainingIds.removeAll(successfullyExpiredIds); |
| } |
| } |
| } |
| |
| //Any remaining ids are of those sessions that no context removed |
| if (!remainingIds.isEmpty() && forceDelete) |
| { |
| LOG.info("Forcibly deleting unrecoverable expired sessions {}", remainingIds); |
| try |
| { |
| //ensure they aren't in the local list of in-use session ids |
| synchronized (_sessionIds) |
| { |
| _sessionIds.removeAll(remainingIds); |
| } |
| |
| cleanExpiredSessionIds(remainingIds); |
| } |
| catch (Exception e) |
| { |
| LOG.warn("Error removing expired session ids", e); |
| } |
| } |
| } |
| |
| |
| |
| |
| private void cleanExpiredSessionIds (Set<String> expiredIds) |
| throws Exception |
| { |
| if (expiredIds == null || expiredIds.isEmpty()) |
| return; |
| |
| String[] ids = expiredIds.toArray(new String[expiredIds.size()]); |
| try (Connection con = getConnection()) |
| { |
| con.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED); |
| con.setAutoCommit(false); |
| |
| int start = 0; |
| int end = 0; |
| int blocksize = _deleteBlockSize; |
| int block = 0; |
| |
| try (Statement statement = con.createStatement()) |
| { |
| while (end < ids.length) |
| { |
| start = block*blocksize; |
| if ((ids.length - start) >= blocksize) |
| end = start + blocksize; |
| else |
| end = ids.length; |
| |
| //take them out of the sessionIds table |
| statement.executeUpdate(fillInClause("delete from "+_sessionIdTableSchema.getTableName()+" where "+_sessionIdTableSchema.getIdColumn()+" in ", ids, start, end)); |
| //take them out of the sessions table |
| statement.executeUpdate(fillInClause("delete from "+_sessionTableSchema.getTableName()+" where "+_sessionTableSchema.getIdColumn()+" in ", ids, start, end)); |
| block++; |
| } |
| } |
| catch (Exception e) |
| { |
| con.rollback(); |
| throw e; |
| } |
| con.commit(); |
| } |
| } |
| |
| |
| |
| /** |
| * |
| * @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(); |
| } |
| |
| |
| |
| private void initializeDatabase () |
| throws Exception |
| { |
| if (_datasource != null) |
| return; //already set up |
| |
| if (_jndiName!=null) |
| { |
| InitialContext ic = new InitialContext(); |
| _datasource = (DataSource)ic.lookup(_jndiName); |
| } |
| else if ( _driver != null && _connectionUrl != null ) |
| { |
| DriverManager.registerDriver(_driver); |
| } |
| else if (_driverClassName != null && _connectionUrl != null) |
| { |
| Class.forName(_driverClassName); |
| } |
| else |
| throw new IllegalStateException("No database configured for sessions"); |
| } |
| |
| |
| } |
