EVA-3260 update block allocation strategy

accession-commons-core/src/main/java/uk/ac/ebi/ampt2d/commons/accession/core/BasicAccessioningService.java

@@ -177,6 +177,10 @@ public void merge(ACCESSION accessionOrigin, ACCESSION mergeInto, String reason)
         dbService.merge(accessionOrigin, mergeInto, reason);
     }
 
+    public void shutDownAccessioning() {
+        accessionGenerator.shutDownAccessionGenerator();
+    }
+
     protected AccessionGenerator<MODEL, ACCESSION> getAccessionGenerator() {
         return accessionGenerator;
     }

accession-commons-core/src/main/java/uk/ac/ebi/ampt2d/commons/accession/core/exceptions/AccessionGeneratorShutDownException.java

@@ -0,0 +1,7 @@
+package uk.ac.ebi.ampt2d.commons.accession.core.exceptions;
+
+public class AccessionGeneratorShutDownException extends RuntimeException {
+    public AccessionGeneratorShutDownException(String msg) {
+        super(msg);
+    }
+}

accession-commons-core/src/main/java/uk/ac/ebi/ampt2d/commons/accession/generators/AccessionGenerator.java

@@ -50,4 +50,9 @@ <HASH> List<AccessionWrapper<MODEL, HASH, ACCESSION>> generateAccessions(Map<HAS
      * @param response DB response
      */
     void postSave(SaveResponse<ACCESSION> response);
+
+    /**
+     * This method should be used to shut-down the generator and release resources
+     */
+    void shutDownAccessionGenerator();
 }

accession-commons-core/src/main/java/uk/ac/ebi/ampt2d/commons/accession/generators/SingleAccessionGenerator.java

@@ -67,4 +67,8 @@ public static <MODEL> SingleAccessionGenerator<MODEL, String> ofSHA1AccessionGen
         return ofHashAccessionGenerator(summaryFunction, new SHA1HashingFunction());
     }
 
+    @Override
+    public void shutDownAccessionGenerator() {
+        // Do nothing - no resources to release
+    }
 }

accession-commons-monotonic-generator-jpa/src/main/java/uk/ac/ebi/ampt2d/commons/accession/generators/monotonic/BlockManager.java

@@ -168,4 +168,14 @@ public Set<ContiguousIdBlock> recoverState(long[] committedElements) throws Acce
         this.availableRanges.addAll(newAvailableRanges);
         return doCommit(committedElements);
     }
+
+    public List<ContiguousIdBlock> getAssignedBlocks(){
+        return assignedBlocks.stream().collect(Collectors.toList());
+    }
+
+    public void shutDownBlockManager() {
+        assignedBlocks.clear();
+        availableRanges.clear();
+        generatedAccessions.clear();
+    }
 }

accession-commons-monotonic-generator-jpa/src/main/java/uk/ac/ebi/ampt2d/commons/accession/generators/monotonic/MonotonicAccessionGenerator.java

@@ -19,6 +19,7 @@
 
 import uk.ac.ebi.ampt2d.commons.accession.block.initialization.BlockInitializationException;
 import uk.ac.ebi.ampt2d.commons.accession.core.exceptions.AccessionCouldNotBeGeneratedException;
+import uk.ac.ebi.ampt2d.commons.accession.core.exceptions.AccessionGeneratorShutDownException;
 import uk.ac.ebi.ampt2d.commons.accession.core.exceptions.AccessionIsNotPendingException;
 import uk.ac.ebi.ampt2d.commons.accession.core.models.AccessionWrapper;
 import uk.ac.ebi.ampt2d.commons.accession.core.models.SaveResponse;
@@ -47,6 +48,8 @@ public class MonotonicAccessionGenerator<MODEL> implements AccessionGenerator<MO
     private final String applicationInstanceId;
     private final ContiguousIdBlockService blockService;
 
