Updated from vnext

microsoft · darrelmiller · Mar 27, 2022 · Aug 15, 2021 · Nov 1, 2021 · Nov 25, 2021
commit e3fa780db7c4b59811bee2f73f7c3e05b799ef1f
diff --git a/src/Microsoft.OpenApi.Hidi/OpenApiService.cs b/src/Microsoft.OpenApi.Hidi/OpenApiService.cs
@@ -34,12 +34,22 @@ public static async void ProcessOpenApiDocument(
             FileInfo output,
             OpenApiSpecVersion? version,
             OpenApiFormat? format,
+<<<<<<< HEAD
             bool inlineExternal,
             bool inlineLocal,
             string filterByOperationIds,
             string filterByTags,
             string filterByCollection
             )
+=======
+            LogLevel loglevel,
+            bool inline,
+            bool resolveexternal,
+            string filterbyoperationids,
+            string filterbytags,
+            string filterbycollection
+           )
+>>>>>>> origin/vnext
         {
             var logger = ConfigureLoggerInstance(loglevel);
 
@@ -80,6 +90,12 @@ string filterByCollection
                 return;
             }
 
+            Stream stream;
+            OpenApiDocument document;
+            OpenApiFormat openApiFormat;
+            var stopwatch = new Stopwatch();
+
+<<<<<<< HEAD
             var inputUrl = GetInputUrl(input);
             var stream = GetStream(inputUrl);
 
@@ -90,10 +106,58 @@ string filterByCollection
                 LoadExternalRefs = inlineExternal,
                 RuleSet = ValidationRuleSet.GetDefaultRuleSet(),
                 BaseUrl = new Uri(inputUrl.AbsoluteUri)
+=======
+            if (!string.IsNullOrEmpty(csdl))
+            {
+                // Default to yaml and OpenApiVersion 3 during csdl to OpenApi conversion
+                openApiFormat = format ?? GetOpenApiFormat(csdl, logger);
+                version ??= OpenApiSpecVersion.OpenApi3_0;
+
+                stream = await GetStream(csdl, logger);
+                document = ConvertCsdlToOpenApi(stream);
+            }
+            else
+            {
+                stream = await GetStream(openapi, logger);
+
+                // Parsing OpenAPI file
+                stopwatch.Start();
+                logger.LogTrace("Parsing OpenApi file");
+                var result = new OpenApiStreamReader(new OpenApiReaderSettings
+                {
+                    ReferenceResolution = resolveexternal ? ReferenceResolutionSetting.ResolveAllReferences : ReferenceResolutionSetting.ResolveLocalReferences,
+                    RuleSet = ValidationRuleSet.GetDefaultRuleSet()
+                }
+                ).ReadAsync(stream).GetAwaiter().GetResult();
+
+                document = result.OpenApiDocument;
+                stopwatch.Stop();
+
+                var context = result.OpenApiDiagnostic;
+                if (context.Errors.Count > 0)
+                {
+                    var errorReport = new StringBuilder();
+
+                    foreach (var error in context.Errors)
+                    {
+                        errorReport.AppendLine(error.ToString());
+                    }
+                    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, logger);
+                version ??= result.OpenApiDiagnostic.SpecificationVersion;
+>>>>>>> origin/vnext
             }
-            ).ReadAsync(stream).GetAwaiter().GetResult();
 
+<<<<<<< HEAD
             document = result.OpenApiDocument;
+=======
+>>>>>>> origin/vnext
             Func<string, OperationType?, OpenApiOperation, bool> predicate;
 
             // Check if filter options are provided, then slice the OpenAPI document
@@ -110,10 +174,28 @@ string filterByCollection
                 document = OpenApiFilterService.CreateFilteredDocument(document, predicate);
             }
             if (!string.IsNullOrEmpty(filterbytags))
+            {
+                logger.LogTrace("Creating predicate based on the tags supplied.");
+                predicate = OpenApiFilterService.CreatePredicate(tags: filterbytags);
+
+<<<<<<< HEAD
+            if (!string.IsNullOrEmpty(filterByCollection))
             {
                 var fileStream = GetStream(GetInputUrl(filterByCollection));
                 var requestUrls = ParseJsonCollectionFile(fileStream);
                 predicate = OpenApiFilterService.CreatePredicate(requestUrls: requestUrls, source:document);
+=======
+                logger.LogTrace("Creating subset OpenApi document.");
+>>>>>>> origin/vnext
+                document = OpenApiFilterService.CreateFilteredDocument(document, predicate);
+            }
+            if (!string.IsNullOrEmpty(filterbycollection))
+            {
+                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);
@@ -147,6 +229,7 @@ string filterByCollection
             textWriter.Flush();
         }
 
+<<<<<<< HEAD
         private static Uri GetInputUrl(string input)
         {
             if (input.StartsWith("http"))
@@ -160,6 +243,18 @@ private static Uri GetInputUrl(string input)
         }
 
         private static Stream GetStream(Uri input)
