Moved OpenAPIWorkspace to sync loading

Author: darrelmiller

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

@@ -19,5 +19,12 @@ public interface IInputLoader<TInput>
         /// <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);
+
+        /// <summary>
+        /// Use Uri to locate data and convert into an input object.
+        /// </summary>
+        /// <param name="uri"></param>
+        /// <returns></returns>
+        TInput 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, Task<Stream>> CustomExternalLoader { get; set; }
+        public Func<Uri, Stream> CustomExternalLoader { get; set; }
     }
 }

src/Microsoft.OpenApi.Readers/OpenApiYamlDocumentReader.cs

@@ -51,30 +51,7 @@ public OpenApiDocument Read(YamlDocument input, out OpenApiDiagnostic diagnostic
                 // Parse the OpenAPI Document
                 document = context.Parse(input);
 
-                // Resolve References if requested
-                switch (_settings.ReferenceResolution)
-                {
-                    case ReferenceResolutionSetting.ResolveAllReferences:
-                        var openApiWorkSpace = new OpenApiWorkspace();
-                        document.Workspace = openApiWorkSpace;
-                        var streamLoader = new DefaultStreamLoader();
-                        
-                        var workspaceLoader = new OpenApiWorkspaceLoader(openApiWorkSpace, _settings.CustomExternalLoader ?? streamLoader.LoadAsync, _settings);
-                        workspaceLoader.LoadAsync(new OpenApiReference() { ExternalResource="/" }, document);
-
-                        // TODO:  Need to add ReadAsync for resolving all references.
-                        throw new ArgumentException(Properties.SRResource.CannotResolveRemoteReferencesSynchronously);
-                    case ReferenceResolutionSetting.ResolveLocalReferences:
-                        var errors = document.ResolveReferences(false);
-
-                        foreach (var item in errors)
-                        {
-                            diagnostic.Errors.Add(item);
-                        }
-                        break;
-                    case ReferenceResolutionSetting.DoNotResolveReferences:
-                        break;
-                }
+                ResolveReferences(diagnostic, document);
             }
             catch (OpenApiException ex)
             {
@@ -93,6 +70,33 @@ public OpenApiDocument Read(YamlDocument input, out OpenApiDiagnostic diagnostic
 
             return document;
         }
+
+        private void ResolveReferences(OpenApiDiagnostic diagnostic, OpenApiDocument document)
+        {
+            // Resolve References if requested
+            switch (_settings.ReferenceResolution)
+            {
+                case ReferenceResolutionSetting.ResolveAllReferences:
+                    var openApiWorkSpace = new OpenApiWorkspace();
+                    document.Workspace = openApiWorkSpace;
+                    var streamLoader = new DefaultStreamLoader();
+
+                    var workspaceLoader = new OpenApiWorkspaceLoader(openApiWorkSpace, _settings.CustomExternalLoader ?? streamLoader.Load, _settings);
+                    workspaceLoader.Load(new OpenApiReference() { ExternalResource = "/" }, document);
+                    break;
+                case ReferenceResolutionSetting.ResolveLocalReferences:
+                    var errors = document.ResolveReferences(false);
+
+                    foreach (var item in errors)
+                    {
+                        diagnostic.Errors.Add(item);
+                    }
+                    break;
+                case ReferenceResolutionSetting.DoNotResolveReferences:
+                    break;
+            }
+        }
+
         /// <summary>
         /// Reads the stream input and parses the fragment of an OpenAPI description into an Open API Element.
         /// </summary>

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

@@ -19,6 +19,21 @@ internal class DefaultStreamLoader : IInputLoader<Stream>
     {
         private HttpClient _httpClient = new HttpClient();
 
+        public Stream Load(Uri uri)
+        {
+            switch (uri.Scheme)
+            {
+                case "file":
+                    return File.OpenRead(uri.AbsolutePath);
+                case "http":
+                case "https":
+                    return _httpClient.GetStreamAsync(uri).GetAwaiter().GetResult();
+
+                default:
+                    throw new ArgumentException("Unsupported scheme");
+            }
+        }
+
         public async Task<Stream> LoadAsync(Uri uri)
         {
             switch (uri.Scheme)
@@ -28,7 +43,6 @@ public async Task<Stream> LoadAsync(Uri uri)
                 case "http":
                 case "https":
                     return await _httpClient.GetStreamAsync(uri);
-
                 default:
                     throw new ArgumentException("Unsupported scheme");
             }

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