+    private Boolean SHUTDOWN = Boolean.FALSE;
+
     public MonotonicAccessionGenerator(String categoryId,
                                        String applicationInstanceId,
                                        ContiguousIdBlockService contiguousIdBlockService,
@@ -88,7 +91,7 @@ private static BlockManager initializeBlockManager(ContiguousIdBlockService bloc
         assertBlockParametersAreInitialized(blockService, categoryId);
         BlockManager blockManager = new BlockManager();
         List<ContiguousIdBlock> uncompletedBlocks = blockService
-                .getUncompletedBlocksByCategoryIdAndApplicationInstanceIdOrderByEndAsc(categoryId,
+                .reserveUncompletedBlocksByCategoryIdAndApplicationInstanceIdOrderByEndAsc(categoryId,
                         applicationInstanceId);
         //Insert as available ranges
         for (ContiguousIdBlock block : uncompletedBlocks) {
@@ -116,6 +119,7 @@ private void recoverState(long[] committedElements) throws AccessionIsNotPending
 
     public synchronized long[] generateAccessions(int numAccessionsToGenerate)
             throws AccessionCouldNotBeGeneratedException {
+        checkAccessionGeneratorNotShutDown();
         long[] accessions = new long[numAccessionsToGenerate];
         reserveNewBlocksUntilSizeIs(numAccessionsToGenerate);
 
@@ -147,20 +151,24 @@ private synchronized void reserveNewBlock(String categoryId, String instanceId)
     }
 
     public synchronized void commit(long... accessions) throws AccessionIsNotPendingException {
+        checkAccessionGeneratorNotShutDown();
         blockService.save(blockManager.commit(accessions));
     }
 
     public synchronized void release(long... accessions) throws AccessionIsNotPendingException {
+        checkAccessionGeneratorNotShutDown();
         blockManager.release(accessions);
     }
 
     public synchronized MonotonicRangePriorityQueue getAvailableRanges() {
+        checkAccessionGeneratorNotShutDown();
         return blockManager.getAvailableRanges();
     }
 
     @Override
     public <HASH> List<AccessionWrapper<MODEL, HASH, Long>> generateAccessions(Map<HASH, MODEL> messages)
             throws AccessionCouldNotBeGeneratedException {
+        checkAccessionGeneratorNotShutDown();
         long[] accessions = generateAccessions(messages.size());
         int i = 0;
         List<AccessionWrapper<MODEL, HASH, Long>> accessionedModels = new ArrayList<>();
@@ -174,8 +182,27 @@ public <HASH> List<AccessionWrapper<MODEL, HASH, Long>> generateAccessions(Map<H
 
     @Override
     public synchronized void postSave(SaveResponse<Long> response) {
+        checkAccessionGeneratorNotShutDown();
         commit(response.getSavedAccessions().stream().mapToLong(l -> l).toArray());
         release(response.getSaveFailedAccessions().stream().mapToLong(l -> l).toArray());
     }
 
+    public void shutDownAccessionGenerator(){
+        List<ContiguousIdBlock> blockList = blockManager.getAssignedBlocks();
+        blockList.stream().forEach(block -> block.releaseReserved());
+        blockService.save(blockList);
+        blockManager.shutDownBlockManager();
+        SHUTDOWN = Boolean.TRUE;
+    }
+
+    /**
+     * Before doing any operation on Accession Generator, we need to make sure it has not been shut down.
+     * We should make the check by calling this method as the first thing in all public methods of this class
+     */
+    private void checkAccessionGeneratorNotShutDown(){
+        if(SHUTDOWN){
+            throw new AccessionGeneratorShutDownException("Accession Generator has been shut down and is no longer available");
+        }
+    }
+
 }

accession-commons-monotonic-generator-jpa/src/main/java/uk/ac/ebi/ampt2d/commons/accession/persistence/jpa/monotonic/entities/ContiguousIdBlock.java

@@ -25,6 +25,7 @@
 import javax.persistence.Index;
 import javax.persistence.Table;
 import javax.persistence.UniqueConstraint;
+import java.time.LocalDateTime;
 
 /**
  * This class represents a block allocated by an application instance, in a monotonic sequence associated with a
@@ -63,6 +64,10 @@ public class ContiguousIdBlock implements Comparable<ContiguousIdBlock> {
 
     private long lastCommitted;
 
+    private Boolean reserved;
+
+    private LocalDateTime createdTimestamp;
+
     // Create / update dates
 
     ContiguousIdBlock() {
@@ -75,6 +80,8 @@ public ContiguousIdBlock(String categoryId, String applicationInstanceId, long f
         this.firstValue = firstValue;
         this.lastValue = firstValue + size - 1;
         this.lastCommitted = firstValue - 1;
+        this.reserved = Boolean.TRUE;
+        this.createdTimestamp = LocalDateTime.now();
     }
 
     /**
@@ -143,6 +150,26 @@ public long getLastValue() {
         return lastValue;
     }
 
+    public Boolean isReserved() {
+        return reserved == Boolean.TRUE;
+    }
+
+    public Boolean isNotReserved() {
+        return reserved == Boolean.FALSE;
+    }
+
+    public void markAsReserved() {
+        this.reserved = Boolean.TRUE;
+    }
+
+    public void releaseReserved() {
+        this.reserved = Boolean.FALSE;
+    }
+
+    public boolean isFull() {
+        return lastCommitted == lastValue;
+    }
+
     public boolean isNotFull() {
         return lastCommitted != lastValue;
     }

accession-commons-monotonic-generator-jpa/src/main/java/uk/ac/ebi/ampt2d/commons/accession/persistence/jpa/monotonic/service/ContiguousIdBlockService.java

@@ -47,6 +47,8 @@ public ContiguousIdBlockService(ContiguousIdBlockRepository repository, Map<Stri
 
     @Transactional
     public void save(Iterable<ContiguousIdBlock> blocks) {
+        // release block if full
+        blocks.forEach(block -> {if (block.isFull()) {block.releaseReserved();}});
         repository.saveAll(blocks);
         entityManager.flush();
     }
@@ -74,12 +76,22 @@ public BlockParameters getBlockParameters(String categoryId) {
         return categoryBlockInitializations.get(categoryId);
     }
 
-    @Transactional(readOnly = true)
-    public List<ContiguousIdBlock> getUncompletedBlocksByCategoryIdAndApplicationInstanceIdOrderByEndAsc(
+    @Transactional(isolation = Isolation.SERIALIZABLE)
+    public List<ContiguousIdBlock> reserveUncompletedBlocksByCategoryIdAndApplicationInstanceIdOrderByEndAsc(
             String categoryId, String applicationInstanceId) {
         try (Stream<ContiguousIdBlock> reservedBlocksOfThisInstance = repository
                 .findAllByCategoryIdAndApplicationInstanceIdOrderByLastValueAsc(categoryId, applicationInstanceId)) {
-            return reservedBlocksOfThisInstance.filter(ContiguousIdBlock::isNotFull).collect(Collectors.toList());
+            List<ContiguousIdBlock> blocksList = reservedBlocksOfThisInstance
+                    .filter(block -> block.isNotFull() && block.isNotReserved()).collect(Collectors.toList());
+
+            blocksList.stream().forEach(block -> block.markAsReserved());
+            save(blocksList);
+
+            return blocksList;
         }
     }
+
+    public ContiguousIdBlockRepository getRepository() {
+        return repository;
+    }
 }