WIP: System.ClientModel and Azure.Core 2.0

sdk/core/Azure.Core.TestFramework/src/Azure.Core.TestFramework.csproj

@@ -4,7 +4,6 @@
     <IncludeOperationsSharedSource>true</IncludeOperationsSharedSource>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="Azure.Core" />
     <PackageReference Include="Azure.Identity" />
     <PackageReference Include="Newtonsoft.Json" />
     <PackageReference Include="NUnit" />
@@ -40,4 +39,8 @@
       <_Parameter2>$(NuGetPackageRoot)\azure.sdk.tools.testproxy\$(TestProxyVersion)\tools\net6.0\any\Azure.Sdk.Tools.TestProxy.dll</_Parameter2>
     </AssemblyAttribute>
   </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\Azure.Core\src\Azure.Core.csproj" />
+  </ItemGroup>
 </Project>

sdk/core/Azure.Core/samples/Configuration.md

@@ -36,11 +36,11 @@ internal class GlobalTimeoutRetryPolicy : RetryPolicy
         _timeout = timeout;
     }
 
-    protected internal override bool ShouldRetry(HttpMessage message, Exception exception)
+    protected override bool ShouldRetry(HttpMessage message, Exception exception)
     {
         return ShouldRetryInternalAsync(message, exception, false).EnsureCompleted();
     }
-    protected internal override ValueTask<bool> ShouldRetryAsync(HttpMessage message, Exception exception)
+    protected override ValueTask<bool> ShouldRetryAsync(HttpMessage message, Exception exception)
     {
         return ShouldRetryInternalAsync(message, exception, true);
     }

sdk/core/Azure.Core/src/Azure.Core.csproj

@@ -73,6 +73,11 @@
     <Compile Include="Shared\CancellationHelper.cs" />
     <Compile Include="Shared\OperationPoller.cs" />
     <Compile Include="Shared\TypeReferenceTypeAttribute.cs" />
+    <Compile Include="..\..\System.ClientModel\src\Internal\BitVector640.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\System.ClientModel\src\System.ClientModel.csproj" />
   </ItemGroup>
 
 </Project>

sdk/core/Azure.Core/src/AzureKeyCredential.cs

@@ -1,28 +1,30 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+using System.ClientModel;
 using System.ComponentModel;
-using System.Threading;
-using Azure.Core;
 
 namespace Azure
 {
     /// <summary>
     /// Key credential used to authenticate to an Azure Service.
     /// It provides the ability to update the key without creating a new client.
     /// </summary>
-    public class AzureKeyCredential
+    public class AzureKeyCredential : ApiKeyCredential
     {
-        private string _key;
-
         /// <summary>
         /// Key used to authenticate to an Azure service.
         /// </summary>
         [EditorBrowsable(EditorBrowsableState.Never)]
         public string Key
         {
-            get => Volatile.Read(ref _key);
-            private set => Volatile.Write(ref _key, value);
+            get
+            {
+                Deconstruct(out string key);
+                return key;
+            }
+
+            private set => Update(value);
         }
 
         /// <summary>
@@ -35,26 +37,8 @@ public string Key
         /// <exception cref="System.ArgumentException">
         /// Thrown when the <paramref name="key"/> is empty.
         /// </exception>
-#pragma warning disable CS8618 // Non-nullable field is uninitialized. Consider declaring as nullable.
-        public AzureKeyCredential(string key) => Update(key);
-#pragma warning restore CS8618 // Non-nullable field is uninitialized. Consider declaring as nullable.
-
-        /// <summary>
-        /// Updates the service key.
-        /// This is intended to be used when you've regenerated your service key
-        /// and want to update long lived clients.
-        /// </summary>
-        /// <param name="key">Key to authenticate the service against.</param>
-        /// <exception cref="System.ArgumentNullException">
-        /// Thrown when the <paramref name="key"/> is null.
-        /// </exception>
-        /// <exception cref="System.ArgumentException">
-        /// Thrown when the <paramref name="key"/> is empty.
-        /// </exception>
-        public void Update(string key)
+        public AzureKeyCredential(string key) : base(key)
         {
-            Argument.AssertNotNullOrEmpty(key, nameof(key));
-            Key = key;
         }
     }
 }

sdk/core/Azure.Core/src/ClientOptions.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using System;
+using System.ClientModel.Primitives;
 using System.Collections.Generic;
 using System.ComponentModel;
 using Azure.Core.Pipeline;
