1062 lines
34 KiB
Java
1062 lines
34 KiB
Java
/*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership.
|
|
* The ASF licenses this file to You under the Apache License, Version 2.0
|
|
* (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package org.apache.catalina.session;
|
|
|
|
import java.io.BufferedInputStream;
|
|
import java.io.BufferedOutputStream;
|
|
import java.io.ByteArrayInputStream;
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.ObjectInputStream;
|
|
import java.io.ObjectOutputStream;
|
|
import java.sql.Connection;
|
|
import java.sql.Driver;
|
|
import java.sql.PreparedStatement;
|
|
import java.sql.ResultSet;
|
|
import java.sql.SQLException;
|
|
import java.util.ArrayList;
|
|
import java.util.Properties;
|
|
|
|
import javax.naming.Context;
|
|
import javax.naming.InitialContext;
|
|
import javax.naming.NamingException;
|
|
import javax.sql.DataSource;
|
|
|
|
import org.apache.catalina.Container;
|
|
import org.apache.catalina.Globals;
|
|
import org.apache.catalina.LifecycleException;
|
|
import org.apache.catalina.Session;
|
|
import org.apache.juli.logging.Log;
|
|
import org.apache.tomcat.util.ExceptionUtils;
|
|
|
|
/**
|
|
* Implementation of the {@link org.apache.catalina.Store Store}
|
|
* interface that stores serialized session objects in a database.
|
|
* Sessions that are saved are still subject to being expired
|
|
* based on inactivity.
|
|
*
|
|
* @author Bip Thelin
|
|
*/
|
|
public class JDBCStore extends StoreBase {
|
|
|
|
/**
|
|
* Context name associated with this Store
|
|
*/
|
|
private String name = null;
|
|
|
|
/**
|
|
* Name to register for this Store, used for logging.
|
|
*/
|
|
protected static final String storeName = "JDBCStore";
|
|
|
|
/**
|
|
* Name to register for the background thread.
|
|
*/
|
|
protected static final String threadName = "JDBCStore";
|
|
|
|
/**
|
|
* The connection username to use when trying to connect to the database.
|
|
*/
|
|
protected String connectionName = null;
|
|
|
|
|
|
/**
|
|
* The connection URL to use when trying to connect to the database.
|
|
*/
|
|
protected String connectionPassword = null;
|
|
|
|
/**
|
|
* Connection string to use when connecting to the DB.
|
|
*/
|
|
protected String connectionURL = null;
|
|
|
|
/**
|
|
* The database connection.
|
|
*/
|
|
private Connection dbConnection = null;
|
|
|
|
/**
|
|
* Instance of the JDBC Driver class we use as a connection factory.
|
|
*/
|
|
protected Driver driver = null;
|
|
|
|
/**
|
|
* Driver to use.
|
|
*/
|
|
protected String driverName = null;
|
|
|
|
/**
|
|
* name of the JNDI resource
|
|
*/
|
|
protected String dataSourceName = null;
|
|
|
|
/**
|
|
* Context local datasource.
|
|
*/
|
|
private boolean localDataSource = false;
|
|
|
|
/**
|
|
* DataSource to use
|
|
*/
|
|
protected DataSource dataSource = null;
|
|
|
|
|
|
// ------------------------------------------------------------ Table & cols
|
|
|
|
/**
|
|
* Table to use.
|
|
*/
|
|
protected String sessionTable = "tomcat$sessions";
|
|
|
|
/**
|
|
* Column to use for /Engine/Host/Context name
|
|
*/
|
|
protected String sessionAppCol = "app";
|
|
|
|
/**
|
|
* Id column to use.
|
|
*/
|
|
protected String sessionIdCol = "id";
|
|
|
|
/**
|
|
* Data column to use.
|
|
*/
|
|
protected String sessionDataCol = "data";
|
|
|
|
/**
|
|
* {@code Is Valid} column to use.
|
|
*/
|
|
protected String sessionValidCol = "valid";
|
|
|
|
/**
|
|
* Max Inactive column to use.
|
|
*/
|
|
protected String sessionMaxInactiveCol = "maxinactive";
|
|
|
|
/**
|
|
* Last Accessed column to use.
|
|
*/
|
|
protected String sessionLastAccessedCol = "lastaccess";
|
|
|
|
|
|
// ----------------------------------------------------------- SQL Variables
|
|
|
|
/**
|
|
* Variable to hold the <code>getSize()</code> prepared statement.
|
|
*/
|
|
protected PreparedStatement preparedSizeSql = null;
|
|
|
|
/**
|
|
* Variable to hold the <code>save()</code> prepared statement.
|
|
*/
|
|
protected PreparedStatement preparedSaveSql = null;
|
|
|
|
/**
|
|
* Variable to hold the <code>clear()</code> prepared statement.
|
|
*/
|
|
protected PreparedStatement preparedClearSql = null;
|
|
|
|
/**
|
|
* Variable to hold the <code>remove()</code> prepared statement.
|
|
*/
|
|
protected PreparedStatement preparedRemoveSql = null;
|
|
|
|
/**
|
|
* Variable to hold the <code>load()</code> prepared statement.
|
|
*/
|
|
protected PreparedStatement preparedLoadSql = null;
|
|
|
|
|
|
// -------------------------------------------------------------- Properties
|
|
|
|
/**
|
|
* @return the name for this instance (built from container name)
|
|
*/
|
|
public String getName() {
|
|
if (name == null) {
|
|
Container container = manager.getContext();
|
|
String contextName = container.getName();
|
|
if (!contextName.startsWith("/")) {
|
|
contextName = "/" + contextName;
|
|
}
|
|
String hostName = "";
|
|
String engineName = "";
|
|
|
|
if (container.getParent() != null) {
|
|
Container host = container.getParent();
|
|
hostName = host.getName();
|
|
if (host.getParent() != null) {
|
|
engineName = host.getParent().getName();
|
|
}
|
|
}
|
|
name = "/" + engineName + "/" + hostName + contextName;
|
|
}
|
|
return name;
|
|
}
|
|
|
|
/**
|
|
* @return the thread name for this Store.
|
|
*/
|
|
public String getThreadName() {
|
|
return threadName;
|
|
}
|
|
|
|
/**
|
|
* @return the name for this Store, used for logging.
|
|
*/
|
|
@Override
|
|
public String getStoreName() {
|
|
return storeName;
|
|
}
|
|
|
|
/**
|
|
* Set the driver for this Store.
|
|
*
|
|
* @param driverName The new driver
|
|
*/
|
|
public void setDriverName(String driverName) {
|
|
String oldDriverName = this.driverName;
|
|
this.driverName = driverName;
|
|
support.firePropertyChange("driverName",
|
|
oldDriverName,
|
|
this.driverName);
|
|
this.driverName = driverName;
|
|
}
|
|
|
|
/**
|
|
* @return the driver for this Store.
|
|
*/
|
|
public String getDriverName() {
|
|
return driverName;
|
|
}
|
|
|
|
/**
|
|
* @return the username to use to connect to the database.
|
|
*/
|
|
public String getConnectionName() {
|
|
return connectionName;
|
|
}
|
|
|
|
/**
|
|
* Set the username to use to connect to the database.
|
|
*
|
|
* @param connectionName Username
|
|
*/
|
|
public void setConnectionName(String connectionName) {
|
|
this.connectionName = connectionName;
|
|
}
|
|
|
|
/**
|
|
* @return the password to use to connect to the database.
|
|
*/
|
|
public String getConnectionPassword() {
|
|
return connectionPassword;
|
|
}
|
|
|
|
/**
|
|
* Set the password to use to connect to the database.
|
|
*
|
|
* @param connectionPassword User password
|
|
*/
|
|
public void setConnectionPassword(String connectionPassword) {
|
|
this.connectionPassword = connectionPassword;
|
|
}
|
|
|
|
/**
|
|
* Set the Connection URL for this Store.
|
|
*
|
|
* @param connectionURL The new Connection URL
|
|
*/
|
|
public void setConnectionURL(String connectionURL) {
|
|
String oldConnString = this.connectionURL;
|
|
this.connectionURL = connectionURL;
|
|
support.firePropertyChange("connectionURL",
|
|
oldConnString,
|
|
this.connectionURL);
|
|
}
|
|
|
|
/**
|
|
* @return the Connection URL for this Store.
|
|
*/
|
|
public String getConnectionURL() {
|
|
return connectionURL;
|
|
}
|
|
|
|
/**
|
|
* Set the table for this Store.
|
|
*
|
|
* @param sessionTable The new table
|
|
*/
|
|
public void setSessionTable(String sessionTable) {
|
|
String oldSessionTable = this.sessionTable;
|
|
this.sessionTable = sessionTable;
|
|
support.firePropertyChange("sessionTable",
|
|
oldSessionTable,
|
|
this.sessionTable);
|
|
}
|
|
|
|
/**
|
|
* @return the table for this Store.
|
|
*/
|
|
public String getSessionTable() {
|
|
return sessionTable;
|
|
}
|
|
|
|
/**
|
|
* Set the App column for the table.
|
|
*
|
|
* @param sessionAppCol the column name
|
|
*/
|
|
public void setSessionAppCol(String sessionAppCol) {
|
|
String oldSessionAppCol = this.sessionAppCol;
|
|
this.sessionAppCol = sessionAppCol;
|
|
support.firePropertyChange("sessionAppCol",
|
|
oldSessionAppCol,
|
|
this.sessionAppCol);
|
|
}
|
|
|
|
/**
|
|
* @return the web application name column for the table.
|
|
*/
|
|
public String getSessionAppCol() {
|
|
return this.sessionAppCol;
|
|
}
|
|
|
|
/**
|
|
* Set the Id column for the table.
|
|
*
|
|
* @param sessionIdCol the column name
|
|
*/
|
|
public void setSessionIdCol(String sessionIdCol) {
|
|
String oldSessionIdCol = this.sessionIdCol;
|
|
this.sessionIdCol = sessionIdCol;
|
|
support.firePropertyChange("sessionIdCol",
|
|
oldSessionIdCol,
|
|
this.sessionIdCol);
|
|
}
|
|
|
|
/**
|
|
* @return the Id column for the table.
|
|
*/
|
|
public String getSessionIdCol() {
|
|
return this.sessionIdCol;
|
|
}
|
|
|
|
/**
|
|
* Set the Data column for the table
|
|
*
|
|
* @param sessionDataCol the column name
|
|
*/
|
|
public void setSessionDataCol(String sessionDataCol) {
|
|
String oldSessionDataCol = this.sessionDataCol;
|
|
this.sessionDataCol = sessionDataCol;
|
|
support.firePropertyChange("sessionDataCol",
|
|
oldSessionDataCol,
|
|
this.sessionDataCol);
|
|
}
|
|
|
|
/**
|
|
* @return the data column for the table
|
|
*/
|
|
public String getSessionDataCol() {
|
|
return this.sessionDataCol;
|
|
}
|
|
|
|
/**
|
|
* Set the {@code Is Valid} column for the table
|
|
*
|
|
* @param sessionValidCol The column name
|
|
*/
|
|
public void setSessionValidCol(String sessionValidCol) {
|
|
String oldSessionValidCol = this.sessionValidCol;
|
|
this.sessionValidCol = sessionValidCol;
|
|
support.firePropertyChange("sessionValidCol",
|
|
oldSessionValidCol,
|
|
this.sessionValidCol);
|
|
}
|
|
|
|
/**
|
|
* @return the {@code Is Valid} column
|
|
*/
|
|
public String getSessionValidCol() {
|
|
return this.sessionValidCol;
|
|
}
|
|
|
|
/**
|
|
* Set the {@code Max Inactive} column for the table
|
|
*
|
|
* @param sessionMaxInactiveCol The column name
|
|
*/
|
|
public void setSessionMaxInactiveCol(String sessionMaxInactiveCol) {
|
|
String oldSessionMaxInactiveCol = this.sessionMaxInactiveCol;
|
|
this.sessionMaxInactiveCol = sessionMaxInactiveCol;
|
|
support.firePropertyChange("sessionMaxInactiveCol",
|
|
oldSessionMaxInactiveCol,
|
|
this.sessionMaxInactiveCol);
|
|
}
|
|
|
|
/**
|
|
* @return the {@code Max Inactive} column
|
|
*/
|
|
public String getSessionMaxInactiveCol() {
|
|
return this.sessionMaxInactiveCol;
|
|
}
|
|
|
|
/**
|
|
* Set the {@code Last Accessed} column for the table
|
|
*
|
|
* @param sessionLastAccessedCol The column name
|
|
*/
|
|
public void setSessionLastAccessedCol(String sessionLastAccessedCol) {
|
|
String oldSessionLastAccessedCol = this.sessionLastAccessedCol;
|
|
this.sessionLastAccessedCol = sessionLastAccessedCol;
|
|
support.firePropertyChange("sessionLastAccessedCol",
|
|
oldSessionLastAccessedCol,
|
|
this.sessionLastAccessedCol);
|
|
}
|
|
|
|
/**
|
|
* @return the {@code Last Accessed} column
|
|
*/
|
|
public String getSessionLastAccessedCol() {
|
|
return this.sessionLastAccessedCol;
|
|
}
|
|
|
|
/**
|
|
* Set the JNDI name of a DataSource-factory to use for db access
|
|
*
|
|
* @param dataSourceName The JNDI name of the DataSource-factory
|
|
*/
|
|
public void setDataSourceName(String dataSourceName) {
|
|
if (dataSourceName == null || "".equals(dataSourceName.trim())) {
|
|
manager.getContext().getLogger().warn(
|
|
sm.getString(getStoreName() + ".missingDataSourceName"));
|
|
return;
|
|
}
|
|
this.dataSourceName = dataSourceName;
|
|
}
|
|
|
|
/**
|
|
* @return the name of the JNDI DataSource-factory
|
|
*/
|
|
public String getDataSourceName() {
|
|
return this.dataSourceName;
|
|
}
|
|
|
|
/**
|
|
* @return if the datasource will be looked up in the webapp JNDI Context.
|
|
*/
|
|
public boolean getLocalDataSource() {
|
|
return localDataSource;
|
|
}
|
|
|
|
/**
|
|
* Set to {@code true} to cause the datasource to be looked up in the webapp
|
|
* JNDI Context.
|
|
*
|
|
* @param localDataSource the new flag value
|
|
*/
|
|
public void setLocalDataSource(boolean localDataSource) {
|
|
this.localDataSource = localDataSource;
|
|
}
|
|
|
|
|
|
// --------------------------------------------------------- Public Methods
|
|
|
|
@Override
|
|
public String[] expiredKeys() throws IOException {
|
|
return keys(true);
|
|
}
|
|
|
|
@Override
|
|
public String[] keys() throws IOException {
|
|
return keys(false);
|
|
}
|
|
|
|
/**
|
|
* Return an array containing the session identifiers of all Sessions
|
|
* currently saved in this Store. If there are no such Sessions, a
|
|
* zero-length array is returned.
|
|
*
|
|
* @param expiredOnly flag, whether only keys of expired sessions should
|
|
* be returned
|
|
* @return array containing the list of session IDs
|
|
*
|
|
* @exception IOException if an input/output error occurred
|
|
*/
|
|
private String[] keys(boolean expiredOnly) throws IOException {
|
|
String keys[] = null;
|
|
synchronized (this) {
|
|
int numberOfTries = 2;
|
|
while (numberOfTries > 0) {
|
|
|
|
Connection _conn = getConnection();
|
|
if (_conn == null) {
|
|
return new String[0];
|
|
}
|
|
try {
|
|
|
|
String keysSql = "SELECT " + sessionIdCol + " FROM "
|
|
+ sessionTable + " WHERE " + sessionAppCol + " = ?";
|
|
if (expiredOnly) {
|
|
keysSql += " AND (" + sessionLastAccessedCol + " + "
|
|
+ sessionMaxInactiveCol + " * 1000 < ?)";
|
|
}
|
|
try (PreparedStatement preparedKeysSql = _conn.prepareStatement(keysSql)) {
|
|
preparedKeysSql.setString(1, getName());
|
|
if (expiredOnly) {
|
|
preparedKeysSql.setLong(2, System.currentTimeMillis());
|
|
}
|
|
try (ResultSet rst = preparedKeysSql.executeQuery()) {
|
|
ArrayList<String> tmpkeys = new ArrayList<>();
|
|
if (rst != null) {
|
|
while (rst.next()) {
|
|
tmpkeys.add(rst.getString(1));
|
|
}
|
|
}
|
|
keys = tmpkeys.toArray(new String[tmpkeys.size()]);
|
|
// Break out after the finally block
|
|
numberOfTries = 0;
|
|
}
|
|
}
|
|
} catch (SQLException e) {
|
|
manager.getContext().getLogger().error(sm.getString(getStoreName() + ".SQLException", e));
|
|
keys = new String[0];
|
|
// Close the connection so that it gets reopened next time
|
|
if (dbConnection != null)
|
|
close(dbConnection);
|
|
} finally {
|
|
release(_conn);
|
|
}
|
|
numberOfTries--;
|
|
}
|
|
}
|
|
return keys;
|
|
}
|
|
|
|
/**
|
|
* Return an integer containing a count of all Sessions
|
|
* currently saved in this Store. If there are no Sessions,
|
|
* <code>0</code> is returned.
|
|
*
|
|
* @return the count of all sessions currently saved in this Store
|
|
*
|
|
* @exception IOException if an input/output error occurred
|
|
*/
|
|
@Override
|
|
public int getSize() throws IOException {
|
|
int size = 0;
|
|
|
|
synchronized (this) {
|
|
int numberOfTries = 2;
|
|
while (numberOfTries > 0) {
|
|
Connection _conn = getConnection();
|
|
|
|
if (_conn == null) {
|
|
return size;
|
|
}
|
|
|
|
try {
|
|
if (preparedSizeSql == null) {
|
|
String sizeSql = "SELECT COUNT(" + sessionIdCol
|
|
+ ") FROM " + sessionTable + " WHERE "
|
|
+ sessionAppCol + " = ?";
|
|
preparedSizeSql = _conn.prepareStatement(sizeSql);
|
|
}
|
|
|
|
preparedSizeSql.setString(1, getName());
|
|
try (ResultSet rst = preparedSizeSql.executeQuery()) {
|
|
if (rst.next()) {
|
|
size = rst.getInt(1);
|
|
}
|
|
// Break out after the finally block
|
|
numberOfTries = 0;
|
|
}
|
|
} catch (SQLException e) {
|
|
manager.getContext().getLogger().error(sm.getString(getStoreName() + ".SQLException", e));
|
|
if (dbConnection != null)
|
|
close(dbConnection);
|
|
} finally {
|
|
release(_conn);
|
|
}
|
|
numberOfTries--;
|
|
}
|
|
}
|
|
return size;
|
|
}
|
|
|
|
/**
|
|
* Load the Session associated with the id <code>id</code>.
|
|
* If no such session is found <code>null</code> is returned.
|
|
*
|
|
* @param id a value of type <code>String</code>
|
|
* @return the stored <code>Session</code>
|
|
* @exception ClassNotFoundException if an error occurs
|
|
* @exception IOException if an input/output error occurred
|
|
*/
|
|
@Override
|
|
public Session load(String id) throws ClassNotFoundException, IOException {
|
|
StandardSession _session = null;
|
|
org.apache.catalina.Context context = getManager().getContext();
|
|
Log contextLog = context.getLogger();
|
|
|
|
synchronized (this) {
|
|
int numberOfTries = 2;
|
|
while (numberOfTries > 0) {
|
|
Connection _conn = getConnection();
|
|
if (_conn == null) {
|
|
return null;
|
|
}
|
|
|
|
ClassLoader oldThreadContextCL = context.bind(Globals.IS_SECURITY_ENABLED, null);
|
|
|
|
try {
|
|
if (preparedLoadSql == null) {
|
|
String loadSql = "SELECT " + sessionIdCol + ", "
|
|
+ sessionDataCol + " FROM " + sessionTable
|
|
+ " WHERE " + sessionIdCol + " = ? AND "
|
|
+ sessionAppCol + " = ?";
|
|
preparedLoadSql = _conn.prepareStatement(loadSql);
|
|
}
|
|
|
|
preparedLoadSql.setString(1, id);
|
|
preparedLoadSql.setString(2, getName());
|
|
try (ResultSet rst = preparedLoadSql.executeQuery()) {
|
|
if (rst.next()) {
|
|
try (ObjectInputStream ois =
|
|
getObjectInputStream(rst.getBinaryStream(2))) {
|
|
if (contextLog.isDebugEnabled()) {
|
|
contextLog.debug(sm.getString(
|
|
getStoreName() + ".loading", id, sessionTable));
|
|
}
|
|
|
|
_session = (StandardSession) manager.createEmptySession();
|
|
_session.readObjectData(ois);
|
|
_session.setManager(manager);
|
|
}
|
|
} else if (context.getLogger().isDebugEnabled()) {
|
|
contextLog.debug(getStoreName() + ": No persisted data object found");
|
|
}
|
|
// Break out after the finally block
|
|
numberOfTries = 0;
|
|
}
|
|
} catch (SQLException e) {
|
|
contextLog.error(sm.getString(getStoreName() + ".SQLException", e));
|
|
if (dbConnection != null)
|
|
close(dbConnection);
|
|
} finally {
|
|
context.unbind(Globals.IS_SECURITY_ENABLED, oldThreadContextCL);
|
|
release(_conn);
|
|
}
|
|
numberOfTries--;
|
|
}
|
|
}
|
|
|
|
return _session;
|
|
}
|
|
|
|
/**
|
|
* Remove the Session with the specified session identifier from
|
|
* this Store, if present. If no such Session is present, this method
|
|
* takes no action.
|
|
*
|
|
* @param id Session identifier of the Session to be removed
|
|
*
|
|
* @exception IOException if an input/output error occurs
|
|
*/
|
|
@Override
|
|
public void remove(String id) throws IOException {
|
|
|
|
synchronized (this) {
|
|
int numberOfTries = 2;
|
|
while (numberOfTries > 0) {
|
|
Connection _conn = getConnection();
|
|
|
|
if (_conn == null) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
remove(id, _conn);
|
|
// Break out after the finally block
|
|
numberOfTries = 0;
|
|
} catch (SQLException e) {
|
|
manager.getContext().getLogger().error(sm.getString(getStoreName() + ".SQLException", e));
|
|
if (dbConnection != null)
|
|
close(dbConnection);
|
|
} finally {
|
|
release(_conn);
|
|
}
|
|
numberOfTries--;
|
|
}
|
|
}
|
|
|
|
if (manager.getContext().getLogger().isDebugEnabled()) {
|
|
manager.getContext().getLogger().debug(sm.getString(getStoreName() + ".removing", id, sessionTable));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Remove the Session with the specified session identifier from
|
|
* this Store, if present. If no such Session is present, this method
|
|
* takes no action.
|
|
*
|
|
* @param id Session identifier of the Session to be removed
|
|
* @param _conn open connection to be used
|
|
* @throws SQLException if an error occurs while talking to the database
|
|
*/
|
|
private void remove(String id, Connection _conn) throws SQLException {
|
|
if (preparedRemoveSql == null) {
|
|
String removeSql = "DELETE FROM " + sessionTable
|
|
+ " WHERE " + sessionIdCol + " = ? AND "
|
|
+ sessionAppCol + " = ?";
|
|
preparedRemoveSql = _conn.prepareStatement(removeSql);
|
|
}
|
|
|
|
preparedRemoveSql.setString(1, id);
|
|
preparedRemoveSql.setString(2, getName());
|
|
preparedRemoveSql.execute();
|
|
}
|
|
|
|
/**
|
|
* Remove all of the Sessions in this Store.
|
|
*
|
|
* @exception IOException if an input/output error occurs
|
|
*/
|
|
@Override
|
|
public void clear() throws IOException {
|
|
|
|
synchronized (this) {
|
|
int numberOfTries = 2;
|
|
while (numberOfTries > 0) {
|
|
Connection _conn = getConnection();
|
|
if (_conn == null) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
if (preparedClearSql == null) {
|
|
String clearSql = "DELETE FROM " + sessionTable
|
|
+ " WHERE " + sessionAppCol + " = ?";
|
|
preparedClearSql = _conn.prepareStatement(clearSql);
|
|
}
|
|
|
|
preparedClearSql.setString(1, getName());
|
|
preparedClearSql.execute();
|
|
// Break out after the finally block
|
|
numberOfTries = 0;
|
|
} catch (SQLException e) {
|
|
manager.getContext().getLogger().error(sm.getString(getStoreName() + ".SQLException", e));
|
|
if (dbConnection != null)
|
|
close(dbConnection);
|
|
} finally {
|
|
release(_conn);
|
|
}
|
|
numberOfTries--;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Save a session to the Store.
|
|
*
|
|
* @param session the session to be stored
|
|
* @exception IOException if an input/output error occurs
|
|
*/
|
|
@Override
|
|
public void save(Session session) throws IOException {
|
|
ByteArrayOutputStream bos = null;
|
|
|
|
synchronized (this) {
|
|
int numberOfTries = 2;
|
|
while (numberOfTries > 0) {
|
|
Connection _conn = getConnection();
|
|
if (_conn == null) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
// If sessions already exist in DB, remove and insert again.
|
|
// TODO:
|
|
// * Check if ID exists in database and if so use UPDATE.
|
|
remove(session.getIdInternal(), _conn);
|
|
|
|
bos = new ByteArrayOutputStream();
|
|
try (ObjectOutputStream oos =
|
|
new ObjectOutputStream(new BufferedOutputStream(bos))) {
|
|
((StandardSession) session).writeObjectData(oos);
|
|
}
|
|
byte[] obs = bos.toByteArray();
|
|
int size = obs.length;
|
|
try (ByteArrayInputStream bis = new ByteArrayInputStream(obs, 0, size);
|
|
InputStream in = new BufferedInputStream(bis, size)) {
|
|
if (preparedSaveSql == null) {
|
|
String saveSql = "INSERT INTO " + sessionTable + " ("
|
|
+ sessionIdCol + ", " + sessionAppCol + ", "
|
|
+ sessionDataCol + ", " + sessionValidCol
|
|
+ ", " + sessionMaxInactiveCol + ", "
|
|
+ sessionLastAccessedCol
|
|
+ ") VALUES (?, ?, ?, ?, ?, ?)";
|
|
preparedSaveSql = _conn.prepareStatement(saveSql);
|
|
}
|
|
|
|
preparedSaveSql.setString(1, session.getIdInternal());
|
|
preparedSaveSql.setString(2, getName());
|
|
preparedSaveSql.setBinaryStream(3, in, size);
|
|
preparedSaveSql.setString(4, session.isValid() ? "1" : "0");
|
|
preparedSaveSql.setInt(5, session.getMaxInactiveInterval());
|
|
preparedSaveSql.setLong(6, session.getLastAccessedTime());
|
|
preparedSaveSql.execute();
|
|
// Break out after the finally block
|
|
numberOfTries = 0;
|
|
}
|
|
} catch (SQLException e) {
|
|
manager.getContext().getLogger().error(sm.getString(getStoreName() + ".SQLException", e));
|
|
if (dbConnection != null)
|
|
close(dbConnection);
|
|
} catch (IOException e) {
|
|
// Ignore
|
|
} finally {
|
|
release(_conn);
|
|
}
|
|
numberOfTries--;
|
|
}
|
|
}
|
|
|
|
if (manager.getContext().getLogger().isDebugEnabled()) {
|
|
manager.getContext().getLogger().debug(sm.getString(getStoreName() + ".saving",
|
|
session.getIdInternal(), sessionTable));
|
|
}
|
|
}
|
|
|
|
|
|
// --------------------------------------------------------- Protected Methods
|
|
|
|
/**
|
|
* Check the connection associated with this store, if it's
|
|
* <code>null</code> or closed try to reopen it.
|
|
* Returns <code>null</code> if the connection could not be established.
|
|
*
|
|
* @return <code>Connection</code> if the connection succeeded
|
|
*/
|
|
protected Connection getConnection() {
|
|
Connection conn = null;
|
|
try {
|
|
conn = open();
|
|
if (conn == null || conn.isClosed()) {
|
|
manager.getContext().getLogger().info(sm.getString(getStoreName() + ".checkConnectionDBClosed"));
|
|
conn = open();
|
|
if (conn == null || conn.isClosed()) {
|
|
manager.getContext().getLogger().info(sm.getString(getStoreName() + ".checkConnectionDBReOpenFail"));
|
|
}
|
|
}
|
|
} catch (SQLException ex) {
|
|
manager.getContext().getLogger().error(sm.getString(getStoreName() + ".checkConnectionSQLException",
|
|
ex.toString()));
|
|
}
|
|
|
|
return conn;
|
|
}
|
|
|
|
/**
|
|
* Open (if necessary) and return a database connection for use by
|
|
* this Store.
|
|
*
|
|
* @return database connection ready to use
|
|
*
|
|
* @exception SQLException if a database error occurs
|
|
*/
|
|
protected Connection open() throws SQLException {
|
|
|
|
// Do nothing if there is a database connection already open
|
|
if (dbConnection != null)
|
|
return dbConnection;
|
|
|
|
if (dataSourceName != null && dataSource == null) {
|
|
org.apache.catalina.Context context = getManager().getContext();
|
|
ClassLoader oldThreadContextCL = null;
|
|
if (localDataSource) {
|
|
oldThreadContextCL = context.bind(Globals.IS_SECURITY_ENABLED, null);
|
|
}
|
|
|
|
Context initCtx;
|
|
try {
|
|
initCtx = new InitialContext();
|
|
Context envCtx = (Context) initCtx.lookup("java:comp/env");
|
|
this.dataSource = (DataSource) envCtx.lookup(this.dataSourceName);
|
|
} catch (NamingException e) {
|
|
context.getLogger().error(
|
|
sm.getString(getStoreName() + ".wrongDataSource",
|
|
this.dataSourceName), e);
|
|
} finally {
|
|
if (localDataSource) {
|
|
context.unbind(Globals.IS_SECURITY_ENABLED, oldThreadContextCL);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dataSource != null) {
|
|
return dataSource.getConnection();
|
|
}
|
|
|
|
// Instantiate our database driver if necessary
|
|
if (driver == null) {
|
|
try {
|
|
Class<?> clazz = Class.forName(driverName);
|
|
driver = (Driver) clazz.getConstructor().newInstance();
|
|
} catch (ReflectiveOperationException e) {
|
|
manager.getContext().getLogger().error(
|
|
sm.getString(getStoreName() + ".checkConnectionClassNotFoundException",
|
|
e.toString()));
|
|
throw new SQLException(e);
|
|
}
|
|
}
|
|
|
|
// Open a new connection
|
|
Properties props = new Properties();
|
|
if (connectionName != null)
|
|
props.put("user", connectionName);
|
|
if (connectionPassword != null)
|
|
props.put("password", connectionPassword);
|
|
dbConnection = driver.connect(connectionURL, props);
|
|
dbConnection.setAutoCommit(true);
|
|
return dbConnection;
|
|
|
|
}
|
|
|
|
/**
|
|
* Close the specified database connection.
|
|
*
|
|
* @param dbConnection The connection to be closed
|
|
*/
|
|
protected void close(Connection dbConnection) {
|
|
|
|
// Do nothing if the database connection is already closed
|
|
if (dbConnection == null)
|
|
return;
|
|
|
|
// Close our prepared statements (if any)
|
|
try {
|
|
preparedSizeSql.close();
|
|
} catch (Throwable f) {
|
|
ExceptionUtils.handleThrowable(f);
|
|
}
|
|
this.preparedSizeSql = null;
|
|
|
|
try {
|
|
preparedSaveSql.close();
|
|
} catch (Throwable f) {
|
|
ExceptionUtils.handleThrowable(f);
|
|
}
|
|
this.preparedSaveSql = null;
|
|
|
|
try {
|
|
preparedClearSql.close();
|
|
} catch (Throwable f) {
|
|
ExceptionUtils.handleThrowable(f);
|
|
}
|
|
|
|
try {
|
|
preparedRemoveSql.close();
|
|
} catch (Throwable f) {
|
|
ExceptionUtils.handleThrowable(f);
|
|
}
|
|
this.preparedRemoveSql = null;
|
|
|
|
try {
|
|
preparedLoadSql.close();
|
|
} catch (Throwable f) {
|
|
ExceptionUtils.handleThrowable(f);
|
|
}
|
|
this.preparedLoadSql = null;
|
|
|
|
// Commit if autoCommit is false
|
|
try {
|
|
if (!dbConnection.getAutoCommit()) {
|
|
dbConnection.commit();
|
|
}
|
|
} catch (SQLException e) {
|
|
manager.getContext().getLogger().error(sm.getString(getStoreName() + ".commitSQLException"), e);
|
|
}
|
|
|
|
// Close this database connection, and log any errors
|
|
try {
|
|
dbConnection.close();
|
|
} catch (SQLException e) {
|
|
manager.getContext().getLogger().error(sm.getString(getStoreName() + ".close", e.toString())); // Just log it here
|
|
} finally {
|
|
this.dbConnection = null;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Release the connection, if it
|
|
* is associated with a connection pool.
|
|
*
|
|
* @param conn The connection to be released
|
|
*/
|
|
protected void release(Connection conn) {
|
|
if (dataSource != null) {
|
|
close(conn);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Start this component and implement the requirements
|
|
* of {@link org.apache.catalina.util.LifecycleBase#startInternal()}.
|
|
*
|
|
* @exception LifecycleException if this component detects a fatal error
|
|
* that prevents this component from being used
|
|
*/
|
|
@Override
|
|
protected synchronized void startInternal() throws LifecycleException {
|
|
|
|
if (dataSourceName == null) {
|
|
// If not using a connection pool, open a connection to the database
|
|
this.dbConnection = getConnection();
|
|
}
|
|
|
|
super.startInternal();
|
|
}
|
|
|
|
/**
|
|
* Stop this component and implement the requirements
|
|
* of {@link org.apache.catalina.util.LifecycleBase#stopInternal()}.
|
|
*
|
|
* @exception LifecycleException if this component detects a fatal error
|
|
* that prevents this component from being used
|
|
*/
|
|
@Override
|
|
protected synchronized void stopInternal() throws LifecycleException {
|
|
|
|
super.stopInternal();
|
|
|
|
// Close and release everything associated with our db.
|
|
if (dbConnection != null) {
|
|
try {
|
|
dbConnection.commit();
|
|
} catch (SQLException e) {
|
|
// Ignore
|
|
}
|
|
close(dbConnection);
|
|
}
|
|
}
|
|
}
|