More shared source updates (Azure#35642)

* More shared source updates

* add temp backcompat

* Add translation between old and new strategy types

* fix maps

* Update ZeroPollingStrategy

* Fix tests

Author: JoshLove-msft

sdk/core/Azure.Core.TestFramework/src/Instrumentation/ZeroPollingStrategy.cs

@@ -8,11 +8,11 @@
 namespace Azure.Core
 {
     /// <summary>
-    /// Implementation of a <see cref="DelayStrategyInternal"/> with 0 interval.
+    /// Implementation of a delay strategy with 0 interval.
     /// This is normally used for testing, like record playback.
     /// </summary>
-    internal class ZeroPollingStrategy : DelayStrategyInternal
+    internal class ZeroPollingStrategy : DelayStrategy
     {
-        public override TimeSpan GetNextDelay(Response response, TimeSpan? suggestedInterval) => TimeSpan.Zero;
+        protected override TimeSpan GetNextDelayCore(Response? response, int retryNumber) => TimeSpan.Zero;
     }
 }

sdk/core/Azure.Core/src/Shared/OperationInternal.cs

@@ -63,34 +63,50 @@ internal class OperationInternal : OperationInternalBase
         /// <summary>
         /// Initializes a new instance of the <see cref="OperationInternal"/> class.
         /// </summary>
-        /// <param name="clientDiagnostics">Used for diagnostic scope and exception creation. This is expected to be the instance created during the construction of your main client.</param>
         /// <param name="operation">The long-running operation making use of this class. Passing "<c>this</c>" is expected.</param>
+        /// <param name="clientDiagnostics">Used for diagnostic scope and exception creation. This is expected to be the instance created during the construction of your main client.</param>
         /// <param name="rawResponse">
-        /// The initial value of <see cref="OperationInternalBase.RawResponse"/>. Usually, long-running operation objects can be instantiated in two ways:
-        /// <list type="bullet">
-        ///   <item>
-        ///   When calling a client's "<c>Start&lt;OperationName&gt;</c>" method, a service call is made to start the operation, and an <see cref="Operation"/> instance is returned.
-        ///   In this case, the response received from this service call can be passed here.
-        ///   </item>
-        ///   <item>
-        ///   When a user instantiates an <see cref="Operation"/> directly using a public constructor, there's no previous service call. In this case, passing <c>null</c> is expected.
-        ///   </item>
-        /// </list>
+        ///     The initial value of <see cref="OperationInternalBase.RawResponse"/>. Usually, long-running operation objects can be instantiated in two ways:
+        ///     <list type="bullet">
+        ///         <item>
+        ///             When calling a client's "<c>Start&lt;OperationName&gt;</c>" method, a service call is made to start the operation, and an <see cref="Operation"/> instance is returned.
+        ///             In this case, the response received from this service call can be passed here.
+        ///         </item>
+        ///         <item>
+        ///             When a user instantiates an <see cref="Operation"/> directly using a public constructor, there's no previous service call. In this case, passing <c>null</c> is expected.
+        ///         </item>
+        ///     </list>
         /// </param>
         /// <param name="operationTypeName">
-        /// The type name of the long-running operation making use of this class. Used when creating diagnostic scopes. If left <c>null</c>, the type name will be inferred based on the
-        /// parameter <paramref name="operation"/>.
+        ///     The type name of the long-running operation making use of this class. Used when creating diagnostic scopes. If left <c>null</c>, the type name will be inferred based on the
+        ///     parameter <paramref name="operation"/>.
         /// </param>
         /// <param name="scopeAttributes">The attributes to use during diagnostic scope creation.</param>
-        /// <param name="fallbackStrategy">The fallback delay strategy when Retry-After header is not present.  When it is present, the longer of the two delays will be used. Default is <see cref="ConstantDelayStrategy"/>.</param>
+        /// <param name="fallbackStrategy"> The delay strategy to use. Default is <see cref="FixedDelayWithNoJitterStrategy"/>.</param>
+        public OperationInternal(IOperation operation,
+            ClientDiagnostics clientDiagnostics,
+            Response rawResponse,
+            string? operationTypeName = null,
+            IEnumerable<KeyValuePair<string, string>>? scopeAttributes = null,
+            DelayStrategy? fallbackStrategy = null)
+            :base(clientDiagnostics, operationTypeName ?? operation.GetType().Name, scopeAttributes, fallbackStrategy)
+        {
+            _internalOperation = new OperationInternal<VoidValue>(new OperationToOperationOfTProxy(operation), clientDiagnostics, rawResponse, operationTypeName ?? operation.GetType().Name, scopeAttributes, fallbackStrategy);
+        }
+
+        // TEMP backcompat with AutoRest
         public OperationInternal(
             ClientDiagnostics clientDiagnostics,
             IOperation operation,
             Response rawResponse,
             string? operationTypeName = null,
             IEnumerable<KeyValuePair<string, string>>? scopeAttributes = null,
             DelayStrategyInternal? fallbackStrategy = null)
-            :base(clientDiagnostics, operationTypeName ?? operation.GetType().Name, scopeAttributes, fallbackStrategy)
+            : base(
+                clientDiagnostics,
+                operationTypeName ?? operation.GetType().Name,
+                scopeAttributes,
+                fallbackStrategy is ExponentialDelayStrategy ? new SequentialDelayStrategy() : (fallbackStrategy is ConstantDelayStrategy) ? new FixedDelayWithNoJitterStrategy() : null)
         {
             _internalOperation = new OperationInternal<VoidValue>(clientDiagnostics, new OperationToOperationOfTProxy(operation), rawResponse, operationTypeName ?? operation.GetType().Name, scopeAttributes, fallbackStrategy);
         }

sdk/core/Azure.Core/src/Shared/OperationInternalBase.cs

@@ -16,7 +16,7 @@ internal abstract class OperationInternalBase
     {
         private readonly ClientDiagnostics _diagnostics;
         private readonly IReadOnlyDictionary<string, string>? _scopeAttributes;
-        private readonly DelayStrategyInternal? _fallbackStrategy;
+        private readonly DelayStrategy? _fallbackStrategy;
         private readonly AsyncLockWithValue<Response> _responseLock;
 
         private readonly string _waitForCompletionResponseScopeName;
@@ -34,7 +34,7 @@ protected OperationInternalBase(Response rawResponse)
             _responseLock = new AsyncLockWithValue<Response>(rawResponse);
         }
 
-        protected OperationInternalBase(ClientDiagnostics clientDiagnostics, string operationTypeName, IEnumerable<KeyValuePair<string, string>>? scopeAttributes = null, DelayStrategyInternal? fallbackStrategy = null)
+        protected OperationInternalBase(ClientDiagnostics clientDiagnostics, string operationTypeName, IEnumerable<KeyValuePair<string, string>>? scopeAttributes = null, DelayStrategy? fallbackStrategy = null)
         {
             _diagnostics = clientDiagnostics;
             _updateStatusScopeName = $"{operationTypeName}.{nameof(UpdateStatus)}";
@@ -107,7 +107,7 @@ public Response UpdateStatus(CancellationToken cancellationToken) =>
         /// <summary>
         /// Periodically calls <see cref="UpdateStatusAsync(CancellationToken)"/> until the long-running operation completes.
         /// After each service call, a retry-after header may be returned to communicate that there is no reason to poll
-        /// for status change until the specified time has passed.  The maximum of the retry after value and the fallback <see cref="DelayStrategyInternal"/>
+        /// for status change until the specified time has passed.  The maximum of the retry after value and the fallback strategy
         /// is then used as the wait interval.
         /// Headers supported are: "Retry-After", "retry-after-ms", and "x-ms-retry-after-ms",
         /// <example>Usage example:
@@ -147,7 +147,7 @@ public async ValueTask<Response> WaitForCompletionResponseAsync(TimeSpan polling
         /// <summary>
         /// Periodically calls <see cref="UpdateStatus(CancellationToken)"/> until the long-running operation completes.
         /// After each service call, a retry-after header may be returned to communicate that there is no reason to poll
-        /// for status change until the specified time has passed.  The maximum of the retry after value and the fallback <see cref="DelayStrategyInternal"/>
+        /// for status change until the specified time has passed.  The maximum of the retry after value and the fallback strategy
         /// is then used as the wait interval.
         /// Headers supported are: "Retry-After", "retry-after-ms", and "x-ms-retry-after-ms",
         /// and "x-ms-retry-after-ms".

sdk/core/Azure.Core/src/Shared/OperationInternalOfT.cs

@@ -72,39 +72,59 @@ internal class OperationInternal<T> : OperationInternalBase
         /// <summary>
         /// Initializes a new instance of the <see cref="OperationInternal{T}"/> class.
         /// </summary>
-        /// <param name="clientDiagnostics">Used for diagnostic scope and exception creation. This is expected to be the instance created during the construction of your main client.</param>
         /// <param name="operation">The long-running operation making use of this class. Passing "<c>this</c>" is expected.</param>
+        /// <param name="clientDiagnostics">Used for diagnostic scope and exception creation. This is expected to be the instance created during the construction of your main client.</param>
         /// <param name="rawResponse">
-        /// The initial value of <see cref="OperationInternalBase.RawResponse"/>. Usually, long-running operation objects can be instantiated in two ways:
-        /// <list type="bullet">
-        ///   <item>
-        ///   When calling a client's "<c>Start&lt;OperationName&gt;</c>" method, a service call is made to start the operation, and an <see cref="Operation{T}"/> instance is returned.
-        ///   In this case, the response received from this service call can be passed here.
-        ///   </item>
-        ///   <item>
-        ///   When a user instantiates an <see cref="Operation{T}"/> directly using a public constructor, there's no previous service call. In this case, passing <c>null</c> is expected.
-        ///   </item>
-        /// </list>
+        ///     The initial value of <see cref="OperationInternalBase.RawResponse"/>. Usually, long-running operation objects can be instantiated in two ways:
+        ///     <list type="bullet">
+        ///         <item>
+        ///             When calling a client's "<c>Start&lt;OperationName&gt;</c>" method, a service call is made to start the operation, and an <see cref="Operation{T}"/> instance is returned.
+        ///             In this case, the response received from this service call can be passed here.
+        ///         </item>
+        ///         <item>
+        ///             When a user instantiates an <see cref="Operation{T}"/> directly using a public constructor, there's no previous service call. In this case, passing <c>null</c> is expected.
+        ///         </item>
+        ///     </list>
         /// </param>
         /// <param name="operationTypeName">
-        /// The type name of the long-running operation making use of this class. Used when creating diagnostic scopes. If left <c>null</c>, the type name will be inferred based on the
-        /// parameter <paramref name="operation"/>.
+        ///     The type name of the long-running operation making use of this class. Used when creating diagnostic scopes. If left <c>null</c>, the type name will be inferred based on the
+        ///     parameter <paramref name="operation"/>.
         /// </param>
         /// <param name="scopeAttributes">The attributes to use during diagnostic scope creation.</param>
-        /// <param name="fallbackStrategy">The fallback delay strategy when Retry-After header is not present.  When it is present, the longer of the two delays will be used. Default is <see cref="ConstantDelayStrategy"/>.</param>
+        /// <param name="fallbackStrategy">The delay strategy when Retry-After header is not present.  When it is present, the longer of the two delays will be used.
+        ///     Default is <see cref="FixedDelayWithNoJitterStrategy"/>.</param>
+        public OperationInternal(IOperation<T> operation,
+            ClientDiagnostics clientDiagnostics,
+            Response rawResponse,
+            string? operationTypeName = null,
+            IEnumerable<KeyValuePair<string, string>>? scopeAttributes = null,
+            DelayStrategy? fallbackStrategy = null)
+            : base(clientDiagnostics, operationTypeName ?? operation.GetType().Name, scopeAttributes, fallbackStrategy)
+        {
+            _operation = operation;
+            _rawResponse = rawResponse;
+            _stateLock = new AsyncLockWithValue<OperationState<T>>();
+        }
+
+        //TEMP for backcompat with AutoRest
         public OperationInternal(
             ClientDiagnostics clientDiagnostics,
             IOperation<T> operation,
             Response rawResponse,
             string? operationTypeName = null,
             IEnumerable<KeyValuePair<string, string>>? scopeAttributes = null,
             DelayStrategyInternal? fallbackStrategy = null)
-            : base(clientDiagnostics, operationTypeName ?? operation.GetType().Name, scopeAttributes, fallbackStrategy)
+            : base(
+                clientDiagnostics,
+                operationTypeName ?? operation.GetType().Name,
+                scopeAttributes,
+                fallbackStrategy is ExponentialDelayStrategy ? new SequentialDelayStrategy() : (fallbackStrategy is ConstantDelayStrategy) ? new FixedDelayWithNoJitterStrategy() : null)
         {
             _operation = operation;
             _rawResponse = rawResponse;
             _stateLock = new AsyncLockWithValue<OperationState<T>>();
         }
+        //end TEMP for backcompat with AutoRest
 
         private OperationInternal(OperationState<T> finalState)
             : base(finalState.RawResponse)
@@ -160,8 +180,7 @@ public T Value
         /// <summary>
         /// Periodically calls <see cref="OperationInternalBase.UpdateStatusAsync(CancellationToken)"/> until the long-running operation completes.
         /// After each service call, a retry-after header may be returned to communicate that there is no reason to poll
-        /// for status change until the specified time has passed.  The maximum of the retry after value and the fallback <see cref="DelayStrategyInternal"/>
-        /// is then used as the wait interval.
+        /// for status change until the specified time has passed.
         /// Headers supported are: "Retry-After", "retry-after-ms", and "x-ms-retry-after-ms",
         /// <example>Usage example:
         /// <code>
@@ -200,8 +219,7 @@ public async ValueTask<Response<T>> WaitForCompletionAsync(TimeSpan pollingInter
         /// <summary>
         /// Periodically calls <see cref="OperationInternalBase.UpdateStatus(CancellationToken)"/> until the long-running operation completes.
         /// After each service call, a retry-after header may be returned to communicate that there is no reason to poll
-        /// for status change until the specified time has passed.  The maximum of the retry after value and the fallback <see cref="DelayStrategyInternal"/>
-        /// is then use as the wait interval.
+        /// for status change until the specified time has passed.
         /// Headers supported are: "Retry-After", "retry-after-ms", and "x-ms-retry-after-ms",
         /// <example>Usage example:
         /// <code>
@@ -218,11 +236,8 @@ public Response<T> WaitForCompletion(CancellationToken cancellationToken)
 
         /// <summary>
         /// Periodically calls <see cref="OperationInternalBase.UpdateStatus(CancellationToken)"/> until the long-running operation completes. The interval
-        /// between calls is defined by the property <see cref="ConstantDelayStrategy.DefaultPollingInterval"/>, but it can change based on information returned
-        /// from the server. After each service call, a retry-after header may be returned to communicate that there is no reason to poll
-        /// for status change until the specified time has passed. In this case, the maximum value between the <see cref="ConstantDelayStrategy.DefaultPollingInterval"/>
-        /// property and the retry-after header is chosen as the wait interval. Headers supported are: "Retry-After", "retry-after-ms",
-        /// and "x-ms-retry-after-ms".
+        /// between calls is defined by the <see cref="FixedDelayWithNoJitterStrategy"/>, which takes into account any retry-after header that is returned
+        /// from the server.
         /// <example>Usage example:
         /// <code>
         ///   public async ValueTask&lt;Response&lt;T&gt;&gt; WaitForCompletionAsync(CancellationToken cancellationToken) =>