+        {
+            Stream stream;
+            if (input.Scheme == "http" || input.Scheme == "https")
+            {
+                var httpClient = new HttpClient(new HttpClientHandler()
+=======
+        /// <summary>
+        /// Converts CSDL to OpenAPI
+        /// </summary>
+        /// <param name="csdl">The CSDL stream.</param>
+        /// <returns>An OpenAPI document.</returns>
+        public static OpenApiDocument ConvertCsdlToOpenApi(Stream csdl)
         {
             using var reader = new StreamReader(csdl);
             var csdlText = reader.ReadToEndAsync().GetAwaiter().GetResult();           
@@ -208,9 +303,10 @@ private static async Task<Stream> GetStream(string input, ILogger logger)
             stopwatch.Start();
 
             Stream stream;
-            if (input.Scheme == "http" || input.Scheme == "https")
+            if (input.StartsWith("http"))
             {
                 try
+>>>>>>> origin/vnext
                 {
                     var httpClientHandler = new HttpClientHandler()
                     {
@@ -230,12 +326,31 @@ private static async Task<Stream> GetStream(string input, ILogger logger)
             }
             else if (input.Scheme == "file")
             {
+<<<<<<< HEAD
                 var fileInput = new FileInfo(input.AbsolutePath);
                 stream = fileInput.OpenRead();
             } 
             else
             {
                 throw new ArgumentException("Unrecognized exception");
+=======
+                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;
+                }
+>>>>>>> origin/vnext
             }
             stopwatch.Stop();
             logger.LogTrace("{timestamp}ms: Read file {input}", stopwatch.ElapsedMilliseconds, input);
@@ -274,18 +389,31 @@ public static Dictionary<string, List<string>> ParseJsonCollectionFile(Stream st
             return requestUrls;
         }
 
+<<<<<<< HEAD
         internal static async Task ValidateOpenApiDocument(string input, bool resolveExternal)
+=======
+        internal static async Task ValidateOpenApiDocument(string openapi, LogLevel loglevel)
+>>>>>>> origin/vnext
         {
             if (string.IsNullOrEmpty(openapi))
             {
                 throw new ArgumentNullException(nameof(openapi));
             }
+<<<<<<< HEAD
             var inputUrl = GetInputUrl(input);
             var stream = GetStream(GetInputUrl(input));
 
             OpenApiDocument document;
 
             var result = await new OpenApiStreamReader(new OpenApiReaderSettings
+=======
+            var logger = ConfigureLoggerInstance(loglevel);
+            var stream = await GetStream(openapi, logger);
+
+            OpenApiDocument document;
+            logger.LogTrace("Parsing the OpenApi file");
+            document = new OpenApiStreamReader(new OpenApiReaderSettings
+>>>>>>> origin/vnext
             {
                 ReferenceResolution = resolveExternal == true ? ReferenceResolutionSetting.ResolveAllReferences : ReferenceResolutionSetting.ResolveLocalReferences,
                 RuleSet = ValidationRuleSet.GetDefaultRuleSet(),
@@ -322,7 +450,12 @@ internal static async Task ValidateOpenApiDocument(string input, bool resolveExt
                 }
             }
 
+<<<<<<< HEAD
 
+=======
+            logger.LogTrace("Finished walking through the OpenApi document. Generating a statistics report..");
+            Console.WriteLine(statsVisitor.GetStatisticsReport());
+>>>>>>> origin/vnext
         }
 
         private static OpenApiFormat GetOpenApiFormat(string input, ILogger logger)

diff --git a/src/Microsoft.OpenApi.Hidi/Program.cs b/src/Microsoft.OpenApi.Hidi/Program.cs
@@ -51,6 +51,7 @@ static async Task<int> Main(string[] args)
 
             var validateCommand = new Command("validate")
             {
+<<<<<<< HEAD
                 new Option("--input", "Input OpenAPI description file path or URL", typeof(string) ),
                 new Option("--resolveExternal","Resolve external $refs", typeof(bool))
             };
@@ -70,6 +71,31 @@ static async Task<int> Main(string[] args)
             };
             transformCommand.Handler = CommandHandler.Create<string, FileInfo, OpenApiSpecVersion?, OpenApiFormat?, bool, bool, string, string, string>(
                 OpenApiService.ProcessOpenApiDocument);
+=======
+                descriptionOption,
+                logLevelOption
+            };
+
+            validateCommand.SetHandler<string, LogLevel>(OpenApiService.ValidateOpenApiDocument, descriptionOption, logLevelOption);
+
+            var transformCommand = new Command("transform")
+            {
+                descriptionOption,
+                csdlOption,
+                outputOption,
+                versionOption,
+                formatOption,
+                logLevelOption,               
+                filterByOperationIdsOption,
+                filterByTagsOption,
+                filterByCollectionOption,
+                inlineOption,
+                resolveExternalOption,
+            };
+
+            transformCommand.SetHandler<string, string, FileInfo, OpenApiSpecVersion?, OpenApiFormat?, LogLevel, bool, bool, string, string, string> (
+                OpenApiService.ProcessOpenApiDocument, descriptionOption, csdlOption, outputOption, versionOption, formatOption, logLevelOption, inlineOption, resolveExternalOption, filterByOperationIdsOption, filterByTagsOption, filterByCollectionOption);
+>>>>>>> origin/vnext
 
             rootCommand.Add(transformCommand);
             rootCommand.Add(validateCommand);