Enabled async read for workspace

Author: darrelmiller

src/Microsoft.OpenApi.Readers/Interface/IStreamLoader.cs

@@ -2,29 +2,29 @@
 // Licensed under the MIT license. 
 
 using System;
+using System.IO;
 using System.Threading.Tasks;
 using Microsoft.OpenApi.Models;
 
 namespace Microsoft.OpenApi.Readers.Interface
 {
     /// <summary>
-    /// Interface for service that translates a URI into an object that can be loaded by a Reader
+    /// Interface for service that translates a URI into a stream that can be loaded by a Reader
     /// </summary>
-    /// <typeparam name="TInput"></typeparam>
-    public interface IInputLoader<TInput>
+    public interface IStreamLoader
     {
         /// <summary>
         /// Use Uri to locate data and convert into an input object.
         /// </summary>
         /// <param name="uri">Identifier of some source of an OpenAPI Description</param>
         /// <returns>A data objext that can be processed by a reader to generate an <see cref="OpenApiDocument"/></returns>
-        Task<TInput> LoadAsync(Uri uri);
+        Task<Stream> LoadAsync(Uri uri);
 
         /// <summary>
         /// Use Uri to locate data and convert into an input object.
         /// </summary>
         /// <param name="uri"></param>
         /// <returns></returns>
-        TInput Load(Uri uri);
+        Stream Load(Uri uri);
     }
 }

src/Microsoft.OpenApi.Readers/OpenApiReaderSettings.cs

@@ -66,6 +66,6 @@ public class OpenApiReaderSettings
         /// <remarks>
         /// Default loader will attempt to dereference http(s) urls and file urls.
         /// </remarks>
-        public Func<Uri, Stream> CustomExternalLoader { get; set; }
+        public IStreamLoader CustomExternalLoader { get; set; }
     }
 }

src/Microsoft.OpenApi.Readers/OpenApiStreamReader.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT license. 
 
 using System.IO;
+using System.Threading.Tasks;
 using Microsoft.OpenApi.Interfaces;
 using Microsoft.OpenApi.Models;
 using Microsoft.OpenApi.Readers.Interface;
@@ -38,6 +39,31 @@ public OpenApiDocument Read(Stream input, out OpenApiDiagnostic diagnostic)
             }
         }
 
+        /// <summary>
+        /// Reads the stream input and parses it into an Open API document.
+        /// </summary>
+        /// <param name="input">Stream containing OpenAPI description to parse.</param>
+        /// <returns>Instance result containing newly created OpenApiDocument and diagnostics object from the process</returns>
+        public async Task<ReadResult> ReadAsync(Stream input)
+        {
+            MemoryStream bufferedStream;
+            if (input is MemoryStream)
+            {
+                bufferedStream = (MemoryStream)input;
+            } 
+            else 
+            {
+                // Buffer stream so that OpenApiTextReaderReader can process it synchronously
+                // YamlDocument doesn't support async reading.
+                bufferedStream = new MemoryStream();
+                await input.CopyToAsync(bufferedStream);
+            }
+
+            var reader = new StreamReader(bufferedStream);
+
+            return await new OpenApiTextReaderReader(_settings).ReadAsync(reader);
+        }
+
         /// <summary>
         /// Reads the stream input and parses the fragment of an OpenAPI description into an Open API Element.
         /// </summary>

src/Microsoft.OpenApi.Readers/OpenApiTextReaderReader.cs

@@ -3,6 +3,7 @@
 
 using System.IO;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.OpenApi.Interfaces;
 using Microsoft.OpenApi.Models;
 using Microsoft.OpenApi.Readers.Interface;
@@ -51,6 +52,31 @@ public OpenApiDocument Read(TextReader input, out OpenApiDiagnostic diagnostic)
 
             return new OpenApiYamlDocumentReader(this._settings).Read(yamlDocument, out diagnostic);
         }
+
+        public async Task<ReadResult> ReadAsync(TextReader input)
+        {
+            YamlDocument yamlDocument;
+
+            // Parse the YAML/JSON text in the TextReader into the YamlDocument
+            try
+            {
+                yamlDocument = LoadYamlDocument(input);
+            }
+            catch (YamlException ex)
+            {
+                var diagnostic = new OpenApiDiagnostic();
+                diagnostic.Errors.Add(new OpenApiError($"#line={ex.Start.Line}", ex.Message));
+                return new ReadResult
+                {
+                    OpenApiDocument = null,
+                    OpenApiDiagnostic = diagnostic
+                };
+            }
+
+            return await new OpenApiYamlDocumentReader(this._settings).ReadAsync(yamlDocument);
+        }
+
+
         /// <summary>
         /// Reads the stream input and parses the fragment of an OpenAPI description into an Open API Element.
         /// </summary>

