React to aspnet/BuildTools#684 (#2660)

* Update KoreBuild
* Minimize blocking threads to increase travis reliability

korebuild-lock.txt

@@ -1,2 +1,2 @@
-version:2.2.0-preview1-17081
+version:2.2.0-preview1-17087
-commithash:73f09c256e2a54270951562ecc0ef4a953926c36
+commithash:596d40f67cbe774675e73c39d463b628bf453531

test/Kestrel.Core.Tests/HttpConnectionTests.cs

@@ -418,10 +418,10 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
         }
 
         [Fact]
-        public void WriteTimingAbortsConnectionWhenWriteDoesNotCompleteWithMinimumDataRate()
+        public async Task WriteTimingAbortsConnectionWhenWriteDoesNotCompleteWithMinimumDataRate()
         {
             var systemClock = new MockSystemClock();
-            var aborted = new ManualResetEventSlim();
+            var aborted = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
 
             _httpConnectionContext.ServiceContext.ServerOptions.Limits.MinResponseDataRate =
                 new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(2));
@@ -434,7 +434,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
             _httpConnection.Http1Connection.Reset();
             _httpConnection.Http1Connection.RequestAborted.Register(() =>
             {
-                aborted.Set();
+                aborted.SetResult(null);
             });
 
             // Initialize timestamp
@@ -448,15 +448,15 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
             _httpConnection.Tick(systemClock.UtcNow);
 
             Assert.True(_httpConnection.RequestTimedOut);
-            Assert.True(aborted.Wait(TimeSpan.FromSeconds(10)));
+            await aborted.Task.DefaultTimeout();
         }
 
         [Fact]
-        public void WriteTimingAbortsConnectionWhenSmallWriteDoesNotCompleteWithinGracePeriod()
+        public async Task WriteTimingAbortsConnectionWhenSmallWriteDoesNotCompleteWithinGracePeriod()
         {
             var systemClock = new MockSystemClock();
             var minResponseDataRate = new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(5));
-            var aborted = new ManualResetEventSlim();
+            var aborted = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
 
             _httpConnectionContext.ServiceContext.ServerOptions.Limits.MinResponseDataRate = minResponseDataRate;
             _httpConnectionContext.ServiceContext.SystemClock = systemClock;
@@ -468,7 +468,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
             _httpConnection.Http1Connection.Reset();
             _httpConnection.Http1Connection.RequestAborted.Register(() =>
             {
-                aborted.Set();
+                aborted.SetResult(null);
             });
 
             // Initialize timestamp
@@ -490,14 +490,14 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
             _httpConnection.Tick(systemClock.UtcNow);
 
             Assert.True(_httpConnection.RequestTimedOut);
-            Assert.True(aborted.Wait(TimeSpan.FromSeconds(10)));
+            await aborted.Task.DefaultTimeout();
         }
 
         [Fact]
-        public void WriteTimingTimeoutPushedOnConcurrentWrite()
+        public async Task WriteTimingTimeoutPushedOnConcurrentWrite()
         {
             var systemClock = new MockSystemClock();
-            var aborted = new ManualResetEventSlim();
+            var aborted = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
 
             _httpConnectionContext.ServiceContext.ServerOptions.Limits.MinResponseDataRate =
                 new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(2));
@@ -510,7 +510,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
             _httpConnection.Http1Connection.Reset();
             _httpConnection.Http1Connection.RequestAborted.Register(() =>
             {
-                aborted.Set();
+                aborted.SetResult(null);
             });
 
             // Initialize timestamp
@@ -537,7 +537,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
             _httpConnection.Tick(systemClock.UtcNow);
 
             Assert.True(_httpConnection.RequestTimedOut);
-            Assert.True(aborted.Wait(TimeSpan.FromSeconds(10)));
+            await aborted.Task.DefaultTimeout();
         }
 
         [Fact]
@@ -547,7 +547,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
             var minResponseDataRate = new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(5));
             var numWrites = 5;
             var writeSize = 100;
-            var aborted = new TaskCompletionSource<object>();
+            var aborted = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
 
             _httpConnectionContext.ServiceContext.ServerOptions.Limits.MinResponseDataRate = minResponseDataRate;
             _httpConnectionContext.ServiceContext.SystemClock = systemClock;

