true if the tables exist;
+ * false otherwise.
+ *
+ * @throws SQLException if a database error occurs.
+ * @throws RepositoryException if a repository exception occurs.
+ */
+ protected boolean checkTablesExist() throws SQLException, RepositoryException {
+ DatabaseMetaData metaData = connectionManager.getConnection().getMetaData();
+ String tableName = schemaObjectPrefix + "BUNDLE";
+ if (metaData.storesLowerCaseIdentifiers()) {
+ tableName = tableName.toLowerCase();
+ } else if (metaData.storesUpperCaseIdentifiers()) {
+ tableName = tableName.toUpperCase();
+ }
+ String userName = checkTablesWithUser() ? metaData.getUserName() : null;
+ ResultSet rs = metaData.getTables(null, userName, tableName, null);
+ try {
+ return rs.next();
+ } finally {
+ rs.close();
+ }
+ }
+
+ /**
+ * Indicates if the user name should be included when retrieving the tables
+ * during {@link #checkTablesExist()}.
+ *
+ * Please note that this currently only needs to be changed for oracle based
+ * persistence managers.
+ *
+ * @return false
+ */
+ protected boolean checkTablesWithUser() {
+ return false;
+ }
+
+ /**
* {@inheritDoc}
*
* Basically wraps a JDBC transaction around super.store().
*/
public synchronized void store(ChangeLog changeLog) throws ItemStateException {
- int failures = 0;
- ItemStateException lastException = null;
- while (failures <= 1) { // retry once
+ int trials = 2;
+ Throwable lastException = null;
+ do {
+ trials--;
+ Connection con = null;
try {
- conHelper.startBatch();
+ con = connectionManager.getConnection();
+ connectionManager.setAutoReconnect(false);
+ con.setAutoCommit(false);
super.store(changeLog);
- conHelper.endBatch(true);
+ con.commit();
+ con.setAutoCommit(true);
return;
- } catch (SQLException e) {
- // Either startBatch or stopBatch threw it: either way the
- // transaction was not persisted and no action needs to be taken.
- failures++;
- lastException = new ItemStateException(e.getMessage(), e);
- } catch (ItemStateException e) {
- // store call threw it: we need to cancel the transaction
- failures++;
- lastException = e;
+ } catch (Throwable th) {
+ lastException = th;
try {
- conHelper.endBatch(false);
- } catch (SQLException e2) {
- DbUtility.logException("rollback failed", e2);
+ if (con != null) {
+ con.rollback();
+ }
+ } catch (SQLException e) {
+ logException("rollback failed", e);
}
+ if (th instanceof SQLException || th.getCause() instanceof SQLException) {
+ connectionManager.close();
+ }
+ } finally {
+ connectionManager.setAutoReconnect(true);
}
- }
- throw lastException;
+ } while(blockOnConnectionLoss || trials > 0);
+ throw new ItemStateException(lastException.getMessage(), lastException);
}
/**
@@ -504,16 +592,17 @@
}
super.init(context);
- conHelper = createConnectionHelper(getDataSource());
-
- this.name = context.getHomeDir().getName();
+ this.name = context.getHomeDir().getName();
+ connectionManager = new ConnectionRecoveryManager(blockOnConnectionLoss,
+ getDriver(), getUrl(), getUser(), getPassword());
+
// make sure schemaObjectPrefix consists of legal name characters only
- schemaObjectPrefix = conHelper.prepareDbIdentifier(schemaObjectPrefix);
+ prepareSchemaObjectPrefix();
// check if schema objects exist and create them if necessary
if (isSchemaCheckEnabled()) {
- createCheckSchemaOperation().run();
+ checkSchema();
}
// create correct blob store
@@ -531,48 +620,9 @@
// check all bundles
checkConsistency(null, true, consistencyFix);
}
-
}
- private DataSource getDataSource() throws Exception {
- if (getDataSourceName() == null || "".equals(getDataSourceName())) {
- return connectionFactory.getDataSource(getDriver(), getUrl(), getUser(), getPassword());
- } else {
- String dbType = connectionFactory.getDataBaseType(dataSourceName);
- if (BundleDbPersistenceManager.class.getResourceAsStream(dbType + ".ddl") != null) {
- setDatabaseType(dbType);
- }
- return connectionFactory.getDataSource(dataSourceName);
- }
- }
-
/**
- * This method is called from the {@link #init(PMContext)} method of this class and returns a
- * {@link ConnectionHelper} instance which is assigned to the {@code conHelper} field. Subclasses may
- * override it to return a specialized connection helper.
- *
- * @param dataSrc the {@link DataSource} of this persistence manager
- * @return a {@link ConnectionHelper}
- * @throws Exception on error
- */
- protected ConnectionHelper createConnectionHelper(DataSource dataSrc) throws Exception {
- return new ConnectionHelper(dataSrc, blockOnConnectionLoss);
- }
-
- /**
- * This method is called from {@link #init(PMContext)} after the
- * {@link #createConnectionHelper(DataSource)} method, and returns a default {@link CheckSchemaOperation}.
- * Subclasses can overrride this implementation to get a customized implementation.
- *
- * @return a new {@link CheckSchemaOperation} instance
- */
- protected CheckSchemaOperation createCheckSchemaOperation() {
- InputStream in = BundleDbPersistenceManager.class.getResourceAsStream(databaseType + ".ddl");
- return new CheckSchemaOperation(conHelper, in, schemaObjectPrefix + "BUNDLE").addVariableReplacement(
- CheckSchemaOperation.SCHEMA_OBJECT_PREFIX_VARIABLE, schemaObjectPrefix);
- }
-
- /**
* {@inheritDoc}
*/
protected BundleBinding getBinding() {
@@ -623,7 +673,7 @@
* @throws SQLException if an SQL error occurs.
*/
protected DbNameIndex createDbNameIndex() throws SQLException {
- return new DbNameIndex(conHelper, schemaObjectPrefix);
+ return new DbNameIndex(connectionManager, schemaObjectPrefix);
}
/**
@@ -740,33 +790,40 @@
}
}
+ /**
+ * {@inheritDoc}
+ */
public void checkConsistency(String[] uuids, boolean recursive, boolean fix) {
+ log.info("{}: checking workspace consistency...", name);
+
int count = 0;
int total = 0;
- CollectionschemaObjectPrefix does only consist of
+ * characters that are allowed in names on the target database. Illegal
+ * characters will be escaped as necessary.
+ *
+ * @throws Exception if an error occurs
+ */
+ protected void prepareSchemaObjectPrefix() throws Exception {
+ DatabaseMetaData metaData = connectionManager.getConnection().getMetaData();
+ String legalChars = metaData.getExtraNameCharacters();
+ legalChars += "ABCDEFGHIJKLMNOPQRSTUVWXZY0123456789_";
+
+ String prefix = schemaObjectPrefix.toUpperCase();
+ StringBuffer escaped = new StringBuffer();
+ for (int i = 0; i < prefix.length(); i++) {
+ char c = prefix.charAt(i);
+ if (legalChars.indexOf(c) == -1) {
+ escaped.append("_x");
+ String hex = Integer.toHexString(c);
+ escaped.append("0000".toCharArray(), 0, 4 - hex.length());
+ escaped.append(hex);
+ escaped.append("_");
+ } else {
+ escaped.append(c);
+ }
+ }
+ schemaObjectPrefix = escaped.toString();
+ }
+
+ /**
* {@inheritDoc}
*/
public synchronized void close() throws Exception {
@@ -898,7 +985,8 @@
try {
if (nameIndex instanceof DbNameIndex) {
((DbNameIndex) nameIndex).close();
- }
+ }
+ connectionManager.close();
// close blob store
blobStore.close();
blobStore = null;
@@ -979,7 +1067,8 @@
// see also bundleSelectAllIdsFrom SQL statement
maxCount += 10;
}
- rs = conHelper.exec(sql, keys, false, maxCount);
+ Statement stmt = connectionManager.executeStmt(sql, keys, false, maxCount);
+ rs = stmt.getResultSet();
ArrayListPreparedStatement by clearing the
+ * parameters and warnings contained.
+ *
+ * @param stmt The PreparedStatement to reset. If
+ * null this method does nothing.
+ */
+ protected synchronized void resetStatement(PreparedStatement stmt) {
+ if (stmt != null) {
+ try {
+ stmt.clearParameters();
+ stmt.clearWarnings();
+ } catch (SQLException se) {
+ logException("Failed resetting PreparedStatement", se);
+ }
+ }
+ }
+
+ /**
+ * Closes the result set
+ * @param rs the result set
+ */
+ protected void closeResultSet(ResultSet rs) {
+ if (rs != null) {
+ try {
+ rs.close();
+ } catch (SQLException se) {
+ logException("Failed closing ResultSet", se);
+ }
+ }
+ }
+
+ /**
+ * closes the statement
+ * @param stmt the statement
+ */
+ protected void closeStatement(PreparedStatement stmt) {
+ if (stmt != null) {
+ try {
+ stmt.close();
+ } catch (SQLException se) {
+ logException("Failed closing PreparedStatement", se);
+ }
+ }
+ }
+
+ /**
+ * logs an sql exception
+ * @param message the message
+ * @param e the exception
+ */
+ protected void logException(String message, SQLException e) {
+ if (message != null) {
+ log.error(message);
+ }
+ log.error(" Reason: " + e.getMessage());
+ log.error(" State/Code: " + e.getSQLState() + "/" + e.getErrorCode());
+ log.debug(" dump:", e);
+ }
+
+ /**
* @inheritDoc
*/
public String toString() {
@@ -1378,40 +1533,31 @@
* {@inheritDoc}
*/
public InputStream get(String blobId) throws Exception {
- ResultSet rs = null;
- boolean close = true;
- try {
- rs = conHelper.exec(blobSelectSQL, new Object[]{blobId}, false, 0);
- if (!rs.next()) {
- throw new Exception("no such BLOB: " + blobId);
- }
+ Statement stmt = connectionManager.executeStmt(blobSelectSQL, new Object[]{blobId});
+ final ResultSet rs = stmt.getResultSet();
+ if (!rs.next()) {
+ closeResultSet(rs);
+ throw new Exception("no such BLOB: " + blobId);
+ }
+ InputStream in = rs.getBinaryStream(1);
+ if (in == null) {
+ // some databases treat zero-length values as NULL;
+ // return empty InputStream in such a case
+ closeResultSet(rs);
+ return new ByteArrayInputStream(new byte[0]);
+ }
- InputStream in = rs.getBinaryStream(1);
- if (in == null) {
- // some databases treat zero-length values as NULL;
- // return empty InputStream in such a case
- return new ByteArrayInputStream(new byte[0]);
+ /**
+ * return an InputStream wrapper in order to
+ * close the ResultSet when the stream is closed
+ */
+ return new FilterInputStream(in) {
+ public void close() throws IOException {
+ in.close();
+ // now it's safe to close ResultSet
+ closeResultSet(rs);
}
-
- // return an InputStream wrapper in order to close the ResultSet when the stream is closed
- close = false;
- final ResultSet rs2 = rs;
- return new FilterInputStream(in) {
-
- public void close() throws IOException {
- try {
- in.close();
- } finally {
- // now it's safe to close ResultSet
- DbUtility.close(rs2);
- }
- }
- };
- } finally {
- if (close) {
- DbUtility.close(rs);
- }
- }
+ };
}
/**
@@ -1419,25 +1565,23 @@
*/
public synchronized void put(String blobId, InputStream in, long size)
throws Exception {
- ResultSet rs = null;
- boolean exists;
- try {
- rs = conHelper.exec(blobSelectExistSQL, new Object[]{blobId}, false, 0);
- // a BLOB exists if the result has at least one entry
- exists = rs.next();
- } finally {
- DbUtility.close(rs);
- }
+ Statement stmt = connectionManager.executeStmt(blobSelectExistSQL, new Object[]{blobId});
+ ResultSet rs = stmt.getResultSet();
+ // a BLOB exists if the result has at least one entry
+ boolean exists = rs.next();
+ closeResultSet(rs);
+
String sql = (exists) ? blobUpdateSQL : blobInsertSQL;
- Object[] params = new Object[]{new StreamWrapper(in, size), blobId};
- conHelper.exec(sql, params);
+ Object[] params = new Object[]{new ConnectionRecoveryManager.StreamWrapper(in, size), blobId};
+ connectionManager.executeStmt(sql, params);
}
/**
* {@inheritDoc}
*/
public synchronized boolean remove(String blobId) throws Exception {
- return conHelper.update(blobDeleteSQL, new Object[]{blobId}) == 1;
+ Statement stmt = connectionManager.executeStmt(blobDeleteSQL, new Object[]{blobId});
+ return stmt.getUpdateCount() == 1;
}
public void close() {
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/MSSqlPersistenceManager.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/MSSqlPersistenceManager.java (.../sandbox/JCR-1456) (revision 827970)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/MSSqlPersistenceManager.java (.../trunk) (revision 827970)
@@ -16,10 +16,12 @@
*/
package org.apache.jackrabbit.core.persistence.bundle;
-import org.apache.jackrabbit.core.util.db.CheckSchemaOperation;
+import org.apache.jackrabbit.util.Text;
/**
- * Extends the {@link BundleDbPersistenceManager} by MS-SQL specific code. Configuration:true
*/
- @Override
- protected ConnectionHelper createConnectionHelper(DataSource dataSrc) throws Exception {
- OracleConnectionHelper helper = new OracleConnectionHelper(dataSrc, blockOnConnectionLoss);
- helper.init();
- return helper;
+ protected boolean checkTablesWithUser() {
+ return true;
}
/**
* {@inheritDoc}
*/
- @Override
- protected CheckSchemaOperation createCheckSchemaOperation() {
- return super.createCheckSchemaOperation().addVariableReplacement(
- CheckSchemaOperation.TABLE_SPACE_VARIABLE, tableSpace);
+ protected String createSchemaSQL(String sql) {
+ sql = Text.replace(sql, SCHEMA_OBJECT_PREFIX_VARIABLE, schemaObjectPrefix).trim();
+ // set the tablespace if it is defined
+ String tspace;
+ if (tableSpace == null || "".equals(tableSpace)) {
+ tspace = "";
+ } else {
+ tspace = "tablespace " + tableSpace;
+ }
+ return Text.replace(sql, TABLE_SPACE_VARIABLE, tspace).trim();
}
+
+ /**
+ * Since Oracle only supports table names up to 30 characters in
+ * length illegal characters are simply replaced with "_" rather than
+ * escaping them with "_x0000_".
+ *
+ * @inheritDoc
+ */
+ protected void prepareSchemaObjectPrefix() throws Exception {
+ DatabaseMetaData metaData = connectionManager.getConnection().getMetaData();
+ String legalChars = metaData.getExtraNameCharacters();
+ legalChars += "ABCDEFGHIJKLMNOPQRSTUVWXZY0123456789_";
+
+ String prefix = schemaObjectPrefix.toUpperCase();
+ StringBuffer escaped = new StringBuffer();
+ for (int i = 0; i < prefix.length(); i++) {
+ char c = prefix.charAt(i);
+ if (legalChars.indexOf(c) == -1) {
+ escaped.append('_');
+ } else {
+ escaped.append(c);
+ }
+ }
+ schemaObjectPrefix = escaped.toString();
+ }
}
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/H2PersistenceManager.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/H2PersistenceManager.java (.../sandbox/JCR-1456) (revision 827970)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/H2PersistenceManager.java (.../trunk) (revision 827970)
@@ -18,6 +18,11 @@
import org.apache.jackrabbit.core.persistence.PMContext;
+import java.sql.Statement;
+import java.sql.SQLException;
+
+import javax.jcr.RepositoryException;
+
/**
* Extends the {@link BundleDbPersistenceManager} by H2 specific code.
*
@@ -60,6 +65,12 @@
}
/**
+ * Creates a new H2 persistence manager.
+ */
+ public H2PersistenceManager() {
+ }
+
+ /**
* {@inheritDoc}
*/
public void init(PMContext context) throws Exception {
@@ -78,8 +89,19 @@
}
super.init(context);
-
- conHelper.exec("SET LOCK_TIMEOUT " + lockTimeout);
}
+ /**
+ * {@inheritDoc}
+ */
+ protected void checkSchema() throws SQLException, RepositoryException {
+ Statement stmt = connectionManager.getConnection().createStatement();
+ try {
+ stmt.execute("SET LOCK_TIMEOUT " + lockTimeout);
+ } finally {
+ stmt.close();
+ }
+ super.checkSchema();
+ }
+
}
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/AbstractBundlePersistenceManager.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/AbstractBundlePersistenceManager.java (.../sandbox/JCR-1456) (revision 827970)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/AbstractBundlePersistenceManager.java (.../trunk) (revision 827970)
@@ -16,40 +16,40 @@
*/
package org.apache.jackrabbit.core.persistence.bundle;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Set;
-
-import javax.jcr.PropertyType;
-
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.jackrabbit.core.fs.FileSystemResource;
import org.apache.jackrabbit.core.fs.FileSystem;
-import org.apache.jackrabbit.core.NamespaceRegistryImpl;
+import org.apache.jackrabbit.core.state.ItemState;
+import org.apache.jackrabbit.core.state.ChangeLog;
+import org.apache.jackrabbit.core.state.ItemStateException;
+import org.apache.jackrabbit.core.state.NodeReferences;
+import org.apache.jackrabbit.core.state.NoSuchItemStateException;
+import org.apache.jackrabbit.core.state.PropertyState;
+import org.apache.jackrabbit.core.state.NodeState;
import org.apache.jackrabbit.core.id.ItemId;
import org.apache.jackrabbit.core.id.NodeId;
import org.apache.jackrabbit.core.id.PropertyId;
+import org.apache.jackrabbit.core.NamespaceRegistryImpl;
+import org.apache.jackrabbit.core.value.InternalValue;
import org.apache.jackrabbit.core.persistence.IterablePersistenceManager;
import org.apache.jackrabbit.core.persistence.PMContext;
import org.apache.jackrabbit.core.persistence.PersistenceManager;
-import org.apache.jackrabbit.core.persistence.bundle.util.BundleBinding;
+import org.apache.jackrabbit.core.util.StringIndex;
+import org.apache.jackrabbit.core.persistence.bundle.util.NodePropBundle;
import org.apache.jackrabbit.core.persistence.bundle.util.BundleCache;
+import org.apache.jackrabbit.core.persistence.bundle.util.LRUNodeIdCache;
import org.apache.jackrabbit.core.persistence.bundle.util.HashMapIndex;
-import org.apache.jackrabbit.core.persistence.bundle.util.LRUNodeIdCache;
-import org.apache.jackrabbit.core.persistence.bundle.util.NodePropBundle;
-import org.apache.jackrabbit.core.state.ItemState;
-import org.apache.jackrabbit.core.state.ChangeLog;
-import org.apache.jackrabbit.core.state.ItemStateException;
-import org.apache.jackrabbit.core.state.NodeReferences;
-import org.apache.jackrabbit.core.state.NoSuchItemStateException;
-import org.apache.jackrabbit.core.state.PropertyState;
-import org.apache.jackrabbit.core.state.NodeState;
-import org.apache.jackrabbit.core.util.StringIndex;
-import org.apache.jackrabbit.core.value.InternalValue;
+import org.apache.jackrabbit.core.persistence.bundle.util.BundleBinding;
import org.apache.jackrabbit.spi.Name;
import org.apache.jackrabbit.spi.commons.name.NameConstants;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.jcr.PropertyType;
+
/**
* The AbstractBundlePersistenceManager acts as base for all
* persistence managers that store the state in a {@link NodePropBundle}.
@@ -131,7 +131,7 @@
public void setBundleCacheSize(String bundleCacheSize) {
this.bundleCacheSize = Long.parseLong(bundleCacheSize) * 1024 * 1024;
}
-
+
/**
* Creates the folder path for the given node id that is suitable for
* storing states in a filesystem.
@@ -405,7 +405,8 @@
*
* Loads the state via the appropriate NodePropBundle.
*/
- public synchronized NodeState load(NodeId id) throws NoSuchItemStateException, ItemStateException {
+ public synchronized NodeState load(NodeId id)
+ throws NoSuchItemStateException, ItemStateException {
NodePropBundle bundle = getBundle(id);
if (bundle == null) {
throw new NoSuchItemStateException(id.toString());
@@ -418,7 +419,8 @@
*
* Loads the state via the appropriate NodePropBundle.
*/
- public synchronized PropertyState load(PropertyId id) throws NoSuchItemStateException, ItemStateException {
+ public synchronized PropertyState load(PropertyId id)
+ throws NoSuchItemStateException, ItemStateException {
NodePropBundle bundle = getBundle(id.getParentId());
if (bundle == null) {
throw new NoSuchItemStateException(id.toString());
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/util/ConnectionFactory.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/util/ConnectionFactory.java (.../sandbox/JCR-1456) (revision 0)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/util/ConnectionFactory.java (.../trunk) (revision 827970)
@@ -0,0 +1,95 @@
+/*
+ * 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.jackrabbit.core.persistence.bundle.util;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+
+import javax.jcr.RepositoryException;
+import javax.naming.Context;
+import javax.naming.NamingException;
+import javax.sql.DataSource;
+
+/**
+ * A factory for new database connections.
+ * Supported are regular JDBC drivers, as well as
+ * JNDI resources.
+ */
+public class ConnectionFactory {
+
+ /**
+ * Utility classes should not have a public or default constructor.
+ */
+ private ConnectionFactory() {
+ }
+
+ /**
+ * Open a connection using the specified properties.
+ * The connection can be created using a JNDI Data Source as well. To do that,
+ * the driver class name must reference a javax.naming.Context class
+ * (for example javax.naming.InitialContext), and the URL must be the JNDI URL
+ * (for example java:comp/env/jdbc/Test).
+ *
+ * @param driver the JDBC driver or the Context class
+ * @param url the database URL
+ * @param user the user name
+ * @param password the password
+ * @return the connection
+ * @throws RepositoryException if the driver could not be loaded
+ * @throws SQLException if the connection could not be established
+ */
+ public static Connection getConnection(String driver, String url,
+ String user, String password) throws RepositoryException,
+ SQLException {
+ if (driver != null && driver.length() > 0) {
+ try {
+ Class< ? > d = Class.forName(driver);
+ if (javax.naming.Context.class.isAssignableFrom(d)) {
+ // JNDI context
+ Context context = (Context) d.newInstance();
+ DataSource ds = (DataSource) context.lookup(url);
+ if (user == null && password == null) {
+ return ds.getConnection();
+ } else {
+ return ds.getConnection(user, password);
+ }
+ } else {
+ try {
+ // Workaround for Apache Derby:
+ // The JDBC specification recommends the Class.forName method without the .newInstance() method call,
+ // but it is required after a Derby 'shutdown'.
+ d.newInstance();
+ } catch (Throwable e) {
+ // Ignore exceptions
+ // There's no requirement that a JDBC driver class has a public default constructor
+ }
+ }
+ } catch (ClassNotFoundException e) {
+ throw new RepositoryException("Could not load class " + driver, e);
+ } catch (InstantiationException e) {
+ throw new RepositoryException("Could not instantiate context " + driver, e);
+ } catch (IllegalAccessException e) {
+ throw new RepositoryException("Could not instantiate context " + driver, e);
+ } catch (NamingException e) {
+ throw new RepositoryException("Naming exception using " + driver + " url: " + url, e);
+ }
+ }
+ return DriverManager.getConnection(url, user, password);
+ }
+
+}
Property changes on: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/util/ConnectionFactory.java
___________________________________________________________________
Added: svn:eol-style
+ native
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/util/ConnectionRecoveryManager.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/util/ConnectionRecoveryManager.java (.../sandbox/JCR-1456) (revision 0)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/util/ConnectionRecoveryManager.java (.../trunk) (revision 827970)
@@ -0,0 +1,482 @@
+/*
+ * 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.jackrabbit.core.persistence.bundle.util;
+
+import java.io.InputStream;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.HashMap;
+
+import javax.jcr.RepositoryException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * This class provides methods to get a database connection and to execute SQL statements.
+ * It also contains reconnection logic. If the connection has been closed with the
+ * {@link #close()} method, then a call to any public method except for
+ * {@link #setAutoReconnect(boolean)} will try to reestablish the connection, but
+ * only if the autoReconnect equals true.
+ *
+ * The reconnection attempt
+ * can either be blocking or non-blocking, which is configured during construction.
+ * In the latter case a fixed number of reconnection attempts is made. When the
+ * reconnection failed an SQLException is thrown.
+ *
+ * The methods of this class that execute SQL statements automatically call
+ * {@link #close()} when they encounter an SQLException.
+ *
+ */
+public class ConnectionRecoveryManager {
+
+ /**
+ * The default logger.
+ */
+ private static Logger log = LoggerFactory.getLogger(ConnectionRecoveryManager.class);
+
+ /**
+ * The database driver.
+ */
+ private final String driver;
+
+ /**
+ * The database URL.
+ */
+ private final String url;
+
+ /**
+ * The database user.
+ */
+ private final String user;
+
+ /**
+ * The database password.
+ */
+ private final String password;
+
+ /**
+ * The database connection that is managed by this {@link ConnectionRecoveryManager}.
+ */
+ private Connection connection;
+
+ /**
+ * An internal flag governing whether an automatic reconnect should be
+ * attempted after a SQLException had been encountered in
+ * {@link #executeStmt(String, Object[])}.
+ */
+ private boolean autoReconnect = true;
+
+ /**
+ * Indicates whether the reconnection function should block
+ * until the connection is up again.
+ */
+ private final boolean block;
+
+ /**
+ * Time to sleep in ms before a reconnect is attempted.
+ */
+ private static final int SLEEP_BEFORE_RECONNECT = 500;
+
+ /**
+ * Number of reconnection attempts per method call. Only
+ * used if block == false.
+ */
+ public static final int TRIALS = 20;
+
+ /**
+ * The map of prepared statements
+ */
+ private HashMapendTransaction.
+ *
+ * @throws SQLException on error
+ */
+ public synchronized void setAutoReconnect(boolean autoReconnect) {
+ this.autoReconnect = autoReconnect;
+ }
+
+ /**
+ * Executes the given SQL query. Retries once or blocks (when the
+ * block parameter has been set to true on construction)
+ * if this fails and autoReconnect is enabled.
+ *
+ * @param sql the SQL query to execute
+ * @return the executed ResultSet
+ * @throws SQLException on error
+ * @throws RepositoryException if the database driver could not be loaded
+ */
+ public synchronized ResultSet executeQuery(String sql) throws SQLException, RepositoryException {
+ int trials = 2;
+ SQLException lastException = null;
+ do {
+ trials--;
+ try {
+ return executeQueryInternal(sql);
+ } catch (SQLException e) {
+ lastException = e;
+ }
+ } while(autoReconnect && (block || trials > 0));
+ throw lastException;
+ }
+
+ /**
+ * Executes the given SQL query.
+ *
+ * @param sql query to execute
+ * @return a ResultSet object
+ * @throws SQLException if an error occurs
+ * @throws RepositoryException if the database driver could not be loaded
+ */
+ private ResultSet executeQueryInternal(String sql) throws SQLException, RepositoryException {
+ PreparedStatement stmt = null;
+ try {
+ stmt = preparedStatements.get(sql);
+ if (stmt == null) {
+ stmt = getConnection().prepareStatement(sql);
+ preparedStatements.put(sql, stmt);
+ }
+ return stmt.executeQuery();
+ } catch (SQLException e) {
+ logException("could not execute statement", e);
+ close();
+ throw e;
+ } finally {
+ resetStatement(stmt);
+ }
+ }
+
+ /**
+ * Executes the given SQL statement with the specified parameters.
+ *
+ * @param sql statement to execute
+ * @param params parameters to set
+ * @return the Statement object that had been executed
+ * @throws SQLException if an error occurs
+ * @throws RepositoryException if the database driver could not be loaded
+ */
+ public PreparedStatement executeStmt(String sql, Object[] params) throws SQLException, RepositoryException {
+ return executeStmt(sql, params, false, 0);
+ }
+
+ /**
+ * Executes the given SQL statement with the specified parameters.
+ *
+ * @param sql statement to execute
+ * @param params parameters to set
+ * @param returnGeneratedKeys if the statement should return auto generated keys
+ * @param maxRows the maximum number of rows to return (0 for all rows)
+ * @return the Statement object that had been executed
+ * @throws SQLException if an error occurs
+ * @throws RepositoryException if the database driver could not be loaded
+ */
+ public synchronized PreparedStatement executeStmt(
+ String sql, Object[] params, boolean returnGeneratedKeys, int maxRows)
+ throws SQLException, RepositoryException {
+ int trials = 2;
+ SQLException lastException = null;
+ do {
+ trials--;
+ try {
+ return executeStmtInternal(sql, params, returnGeneratedKeys, maxRows);
+ } catch (SQLException e) {
+ lastException = e;
+ }
+ } while(autoReconnect && (block || trials > 0));
+ throw lastException;
+ }
+
+ /**
+ * Executes the given SQL statement with the specified parameters.
+ *
+ * @param sql statement to execute
+ * @param params parameters to set
+ * @param returnGeneratedKeys if the statement should return auto generated keys
+ * @param maxRows the maximum number of rows to return (0 for all rows)
+ * @return the Statement object that had been executed
+ * @throws SQLException if an error occurs
+ * @throws RepositoryException if the database driver could not be loaded
+ */
+ private PreparedStatement executeStmtInternal(
+ String sql, Object[] params, boolean returnGeneratedKeys, int maxRows)
+ throws SQLException, RepositoryException {
+ try {
+ String key = sql;
+ if (returnGeneratedKeys) {
+ key += " RETURN_GENERATED_KEYS";
+ }
+ PreparedStatement stmt = preparedStatements.get(key);
+ if (stmt == null) {
+ if (returnGeneratedKeys) {
+ stmt = getConnection().prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
+ } else {
+ stmt = getConnection().prepareStatement(sql);
+ }
+ preparedStatements.put(key, stmt);
+ }
+ stmt.setMaxRows(maxRows);
+ return executeStmtInternal(params, stmt);
+ } catch (SQLException e) {
+ logException("could not execute statement", e);
+ close();
+ throw e;
+ }
+ }
+
+ /**
+ * Closes all resources held by this {@link ConnectionRecoveryManager}.
+ * An ongoing transaction is discarded.
+ */
+ public synchronized void close() {
+ preparedStatements.clear();
+ try {
+ if (connection != null) {
+ if (!connection.getAutoCommit()) {
+ connection.rollback();
+ }
+ connection.close();
+ }
+ } catch (SQLException e) {
+ logException("failed to close connection", e);
+ }
+ connection = null;
+ isClosed = true;
+ }
+
+ /**
+ * Creates the database connection.
+ *
+ * @throws SQLException on error
+ * @throws RepositoryException if the database driver could not be loaded
+ */
+ private void setupConnection() throws SQLException, RepositoryException {
+ try {
+ connection = ConnectionFactory.getConnection(driver, url, user, password);
+ } catch (SQLException e) {
+ log.warn("Could not connect; driver: " + driver + " url: " + url + " user: " + user + " error: " + e.toString(), e);
+ throw e;
+ }
+ // JCR-1013: Setter may fail unnecessarily on a managed connection
+ if (!connection.getAutoCommit()) {
+ connection.setAutoCommit(true);
+ }
+ try {
+ DatabaseMetaData meta = connection.getMetaData();
+ log.info("Database: " + meta.getDatabaseProductName() + " / " + meta.getDatabaseProductVersion());
+ log.info("Driver: " + meta.getDriverName() + " / " + meta.getDriverVersion());
+ } catch (SQLException e) {
+ log.warn("Can not retrieve database and driver name / version", e);
+ }
+ }
+
+ /**
+ * @param params the parameters for the stmt parameter
+ * @param stmt the statement to execute
+ * @return the executed Statement
+ * @throws SQLException on error
+ */
+ private PreparedStatement executeStmtInternal(Object[] params, PreparedStatement stmt) throws SQLException {
+ for (int i = 0; params != null && i < params.length; i++) {
+ Object p = params[i];
+ if (p instanceof StreamWrapper) {
+ StreamWrapper wrapper = (StreamWrapper) p;
+ stmt.setBinaryStream(i + 1, wrapper.stream, (int) wrapper.size);
+ } else if (p instanceof InputStream) {
+ InputStream stream = (InputStream) p;
+ stmt.setBinaryStream(i + 1, stream, -1);
+ } else {
+ stmt.setObject(i + 1, p);
+ }
+ }
+ stmt.execute();
+ resetStatement(stmt);
+ return stmt;
+ }
+
+ /**
+ * Re-establishes the database connection.
+ *
+ * @throws SQLException if reconnecting failed
+ * @throws RepositoryException
+ */
+ private void reestablishConnection() throws SQLException, RepositoryException {
+
+ long trials = TRIALS;
+ SQLException exception = null;
+
+ // Close the connection (might already have been done)
+ close();
+
+ if (block) {
+ log.warn("blocking until database connection is up again...");
+ }
+
+ // Try to reconnect
+ while (trials-- >= 0 || block) {
+
+ // Reset the last caught exception
+ exception = null;
+
+ // Sleep for a while to give database a chance
+ // to restart before a reconnect is attempted.
+ try {
+ Thread.sleep(SLEEP_BEFORE_RECONNECT);
+ } catch (InterruptedException ignore) {
+ }
+
+ // now try to re-establish connection
+ try {
+ setupConnection();
+ isClosed = false;
+ break;
+ } catch (SQLException e) {
+ exception = e;
+ close();
+ }
+ }
+
+ // Rethrow last caught exception (if this is not null, then
+ // we know that reconnecting failed and close has been called.
+ if (exception != null) {
+ throw exception;
+ } else if (block) {
+ log.warn("database connection is up again!");
+ }
+ }
+
+ /**
+ * Resets the given PreparedStatement by clearing the
+ * parameters and warnings contained.
+ *
+ * @param stmt The PreparedStatement to reset. If
+ * null this method does nothing.
+ */
+ private void resetStatement(PreparedStatement stmt) {
+ if (stmt != null) {
+ try {
+ stmt.clearParameters();
+ stmt.clearWarnings();
+ } catch (SQLException se) {
+ logException("Failed resetting PreparedStatement", se);
+ }
+ }
+ }
+
+ /**
+ * Logs an sql exception.
+ *
+ * @param message the message
+ * @param se the exception
+ */
+ private void logException(String message, SQLException se) {
+ message = message == null ? "" : message;
+ log.error(message + ", reason: " + se.getMessage() + ", state/code: "
+ + se.getSQLState() + "/" + se.getErrorCode());
+ log.debug(" dump:", se);
+ }
+
+ /**
+ * A wrapper for a binary stream that includes the
+ * size of the stream.
+ *
+ */
+ public static class StreamWrapper {
+
+ private final InputStream stream;
+ private final long size;
+
+ /**
+ * Creates a wrapper for the given InputStream that can
+ * safely be passed as a parameter to the executeStmt
+ * methods in the {@link ConnectionRecoveryManager} class.
+ *
+ * @param in the InputStream to wrap
+ * @param size the size of the input stream
+ */
+ public StreamWrapper(InputStream in, long size) {
+ this.stream = in;
+ this.size = size;
+ }
+ }
+
+}
Property changes on: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/util/ConnectionRecoveryManager.java
___________________________________________________________________
Added: svn:eol-style
+ native
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/util/PostgreSQLNameIndex.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/util/PostgreSQLNameIndex.java (.../sandbox/JCR-1456) (revision 827970)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/util/PostgreSQLNameIndex.java (.../trunk) (revision 827970)
@@ -19,9 +19,6 @@
import java.sql.ResultSet;
import java.sql.SQLException;
-import org.apache.jackrabbit.core.util.db.ConnectionHelper;
-import org.apache.jackrabbit.core.util.db.DbUtility;
-
/**
* Same as {@link DbNameIndex} but does not make use of the
* {@link java.sql.Statement#RETURN_GENERATED_KEYS} feature as it is not
@@ -31,9 +28,9 @@
protected String generatedKeySelectSQL;
- public PostgreSQLNameIndex(ConnectionHelper connectionHelper, String schemaObjectPrefix)
+ public PostgreSQLNameIndex(ConnectionRecoveryManager conMgr, String schemaObjectPrefix)
throws SQLException {
- super(connectionHelper, schemaObjectPrefix);
+ super(conMgr, schemaObjectPrefix);
}
/**
@@ -63,9 +60,9 @@
protected int insertString(String string) {
// assert index does not exist
try {
- conHelper.exec(nameInsertSQL, new Object[]{string});
+ connectionManager.executeStmt(nameInsertSQL, new Object[]{string});
return getGeneratedKey();
- } catch (Exception e) {
+ } catch (Exception e) {
IllegalStateException ise = new IllegalStateException("Unable to insert index for string: " + string);
ise.initCause(e);
throw ise;
@@ -77,20 +74,21 @@
* @return the index.
*/
protected int getGeneratedKey() {
- ResultSet rs = null;
try {
- rs = conHelper.exec(generatedKeySelectSQL, null, false, 0);
- if (!rs.next()) {
- return -1;
- } else {
- return rs.getInt(1);
+ ResultSet rs = connectionManager.executeQuery(generatedKeySelectSQL);
+ try {
+ if (!rs.next()) {
+ return -1;
+ } else {
+ return rs.getInt(1);
+ }
+ } finally {
+ rs.close();
}
} catch (Exception e) {
IllegalStateException ise = new IllegalStateException("Unable to read generated index");
ise.initCause(e);
throw ise;
- } finally {
- DbUtility.close(rs);
}
}
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/util/DbNameIndex.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/util/DbNameIndex.java (.../sandbox/JCR-1456) (revision 827970)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/util/DbNameIndex.java (.../trunk) (revision 827970)
@@ -16,13 +16,13 @@
*/
package org.apache.jackrabbit.core.persistence.bundle.util;
+import java.util.HashMap;
+
import java.sql.ResultSet;
import java.sql.SQLException;
-import java.util.HashMap;
+import java.sql.Statement;
import org.apache.jackrabbit.core.util.StringIndex;
-import org.apache.jackrabbit.core.util.db.ConnectionHelper;
-import org.apache.jackrabbit.core.util.db.DbUtility;
/**
* Implements a {@link StringIndex} that stores and retrieves the names from a
@@ -37,7 +37,10 @@
*/
public class DbNameIndex implements StringIndex {
- protected final ConnectionHelper conHelper;
+ /**
+ * The class that manages statement execution and recovery from connection loss.
+ */
+ protected ConnectionRecoveryManager connectionManager;
// name index statements
protected String nameSelectSQL;
@@ -50,13 +53,13 @@
/**
* Creates a new index that is stored in a db.
- * @param conHelper the {@link ConnectionHelper}
+ * @param con the jdbc connection
* @param schemaObjectPrefix the prefix for table names
* @throws SQLException if the statements cannot be prepared.
*/
- public DbNameIndex(ConnectionHelper conHlpr, String schemaObjectPrefix)
+ public DbNameIndex(ConnectionRecoveryManager conMgr, String schemaObjectPrefix)
throws SQLException {
- conHelper = conHlpr;
+ connectionManager = conMgr;
init(schemaObjectPrefix);
}
@@ -130,19 +133,22 @@
protected int insertString(String string) {
// assert index does not exist
int result = -1;
- ResultSet rs = null;
try {
- rs = conHelper.exec(nameInsertSQL, new Object[] { string }, true, 0);
- if (rs.next()) {
- result = rs.getInt(1);
+ Statement stmt = connectionManager.executeStmt(
+ nameInsertSQL, new Object[] { string }, true, 0);
+ ResultSet rs = stmt.getGeneratedKeys();
+ try {
+ if (rs.next()) {
+ result = rs.getInt(1);
+ }
+ } finally {
+ rs.close();
}
} catch (Exception e) {
IllegalStateException ise = new IllegalStateException(
"Unable to insert index for string: " + string);
ise.initCause(e);
throw ise;
- } finally {
- DbUtility.close(rs);
}
if (result != -1) {
return result;
@@ -158,21 +164,24 @@
* @return the index or -1 if not found.
*/
protected int getIndex(String string) {
- ResultSet rs = null;
try {
- rs = conHelper.exec(indexSelectSQL, new Object[] { string }, false, 0);
- if (rs.next()) {
- return rs.getInt(1);
- } else {
- return -1;
+ Statement stmt = connectionManager.executeStmt(
+ indexSelectSQL, new Object[] { string });
+ ResultSet rs = stmt.getResultSet();
+ try {
+ if (rs.next()) {
+ return rs.getInt(1);
+ } else {
+ return -1;
+ }
+ } finally {
+ rs.close();
}
} catch (Exception e) {
IllegalStateException ise = new IllegalStateException(
"Unable to read index for string: " + string);
ise.initCause(e);
throw ise;
- } finally {
- DbUtility.close(rs);
}
}
@@ -185,19 +194,22 @@
protected String getString(int index)
throws IllegalArgumentException, IllegalStateException {
String result = null;
- ResultSet rs = null;
try {
- rs = conHelper.exec(nameSelectSQL, new Object[] { Integer.valueOf(index) }, false, 0);
- if (rs.next()) {
- result = rs.getString(1);
+ Statement stmt = connectionManager.executeStmt(
+ nameSelectSQL, new Object[] { Integer.valueOf(index) });
+ ResultSet rs = stmt.getResultSet();
+ try {
+ if (rs.next()) {
+ result = rs.getString(1);
+ }
+ } finally {
+ rs.close();
}
} catch (Exception e) {
IllegalStateException ise = new IllegalStateException(
"Unable to read name for index: " + index);
ise.initCause(e);
throw ise;
- } finally {
- DbUtility.close(rs);
}
if (result == null) {
throw new IllegalArgumentException("Index not found: " + index);
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/util/NGKDbNameIndex.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/util/NGKDbNameIndex.java (.../sandbox/JCR-1456) (revision 827970)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/util/NGKDbNameIndex.java (.../trunk) (revision 827970)
@@ -17,10 +17,7 @@
package org.apache.jackrabbit.core.persistence.bundle.util;
import java.sql.SQLException;
-import java.sql.Statement;
-import org.apache.jackrabbit.core.util.db.ConnectionHelper;
-
/**
* Same as {@link DbNameIndex} but does not make use of the
* {@link Statement#RETURN_GENERATED_KEYS} feature as it might not be provided
@@ -30,13 +27,13 @@
/**
* Creates a new index that is stored in a db.
- * @param conHelper the {@link ConnectionHelper}
+ * @param con the ConnectionRecoveryManager
* @param schemaObjectPrefix the prefix for table names
* @throws SQLException if the statements cannot be prepared.
*/
- public NGKDbNameIndex(ConnectionHelper conHelper, String schemaObjectPrefix)
+ public NGKDbNameIndex(ConnectionRecoveryManager conMgr, String schemaObjectPrefix)
throws SQLException {
- super(conHelper, schemaObjectPrefix);
+ super(conMgr, schemaObjectPrefix);
}
/**
@@ -61,13 +58,14 @@
protected int insertString(String string) {
// assert index does not exist
try {
- conHelper.exec(nameInsertSQL, new Object[] { string });
+ connectionManager.executeStmt(nameInsertSQL, new Object[] { string });
} catch (Exception e) {
IllegalStateException ise = new IllegalStateException(
"Unable to insert index for string: " + string);
ise.initCause(e);
throw ise;
}
+
return getIndex(string);
}
}
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/Oracle9PersistenceManager.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/Oracle9PersistenceManager.java (.../sandbox/JCR-1456) (revision 827970)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/persistence/bundle/Oracle9PersistenceManager.java (.../trunk) (revision 827970)
@@ -16,14 +16,33 @@
*/
package org.apache.jackrabbit.core.persistence.bundle;
-import javax.sql.DataSource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.apache.commons.io.IOUtils;
+import org.apache.jackrabbit.core.persistence.PMContext;
+import org.apache.jackrabbit.core.persistence.bundle.util.NodePropBundle;
+import org.apache.jackrabbit.core.persistence.util.Serializer;
+import org.apache.jackrabbit.core.state.ItemStateException;
+import org.apache.jackrabbit.core.state.NodeReferences;
-import org.apache.jackrabbit.core.util.db.ConnectionHelper;
-import org.apache.jackrabbit.core.util.db.Oracle10R1ConnectionHelper;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.lang.reflect.Method;
+import java.sql.Blob;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
/**
- * OracleLegacyPersistenceManager provides support for Oracle jdbc drivers prior to version 10
- * which require special handling of BLOB data. Configuration:OracleLegacyPersistenceManager provides support for Oracle jdbc
+ * drivers prior to version 10 which require special handling of BLOB data.
+ *
+ * Configuration:oracle.sql.BLOB class via reflection, and
+ * initialize the values for the DURATION_SESSION and
+ * MODE_READWRITE constants defined there.
+ *
+ * @see oracle.sql.BLOB#DURATION_SESSION
+ * @see oracle.sql.BLOB#MODE_READWRITE
*/
- @Override
- protected ConnectionHelper createConnectionHelper(DataSource dataSrc) throws Exception {
- Oracle10R1ConnectionHelper helper = new Oracle10R1ConnectionHelper(dataSrc, blockOnConnectionLoss);
- helper.init();
- return helper;
+ public void init(PMContext context) throws Exception {
+ super.init(context);
+
+ // initialize oracle.sql.BLOB class & constants
+
+ // use the Connection object for using the exact same
+ // class loader that the Oracle driver was loaded with
+ blobClass = connectionManager.getConnection().getClass().getClassLoader().loadClass("oracle.sql.BLOB");
+ duractionSessionConstant =
+ new Integer(blobClass.getField("DURATION_SESSION").getInt(null));
+ modeReadWriteConstant =
+ new Integer(blobClass.getField("MODE_READWRITE").getInt(null));
}
+
+ /**
+ * @inheritDoc
+ */
+ protected BundleDbPersistenceManager.CloseableBLOBStore createDBBlobStore(PMContext context) throws Exception {
+ return new OracleBLOBStore();
+ }
+
+ /**
+ * @inheritDoc
+ */
+ protected synchronized void storeBundle(NodePropBundle bundle)
+ throws ItemStateException {
+ Blob blob = null;
+ try {
+ ByteArrayOutputStream out = new ByteArrayOutputStream(INITIAL_BUFFER_SIZE);
+ DataOutputStream dout = new DataOutputStream(out);
+ binding.writeBundle(dout, bundle);
+ dout.close();
+
+ String sql = bundle.isNew() ? bundleInsertSQL : bundleUpdateSQL;
+ blob = createTemporaryBlob(new ByteArrayInputStream(out.toByteArray()));
+ Object[] params = createParams(bundle.getId(), blob, true);
+ connectionManager.executeStmt(sql, params);
+ } catch (Exception e) {
+ String msg = "failed to write bundle: " + bundle.getId();
+ log.error(msg, e);
+ throw new ItemStateException(msg, e);
+ } finally {
+ if (blob != null) {
+ try {
+ freeTemporaryBlob(blob);
+ } catch (Exception e1) {
+ }
+ }
+ }
+ }
+
+ /**
+ * @inheritDoc
+ */
+ public synchronized void store(NodeReferences refs)
+ throws ItemStateException {
+ if (!initialized) {
+ throw new IllegalStateException("not initialized");
+ }
+
+ Blob blob = null;
+ try {
+ // check if insert or update
+ boolean update = existsReferencesTo(refs.getTargetId());
+ String sql = (update) ? nodeReferenceUpdateSQL : nodeReferenceInsertSQL;
+
+ ByteArrayOutputStream out = new ByteArrayOutputStream(INITIAL_BUFFER_SIZE);
+ // serialize references
+ Serializer.serialize(refs, out);
+
+ // we are synchronized on this instance, therefore we do not
+ // not have to additionally synchronize on the preparedStatement
+
+ blob = createTemporaryBlob(new ByteArrayInputStream(out.toByteArray()));
+ Object[] params = createParams(refs.getTargetId(), blob, true);
+ connectionManager.executeStmt(sql, params);
+
+ // there's no need to close a ByteArrayOutputStream
+ //out.close();
+ } catch (Exception e) {
+ String msg = "failed to write " + refs;
+ log.error(msg, e);
+ throw new ItemStateException(msg, e);
+ } finally {
+ if (blob != null) {
+ try {
+ freeTemporaryBlob(blob);
+ } catch (Exception e1) {
+ }
+ }
+ }
+ }
+
+ //----------------------------------------< oracle-specific blob handling >
+ /**
+ * Creates a temporary oracle.sql.BLOB instance via reflection and spools
+ * the contents of the specified stream.
+ */
+ protected Blob createTemporaryBlob(InputStream in) throws Exception {
+ /*
+ BLOB blob = BLOB.createTemporary(con, false, BLOB.DURATION_SESSION);
+ blob.open(BLOB.MODE_READWRITE);
+ OutputStream out = blob.getBinaryOutputStream();
+ ...
+ out.flush();
+ out.close();
+ blob.close();
+ return blob;
+ */
+ Method createTemporary = blobClass.getMethod("createTemporary",
+ new Class[]{Connection.class, Boolean.TYPE, Integer.TYPE});
+ Object blob = createTemporary.invoke(null,
+ new Object[]{connectionManager.getConnection(), Boolean.FALSE, duractionSessionConstant});
+ Method open = blobClass.getMethod("open", new Class[]{Integer.TYPE});
+ open.invoke(blob, new Object[]{modeReadWriteConstant});
+ Method getBinaryOutputStream = blobClass.getMethod("getBinaryOutputStream", new Class[0]);
+ OutputStream out = (OutputStream) getBinaryOutputStream.invoke(blob);
+ try {
+ IOUtils.copy(in, out);
+ } finally {
+ try {
+ out.flush();
+ } catch (IOException ioe) {
+ }
+ out.close();
+ }
+ Method close = blobClass.getMethod("close", new Class[0]);
+ close.invoke(blob);
+ return (Blob) blob;
+ }
+
+ /**
+ * Frees a temporary oracle.sql.BLOB instance via reflection.
+ */
+ protected void freeTemporaryBlob(Object blob) throws Exception {
+ // blob.freeTemporary();
+ Method freeTemporary = blobClass.getMethod("freeTemporary", new Class[0]);
+ freeTemporary.invoke(blob);
+ }
+
+ /**
+ * A blob store specially for Oracle 9.
+ */
+ class OracleBLOBStore extends DbBlobStore {
+
+ public OracleBLOBStore() throws SQLException {
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public synchronized void put(String blobId, InputStream in, long size)
+ throws Exception {
+
+ Blob blob = null;
+ try {
+ Statement stmt = connectionManager.executeStmt(blobSelectExistSQL, new Object[]{blobId});
+ ResultSet rs = stmt.getResultSet();
+ // a BLOB exists if the result has at least one entry
+ boolean exists = rs.next();
+ closeResultSet(rs);
+
+ String sql = (exists) ? blobUpdateSQL : blobInsertSQL;
+ blob = createTemporaryBlob(in);
+ connectionManager.executeStmt(sql, new Object[]{blob, blobId});
+ } finally {
+ if (blob != null) {
+ try {
+ freeTemporaryBlob(blob);
+ } catch (Exception e) {
+ }
+ }
+ }
+ }
+ }
}
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/fs/db/MSSqlFileSystem.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/fs/db/MSSqlFileSystem.java (.../sandbox/JCR-1456) (revision 827970)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/fs/db/MSSqlFileSystem.java (.../trunk) (revision 827970)
@@ -16,7 +16,7 @@
*/
package org.apache.jackrabbit.core.fs.db;
-import org.apache.jackrabbit.core.util.db.CheckSchemaOperation;
+import org.apache.jackrabbit.util.Text;
/**
* MSSqlFileSystem is a JDBC-based FileSystem
@@ -86,12 +86,8 @@
driver = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
}
- /**
- * {@inheritDoc}
- */
- @Override
- protected CheckSchemaOperation createCheckSchemaOperation() {
- return super.createCheckSchemaOperation().addVariableReplacement(
- CheckSchemaOperation.TABLE_SPACE_VARIABLE, tableSpace);
- }
+ protected String createSchemaSql(String sql) {
+ return Text.replace(
+ super.createSchemaSql(sql), TABLE_SPACE_VARIABLE, tableSpace);
+ }
}
\ No newline at end of file
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/fs/db/DatabaseFileSystem.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/fs/db/DatabaseFileSystem.java (.../sandbox/JCR-1456) (revision 827970)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/fs/db/DatabaseFileSystem.java (.../trunk) (revision 827970)
@@ -20,30 +20,30 @@
import org.apache.jackrabbit.core.fs.FileSystem;
import org.apache.jackrabbit.core.fs.FileSystemException;
import org.apache.jackrabbit.core.fs.FileSystemPathUtil;
-import org.apache.jackrabbit.core.fs.RandomAccessOutputStream;
-import org.apache.jackrabbit.core.persistence.PMContext;
-import org.apache.jackrabbit.core.util.db.CheckSchemaOperation;
-import org.apache.jackrabbit.core.util.db.ConnectionHelper;
-import org.apache.jackrabbit.core.util.db.DbUtility;
-import org.apache.jackrabbit.core.util.db.StreamWrapper;
+import org.apache.jackrabbit.util.Text;
import org.apache.jackrabbit.util.TransientFileFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import javax.sql.DataSource;
-
+import javax.jcr.RepositoryException;
+import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FilterInputStream;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.InputStream;
+import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.FileInputStream;
-import java.io.RandomAccessFile;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
+import java.sql.Statement;
import java.util.ArrayList;
+import java.util.HashMap;
/**
* Base class for database file systems. This class contains common
@@ -55,29 +55,38 @@
* See the {@link DbFileSystem} for a detailed description of the available
* configuration options and database behaviour.
*/
-public abstract class DatabaseFileSystem implements FileSystem {
+public class DatabaseFileSystem implements FileSystem {
/**
* Logger instance
*/
private static Logger log = LoggerFactory.getLogger(DatabaseFileSystem.class);
+ protected static final String SCHEMA_OBJECT_PREFIX_VARIABLE =
+ "${schemaObjectPrefix}";
+
protected boolean initialized;
protected String schema;
protected String schemaObjectPrefix;
- // initial size of buffer used to serialize objects
- protected static final int INITIAL_BUFFER_SIZE = 8192;
-
/**
* Whether the schema check must be done during initialization.
*/
private boolean schemaCheckEnabled = true;
- /** the {@link ConnectionHelper} set in the {@link #init()} method */
- protected ConnectionHelper conHelper;
+ // initial size of buffer used to serialize objects
+ protected static final int INITIAL_BUFFER_SIZE = 8192;
+ // jdbc connection
+ protected Connection con;
+
+ // time to sleep in ms before a reconnect is attempted
+ protected static final int SLEEP_BEFORE_RECONNECT = 10000;
+
+ // the map of prepared statements (key: sql stmt, value: prepared stmt)
+ private HashMap
+ * Subclasses should normally override the {@link #getConnection()}
+ * method instead of this one. The default implementation calls
+ * {@link #getConnection()} to get the database connection and disables
+ * the autocommit feature.
+ *
+ * @throws Exception if an error occurs
+ */
+ protected void initConnection() throws Exception {
+ con = getConnection();
+ // JCR-1013: Setter may fail unnecessarily on a managed connection
+ if (!con.getAutoCommit()) {
+ con.setAutoCommit(true);
+ }
+ }
+
+ /**
+ * Abstract factory method for creating a new database connection. This
+ * method is called by {@link #initConnection()} when the file system is
+ * started. The returned connection should come with the default JDBC
+ * settings, as the {@link #initConnection()} method will explicitly set
+ * the autoCommit and other properties as needed.
+ *
+ * Note that the returned database connection is kept during the entire + * lifetime of the file system, after which it is closed by + * {@link #close()} using the {@link #closeConnection(Connection)} method. + * + * @return new connection + * @throws Exception if an error occurs + */ + protected Connection getConnection() throws Exception { + throw new UnsupportedOperationException("Override in a subclass!"); + } + + /** + * Closes the given database connection. This method is called by + * {@link #close()} to close the connection acquired using + * {@link #getConnection()} when the file system was started. + *
+ * The default implementation just calls the {@link Connection#close()}
+ * method of the given connection, but subclasses can override this
+ * method to provide more extensive database and connection cleanup.
+ *
+ * @param connection database connection
+ * @throws SQLException if an error occurs
+ */
+ protected void closeConnection(Connection connection) throws SQLException {
+ connection.close();
+ }
+
+ /**
+ * Re-establishes the database connection. This method is called by
+ * {@link #executeStmt(String, Object[])} after a SQLException
+ * had been encountered.
+ *
+ * @return true if the connection could be successfully re-established,
+ * false otherwise.
+ */
+ protected synchronized boolean reestablishConnection() {
+ // in any case try to shut down current connection
+ // gracefully in order to avoid potential memory leaks
+
+ // close shared prepared statements
+ for (PreparedStatement prep : preparedStatements.values()) {
+ closeStatement(prep);
+ }
+ try {
+ closeConnection(con);
+ } catch (Exception ignore) {
+ }
+
+ // sleep for a while to give database a chance
+ // to restart before a reconnect is attempted
+
+ try {
+ Thread.sleep(SLEEP_BEFORE_RECONNECT);
+ } catch (InterruptedException ignore) {
+ }
+
+ // now try to re-establish connection
+
+ try {
+ initConnection();
+ initPreparedStatements();
+ return true;
+ } catch (Exception e) {
+ log.error("failed to re-establish connection", e);
+ // reconnect failed
+ return false;
+ }
+ }
+
+ /**
+ * Executes the given SQL statement with the specified parameters.
+ * If a SQLException is encountered one attempt is made
+ * to re-establish the database connection and re-execute the statement.
+ *
+ * @param sql statement to execute
+ * @param params parameters to set
+ * @return the Statement object that had been executed
+ * @throws SQLException if an error occurs
+ */
+ protected Statement executeStmt(String sql, Object[] params)
+ throws SQLException {
+ int trials = 2;
+ while (true) {
+ PreparedStatement stmt = preparedStatements.get(sql);
+ try {
+ for (int i = 0; i < params.length; i++) {
+ if (params[i] instanceof SizedInputStream) {
+ SizedInputStream in = (SizedInputStream) params[i];
+ stmt.setBinaryStream(i + 1, in, (int) in.getSize());
+ } else {
+ stmt.setObject(i + 1, params[i]);
+ }
+ }
+ stmt.execute();
+ resetStatement(stmt);
+ return stmt;
+ } catch (SQLException se) {
+ if (--trials == 0) {
+ // no more trials, re-throw
+ throw se;
+ }
+ log.warn("execute failed, about to reconnect...", se.getMessage());
+
+ // try to reconnect
+ if (reestablishConnection()) {
+ // reconnect succeeded; check whether it's possible to
+ // re-execute the prepared stmt with the given parameters
+ for (int i = 0; i < params.length; i++) {
+ if (params[i] instanceof SizedInputStream) {
+ SizedInputStream in = (SizedInputStream) params[i];
+ if (in.isConsumed()) {
+ // we're unable to re-execute the prepared stmt
+ // since an InputStream paramater has already
+ // been 'consumed';
+ // re-throw previous SQLException
+ throw se;
+ }
+ }
+ }
+
+ // try again to execute the statement
+ continue;
+ } else {
+ // reconnect failed, re-throw previous SQLException
+ throw se;
+ }
+ }
+ }
+ }
+
+ /**
+ * Makes sure that schemaObjectPrefix does only consist of
+ * characters that are allowed in names on the target database. Illegal
+ * characters will be escaped as necessary.
+ *
+ * @throws Exception if an error occurs
+ */
+ protected void prepareSchemaObjectPrefix() throws Exception {
+ DatabaseMetaData metaData = con.getMetaData();
+ String legalChars = metaData.getExtraNameCharacters();
+ legalChars += "ABCDEFGHIJKLMNOPQRSTUVWXZY0123456789_";
+
+ String prefix = schemaObjectPrefix.toUpperCase();
+ StringBuffer escaped = new StringBuffer();
+ for (int i = 0; i < prefix.length(); i++) {
+ char c = prefix.charAt(i);
+ if (legalChars.indexOf(c) == -1) {
+ escaped.append("_x");
+ String hex = Integer.toHexString(c);
+ escaped.append("0000".toCharArray(), 0, 4 - hex.length());
+ escaped.append(hex);
+ escaped.append("_");
+ } else {
+ escaped.append(c);
+ }
+ }
+ schemaObjectPrefix = escaped.toString();
+ }
+
+ /**
+ * Checks if the required schema objects exist and creates them if they
+ * don't exist yet.
+ *
+ * @throws Exception if an error occurs
+ */
+ protected void checkSchema() throws Exception {
+ DatabaseMetaData metaData = con.getMetaData();
+ String tableName = schemaObjectPrefix + "FSENTRY";
+ if (metaData.storesLowerCaseIdentifiers()) {
+ tableName = tableName.toLowerCase();
+ } else if (metaData.storesUpperCaseIdentifiers()) {
+ tableName = tableName.toUpperCase();
+ }
+ ResultSet rs = metaData.getTables(null, null, tableName, null);
+ boolean schemaExists;
+ try {
+ schemaExists = rs.next();
+ } finally {
+ rs.close();
+ }
+
+ if (!schemaExists) {
+ // read ddl from resources
+ InputStream in = DatabaseFileSystem.class.getResourceAsStream(schema + ".ddl");
+ if (in == null) {
+ String msg = "Configuration error: unknown schema '" + schema + "'";
+ log.debug(msg);
+ throw new RepositoryException(msg);
+ }
+ BufferedReader reader = new BufferedReader(new InputStreamReader(in));
+ Statement stmt = con.createStatement();
+ try {
+ String sql = reader.readLine();
+ while (sql != null) {
+ // Skip comments and empty lines
+ if (!sql.startsWith("#") && sql.length() > 0) {
+ // replace prefix variable
+ sql = createSchemaSql(sql);
+ stmt.executeUpdate(sql);
+ }
+ // read next sql stmt
+ sql = reader.readLine();
+ }
+ } finally {
+ IOUtils.closeQuietly(in);
+ closeStatement(stmt);
+ }
+ }
+ }
+
+ /**
+ * Replace wildcards.
+ */
+ protected String createSchemaSql(String sql) {
+ sql = Text.replace(sql, SCHEMA_OBJECT_PREFIX_VARIABLE, schemaObjectPrefix);
+ return sql;
+ }
+
+ /**
* Builds the SQL statements
*/
protected void buildSQLStatements() {
@@ -869,6 +1122,51 @@
}
/**
+ * Initializes the map of prepared statements.
+ *
+ * @throws SQLException if an error occurs
+ */
+ protected void initPreparedStatements() throws SQLException {
+ preparedStatements.put(
+ selectExistSQL, con.prepareStatement(selectExistSQL));
+ preparedStatements.put(
+ selectFileExistSQL, con.prepareStatement(selectFileExistSQL));
+ preparedStatements.put(
+ selectFolderExistSQL, con.prepareStatement(selectFolderExistSQL));
+ preparedStatements.put(
+ selectChildCountSQL, con.prepareStatement(selectChildCountSQL));
+ preparedStatements.put(
+ selectDataSQL, con.prepareStatement(selectDataSQL));
+ preparedStatements.put(
+ selectLastModifiedSQL, con.prepareStatement(selectLastModifiedSQL));
+ preparedStatements.put(
+ selectLengthSQL, con.prepareStatement(selectLengthSQL));
+ preparedStatements.put(
+ selectFileNamesSQL, con.prepareStatement(selectFileNamesSQL));
+ preparedStatements.put(
+ selectFolderNamesSQL, con.prepareStatement(selectFolderNamesSQL));
+ preparedStatements.put(
+ selectFileAndFolderNamesSQL, con.prepareStatement(selectFileAndFolderNamesSQL));
+ preparedStatements.put(
+ deleteFileSQL, con.prepareStatement(deleteFileSQL));
+ preparedStatements.put(
+ deleteFolderSQL, con.prepareStatement(deleteFolderSQL));
+ preparedStatements.put(
+ insertFileSQL, con.prepareStatement(insertFileSQL));
+ preparedStatements.put(
+ insertFolderSQL, con.prepareStatement(insertFolderSQL));
+ preparedStatements.put(
+ updateDataSQL, con.prepareStatement(updateDataSQL));
+ preparedStatements.put(
+ updateLastModifiedSQL, con.prepareStatement(updateLastModifiedSQL));
+ preparedStatements.put(
+ copyFileSQL, con.prepareStatement(copyFileSQL));
+ preparedStatements.put(
+ copyFilesSQL, con.prepareStatement(copyFilesSQL));
+
+ }
+
+ /**
* Verifies that the root file system entry exists. If it doesn't exist yet
* it will be automatically created.
*
@@ -879,9 +1177,10 @@
synchronized (selectFolderExistSQL) {
ResultSet rs = null;
try {
- rs = conHelper.exec(
+ Statement stmt = executeStmt(
selectFolderExistSQL,
- new Object[]{FileSystem.SEPARATOR, ""}, false, 0);
+ new Object[]{FileSystem.SEPARATOR, ""});
+ rs = stmt.getResultSet();
if (rs.next()) {
// root entry exists
@@ -892,7 +1191,7 @@
log.error(msg, e);
throw new FileSystemException(msg, e);
} finally {
- DbUtility.close(rs);
+ closeResultSet(rs);
}
}
@@ -920,7 +1219,7 @@
synchronized (insertFolderSQL) {
try {
- conHelper.exec(
+ executeStmt(
insertFolderSQL,
new Object[]{
parentDir,
@@ -934,4 +1233,88 @@
}
}
+ /**
+ * Resets the given PreparedStatement by clearing the parameters
+ * and warnings contained.
+ *
PreparedStatement instance on which it
+ * operates are thread safe.
+ *
+ * @param stmt The PreparedStatement to reset. If
+ * null this method does nothing.
+ */
+ protected void resetStatement(PreparedStatement stmt) {
+ if (stmt != null) {
+ try {
+ stmt.clearParameters();
+ stmt.clearWarnings();
+ } catch (SQLException se) {
+ log.error("failed resetting PreparedStatement", se);
+ }
+ }
+ }
+
+ protected void closeResultSet(ResultSet rs) {
+ if (rs != null) {
+ try {
+ rs.close();
+ } catch (SQLException se) {
+ log.error("failed closing ResultSet", se);
+ }
+ }
+ }
+
+ protected void closeStatement(Statement stmt) {
+ if (stmt != null) {
+ try {
+ stmt.close();
+ } catch (SQLException se) {
+ log.error("failed closing Statement", se);
+ }
+ }
+ }
+
+ //--------------------------------------------------------< inner classes >
+
+ /**
+ * An input stream that knows its size.
+ */
+ class SizedInputStream extends FilterInputStream {
+ private final long size;
+ private boolean consumed;
+
+ SizedInputStream(InputStream in, long size) {
+ super(in);
+ this.size = size;
+ }
+
+ long getSize() {
+ return size;
+ }
+
+ boolean isConsumed() {
+ return consumed;
+ }
+
+ public int read() throws IOException {
+ consumed = true;
+ return super.read();
+ }
+
+ public long skip(long n) throws IOException {
+ consumed = true;
+ return super.skip(n);
+ }
+
+ public int read(byte[] b) throws IOException {
+ consumed = true;
+ return super.read(b);
+ }
+
+ public int read(byte[] b, int off, int len) throws IOException {
+ consumed = true;
+ return super.read(b, off, len);
+ }
+ }
}
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/fs/db/DbFileSystem.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/fs/db/DbFileSystem.java (.../sandbox/JCR-1456) (revision 827970)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/fs/db/DbFileSystem.java (.../trunk) (revision 827970)
@@ -16,11 +16,13 @@
*/
package org.apache.jackrabbit.core.fs.db;
-import org.apache.jackrabbit.core.util.db.ConnectionFactory;
-import org.apache.jackrabbit.core.util.db.DatabaseAware;
+import org.apache.jackrabbit.core.persistence.bundle.util.ConnectionFactory;
-import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.SQLException;
+import javax.jcr.RepositoryException;
+
/**
* DbFileSystem is a generic JDBC-based FileSystem
* implementation for Jackrabbit that persists file system entries in a
@@ -106,7 +108,7 @@
*
* See also {@link DerbyFileSystem}, {@link DB2FileSystem}, {@link OracleFileSystem}.
*/
-public class DbFileSystem extends DatabaseFileSystem implements DatabaseAware {
+public class DbFileSystem extends DatabaseFileSystem {
/**
* the full qualified JDBC driver name
@@ -128,20 +130,6 @@
*/
protected String password;
- protected String dataSourceName;
-
- /**
- * The repositories {@link ConnectionFactory}.
- */
- private ConnectionFactory connectionFactory;
-
- /**
- * {@inheritDoc}
- */
- public void setConnectionFactory(ConnectionFactory connnectionFactory) {
- this.connectionFactory = connnectionFactory;
- }
-
//----------------------------------------------------< setters & getters >
public String getUrl() {
return url;
@@ -175,14 +163,7 @@
this.driver = driver;
}
- public String getDataSourceName() {
- return dataSourceName;
- }
- public void setDataSourceName(String dataSourceName) {
- this.dataSourceName = dataSourceName;
- }
-
//-------------------------------------------< java.lang.Object overrides >
/**
* {@inheritDoc}
@@ -218,18 +199,12 @@
//--------------------------------------------------< DatabaseFileSystem >
/**
- * {@inheritDoc}
+ * Initialize the JDBC connection.
+ *
+ * @throws SQLException if an error occurs
*/
- @Override
- protected final DataSource getDataSource() throws Exception {
- if (getDataSourceName() == null || "".equals(getDataSourceName())) {
- return connectionFactory.getDataSource(getDriver(), getUrl(), getUser(), getPassword());
- } else {
- String dbType = connectionFactory.getDataBaseType(dataSourceName);
- if (DatabaseFileSystem.class.getResourceAsStream(dbType + ".ddl") != null) {
- setSchema(dbType);
- }
- return connectionFactory.getDataSource(dataSourceName);
- }
+ protected Connection getConnection() throws RepositoryException, SQLException {
+ return ConnectionFactory.getConnection(driver, url, user, password);
}
+
}
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/fs/db/DerbyFileSystem.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/fs/db/DerbyFileSystem.java (.../sandbox/JCR-1456) (revision 827970)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/fs/db/DerbyFileSystem.java (.../trunk) (revision 827970)
@@ -16,16 +16,13 @@
*/
package org.apache.jackrabbit.core.fs.db;
-import org.apache.jackrabbit.core.fs.FileSystemException;
-import org.apache.jackrabbit.core.util.db.ConnectionHelper;
-import org.apache.jackrabbit.core.util.db.DerbyConnectionHelper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import java.sql.DriverManager;
import java.sql.SQLException;
+import java.sql.Connection;
-import javax.sql.DataSource;
-
/**
* DerbyFileSystem is a JDBC-based FileSystem
* implementation for Jackrabbit that persists file system entries in an
@@ -59,6 +56,11 @@
public class DerbyFileSystem extends DbFileSystem {
/**
+ * Logger instance
+ */
+ private static Logger log = LoggerFactory.getLogger(DerbyFileSystem.class);
+
+ /**
* Flag indicating whether this derby database should be shutdown on close.
*/
protected boolean shutdownOnClose;
@@ -87,24 +89,46 @@
//-----------------------------------------------< DbFileSystem overrides >
/**
- * {@inheritDoc}
+ * Closes the given connection and shuts down the embedded Derby
+ * database if shutdownOnClose is set to true.
+ *
+ * @param connection database connection
+ * @throws SQLException if an error occurs
+ * @see DatabaseFileSystem#closeConnection(Connection)
*/
- @Override
- protected ConnectionHelper createConnectionHelper(DataSource dataSrc) throws Exception {
- return new DerbyConnectionHelper(dataSrc, false);
- }
+ protected void closeConnection(Connection connection) throws SQLException {
+ // prepare connection url for issuing shutdown command
+ String url;
+ try {
+ url = connection.getMetaData().getURL();
+ } catch (SQLException e) {
+ // JCR-1557: embedded derby db probably already shut down;
+ // this happens when configuring multiple FS/PM instances
+ // to use the same embedded derby db instance.
+ log.debug("failed to retrieve connection url: embedded db probably already shut down", e);
+ return;
+ }
+ int pos = url.lastIndexOf(';');
+ if (pos != -1) {
+ // strip any attributes from connection url
+ url = url.substring(0, pos);
+ }
+ url += ";shutdown=true";
- /**
- * {@inheritDoc}
- */
- @Override
- public void close() throws FileSystemException {
- super.close();
+ // we have to reset the connection to 'autoCommit=true' before closing it;
+ // otherwise Derby would mysteriously complain about some pending uncommitted
+ // changes which can't possibly be true.
+ // @todo further investigate
+ connection.setAutoCommit(true);
+ connection.close();
+
if (shutdownOnClose) {
+ // now it's safe to shutdown the embedded Derby database
try {
- ((DerbyConnectionHelper) conHelper).shutDown(driver);
+ DriverManager.getConnection(url);
} catch (SQLException e) {
- throw new FileSystemException("failed to shutdown Derby", e);
+ // a shutdown command always raises a SQLException
+ log.info(e.getMessage());
}
}
}
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/fs/db/OracleFileSystem.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/fs/db/OracleFileSystem.java (.../sandbox/JCR-1456) (revision 827970)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/fs/db/OracleFileSystem.java (.../trunk) (revision 827970)
@@ -16,11 +16,30 @@
*/
package org.apache.jackrabbit.core.fs.db;
-import org.apache.jackrabbit.core.util.db.CheckSchemaOperation;
-import org.apache.jackrabbit.core.util.db.ConnectionHelper;
-import org.apache.jackrabbit.core.util.db.Oracle10R1ConnectionHelper;
+import org.apache.commons.io.IOUtils;
+import org.apache.jackrabbit.util.Text;
+import org.apache.jackrabbit.util.TransientFileFactory;
+import org.apache.jackrabbit.core.fs.FileSystemException;
+import org.apache.jackrabbit.core.fs.FileSystemPathUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
-import javax.sql.DataSource;
+import javax.jcr.RepositoryException;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.sql.Blob;
+import java.sql.Connection;
+import java.io.InputStream;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.IOException;
+import java.io.File;
+import java.io.FilterOutputStream;
+import java.io.FileOutputStream;
+import java.io.FileInputStream;
+import java.lang.reflect.Method;
/**
* OracleFileSystem is a JDBC-based FileSystem
@@ -55,8 +74,21 @@
*/
public class OracleFileSystem extends DbFileSystem {
+ /**
+ * Logger instance
+ */
+ private static Logger log = LoggerFactory.getLogger(OracleFileSystem.class);
+
+ private Class< ? > blobClass;
+ private Integer durationSessionConstant;
+ private Integer modeReadWriteConstant;
+
+ /** the variable for the Oracle table space */
+ public static final String TABLE_SPACE_VARIABLE =
+ "${tableSpace}";
+
/** the Oracle table space to use */
- protected String tableSpace = "";
+ protected String tableSpace;
/**
* Creates a new OracleFileSystem instance.
@@ -82,36 +114,110 @@
* @param tableSpace the Oracle table space.
*/
public void setTableSpace(String tableSpace) {
- if (tableSpace != null && tableSpace.trim().length() > 0) {
- this.tableSpace = "tablespace " + tableSpace.trim();
+ if (tableSpace != null) {
+ this.tableSpace = tableSpace.trim();
} else {
- this.tableSpace = "";
+ this.tableSpace = null;
}
}
//-----------------------------------------< DatabaseFileSystem overrides >
-
/**
* {@inheritDoc}
+ *
+ * Retrieve the oracle.sql.BLOB class via reflection, and
+ * initialize the values for the DURATION_SESSION and
+ * MODE_READWRITE constants defined there.
+ * @see oracle.sql.BLOB#DURATION_SESSION
+ * @see oracle.sql.BLOB#MODE_READWRITE
*/
- @Override
- protected ConnectionHelper createConnectionHelper(DataSource dataSrc) throws Exception {
- Oracle10R1ConnectionHelper helper = new Oracle10R1ConnectionHelper(dataSrc, false);
- helper.init();
- return helper;
+ public void init() throws FileSystemException {
+ super.init();
+
+ // initialize oracle.sql.BLOB class & constants
+
+ // use the Connection object for using the exact same
+ // class loader that the Oracle driver was loaded with
+ try {
+ blobClass = con.getClass().getClassLoader().loadClass("oracle.sql.BLOB");
+ durationSessionConstant =
+ new Integer(blobClass.getField("DURATION_SESSION").getInt(null));
+ modeReadWriteConstant =
+ new Integer(blobClass.getField("MODE_READWRITE").getInt(null));
+ } catch (Exception e) {
+ String msg = "failed to load/introspect oracle.sql.BLOB";
+ log.error(msg, e);
+ throw new FileSystemException(msg, e);
+ }
}
/**
* {@inheritDoc}
+ *
+ * Overridden in order to support multiple oracle schemas. Note that
+ * schema names in Oracle correspond to the username of the connection.
+ * See http://issues.apache.org/jira/browse/JCR-582
+ *
+ * @throws Exception if an error occurs
*/
- @Override
- protected CheckSchemaOperation createCheckSchemaOperation() {
- return super.createCheckSchemaOperation().addVariableReplacement(
- CheckSchemaOperation.TABLE_SPACE_VARIABLE, tableSpace);
+ protected void checkSchema() throws Exception {
+ DatabaseMetaData metaData = con.getMetaData();
+ String tableName = schemaObjectPrefix + "FSENTRY";
+ if (metaData.storesLowerCaseIdentifiers()) {
+ tableName = tableName.toLowerCase();
+ } else if (metaData.storesUpperCaseIdentifiers()) {
+ tableName = tableName.toUpperCase();
+ }
+ String userName = metaData.getUserName();
+
+ ResultSet rs = metaData.getTables(null, userName, tableName, null);
+ boolean schemaExists;
+ try {
+ schemaExists = rs.next();
+ } finally {
+ rs.close();
+ }
+
+ if (!schemaExists) {
+ // read ddl from resources
+ InputStream in = OracleFileSystem.class.getResourceAsStream(schema + ".ddl");
+ if (in == null) {
+ String msg = "Configuration error: unknown schema '" + schema + "'";
+ log.debug(msg);
+ throw new RepositoryException(msg);
+ }
+ BufferedReader reader = new BufferedReader(new InputStreamReader(in));
+ Statement stmt = con.createStatement();
+ try {
+ String sql = reader.readLine();
+ while (sql != null) {
+ // Skip comments and empty lines
+ if (!sql.startsWith("#") && sql.length() > 0) {
+ // replace prefix variable
+ sql = Text.replace(sql, SCHEMA_OBJECT_PREFIX_VARIABLE, schemaObjectPrefix);
+
+ // set the tablespace if it is defined
+ String tspace;
+ if (tableSpace == null || "".equals(tableSpace)) {
+ tspace = "";
+ } else {
+ tspace = "tablespace " + tableSpace;
+ }
+ sql = Text.replace(sql, TABLE_SPACE_VARIABLE, tspace).trim();
+
+ // execute sql stmt
+ stmt.executeUpdate(sql);
+ }
+ // read next sql stmt
+ sql = reader.readLine();
+ }
+ } finally {
+ IOUtils.closeQuietly(in);
+ closeStatement(stmt);
+ }
+ }
}
- //-----------------------------------------< DatabaseFileSystem overrides >
-
/**
* Builds the SQL statements
*
@@ -220,4 +326,149 @@
+ schemaObjectPrefix + "FSENTRY where FSENTRY_PATH = ? "
+ "and FSENTRY_LENGTH is not null";
}
+
+
+ /**
+ * {@inheritDoc}
+ *
+ * Overridden because we need to use oracle.sql.BLOB
+ * and PreparedStatement#setBlob instead of just
+ * PreparedStatement#setBinaryStream.
+ */
+ public OutputStream getOutputStream(final String filePath) throws FileSystemException {
+ if (!initialized) {
+ throw new IllegalStateException("not initialized");
+ }
+
+ FileSystemPathUtil.checkFormat(filePath);
+
+ final String parentDir = FileSystemPathUtil.getParentDir(filePath);
+ final String name = FileSystemPathUtil.getName(filePath);
+
+ if (!isFolder(parentDir)) {
+ throw new FileSystemException("path not found: " + parentDir);
+ }
+
+ if (isFolder(filePath)) {
+ throw new FileSystemException("path denotes folder: " + filePath);
+ }
+
+ try {
+ TransientFileFactory fileFactory = TransientFileFactory.getInstance();
+ final File tmpFile = fileFactory.createTransientFile("bin", null, null);
+
+ return new FilterOutputStream(new FileOutputStream(tmpFile)) {
+
+ public void write(byte[] bytes, int off, int len) throws IOException {
+ out.write(bytes, off, len);
+ }
+
+ public void close() throws IOException {
+ out.flush();
+ ((FileOutputStream) out).getFD().sync();
+ out.close();
+
+ InputStream in = null;
+ Blob blob = null;
+ try {
+ if (isFile(filePath)) {
+ synchronized (updateDataSQL) {
+ long length = tmpFile.length();
+ in = new FileInputStream(tmpFile);
+ blob = createTemporaryBlob(in);
+ executeStmt(updateDataSQL,
+ new Object[]{
+ blob,
+ new Long(System.currentTimeMillis()),
+ new Long(length),
+ parentDir,
+ name
+ });
+ }
+ } else {
+ synchronized (insertFileSQL) {
+ long length = tmpFile.length();
+ in = new FileInputStream(tmpFile);
+ blob = createTemporaryBlob(in);
+ executeStmt(insertFileSQL,
+ new Object[]{
+ parentDir,
+ name,
+ blob,
+ new Long(System.currentTimeMillis()),
+ new Long(length)
+ });
+ }
+ }
+ } catch (Exception e) {
+ IOException ioe = new IOException(e.getMessage());
+ ioe.initCause(e);
+ throw ioe;
+ } finally {
+ if (blob != null) {
+ try {
+ freeTemporaryBlob(blob);
+ } catch (Exception e1) {
+ }
+ }
+ IOUtils.closeQuietly(in);
+ // temp file can now safely be removed
+ tmpFile.delete();
+ }
+ }
+ };
+ } catch (Exception e) {
+ String msg = "failed to open output stream to file: " + filePath;
+ log.error(msg, e);
+ throw new FileSystemException(msg, e);
+ }
+ }
+
+ //----------------------------------------< oracle-specific blob handling >
+ /**
+ * Creates a temporary oracle.sql.BLOB instance via reflection and spools
+ * the contents of the specified stream.
+ */
+ protected Blob createTemporaryBlob(InputStream in) throws Exception {
+ /*
+ BLOB blob = BLOB.createTemporary(con, false, BLOB.DURATION_SESSION);
+ blob.open(BLOB.MODE_READWRITE);
+ OutputStream out = blob.getBinaryOutputStream();
+ ...
+ out.flush();
+ out.close();
+ blob.close();
+ return blob;
+ */
+ Method createTemporary = blobClass.getMethod("createTemporary",
+ new Class[]{Connection.class, Boolean.TYPE, Integer.TYPE});
+ Object blob = createTemporary.invoke(null,
+ new Object[]{con, Boolean.FALSE, durationSessionConstant});
+ Method open = blobClass.getMethod("open", new Class[]{Integer.TYPE});
+ open.invoke(blob, new Object[]{modeReadWriteConstant});
+ Method getBinaryOutputStream =
+ blobClass.getMethod("getBinaryOutputStream", new Class[0]);
+ OutputStream out = (OutputStream) getBinaryOutputStream.invoke(blob);
+ try {
+ IOUtils.copy(in, out);
+ } finally {
+ try {
+ out.flush();
+ } catch (IOException ioe) {
+ }
+ out.close();
+ }
+ Method close = blobClass.getMethod("close", new Class[0]);
+ close.invoke(blob);
+ return (Blob) blob;
+ }
+
+ /**
+ * Frees a temporary oracle.sql.BLOB instance via reflection.
+ */
+ protected void freeTemporaryBlob(Object blob) throws Exception {
+ // blob.freeTemporary();
+ Method freeTemporary = blobClass.getMethod("freeTemporary", new Class[0]);
+ freeTemporary.invoke(blob);
+ }
}
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/fs/db/JNDIDatabaseFileSystem.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/fs/db/JNDIDatabaseFileSystem.java (.../sandbox/JCR-1456) (revision 827970)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/fs/db/JNDIDatabaseFileSystem.java (.../trunk) (revision 827970)
@@ -17,7 +17,10 @@
package org.apache.jackrabbit.core.fs.db;
import javax.naming.InitialContext;
+import javax.naming.NamingException;
import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.SQLException;
/**
* @deprecated
@@ -65,11 +68,17 @@
//--------------------------------------------------< DatabaseFileSystem >
/**
- * {@inheritDoc}
+ * Returns a JDBC connection from a {@link DataSource} acquired from JNDI
+ * with the configured data source location.
+ *
+ * @return new database connection
+ * @throws NamingException if the given data source location does not exist
+ * @throws SQLException if a database access error occurs
*/
- @Override
- protected DataSource getDataSource() throws Exception {
+ protected Connection getConnection() throws NamingException, SQLException {
InitialContext ic = new InitialContext();
- return (DataSource) ic.lookup(dataSourceLocation);
+ DataSource dataSource = (DataSource) ic.lookup(dataSourceLocation);
+ return dataSource.getConnection();
}
+
}
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/data/db/DbInputStream.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/data/db/DbInputStream.java (.../sandbox/JCR-1456) (revision 827970)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/data/db/DbInputStream.java (.../trunk) (revision 827970)
@@ -23,7 +23,7 @@
import org.apache.commons.io.input.AutoCloseInputStream;
import org.apache.jackrabbit.core.data.DataIdentifier;
import org.apache.jackrabbit.core.data.DataStoreException;
-import org.apache.jackrabbit.core.util.db.DbUtility;
+import org.apache.jackrabbit.core.persistence.bundle.util.ConnectionRecoveryManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -39,7 +39,8 @@
protected DbDataStore store;
protected DataIdentifier identifier;
protected boolean endOfStream;
-
+
+ protected ConnectionRecoveryManager conn;
protected ResultSet rs;
@@ -129,9 +130,16 @@
// some additional database objects
// may need to be closed
if (rs != null) {
- DbUtility.close(rs);
+ DatabaseHelper.closeSilently(rs);
rs = null;
}
+ if (conn != null) {
+ try {
+ store.putBack(conn);
+ } catch (DataStoreException e) {
+ log.info("Error closing DbResource", e);
+ }
+ }
}
}
@@ -200,6 +208,16 @@
}
/**
+ * Set the database connection of this input stream. This object must be
+ * closed once the stream is closed.
+ *
+ * @param conn the connection
+ */
+ void setConnection(ConnectionRecoveryManager conn) {
+ this.conn = conn;
+ }
+
+ /**
* Set the result set of this input stream. This object must be closed once
* the stream is closed.
*
@@ -208,4 +226,5 @@
void setResultSet(ResultSet rs) {
this.rs = rs;
}
+
}
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/data/db/DatabaseHelper.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/data/db/DatabaseHelper.java (.../sandbox/JCR-1456) (revision 0)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/data/db/DatabaseHelper.java (.../trunk) (revision 827970)
@@ -0,0 +1,72 @@
+/*
+ * 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.jackrabbit.core.data.db;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Helper methods for database operations.
+ */
+public class DatabaseHelper {
+
+ private static Logger log = LoggerFactory.getLogger(DatabaseHelper.class);
+
+ /**
+ * Silently closes a connection.
+ */
+ public static void closeSilently(Connection con) {
+ try {
+ if (con != null) {
+ con.close();
+ }
+ } catch (SQLException e) {
+ log.info("Couldn't close connection: ", e);
+ }
+ }
+
+ /**
+ * Silently closes a result set.
+ */
+ public static void closeSilently(ResultSet rs) {
+ try {
+ if (rs != null) {
+ rs.close();
+ }
+ } catch (SQLException e) {
+ log.info("Couldn't close result set: ", e);
+ }
+ }
+
+ /**
+ * Silently closes a statement.
+ */
+ public static void closeSilently(Statement stmt) {
+ try {
+ if (stmt != null) {
+ stmt.close();
+ }
+ } catch (SQLException e) {
+ log.info("Couldn't close statement: ", e);
+ }
+ }
+}
Property changes on: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/data/db/DatabaseHelper.java
___________________________________________________________________
Added: svn:eol-style
+ native
Added: svn:keywords
+ Author Date Id Revision Rev URL
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/data/db/Pool.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/data/db/Pool.java (.../sandbox/JCR-1456) (revision 0)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/data/db/Pool.java (.../trunk) (revision 827970)
@@ -0,0 +1,88 @@
+/*
+ * 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.jackrabbit.core.data.db;
+
+import java.util.ArrayList;
+import java.util.concurrent.LinkedBlockingQueue;
+
+import javax.jcr.RepositoryException;
+
+import org.apache.jackrabbit.core.persistence.bundle.util.ConnectionRecoveryManager;
+
+/**
+ * Implementation of a simple ConnectionRecoveryManager pool.
+ * The maximum number of pooled objects can be set, and if more objects
+ * are requested the pool waits until one object is put back.
+ */
+public class Pool {
+ protected final int maxSize;
+ protected final ArrayListnull if a data store has not been configured.
*
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/config/RepositoryConfigurationParser.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/config/RepositoryConfigurationParser.java (.../sandbox/JCR-1456) (revision 827970)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/config/RepositoryConfigurationParser.java (.../trunk) (revision 827970)
@@ -36,7 +36,6 @@
import org.apache.jackrabbit.core.util.RepositoryLock;
import org.apache.jackrabbit.core.util.RepositoryLockMechanism;
import org.apache.jackrabbit.core.util.RepositoryLockMechanismFactory;
-import org.apache.jackrabbit.core.util.db.ConnectionFactory;
import org.apache.jackrabbit.spi.commons.namespace.NamespaceResolver;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
@@ -117,12 +116,6 @@
/** Name of the cluster configuration element. */
public static final String CLUSTER_ELEMENT = "Cluster";
- /** Name of the data source configuration element. */
- public static final String DATASOURCES_ELEMENT = "DataSources";
-
- /** Name of the data source configuration element. */
- public static final String DATASOURCE_ELEMENT = "DataSource";
-
/** Name of the journal configuration element. */
public static final String JOURNAL_ELEMENT = "Journal";
@@ -188,11 +181,6 @@
private static final String AC_PROVIDER_ELEMENT = "AccessControlProvider";
/**
- * The repositories {@link ConnectionFactory}.
- */
- private final ConnectionFactory connectionFactory;
-
- /**
* Name of the cluster node id file.
*/
private static final String CLUSTER_NODE_ID_FILE = "cluster_node.id";
@@ -202,9 +190,8 @@
*
* @param variables parser variables
*/
- public RepositoryConfigurationParser(Properties variables, ConnectionFactory connectionFactory) {
+ public RepositoryConfigurationParser(Properties variables) {
super(variables);
- this.connectionFactory = connectionFactory;
}
/**
@@ -302,36 +289,12 @@
RepositoryLockMechanismFactory rlf = getRepositoryLockMechanismFactory(root);
- // Optional data source configuration
- DataSourceConfig dsc = parseDataSourceConfig(root);
-
return new RepositoryConfig(home, securityConfig, fsf,
workspaceDirectory, workspaceConfigDirectory, defaultWorkspace,
- maxIdleTime, template, vc, qhf, cc, dsf, rlf, dsc, connectionFactory, this);
+ maxIdleTime, template, vc, qhf, cc, dsf, rlf, this);
}
-
/**
- * {@inheritDoc}
- */
- @Override
- protected BeanConfig parseBeanConfig(Element parent, String name) throws ConfigurationException {
- BeanConfig cfg = super.parseBeanConfig(parent, name);
- cfg.setConnectionFactory(connectionFactory);
- return cfg;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- protected BeanConfig parseBeanConfig(Element element) throws ConfigurationException {
- BeanConfig cfg = super.parseBeanConfig(element);
- cfg.setConnectionFactory(connectionFactory);
- return cfg;
- }
-
- /**
* Parses security configuration. Security configuration
* uses the following format:
*
@@ -825,38 +788,6 @@
}
/**
- * TODO
- *
- * @param parent
- * @return
- * @throws ConfigurationException
- */
- protected DataSourceConfig parseDataSourceConfig(Element parent)
- throws ConfigurationException {
- DataSourceConfig dsc = new DataSourceConfig();
- NodeList children = parent.getChildNodes();
- for (int i = 0; i < children.getLength(); i++) {
- Node child = children.item(i);
- if (child.getNodeType() == Node.ELEMENT_NODE
- && DATASOURCES_ELEMENT.equals(child.getNodeName())) {
- Element element = (Element) child;
- NodeList children2 = element.getChildNodes();
- // Process the DataSource entries:
- for (int j = 0; j < children2.getLength(); j++) {
- Node child2 = children2.item(j);
- if (child2.getNodeType() == Node.ELEMENT_NODE
- && DATASOURCE_ELEMENT.equals(child2.getNodeName())) {
- Element dsdef = (Element) child2;
- Properties props = parseParameters(dsdef);
- dsc.addDataSourceDefinition(props);
- }
- }
- }
- }
- return dsc;
- }
-
- /**
* Parses data store configuration. Data store configuration uses the following format:
*
* <DataStore class="...">
@@ -950,7 +881,7 @@
/**
* Creates a new instance of a configuration parser but with overlayed
- * variables and the same connection factory as this parser.
+ * variables.
*
* @param variables the variables overlay
* @return a new configuration parser instance
@@ -959,7 +890,7 @@
// overlay the properties
Properties props = new Properties(getVariables());
props.putAll(variables);
- return new RepositoryConfigurationParser(props, connectionFactory);
+ return new RepositoryConfigurationParser(props);
}
/**
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/config/BeanConfig.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/config/BeanConfig.java (.../sandbox/JCR-1456) (revision 827970)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/config/BeanConfig.java (.../trunk) (revision 827970)
@@ -17,8 +17,6 @@
package org.apache.jackrabbit.core.config;
import org.apache.commons.collections.BeanMap;
-import org.apache.jackrabbit.core.util.db.ConnectionFactory;
-import org.apache.jackrabbit.core.util.db.DatabaseAware;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -80,11 +78,6 @@
private final Properties properties;
/**
- * The repositories {@link ConnectionFactory}.
- */
- private ConnectionFactory connectionFactory = null;
-
- /**
* Flag to validate the configured bean property names against
* the configured bean class. By default this is true
* to prevent incorrect property names. However, in some cases this
@@ -122,7 +115,6 @@
*/
public BeanConfig(BeanConfig config) {
this(config.getClassName(), config.getParameters());
- setConnectionFactory(config.connectionFactory);
}
/**
@@ -136,14 +128,6 @@
}
/**
- * @param connectionFactory the {@link ConnectionFactory} to inject (if possible) in the
- * {@link #newInstance()} method
- */
- public void setConnectionFactory(ConnectionFactory connectionFactory) {
- this.connectionFactory = connectionFactory;
- }
-
- /**
* Returns the class name of the configured bean.
*
* @return class name of the bean
@@ -183,10 +167,6 @@
}
}
- if (object instanceof DatabaseAware) {
- ((DatabaseAware) object).setConnectionFactory(connectionFactory);
- }
-
if (validate) {
// Check that no invalid property names were configured
for (Object key : properties.keySet()) {
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/journal/DatabaseJournal.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/journal/DatabaseJournal.java (.../sandbox/JCR-1456) (revision 827970)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/journal/DatabaseJournal.java (.../trunk) (revision 827970)
@@ -16,28 +16,26 @@
*/
package org.apache.jackrabbit.core.journal;
-import org.apache.commons.io.IOUtils;
-import org.apache.jackrabbit.core.util.db.CheckSchemaOperation;
-import org.apache.jackrabbit.core.util.db.ConnectionFactory;
-import org.apache.jackrabbit.core.util.db.ConnectionHelper;
-import org.apache.jackrabbit.core.util.db.DatabaseAware;
-import org.apache.jackrabbit.core.util.db.DbUtility;
-import org.apache.jackrabbit.core.util.db.StreamWrapper;
+import org.apache.jackrabbit.core.persistence.bundle.util.ConnectionFactory;
import org.apache.jackrabbit.spi.commons.namespace.NamespaceResolver;
+import org.apache.jackrabbit.util.Text;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.BufferedReader;
-import java.io.ByteArrayInputStream;
import java.io.File;
+import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
+import java.sql.Statement;
import java.util.Calendar;
import javax.jcr.RepositoryException;
-import javax.sql.DataSource;
/**
* Database-based journal implementation. Stores records inside a database table named
@@ -78,9 +76,20 @@
* *
* driver and
* url have been specified and optionally deduces a valid
@@ -324,24 +340,15 @@
* @throws JournalException if initialization fails
*/
protected void init() throws JournalException {
- if (driver == null && dataSourceName == null) {
+ if (driver == null) {
String msg = "Driver not specified.";
throw new JournalException(msg);
}
- if (url == null && dataSourceName == null) {
+ if (url == null) {
String msg = "Connection URL not specified.";
throw new JournalException(msg);
}
- if (dataSourceName != null) {
- try {
- String configuredDatabaseType = connectionFactory.getDataBaseType(dataSourceName);
- if (DatabaseJournal.class.getResourceAsStream(configuredDatabaseType + ".ddl") != null) {
- setDatabaseType(configuredDatabaseType);
- }
- } catch (RepositoryException e) {
- throw new JournalException("failed to get database type", e);
- }
- }
+
if (databaseType == null) {
try {
databaseType = getDatabaseTypeFromURL(url);
@@ -350,6 +357,13 @@
throw new JournalException(msg);
}
}
+
+ try {
+ Class.forName(driver);
+ } catch (ClassNotFoundException e) {
+ String msg = "Unable to load driver class.";
+ throw new JournalException(msg, e);
+ }
}
/**
@@ -392,6 +406,27 @@
}
/**
+ * Creates a new database connection. This method is called inside
+ * {@link #init(String, org.apache.jackrabbit.spi.commons.namespace.NamespaceResolver)} or
+ * when a connection has been dropped and must be reacquired. Base
+ * implementation uses java.sql.DriverManager to get the
+ * connection. May be overridden by subclasses.
+ *
+ * @see #init()
+ * @return new connection
+ * @throws JournalException if the driver could not be loaded
+ * @throws SQLException if the connection could not be established
+ */
+ protected Connection getConnection() throws SQLException, JournalException {
+ try {
+ return ConnectionFactory.getConnection(driver, url, user, password);
+ } catch (RepositoryException e) {
+ String msg = "Unable to load driver class.";
+ throw new JournalException(msg, e);
+ }
+ }
+
+ /**
* Derive a database type from a JDBC connection URL. This simply treats the given URL
* as delimeted by colons and takes the 2nd field.
*
@@ -413,12 +448,24 @@
/**
* {@inheritDoc}
*/
- public RecordIterator getRecords(long startRevision) throws JournalException {
+ public RecordIterator getRecords(long startRevision)
+ throws JournalException {
+
try {
- return new DatabaseRecordIterator(conHelper.exec(selectRevisionsStmtSQL, new Object[]{new Long(
- startRevision)}, false, 0), getResolver(), getNamePathResolver());
+ checkConnection();
+
+ selectRevisionsStmt.clearParameters();
+ selectRevisionsStmt.clearWarnings();
+ selectRevisionsStmt.setLong(1, startRevision);
+ selectRevisionsStmt.execute();
+
+ return new DatabaseRecordIterator(
+ selectRevisionsStmt.getResultSet(), getResolver(), getNamePathResolver());
} catch (SQLException e) {
- throw new JournalException("Unable to return record iterator.", e);
+ close(true);
+
+ String msg = "Unable to return record iterator.";
+ throw new JournalException(msg, e);
}
}
@@ -427,10 +474,20 @@
*/
public RecordIterator getRecords() throws JournalException {
try {
- return new DatabaseRecordIterator(conHelper.exec(selectRevisionsStmtSQL, new Object[]{new Long(
- Long.MIN_VALUE)}, false, 0), getResolver(), getNamePathResolver());
+ checkConnection();
+
+ selectRevisionsStmt.clearParameters();
+ selectRevisionsStmt.clearWarnings();
+ selectRevisionsStmt.setLong(1, Long.MIN_VALUE);
+ selectRevisionsStmt.execute();
+
+ return new DatabaseRecordIterator(
+ selectRevisionsStmt.getResultSet(), getResolver(), getNamePathResolver());
} catch (SQLException e) {
- throw new JournalException("Unable to return record iterator.", e);
+ close(true);
+
+ String msg = "Unable to return record iterator.";
+ throw new JournalException(msg, e);
}
}
@@ -447,16 +504,27 @@
boolean succeeded = false;
try {
+ checkConnection();
if (lockLevel++ == 0) {
- conHelper.startBatch();
+ setAutoCommit(connection, false);
}
} catch (SQLException e) {
- throw new JournalException("Unable to set autocommit to false.", e);
+ close(true);
+
+ String msg = "Unable to set autocommit to false.";
+ throw new JournalException(msg, e);
}
try {
- conHelper.exec(updateGlobalStmtSQL);
- rs = conHelper.exec(selectGlobalStmtSQL, null, false, 0);
+ updateGlobalStmt.clearParameters();
+ updateGlobalStmt.clearWarnings();
+ updateGlobalStmt.execute();
+
+ selectGlobalStmt.clearParameters();
+ selectGlobalStmt.clearWarnings();
+ selectGlobalStmt.execute();
+
+ rs = selectGlobalStmt.getResultSet();
if (!rs.next()) {
throw new JournalException("No revision available.");
}
@@ -464,9 +532,12 @@
succeeded = true;
} catch (SQLException e) {
- throw new JournalException("Unable to lock global revision table.", e);
+ close(true);
+
+ String msg = "Unable to lock global revision table.";
+ throw new JournalException(msg, e);
} finally {
- DbUtility.close(rs);
+ close(rs);
if (!succeeded) {
doUnlock(false);
}
@@ -478,11 +549,12 @@
*/
protected void doUnlock(boolean successful) {
if (--lockLevel == 0) {
- try {
- conHelper.endBatch(successful);;
- } catch (SQLException e) {
- log.error("failed to end batch", e);
+ if (successful) {
+ commit(connection);
+ } else {
+ rollback(connection);
}
+ setAutoCommit(connection, true);
}
}
@@ -504,10 +576,19 @@
throws JournalException {
try {
- conHelper.exec(insertRevisionStmtSQL, record.getRevision(), getId(), record.getProducerId(),
- new StreamWrapper(in, length));
+ checkConnection();
+ insertRevisionStmt.clearParameters();
+ insertRevisionStmt.clearWarnings();
+ insertRevisionStmt.setLong(1, record.getRevision());
+ insertRevisionStmt.setString(2, getId());
+ insertRevisionStmt.setString(3, record.getProducerId());
+ insertRevisionStmt.setBinaryStream(4, in, length);
+ insertRevisionStmt.execute();
+
} catch (SQLException e) {
+ close(true);
+
String msg = "Unable to append revision " + lockedRevision + ".";
throw new JournalException(msg, e);
}
@@ -517,43 +598,313 @@
* {@inheritDoc}
*/
public void close() {
+ close(false);
if (janitorThread != null) {
janitorThread.interrupt();
}
}
/**
+ * Close database connections and statements. If closing was due to an
+ * error that occurred, calculates the next time a reconnect should
+ * be attempted.
+ *
+ * @param failure whether closing is due to a failure
+ */
+ private void close(boolean failure) {
+ if (failure) {
+ reconnectTimeMs = System.currentTimeMillis() + reconnectDelayMs;
+ }
+
+ close(selectRevisionsStmt);
+ selectRevisionsStmt = null;
+ close(updateGlobalStmt);
+ updateGlobalStmt = null;
+ close(selectGlobalStmt);
+ selectGlobalStmt = null;
+ close(insertRevisionStmt);
+ insertRevisionStmt = null;
+ close(selectMinLocalRevisionStmt);
+ selectMinLocalRevisionStmt = null;
+ close(cleanRevisionStmt);
+ cleanRevisionStmt = null;
+ close(getLocalRevisionStmt);
+ getLocalRevisionStmt = null;
+ close(insertLocalRevisionStmt);
+ insertLocalRevisionStmt = null;
+ close(updateLocalRevisionStmt);
+ updateLocalRevisionStmt = null;
+
+ close(connection);
+ connection = null;
+ }
+
+ /**
+ * Set the autocommit flag of a connection. Does nothing if the connection
+ * passed is null and logs any exception as warning.
+ *
+ * @param connection database connection
+ * @param autoCommit where to enable or disable autocommit
+ */
+ private static void setAutoCommit(Connection connection, boolean autoCommit) {
+ if (connection != null) {
+ try {
+ // JCR-1013: Setter may fail on a managed connection
+ if (connection.getAutoCommit() != autoCommit) {
+ connection.setAutoCommit(autoCommit);
+ }
+ } catch (SQLException e) {
+ String msg = "Unable to set autocommit flag to " + autoCommit;
+ log.warn(msg, e);
+ }
+ }
+ }
+
+ /**
+ * Commit a connection. Does nothing if the connection passed is
+ * null and logs any exception as warning.
+ *
+ * @param connection connection.
+ */
+ private static void commit(Connection connection) {
+ if (connection != null) {
+ try {
+ connection.commit();
+ } catch (SQLException e) {
+ String msg = "Error while committing connection: " + e.getMessage();
+ log.warn(msg);
+ }
+ }
+ }
+
+ /**
+ * Rollback a connection. Does nothing if the connection passed is
+ * null and logs any exception as warning.
+ *
+ * @param connection connection.
+ */
+ private static void rollback(Connection connection) {
+ if (connection != null) {
+ try {
+ connection.rollback();
+ } catch (SQLException e) {
+ String msg = "Error while rolling back connection: " + e.getMessage();
+ log.warn(msg);
+ }
+ }
+ }
+
+ /**
+ * Closes the given database connection. Does nothing if the connection
+ * passed is null and logs any exception as warning.
+ *
+ * @param connection database connection
+ */
+ private static void close(Connection connection) {
+ if (connection != null) {
+ try {
+ connection.close();
+ } catch (SQLException e) {
+ String msg = "Error while closing connection: " + e.getMessage();
+ log.warn(msg);
+ }
+ }
+ }
+
+ /**
+ * Close some input stream. Does nothing if the input stream
+ * passed is null and logs any exception as warning.
+ *
+ * @param in input stream, may be null.
+ */
+ private static void close(InputStream in) {
+ if (in != null) {
+ try {
+ in.close();
+ } catch (IOException e) {
+ String msg = "Error while closing input stream: " + e.getMessage();
+ log.warn(msg);
+ }
+ }
+ }
+
+ /**
+ * Close some statement. Does nothing if the statement
+ * passed is null and logs any exception as warning.
+ *
+ * @param stmt statement, may be null.
+ */
+ private static void close(Statement stmt) {
+ if (stmt != null) {
+ try {
+ stmt.close();
+ } catch (SQLException e) {
+ String msg = "Error while closing statement: " + e.getMessage();
+ log.warn(msg);
+ }
+ }
+ }
+
+ /**
+ * Close some resultset. Does nothing if the result set
+ * passed is null and logs any exception as warning.
+ *
+ * @param rs resultset, may be null.
+ */
+ private static void close(ResultSet rs) {
+ if (rs != null) {
+ try {
+ rs.close();
+ } catch (SQLException e) {
+ String msg = "Error while closing result set: " + e.getMessage();
+ log.warn(msg);
+ }
+ }
+ }
+
+ /**
+ * Checks the currently established connection. If the connection no longer
+ * exists, waits until at least reconnectTimeMs have passed
+ * since the error occurred and recreates the connection.
+ */
+ private void checkConnection() throws SQLException, JournalException {
+ if (connection == null) {
+ long delayMs = reconnectTimeMs - System.currentTimeMillis();
+ if (delayMs > 0) {
+ try {
+ Thread.sleep(delayMs);
+ } catch (InterruptedException e) {
+ /* ignore */
+ }
+ }
+ connection = getConnection();
+ prepareStatements();
+ }
+ }
+
+ /**
+ * Checks if the required schema objects exist and creates them if they
+ * don't exist yet.
+ *
+ * @throws Exception if an error occurs
+ */
+ private void checkSchema() throws Exception {
+ if (!tableExists(connection.getMetaData(), schemaObjectPrefix + DEFAULT_JOURNAL_TABLE)) { // read ddl from resources
+ InputStream in = DatabaseJournal.class.getResourceAsStream(databaseType + ".ddl");
+ if (in == null) {
+ String msg = "No database-specific DDL found: '" + databaseType + ".ddl"
+ + "', falling back to '" + DEFAULT_DDL_NAME + "'.";
+ log.info(msg);
+ in = DatabaseJournal.class.getResourceAsStream(DEFAULT_DDL_NAME);
+ if (in == null) {
+ msg = "Unable to load '" + DEFAULT_DDL_NAME + "'.";
+ throw new JournalException(msg);
+ }
+ }
+ BufferedReader reader = new BufferedReader(new InputStreamReader(in));
+ Statement stmt = connection.createStatement();
+ try {
+ String sql = reader.readLine();
+ while (sql != null) {
+ // Skip comments and empty lines
+ if (!sql.startsWith("#") && sql.length() > 0) {
+ // replace prefix variable
+ sql = createSchemaSQL(sql);
+ // execute sql stmt
+ stmt.executeUpdate(sql);
+ }
+ // read next sql stmt
+ sql = reader.readLine();
+ }
+ } finally {
+ close(in);
+ close(stmt);
+ }
+ }
+ }
+
+ /**
* Checks if the local revision schema objects exist and creates them if they
* don't exist yet.
*
* @throws Exception if an error occurs
*/
private void checkLocalRevisionSchema() throws Exception {
- InputStream localRevisionDDLStream = null;
- InputStream in = DatabaseJournal.class.getResourceAsStream(databaseType + ".ddl");
- try {
+ if (!tableExists(connection.getMetaData(), schemaObjectPrefix + LOCAL_REVISIONS_TABLE)) {
+ log.info("Creating " + schemaObjectPrefix + LOCAL_REVISIONS_TABLE + " table");
+ // read ddl from resources
+ InputStream in = DatabaseJournal.class.getResourceAsStream(databaseType + ".ddl");
+ if (in == null) {
+ String msg = "No database-specific DDL found: '" + databaseType + ".ddl" +
+ "', falling back to '" + DEFAULT_DDL_NAME + "'.";
+ log.info(msg);
+ in = DatabaseJournal.class.getResourceAsStream(DEFAULT_DDL_NAME);
+ if (in == null) {
+ msg = "Unable to load '" + DEFAULT_DDL_NAME + "'.";
+ throw new JournalException(msg);
+ }
+ }
BufferedReader reader = new BufferedReader(new InputStreamReader(in));
- String sql = reader.readLine();
- while (sql != null) {
- // Skip comments and empty lines, and select only the statement to create the LOCAL_REVISIONS
- // table.
- if (!sql.startsWith("#") && sql.length() > 0 && sql.indexOf(LOCAL_REVISIONS_TABLE) != -1) {
- localRevisionDDLStream = new ByteArrayInputStream(sql.getBytes());
- break;
+ Statement stmt = connection.createStatement();
+ try {
+ String sql = reader.readLine();
+ while (sql != null) {
+ // Skip comments and empty lines, and select only the statement
+ // to create the LOCAL_REVISIONS table.
+ if (!sql.startsWith("#") && sql.length() > 0
+ && sql.indexOf(LOCAL_REVISIONS_TABLE) != -1) {
+ // replace prefix variable
+ sql = createSchemaSQL(sql);
+ // execute sql stmt
+ stmt.executeUpdate(sql);
+ }
+ // read next sql stmt
+ sql = reader.readLine();
}
- // read next sql stmt
- sql = reader.readLine();
+ } finally {
+ close(in);
+ close(stmt);
}
+ }
+ }
+
+ /**
+ * Checks whether the required table(s) exist in the schema. May be
+ * overridden by subclasses to allow different table names.
+ *
+ * @param metaData database meta data
+ * @return true if the schema exists
+ * @throws SQLException if an SQL error occurs
+ */
+ protected boolean tableExists(DatabaseMetaData metaData, String tableName)
+ throws SQLException {
+
+ if (metaData.storesLowerCaseIdentifiers()) {
+ tableName = tableName.toLowerCase();
+ } else if (metaData.storesUpperCaseIdentifiers()) {
+ tableName = tableName.toUpperCase();
+ }
+
+ ResultSet rs = metaData.getTables(null, null, tableName, null);
+
+ try {
+ return rs.next();
} finally {
- IOUtils.closeQuietly(in);
+ rs.close();
}
- // Run the schema check for the single table
- new CheckSchemaOperation(conHelper, localRevisionDDLStream, schemaObjectPrefix
- + LOCAL_REVISIONS_TABLE).addVariableReplacement(
- CheckSchemaOperation.SCHEMA_OBJECT_PREFIX_VARIABLE, schemaObjectPrefix).run();
}
/**
+ * Creates an SQL statement for schema creation by variable substitution.
+ *
+ * @param sql a SQL string which may contain variables to substitute
+ * @return a valid SQL string
+ */
+ protected String createSchemaSQL(String sql) {
+ return Text.replace(sql, SCHEMA_OBJECT_PREFIX_VARIABLE, schemaObjectPrefix);
+ }
+
+ /**
* Builds the SQL statements. May be overridden by subclasses to allow
* different table and/or column names.
*/
@@ -587,6 +938,23 @@
}
/**
+ * Prepares the SQL statements.
+ *
+ * @throws SQLException if an error occurs
+ */
+ private void prepareStatements() throws SQLException {
+ selectRevisionsStmt = connection.prepareStatement(selectRevisionsStmtSQL);
+ updateGlobalStmt = connection.prepareStatement(updateGlobalStmtSQL);
+ selectGlobalStmt = connection.prepareStatement(selectGlobalStmtSQL);
+ insertRevisionStmt = connection.prepareStatement(insertRevisionStmtSQL);
+ selectMinLocalRevisionStmt = connection.prepareStatement(selectMinLocalRevisionStmtSQL);
+ cleanRevisionStmt = connection.prepareStatement(cleanRevisionStmtSQL);
+ getLocalRevisionStmt = connection.prepareStatement(getLocalRevisionStmtSQL);
+ insertLocalRevisionStmt = connection.prepareStatement(insertLocalRevisionStmtSQL);
+ updateLocalRevisionStmt = connection.prepareStatement(updateLocalRevisionStmtSQL);
+ }
+
+ /**
* Bean getters
*/
public String getDriver() {
@@ -599,7 +967,7 @@
/**
* Get the database type.
- *
+ *
* @return the database type
*/
public String getDatabaseType() {
@@ -610,7 +978,7 @@
* Get the database type.
* @deprecated
* This method is deprecated; {@link #getDatabaseType} should be used instead.
- *
+ *
* @return the database type
*/
public String getSchema() {
@@ -629,6 +997,10 @@
return password;
}
+ public long getReconnectDelayMs() {
+ return reconnectDelayMs;
+ }
+
public boolean getJanitorEnabled() {
return janitorEnabled;
}
@@ -654,7 +1026,7 @@
/**
* Set the database type.
- *
+ *
* @param databaseType the database type
*/
public void setDatabaseType(String databaseType) {
@@ -664,8 +1036,8 @@
/**
* Set the database type.
* @deprecated
- * This method is deprecated; {@link #getDatabaseType} should be used instead.
- *
+ * This method is deprecated; {@link #setDatabaseType} should be used instead.
+ *
* @param databaseType the database type
*/
public void setSchema(String databaseType) {
@@ -684,6 +1056,10 @@
this.password = password;
}
+ public void setReconnectDelayMs(long reconnectDelayMs) {
+ this.reconnectDelayMs = reconnectDelayMs;
+ }
+
public void setJanitorEnabled(boolean enabled) {
this.janitorEnabled = enabled;
}
@@ -703,14 +1079,6 @@
janitorNextRun.set(Calendar.MILLISECOND, 0);
}
- public String getDataSourceName() {
- return dataSourceName;
- }
-
- public void setDataSourceName(String dataSourceName) {
- this.dataSourceName = dataSourceName;
- }
-
/**
* @return whether the schema check is enabled
*/
@@ -738,9 +1106,9 @@
private long localRevision;
/**
- * Indicates whether the init method has been called.
+ * Indicates whether the init method has been called.
*/
- private boolean initialized = false;
+ private boolean initialized;
/**
* Checks whether there's a local revision value in the database for this
@@ -751,18 +1119,29 @@
* @throws JournalException on error
*/
protected synchronized long init(long revision) throws JournalException {
- ResultSet rs = null;
try {
+ // Check whether the connection is available
+ checkConnection();
+
// Check whether there is an entry in the database.
- rs = conHelper.exec(getLocalRevisionStmtSQL, new Object[]{getId()}, false, 0);
+ getLocalRevisionStmt.clearParameters();
+ getLocalRevisionStmt.clearWarnings();
+ getLocalRevisionStmt.setString(1, getId());
+ getLocalRevisionStmt.execute();
+ ResultSet rs = getLocalRevisionStmt.getResultSet();
boolean exists = rs.next();
if (exists) {
revision = rs.getLong(1);
}
+ rs.close();
// Insert the given revision in the database
if (!exists) {
- conHelper.exec(insertLocalRevisionStmtSQL, revision, getId());
+ insertLocalRevisionStmt.clearParameters();
+ insertLocalRevisionStmt.clearWarnings();
+ insertLocalRevisionStmt.setLong(1, revision);
+ insertLocalRevisionStmt.setString(2, getId());
+ insertLocalRevisionStmt.execute();
}
// Set the cached local revision and return
@@ -772,9 +1151,8 @@
} catch (SQLException e) {
log.warn("Failed to initialize local revision.", e);
+ DatabaseJournal.this.close(true);
throw new JournalException("Failed to initialize local revision", e);
- } finally {
- DbUtility.close(rs);
}
}
@@ -799,18 +1177,25 @@
// Update the cached value and the table with local revisions.
try {
- conHelper.exec(updateLocalRevisionStmtSQL, localRevision, getId());
+ // Check whether the connection is available
+ checkConnection();
+ updateLocalRevisionStmt.clearParameters();
+ updateLocalRevisionStmt.clearWarnings();
+ updateLocalRevisionStmt.setLong(1, localRevision);
+ updateLocalRevisionStmt.setString(2, getId());
+ updateLocalRevisionStmt.execute();
this.localRevision = localRevision;
} catch (SQLException e) {
log.warn("Failed to update local revision.", e);
- throw new JournalException("Failed to update local revision.", e);
+ DatabaseJournal.this.close(true);
}
}
-
+
/**
* {@inheritDoc}
*/
- public void close() {
+ public synchronized void close() {
+ // Do nothing: The statements are closed in DatabaseJournal.close()
}
}
@@ -840,30 +1225,40 @@
}
log.info("Interrupted: stopping clean-up task.");
}
-
+
/**
* Cleans old revisions from the clustering table.
*/
protected void cleanUpOldRevisions() {
- ResultSet rs = null;
try {
long minRevision = 0;
- rs = conHelper.exec(selectMinLocalRevisionStmtSQL, null, false, 0);
+
+ // Check whether the connection is available
+ checkConnection();
+
+ // Find the minimal local revision
+ selectMinLocalRevisionStmt.clearParameters();
+ selectMinLocalRevisionStmt.clearWarnings();
+ selectMinLocalRevisionStmt.execute();
+ ResultSet rs = selectMinLocalRevisionStmt.getResultSet();
boolean cleanUp = rs.next();
if (cleanUp) {
minRevision = rs.getLong(1);
}
+ rs.close();
// Clean up if necessary:
if (cleanUp) {
- conHelper.exec(cleanRevisionStmtSQL, minRevision);
+ cleanRevisionStmt.clearParameters();
+ cleanRevisionStmt.clearWarnings();
+ cleanRevisionStmt.setLong(1, minRevision);
+ cleanRevisionStmt.execute();
log.info("Cleaned old revisions up to revision " + minRevision + ".");
}
} catch (Exception e) {
log.warn("Failed to clean up old revisions.", e);
- } finally {
- DbUtility.close(rs);
+ close(true);
}
}
}
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/journal/MSSqlDatabaseJournal.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/journal/MSSqlDatabaseJournal.java (.../sandbox/JCR-1456) (revision 827970)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/journal/MSSqlDatabaseJournal.java (.../trunk) (revision 827970)
@@ -16,7 +16,7 @@
*/
package org.apache.jackrabbit.core.journal;
-import org.apache.jackrabbit.core.util.db.CheckSchemaOperation;
+import org.apache.jackrabbit.util.Text;
/**
* It has the following property in addition to those of the DatabaseJournal:
@@ -39,15 +39,6 @@
}
/**
- * {@inheritDoc}
- */
- @Override
- protected CheckSchemaOperation createCheckSchemaOperation() {
- return super.createCheckSchemaOperation().addVariableReplacement(
- CheckSchemaOperation.TABLE_SPACE_VARIABLE, tableSpace);
- }
-
- /**
* Returns the configured MS SQL table space.
* @return the configured MS SQL table space.
*/
@@ -66,4 +57,13 @@
this.tableSpace = "";
}
}
+
+ /**
+ * {@inheritDoc}
+ */
+ protected String createSchemaSQL(String sql) {
+ return Text.replace(
+ super.createSchemaSQL(sql), "${tableSpace}", tableSpace);
+ }
+
}
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/journal/OracleDatabaseJournal.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/journal/OracleDatabaseJournal.java (.../sandbox/JCR-1456) (revision 827970)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/journal/OracleDatabaseJournal.java (.../trunk) (revision 827970)
@@ -16,11 +16,11 @@
*/
package org.apache.jackrabbit.core.journal;
-import javax.sql.DataSource;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.sql.SQLException;
-import org.apache.jackrabbit.core.util.db.CheckSchemaOperation;
-import org.apache.jackrabbit.core.util.db.ConnectionHelper;
-import org.apache.jackrabbit.core.util.db.OracleConnectionHelper;
+import org.apache.jackrabbit.util.Text;
/**
* It has the following property in addition to those of the DatabaseJournal:
@@ -35,28 +35,9 @@
"${tableSpace}";
/** the Oracle table space to use */
- protected String tableSpace = "";
+ protected String tableSpace;
/**
- * {@inheritDoc}
- */
- @Override
- protected ConnectionHelper createConnectionHelper(DataSource dataSrc) throws Exception {
- OracleConnectionHelper helper = new OracleConnectionHelper(dataSrc, false);
- helper.init();
- return helper;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- protected CheckSchemaOperation createCheckSchemaOperation() {
- return super.createCheckSchemaOperation().addVariableReplacement(
- CheckSchemaOperation.TABLE_SPACE_VARIABLE, tableSpace);
- }
-
- /**
* Returns the configured Oracle table space.
* @return the configured Oracle table space.
*/
@@ -69,10 +50,46 @@
* @param tableSpace the Oracle table space.
*/
public void setTableSpace(String tableSpace) {
- if (tableSpace != null && tableSpace.trim().length() > 0) {
- this.tableSpace = "tablespace " + tableSpace.trim();
+ if (tableSpace != null) {
+ this.tableSpace = tableSpace.trim();
} else {
- this.tableSpace = "";
+ this.tableSpace = null;
}
}
+
+ /**
+ * {@inheritDoc}
+ */
+ protected String createSchemaSQL(String sql) {
+ // replace the schemaObjectPrefix
+ sql = super.createSchemaSQL(sql);
+ // set the tablespace if it is defined
+ String tspace;
+ if (tableSpace == null || "".equals(tableSpace)) {
+ tspace = "";
+ } else {
+ tspace = "tablespace " + tableSpace;
+ }
+ return Text.replace(sql, TABLE_SPACE_VARIABLE, tspace).trim();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ protected boolean tableExists(DatabaseMetaData metaData, String tableName) throws SQLException {
+ if (metaData.storesLowerCaseIdentifiers()) {
+ tableName = tableName.toLowerCase();
+ } else if (metaData.storesUpperCaseIdentifiers()) {
+ tableName = tableName.toUpperCase();
+ }
+
+ String userName = metaData.getUserName();
+ ResultSet rs = metaData.getTables(null, userName, tableName, null);
+
+ try {
+ return rs.next();
+ } finally {
+ rs.close();
+ }
+ }
}
Index: jackrabbit-core/pom.xml
===================================================================
--- jackrabbit-core/pom.xml (.../sandbox/JCR-1456) (revision 827970)
+++ jackrabbit-core/pom.xml (.../trunk) (revision 827970)
@@ -166,11 +166,6 @@