Resolve merge conflicts

Author: MaggieKimani1

src/Microsoft.OpenApi.Hidi/Microsoft.OpenApi.Hidi.csproj

@@ -3,16 +3,21 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp3.1</TargetFramework>
+      <LangVersion>9.0</LangVersion>
     <PackAsTool>true</PackAsTool>
     <ToolCommandName>hidi</ToolCommandName>
     <PackageOutputPath>./../../artifacts</PackageOutputPath>
-    <Version>0.5.0-preview2</Version>
+    <Version>0.5.0-preview3</Version>
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="6.0.0" />
+    <PackageReference Include="System.CommandLine" Version="2.0.0-beta2.21617.1" />
     <PackageReference Include="Microsoft.OData.Edm" Version="7.9.4" />
     <PackageReference Include="Microsoft.OpenApi.OData" Version="1.0.8" />
-    <PackageReference Include="System.CommandLine" Version="2.0.0-beta1.21216.1" />
   </ItemGroup>
 
   <ItemGroup>

src/Microsoft.OpenApi.Hidi/OpenApiService.cs

@@ -3,12 +3,16 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Net;
 using System.Net.Http;
+using System.Security;
 using System.Text;
 using System.Text.Json;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
 using System.Xml.Linq;
 using Microsoft.OData.Edm.Csdl;
 using Microsoft.OpenApi.Extensions;
