Use Duration for retry period in BlockchainAdapterService

Author: mcornaton

CHANGELOG.md

@@ -8,7 +8,7 @@ All notable changes to this project will be documented in this file.
 
 - Send up to 2 blockchain transactions per block.
   With a big enough latency, the nonce is properly computed in web3j library against the pending block. (#111)
-- Add `BlockchainAdapterService` class to implement interactions with REST API. (#117 #118 #119)
+- Add `BlockchainAdapterService` class to implement interactions with REST API. (#117 #118 #119 126)
 - Expose version through prometheus endpoint and through VersionController. (#122 #123)
 
 ### Bug Fixes

iexec-blockchain-adapter-api-library/src/main/java/com/iexec/blockchain/api/BlockchainAdapterService.java

@@ -20,17 +20,18 @@
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 
+import java.time.Duration;
 import java.util.Optional;
 import java.util.function.Function;
 
 @Slf4j
 public class BlockchainAdapterService {
 
     private final BlockchainAdapterApiClient apiClient;
-    private final long period;
+    private final Duration period;
     private final int maxAttempts;
 
-    public BlockchainAdapterService(BlockchainAdapterApiClient apiClient, long period, int maxAttempts) {
+    public BlockchainAdapterService(BlockchainAdapterApiClient apiClient, Duration period, int maxAttempts) {
         this.apiClient = apiClient;
         this.period = period;
         this.maxAttempts = maxAttempts;
@@ -73,7 +74,7 @@ public Optional<String> requestInitialize(String chainDealId, int taskIndex) {
      */
     public Optional<Boolean> isInitialized(String chainTaskId) {
         return isCommandCompleted(apiClient::getStatusForInitializeTaskRequest,
-                chainTaskId, period, maxAttempts);
+                chainTaskId, maxAttempts);
     }
 
     // endregion
@@ -119,7 +120,7 @@ public Optional<String> requestFinalize(String chainTaskId,
      */
     public Optional<Boolean> isFinalized(String chainTaskId) {
         return isCommandCompleted(apiClient::getStatusForFinalizeTaskRequest,
-                chainTaskId, period, maxAttempts);
+                chainTaskId, maxAttempts);
     }
 
     // endregion
@@ -129,7 +130,6 @@ public Optional<Boolean> isFinalized(String chainTaskId) {
      *
      * @param getCommandStatusFunction method for fetching the current command status from the adapter
      * @param chainTaskId              ID of the task
-     * @param period                   period in ms between consecutive checks
      * @param maxAttempts              maximum number of attempts
      * @return an optional which will be:
      * <ul>
@@ -140,7 +140,7 @@ public Optional<Boolean> isFinalized(String chainTaskId) {
      */
     Optional<Boolean> isCommandCompleted(
             Function<String, CommandStatus> getCommandStatusFunction,
-            String chainTaskId, long period, int maxAttempts) {
+            String chainTaskId, int maxAttempts) {
         for (int attempt = 0; attempt < maxAttempts; attempt++) {
             try {
                 CommandStatus status = getCommandStatusFunction.apply(chainTaskId);
@@ -156,7 +156,7 @@ Optional<Boolean> isCommandCompleted(
             }
 
             try {
-                Thread.sleep(period);
+                Thread.sleep(period.toMillis());
             } catch (InterruptedException e) {
                 log.error("Polling on blockchain command was interrupted", e);
                 Thread.currentThread().interrupt();

iexec-blockchain-adapter-api-library/src/test/java/com/iexec/blockchain/api/BlockchainAdapterServiceTests.java

@@ -23,6 +23,7 @@
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
+import java.time.Duration;
 import java.util.Optional;
 import java.util.concurrent.CancellationException;
 import java.util.concurrent.ExecutorService;
@@ -39,7 +40,7 @@ class BlockchainAdapterServiceTests {
     static final String CHAIN_TASK_ID = "CHAIN_TASK_ID";
     static final String LINK = "link";
     static final String CALLBACK = "callback";
-    static final int PERIOD = 10;
+    static final Duration PERIOD = Duration.ofMillis(10);
     static final int MAX_ATTEMPTS = 3;
 
     @Mock
@@ -134,7 +135,7 @@ void isCommandCompletedTrueWhenSuccess() {
                 .thenReturn(CommandStatus.SUCCESS);
 
         Optional<Boolean> commandCompleted = blockchainAdapterService.isCommandCompleted(
-                blockchainAdapterClient::getStatusForInitializeTaskRequest, CHAIN_TASK_ID, PERIOD, MAX_ATTEMPTS);
+                blockchainAdapterClient::getStatusForInitializeTaskRequest, CHAIN_TASK_ID, MAX_ATTEMPTS);
         assertEquals(Optional.of(true), commandCompleted);
     }
 
@@ -146,7 +147,7 @@ void isCommandCompletedFalseWhenFailure() {
                 .thenReturn(CommandStatus.FAILURE);
 
         Optional<Boolean> commandCompleted = blockchainAdapterService.isCommandCompleted(
-                blockchainAdapterClient::getStatusForInitializeTaskRequest, CHAIN_TASK_ID, PERIOD, MAX_ATTEMPTS);
+                blockchainAdapterClient::getStatusForInitializeTaskRequest, CHAIN_TASK_ID, MAX_ATTEMPTS);
         assertEquals(Optional.of(false), commandCompleted);
     }
 
@@ -155,7 +156,7 @@ void isCommandCompletedFalseWhenMaxAttempts() {
         when(blockchainAdapterClient.getStatusForInitializeTaskRequest(CHAIN_TASK_ID))
                 .thenReturn(CommandStatus.PROCESSING);
         Optional<Boolean> commandCompleted = blockchainAdapterService.isCommandCompleted(
-                blockchainAdapterClient::getStatusForInitializeTaskRequest, CHAIN_TASK_ID, PERIOD, MAX_ATTEMPTS);
+                blockchainAdapterClient::getStatusForInitializeTaskRequest, CHAIN_TASK_ID, MAX_ATTEMPTS);
         assertEquals(Optional.empty(), commandCompleted);
     }
 
@@ -164,18 +165,20 @@ void isCommandCompletedFalseWhenFeignException() {
         when(blockchainAdapterClient.getStatusForFinalizeTaskRequest(CHAIN_TASK_ID))
                 .thenThrow(FeignException.class);
         Optional<Boolean> commandCompleted = blockchainAdapterService.isCommandCompleted(
-                blockchainAdapterClient::getStatusForFinalizeTaskRequest, CHAIN_TASK_ID, PERIOD, MAX_ATTEMPTS);
+                blockchainAdapterClient::getStatusForFinalizeTaskRequest, CHAIN_TASK_ID, MAX_ATTEMPTS);
         assertEquals(Optional.empty(), commandCompleted);
     }
 
     @Test
     void isCommandCompletedFalseWhenInterrupted() throws InterruptedException {
+        blockchainAdapterService = new BlockchainAdapterService(blockchainAdapterClient, Duration.ofSeconds(5), MAX_ATTEMPTS);
+
         when(blockchainAdapterClient.getStatusForFinalizeTaskRequest(CHAIN_TASK_ID))
                 .thenReturn(CommandStatus.PROCESSING);
         ExecutorService service = Executors.newSingleThreadExecutor();
         Future<?> future = service.submit(() ->
                 blockchainAdapterService.isCommandCompleted(blockchainAdapterClient::getStatusForFinalizeTaskRequest,
-                        CHAIN_TASK_ID, 5000L, MAX_ATTEMPTS));
+                        CHAIN_TASK_ID, MAX_ATTEMPTS));
         Thread.sleep(1000L);
         future.cancel(true);
         assertThrows(CancellationException.class, future::get);