Merge branch 'CME-238-patch' into CME-239

elastic-search-support/src/main/java/uk/gov/hmcts/ccd/definition/store/elastic/AsynchronousElasticDefinitionImportListener.java

@@ -22,8 +22,9 @@ public AsynchronousElasticDefinitionImportListener(CcdElasticSearchProperties co
                                                        CaseMappingGenerator mappingGenerator,
                                                        ObjectFactory<HighLevelCCDElasticClient> clientFactory,
                                                        ElasticsearchErrorHandler elasticsearchErrorHandler,
+                                                       ReindexService reindexService,
                                                        ReindexTaskService reindexTaskService) {
-        super(config, mappingGenerator, clientFactory, elasticsearchErrorHandler, reindexTaskService);
+        super(config, mappingGenerator, clientFactory, elasticsearchErrorHandler, reindexService, reindexTaskService);
     }
 
     @Async

elastic-search-support/src/main/java/uk/gov/hmcts/ccd/definition/store/elastic/ElasticDefinitionImportListener.java

@@ -12,7 +12,6 @@
 import uk.gov.hmcts.ccd.definition.store.elastic.service.ReindexTaskService;
 import uk.gov.hmcts.ccd.definition.store.event.DefinitionImportedEvent;
 import uk.gov.hmcts.ccd.definition.store.repository.entity.CaseTypeEntity;
-import uk.gov.hmcts.ccd.definition.store.repository.entity.ReindexEntity;
 
 import java.io.IOException;
 import java.util.List;
