Merge branch 'RED-10526' into 'main'

RED-10526: Set liquibase to 4.29.2 as 4.30.0 is 3 times slower

See merge request fforesight/mongo-database-commons!20

.gitignore

@@ -40,3 +40,4 @@ gradle/
 
 **/.gradle
 **/build
+.DS_Store

.gitlab-ci.yml

@@ -18,4 +18,5 @@ deploy:
   rules:
     - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
     - if: $CI_COMMIT_BRANCH =~ /^release/
+    - if: $CI_COMMIT_BRANCH =~ /^feature/
     - if: $CI_COMMIT_TAG

build.gradle.kts

@@ -1,7 +1,6 @@
 plugins {
     `java-library`
     `maven-publish`
-    `kotlin-dsl`
     pmd
     checkstyle
     jacoco
@@ -25,10 +24,11 @@ repositories {
 val springBootVersion = "3.1.5"
 
 dependencies {
-    api("com.knecon.fforesight:tenant-commons:0.23.0")
-    api("org.liquibase:liquibase-core:4.20.0")
-    api("org.liquibase.ext:liquibase-mongodb:4.20.0")
+    api("com.knecon.fforesight:tenant-commons:0.31.0")
+    api("org.liquibase:liquibase-core:4.29.2")
+    api("org.liquibase.ext:liquibase-mongodb:4.29.2")
     api("org.springframework.boot:spring-boot-starter-data-mongodb:${springBootVersion}")
+    api("org.springframework.boot:spring-boot-starter-validation:${springBootVersion}")
     api("org.springframework.boot:spring-boot-configuration-processor:${springBootVersion}")
     api("org.projectlombok:lombok:1.18.28")
     runtimeOnly("org.springframework.boot:spring-boot-devtools:${springBootVersion}")
@@ -83,7 +83,7 @@ tasks.named<Test>("test") {
 
 sonarqube {
     properties {
-        property("sonar.login", providers.gradleProperty("sonarToken").getOrNull())
+        providers.gradleProperty("sonarToken").getOrNull()?.let { property("sonar.login", it) }
         property("sonar.host.url", "https://sonarqube.knecon.com")
     }
 }
@@ -103,4 +103,4 @@ tasks.jacocoTestReport {
 
 java {
     withJavadocJar()
-}
+}

src/main/java/com/knecon/fforesight/mongo/database/commons/MongoTenantMessagingConfiguration.java

@@ -1,59 +0,0 @@
-package com.knecon.fforesight.mongo.database.commons;
-
-import org.springframework.amqp.core.Binding;
-import org.springframework.amqp.core.BindingBuilder;
-import org.springframework.amqp.core.Queue;
-import org.springframework.amqp.core.QueueBuilder;
-import org.springframework.amqp.core.TopicExchange;
-import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Conditional;
-import org.springframework.context.annotation.Configuration;
-
-import com.knecon.fforesight.mongo.database.commons.liquibase.EnableMongoLiquibaseCondition;
-
-import lombok.RequiredArgsConstructor;
-
-@Configuration
-@RequiredArgsConstructor
-@Conditional(EnableMongoLiquibaseCondition.class)
-public class MongoTenantMessagingConfiguration {
-
-    @Value("${fforesight.mongo.multitenancy.tenant-created-queue:mongo-tenant-created}")
-    private String mongoTenantCreatedEventQueue;
-
-    @Value("${fforesight.mongo.multitenancy.tenant-created-dlq:mongo-tenant-created-dlq}")
-    private String mongoTenantCreatedDLQ;
-
-
-    @Bean(name = "mongoTenantExchange")
-    TopicExchange mongoTenantExchange(@Value("${fforesight.tenant-exchange.name}") String tenantExchangeName) {
-
-        return new TopicExchange(tenantExchangeName);
-    }
-
-
-    @Bean("persistenceServiceMongoTenantCreatedQueue")
-    public Queue persistenceServiceMongoTenantCreatedQueue() {
-
-        return QueueBuilder.durable(mongoTenantCreatedEventQueue)
-                .withArgument("x-dead-letter-exchange", "").withArgument("x-dead-letter-routing-key", mongoTenantCreatedDLQ).build();
-    }
-
-
-    @Bean("persistenceServiceMongoTenantDLQ")
-    public Queue persistenceServiceMongoTenantDLQ() {
-
-        return QueueBuilder.durable(mongoTenantCreatedDLQ).build();
-    }
-
-
-    @Bean("mongoTenantExchangeBinding")
-    public Binding mongoTenantExchangeBinding(@Qualifier("persistenceServiceMongoTenantCreatedQueue") Queue persistenceServiceTenantCreatedQueue,
-                                              @Qualifier("mongoTenantExchange") TopicExchange tenantExchange) {
-
-        return BindingBuilder.bind(persistenceServiceTenantCreatedQueue).to(tenantExchange).with("tenant.created");
-    }
-
-}

src/main/java/com/knecon/fforesight/mongo/database/commons/config/MultiTenantMongoDBFactory.java

@@ -1,15 +1,20 @@
 package com.knecon.fforesight.mongo.database.commons.config;
 
 import java.util.List;
+import java.util.concurrent.TimeUnit;
 
+import jakarta.validation.constraints.NotNull;
 import org.bson.Document;
+import org.bson.codecs.configuration.CodecRegistry;
 import org.bson.conversions.Bson;
-import org.jetbrains.annotations.NotNull;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.data.mongodb.core.SimpleMongoClientDatabaseFactory;
 
 import com.knecon.fforesight.mongo.database.commons.service.MongoDataSources;
 import com.mongodb.ClientSessionOptions;
+import com.mongodb.ReadConcern;
+import com.mongodb.ReadPreference;
+import com.mongodb.WriteConcern;
 import com.mongodb.client.ChangeStreamIterable;
 import com.mongodb.client.ClientSession;
 import com.mongodb.client.ListDatabasesIterable;
@@ -40,6 +45,7 @@ public class MultiTenantMongoDBFactory extends SimpleMongoClientDatabaseFactory
 
     private static MongoClient getBootstrapMongoClient() {
         return new MongoClient() {
+            
             @Override
             public MongoDatabase getDatabase(String s) {
 

src/main/java/com/knecon/fforesight/mongo/database/commons/liquibase/EnableMongoLiquibaseCondition.java

@@ -2,11 +2,12 @@ package com.knecon.fforesight.mongo.database.commons.liquibase;
 
 import java.util.Objects;
 
-import org.jetbrains.annotations.NotNull;
 import org.springframework.context.annotation.Condition;
 import org.springframework.context.annotation.ConditionContext;
 import org.springframework.core.type.AnnotatedTypeMetadata;
 
+import jakarta.validation.constraints.NotNull;
+
 public class EnableMongoLiquibaseCondition implements Condition {
 
     @Override

src/main/java/com/knecon/fforesight/mongo/database/commons/liquibase/MongoLiquibaseConfig.java

@@ -23,7 +23,7 @@ public class MongoLiquibaseConfig {
 
 
     @Bean
-    public TenantMongoLiquibaseExecutor tenantLiquibase(EncryptionDecryptionService encryptionService,
+    public TenantMongoLiquibaseExecutor tenantMongoLiquibaseExecutor(EncryptionDecryptionService encryptionService,
                                                         TenantProvider tenantProvider,
                                                         @Qualifier("tenantMongoLiquibaseProperties") LiquibaseProperties mongoLiquibaseProperties) {
 

src/main/java/com/knecon/fforesight/mongo/database/commons/liquibase/MongoSpringLiquibase.java

@@ -0,0 +1,104 @@
+package com.knecon.fforesight.mongo.database.commons.liquibase;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.nio.file.Files;
+import java.util.Map;
+
+import liquibase.Contexts;
+import liquibase.GlobalConfiguration;
+import liquibase.LabelExpression;
+import liquibase.Liquibase;
+import liquibase.Scope;
+import liquibase.configuration.ConfiguredValue;
+import liquibase.database.Database;
+import liquibase.exception.LiquibaseException;
+import liquibase.integration.commandline.LiquibaseCommandLineConfiguration;
+import liquibase.integration.spring.SpringLiquibase;
+import liquibase.integration.spring.SpringResourceAccessor;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.SneakyThrows;
+
+@Getter
+@Setter
+public class MongoSpringLiquibase extends SpringLiquibase {
+
+    protected Database database;
+
+
+    public MongoSpringLiquibase() {
+
+        super();
+    }
+
+
+    /**
+     * Executed automatically when the bean is initialized.
+     */
+    @Override
+    public void afterPropertiesSet() throws LiquibaseException {
+
+        final ConfiguredValue<Boolean> shouldRunProperty = LiquibaseCommandLineConfiguration.SHOULD_RUN.getCurrentConfiguredValue();
+
+        if (!(Boolean) shouldRunProperty.getValue()) {
+            Scope.getCurrentScope().getLog(getClass()).info("Liquibase did not run because " + shouldRunProperty.getProvidedValue().describe() + " was set to false");
+            return;
+        }
+        if (!shouldRun) {
+            Scope.getCurrentScope()
+                    .getLog(getClass())
+                    .info("Liquibase did not run because 'shouldRun' " + "property was set " + "to false on " + getBeanName() + " Liquibase Spring bean.");
+            return;
+        }
+
+        try (Liquibase liquibase = createLiquibase(getDatabase())) {
+            generateRollbackFile(liquibase);
+            performUpdate(liquibase);
+        }
+    }
+
+
+    private void generateRollbackFile(Liquibase liquibase) throws LiquibaseException {
+
+        if (rollbackFile != null) {
+
+            try (OutputStream outputStream = Files.newOutputStream(rollbackFile.toPath()); Writer output = new OutputStreamWriter(outputStream,
+                                                                                                                                  GlobalConfiguration.OUTPUT_FILE_ENCODING.getCurrentValue())) {
+
+                if (tag != null) {
+                    liquibase.futureRollbackSQL(tag, new Contexts(getContexts()), new LabelExpression(getLabelFilter()), output);
+                } else {
+                    liquibase.futureRollbackSQL(new Contexts(getContexts()), new LabelExpression(getLabelFilter()), output);
+                }
+            } catch (IOException e) {
+                throw new LiquibaseException("Unable to generate rollback file.", e);
+            }
+        }
+    }
+
+
+    @SuppressWarnings("squid:S2095")
+    @SneakyThrows
+    protected Liquibase createLiquibase(Database db) {
+
+        Liquibase liquibase;
+        try (SpringResourceAccessor resourceAccessor = createResourceOpener()) {
+            liquibase = new Liquibase(getChangeLog(), resourceAccessor, db);
+            if (parameters != null) {
+                for (Map.Entry<String, String> entry : parameters.entrySet()) {
+                    liquibase.setChangeLogParameter(entry.getKey(), entry.getValue());
+                }
+            }
+
+            if (isDropFirst()) {
+                liquibase.dropAll();
+            }
+        }
+
+        return liquibase;
+    }
+
+}

src/main/java/com/knecon/fforesight/mongo/database/commons/liquibase/MongoTenantCreatedEvent.java

@@ -1,14 +0,0 @@
-package com.knecon.fforesight.mongo.database.commons.liquibase;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-@Data
-@AllArgsConstructor
-@NoArgsConstructor
-public class MongoTenantCreatedEvent {
-
-    private String tenantId;
-
-}

src/main/java/com/knecon/fforesight/mongo/database/commons/liquibase/MongoTenantCreatedListener.java

@@ -1,39 +0,0 @@
-package com.knecon.fforesight.mongo.database.commons.liquibase;
-
-import org.springframework.amqp.rabbit.annotation.RabbitListener;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.annotation.Conditional;
-import org.springframework.stereotype.Service;
-
-import jakarta.annotation.PostConstruct;
-import lombok.RequiredArgsConstructor;
-import lombok.SneakyThrows;
-import lombok.extern.slf4j.Slf4j;
-
-@Slf4j
-@Service
-@RequiredArgsConstructor
-@Conditional(EnableMongoLiquibaseCondition.class)
-public class MongoTenantCreatedListener {
-
-    private final TenantMongoLiquibaseExecutor tenantMongoLiquibaseExecutor;
-
-    @Value("${fforesight.multitenancy.mongo.tenant-created-queue:mongo-tenant-created}")
-    private String tenantCreatedQueue;
-
-
-    @PostConstruct
-    public void postConstruct() {
-
-        log.info("Listener for tenant-created started for queue: {}", tenantCreatedQueue);
-    }
-
-
-    @SneakyThrows
-    @RabbitListener(queues = "${fforesight.multitenancy.mongo.tenant-created-queue:mongo-tenant-created}")
-    public void createTenant(MongoTenantCreatedEvent tenantRequest) {
-
-        tenantMongoLiquibaseExecutor.initializeTenant(tenantRequest.getTenantId());
-    }
-
-}

src/main/java/com/knecon/fforesight/mongo/database/commons/liquibase/TenantCreatedMongoEventHandler.java

@@ -0,0 +1,33 @@
+package com.knecon.fforesight.mongo.database.commons.liquibase;
+
+import org.springframework.context.annotation.Conditional;
+import org.springframework.stereotype.Service;
+
+import com.knecon.fforesight.tenantcommons.listener.ITenantEventHandler;
+import com.knecon.fforesight.tenantcommons.model.TenantCreatedEvent;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+@Conditional(EnableMongoLiquibaseCondition.class)
+public class TenantCreatedMongoEventHandler implements ITenantEventHandler<TenantCreatedEvent> {
+
+    private final TenantMongoLiquibaseExecutor tenantMongoLiquibaseExecutor;
+
+
+    @Override
+    public void handle(TenantCreatedEvent tenantCreatedEvent) {
+
+        tenantMongoLiquibaseExecutor.initializeTenant(tenantCreatedEvent.getTenantId());
+    }
+
+
+    @Override
+    public Class<TenantCreatedEvent> getEventClass() {
+
+        return TenantCreatedEvent.class;
+    }
+
+}

src/main/java/com/knecon/fforesight/mongo/database/commons/liquibase/TenantMongoLiquibaseExecutor.java

@@ -1,23 +1,24 @@
 package com.knecon.fforesight.mongo.database.commons.liquibase;
 
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 import org.springframework.beans.factory.InitializingBean;
 import org.springframework.boot.autoconfigure.liquibase.LiquibaseProperties;
 import org.springframework.context.ResourceLoaderAware;
 import org.springframework.core.io.ResourceLoader;
 
-import com.knecon.fforesight.mongo.database.commons.utils.MongoUtils;
 import com.knecon.fforesight.tenantcommons.EncryptionDecryptionService;
 import com.knecon.fforesight.tenantcommons.TenantProvider;
 import com.knecon.fforesight.tenantcommons.model.MongoDBConnection;
 import com.knecon.fforesight.tenantcommons.model.TenantResponse;
+import com.knecon.fforesight.tenantcommons.utils.MongoConnectionStringHelper;
 
 import feign.RetryableException;
-import liquibase.Contexts;
-import liquibase.Liquibase;
-import liquibase.changelog.ChangeSet;
+import liquibase.database.Database;
 import liquibase.database.DatabaseFactory;
+import liquibase.exception.LiquibaseException;
 import liquibase.ext.mongodb.database.MongoLiquibaseDatabase;
 import liquibase.integration.spring.SpringResourceAccessor;
 import lombok.RequiredArgsConstructor;
@@ -54,41 +55,56 @@ public class TenantMongoLiquibaseExecutor implements InitializingBean, ResourceL
     @SneakyThrows
     protected void runOnAllTenants(List<TenantResponse> tenants) {
 
-        tenants.forEach(this::runLiquibase);
-    }
-
-
-    private void runLiquibase(TenantResponse tenant) {
-
-        MongoDBConnection mongoDBConnection = tenant.getMongoDBConnection();
-        var mongoUrl = MongoUtils.buildMongoUrl(mongoDBConnection);
-        log.info("Initializing MongoDB liquibase for tenant {} / {}", tenant.getTenantId(), mongoUrl);
-
-        try (SpringResourceAccessor resourceAccessor = new SpringResourceAccessor(resourceLoader)) {
-
-            try (MongoLiquibaseDatabase database = (MongoLiquibaseDatabase) DatabaseFactory.getInstance()
-                    .openDatabase(mongoUrl, mongoDBConnection.getUsername(), encryptionService.decrypt(mongoDBConnection.getPassword()), null, resourceAccessor)) {
-                database.setSupportsValidator(false);
-                try (Liquibase liquibase = new Liquibase(tenantMongoLiquibaseProperties.getChangeLog(), resourceAccessor, database)) {
-                    Contexts contexts = new Contexts(tenantMongoLiquibaseProperties.getContexts());
-                    List<ChangeSet> changeSetsList = liquibase.listUnrunChangeSets(contexts, null);
-                    if (!changeSetsList.isEmpty()) {
-                        liquibase.update(contexts);
-                    }
-                }
-            }
-
-        } catch (Exception e) {
-            log.error("Failed to run liquibase migration on MongoDB for tenant: {}", tenant.getTenantId(), e);
-        }
-        log.info("Liquibase ran on MongoDB for tenant " + tenant.getTenantId());
+        tenants.forEach(this::runMongoLiquibase);
     }
 
 
     public void initializeTenant(String tenantId) {
 
-        runLiquibase(tenantProvider.getTenant(tenantId));
+        runMongoLiquibase(tenantProvider.getTenant(tenantId));
 
     }
 
+
+    protected void runMongoLiquibase(TenantResponse tenant) {
+
+        log.info("Initializing MongoDB liquibase for tenant {}", tenant.getTenantId());
+
+        try (SpringResourceAccessor resourceAccessor = new SpringResourceAccessor(resourceLoader)) {
+
+            MongoDBConnection mongoDBConnection = tenant.getMongoDBConnection();
+            try (MongoLiquibaseDatabase database = (MongoLiquibaseDatabase) DatabaseFactory.getInstance()
+                    .openDatabase(MongoConnectionStringHelper.buildGenericMongoUrl(mongoDBConnection),
+                                  mongoDBConnection.getUsername(),
+                                  encryptionService.decrypt( mongoDBConnection.getPassword()),
+                                  null,
+                                  resourceAccessor)) {
+                database.setSupportsValidator(false);
+
+                executeMongoSpringLiquibase(database);
+            }
+
+        } catch (Exception e) {
+            log.error("Failed to run liquibase migration on MongoDB for tenant: {}", tenant.getTenantId(), e);
+        } log.info("Liquibase ran on MongoDB for tenant " + tenant.getTenantId());
+    }
+
+
+    protected void executeMongoSpringLiquibase(Database database) throws LiquibaseException {
+
+        MongoSpringLiquibase liquibase = new MongoSpringLiquibase();
+        liquibase.setResourceLoader(resourceLoader);
+        liquibase.setDatabase(database);
+        liquibase.setChangeLog(tenantMongoLiquibaseProperties.getChangeLog());
+        liquibase.setContexts(tenantMongoLiquibaseProperties.getContexts());
+        liquibase.setClearCheckSums(tenantMongoLiquibaseProperties.isClearChecksums());
+
+        String databaseName = database.getConnection().getCatalog(); // or getDatabaseName() depending on your implementation
+        Map<String, String> changeLogParameters = new HashMap<>();
+        changeLogParameters.put("databaseName", databaseName);
+        liquibase.setChangeLogParameters(changeLogParameters);
+
+        liquibase.afterPropertiesSet();
+    }
+
 }

src/main/java/com/knecon/fforesight/mongo/database/commons/service/MongoClientCache.java

@@ -1,9 +1,7 @@
 package com.knecon.fforesight.mongo.database.commons.service;
 
-import java.util.Collections;
 import java.util.concurrent.TimeUnit;
 
-import org.jetbrains.annotations.NotNull;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 
@@ -12,13 +10,12 @@ import com.google.common.cache.CacheLoader;
 import com.google.common.cache.LoadingCache;
 import com.knecon.fforesight.mongo.database.commons.model.MongoClientConnection;
 import com.knecon.fforesight.tenantcommons.model.MongoDBConnection;
-import com.mongodb.MongoClientSettings;
-import com.mongodb.MongoCredential;
-import com.mongodb.ServerAddress;
+import com.knecon.fforesight.tenantcommons.utils.MongoConnectionStringHelper;
 import com.mongodb.client.MongoClient;
 import com.mongodb.client.MongoClients;
 
 import jakarta.annotation.PostConstruct;
+import jakarta.validation.constraints.NotNull;
 import lombok.RequiredArgsConstructor;
 import lombok.SneakyThrows;
 
@@ -56,14 +53,7 @@ public class MongoClientCache {
 
     private MongoClient buildMongoClient(MongoDBConnection mongoDBConnection) {
 
-        MongoCredential credential = MongoCredential.createCredential(mongoDBConnection.getUsername(),
-                                                                      mongoDBConnection.getDatabase(),
-                                                                      mongoDBConnection.getPassword().toCharArray());
-        return MongoClients.create(MongoClientSettings.builder()
-                                           .applyToClusterSettings(builder -> builder.hosts(Collections.singletonList(new ServerAddress(mongoDBConnection.getHost(),
-                                                                                                                                        Integer.parseInt(mongoDBConnection.getPort())))))
-                                           .credential(credential)
-                                           .build());
+        return MongoClients.create(MongoConnectionStringHelper.buildGenericMongoConnectionString(mongoDBConnection));
     }
 
 
@@ -80,4 +70,4 @@ public class MongoClientCache {
         return clients.get(tenantId);
     }
 
-}
+}

src/main/java/com/knecon/fforesight/mongo/database/commons/utils/MongoUtils.java

@@ -1,55 +0,0 @@
-package com.knecon.fforesight.mongo.database.commons.utils;
-
-import com.knecon.fforesight.tenantcommons.model.MongoDBConnection;
-
-import lombok.experimental.UtilityClass;
-
-@UtilityClass
-public class MongoUtils {
-
-
-    private StringBuilder createMongoConnectionStringBuilder(String host, String port, String database) {
-
-        return new StringBuilder("mongodb://").append(host).append(':').append(port).append('/').append(database);
-    }
-
-    private StringBuilder createMongoConnectionStringBuilder(String host, String port, String username, String password, String database) {
-
-        return createMongoConnectionStringBuilder(host, port, username, password).append('/').append(database);
-    }
-
-
-    private StringBuilder createMongoConnectionStringBuilder(String host, String port, String username, String password) {
-
-        return new StringBuilder("mongodb://").append(username).append(':').append(password).append("@").append(host).append(':').append(port);
-    }
-
-
-    public String buildMongoUrl(MongoDBConnection mongoDBConnection) {
-
-        return createMongoConnectionStringBuilder(mongoDBConnection.getHost(),
-                                                  mongoDBConnection.getPort(),
-                                                  mongoDBConnection.getDatabase()).toString();
-    }
-
-
-    public String buildMongoUrlWithAuth(MongoDBConnection mongoDBConnection) {
-
-        return createMongoConnectionStringBuilder(mongoDBConnection.getHost(),
-                                                  mongoDBConnection.getPort(),
-                                                  mongoDBConnection.getUsername(),
-                                                  mongoDBConnection.getPassword()).toString();
-    }
-
-
-    public String buildMongoUrlWithAuthForDatabase(MongoDBConnection mongoDBConnection) {
-
-        return createMongoConnectionStringBuilder(mongoDBConnection.getHost(),
-                                                  mongoDBConnection.getPort(),
-                                                  mongoDBConnection.getUsername(),
-                                                  mongoDBConnection.getPassword(),
-                                                  mongoDBConnection.getDatabase()).toString();
-
-    }
-
-}