Skip to content

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.java
index 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.java
index 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
@Override
public 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.java
index 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.java
index 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.java
index 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<>();
+
@Inject
public 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);
- }
- }
-
- });
- }
-
@Override
public 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.java
index 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.java
index 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.java
index 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.java
index 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
@Override
public <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
@Override
public <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
@Override
public <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.java
index 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.NotificationPanel
import 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.java
index 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() {
@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();
- }
+ 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.java
new file mode 100644
index 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.properties
index 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=true
hibernate.hikari.transactionIsolation=TRANSACTION_READ_COMMITTED
hibernate.hikari.autoCommit=true
hibernate.hikari.maximumPoolSize=25
-hibernate.hikari.leakDetectionThreshold=1800000
hibernate.show_sql=false
hibernate.format_sql=true