@@ -21,31 +25,59 @@
 
 namespace Microsoft.OpenApi.Hidi
 {
-    public static class OpenApiService
+    public class OpenApiService
     {
-        public static void ProcessOpenApiDocument(
+        public static async void ProcessOpenApiDocument(
             string openapi,
             string csdl,
             FileInfo output,
             OpenApiSpecVersion? version,
             OpenApiFormat? format,
+            LogLevel loglevel,
+            bool inline,
+            bool resolveexternal,
             string filterbyoperationids,
             string filterbytags,
-            string filterbycollection,
-            bool inline,
-            bool resolveexternal)
+            string filterbycollection
+           )
         {
-            if (string.IsNullOrEmpty(openapi) && string.IsNullOrEmpty(csdl))
+            var logger = ConfigureLoggerInstance(loglevel);
+
+            try
+            {
+                if (string.IsNullOrEmpty(openapi) && string.IsNullOrEmpty(csdl))
+                {
+                    throw new ArgumentNullException("Please input a file path");
+                }
+            }
+            catch (ArgumentNullException ex)
             {
-                throw new ArgumentNullException("Please input a file path");
+                logger.LogError(ex.Message);
+                return;
             }
-            if(output == null)
+            try
             {
-                throw new ArgumentException(nameof(output));
+                if(output == null)
+                {
+                    throw new ArgumentException(nameof(output));
+                }
             }
-            if (output.Exists)
+            catch (ArgumentException ex)
             {
-                throw new IOException("The file you're writing to already exists. Please input a new output path.");
+                logger.LogError(ex.Message);
+                return;
+            }
+            try
+            {
+                if (output.Exists)
+                {
+                    throw new IOException("The file you're writing to already exists. Please input a new file path.");
+                }
+            }
+            catch (IOException ex)
+            {
+                logger.LogError(ex.Message);
+                return;
             }
 
             Stream stream;
@@ -56,14 +88,18 @@ public static void ProcessOpenApiDocument(
             {
                 // Default to yaml during csdl to OpenApi conversion
                 openApiFormat = format ?? GetOpenApiFormat(csdl);
-                 
-                stream = GetStream(csdl);                
-                document = ConvertCsdlToOpenApi(stream);                
+
+                stream = GetStream(csdl);
+                document = ConvertCsdlToOpenApi(stream);
             }
             else
             {
-                stream = GetStream(openapi);
+                stream = GetStream(openapi, logger);
 
+                // Parsing OpenAPI file
+                var stopwatch = new Stopwatch();
+                stopwatch.Start();
+                logger.LogTrace("Parsing OpenApi file");
                 var result = new OpenApiStreamReader(new OpenApiReaderSettings
                 {
                     ReferenceResolution = resolveexternal ? ReferenceResolutionSetting.ResolveAllReferences : ReferenceResolutionSetting.ResolveLocalReferences,
@@ -72,9 +108,9 @@ public static void ProcessOpenApiDocument(
                 ).ReadAsync(stream).GetAwaiter().GetResult();
 
                 document = result.OpenApiDocument;
+                stopwatch.Stop();
 
                 var context = result.OpenApiDiagnostic;
-
                 if (context.Errors.Count > 0)
                 {
                     var errorReport = new StringBuilder();
@@ -83,8 +119,11 @@ public static void ProcessOpenApiDocument(
                     {
                         errorReport.AppendLine(error.ToString());
                     }
-
-                    throw new ArgumentException(string.Join(Environment.NewLine, context.Errors.Select(e => e.Message).ToArray()));
+                    logger.LogError($"{stopwatch.ElapsedMilliseconds}ms: OpenApi Parsing errors {string.Join(Environment.NewLine, context.Errors.Select(e => e.Message).ToArray())}");
+                }
+                else
+                {
+                    logger.LogTrace("{timestamp}ms: Parsed OpenApi successfully. {count} paths found.", stopwatch.ElapsedMilliseconds, document.Paths.Count);
                 }
 
                 openApiFormat = format ?? GetOpenApiFormat(openapi);
@@ -93,32 +132,42 @@ public static void ProcessOpenApiDocument(
 
             Func<string, OperationType?, OpenApiOperation, bool> predicate;
 
-            // Check if filter options are provided, then execute
+            // Check if filter options are provided, then slice the OpenAPI document
             if (!string.IsNullOrEmpty(filterbyoperationids) && !string.IsNullOrEmpty(filterbytags))
             {
                 throw new InvalidOperationException("Cannot filter by operationIds and tags at the same time.");
             }
             if (!string.IsNullOrEmpty(filterbyoperationids))
             {
+                logger.LogTrace("Creating predicate based on the operationIds supplied.");
                 predicate = OpenApiFilterService.CreatePredicate(operationIds: filterbyoperationids);
+
+                logger.LogTrace("Creating subset OpenApi document.");
                 document = OpenApiFilterService.CreateFilteredDocument(document, predicate);
             }
             if (!string.IsNullOrEmpty(filterbytags))
             {
+                logger.LogTrace("Creating predicate based on the tags supplied.");
                 predicate = OpenApiFilterService.CreatePredicate(tags: filterbytags);
+
+                logger.LogTrace("Creating subset OpenApi document.");
                 document = OpenApiFilterService.CreateFilteredDocument(document, predicate);
             }
             if (!string.IsNullOrEmpty(filterbycollection))
             {
-                var fileStream = GetStream(filterbycollection);
-                var requestUrls = ParseJsonCollectionFile(fileStream);
+                var fileStream = await GetStream(filterbycollection, logger);
+                var requestUrls = ParseJsonCollectionFile(fileStream, logger);
+
+                logger.LogTrace("Creating predicate based on the paths and Http methods defined in the Postman collection.");
                 predicate = OpenApiFilterService.CreatePredicate(requestUrls: requestUrls, source:document);
+
+                logger.LogTrace("Creating subset OpenApi document.");
                 document = OpenApiFilterService.CreateFilteredDocument(document, predicate);
             }
 
+            logger.LogTrace("Creating a new file");
             using var outputStream = output?.Create();
-
-            var textWriter = outputStream != null ? new StreamWriter(outputStream) : Console.Out;
+            var textWriter = outputStream != null ? new StreamWriter(outputStream) : Console.Out;            
 
             var settings = new OpenApiWriterSettings()
             {
@@ -131,7 +180,14 @@ public static void ProcessOpenApiDocument(
                 OpenApiFormat.Yaml => new OpenApiYamlWriter(textWriter, settings),
                 _ => throw new ArgumentException("Unknown format"),
             };
+
+            logger.LogTrace("Serializing to OpenApi document using the provided spec version and writer");
+            
+            stopwatch.Start();
             document.Serialize(writer, (OpenApiSpecVersion)version);
+            stopwatch.Stop();
+
+            logger.LogTrace($"Finished serializing in {stopwatch.ElapsedMilliseconds}ms");
 
             textWriter.Flush();
         }
@@ -184,26 +240,53 @@ public static OpenApiDocument FixReferences(OpenApiDocument document)
             return doc;
         }
 
-        private static Stream GetStream(string input)
+        private static async Task<Stream> GetStream(string input, ILogger logger)
         {
+            var stopwatch = new Stopwatch();
+            stopwatch.Start();
+
             Stream stream;
             if (input.StartsWith("http"))
             {
-                var httpClient = new HttpClient(new HttpClientHandler()
+                try
                 {
-                    SslProtocols = System.Security.Authentication.SslProtocols.Tls12,
-                })
+                    using var httpClientHandler = new HttpClientHandler()
+                    {
+                        SslProtocols = System.Security.Authentication.SslProtocols.Tls12,
+                    };
+                    using var httpClient = new HttpClient(httpClientHandler)
+                    {
+                        DefaultRequestVersion = HttpVersion.Version20
+                    };
+                    stream = await httpClient.GetStreamAsync(input);
+                }
+                catch (HttpRequestException ex)
                 {
-                    DefaultRequestVersion = HttpVersion.Version20
-                };
-                stream = httpClient.GetStreamAsync(input).Result;
+                    logger.LogError($"Could not download the file at {input}, reason{ex}");
+                    return null;
+                }
             }
             else
             {
-                var fileInput = new FileInfo(input);
-                stream = fileInput.OpenRead();
+                try
+                {
+                    var fileInput = new FileInfo(input);
+                    stream = fileInput.OpenRead();
+                }
+                catch (Exception ex) when (ex is FileNotFoundException ||
+                    ex is PathTooLongException ||
+                    ex is DirectoryNotFoundException ||
+                    ex is IOException ||
+                    ex is UnauthorizedAccessException ||
+                    ex is SecurityException ||
+                    ex is NotSupportedException)
+                {
+                    logger.LogError($"Could not open the file at {input}, reason: {ex.Message}");
+                    return null;
+                }
             }
-
+            stopwatch.Stop();
+            logger.LogTrace("{timestamp}ms: Read file {input}", stopwatch.ElapsedMilliseconds, input);
             return stream;
         }
 
@@ -212,11 +295,11 @@ private static Stream GetStream(string input)
         /// </summary>
         /// <param name="stream"> A file stream.</param>
         /// <returns> A dictionary of request urls and http methods from a collection.</returns>
-        public static Dictionary<string, List<string>> ParseJsonCollectionFile(Stream stream)
+        public static Dictionary<string, List<string>> ParseJsonCollectionFile(Stream stream, ILogger logger)
         {
             var requestUrls = new Dictionary<string, List<string>>();
 
-            // Convert file to JsonDocument
+            logger.LogTrace("Parsing the json collection file into a JsonDocument");
             using var document = JsonDocument.Parse(stream);
             var root = document.RootElement;
             var itemElement = root.GetProperty("item");
@@ -235,21 +318,21 @@ public static Dictionary<string, List<string>> ParseJsonCollectionFile(Stream st
                     requestUrls[path].Add(method);
                 }
             }
-
+            logger.LogTrace("Finished fetching the list of paths and Http methods defined in the Postman collection.");
             return requestUrls;
         }
 
-        internal static void ValidateOpenApiDocument(string openapi)
+        internal static async void ValidateOpenApiDocument(string openapi, LogLevel loglevel)
         {
-            if (openapi == null)
+            if (string.IsNullOrEmpty(openapi))
             {
-                throw new ArgumentNullException("openapi");
+                throw new ArgumentNullException(nameof(openapi));
             }
-
-            var stream = GetStream(openapi);
+            var logger = ConfigureLoggerInstance(loglevel);
+            var stream = await GetStream(openapi, logger);
 
             OpenApiDocument document;
-
+            logger.LogTrace("Parsing the OpenApi file");
             document = new OpenApiStreamReader(new OpenApiReaderSettings
             {
                 RuleSet = ValidationRuleSet.GetDefaultRuleSet()
@@ -268,12 +351,33 @@ internal static void ValidateOpenApiDocument(string openapi)
             var walker = new OpenApiWalker(statsVisitor);
             walker.Walk(document);
 
+            logger.LogTrace("Finished walking through the OpenApi document. Generating a statistics report..");
             Console.WriteLine(statsVisitor.GetStatisticsReport());
         }
 
-        private static OpenApiFormat GetOpenApiFormat(string openapi)
+        private static OpenApiFormat GetOpenApiFormat(string openapi, ILogger logger)
         {
+            logger.LogTrace("Getting the OpenApi format");
             return !openapi.StartsWith("http") && Path.GetExtension(openapi) == ".json" ? OpenApiFormat.Json : OpenApiFormat.Yaml;
         }
+
+        private static ILogger ConfigureLoggerInstance(LogLevel loglevel)
+        {
+            // Configure logger options
+            #if DEBUG
+            loglevel = loglevel > LogLevel.Debug ? LogLevel.Debug : loglevel;
+            #endif
+
+            var logger = LoggerFactory.Create((builder) => {
+                builder
+                    .AddConsole()
+                #if DEBUG
+                    .AddDebug()
+                #endif
+                    .SetMinimumLevel(loglevel);
+            }).CreateLogger<OpenApiService>();
+
+            return logger;
+        }
     }
 }