CBSNexora/cbsnexora-backend
4
0
Fork 0
Code Issues Pull Requests Actions 46 Packages Projects Releases Wiki Activity

FINERACT-2081: Support read-only transactions via Batch API

Browse Source
This commit is contained in:
Adam Saghy
2024-12-17 14:49:18 +01:00
parent 8716751c88
commit d03973165d
5 changed files with 125 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files
fineract-provider/src/main/java/org/apache/fineract/infrastructure/core/persistence/DatabaseSelectingPersistenceUnitPostProcessor.java
-49
View File
@@ -1,49 +0,0 @@
/**
* 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.fineract.infrastructure.core.persistence;
import java.util.Map;
import org.apache.fineract.infrastructure.core.service.database.DatabaseType;
import org.apache.fineract.infrastructure.core.service.database.DatabaseTypeResolver;
import org.eclipse.persistence.config.PersistenceUnitProperties;
import org.eclipse.persistence.config.TargetDatabase;
import org.springframework.orm.jpa.persistenceunit.MutablePersistenceUnitInfo;
import org.springframework.orm.jpa.persistenceunit.PersistenceUnitPostProcessor;
public class DatabaseSelectingPersistenceUnitPostProcessor implements PersistenceUnitPostProcessor {
private static final Map<DatabaseType, String> TARGET_DATABASE_MAP = Map.of(DatabaseType.MYSQL, TargetDatabase.MySQL,
DatabaseType.POSTGRESQL, TargetDatabase.PostgreSQL);
private final DatabaseTypeResolver databaseTypeResolver;
public DatabaseSelectingPersistenceUnitPostProcessor(DatabaseTypeResolver databaseTypeResolver) {
this.databaseTypeResolver = databaseTypeResolver;
}
@Override
public void postProcessPersistenceUnitInfo(MutablePersistenceUnitInfo pui) {
DatabaseType databaseType = databaseTypeResolver.databaseType();
String targetDatabase = TARGET_DATABASE_MAP.get(databaseType);
if (targetDatabase == null) {
throw new IllegalStateException("Unsupported database: " + databaseType);
}
pui.addProperty(PersistenceUnitProperties.TARGET_DATABASE, targetDatabase);
}
}
fineract-provider/src/main/java/org/apache/fineract/infrastructure/core/persistence/ExtendedJpaTransactionManager.java
-101
View File
@@ -1,101 +0,0 @@
/**
* 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.fineract.infrastructure.core.persistence;
import jakarta.persistence.EntityManager;
import jakarta.persistence.FlushModeType;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.function.Consumer;
import org.springframework.jdbc.datasource.JdbcTransactionObjectSupport;
import org.springframework.orm.jpa.EntityManagerHolder;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.support.DefaultTransactionStatus;
import org.springframework.transaction.support.TransactionSynchronizationManager;
public class ExtendedJpaTransactionManager extends JpaTransactionManager {
private final List<TransactionLifecycleCallback> lifecycleCallbacks = new CopyOnWriteArrayList<>();
public ExtendedJpaTransactionManager() {
setValidateExistingTransaction(true);
}
@Override
protected void doBegin(Object transaction, TransactionDefinition definition) {
super.doBegin(transaction, definition);
if (isReadOnlyConnection() || isReadOnlyTx(transaction)) {
EntityManager entityManager = getCurrentEntityManager();
if (entityManager != null) {
entityManager.setFlushMode(FlushModeType.COMMIT);
}
}
invokeLifecycleCallbacks(TransactionLifecycleCallback::afterBegin);
}
@Override
protected void doCommit(DefaultTransactionStatus status) {
if (isReadOnlyConnection() || isReadOnlyTx(status.getTransaction())) {
EntityManager entityManager = getCurrentEntityManager();
if (entityManager != null) {
entityManager.clear();
}
}
super.doCommit(status);
invokeLifecycleCallbacks(TransactionLifecycleCallback::afterCommit);
}
private boolean isReadOnlyConnection() {
try (Connection connection = getDataSource().getConnection()) {
return connection.isReadOnly();
} catch (SQLException e) {
throw new IllegalStateException(e);
}
}
@Override
protected void doCleanupAfterCompletion(Object transaction) {
super.doCleanupAfterCompletion(transaction);
invokeLifecycleCallbacks(TransactionLifecycleCallback::afterCompletion);
}
private boolean isReadOnlyTx(Object transaction) {
JdbcTransactionObjectSupport txObject = (JdbcTransactionObjectSupport) transaction;
return txObject.isReadOnly();
}
private EntityManager getCurrentEntityManager() {
EntityManagerHolder holder = (EntityManagerHolder) TransactionSynchronizationManager.getResource(obtainEntityManagerFactory());
if (holder != null) {
return holder.getEntityManager();
}
return null;
}
private void invokeLifecycleCallbacks(Consumer<TransactionLifecycleCallback> f) {
lifecycleCallbacks.forEach(f::accept);
}
public void setLifecycleCallbacks(List<TransactionLifecycleCallback> lifecycleCallbacks) {
this.lifecycleCallbacks.addAll(lifecycleCallbacks);
}
}
fineract-provider/src/main/java/org/apache/fineract/infrastructure/core/persistence/TransactionLifecycleCallback.java
-28
View File
@@ -1,28 +0,0 @@
/**
* 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.fineract.infrastructure.core.persistence;
public interface TransactionLifecycleCallback {
default void afterBegin() {}
default void afterCommit() {}
default void afterCompletion() {}
}