src/Microsoft.OpenApi.Readers/OpenApiYamlDocumentReader.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.IO;
+using System.Threading.Tasks;
 using Microsoft.OpenApi.Exceptions;
 using Microsoft.OpenApi.Extensions;
 using Microsoft.OpenApi.Interfaces;
@@ -71,7 +72,67 @@ public OpenApiDocument Read(YamlDocument input, out OpenApiDiagnostic diagnostic
             return document;
         }
 
+        public async Task<ReadResult> ReadAsync(YamlDocument input)
+        {
+            var diagnostic = new OpenApiDiagnostic();
+            var context = new ParsingContext(diagnostic)
+            {
+                ExtensionParsers = _settings.ExtensionParsers,
+                BaseUrl = _settings.BaseUrl
+            };
+
+            OpenApiDocument document = null;
+            try
+            {
+                // Parse the OpenAPI Document
+                document = context.Parse(input);
+
+                await ResolveReferencesAsync(diagnostic, document);
+            }
+            catch (OpenApiException ex)
+            {
+                diagnostic.Errors.Add(new OpenApiError(ex));
+            }
+
+            // Validate the document
+            if (_settings.RuleSet != null && _settings.RuleSet.Rules.Count > 0)
+            {
+                var errors = document.Validate(_settings.RuleSet);
+                foreach (var item in errors)
+                {
+                    diagnostic.Errors.Add(item);
+                }
+            }
+
+            return new ReadResult()
+            {
+                OpenApiDocument = document,
+                OpenApiDiagnostic = diagnostic
+            };
+        }
+
+
         private void ResolveReferences(OpenApiDiagnostic diagnostic, OpenApiDocument document)
+        {
+            // Resolve References if requested
+            switch (_settings.ReferenceResolution)
+            {
+                case ReferenceResolutionSetting.ResolveAllReferences:
+                    throw new ArgumentException("Cannot resolve all references via a synchronous call. Use ReadAsync.");
+                case ReferenceResolutionSetting.ResolveLocalReferences:
+                    var errors = document.ResolveReferences(false);
+
+                    foreach (var item in errors)
+                    {
+                        diagnostic.Errors.Add(item);
+                    }
+                    break;
+                case ReferenceResolutionSetting.DoNotResolveReferences:
+                    break;
+            }
+        }
+
+        private async Task ResolveReferencesAsync(OpenApiDiagnostic diagnostic, OpenApiDocument document)
         {
             // Resolve References if requested
             switch (_settings.ReferenceResolution)
@@ -81,8 +142,8 @@ private void ResolveReferences(OpenApiDiagnostic diagnostic, OpenApiDocument doc
                     document.Workspace = openApiWorkSpace;
                     var streamLoader = new DefaultStreamLoader();
 
-                    var workspaceLoader = new OpenApiWorkspaceLoader(openApiWorkSpace, _settings.CustomExternalLoader ?? streamLoader.Load, _settings);
-                    workspaceLoader.Load(new OpenApiReference() { ExternalResource = "/" }, document);
+                    var workspaceLoader = new OpenApiWorkspaceLoader(openApiWorkSpace, _settings.CustomExternalLoader ?? streamLoader, _settings);
+                    await workspaceLoader.LoadAsync(new OpenApiReference() { ExternalResource = "/" }, document);
                     break;
                 case ReferenceResolutionSetting.ResolveLocalReferences:
                     var errors = document.ResolveReferences(false);
@@ -97,6 +158,7 @@ private void ResolveReferences(OpenApiDiagnostic diagnostic, OpenApiDocument doc
             }
         }
 
+
         /// <summary>
         /// Reads the stream input and parses the fragment of an OpenAPI description into an Open API Element.
         /// </summary>

src/Microsoft.OpenApi.Readers/ReadResult.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.OpenApi.Models;
+
+namespace Microsoft.OpenApi.Readers
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class ReadResult
+    {
+        public OpenApiDocument OpenApiDocument { set; get; }
+        public OpenApiDiagnostic OpenApiDiagnostic { set; get; }
+    }
+}

