今天这一篇博客讲的是.net core 自带的kestrel server，当你开发微服务k8s部署在linux环境下，一般默认开启这个高性能服务，如果大家之前看过我的owin katana的博客，会发现.net core 的好多实现在之前.net standard 的版本已经实现过了，当时开发的asp.net 程序与IIS紧紧耦合在一起，后来的微软团队意识到这个问题并尝试将asp.net 解耦server，制定了owin标准并启动了一个开源项目katana，这个项目的结果并没有带动社区效应，但是此时微软已经制订了.net core的开发，并在katana文档暗示了.net vnext 版本，这个就是。net core 与owin katana 的故事。强烈建议大家有时间看看owin katana,里面有一些 dependency inject, hash map, raw http 协议等等实现。非常收益。说到这些我们开始步入正题吧。原代码在github上的asp.net core 源码。

上图大致地描述了一个asp.net core 的请求过程，但是我们会发现appication 依赖了server，所以我们需要一个Host 的去解耦server 和aplication 的实现，只要server符合host标准可以任意更换，解耦之后的代码与下图所示。

所以我们的代码都是创建一个web host然后使用usekestrel,如下所示。

        var host = new WebHostBuilder()  
            .UseKestrel(options =>  
            {  
                options.Listen(IPAddress.Loopback, 5001);  
            })  
            .UseStartup<Startup>();

首先我们知道一个server 实现需要网络编程，所以我们需要socket库来快速编程，它已经帮你实现了tcp与udp协议，不需要自己重复的造轮子。首先我们需要看UseKestrel的方法做了什么。

1 public static IWebHostBuilder UseKestrel(this IWebHostBuilder hostBuilder)
2 {
3 return hostBuilder.ConfigureServices(services =>
4 {
5 // Don't override an already-configured transport
6 services.TryAddSingleton();
7
8 services.AddTransient, KestrelServerOptionsSetup>();
9 services.AddSingleton();
10 });
11 }

依赖注入注册了三个对象，一个连接池，一个配置类还有一个是server，会和web host注册了IServer 的实现类,然后我们继续看一下，当你调用run的时候会将控制权从web host 转移给server，如下代码第18行所示。

1 public virtual async Task StartAsync(CancellationToken cancellationToken = default)
2 {
3 HostingEventSource.Log.HostStart(); 6
7 var application = BuildApplication();
8
12 // Fire IHostedService.Start
13 await _hostedServiceExecutor.StartAsync(cancellationToken).ConfigureAwait(false);//启动后台服务
14
15 var diagnosticSource = _applicationServices.GetRequiredService();
16 var httpContextFactory = _applicationServices.GetRequiredService();
17 var hostingApp = new HostingApplication(application, _logger, diagnosticSource, httpContextFactory);
18 await Server.StartAsync(hostingApp, cancellationToken).ConfigureAwait(false);//socket 启动
19 _startedServer = true;
20
21 // Fire IApplicationLifetime.Started
22 _applicationLifetime?.NotifyStarted();
23
24
25 _logger.Started();
26
27 // Log the fact that we did load hosting startup assemblies.
28 if (_logger.IsEnabled(LogLevel.Debug))
29 {
30 foreach (var assembly in _options.GetFinalHostingStartupAssemblies())
31 {
32 _logger.LogDebug("Loaded hosting startup assembly {assemblyName}", assembly);
33 }
34 }
35
36 if (_hostingStartupErrors != null)
37 {
38 foreach (var exception in _hostingStartupErrors.InnerExceptions)
39 {
40 _logger.HostingStartupAssemblyError(exception);
41 }
42 }
43 }

当我们转进到StartAsync方法时会看到如下代码

1 public async Task StartAsync(IHttpApplication application, CancellationToken cancellationToken)
2 {
3 try
4 {
19 // ServiceContext.Heartbeat?.Start();//一个是连接池一个是日期时间
20
21 async Task OnBind(ListenOptions options)
22 {
23 // Add the HTTP middleware as the terminal connection middleware
24 options.UseHttpServer(ServiceContext, application, options.Protocols);//注册中间件
25
26 var connectionDelegate = options.Build();
27
28 // Add the connection limit middleware
29 if (Options.Limits.MaxConcurrentConnections.HasValue)
30 {
31 connectionDelegate = new ConnectionLimitMiddleware(connectionDelegate, Options.Limits.MaxConcurrentConnections.Value, Trace).OnConnectionAsync;
32 }
33
34 var connectionDispatcher = new ConnectionDispatcher(ServiceContext, connectionDelegate);
35 var transport = await _transportFactory.BindAsync(options.EndPoint).ConfigureAwait(false);
36
37 // Update the endpoint
38 options.EndPoint = transport.EndPoint;
39 var acceptLoopTask = connectionDispatcher.StartAcceptingConnections(transport);
40
41 _transports.Add((transport, acceptLoopTask));
42 }
43
44 await AddressBinder.BindAsync(_serverAddresses, Options, Trace, OnBind).ConfigureAwait(false);
45 }
46 catch (Exception ex)
47 {51 }
52 }

