From 1937b9f427519cba2be183662edacf917d444b94 Mon Sep 17 00:00:00 2001 From: Peter Zaoral Date: Thu, 29 Oct 2026 21:37:53 +0100 Subject: [PATCH] [Quarkus 4] Remove the async-commit rollback workaround fixed in Hibernate Closes: #55199 Signed-off-by: Peter Zaoral --- model/jpa/pom.xml | 11 ++ .../jpa/AsyncCommitIntegrator.java | 18 -- .../jpa/AsyncCommitIntegratorTest.java | 175 ++++++++++++++++++ 3 files changed, 186 insertions(+), 18 deletions(-) create mode 100644 model/jpa/src/test/java/org/keycloak/connections/jpa/AsyncCommitIntegratorTest.java diff --git a/model/jpa/pom.xml b/model/jpa/pom.xml index 2103563d168e..8bb863e45661 100755 --- a/model/jpa/pom.xml +++ b/model/jpa/pom.xml @@ -104,6 +104,17 @@ junit test + + + org.hibernate.accessor + hibernate-accessor-bytebuddy + test + + + org.jboss.narayana.jta + narayana-jta + test + org.hamcrest hamcrest diff --git a/model/jpa/src/main/java/org/keycloak/connections/jpa/AsyncCommitIntegrator.java b/model/jpa/src/main/java/org/keycloak/connections/jpa/AsyncCommitIntegrator.java index 933aff89dd0c..653cc5083761 100644 --- a/model/jpa/src/main/java/org/keycloak/connections/jpa/AsyncCommitIntegrator.java +++ b/model/jpa/src/main/java/org/keycloak/connections/jpa/AsyncCommitIntegrator.java @@ -29,8 +29,6 @@ import org.hibernate.dialect.OracleDialect; import org.hibernate.dialect.PostgreSQLDialect; import org.hibernate.dialect.SQLServerDialect; -import org.hibernate.engine.internal.TransactionCompletionCallbacksImpl; -import org.hibernate.engine.spi.ActionQueue; import org.hibernate.engine.spi.SessionFactoryImplementor; import org.hibernate.engine.spi.SharedSessionContractImplementor; import org.hibernate.event.spi.EventType; @@ -40,7 +38,6 @@ import org.hibernate.event.spi.PreInsertEventListener; import org.hibernate.event.spi.PreUpdateEvent; import org.hibernate.event.spi.PreUpdateEventListener; -import org.hibernate.internal.SessionImpl; import org.jboss.logging.Logger; /** @@ -173,21 +170,6 @@ private void handleEntity(Object entity, SharedSessionContractImplementor sessio } } ); - // Workaround for https://hibernate.atlassian.net/browse/HHH-20863: - // On rollback, beforeTransactionCompletion() is never called, so the BeforeCompletionCallback - // above remains in the ActionQueue and triggers HHH90010101 during em.close(). - // Clear it on rollback via an AfterCompletionCallback. - session.getTransactionCompletionCallbacks().registerCallback( - (boolean success, SharedSessionContractImplementor sess) -> { - if (!success && sess instanceof SessionImpl si) { - ActionQueue aq = si.getActionQueue(); - if (aq.hasBeforeTransactionActions()) { - aq.setTransactionCompletionCallbacks( - new TransactionCompletionCallbacksImpl(si), false); - } - } - } - ); } if (entity instanceof AsynchronousCommitAllowed asyncEntity) { diff --git a/model/jpa/src/test/java/org/keycloak/connections/jpa/AsyncCommitIntegratorTest.java b/model/jpa/src/test/java/org/keycloak/connections/jpa/AsyncCommitIntegratorTest.java new file mode 100644 index 000000000000..69e42b4944e8 --- /dev/null +++ b/model/jpa/src/test/java/org/keycloak/connections/jpa/AsyncCommitIntegratorTest.java @@ -0,0 +1,175 @@ +package org.keycloak.connections.jpa; + +import java.sql.Connection; +import java.util.Arrays; +import java.util.Collection; +import java.util.UUID; +import java.util.concurrent.atomic.AtomicInteger; + +import jakarta.persistence.Entity; +import jakarta.persistence.Id; + +import com.arjuna.ats.jta.TransactionManager; +import org.hibernate.Session; +import org.hibernate.SessionFactory; +import org.hibernate.boot.MetadataSources; +import org.hibernate.boot.registry.StandardServiceRegistry; +import org.hibernate.boot.registry.StandardServiceRegistryBuilder; +import org.hibernate.engine.spi.SessionFactoryImplementor; +import org.hibernate.event.spi.EventSource; +import org.hibernate.event.spi.EventType; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; + +@RunWith(Parameterized.class) +public class AsyncCommitIntegratorTest { + + @Parameterized.Parameters(name = "queue={0}, transactions={1}") + public static Collection queues() { + return Arrays.asList(new Object[][] { + { "graph", "jdbc" }, { "legacy", "jdbc" }, { "graph", "jta" }, { "legacy", "jta" } + }); + } + + @Parameterized.Parameter + public String queue; + + @Parameterized.Parameter(1) + public String transactions; + + private final AtomicInteger asyncCommits = new AtomicInteger(); + private StandardServiceRegistry registry; + private SessionFactory sessionFactory; + + @Before + public void createSessionFactory() { + registry = new StandardServiceRegistryBuilder() + .applySetting("hibernate.connection.driver_class", "org.h2.Driver") + .applySetting("hibernate.connection.url", "jdbc:h2:mem:" + UUID.randomUUID()) + .applySetting("hibernate.hbm2ddl.auto", "create-drop") + .applySetting("hibernate.flush.queue.type", queue) + .applySetting("hibernate.transaction.coordinator_class", transactions) + .applySetting("hibernate.transaction.jta.platform", transactions.equals("jta") + ? "org.hibernate.engine.transaction.jta.platform.internal.NarayanaJtaPlatform" + : "org.hibernate.engine.transaction.jta.platform.internal.NoJtaPlatform") + .build(); + sessionFactory = new MetadataSources(registry) + .addAnnotatedClass(AsyncEntity.class) + .addAnnotatedClass(SyncEntity.class) + .buildMetadata().buildSessionFactory(); + AsyncCommitIntegrator integrator = new AsyncCommitIntegrator() { + @Override + protected boolean isEnabled(SessionFactoryImplementor sf) { + return true; + } + + @Override + protected void applyAsyncCommit(Connection connection) { + asyncCommits.incrementAndGet(); + } + }; + sessionFactory.unwrap(SessionFactoryImplementor.class).getEventEngine().getListenerRegistry() + .appendListeners(EventType.PRE_INSERT, integrator); + } + + @After + public void closeSessionFactory() throws Exception { + try { + if (transactions.equals("jta")) { + var transactionManager = TransactionManager.transactionManager(); + if (transactionManager.getTransaction() != null) { + transactionManager.rollback(); + } + } + } finally { + if (sessionFactory != null) { + sessionFactory.close(); + } + if (registry != null) { + StandardServiceRegistryBuilder.destroy(registry); + } + } + } + + @Test + public void commitRunsCallbackOnce() { + try (Session session = sessionFactory.openSession()) { + session.beginTransaction(); + session.persist(new AsyncEntity(1)); + session.flush(); + session.persist(new AsyncEntity(2)); + session.getTransaction().commit(); + } + assertEquals(1, asyncCommits.get()); + } + + @Test + public void rollbackDoesNotRunCallback() { + try (Session session = sessionFactory.openSession()) { + session.beginTransaction(); + session.persist(new AsyncEntity(1)); + session.flush(); + session.getTransaction().rollback(); + assertFalse("Rollback must clear before-completion callbacks", + session.unwrap(EventSource.class).getActionQueue().hasBeforeTransactionActions()); + assertEquals(0, asyncCommits.get()); + } + assertEquals(0, asyncCommits.get()); + + try (Session session = sessionFactory.openSession()) { + session.beginTransaction(); + session.persist(new AsyncEntity(2)); + session.getTransaction().commit(); + } + assertEquals(1, asyncCommits.get()); + } + + @Test + public void mixedChangesRequireSynchronousCommit() { + try (Session session = sessionFactory.openSession()) { + session.beginTransaction(); + session.persist(new AsyncEntity(1)); + session.flush(); + session.persist(new SyncEntity(2)); + session.getTransaction().commit(); + } + assertEquals(0, asyncCommits.get()); + } + + @Entity(name = "AsyncCommitTestAsyncEntity") + public static class AsyncEntity implements AsynchronousCommitAllowed { + @Id + private int id; + + public AsyncEntity() { + } + + public AsyncEntity(int id) { + this.id = id; + } + + @Override + public boolean isAsyncCommitAllowed(EntityOperationType operationType) { + return true; + } + } + + @Entity(name = "AsyncCommitTestSyncEntity") + public static class SyncEntity { + @Id + private int id; + + public SyncEntity() { + } + + public SyncEntity(int id) { + this.id = id; + } + } +}