src/Microsoft.OpenApi.Readers/Services/DefaultStreamLoader.cs

@@ -15,7 +15,7 @@ namespace Microsoft.OpenApi.Readers.Services
     /// <summary>
     /// Implementation of IInputLoader that loads streams from URIs
     /// </summary>
-    internal class DefaultStreamLoader : IInputLoader<Stream>
+    internal class DefaultStreamLoader : IStreamLoader
     {
         private HttpClient _httpClient = new HttpClient();
 

src/Microsoft.OpenApi.Readers/Services/OpenApiWorkspaceLoader.cs

@@ -14,18 +14,18 @@ namespace Microsoft.OpenApi.Readers.Services
     internal class OpenApiWorkspaceLoader 
     {
         private OpenApiWorkspace _workspace;
-        private Func<Uri, Stream> _loader;
+        private IStreamLoader _loader;
         private OpenApiDiagnostic _diagnostics;
         private OpenApiReaderSettings _readerSettings;
 
-        public OpenApiWorkspaceLoader(OpenApiWorkspace workspace, Func<Uri,Stream> loader, OpenApiReaderSettings readerSettings)
+        public OpenApiWorkspaceLoader(OpenApiWorkspace workspace, IStreamLoader loader, OpenApiReaderSettings readerSettings)
         {
             _workspace = workspace;
             _loader = loader;
             _readerSettings = readerSettings;
         }
 
-        internal void Load(OpenApiReference reference, OpenApiDocument document)
+        internal async Task LoadAsync(OpenApiReference reference, OpenApiDocument document)
         {
             _workspace.AddDocument(reference.ExternalResource, document);
             document.Workspace = _workspace;
@@ -43,9 +43,9 @@ internal void Load(OpenApiReference reference, OpenApiDocument document)
                 // If not already in workspace, load it and process references
                 if (!_workspace.Contains(item.ExternalResource))
                 {
-                    var input = _loader(new Uri(item.ExternalResource));
-                    var newDocument = reader.Read(input, out _diagnostics); // TODO merge _diagnositics
-                    Load(item, newDocument);
+                    var input = _loader.Load(new Uri(item.ExternalResource));
+                    var result = await reader.ReadAsync(input); // TODO merge _diagnositics
+                    await LoadAsync(item, result.OpenApiDocument);
                 }
             }
         }

test/Microsoft.OpenApi.Readers.Tests/OpenApiWorkspaceTests/OpenApiWorkspaceStreamTests.cs

@@ -18,20 +18,45 @@ public class OpenApiWorkspaceStreamTests
 
         // Use OpenApiWorkspace to load a document and a referenced document
 
-        //[Fact]
-        public void LoadDocumentIntoWorkspace()
+        [Fact]
+        public async Task LoadDocumentIntoWorkspace()
         {
             // Create a reader that will resolve all references
-            var reader = new OpenApiStringReader(new OpenApiReaderSettings() {
-                ReferenceResolution = ReferenceResolutionSetting.ResolveAllReferences, 
-                CustomExternalLoader = (url) => { return null; }
+            var reader = new OpenApiStreamReader(new OpenApiReaderSettings()
+            {
+                ReferenceResolution = ReferenceResolutionSetting.ResolveAllReferences,
+                CustomExternalLoader = new MockLoader()
             });
 
             // Todo: this should be ReadAsync
-            var doc = reader.Read("", out OpenApiDiagnostic diagnostic);
+            var stream = new MemoryStream();
+            var doc = @"openapi: 3.0.0
+info:
+  title: foo
+  version: 1.0.0
+paths: {}";
+            var wr = new StreamWriter(stream);
+            wr.Write(doc);
+            wr.Flush();
+            stream.Position = 0;
 
-            Assert.NotNull(doc.Workspace);
+            var result = await reader.ReadAsync(stream);
 
+            Assert.NotNull(result.OpenApiDocument.Workspace);
+
+        }
+    }
+
+    public class MockLoader : IStreamLoader
+    {
+        public Stream Load(Uri uri)
+        {
+            return null;
+        }
+
+        public async Task<Stream> LoadAsync(Uri uri)
+        {
+            return null;
         }
     }
 }