feat(java): waitForTask APIC-478

clients/algoliasearch-client-java-2/algoliasearch-core/src/main/java/com/algolia/exceptions/AlgoliaRetriesExceededException.java

@@ -0,0 +1,22 @@
+package com.algolia.exceptions;
+
+/**
+ * Exception thrown when an error occurs during the waitForTask strategy. For example: maximum
+ * number of retry exceeded
+ */
+public class AlgoliaRetriesExceededException extends AlgoliaRuntimeException {
+
+  public static final long serialVersionUID = 1L;
+
+  public AlgoliaRetriesExceededException(String message, Throwable cause) {
+    super(message, cause);
+  }
+
+  public AlgoliaRetriesExceededException(String message) {
+    super(message);
+  }
+
+  public AlgoliaRetriesExceededException(Throwable cause) {
+    super(cause);
+  }
+}

clients/algoliasearch-client-java-2/algoliasearch-core/src/main/java/com/algolia/utils/TaskUtils.java

@@ -0,0 +1,62 @@
+package com.algolia.utils;
+
+import com.algolia.exceptions.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.function.IntUnaryOperator;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+public class TaskUtils {
+
+  public static <TResponse> void retryUntil(
+    Supplier<CompletableFuture<TResponse>> func,
+    Predicate<TResponse> validate,
+    int maxTrial,
+    IntUnaryOperator timeout
+  ) throws AlgoliaRuntimeException {
+    int retryCount = 0;
+    while (retryCount < maxTrial) {
+      try {
+        TResponse resp = func.get().get();
+        System.out.println(resp);
+        if (validate.test(resp)) {
+          return;
+        }
+      } catch (InterruptedException | ExecutionException e) {
+        // if the task is interrupted, just return
+        return;
+      }
+      try {
+        System.out.println("sleeping for " + timeout.applyAsInt(retryCount));
+        Thread.sleep(timeout.applyAsInt(retryCount));
+      } catch (InterruptedException ignored) {
+        // Restore interrupted state...
+        Thread.currentThread().interrupt();
+      }
+
+      retryCount++;
+    }
+    throw new AlgoliaRetriesExceededException(
+      "The maximum number of trials exceeded. (" +
+      (retryCount + 1) +
+      "/" +
+      maxTrial +
+      ")"
+    );
+  }
+
+  public static <TResponse> void retryUntil(
+    Supplier<CompletableFuture<TResponse>> func,
+    Predicate<TResponse> validate
+  ) {
+    retryUntil(
+      func,
+      validate,
+      50,
+      (int retries) -> {
+        return Math.min(retries * 200, 5000);
+      }
+    );
+  }
+}

clients/algoliasearch-client-javascript/packages/client-common/src/createRetryablePromise.ts

@@ -12,8 +12,8 @@ import type { CreateRetryablePromiseOptions } from './types/CreateRetryablePromi
 export function createRetryablePromise<TResponse>({
   func,
   validate,
-  maxTrial = 10,
-  timeout = (retryCount: number): number => Math.min(retryCount * 10, 1000),
+  maxTrial = 50,
+  timeout = (retryCount: number): number => Math.min(retryCount * 200, 5000),
 }: CreateRetryablePromiseOptions<TResponse>): Promise<TResponse> {
   let retryCount = 0;
   const retry = (): Promise<TResponse> => {

generators/src/main/java/com/algolia/codegen/AlgoliaJavaGenerator.java

@@ -50,6 +50,10 @@ public Map<String, Object> postProcessOperationsWithModels(
         Utils.getClientNameKebabCase(results),
         additionalProperties
       );
+      additionalProperties.put(
+        "isSearchClient",
+        Utils.getClientNameKebabCase(results).equals("search")
+      );
       additionalProperties.put(
         "packageVersion",
         Utils.getClientConfigField("java", "packageVersion")

templates/java/libraries/okhttp-gson/api.mustache

@@ -216,5 +216,19 @@ public class {{classname}} extends ApiClient {
   }
   {{/optionalParams.0}}
   {{/operation}}
+
+  {{#isSearchClient}}
+  public void waitForTask(String indexName, Long taskID, RequestOptions requestOptions) {
+    TaskUtils.retryUntil(() -> {
+      return this.getTaskAsync(indexName, taskID, requestOptions);
+    }, (GetTaskResponse task) -> {
+      return task.getStatus() == TaskStatus.PUBLISHED;
+    });
+  }
+
+  public void waitForTask(String indexName, Long taskID) {
+    this.waitForTask(indexName, taskID, null);
+  }
+  {{/isSearchClient}}
 }
 {{/operations}}