The Unified and Autonomous Development Platform
Hopefully we fixed a deadlock issue
Robin Shen86fa1afdf7bb
diff --git a/core/src/main/java/io/onedev/server/CoreModule.java b/core/src/main/java/io/onedev/server/CoreModule.javaindex 5282c36d62..996889f479 100644--- a/core/src/main/java/io/onedev/server/CoreModule.java+++ b/core/src/main/java/io/onedev/server/CoreModule.java@@ -574,6 +574,7 @@ public class CoreModule extends AbstractPluginModule {public void onDelete(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types)throws CallbackException {}+});bind(XStream.class).toProvider(new com.google.inject.Provider<XStream>() {diff --git a/core/src/main/java/io/onedev/server/ci/job/DefaultJobManager.java b/core/src/main/java/io/onedev/server/ci/job/DefaultJobManager.javaindex a10a1c08b2..36107160f1 100644--- a/core/src/main/java/io/onedev/server/ci/job/DefaultJobManager.java+++ b/core/src/main/java/io/onedev/server/ci/job/DefaultJobManager.java@@ -21,7 +21,6 @@ import java.util.concurrent.locks.Lock;import javax.annotation.Nullable;import javax.inject.Inject;import javax.inject.Singleton;-import javax.transaction.Synchronization;import javax.validation.ValidationException;import org.eclipse.jgit.lib.ObjectId;@@ -142,18 +141,14 @@ public class DefaultJobManager implements JobManager, Runnable, SchedulableTask@Overridepublic Build submit(Project project, ObjectId commitId, String jobName, Map<String, List<String>> paramMap) {Lock lock = LockUtils.getLock("job-schedule: " + project.getId() + "-" + commitId.name());- transactionManager.getTransaction().registerSynchronization(new Synchronization() {-- @Override- public void beforeCompletion() {- }-+ transactionManager.mustRunAfterTransaction(new Runnable() {+@Override- public void afterCompletion(int status) {+ public void run() {lock.unlock();}-- });++ });try {lock.lockInterruptibly();diff --git a/core/src/main/java/io/onedev/server/entitymanager/BuildManager.java b/core/src/main/java/io/onedev/server/entitymanager/BuildManager.javaindex f697a29edc..2ed8e00515 100644--- a/core/src/main/java/io/onedev/server/entitymanager/BuildManager.java+++ b/core/src/main/java/io/onedev/server/entitymanager/BuildManager.java@@ -40,5 +40,5 @@ public interface BuildManager extends EntityManager<Build> {List<Build> query(Project project, User user, EntityQuery<Build> buildQuery, int firstResult, int maxResults);int count(Project project, User user, EntityCriteria<Build> buildCriteria);-+}diff --git a/core/src/main/java/io/onedev/server/notification/PullRequestNotificationManager.java b/core/src/main/java/io/onedev/server/notification/PullRequestNotificationManager.javaindex adfd0ea668..3ed9fa446e 100644--- a/core/src/main/java/io/onedev/server/notification/PullRequestNotificationManager.java+++ b/core/src/main/java/io/onedev/server/notification/PullRequestNotificationManager.java@@ -280,5 +280,5 @@ public class PullRequestNotificationManager implements PersistListener {public void onDelete(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types)throws CallbackException {}-+}diff --git a/core/src/main/java/io/onedev/server/persistence/DefaultTransactionManager.java b/core/src/main/java/io/onedev/server/persistence/DefaultTransactionManager.javaindex 30b8e9973a..8a88632212 100644--- a/core/src/main/java/io/onedev/server/persistence/DefaultTransactionManager.java+++ b/core/src/main/java/io/onedev/server/persistence/DefaultTransactionManager.java@@ -16,7 +16,11 @@package io.onedev.server.persistence;+import java.util.ArrayList;+import java.util.Collection;+import java.util.Map;import java.util.concurrent.Callable;+import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.ExecutorService;import javax.inject.Singleton;@@ -29,6 +33,7 @@ import org.hibernate.Transaction;import org.slf4j.Logger;import org.slf4j.LoggerFactory;+import com.google.common.base.Preconditions;import com.google.inject.Inject;import io.onedev.commons.utils.ExceptionUtils;@@ -43,6 +48,8 @@ public class DefaultTransactionManager implements TransactionManager {private final ExecutorService executorService;+ private final Map<Transaction, Collection<Runnable>> completionRunnables = new ConcurrentHashMap<>();+@Injectpublic DefaultTransactionManager(SessionManager sessionManager, ExecutorService executorService) {this.sessionManager = sessionManager;@@ -70,6 +77,16 @@ public class DefaultTransactionManager implements TransactionManager {tx.rollback();throw ExceptionUtils.unchecked(t);} finally {+ Collection<Runnable> runnables = completionRunnables.remove(tx);+ if (runnables != null) {+ for (Runnable runnable: runnables) {+ try {+ runnable.run();+ } catch (Exception e) {+ logger.error("Error running completion callback", e);+ }+ }+ }session.setFlushMode(prevFlushModeType);}}@@ -91,22 +108,6 @@ public class DefaultTransactionManager implements TransactionManager {});}- @Override- public void runAsync(Runnable runnable) {- executorService.execute(new Runnable() {-- @Override- public void run() {- try {- DefaultTransactionManager.this.run(runnable);- } catch (Exception e) {- logger.error("Error running", e);- }- }-- });- }-@Overridepublic void runAfterCommit(Runnable runnable) {if (getTransaction().isActive()) {@@ -170,5 +171,17 @@ public class DefaultTransactionManager implements TransactionManager {public Session getSession() {return sessionManager.getSession();}++ @Override+ public void mustRunAfterTransaction(Runnable runnable) {+ Transaction transaction = getTransaction();+ Preconditions.checkState(transaction.isActive());+ Collection<Runnable> runnables = completionRunnables.get(transaction);+ if (runnables == null) {+ runnables = new ArrayList<>();+ completionRunnables.put(transaction, runnables);+ }+ runnables.add(runnable);+ }}diff --git a/core/src/main/java/io/onedev/server/persistence/HibernateInterceptor.java b/core/src/main/java/io/onedev/server/persistence/HibernateInterceptor.javaindex fb7de6200d..116b51b2ca 100644--- a/core/src/main/java/io/onedev/server/persistence/HibernateInterceptor.java+++ b/core/src/main/java/io/onedev/server/persistence/HibernateInterceptor.java@@ -64,5 +64,5 @@ public class HibernateInterceptor extends EmptyInterceptor {for (PersistListener listener: listeners)listener.onDelete(entity, id, state, propertyNames, types);}-+}diff --git a/core/src/main/java/io/onedev/server/persistence/PersistListener.java b/core/src/main/java/io/onedev/server/persistence/PersistListener.javaindex 16edf19827..d869d48300 100644--- a/core/src/main/java/io/onedev/server/persistence/PersistListener.java+++ b/core/src/main/java/io/onedev/server/persistence/PersistListener.java@@ -18,5 +18,5 @@ public interface PersistListener {void onDelete(Object entity, Serializable id, Object[] state, String[] propertyNames,Type[] types) throws CallbackException;-+}diff --git a/core/src/main/java/io/onedev/server/persistence/TransactionManager.java b/core/src/main/java/io/onedev/server/persistence/TransactionManager.javaindex 64508e5792..67e35e9074 100644--- a/core/src/main/java/io/onedev/server/persistence/TransactionManager.java+++ b/core/src/main/java/io/onedev/server/persistence/TransactionManager.java@@ -33,8 +33,6 @@ public interface TransactionManager {void run(Runnable runnable);- void runAsync(Runnable runnable);-/*** Do some work after commit if there is an active transaction, or do the work immediately if there is no active* transaction. Note that the work should not involve any other database operations in current thread@@ -45,4 +43,5 @@ public interface TransactionManager {void runAsyncAfterCommit(Runnable runnable);+ void mustRunAfterTransaction(Runnable runnable);}diff --git a/core/src/main/java/io/onedev/server/persistence/dao/DefaultDao.java b/core/src/main/java/io/onedev/server/persistence/dao/DefaultDao.javaindex cb45647db5..2171064e4a 100644--- a/core/src/main/java/io/onedev/server/persistence/dao/DefaultDao.java+++ b/core/src/main/java/io/onedev/server/persistence/dao/DefaultDao.java@@ -77,7 +77,7 @@ public class DefaultDao implements Dao, Serializable {return query(entityCriteria, 0, Integer.MAX_VALUE);}- @Transactional+ @Sessional@Overridepublic <T extends AbstractEntity> T find(EntityCriteria<T> entityCriteria) {Criteria criteria = entityCriteria.getExecutableCriteria(getSession());@@ -86,6 +86,7 @@ public class DefaultDao implements Dao, Serializable {return (T) criteria.uniqueResult();}+ @Sessional@Overridepublic <T extends AbstractEntity> int count(EntityCriteria<T> entityCriteria) {Criteria criteria = entityCriteria.getExecutableCriteria(getSession());@@ -97,7 +98,7 @@ public class DefaultDao implements Dao, Serializable {return new ManagedSerializedForm(Dao.class);}- @Transactional+ @Sessional@Overridepublic <T extends AbstractEntity> List<T> query(Class<T> entityClass) {return query(EntityCriteria.of(entityClass), 0, Integer.MAX_VALUE);diff --git a/core/src/main/java/io/onedev/server/web/component/markdown/InsertUrlPanel.java b/core/src/main/java/io/onedev/server/web/component/markdown/InsertUrlPanel.javaindex 50f37443fd..fd49eb79de 100644--- a/core/src/main/java/io/onedev/server/web/component/markdown/InsertUrlPanel.java+++ b/core/src/main/java/io/onedev/server/web/component/markdown/InsertUrlPanel.java@@ -47,6 +47,7 @@ import de.agilecoders.wicket.core.markup.html.bootstrap.common.NotificationPanelimport io.onedev.commons.utils.PathUtils;import io.onedev.commons.utils.StringUtils;import io.onedev.commons.utils.UrlUtils;+import io.onedev.server.event.RefUpdated;import io.onedev.server.git.BlobIdent;import io.onedev.server.git.BlobIdentFilter;import io.onedev.server.model.Project;@@ -442,7 +443,8 @@ abstract class InsertUrlPanel extends Panel {try {String directory = WebSession.get().getMetaData(UPLOAD_DIRECTORY);- context.uploadFiles(uploads, directory, commitMessage);+ RefUpdated refUpdated = context.uploadFiles(uploads, directory, commitMessage);+ context.onCommitted(target, refUpdated);String fileName = uploads.iterator().next().getClientFileName();String url;if (directory != null) {diff --git a/core/src/main/java/io/onedev/server/web/page/project/blob/ProjectBlobPage.java b/core/src/main/java/io/onedev/server/web/page/project/blob/ProjectBlobPage.javaindex c466b7205c..88d2dc80ef 100644--- a/core/src/main/java/io/onedev/server/web/page/project/blob/ProjectBlobPage.java+++ b/core/src/main/java/io/onedev/server/web/page/project/blob/ProjectBlobPage.java@@ -71,6 +71,7 @@ import io.onedev.server.model.Project;import io.onedev.server.model.PullRequest;import io.onedev.server.model.User;import io.onedev.server.persistence.SessionManager;+import io.onedev.server.persistence.TransactionManager;import io.onedev.server.search.code.CommitIndexed;import io.onedev.server.search.code.IndexManager;import io.onedev.server.search.code.SearchManager;@@ -1026,19 +1027,26 @@ public class ProjectBlobPage extends ProjectPage implements BlobRenderContext {String refName = refUpdated.getRefName();ObjectId oldCommitId = refUpdated.getOldCommitId();ObjectId newCommitId = refUpdated.getNewCommitId();- OneDev.getInstance(SessionManager.class).runAsync(new Runnable() {+ OneDev.getInstance(TransactionManager.class).runAsyncAfterCommit(new Runnable() {@Overridepublic void run() {- ThreadContext.bind(subject);- try {- Project project = OneDev.getInstance(ProjectManager.class).load(projectId);- project.cacheObjectId(branch, refUpdated.getNewCommitId());- RefUpdated refUpdated = new RefUpdated(project, refName, oldCommitId, newCommitId);- OneDev.getInstance(ListenerRegistry.class).post(refUpdated);- } finally {- ThreadContext.unbindSubject();- }+ OneDev.getInstance(SessionManager.class).run(new Runnable() {++ @Override+ public void run() {+ ThreadContext.bind(subject);+ try {+ Project project = OneDev.getInstance(ProjectManager.class).load(projectId);+ project.cacheObjectId(branch, refUpdated.getNewCommitId());+ RefUpdated refUpdated = new RefUpdated(project, refName, oldCommitId, newCommitId);+ OneDev.getInstance(ListenerRegistry.class).post(refUpdated);+ } finally {+ ThreadContext.unbindSubject();+ }+ }++ });}});diff --git a/core/src/main/java/org/hibernate/resource/jdbc/internal/LogicalConnectionManagedImpl.java b/core/src/main/java/org/hibernate/resource/jdbc/internal/LogicalConnectionManagedImpl.javanew file mode 100644index 0000000000..5fc4a641f7--- /dev/null+++ b/core/src/main/java/org/hibernate/resource/jdbc/internal/LogicalConnectionManagedImpl.java@@ -0,0 +1,288 @@+/*+ * Hibernate, Relational Persistence for Idiomatic Java+ *+ * License: GNU Lesser General Public License (LGPL), version 2.1 or later.+ * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.+ */+package org.hibernate.resource.jdbc.internal;++import java.io.IOException;+import java.io.ObjectInputStream;+import java.io.ObjectOutputStream;+import java.sql.Connection;+import java.sql.SQLException;++import org.hibernate.ConnectionAcquisitionMode;+import org.hibernate.ConnectionReleaseMode;+import org.hibernate.ResourceClosedException;+import org.hibernate.engine.jdbc.connections.spi.JdbcConnectionAccess;+import org.hibernate.engine.jdbc.spi.JdbcServices;+import org.hibernate.engine.jdbc.spi.SqlExceptionHelper;+import org.hibernate.resource.jdbc.ResourceRegistry;+import org.hibernate.resource.jdbc.spi.JdbcObserver;+import org.hibernate.resource.jdbc.spi.JdbcSessionContext;+import org.hibernate.resource.jdbc.spi.LogicalConnectionImplementor;+import org.hibernate.resource.jdbc.spi.PhysicalConnectionHandlingMode;++import org.jboss.logging.Logger;++/**+ * Represents a LogicalConnection where we manage obtaining and releasing the Connection as needed.+ *+ * @author Steve Ebersole+ */+public class LogicalConnectionManagedImpl extends AbstractLogicalConnectionImplementor {+ private static final Logger log = Logger.getLogger( LogicalConnectionManagedImpl.class );++ private final transient JdbcConnectionAccess jdbcConnectionAccess;+ private final transient JdbcObserver observer;+ private final transient SqlExceptionHelper sqlExceptionHelper;++ private final transient PhysicalConnectionHandlingMode connectionHandlingMode;++ private transient Connection physicalConnection;+ private boolean closed;++ private boolean providerDisablesAutoCommit;++ public LogicalConnectionManagedImpl(+ JdbcConnectionAccess jdbcConnectionAccess,+ JdbcSessionContext jdbcSessionContext) {+ this( jdbcConnectionAccess, jdbcSessionContext, new ResourceRegistryStandardImpl() );+ }++ public LogicalConnectionManagedImpl(+ JdbcConnectionAccess jdbcConnectionAccess,+ JdbcSessionContext jdbcSessionContext,+ ResourceRegistry resourceRegistry) {+ this.jdbcConnectionAccess = jdbcConnectionAccess;+ this.observer = jdbcSessionContext.getObserver();+ this.resourceRegistry = resourceRegistry;++ this.connectionHandlingMode = determineConnectionHandlingMode(+ jdbcSessionContext.getPhysicalConnectionHandlingMode(),+ jdbcConnectionAccess++ );++ this.sqlExceptionHelper = jdbcSessionContext.getServiceRegistry()+ .getService( JdbcServices.class )+ .getSqlExceptionHelper();++ if ( connectionHandlingMode.getAcquisitionMode() == ConnectionAcquisitionMode.IMMEDIATELY ) {+ acquireConnectionIfNeeded();+ }++ this.providerDisablesAutoCommit = jdbcSessionContext.doesConnectionProviderDisableAutoCommit();+ if ( providerDisablesAutoCommit ) {+ log.debug(+ "`hibernate.connection.provider_disables_autocommit` was enabled. This setting should only be " ++ "enabled when you are certain that the Connections given to Hibernate by the " ++ "ConnectionProvider have auto-commit disabled. Enabling this setting when the " ++ "Connections do not have auto-commit disabled will lead to Hibernate executing " ++ "SQL operations outside of any JDBC/SQL transaction."+ );+ }+ }++ private PhysicalConnectionHandlingMode determineConnectionHandlingMode(+ PhysicalConnectionHandlingMode connectionHandlingMode,+ JdbcConnectionAccess jdbcConnectionAccess) {+ if ( connectionHandlingMode.getReleaseMode() == ConnectionReleaseMode.AFTER_STATEMENT+ && !jdbcConnectionAccess.supportsAggressiveRelease() ) {+ return PhysicalConnectionHandlingMode.DELAYED_ACQUISITION_AND_RELEASE_AFTER_TRANSACTION;+ }++ return connectionHandlingMode;+ }++ private LogicalConnectionManagedImpl(+ JdbcConnectionAccess jdbcConnectionAccess,+ JdbcSessionContext jdbcSessionContext,+ boolean closed) {+ this( jdbcConnectionAccess, jdbcSessionContext, new ResourceRegistryStandardImpl() );+ this.closed = closed;+ }++ private Connection acquireConnectionIfNeeded() {+ if ( physicalConnection == null ) {+ // todo : is this the right place for these observer calls?+ observer.jdbcConnectionAcquisitionStart();+ try {+ physicalConnection = jdbcConnectionAccess.obtainConnection();+ }+ catch (SQLException e) {+ throw sqlExceptionHelper.convert( e, "Unable to acquire JDBC Connection" );+ }+ finally {+ observer.jdbcConnectionAcquisitionEnd( physicalConnection );+ }+ }+ return physicalConnection;+ }++ @Override+ public boolean isOpen() {+ return !closed;+ }++ @Override+ public PhysicalConnectionHandlingMode getConnectionHandlingMode() {+ return connectionHandlingMode;+ }++ @Override+ public boolean isPhysicallyConnected() {+ return physicalConnection != null;+ }++ @Override+ public Connection getPhysicalConnection() {+ errorIfClosed();+ return acquireConnectionIfNeeded();+ }++ @Override+ public void afterStatement() {+ super.afterStatement();++ if ( connectionHandlingMode.getReleaseMode() == ConnectionReleaseMode.AFTER_STATEMENT ) {+ if ( getResourceRegistry().hasRegisteredResources() ) {+ log.debug( "Skipping aggressive release of JDBC Connection afterQuery-statement due to held resources" );+ }+ else {+ log.debug( "Initiating JDBC connection release from afterStatement" );+ releaseConnection();+ }+ }+ }++ @Override+ public void afterTransaction() {+ super.afterTransaction();++ if ( connectionHandlingMode.getReleaseMode() != ConnectionReleaseMode.ON_CLOSE ) {+ // NOTE : we check for !ON_CLOSE here (rather than AFTER_TRANSACTION) to also catch AFTER_STATEMENT cases+ // that were circumvented due to held resources+ log.debug( "Initiating JDBC connection release from afterTransaction" );+ releaseConnection();+ }+ }++ @Override+ public Connection manualDisconnect() {+ if ( closed ) {+ throw new ResourceClosedException( "Logical connection is closed" );+ }+ final Connection c = physicalConnection;+ releaseConnection();+ return c;+ }++ @Override+ public void manualReconnect(Connection suppliedConnection) {+ if ( closed ) {+ throw new ResourceClosedException( "Logical connection is closed" );+ }++ throw new IllegalStateException( "Cannot manually reconnect unless Connection was originally supplied by user" );+ }++ private void releaseConnection() {+ if ( physicalConnection == null ) {+ return;+ }++ // todo : is this the right place for these observer calls?+ observer.jdbcConnectionReleaseStart();+ try {+ if ( !physicalConnection.isClosed() ) {+ sqlExceptionHelper.logAndClearWarnings( physicalConnection );+ }+ jdbcConnectionAccess.releaseConnection( physicalConnection );+ }+ catch (SQLException e) {+ throw sqlExceptionHelper.convert( e, "Unable to release JDBC Connection" );+ }+ finally {+ observer.jdbcConnectionReleaseEnd();+ physicalConnection = null;+ getResourceRegistry().releaseResources();+ }+ }++ @Override+ public LogicalConnectionImplementor makeShareableCopy() {+ errorIfClosed();++ // todo : implement+ return null;+ }++ @Override+ public void serialize(ObjectOutputStream oos) throws IOException {+ oos.writeBoolean( closed );+ }++ public static LogicalConnectionManagedImpl deserialize(+ ObjectInputStream ois,+ JdbcConnectionAccess jdbcConnectionAccess,+ JdbcSessionContext jdbcSessionContext) throws IOException, ClassNotFoundException {+ final boolean isClosed = ois.readBoolean();+ return new LogicalConnectionManagedImpl( jdbcConnectionAccess, jdbcSessionContext, isClosed );+ }++ @Override+ public Connection close() {+ if ( closed ) {+ return null;+ }++ getResourceRegistry().releaseResources();++ log.trace( "Closing logical connection" );+ try {+ releaseConnection();+ }+ finally {+ // no matter what+ closed = true;+ log.trace( "Logical connection closed" );+ }+ return null;+ }+++ // PhysicalJdbcTransaction impl ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++ @Override+ protected Connection getConnectionForTransactionManagement() {+ return getPhysicalConnection();+ }++ boolean initiallyAutoCommit;++ @Override+ public void begin() {+ initiallyAutoCommit = !doConnectionsFromProviderHaveAutoCommitDisabled() && determineInitialAutoCommitMode(+ getConnectionForTransactionManagement() );+ super.begin();+ }++ @Override+ protected void afterCompletion() {+ /*+ * Modified by robin to reset connection before releasing connection+ * as otherwise connection will be acquired again when doing reset,+ * and it may cause deadlock when combined with locking in DefaultJobManager.submit()+ */+ resetConnection( initiallyAutoCommit );+ initiallyAutoCommit = false;+ afterTransaction();+ }++ @Override+ protected boolean doConnectionsFromProviderHaveAutoCommitDisabled() {+ return providerDisablesAutoCommit;+ }+}diff --git a/product/system/conf/hibernate.properties b/product/system/conf/hibernate.propertiesindex 4dbf307a84..3d6bf9bb4f 100644--- a/product/system/conf/hibernate.properties+++ b/product/system/conf/hibernate.properties@@ -105,12 +105,10 @@ hibernate.connection.password=hibernate.connection.provider_class=org.hibernate.hikaricp.internal.HikariCPConnectionProvider-hibernate.connection.autocommit=truehibernate.hikari.transactionIsolation=TRANSACTION_READ_COMMITTEDhibernate.hikari.autoCommit=truehibernate.hikari.maximumPoolSize=25-hibernate.hikari.leakDetectionThreshold=1800000hibernate.show_sql=falsehibernate.format_sql=true