Merge pull request #2077 from microsoft/dev

Release v2.0.0-preview5

.github/workflows/ci-cd.yml

@@ -36,3 +36,18 @@ jobs:
         shell: pwsh
         run: |
           dotnet test Microsoft.OpenApi.sln -c Release -v n
+
+  validate-trimming:
+    name: Validate Project for Trimming
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: 8.x
+
+      - name: Validate Trimming warnings
+        run: dotnet publish -c Release -r win-x64 /p:TreatWarningsAsErrors=true /warnaserror -f net8.0
+        working-directory: ./test/Microsoft.OpenApi.Trimming.Tests

.github/workflows/docker.yml

@@ -30,13 +30,13 @@ jobs:
         id: getversion
       - name: Push to registry - Nightly
         if: ${{ github.ref == 'refs/heads/dev' }}
-        uses: docker/build-push-action@v6.10.0
+        uses: docker/build-push-action@v6.12.0
         with:
           push: true
           tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:nightly
       - name: Push to registry - Release
         if: ${{ github.ref == 'refs/heads/main' || github.ref == 'refs/heads/support/v1' }}
-        uses: docker/build-push-action@v6.10.0
+        uses: docker/build-push-action@v6.12.0
         with:
           push: true
           tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest,${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.getversion.outputs.version }}

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

@@ -9,7 +9,7 @@
     <Nullable>enable</Nullable>
     <ToolCommandName>hidi</ToolCommandName>
     <PackageOutputPath>./../../artifacts</PackageOutputPath>
-    <Version>2.0.0-preview4</Version>
+    <Version>2.0.0-preview5</Version>
     <Description>OpenAPI.NET CLI tool for slicing OpenAPI documents</Description>
     <SignAssembly>true</SignAssembly>
     <!-- https://github.com/dotnet/sourcelink/blob/main/docs/README.md#embeduntrackedsources -->
@@ -29,10 +29,10 @@
 
   <ItemGroup>
     <PackageReference Include="Humanizer.Core" Version="2.14.1" />
-    <PackageReference Include="Microsoft.Extensions.Logging" Version="9.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="9.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="9.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="9.0.1" />
     <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="9.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="8.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="9.0.1" />
     <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.12.19">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>

src/Microsoft.OpenApi.Hidi/OpenApiService.cs

@@ -113,7 +113,7 @@ public static async Task TransformOpenApiDocumentAsync(HidiOptions options, ILog
                     var walker = new OpenApiWalker(powerShellFormatter);
                     walker.Walk(document);
                 }