@@ -30,16 +29,20 @@ public abstract class ElasticDefinitionImportListener {
 
     private final ElasticsearchErrorHandler elasticsearchErrorHandler;
 
+    private final ReindexService reindexService;
+
     private final ReindexTaskService reindexTaskService;
 
+
     public ElasticDefinitionImportListener(CcdElasticSearchProperties config, CaseMappingGenerator mappingGenerator,
                                            ObjectFactory<HighLevelCCDElasticClient> clientFactory,
-                                           ElasticsearchErrorHandler elasticsearchErrorHandler,
+                                           ElasticsearchErrorHandler elasticsearchErrorHandler, ReindexService reindexService,
                                            ReindexTaskService reindexTaskService) {
         this.config = config;
         this.mappingGenerator = mappingGenerator;
         this.clientFactory = clientFactory;
         this.elasticsearchErrorHandler = elasticsearchErrorHandler;
+        this.reindexService = reindexService;
         this.reindexTaskService = reindexTaskService;
     }
 
@@ -54,7 +57,6 @@ public ElasticDefinitionImportListener(CcdElasticSearchProperties config, CaseMa
     public void initialiseElasticSearch(DefinitionImportedEvent event) {
         List<CaseTypeEntity> caseTypes = event.getContent();
         boolean reindex = event.isReindex();
-        boolean deleteOldIndex = event.isDeleteOldIndex();
         boolean reindexStarted = false;
         String newIndexName = null;
         String caseMapping = null;
@@ -70,31 +72,7 @@ public void initialiseElasticSearch(DefinitionImportedEvent event) {
                     elasticClient.createIndex(actualIndexName, baseIndexName);
                 }
                 if (reindex) {
-                    //get current alias index
-                    GetAliasesResponse aliasResponse = elasticClient.getAlias(baseIndexName);
-                    String indexName = aliasResponse.getAliases().keySet().iterator().next();
-                    newIndexName = incrementIndexNumber(indexName);
-
-                    //prepare for db
-                    ReindexEntity reindexEntity = reindexTaskService.saveEntity(reindex,
-                        deleteOldIndex, caseType, newIndexName);
-
-                    //create new index with generated mapping and incremented case type name (no alias update yet)
-                    caseMapping = mappingGenerator.generateMapping(caseType);
-                    log.debug("case mapping: {}", caseMapping);
-
-                    //update index name for db
-                    elasticClient.setIndexReadOnly(baseIndexName, true);
-                    elasticClient.createIndexAndMapping(newIndexName, caseMapping);
-
-                    //initiate reindexing
-                    reindexStarted = true;
-                    handleReindexing(baseIndexName, indexName, newIndexName,
-                        deleteOldIndex);
-                    //dummy value for phase 1
-                    event.setTaskId("taskID");
-                    log.info("reindexing successful for case type: {}", caseType.getReference());
-                    log.info("task id returned from the import: {}", event.getTaskId());
+                    reindexService.asyncReindex(event, baseIndexName, caseType, reindexStarted);
                 } else {
                     caseMapping = mappingGenerator.generateMapping(caseType);
                     log.debug("case mapping: {}", caseMapping);
@@ -116,75 +94,6 @@ public void initialiseElasticSearch(DefinitionImportedEvent event) {
         }
     }
 
-    private void handleReindexing(String baseIndexName,
-                                  String oldIndexName, String newIndexName,
-                                  boolean deleteOldIndex) {
-        HighLevelCCDElasticClient elasticClient = clientFactory.getObject();
-        elasticClient.reindexData(oldIndexName, newIndexName, new ActionListener<>() {
-            @Override
-            public void onResponse(BulkByScrollResponse bulkByScrollResponse) {
-                try (elasticClient; HighLevelCCDElasticClient asyncElasticClient = clientFactory.getObject()) {
-                    //if success set writable and update alias to new index
-                    log.info("updating alias from {} to {}", oldIndexName, newIndexName);
-                    asyncElasticClient.setIndexReadOnly(baseIndexName, false);
-                    asyncElasticClient.updateAlias(baseIndexName, oldIndexName, newIndexName);
-                    if (deleteOldIndex) {
-                        log.info("deleting old index {}", oldIndexName);
-                        asyncElasticClient.removeIndex(oldIndexName);
-                    }
-                    //set success status and end time for db
-                    reindexTaskService.updateEntity(newIndexName, bulkByScrollResponse.toString());
-                    log.info("saved reindex entity"
-                             + " metadata for case type {} to DB", baseIndexName);
-
-                } catch (IOException e) {
-                    log.error("failed to clean up after reindexing success", e);
-                    reindexTaskService.updateEntity(newIndexName, e);
-                    throw new CompletionException(e);
-                }
-            }
-
-            @Override
-            public void onFailure(Exception ex) {
-                try (elasticClient; HighLevelCCDElasticClient asyncElasticClient = clientFactory.getObject()) {
-                    //set failure status, end time and ex for db
-                    reindexTaskService.updateEntity(newIndexName, ex);
-
-                    //if failed delete new index, set old index writable
-                    log.error("reindexing failed", ex);
-                    asyncElasticClient.removeIndex(newIndexName);
-                    log.info("{} deleted", newIndexName);
-                    asyncElasticClient.setIndexReadOnly(oldIndexName, false);
-                    log.info("{} set to writable", oldIndexName);
-                } catch (IOException e) {
-                    log.error("failed to clean up after reindexing failure", e);
-                    reindexTaskService.updateEntity(newIndexName, e);
-                    throw new CompletionException(e);
-                }
-                throw new CompletionException(ex);
-            }
-        });
-    }
-
-    String incrementIndexNumber(String indexName) {
-        Pattern pattern = Pattern.compile("(.+_cases-)(\\d+)$");
-        Matcher matcher = pattern.matcher(indexName);
-
-        if (!matcher.matches() || matcher.groupCount() < 2) {
-            throw new IllegalArgumentException("invalid index name format: " + indexName);
-        }
-
-        String prefix = matcher.group(1);
-        String numberStr = matcher.group(2);
-
-        int incremented = Integer.parseInt(numberStr) + 1;
-        String formattedNumber = StringUtils.leftPad(String.valueOf(incremented), numberStr.length(), '0');
-
-        String incrementedIndexName = prefix + formattedNumber;
-        log.info("incremented index name: {}", incrementedIndexName);
-        return incrementedIndexName;
-    }
-
     private String baseIndexName(CaseTypeEntity caseType) {
         String caseTypeId = caseType.getReference();
         return String.format(config.getCasesIndexNameFormat(), caseTypeId.toLowerCase());

elastic-search-support/src/main/java/uk/gov/hmcts/ccd/definition/store/elastic/ReindexService.java

@@ -1,116 +1,4 @@
 package uk.gov.hmcts.ccd.definition.store.elastic;
 
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.StringUtils;
-import org.elasticsearch.action.ActionListener;
-import org.elasticsearch.client.GetAliasesResponse;
-import org.elasticsearch.index.reindex.BulkByScrollResponse;
-import org.springframework.beans.factory.ObjectFactory;
-import org.springframework.scheduling.annotation.Async;
-import org.springframework.stereotype.Service;
-import uk.gov.hmcts.ccd.definition.store.elastic.client.HighLevelCCDElasticClient;
-import uk.gov.hmcts.ccd.definition.store.elastic.mapping.CaseMappingGenerator;
-import uk.gov.hmcts.ccd.definition.store.event.DefinitionImportedEvent;
-import uk.gov.hmcts.ccd.definition.store.repository.entity.CaseTypeEntity;
-
-import java.io.IOException;
-import java.util.concurrent.CompletionException;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-@Slf4j
-@Service
 public class ReindexService {
-
-    private final CaseMappingGenerator mappingGenerator;
-
-    private final ObjectFactory<HighLevelCCDElasticClient> clientFactory;
-
-    public ReindexService(CaseMappingGenerator mappingGenerator,
-                          ObjectFactory<HighLevelCCDElasticClient> clientFactory) {
-        this.mappingGenerator = mappingGenerator;
-        this.clientFactory = clientFactory;
-    }
-
-    @Async("reindexExecutor")
-    public void asyncReindex(DefinitionImportedEvent event,
-                              String baseIndexName,
-                              CaseTypeEntity caseType) throws IOException {
-        HighLevelCCDElasticClient elasticClient = clientFactory.getObject();
-        GetAliasesResponse aliasResponse = elasticClient.getAlias(baseIndexName);
-        String caseTypeName = aliasResponse.getAliases().keySet().iterator().next();
-
-        //create new index with generated mapping and incremented case type name (no alias update yet)
-        String caseMapping = mappingGenerator.generateMapping(caseType);
-        log.debug("case mapping: {}", caseMapping);
-        String incrementedCaseTypeName = incrementIndexNumber(caseTypeName);
-        elasticClient.setIndexReadOnly(baseIndexName, true);
-        elasticClient.createIndexAndMapping(incrementedCaseTypeName, caseMapping);
-
-        //initiate reindexing
-        handleReindexing(elasticClient, baseIndexName, caseTypeName, incrementedCaseTypeName,
-            event.isDeleteOldIndex());
-        //dummy value for phase 1
-        event.setTaskId("taskID");
-        log.debug("reindexing successful for case type: {}", caseType.getReference());
-        log.debug("task id returned from the import: {}", event.getTaskId());
-    }
-
-    private void handleReindexing(HighLevelCCDElasticClient elasticClient, String baseIndexName,
-                                  String oldIndex, String newIndex,
-                                  boolean deleteOldIndex) {
-        elasticClient.reindexData(oldIndex, newIndex, new ActionListener<>() {
-            @Override
-            public void onResponse(BulkByScrollResponse bulkByScrollResponse) {
-                try (elasticClient; HighLevelCCDElasticClient highLevelCCDElasticClient = clientFactory.getObject()) {
-                    //if success set writable and update alias to new index
-                    log.debug("updating alias from {} to {}", oldIndex, newIndex);
-                    highLevelCCDElasticClient.setIndexReadOnly(baseIndexName, false);
-                    highLevelCCDElasticClient.updateAlias(baseIndexName, oldIndex, newIndex);
-                    if (deleteOldIndex) {
-                        log.debug("deleting old index {}", oldIndex);
-                        highLevelCCDElasticClient.removeIndex(oldIndex);
-                    }
-                } catch (IOException e) {
-                    log.error("failed to clean up after reindexing success", e);
-                    throw new CompletionException(e);
-                }
-            }
-
-            @Override
-            public void onFailure(Exception ex) {
-                try (elasticClient; HighLevelCCDElasticClient highLevelCCDElasticClient = clientFactory.getObject()) {
-                    //if failed delete new index, set old index writable
-                    log.debug("reindexing failed", ex);
-                    highLevelCCDElasticClient.removeIndex(newIndex);
-                    log.debug("{} deleted", newIndex);
-                    highLevelCCDElasticClient.setIndexReadOnly(oldIndex, false);
-                    log.debug("{} set to writable", oldIndex);
-                } catch (IOException e) {
-                    log.error("failed to clean up after reindexing failure", e);
-                    throw new CompletionException(e);
-                }
-                throw new CompletionException(ex);
-            }
-        });
-    }
-
-    String incrementIndexNumber(String indexName) {
-        Pattern pattern = Pattern.compile("(.+_cases-)(\\d+)$");
-        Matcher matcher = pattern.matcher(indexName);
-
-        if (!matcher.matches() || matcher.groupCount() < 2) {
-            throw new IllegalArgumentException("invalid index name format: " + indexName);
-        }
-
-        String prefix = matcher.group(1);
-        String numberStr = matcher.group(2);
-
-        int incremented = Integer.parseInt(numberStr) + 1;
-        String formattedNumber = StringUtils.leftPad(String.valueOf(incremented), numberStr.length(), '0');
-
-        String incrementedIndexName = prefix + formattedNumber;
-        return incrementedIndexName;
-    }
-
 }

elastic-search-support/src/main/java/uk/gov/hmcts/ccd/definition/store/elastic/SynchronousElasticDefinitionImportListener.java

@@ -23,8 +23,9 @@ public SynchronousElasticDefinitionImportListener(CcdElasticSearchProperties con
                                                       CaseMappingGenerator mappingGenerator,
                                                       ObjectFactory<HighLevelCCDElasticClient> clientFactory,
                                                       ElasticsearchErrorHandler elasticsearchErrorHandler,
+                                                      ReindexService reindexService,
                                                       ReindexTaskService reindexTaskService) {
-        super(config, mappingGenerator, clientFactory, elasticsearchErrorHandler, reindexTaskService);
+        super(config, mappingGenerator, clientFactory, elasticsearchErrorHandler, reindexService, reindexTaskService);
     }
 
     @EventListener