@@ -11,11 +12,15 @@ namespace Azure.Core
     /// <summary>
     /// Base type for all client option types, exposes various common client options like <see cref="Diagnostics"/>, <see cref="Retry"/>, <see cref="Transport"/>.
     /// </summary>
-    public abstract class ClientOptions
+    public abstract class ClientOptions : ClientPipelineOptions
     {
+        internal static readonly TimeSpan DefaultNetworkTimeout = TimeSpan.FromSeconds(100);
+
         private HttpPipelineTransport _transport;
         internal bool IsCustomTransportSet { get; private set; }
 
+        private HttpPipelinePolicy? _retryPolicy;
+
         /// <summary>
         /// Gets the default set of <see cref="ClientOptions"/>. Changes to the <see cref="Default"/> options would be reflected
         /// in new instances of <see cref="ClientOptions"/> type created after changes to <see cref="Default"/> were made.
@@ -71,11 +76,13 @@ internal ClientOptions(ClientOptions? clientOptions, DiagnosticsOptions? diagnos
         /// <summary>
         /// The <see cref="HttpPipelineTransport"/> to be used for this client. Defaults to an instance of <see cref="HttpClientTransport"/>.
         /// </summary>
-        public HttpPipelineTransport Transport
+        public new HttpPipelineTransport Transport
         {
             get => _transport;
             set
             {
+                AssertNotFrozen();
+
                 _transport = value ?? throw new ArgumentNullException(nameof(value));
                 IsCustomTransportSet = true;
             }
@@ -97,7 +104,16 @@ public HttpPipelineTransport Transport
         /// If <see cref="RetryPolicy.Process"/> is overridden or a custom <see cref="HttpPipelinePolicy"/> is specified,
         /// it is the implementer's responsibility to update the <see cref="HttpMessage.ProcessingContext"/> values.
         /// </summary>
-        public HttpPipelinePolicy? RetryPolicy { get; set; }
+        public new HttpPipelinePolicy? RetryPolicy
+        {
+            get => _retryPolicy;
+            set
+            {
+                AssertNotFrozen();
+
+                _retryPolicy = value;
+            }
+        }
 
         /// <summary>
         /// Adds an <see cref="HttpPipeline"/> policy into the client pipeline. The position of policy in the pipeline is controlled by the <paramref name="position"/> parameter.
@@ -108,6 +124,8 @@ public HttpPipelineTransport Transport
         /// <param name="position">The position of policy in the pipeline.</param>
         public void AddPolicy(HttpPipelinePolicy policy, HttpPipelinePosition position)
         {
+            AssertNotFrozen();
+
             if (position != HttpPipelinePosition.PerCall &&
                 position != HttpPipelinePosition.PerRetry &&
                 position != HttpPipelinePosition.BeforeTransport)
@@ -132,5 +150,16 @@ public void AddPolicy(HttpPipelinePolicy policy, HttpPipelinePosition position)
         /// <inheritdoc />
         [EditorBrowsable(EditorBrowsableState.Never)]
         public override string? ToString() => base.ToString();
+
+        /// <summary>
+        /// TBD.
+        /// </summary>
+        public override void Freeze()
+        {
+            Diagnostics.Freeze();
+            Retry.Freeze();
+
+            base.Freeze();
+        }
     }
 }

sdk/core/Azure.Core/src/DelayStrategy.cs

@@ -1,8 +1,6 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-#nullable enable
-
 using System;
 using Azure.Core.Pipeline;
 
@@ -11,15 +9,14 @@ namespace Azure.Core
     /// <summary>
     /// An abstraction to control delay behavior.
     /// </summary>
-#pragma warning disable AZC0012 // Avoid single word type names
     public abstract class DelayStrategy
-#pragma warning restore AZC0012 // Avoid single word type names
     {
+        internal const double DefaultJitterFactor = 0.2;
+
         private readonly Random _random = new ThreadSafeRandom();
         private readonly double _minJitterFactor;
         private readonly double _maxJitterFactor;
         private readonly TimeSpan _maxDelay;
-        internal const double DefaultJitterFactor = 0.2;
 
         /// <summary>
         /// Constructs a new instance of <see cref="DelayStrategy"/>. This constructor can be used by derived classes to customize the jitter factor and max delay.
@@ -29,10 +26,11 @@ public abstract class DelayStrategy
         /// delay used will be a random double between 0.8 and 1.2. If set to 0, no jitter will be applied.</param>
         protected DelayStrategy(TimeSpan? maxDelay = default, double jitterFactor = DefaultJitterFactor)
         {
+            _minJitterFactor = 1.0 - jitterFactor;
+            _maxJitterFactor = 1.0 + jitterFactor;
+
             // use same defaults as RetryOptions
-            _minJitterFactor = 1 - jitterFactor;
-            _maxJitterFactor = 1 + jitterFactor;
-            _maxDelay = maxDelay ?? TimeSpan.FromMinutes(1);
+            _maxDelay = maxDelay ?? RetryOptions.DefaultMaxDelay;
         }
 
         /// <summary>
@@ -45,19 +43,19 @@ public static DelayStrategy CreateExponentialDelayStrategy(
             TimeSpan? initialDelay = default,
             TimeSpan? maxDelay = default)
         {
-            return new ExponentialDelayStrategy(initialDelay ?? TimeSpan.FromSeconds(0.8), maxDelay ?? TimeSpan.FromMinutes(1));
+            initialDelay ??= RetryOptions.DefaultInitialDelay;
+            maxDelay ??= RetryOptions.DefaultMaxDelay;
+
+            return new ExponentialDelayStrategy(initialDelay, maxDelay);
         }
 
         /// <summary>
         /// Constructs a fixed delay with jitter.
         /// </summary>
         /// <param name="delay">The delay to use.</param>
         /// <returns>The <see cref="DelayStrategy"/> instance.</returns>
-        public static DelayStrategy CreateFixedDelayStrategy(
-            TimeSpan? delay = default)
-        {
-            return new FixedDelayStrategy(delay ?? TimeSpan.FromSeconds(0.8));
-        }
+        public static DelayStrategy CreateFixedDelayStrategy(TimeSpan? delay = default)
+            => new FixedDelayStrategy(delay ?? RetryOptions.DefaultInitialDelay);
 
         /// <summary>
         /// Gets the next delay interval. Implement this method to provide custom delay logic.
@@ -74,12 +72,16 @@ public static DelayStrategy CreateFixedDelayStrategy(
         /// <param name="response">The response, if any, returned from the service.</param>
         /// <param name="retryNumber">The retry number.</param>
         /// <returns>A <see cref="TimeSpan"/> representing the next delay interval.</returns>
-        public TimeSpan GetNextDelay(Response? response, int retryNumber) =>
-            Max(
-                response?.Headers.RetryAfter ?? TimeSpan.Zero,
-                Min(
-                    ApplyJitter(GetNextDelayCore(response, retryNumber)),
-                    _maxDelay));
+        public TimeSpan GetNextDelay(Response? response, int retryNumber)
+        {
+            TimeSpan retryAfter = response?.Headers.RetryAfter ?? TimeSpan.Zero;
+
+            TimeSpan defaultDelay = GetNextDelayCore(response, retryNumber);
+            TimeSpan defaultWithJitter = ApplyJitter(defaultDelay);
+            TimeSpan cappedDefault = Min(defaultWithJitter, _maxDelay);
+
+            return Max(retryAfter, cappedDefault);
+        }
 
         private TimeSpan ApplyJitter(TimeSpan delay)
         {
@@ -99,14 +101,16 @@ private TimeSpan ApplyJitter(TimeSpan delay)
         /// <param name="val1">The first value.</param>
         /// <param name="val2">The second value.</param>
         /// <returns>The maximum of the two <see cref="TimeSpan"/> values.</returns>
-        protected static TimeSpan Max(TimeSpan val1, TimeSpan val2) => val1 > val2 ? val1 : val2;
+        protected static TimeSpan Max(TimeSpan val1, TimeSpan val2)
+            => val1 > val2 ? val1 : val2;
 
         /// <summary>
         /// Gets the minimum of two <see cref="TimeSpan"/> values.
         /// </summary>
         /// <param name="val1">The first value.</param>
         /// <param name="val2">The second value.</param>
         /// <returns>The minimum of the two <see cref="TimeSpan"/> values.</returns>
-        protected static TimeSpan Min(TimeSpan val1, TimeSpan val2) => val1 < val2 ? val1 : val2;
+        protected static TimeSpan Min(TimeSpan val1, TimeSpan val2)
+            => val1 < val2 ? val1 : val2;
     }
 }