Merge pull request #66 from iExecBlockchainComputing/release/7.2.0

Release/7.2.0

Author: jbern0rd

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 All notable changes to this project will be documented in this file.
 
+## [[7.2.0]](https://github.com/iExecBlockchainComputing/iexec-blockchain-adapter-api/releases/tag/v7.2.0) 2023-01-09
+
+* Increments jenkins-library up to version 2.2.3. Enable SonarCloud analyses on branches and pull requests.
+* Improve thread management in some tests.
+
 ## [[7.1.2]](https://github.com/iExecBlockchainComputing/iexec-blockchain-adapter-api/releases/tag/v7.1.2) 2022-11-29
 
 * Update build workflow to 2.1.4, update documentation in README and add CHANGELOG.

Jenkinsfile

@@ -1,4 +1,4 @@
-@Library('global-jenkins-library@2.1.4') _
+@Library('global-jenkins-library@2.2.3') _
 buildJavaProject(
         buildInfo: getBuildInfo(),
         integrationTestsEnvVars: ['BROKER_PRIVATE_KEY'],

gradle.properties

@@ -1,4 +1,4 @@
-version=7.1.2
+version=7.2.0
 iexecCommonVersion=6.0.0
 
 nexusUser

src/main/java/com/iexec/blockchain/tool/QueueService.java

@@ -45,7 +45,7 @@ private void startAsyncActionsExecution() {
      * The first action is the action with the highest priority that is in the queue for the longer time.
      */
     void executeActions() {
-        while (Thread.currentThread().isAlive()) {
+        while (Thread.currentThread().isAlive() && !Thread.currentThread().isInterrupted()) {
             executeFirstAction();
         }
     }

src/test/java/com/iexec/blockchain/tool/QueueServiceTest.java

@@ -15,6 +15,8 @@
 import java.util.List;
 import java.util.Queue;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Function;
@@ -24,12 +26,16 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 class QueueServiceTest {
+
+    private ExecutorService executorService;
+
     @InjectMocks
     @Spy
     private QueueService queueService;
 
     @BeforeEach
     void setUp() {
+        executorService = Executors.newSingleThreadExecutor();
         MockitoAnnotations.openMocks(this);
     }
 
@@ -75,12 +81,15 @@ void shouldRunHighPriorityRunnable() {
 
         // Start execution thread.
         // It won't stop itself, so we have to do it.
-        final CompletableFuture<Void> tasksExecutionFuture = CompletableFuture.runAsync(queueService::executeActions);
+        CompletableFuture.runAsync(queueService::executeActions, executorService);
         Awaitility
                 .await()
                 .atMost(5, TimeUnit.SECONDS)
                 .until(() -> highPriorityTimestamps.size() == 1);
-        tasksExecutionFuture.cancel(true);
+        // Thread blocks indefinitely on PriorityBlockingQueue#take and needs to be interrupted
+        // CompletableFuture#cancel does not interrupt the thread, an ExecutorService is needed
+        // A call to ExecutorService#shutdownNow is done to interrupt the thread
+        executorService.shutdownNow();
 
         // We simply ensure the execution has completed.
         assertThat(highPriorityTimestamps.size()).isOne();
@@ -95,12 +104,15 @@ void shouldRunLowPriorityRunnable() {
 
         // Start execution thread.
         // It won't stop itself, so we have to do it.
-        final CompletableFuture<Void> tasksExecutionFuture = CompletableFuture.runAsync(queueService::executeActions);
+        CompletableFuture.runAsync(queueService::executeActions, executorService);
         Awaitility
                 .await()
                 .atMost(5, TimeUnit.SECONDS)
                 .until(() -> lowPriorityTimestamps.size() == 1);
-        tasksExecutionFuture.cancel(true);
+        // Thread blocks indefinitely on PriorityBlockingQueue#take and needs to be interrupted
+        // CompletableFuture#cancel does not interrupt the thread, an ExecutorService is needed
+        // A call to ExecutorService#shutdownNow is done to interrupt the thread
+        executorService.shutdownNow();
 
         // We simply ensure the execution has completed.
         assertThat(lowPriorityTimestamps.size()).isOne();
@@ -121,12 +133,15 @@ void shouldRunHighPriorityBeforeLowPriority() {
 
         // Start execution thread.
         // It won't stop itself, so we have to do it.
-        final CompletableFuture<Void> tasksExecutionFuture = CompletableFuture.runAsync(queueService::executeActions);
+        CompletableFuture.runAsync(queueService::executeActions);
         Awaitility
                 .await()
                 .atMost(5, TimeUnit.SECONDS)
                 .until(() -> highPriorityTimestamps.size() == 1 && lowPriorityTimestamps.size() == 1);
-        tasksExecutionFuture.cancel(true);
+        // Thread blocks indefinitely on PriorityBlockingQueue#take and needs to be interrupted
+        // CompletableFuture#cancel does not interrupt the thread, an ExecutorService is needed
+        // A call to ExecutorService#shutdownNow is done to interrupt the thread
+        executorService.shutdownNow();
 
         // We have executed a single task per priority so we that's what we should now have.
         assertThat(highPriorityTimestamps.size()).isOne();
@@ -177,12 +192,15 @@ void shouldExecuteInOrder() throws NoSuchFieldException {
 
         // Start execution thread.
         // It won't stop itself, so we have to do it.
-        final CompletableFuture<Void> executionFuture = CompletableFuture.runAsync(queueService::executeActions);
+        CompletableFuture.runAsync(queueService::executeActions, executorService);
         Awaitility
                 .await()
                 .atMost(5, TimeUnit.SECONDS)
                 .until(() -> executionOrder.size() == totalTasksNumber);
-        executionFuture.cancel(true);
+        // Thread blocks indefinitely on PriorityBlockingQueue#take and needs to be interrupted
+        // CompletableFuture#cancel does not interrupt the thread, an ExecutorService is needed
+        // A call to ExecutorService#shutdownNow is done to interrupt the thread
+        executorService.shutdownNow();
 
         // Tasks should have been executed in the right order.
         // This should look like [0, 1, 2, 3, 4, 5].