-                WriteOpenApi(options, openApiFormat, openApiVersion, document, logger);
+                await WriteOpenApiAsync(options, openApiFormat, openApiVersion, document, logger, cancellationToken).ConfigureAwait(false);
             }
             catch (TaskCanceledException)
             {
@@ -191,7 +191,7 @@ private static OpenApiDocument ApplyFilters(HidiOptions options, ILogger logger,
             return document;
         }
 
-        private static void WriteOpenApi(HidiOptions options, OpenApiFormat openApiFormat, OpenApiSpecVersion openApiVersion, OpenApiDocument document, ILogger logger)
+        private static async Task WriteOpenApiAsync(HidiOptions options, OpenApiFormat openApiFormat, OpenApiSpecVersion openApiVersion, OpenApiDocument document, ILogger logger, CancellationToken cancellationToken)
         {
             using (logger.BeginScope("Output"))
             {
@@ -216,11 +216,11 @@ private static void WriteOpenApi(HidiOptions options, OpenApiFormat openApiForma
 
                 var stopwatch = new Stopwatch();
                 stopwatch.Start();
-                document.Serialize(writer, openApiVersion);
+                await document.SerializeAsync(writer, openApiVersion, cancellationToken).ConfigureAwait(false);
                 stopwatch.Stop();
 
                 logger.LogTrace("Finished serializing in {ElapsedMilliseconds}ms", stopwatch.ElapsedMilliseconds);
-                textWriter.Flush();
+                await textWriter.FlushAsync(cancellationToken).ConfigureAwait(false);
             }
         }
 
@@ -769,7 +769,7 @@ internal static async Task PluginManifestAsync(HidiOptions options, ILogger logg
             // Write OpenAPI to Output folder
             options.Output = new(Path.Combine(options.OutputFolder, "openapi.json"));
             options.TerseOutput = true;
-            WriteOpenApi(options, OpenApiFormat.Json, OpenApiSpecVersion.OpenApi3_1, document, logger);
+            await WriteOpenApiAsync(options, OpenApiFormat.Json, OpenApiSpecVersion.OpenApi3_1, document, logger, cancellationToken).ConfigureAwait(false);
 
             // Create OpenAIPluginManifest from ApiDependency and OpenAPI document
             var manifest = new OpenAIPluginManifest(document.Info?.Title ?? "Title", document.Info?.Title ?? "Title", "https://go.microsoft.com/fwlink/?LinkID=288890", document.Info?.Contact?.Email ?? "[email protected]", document.Info?.License?.Url.ToString() ?? "https://placeholderlicenseurl.com")

src/Microsoft.OpenApi.Readers/Microsoft.OpenApi.Readers.csproj

@@ -1,12 +1,14 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
-        <TargetFrameworks>netstandard2.0;net6.0;</TargetFrameworks>
+        <TargetFrameworks>netstandard2.0;net8.0;</TargetFrameworks>
         <!-- net6.0 target is present because of the conditional build in OpenApiYamlReader.Read -->
         <LangVersion>latest</LangVersion>
         <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
-        <Version>2.0.0-preview4</Version>
+        <Version>2.0.0-preview5</Version>
         <Description>OpenAPI.NET Readers for JSON and YAML documents</Description>
         <SignAssembly>true</SignAssembly>
+        <IsTrimmable Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)','net5.0'))">true</IsTrimmable>
+        <IsAotCompatible Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)','net8.0'))">true</IsAotCompatible>
         <!-- https://github.com/dotnet/sourcelink/blob/main/docs/README.md#embeduntrackedsources -->
         <EmbedUntrackedSources>true</EmbedUntrackedSources>
         <NoWarn>NU5048</NoWarn>

src/Microsoft.OpenApi.Readers/OpenApiYamlReader.cs

@@ -9,7 +9,6 @@
 using Microsoft.OpenApi.Interfaces;
 using Microsoft.OpenApi.Reader;
 using SharpYaml.Serialization;
-using System.Linq;
 using Microsoft.OpenApi.Models;
 using System;
 using System.Text;
@@ -86,6 +85,7 @@ public static ReadResult Read(JsonNode jsonNode, OpenApiReaderSettings settings,
         /// <inheritdoc/>
         public T ReadFragment<T>(MemoryStream input,
                                  OpenApiSpecVersion version,
+                                 OpenApiDocument openApiDocument,
                                  out OpenApiDiagnostic diagnostic,
                                  OpenApiReaderSettings settings = null) where T : IOpenApiElement
         {
@@ -105,13 +105,13 @@ public T ReadFragment<T>(MemoryStream input,
                 return default;
             }
 
-            return ReadFragment<T>(jsonNode, version, out diagnostic, settings);
+            return ReadFragment<T>(jsonNode, version, openApiDocument, out diagnostic, settings);
         }
 
         /// <inheritdoc/>
-        public static T ReadFragment<T>(JsonNode input, OpenApiSpecVersion version, out OpenApiDiagnostic diagnostic, OpenApiReaderSettings settings = null) where T : IOpenApiElement
+        public static T ReadFragment<T>(JsonNode input, OpenApiSpecVersion version, OpenApiDocument openApiDocument, out OpenApiDiagnostic diagnostic, OpenApiReaderSettings settings = null) where T : IOpenApiElement
         {
-            return _jsonReader.ReadFragment<T>(input, version, out diagnostic, settings);
+            return _jsonReader.ReadFragment<T>(input, version, openApiDocument, out diagnostic, settings);
         }
 
         /// <summary>

src/Microsoft.OpenApi.Workbench/MainModel.cs

@@ -270,7 +270,7 @@ internal async Task ParseDocumentAsync()
 
                 stopwatch.Reset();
                 stopwatch.Start();
-                Output = WriteContents(document);
+                Output = await WriteContentsAsync(document);
                 stopwatch.Stop();
 
                 RenderTime = $"{stopwatch.ElapsedMilliseconds} ms";
@@ -299,23 +299,23 @@ internal async Task ParseDocumentAsync()
         /// <summary>
         /// Write content from the given document based on the format and version set in this class.
         /// </summary>
-        private string WriteContents(OpenApiDocument document)
+        private async Task<string> WriteContentsAsync(OpenApiDocument document)
         {
             var outputStream = new MemoryStream();
 
-            document.Serialize(
+            await document.SerializeAsync(
                 outputStream,
                 Version,
                 Format,
-                new()
+                (Writers.OpenApiWriterSettings)new()
                 {
                     InlineLocalReferences = InlineLocal,
                     InlineExternalReferences = InlineExternal
                 });
 
             outputStream.Position = 0;
 
-            return new StreamReader(outputStream).ReadToEnd();
+            return await new StreamReader(outputStream).ReadToEndAsync();
         }
 
         private static MemoryStream CreateStream(string text)

src/Microsoft.OpenApi.Workbench/Microsoft.OpenApi.Workbench.csproj

@@ -13,9 +13,9 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.Windows.Compatibility" Version="9.0.0" />
+    <PackageReference Include="Microsoft.Windows.Compatibility" Version="9.0.1" />
     <!-- Microsoft.Windows.Compatibility 8.0.8 depends on 8.0.0 this dependency can be removed once they update theirs -->
-    <PackageReference Include="System.Formats.Asn1" Version="9.0.0" />
+    <PackageReference Include="System.Formats.Asn1" Version="9.0.1" />
   </ItemGroup>
   <ItemGroup>
     <Resource Include="Themes\Metro\HowToApplyTheme.txt" />

src/Microsoft.OpenApi/Extensions/OpenApiSerializableExtensions.cs

@@ -3,6 +3,8 @@
 
 using System.Globalization;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.OpenApi.Exceptions;
 using Microsoft.OpenApi.Interfaces;
 using Microsoft.OpenApi.Properties;
@@ -22,10 +24,11 @@ public static class OpenApiSerializableExtensions
         /// <param name="element">The Open API element.</param>
         /// <param name="stream">The output stream.</param>
         /// <param name="specVersion">The Open API specification version.</param>
-        public static void SerializeAsJson<T>(this T element, Stream stream, OpenApiSpecVersion specVersion)
+        /// <param name="cancellationToken">The cancellation token.</param>
+        public static Task SerializeAsJsonAsync<T>(this T element, Stream stream, OpenApiSpecVersion specVersion, CancellationToken cancellationToken = default)
             where T : IOpenApiSerializable
         {
-            element.Serialize(stream, specVersion, OpenApiFormat.Json);
+            return element.SerializeAsync(stream, specVersion, OpenApiFormat.Json, cancellationToken);
         }
 
         /// <summary>
@@ -35,10 +38,11 @@ public static void SerializeAsJson<T>(this T element, Stream stream, OpenApiSpec
         /// <param name="element">The Open API element.</param>
         /// <param name="stream">The output stream.</param>
         /// <param name="specVersion">The Open API specification version.</param>
-        public static void SerializeAsYaml<T>(this T element, Stream stream, OpenApiSpecVersion specVersion)
+        /// <param name="cancellationToken">The cancellation token.</param>
+        public static Task SerializeAsYamlAsync<T>(this T element, Stream stream, OpenApiSpecVersion specVersion, CancellationToken cancellationToken = default)
             where T : IOpenApiSerializable
         {
-            element.Serialize(stream, specVersion, OpenApiFormat.Yaml);
+            return element.SerializeAsync(stream, specVersion, OpenApiFormat.Yaml, cancellationToken);
         }
 
         /// <summary>
@@ -50,14 +54,16 @@ public static void SerializeAsYaml<T>(this T element, Stream stream, OpenApiSpec
         /// <param name="stream">The given stream.</param>
         /// <param name="specVersion">The Open API specification version.</param>
         /// <param name="format">The output format (JSON or YAML).</param>
-        public static void Serialize<T>(
+        /// <param name="cancellationToken">The cancellation token.</param>
+        public static Task SerializeAsync<T>(
             this T element,
             Stream stream,
             OpenApiSpecVersion specVersion,
-            OpenApiFormat format)
+            OpenApiFormat format,
+            CancellationToken cancellationToken = default)
             where T : IOpenApiSerializable
         {
-            element.Serialize(stream, specVersion, format, null);
+            return element.SerializeAsync(stream, specVersion, format, null, cancellationToken);
         }
 
         /// <summary>
@@ -70,12 +76,14 @@ public static void Serialize<T>(
         /// <param name="specVersion">The Open API specification version.</param>
         /// <param name="format">The output format (JSON or YAML).</param>
         /// <param name="settings">Provide configuration settings for controlling writing output</param>
-        public static void Serialize<T>(
+        /// <param name="cancellationToken">The cancellation token.</param>
+        public static Task SerializeAsync<T>(
             this T element,
             Stream stream,
             OpenApiSpecVersion specVersion,
             OpenApiFormat format,
-            OpenApiWriterSettings settings)
+            OpenApiWriterSettings settings,
+            CancellationToken cancellationToken = default)
             where T : IOpenApiSerializable
         {
             Utils.CheckArgumentNull(stream);
@@ -88,7 +96,7 @@ public static void Serialize<T>(
                 OpenApiFormat.Yaml => new OpenApiYamlWriter(streamWriter, settings),
                 _ => throw new OpenApiException(string.Format(SRResource.OpenApiFormatNotSupported, format)),
             };
-            element.Serialize(writer, specVersion);
+            return element.SerializeAsync(writer, specVersion, cancellationToken);
         }
 
         /// <summary>
@@ -98,7 +106,8 @@ public static void Serialize<T>(
         /// <param name="element">The Open API element.</param>
         /// <param name="writer">The output writer.</param>
         /// <param name="specVersion">Version of the specification the output should conform to</param>
-        public static void Serialize<T>(this T element, IOpenApiWriter writer, OpenApiSpecVersion specVersion)
+        /// <param name="cancellationToken">The cancellation token.</param>
+        public static Task SerializeAsync<T>(this T element, IOpenApiWriter writer, OpenApiSpecVersion specVersion, CancellationToken cancellationToken = default)
             where T : IOpenApiSerializable
         {
             Utils.CheckArgumentNull(element);
@@ -122,7 +131,7 @@ public static void Serialize<T>(this T element, IOpenApiWriter writer, OpenApiSp
                     throw new OpenApiException(string.Format(SRResource.OpenApiSpecVersionNotSupported, specVersion));
             }
 
-            writer.Flush();
+            return writer.FlushAsync(cancellationToken);
         }
 
         /// <summary>
@@ -131,12 +140,14 @@ public static void Serialize<T>(this T element, IOpenApiWriter writer, OpenApiSp
         /// <typeparam name="T">the <see cref="IOpenApiSerializable"/></typeparam>
         /// <param name="element">The Open API element.</param>
         /// <param name="specVersion">The Open API specification version.</param>
-        public static string SerializeAsJson<T>(
+        /// <param name="cancellationToken">The cancellation token.</param>
+        public static Task<string> SerializeAsJsonAsync<T>(
             this T element,
-            OpenApiSpecVersion specVersion)
+            OpenApiSpecVersion specVersion,
+            CancellationToken cancellationToken = default)
             where T : IOpenApiSerializable
         {
-            return element.Serialize(specVersion, OpenApiFormat.Json);
+            return element.SerializeAsync(specVersion, OpenApiFormat.Json, cancellationToken);
         }
 
         /// <summary>
@@ -145,12 +156,14 @@ public static string SerializeAsJson<T>(
         /// <typeparam name="T">the <see cref="IOpenApiSerializable"/></typeparam>
         /// <param name="element">The Open API element.</param>
         /// <param name="specVersion">The Open API specification version.</param>
-        public static string SerializeAsYaml<T>(
+        /// <param name="cancellationToken">The cancellation token.</param>
+        public static Task<string> SerializeAsYamlAsync<T>(
             this T element,
-            OpenApiSpecVersion specVersion)
+            OpenApiSpecVersion specVersion,
+            CancellationToken cancellationToken = default)
             where T : IOpenApiSerializable
         {
-            return element.Serialize(specVersion, OpenApiFormat.Yaml);
+            return element.SerializeAsync(specVersion, OpenApiFormat.Yaml, cancellationToken);
         }
 
         /// <summary>
@@ -160,20 +173,26 @@ public static string SerializeAsYaml<T>(
         /// <param name="element">The Open API element.</param>
         /// <param name="specVersion">The Open API specification version.</param>
         /// <param name="format">Open API document format.</param>
-        public static string Serialize<T>(
+        /// <param name="cancellationToken">The cancellation token.</param>
+        public static async Task<string> SerializeAsync<T>(
             this T element,
             OpenApiSpecVersion specVersion,
-            OpenApiFormat format)
+            OpenApiFormat format,
+            CancellationToken cancellationToken = default)
             where T : IOpenApiSerializable
         {
             Utils.CheckArgumentNull(element);
 
             using var stream = new MemoryStream();
-            element.Serialize(stream, specVersion, format);
+            await element.SerializeAsync(stream, specVersion, format, cancellationToken).ConfigureAwait(false);
             stream.Position = 0;
 
             using var streamReader = new StreamReader(stream);
-            return streamReader.ReadToEnd();
+#if NET7_0_OR_GREATER
+            return await streamReader.ReadToEndAsync(cancellationToken).ConfigureAwait(false);
+#else
+            return await streamReader.ReadToEndAsync().ConfigureAwait(false);
+#endif
         }
     }
 }