namespace Microsoft.AspNetCore.Hosting.Server
{/// <summary>/// Represents a server./// </summary>public interface IServer : IDisposable{/// <summary>/// A collection of HTTP features of the server./// </summary>IFeatureCollection Features { get; }/// <summary>/// Start the server with an application./// </summary>/// <param name="application">An instance of <see cref="IHttpApplication{TContext}"/>.</param>/// <typeparam name="TContext">The context associated with the application.</typeparam>/// <param name="cancellationToken">Indicates if the server startup should be aborted.</param>Task StartAsync<TContext>(IHttpApplication<TContext> application, CancellationToken cancellationToken);/// <summary>/// Stop processing requests and shut down the server, gracefully if possible./// </summary>/// <param name="cancellationToken">Indicates if the graceful shutdown should be aborted.</param>Task StopAsync(CancellationToken cancellationToken);}
}

namespace Microsoft.AspNetCore.Hosting.Server
{/// <summary>/// Represents an application./// </summary>/// <typeparam name="TContext">The context associated with the application.</typeparam>public interface IHttpApplication<TContext>{/// <summary>/// Create a TContext given a collection of HTTP features./// </summary>/// <param name="contextFeatures">A collection of HTTP features to be used for creating the TContext.</param>/// <returns>The created TContext.</returns>TContext CreateContext(IFeatureCollection contextFeatures);/// <summary>/// Asynchronously processes an TContext./// </summary>/// <param name="context">The TContext that the operation will process.</param>Task ProcessRequestAsync(TContext context);/// <summary>/// Dispose a given TContext./// </summary>/// <param name="context">The TContext to be disposed.</param>/// <param name="exception">The Exception thrown when processing did not complete successfully, otherwise null.</param>void DisposeContext(TContext context, Exception exception);}
}

public async Task StartAsync<TContext>(IHttpApplication<TContext> application, CancellationToken cancellationToken){try{if (!BitConverter.IsLittleEndian){throw new PlatformNotSupportedException(CoreStrings.BigEndianNotSupported);}ValidateOptions();if (_hasStarted){// The server has already started and/or has not been cleaned up yetthrow new InvalidOperationException(CoreStrings.ServerAlreadyStarted);}_hasStarted = true;ServiceContext.Heartbeat?.Start();async Task OnBind(ListenOptions options){// Add the HTTP middleware as the terminal connection middlewareoptions.UseHttpServer(ServiceContext, application, options.Protocols);var connectionDelegate = options.Build();// Add the connection limit middlewareif (Options.Limits.MaxConcurrentConnections.HasValue){connectionDelegate = new ConnectionLimitMiddleware(connectionDelegate, Options.Limits.MaxConcurrentConnections.Value, Trace).OnConnectionAsync;}var connectionDispatcher = new ConnectionDispatcher(ServiceContext, connectionDelegate);var transport = await _transportFactory.BindAsync(options.EndPoint).ConfigureAwait(false);// Update the endpointoptions.EndPoint = transport.EndPoint;var acceptLoopTask = connectionDispatcher.StartAcceptingConnections(transport);_transports.Add((transport, acceptLoopTask));}await AddressBinder.BindAsync(_serverAddresses, Options, Trace, OnBind).ConfigureAwait(false);}catch (Exception ex){Trace.LogCritical(0, ex, "Unable to start Kestrel.");Dispose();throw;}}

internal class HttpConnectionMiddleware<TContext>{private readonly ServiceContext _serviceContext;private readonly IHttpApplication<TContext> _application;private readonly HttpProtocols _protocols;public HttpConnectionMiddleware(ServiceContext serviceContext, IHttpApplication<TContext> application, HttpProtocols protocols){_serviceContext = serviceContext;_application = application;_protocols = protocols;}public Task OnConnectionAsync(ConnectionContext connectionContext){var memoryPoolFeature = connectionContext.Features.Get<IMemoryPoolFeature>();var httpConnectionContext = new HttpConnectionContext{ConnectionId = connectionContext.ConnectionId,ConnectionContext = connectionContext,Protocols = _protocols,ServiceContext = _serviceContext,ConnectionFeatures = connectionContext.Features,MemoryPool = memoryPoolFeature.MemoryPool,Transport = connectionContext.Transport,LocalEndPoint = connectionContext.LocalEndPoint as IPEndPoint,RemoteEndPoint = connectionContext.RemoteEndPoint as IPEndPoint};var connection = new HttpConnection(httpConnectionContext);return connection.ProcessRequestsAsync(_application);}}

public async Task ProcessRequestsAsync<TContext>(IHttpApplication<TContext> httpApplication){try{// Ensure TimeoutControl._lastTimestamp is initialized before anything that could set timeouts runs._timeoutControl.Initialize(_systemClock.UtcNowTicks);IRequestProcessor requestProcessor = null;switch (SelectProtocol()){case HttpProtocols.Http1:// _http1Connection must be initialized before adding the connection to the connection managerrequestProcessor = _http1Connection = new Http1Connection<TContext>(_context);_protocolSelectionState = ProtocolSelectionState.Selected;break;case HttpProtocols.Http2:// _http2Connection must be initialized before yielding control to the transport thread,// to prevent a race condition where _http2Connection.Abort() is called just as// _http2Connection is about to be initialized.requestProcessor = new Http2Connection(_context);_protocolSelectionState = ProtocolSelectionState.Selected;break;case HttpProtocols.None:// An error was already logged in SelectProtocol(), but we should close the connection.break;default:// SelectProtocol() only returns Http1, Http2 or None.throw new NotSupportedException($"{nameof(SelectProtocol)} returned something other than Http1, Http2 or None.");}_requestProcessor = requestProcessor;if (requestProcessor != null){var connectionHeartbeatFeature = _context.ConnectionFeatures.Get<IConnectionHeartbeatFeature>();var connectionLifetimeNotificationFeature = _context.ConnectionFeatures.Get<IConnectionLifetimeNotificationFeature>();// These features should never be null in Kestrel itself, if this middleware is ever refactored to run outside of kestrel,// we'll need to handle these missing.Debug.Assert(connectionHeartbeatFeature != null, nameof(IConnectionHeartbeatFeature) + " is missing!");Debug.Assert(connectionLifetimeNotificationFeature != null, nameof(IConnectionLifetimeNotificationFeature) + " is missing!");// Register the various callbacks once we're going to start processing requests// The heart beat for various timeoutsconnectionHeartbeatFeature?.OnHeartbeat(state => ((HttpConnection)state).Tick(), this);// Register for graceful shutdown of the serverusing var shutdownRegistration = connectionLifetimeNotificationFeature?.ConnectionClosedRequested.Register(state => ((HttpConnection)state).StopProcessingNextRequest(), this);// Register for connection closeusing var closedRegistration = _context.ConnectionContext.ConnectionClosed.Register(state => ((HttpConnection)state).OnConnectionClosed(), this);await requestProcessor.ProcessRequestsAsync(httpApplication);}}catch (Exception ex){Log.LogCritical(0, ex, $"Unexpected exception in {nameof(HttpConnection)}.{nameof(ProcessRequestsAsync)}.");}finally{if (_http1Connection?.IsUpgraded == true){_context.ServiceContext.ConnectionManager.UpgradedConnectionCount.ReleaseOne();}}}