test/Kestrel.Core.Tests/MessageBodyTests.cs

@@ -687,11 +687,11 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
         {
             using (var input = new TestInput())
             {
-                var logEvent = new ManualResetEventSlim();
+                var logEvent = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
                 var mockLogger = new Mock<IKestrelTrace>();
                 mockLogger
                     .Setup(logger => logger.RequestBodyDone("ConnectionId", "RequestId"))
-                    .Callback(() => logEvent.Set());
+                    .Callback(() => logEvent.SetResult(null));
                 input.Http1Connection.ServiceContext.Log = mockLogger.Object;
                 input.Http1Connection.ConnectionIdFeature = "ConnectionId";
                 input.Http1Connection.TraceIdentifier = "RequestId";
@@ -706,7 +706,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
 
                 input.Fin();
 
-                Assert.True(logEvent.Wait(TestConstants.DefaultTimeout));
+                await logEvent.Task.DefaultTimeout();
 
                 await body.StopAsync();
             }

test/Kestrel.FunctionalTests/ChunkedResponseTests.cs

@@ -350,7 +350,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.FunctionalTests
         {
             var testContext = new TestServiceContext(LoggerFactory);
 
-            var flushWh = new ManualResetEventSlim();
+            var flushWh = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
 
             using (var server = new TestServer(async httpContext =>
             {
@@ -358,7 +358,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.FunctionalTests
                 await response.Body.WriteAsync(Encoding.ASCII.GetBytes("Hello "), 0, 6);
 
                 // Don't complete response until client has received the first chunk.
-                flushWh.Wait();
+                await flushWh.Task.DefaultTimeout();
 
                 await response.Body.WriteAsync(Encoding.ASCII.GetBytes("World!"), 0, 6);
             }, testContext, listenOptions))
@@ -379,7 +379,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.FunctionalTests
                         "Hello ",
                         "");
 
-                    flushWh.Set();
+                    flushWh.SetResult(null);
 
                     await connection.ReceiveEnd(
                         "6",

test/Kestrel.FunctionalTests/RequestBodyTimeoutTests.cs

@@ -29,7 +29,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.FunctionalTests
                 DateHeaderValueManager = new DateHeaderValueManager(systemClock)
             };
 
-            var appRunningEvent = new ManualResetEventSlim();
+            var appRunningEvent = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
 
             using (var server = new TestServer(context =>
             {
@@ -37,7 +37,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.FunctionalTests
                     new MinDataRate(bytesPerSecond: 1, gracePeriod: gracePeriod);
 
                 // The server must call Request.Body.ReadAsync() *before* the test sets systemClock.UtcNow (which is triggered by the
-                // server calling appRunningEvent.Set()).  If systemClock.UtcNow is set first, it's possible for the test to fail
+                // server calling appRunningEvent.SetResult(null)).  If systemClock.UtcNow is set first, it's possible for the test to fail
                 // due to the following race condition:
                 //
                 // 1. [test]    systemClock.UtcNow += gracePeriod + TimeSpan.FromSeconds(1);
@@ -55,12 +55,12 @@ namespace Microsoft.AspNetCore.Server.Kestrel.FunctionalTests
                 // test flakiness in our CI (https://github.com/aspnet/KestrelHttpServer/issues/2539).
                 //
                 // For verification, I was able to induce the race by adding a sleep in the RequestDelegate:
-                //     appRunningEvent.Set();
+                //     appRunningEvent.SetResult(null);
                 //     Thread.Sleep(5000);
                 //     return context.Request.Body.ReadAsync(new byte[1], 0, 1);
 
                 var readTask = context.Request.Body.ReadAsync(new byte[1], 0, 1);
-                appRunningEvent.Set();
+                appRunningEvent.SetResult(null);
                 return readTask;
             }, serviceContext))
             {
@@ -73,7 +73,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.FunctionalTests
                         "",
                         "");
 
-                    Assert.True(appRunningEvent.Wait(TestConstants.DefaultTimeout));
+                    await appRunningEvent.Task.DefaultTimeout();
                     systemClock.UtcNow += gracePeriod + TimeSpan.FromSeconds(1);
 
                     await connection.Receive(
@@ -100,13 +100,13 @@ namespace Microsoft.AspNetCore.Server.Kestrel.FunctionalTests
                 DateHeaderValueManager = new DateHeaderValueManager(systemClock),
             };
 
-            var appRunningEvent = new ManualResetEventSlim();
+            var appRunningEvent = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
 
             using (var server = new TestServer(context =>
             {
                 context.Features.Get<IHttpMinRequestBodyDataRateFeature>().MinDataRate = null;
 
-                appRunningEvent.Set();
+                appRunningEvent.SetResult(null);
                 return Task.CompletedTask;
             }, serviceContext))
             {
@@ -119,7 +119,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.FunctionalTests
                         "",
                         "");
 
-                    Assert.True(appRunningEvent.Wait(TestConstants.DefaultTimeout));
+                    await appRunningEvent.Task.DefaultTimeout();
 
                     await connection.Receive(
                         "HTTP/1.1 200 OK",

test/Kestrel.FunctionalTests/RequestTests.cs

@@ -1696,8 +1696,8 @@ namespace Microsoft.AspNetCore.Server.Kestrel.FunctionalTests
         [Fact]
         public async Task DoesNotEnforceRequestBodyMinimumDataRateOnUpgradedRequest()
         {
-            var appEvent = new ManualResetEventSlim();
+            var appEvent = new TaskCompletionSource<object>();
-            var delayEvent = new ManualResetEventSlim();
+            var delayEvent = new TaskCompletionSource<object>();
             var serviceContext = new TestServiceContext(LoggerFactory)
             {
                 SystemClock = new SystemClock()
@@ -1710,12 +1710,12 @@ namespace Microsoft.AspNetCore.Server.Kestrel.FunctionalTests
 
                 using (var stream = await context.Features.Get<IHttpUpgradeFeature>().UpgradeAsync())
                 {
-                    appEvent.Set();
+                    appEvent.SetResult(null);
 
                     // Read once to go through one set of TryPauseTimingReads()/TryResumeTimingReads() calls
                     await stream.ReadAsync(new byte[1], 0, 1);
 
-                    delayEvent.Wait();
+                    await delayEvent.Task.DefaultTimeout();
 
                     // Read again to check that the connection is still alive
                     await stream.ReadAsync(new byte[1], 0, 1);
@@ -1735,11 +1735,11 @@ namespace Microsoft.AspNetCore.Server.Kestrel.FunctionalTests
                         "",
                         "a");
 
-                    Assert.True(appEvent.Wait(TestConstants.DefaultTimeout));
+                    await appEvent.Task.DefaultTimeout();
 
                     await Task.Delay(TimeSpan.FromSeconds(5));
 
-                    delayEvent.Set();
+                    delayEvent.SetResult(null);
 
                     await connection.Send("b");
 

test/Kestrel.FunctionalTests/ResponseTests.cs

@@ -1116,12 +1116,11 @@ namespace Microsoft.AspNetCore.Server.Kestrel.FunctionalTests
             var flushed = new SemaphoreSlim(0, 1);
             var serviceContext = new TestServiceContext(LoggerFactory) { ServerOptions = { AllowSynchronousIO = true } };
 
-            using (var server = new TestServer(httpContext =>
+            using (var server = new TestServer(async httpContext =>
             {
                 httpContext.Response.ContentLength = 12;
                 httpContext.Response.Body.Write(Encoding.ASCII.GetBytes("hello, world"), 0, 12);
-                flushed.Wait();
+                await flushed.WaitAsync();
-                return Task.CompletedTask;
             }, serviceContext))
             {
                 using (var connection = server.CreateConnection())
@@ -1152,7 +1151,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.FunctionalTests
             {
                 httpContext.Response.ContentLength = 12;
                 await httpContext.Response.WriteAsync("");
-                flushed.Wait();
+                await flushed.WaitAsync();
                 await httpContext.Response.WriteAsync("hello, world");
             }, new TestServiceContext(LoggerFactory)))
             {
@@ -1180,23 +1179,23 @@ namespace Microsoft.AspNetCore.Server.Kestrel.FunctionalTests
         [Fact]
         public async Task WriteAfterConnectionCloseNoops()
         {
-            var connectionClosed = new ManualResetEventSlim();
+            var connectionClosed = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
-            var requestStarted = new ManualResetEventSlim();
+            var requestStarted = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
-            var tcs = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
+            var appCompleted = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
 
             using (var server = new TestServer(async httpContext =>
             {
                 try
                 {
-                    requestStarted.Set();
+                    requestStarted.SetResult(null);
-                    connectionClosed.Wait();
+                    await connectionClosed.Task.DefaultTimeout();
                     httpContext.Response.ContentLength = 12;
                     await httpContext.Response.WriteAsync("hello, world");
-                    tcs.TrySetResult(null);
+                    appCompleted.TrySetResult(null);
                 }
                 catch (Exception ex)
                 {
-                    tcs.TrySetException(ex);
+                    appCompleted.TrySetException(ex);
                 }
             }, new TestServiceContext(LoggerFactory)))
             {
@@ -1208,14 +1207,14 @@ namespace Microsoft.AspNetCore.Server.Kestrel.FunctionalTests
                         "",
                         "");
 
-                    requestStarted.Wait();
+                    await requestStarted.Task.DefaultTimeout();
                     connection.Shutdown(SocketShutdown.Send);
                     await connection.WaitForConnectionClose().DefaultTimeout();
                 }
 
-                connectionClosed.Set();
+                connectionClosed.SetResult(null);
 
-                await tcs.Task.DefaultTimeout();
+                await appCompleted.Task.DefaultTimeout();
             }
         }
 
@@ -2280,19 +2279,19 @@ namespace Microsoft.AspNetCore.Server.Kestrel.FunctionalTests
             var largeString = new string('a', maxBytesPreCompleted + 1);
 
             var writeTcs = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
-            var requestAbortedWh = new ManualResetEventSlim();
+            var requestAbortedWh = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
-            var requestStartWh = new ManualResetEventSlim();
+            var requestStartWh = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
 
             using (var server = new TestServer(async httpContext =>
             {
-                requestStartWh.Set();
+                requestStartWh.SetResult(null);
 
                 var response = httpContext.Response;
                 var request = httpContext.Request;
                 var lifetime = httpContext.Features.Get<IHttpRequestLifetimeFeature>();
 
-                lifetime.RequestAborted.Register(() => requestAbortedWh.Set());
+                lifetime.RequestAborted.Register(() => requestAbortedWh.SetResult(null));
-                Assert.True(requestAbortedWh.Wait(TestConstants.DefaultTimeout));
+                await requestAbortedWh.Task.DefaultTimeout();
 
                 try
                 {
@@ -2316,15 +2315,15 @@ namespace Microsoft.AspNetCore.Server.Kestrel.FunctionalTests
                         "",
                         "");
 
-                    Assert.True(requestStartWh.Wait(TestConstants.DefaultTimeout));
+                    await requestStartWh.Task.DefaultTimeout();
                 }
 
                 // Write failed - can throw TaskCanceledException or OperationCanceledException,
-                // dependending on how far the canceled write goes.
+                // depending on how far the canceled write goes.
                 await Assert.ThrowsAnyAsync<OperationCanceledException>(async () => await writeTcs.Task).DefaultTimeout();
 
                 // RequestAborted tripped
-                Assert.True(requestAbortedWh.Wait(TestConstants.DefaultTimeout));
+                await requestAbortedWh.Task.DefaultTimeout();
             }
         }
 

test/SystemdActivation/docker.sh

@@ -3,10 +3,11 @@
 set -e
 
 scriptDir=$(dirname "${BASH_SOURCE[0]}")
-PATH="$PWD/.dotnet/:$PATH"
+dotnetDir="$PWD/.build/.dotnet"
+PATH="$dotnetDir:$PATH"
 dotnet publish -f netcoreapp2.2 ./samples/SystemdTestApp/
 cp -R ./samples/SystemdTestApp/bin/Debug/netcoreapp2.2/publish/ $scriptDir
-cp -R ./.dotnet/ $scriptDir
+cp -R $dotnetDir $scriptDir
 
 image=$(docker build -qf $scriptDir/Dockerfile $scriptDir)
 container=$(docker run -Pd $image)