Default config reloadOnChange to false

Author: halter73

src/Servers/Kestrel/Core/src/KestrelServerOptions.cs

@@ -208,13 +208,11 @@ private void EnsureDefaultCert()
         /// <summary>
         /// Creates a configuration loader for setting up Kestrel that takes an <see cref="IConfiguration"/> as input.
         /// This configuration must be scoped to the configuration section for Kestrel.
-        /// Kestrel will dynamically update endpoint bindings when configuration changes.
-        /// This will only reload endpoints defined in the "Endpoints" section of your <paramref name="config"/>. Endpoints defined in code will not be reloaded.
-        /// Call <see cref="Configure(IConfiguration, bool)"/> to disable dynamic endpoint binding updates.
+        /// Call <see cref="Configure(IConfiguration, bool)"/> to enable dynamic endpoint binding updates.
         /// </summary>
         /// <param name="config">The configuration section for Kestrel.</param>
         /// <returns>A <see cref="KestrelConfigurationLoader"/> for further endpoint configuration.</returns>
-        public KestrelConfigurationLoader Configure(IConfiguration config) => Configure(config, true);
+        public KestrelConfigurationLoader Configure(IConfiguration config) => Configure(config, reloadOnChange: false);
 
         /// <summary>
         /// Creates a configuration loader for setting up Kestrel that takes an <see cref="IConfiguration"/> as input.

src/Servers/Kestrel/Core/test/KestrelServerTests.cs

@@ -458,7 +458,7 @@ public void StartingServerInitializesHeartbeat()
         }
 
         [Fact]
-        public async Task ReloadsOnConfigurationChangeByDefault()
+        public async Task ReloadsOnConfigurationChangeWhenOptedIn()
         {
             var currentConfig = new ConfigurationBuilder().AddInMemoryCollection(new[]
             {
@@ -501,7 +501,7 @@ public async Task ReloadsOnConfigurationChangeByDefault()
                 ApplicationServices = serviceCollection.BuildServiceProvider(),
             };
 
-            options.Configure(mockConfig.Object);
+            options.Configure(mockConfig.Object, reloadOnChange: true);
 
             var mockTransports = new List<Mock<IConnectionListener>>();
             var mockTransportFactory = new Mock<IConnectionListenerFactory>();
@@ -611,6 +611,65 @@ public async Task ReloadsOnConfigurationChangeByDefault()
             }
         }
 
+        [Fact]
+        public async Task DoesNotReloadOnConfigurationChangeByDefault()
+        {
+            var currentConfig = new ConfigurationBuilder().AddInMemoryCollection(new[]
+            {
+                new KeyValuePair<string, string>("Endpoints:A:Url", "http://*:5000"),
+                new KeyValuePair<string, string>("Endpoints:B:Url", "http://*:5001"),
+            }).Build();
+
+            var mockConfig = new Mock<IConfiguration>();
+            mockConfig.Setup(c => c.GetSection(It.IsAny<string>())).Returns<string>(name => currentConfig.GetSection(name));
+            mockConfig.Setup(c => c.GetChildren()).Returns(() => currentConfig.GetChildren());
+
+            var mockLoggerFactory = new Mock<ILoggerFactory>();
+            mockLoggerFactory.Setup(m => m.CreateLogger(It.IsAny<string>())).Returns(Mock.Of<ILogger>());
+
+            var serviceCollection = new ServiceCollection();
+            serviceCollection.AddSingleton(mockLoggerFactory.Object);
+            serviceCollection.AddSingleton(Mock.Of<ILogger<KestrelServer>>());
+
+            var options = new KestrelServerOptions
+            {
+                ApplicationServices = serviceCollection.BuildServiceProvider(),
+            };
+
+            options.Configure(mockConfig.Object);
+
+            var mockTransports = new List<Mock<IConnectionListener>>();
+            var mockTransportFactory = new Mock<IConnectionListenerFactory>();
+            mockTransportFactory
+                .Setup(transportFactory => transportFactory.BindAsync(It.IsAny<EndPoint>(), It.IsAny<CancellationToken>()))
+                .Returns<EndPoint, CancellationToken>((e, token) =>
+                {
+                    var mockTransport = new Mock<IConnectionListener>();
+                    mockTransport
+                        .Setup(transport => transport.AcceptAsync(It.IsAny<CancellationToken>()))
+                        .Returns(new ValueTask<ConnectionContext>(result: null));
+                    mockTransport
+                        .Setup(transport => transport.EndPoint)
+                        .Returns(e);
+
+                    mockTransports.Add(mockTransport);
+
+                    return new ValueTask<IConnectionListener>(mockTransport.Object);
+                });
+
+            // Don't use "using". Dispose() could hang if test fails.
+            var server = new KestrelServer(Options.Create(options), new List<IConnectionListenerFactory>() { mockTransportFactory.Object }, mockLoggerFactory.Object);
+
+            await server.StartAsync(new DummyApplication(), CancellationToken.None).DefaultTimeout();
+
+            mockTransportFactory.Verify(f => f.BindAsync(new IPEndPoint(IPAddress.IPv6Any, 5000), It.IsAny<CancellationToken>()), Times.Once);
+            mockTransportFactory.Verify(f => f.BindAsync(new IPEndPoint(IPAddress.IPv6Any, 5001), It.IsAny<CancellationToken>()), Times.Once);
+
+            mockConfig.Verify(c => c.GetReloadToken(), Times.Never);
+
+            await server.StopAsync(CancellationToken.None).DefaultTimeout();
+        }
+
         private static KestrelServer CreateServer(KestrelServerOptions options, ILogger testLogger)
         {
             return new KestrelServer(Options.Create(options), new List<IConnectionListenerFactory>() { new MockTransportFactory() }, new LoggerFactory(new[] { new KestrelTestLoggerProvider(testLogger) }));