Add sync polling support to azure-core v2 (#44670)

* Add sync polling support to core-v2

* update javadocs

* address pr comments

* fix formatting

Author: srnagar

sdk/corev2/azure-core/pom.xml

@@ -75,7 +75,7 @@
     <dependency>
       <groupId>io.clientcore</groupId>
       <artifactId>core</artifactId>
-      <version>1.0.0-beta.7</version> <!-- {x-version-update;io.clientcore:core;dependency} -->
+      <version>1.0.0-beta.8</version> <!-- {x-version-update;unreleased_io.clientcore:core;dependency} -->
     </dependency>
 
     <dependency>

sdk/corev2/azure-core/src/main/java/com/azure/v2/core/http/polling/ChainedPollingStrategy.java

@@ -0,0 +1,98 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+package com.azure.v2.core.http.polling;
+
+import io.clientcore.core.http.models.Response;
+import io.clientcore.core.instrumentation.logging.ClientLogger;
+import io.clientcore.core.models.binarydata.BinaryData;
+
+import java.lang.reflect.Type;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * A polling strategy that chains multiple polling strategies, finds the first strategy that can
+ * poll the current long-running operation, and polls with that strategy.
+ *
+ * @param <T> the type of the response type from a polling call, or BinaryData if raw response body should be kept
+ * @param <U> the type of the final result object to deserialize into, or BinaryData if raw response body should be
+ * kept
+ */
+public final class ChainedPollingStrategy<T, U> implements PollingStrategy<T, U> {
+    private static final ClientLogger LOGGER = new ClientLogger(ChainedPollingStrategy.class);
+
+    private final List<PollingStrategy<T, U>> pollingStrategies;
+    private PollingStrategy<T, U> pollableStrategy = null;
+
+    /**
+     * Creates a chained polling strategy with a list of polling strategies.
+     *
+     * @param strategies the list of polling strategies
+     * @throws NullPointerException If {@code strategies} is null.
+     * @throws IllegalArgumentException If {@code strategies} is an empty list.
+     */
+    public ChainedPollingStrategy(List<PollingStrategy<T, U>> strategies) {
+        Objects.requireNonNull(strategies, "'strategies' cannot be null.");
+        if (strategies.isEmpty()) {
+            throw LOGGER.logThrowableAsError(new IllegalArgumentException("'strategies' cannot be empty."));
+        }
+        this.pollingStrategies = Collections.unmodifiableList(strategies);
+    }
+
+    @Override
+    public boolean canPoll(Response<BinaryData> initialResponse) {
+        // Find the first strategy that can poll in series so that
+        // pollableStrategy is only set once
+        for (PollingStrategy<T, U> strategy : pollingStrategies) {
+            if (strategy.canPoll(initialResponse)) {
+                this.pollableStrategy = strategy;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @throws NullPointerException if {@link #canPoll(Response)} is not called prior to this, or if it returns false.
+     */
+    @Override
+    public U getResult(PollingContext<T> context, Type resultType) {
+        return pollableStrategy.getResult(context, resultType);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @throws NullPointerException if {@link #canPoll(Response)} is not called prior to this, or if it returns false.
+     */
+    @Override
+    public PollResponse<T> onInitialResponse(Response<BinaryData> response, PollingContext<T> pollingContext,
+        Type pollResponseType) {
+        return pollableStrategy.onInitialResponse(response, pollingContext, pollResponseType);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @throws NullPointerException if {@link #canPoll(Response)} is not called prior to this, or if it returns false.
+     */
+    @Override
+    public PollResponse<T> poll(PollingContext<T> context, Type pollResponseType) {
+        return pollableStrategy.poll(context, pollResponseType);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @throws NullPointerException if {@link #canPoll(Response)} is not called prior to this, or if it returns false.
+     */
+    @Override
+    public T cancel(PollingContext<T> pollingContext, PollResponse<T> initialResponse) {
+        return pollableStrategy.cancel(pollingContext, initialResponse);
+    }
+}

sdk/corev2/azure-core/src/main/java/com/azure/v2/core/http/polling/DefaultPollingStrategy.java

@@ -0,0 +1,128 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+package com.azure.v2.core.http.polling;
+
+import io.clientcore.core.http.models.Response;
+import io.clientcore.core.http.pipeline.HttpPipeline;
+import io.clientcore.core.models.binarydata.BinaryData;
+import io.clientcore.core.serialization.json.JsonSerializer;
+import io.clientcore.core.utils.Context;
+
+import java.lang.reflect.Type;
+import java.util.Arrays;
+import java.util.Objects;
+
+/**
+ * The default polling strategy to use with Azure data plane services. The default polling strategy will
+ * attempt three known strategies, {@link OperationResourcePollingStrategy}, {@link LocationPollingStrategy},
+ * and {@link StatusCheckPollingStrategy}, in this order. The first strategy that can poll on the initial response
+ * will be used. The created chained polling strategy is capable of handling most of the polling scenarios in Azure.
+ *
+ * @param <T> the type of the response type from a polling call, or BinaryData if raw response body should be kept
+ * @param <U> the type of the final result object to deserialize into, or BinaryData if raw response body should be
+ * kept
+ */
+public final class DefaultPollingStrategy<T, U> implements PollingStrategy<T, U> {
+    private final ChainedPollingStrategy<T, U> chainedPollingStrategy;
+
+    /**
+     * Creates a chained polling strategy with three known polling strategies,
+     * {@link OperationResourcePollingStrategy}, {@link LocationPollingStrategy}, and
+     * {@link StatusCheckPollingStrategy}, in this order, with a JSON serializer.
+     *
+     * @param httpPipeline an instance of {@link HttpPipeline} to send requests with
+     * @throws NullPointerException If {@code httpPipeline} is null.
+     */
+    public DefaultPollingStrategy(HttpPipeline httpPipeline) {
+        this(httpPipeline, new JsonSerializer(), Context.none());
+    }
+
+    /**
+     * Creates a chained polling strategy with three known polling strategies,
+     * {@link OperationResourcePollingStrategy}, {@link LocationPollingStrategy}, and
+     * {@link StatusCheckPollingStrategy}, in this order, with a JSON serializer.
+     *
+     * @param httpPipeline an instance of {@link HttpPipeline} to send requests with
+     * @param serializer a custom serializer for serializing and deserializing polling responses
+     * @throws NullPointerException If {@code httpPipeline} is null.
+     */
+    public DefaultPollingStrategy(HttpPipeline httpPipeline, JsonSerializer serializer) {
+        this(httpPipeline, serializer, Context.none());
+    }
+
+    /**
+     * Creates a chained polling strategy with three known polling strategies,
+     * {@link OperationResourcePollingStrategy}, {@link LocationPollingStrategy}, and
+     * {@link StatusCheckPollingStrategy}, in this order, with a JSON serializer.
+     *
+     * @param httpPipeline an instance of {@link HttpPipeline} to send requests with
+     * @param serializer a custom serializer for serializing and deserializing polling responses
+     * @param context an instance of {@link Context}
+     * @throws NullPointerException If {@code httpPipeline} is null.
+     */
+    public DefaultPollingStrategy(HttpPipeline httpPipeline, JsonSerializer serializer, Context context) {
+        this(httpPipeline, null, serializer, context);
+    }
+
+    /**
+     * Creates a chained polling strategy with three known polling strategies,
+     * {@link OperationResourcePollingStrategy}, {@link LocationPollingStrategy}, and
+     * {@link StatusCheckPollingStrategy}, in this order, with a JSON serializer.
+     *
+     * @param httpPipeline an instance of {@link HttpPipeline} to send requests with.
+     * @param endpoint an endpoint for creating an absolute path when the path itself is relative.
+     * @param serializer a custom serializer for serializing and deserializing polling responses.
+     * @param context an instance of {@link Context}.
+     * @throws NullPointerException If {@code httpPipeline} is null.
+     */
+    public DefaultPollingStrategy(HttpPipeline httpPipeline, String endpoint, JsonSerializer serializer,
+        Context context) {
+        this.chainedPollingStrategy = new ChainedPollingStrategy<>(
+            Arrays.asList(new OperationResourcePollingStrategy<>(httpPipeline, endpoint, serializer, null, context),
+                new LocationPollingStrategy<>(httpPipeline, endpoint, serializer, context),
+                new StatusCheckPollingStrategy<>(serializer)));
+    }
+
+    /**
+     * Creates a chained polling strategy with 3 known polling strategies, {@link OperationResourcePollingStrategy},
+     * {@link LocationPollingStrategy}, and {@link StatusCheckPollingStrategy}, in this order, with a custom
+     * serializer.
+     *
+     * @param pollingStrategyOptions options to configure this polling strategy.
+     * @throws NullPointerException If {@code pollingStrategyOptions} is null.
+     */
+    public DefaultPollingStrategy(PollingStrategyOptions pollingStrategyOptions) {
+        Objects.requireNonNull(pollingStrategyOptions, "'pollingStrategyOptions' cannot be null");
+        this.chainedPollingStrategy = new ChainedPollingStrategy<>(
+            Arrays.asList(new OperationResourcePollingStrategy<>(null, pollingStrategyOptions),
+                new LocationPollingStrategy<>(pollingStrategyOptions),
+                new StatusCheckPollingStrategy<>(pollingStrategyOptions.getSerializer())));
+    }
+
+    @Override
+    public U getResult(PollingContext<T> pollingContext, Type resultType) {
+        return chainedPollingStrategy.getResult(pollingContext, resultType);
+    }
+
+    @Override
+    public boolean canPoll(Response<BinaryData> initialResponse) {
+        return chainedPollingStrategy.canPoll(initialResponse);
+    }
+
+    @Override
+    public PollResponse<T> onInitialResponse(Response<BinaryData> response, PollingContext<T> pollingContext,
+        Type pollResponseType) {
+        return chainedPollingStrategy.onInitialResponse(response, pollingContext, pollResponseType);
+    }
+
+    @Override
+    public PollResponse<T> poll(PollingContext<T> pollingContext, Type pollResponseType) {
+        return chainedPollingStrategy.poll(pollingContext, pollResponseType);
+    }
+
+    @Override
+    public T cancel(PollingContext<T> pollingContext, PollResponse<T> initialResponse) {
+        return chainedPollingStrategy.cancel(pollingContext, initialResponse);
+    }
+}