Merge pull request #2165 from microsoft/fix/static-factories

fix/static factories

Author: baywet

src/Microsoft.OpenApi.Hidi/OpenApiService.cs

@@ -40,12 +40,6 @@ namespace Microsoft.OpenApi.Hidi
 {
     internal static class OpenApiService
     {
-        static OpenApiService()
-        {
-            OpenApiReaderRegistry.RegisterReader(OpenApiConstants.Yaml, new OpenApiYamlReader());
-            OpenApiReaderRegistry.RegisterReader(OpenApiConstants.Yml, new OpenApiYamlReader());
-        }
-
         /// <summary>
         /// Implementation of the transform command
         /// </summary>
@@ -392,8 +386,10 @@ private static async Task<ReadResult> ParseOpenApiAsync(string openApiFile, bool
                     LoadExternalRefs = inlineExternal,
                     BaseUrl = openApiFile.StartsWith("http", StringComparison.OrdinalIgnoreCase) ?
                         new(openApiFile) :
-                        new Uri("file://" + new FileInfo(openApiFile).DirectoryName + Path.DirectorySeparatorChar)
+                        new Uri("file://" + new FileInfo(openApiFile).DirectoryName + Path.DirectorySeparatorChar),
+                    HttpClient = httpClient.Value
                 };
+                settings.AddYamlReader();
 
                 result = await OpenApiDocument.LoadAsync(stream, settings: settings, cancellationToken: cancellationToken).ConfigureAwait(false);
 
@@ -497,6 +493,11 @@ private static Dictionary<string, List<string>> EnumerateJsonDocument(JsonElemen
             return paths;
         }
 
+        private static readonly Lazy<HttpClient> httpClient = new(() => new HttpClient()
+        {
+            DefaultRequestVersion = HttpVersion.Version20
+        });
+
         /// <summary>
         /// Reads stream from file system or makes HTTP request depending on the input string
         /// </summary>
@@ -512,11 +513,7 @@ private static async Task<Stream> GetStreamAsync(string input, ILogger logger, C
                 {
                     try
                     {
-                        using var httpClient = new HttpClient
-                        {
-                            DefaultRequestVersion = HttpVersion.Version20
-                        };
-                        stream = await httpClient.GetStreamAsync(new Uri(input), cancellationToken).ConfigureAwait(false);
+                        stream = await httpClient.Value.GetStreamAsync(new Uri(input), cancellationToken).ConfigureAwait(false);
                     }
                     catch (HttpRequestException ex)
                     {

src/Microsoft.OpenApi.Readers/OpenApiReaderSettingsExtensions.cs

@@ -0,0 +1,22 @@
+using Microsoft.OpenApi.Interfaces;
+using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Readers;
+
+namespace Microsoft.OpenApi.Reader;
+
+/// <summary>
+/// Extensions for <see cref="OpenApiReaderSettings"/>
+/// </summary>
+public static class OpenApiReaderSettingsExtensions
+{
+    /// <summary>
+    /// Adds a reader for the specified format
+    /// </summary>
+    /// <param name="settings">The settings to add the reader to.</param>
+    public static void AddYamlReader(this OpenApiReaderSettings settings)
+    {
+        var yamlReader = new OpenApiYamlReader();
+        settings.TryAddReader(OpenApiConstants.Yaml, yamlReader);
+        settings.TryAddReader(OpenApiConstants.Yml, yamlReader);
+    }
+}

src/Microsoft.OpenApi.Workbench/MainModel.cs

@@ -211,9 +211,6 @@ protected void OnPropertyChanged(string propertyName)
         /// </summary>
         internal async Task ParseDocumentAsync()
         {
-            OpenApiReaderRegistry.RegisterReader(OpenApiConstants.Yaml, new OpenApiYamlReader());
-            OpenApiReaderRegistry.RegisterReader(OpenApiConstants.Yml, new OpenApiYamlReader());
-
             Stream stream = null;
             try
             {
@@ -238,6 +235,7 @@ internal async Task ParseDocumentAsync()
                 {
                     RuleSet = ValidationRuleSet.GetDefaultRuleSet()
                 };
+                settings.AddYamlReader();
                 if (ResolveExternal && !string.IsNullOrWhiteSpace(_inputFile))
                 {
                     settings.BaseUrl = _inputFile.StartsWith("http", StringComparison.OrdinalIgnoreCase) ? new(_inputFile) 

src/Microsoft.OpenApi/Models/OpenApiDocument.cs

@@ -562,10 +562,11 @@ public static ReadResult Load(MemoryStream stream,
         /// </summary>
         /// <param name="url"> The path to the OpenAPI file.</param>
         /// <param name="settings">The OpenApi reader settings.</param>
+        /// <param name="token">The cancellation token</param>
         /// <returns></returns>
-        public static async Task<ReadResult> LoadAsync(string url, OpenApiReaderSettings? settings = null)
+        public static async Task<ReadResult> LoadAsync(string url, OpenApiReaderSettings? settings = null, CancellationToken token = default)
         {
-            return await OpenApiModelFactory.LoadAsync(url, settings);
+            return await OpenApiModelFactory.LoadAsync(url, settings, token).ConfigureAwait(false);
         }
 
         /// <summary>

src/Microsoft.OpenApi/Reader/OpenApiModelFactory.cs

@@ -4,7 +4,6 @@
 using System;
 using System.IO;
 using System.Linq;
-using System.Net.Http;
 using System.Security;
 using System.Text;
 using System.Threading;
@@ -21,13 +20,6 @@ namespace Microsoft.OpenApi.Reader
     /// </summary>
     public static class OpenApiModelFactory
     {
-        private static readonly HttpClient _httpClient = new();
-
-        static OpenApiModelFactory()
-        {
-            OpenApiReaderRegistry.RegisterReader(OpenApiConstants.Json, new OpenApiJsonReader());
-        }
-
         /// <summary>
         /// Loads the input stream and parses it into an Open API document.
         /// </summary>
@@ -73,19 +65,21 @@ public static ReadResult Load(MemoryStream stream,
         public static T Load<T>(MemoryStream input, OpenApiSpecVersion version, string format, OpenApiDocument openApiDocument, out OpenApiDiagnostic diagnostic, OpenApiReaderSettings settings = null) where T : IOpenApiElement
         {
             format ??= InspectStreamFormat(input);
-            return OpenApiReaderRegistry.GetReader(format).ReadFragment<T>(input, version, openApiDocument, out diagnostic, settings);
+            settings ??= DefaultReaderSettings.Value;
+            return settings.GetReader(format).ReadFragment<T>(input, version, openApiDocument, out diagnostic, settings);
         }
 
         /// <summary>
         /// Loads the input URL and parses it into an Open API document.
         /// </summary>
         /// <param name="url">The path to the OpenAPI file</param>
         /// <param name="settings"> The OpenApi reader settings.</param>
-        /// <param name="token"></param>
+        /// <param name="token">The cancellation token</param>
         /// <returns></returns>
         public static async Task<ReadResult> LoadAsync(string url, OpenApiReaderSettings settings = null, CancellationToken token = default)
         {
-            var (stream, format) = await RetrieveStreamAndFormatAsync(url, token).ConfigureAwait(false);
+            settings ??= DefaultReaderSettings.Value;
+            var (stream, format) = await RetrieveStreamAndFormatAsync(url, settings, token).ConfigureAwait(false);
             return await LoadAsync(stream, format, settings, token).ConfigureAwait(false);
         }
 
@@ -102,7 +96,8 @@ public static async Task<ReadResult> LoadAsync(string url, OpenApiReaderSettings
         /// <returns>The OpenAPI element.</returns>
         public static async Task<T> LoadAsync<T>(string url, OpenApiSpecVersion version, OpenApiDocument openApiDocument, OpenApiReaderSettings settings = null, CancellationToken token = default) where T : IOpenApiElement
         {
-            var (stream, format) = await RetrieveStreamAndFormatAsync(url, token).ConfigureAwait(false);
+            settings ??= DefaultReaderSettings.Value;
+            var (stream, format) = await RetrieveStreamAndFormatAsync(url, settings, token).ConfigureAwait(false);
             return await LoadAsync<T>(stream, version, openApiDocument, format, settings, token);
         }
 
@@ -239,14 +234,15 @@ public static T Parse<T>(string input,
             return Load<T>(stream, version, format, openApiDocument, out diagnostic, settings);
         }
 
-        private static readonly OpenApiReaderSettings DefaultReaderSettings = new();
+        private static readonly Lazy<OpenApiReaderSettings> DefaultReaderSettings = new(() => new OpenApiReaderSettings());
 
         private static async Task<ReadResult> InternalLoadAsync(Stream input, string format, OpenApiReaderSettings settings, CancellationToken cancellationToken = default)
         {
-            var reader = OpenApiReaderRegistry.GetReader(format);
+            settings ??= DefaultReaderSettings.Value;
+            var reader = settings.GetReader(format);
             var readResult = await reader.ReadAsync(input, settings, cancellationToken).ConfigureAwait(false);
 
-            if (settings?.LoadExternalRefs ?? DefaultReaderSettings.LoadExternalRefs)
+            if (settings.LoadExternalRefs)
             {
                 var diagnosticExternalRefs = await LoadExternalRefsAsync(readResult.Document, settings, format, cancellationToken).ConfigureAwait(false);
                 // Merge diagnostics of external reference
@@ -267,14 +263,15 @@ private static async Task<OpenApiDiagnostic> LoadExternalRefsAsync(OpenApiDocume
             var openApiWorkSpace = new OpenApiWorkspace(baseUrl);
 
             // Load this root document into the workspace
-            var streamLoader = new DefaultStreamLoader(settings.BaseUrl);
+            var streamLoader = new DefaultStreamLoader(settings.BaseUrl, settings.HttpClient);
             var workspaceLoader = new OpenApiWorkspaceLoader(openApiWorkSpace, settings.CustomExternalLoader ?? streamLoader, settings);
             return await workspaceLoader.LoadAsync(new OpenApiReference() { ExternalResource = "/" }, document, format ?? OpenApiConstants.Json, null, token).ConfigureAwait(false);
         }
 
         private static ReadResult InternalLoad(MemoryStream input, string format, OpenApiReaderSettings settings)
         {
-            if (settings?.LoadExternalRefs ?? DefaultReaderSettings.LoadExternalRefs)
+            settings ??= DefaultReaderSettings.Value;
+            if (settings.LoadExternalRefs)
             {
                 throw new InvalidOperationException("Loading external references are not supported when using synchronous methods.");
             }
@@ -283,12 +280,12 @@ private static ReadResult InternalLoad(MemoryStream input, string format, OpenAp
                 throw new ArgumentException($"Cannot parse the stream: {nameof(input)} is empty or contains no elements.");
             }
 
-            var reader = OpenApiReaderRegistry.GetReader(format);
+            var reader = settings.GetReader(format);
             var readResult = reader.Read(input, settings);
             return readResult;
         }
 
-        private static async Task<(Stream, string)> RetrieveStreamAndFormatAsync(string url, CancellationToken token = default)
+        private static async Task<(Stream, string)> RetrieveStreamAndFormatAsync(string url, OpenApiReaderSettings settings, CancellationToken token = default)
         {
             if (!string.IsNullOrEmpty(url))
             {
@@ -298,7 +295,7 @@ private static ReadResult InternalLoad(MemoryStream input, string format, OpenAp
                 if (url.StartsWith("http", StringComparison.OrdinalIgnoreCase)
                     || url.StartsWith("https", StringComparison.OrdinalIgnoreCase))
                 {
-                    var response = await _httpClient.GetAsync(url, token).ConfigureAwait(false);
+                    var response = await settings.HttpClient.GetAsync(url, token).ConfigureAwait(false);
                     var mediaType = response.Content.Headers.ContentType.MediaType;
                     var contentType = mediaType.Split(";".ToCharArray(), StringSplitOptions.RemoveEmptyEntries)[0];
                     format = contentType.Split('/').Last().Split('+').Last().Split('-').Last();