AddressBinder就是server绑定的ip地址，这个可以在StartUp方法或者环境变量里面配置，里面传了一个回调方法OnBind, 在第24行的UseHttpServer会注册server 内部的中间件去处理这个请求，在第35行socet会绑定地址，用tcp协议，默认使用512个最大pending队列，在接受socket会有多处异步编程和开启线程，建议大家在调试的时候可以修改代码用尽可能少的线程来进行调试。accept 的代码如下图所示

1 private void StartAcceptingConnectionsCore(IConnectionListener listener)
2 {
3 // REVIEW: Multiple accept loops in parallel?
4 _ = AcceptConnectionsAsync();
5
6 async Task AcceptConnectionsAsync()
7 {
8 try
9 {
10 while (true)
11 {
12 var connection = await listener.AcceptAsync();
13 19
20 // Add the connection to the connection manager before we queue it for execution
21 var id = Interlocked.Increment(ref _lastConnectionId);
22 var kestrelConnection = new KestrelConnection(id, _serviceContext, _connectionDelegate, connection, Log);
23
24 _serviceContext.ConnectionManager.AddConnection(id, kestrelConnection);27
28 ThreadPool.UnsafeQueueUserWorkItem(kestrelConnection, preferLocal: false);
29 }
30 }
31 catch (Exception ex)
32 {
33 // REVIEW: If the accept loop ends should this trigger a server shutdown? It will manifest as a hang
34 Log.LogCritical(0, ex, "The connection listener failed to accept any new connections.");
35 }
36 finally
37 {
38 _acceptLoopTcs.TrySetResult(null);
39 }
40 }
41 }

接收到accept socket的时候，会创建一个kestrelconnection 对象，这个对象实现线程方法，然后它会重新去等待一个请求的到来，而用户代码的执行则交给线程池执行。在第14行就是之前kerstrel server 内部的中间件build生成的方法，他的主要功能就是解析socket的携带http信息。

1 internal async Task ExecuteAsync()
2 {
3 var connectionContext = TransportConnection;
4
5 try
6 {
10 using (BeginConnectionScope(connectionContext))
11 {
12 try
13 {
14 await _connectionDelegate(connectionContext);
15 }
16 catch (Exception ex)
17 {
18 Logger.LogError(0, ex, "Unhandled exception while processing {ConnectionId}.", connectionContext.ConnectionId);
19 }
20 }
21 }
22 finally
23 {
34 _serviceContext.ConnectionManager.RemoveConnection(_id);
35 }
36 }

由于http协议版本的不一致导致解析方式的不同，如果有兴趣的小伙伴可以具体查看这一块的逻辑。

1 switch (SelectProtocol())
2 {
3 case HttpProtocols.Http1:
4 // _http1Connection must be initialized before adding the connection to the connection manager
5 requestProcessor = _http1Connection = new Http1Connection(_context);
6 _protocolSelectionState = ProtocolSelectionState.Selected;
7 break;
8 case HttpProtocols.Http2:
9 // _http2Connection must be initialized before yielding control to the transport thread,
10 // to prevent a race condition where _http2Connection.Abort() is called just as
11 // _http2Connection is about to be initialized.
12 requestProcessor = new Http2Connection(_context);
13 _protocolSelectionState = ProtocolSelectionState.Selected;
14 break;
15 case HttpProtocols.None:
16 // An error was already logged in SelectProtocol(), but we should close the connection.
17 break;
18 default:
19 // SelectProtocol() only returns Http1, Http2 or None.
20 throw new NotSupportedException($"{nameof(SelectProtocol)} returned something other than Http1, Http2 or None.");
21 }

然后server解析完请求之后所做的重要的一步就是创建httpContext,然后server在第40行将控制权转给web host，web host 会自动调用application code 也就是用户代码。

1 private async Task ProcessRequests(IHttpApplication application)
2 {
3 while (_keepAlive)
4 {
33 var context = application.CreateContext(this);
34
35 try
36 {
37 KestrelEventSource.Log.RequestStart(this);
38
39 // Run the application code for this request
40 await application.ProcessRequestAsync(context);
41 55 }
56 catch (BadHttpRequestException ex)
57 {
58 // Capture BadHttpRequestException for further processing
59 // This has to be caught here so StatusCode is set properly before disposing the HttpContext
60 // (DisposeContext logs StatusCode).
61 SetBadRequestState(ex);
62 ReportApplicationError(ex);
63 }
64 catch (Exception ex)
65 {
66 ReportApplicationError(ex);
67 }
68
69 KestrelEventSource.Log.RequestStop(this);129 }
130 }

到这里server 的工作大部分都结束了，在之前的描述中我们看到web host 怎么将控制权给到server 的， server 创建好httpContext规则后又是如何将控制权给到web host ， web host 又如何去调用application code的， web host 实际上build 的时候将用户的中间件定义为链表结构暴露一个入口供web host调用，其他的有时间我会再写博客描述这一块。谢谢大家今天的阅读了。欢迎大家能够留言一起讨论。最后谢谢大家的阅读，如果有任何不懂的地方可以私信我。