KestrelServer是基于Libuv开发的高性能web服务器，那我们现在就来看一下它是如何工作的。在上一篇文章中提到了Program的Main方法，在这个方法里Build了一个WebHost，我们再来看一下代码：
|
1
2
3
4
5
6
7
8
9
10
11
|
public static void Main(string[] args) { var host = new WebHostBuilder() .UseKestrel() .UseContentRoot(Directory.GetCurrentDirectory()) .UseIISIntegration() .UseStartup<Startup>() .Build(); host.Run(); } |
里面有一个UseKestrel方法调用，这个方法的作用就是使用KestrelServer作为web server来提供web服务。在WebHost启动的时候，调用了IServer的Start方法启动服务，由于我们使用KestrelServer作为web server，自然这里调用的就是KestrelServer.Start方法，那我们来看下KestrelServer的Start方法里主要代码：
首先，我们发现在Start方法里创建了一个KestrelEngine对象，具体代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
var engine = new KestrelEngine(new ServiceContext{ FrameFactory = context => { return new Frame<TContext>(application, context); }, AppLifetime = _applicationLifetime, Log = trace, ThreadPool = new LoggingThreadPool(trace), DateHeaderValueManager = dateHeaderValueManager, ServerOptions = Options }); |
KestrelEngine构造方法接受一个ServiceContext对象参数，ServiceContext里包含一个FrameFactory，从名称上很好理解，就是Frame得工厂，Frame是什么？Frame是http请求处理对象，每个请求过来后，都会交给一个Frame对象进行受理，我们这里先记住它的作用，后面还会看到它是怎么实例化的。除了这个外，还有一个是AppLiftTime，它是一个IApplicationLifetime对象，它是整个应用生命周期的管理对象，前面没有说到，这里补充上。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
public interface IApplicationLifetime { /// <summary> /// Triggered when the application host has fully started and is about to wait /// for a graceful shutdown. /// </summary> CancellationToken ApplicationStarted { get; } /// <summary> /// Triggered when the application host is performing a graceful shutdown. /// Requests may still be in flight. Shutdown will block until this event completes. /// </summary> CancellationToken ApplicationStopping { get; } /// <summary> /// Triggered when the application host is performing a graceful shutdown. /// All requests should be complete at this point. Shutdown will block /// until this event completes. /// </summary> CancellationToken ApplicationStopped { get; } /// <summary> /// Requests termination the current application. /// </summary> void StopApplication(); } |
IApplicationLifetime中提供了三个时间点，
1，ApplicationStarted：应用程序已启动
2，ApplicationStopping：应用程序正在停止
3，ApplicationStopped：应用程序已停止
我们可以通过CancellationToken.Register方法注册回调方法，在上面说到的三个时间点，执行我们特定的业务逻辑。IApplicationLifetime是在WebHost的Start方法里创建的，如果想在我们自己的应用程序获取这个对象，我们可以直接通过依赖注入的方式获取即可。
我们继续回到ServiceContext对象，这里面还包含了Log对象，用于跟踪日志，一般我们是用来看程序执行的过程，并可以通过它发现程序执行出现问题的地方。还包含一个ServerOptions，它是一个KestrelServerOptions，里面包含跟服务相关的配置参数：
1，ThreadCount：服务线程数，表示服务启动后，要开启多少个服务线程，因为每个请求都会使用一个线程来进行处理，多线程会提高吞吐量，但是并不一定线程数越多越好，在系统里默认值是跟CPU内核数相等。
2，ShutdownTimeout：The amount of time after the server begins shutting down before connections will be forcefully closed（在应用程序开始停止到强制关闭当前请求连接所等待的时间，在这个时间段内，应用程序会等待请求处理完，如果还没处理完，将强制关闭）
3，Limits：KestrelServerLimits对象，里面包含了服务限制参数，比如MaxRequestBufferSize，MaxResponseBufferSize
其他参数就不再一个一个说明了。
KestrelEngine对象创建好后，通过调用 engine.Start(threadCount)，根据配置的threadcount进行服务线程KestrelThread实例化，代码如下：
public void Start(int count)
{
for (var index = 0; index < count; index++)
{
Threads.Add(new KestrelThread(this));
}
foreach (var thread in Threads)
{
thread.StartAsync().Wait();
}
}
上面的代码会创建指定数量的Thread对象，然后开始等待任务处理。KestrelThread是对libuv线程处理的封装。
这些工作都准备好后，就开始启动监听服务了
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
foreach (var endPoint in listenOptions) { try { _disposables.Push(engine.CreateServer(endPoint)); } catch (AggregateException ex) { if ((ex.InnerException as UvException)?.StatusCode == Constants.EADDRINUSE) { throw new IOException($"Failed to bind to address {endPoint}: address already in use.", ex); } throw; } // If requested port was "0", replace with assigned dynamic port. _serverAddresses.Addresses.Add(endPoint.ToString()); } |
上面红色字体代码，就是创建监听服务的方法，我们再详细看下里面的详细情况：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
public IDisposable CreateServer(ListenOptions listenOptions) { var listeners = new List<iasyncdisposable>(); try { //如果前面创建的线程数量为1，直接创建listener对象，启动监听 if (Threads.Count == 1) { var listener = new Listener(ServiceContext); listeners.Add(listener); listener.StartAsync(listenOptions, Threads[0]).Wait(); } else { //如果线程数不为1的时候 var pipeName = (Libuv.IsWindows ? @"\.pipekestrel_" : "/tmp/kestrel_") + Guid.NewGuid().ToString("n"); var pipeMessage = Guid.NewGuid().ToByteArray(); //先创建一个主监听对象，这个Listenerprimary就是一个Listener，监听socket就是在这里面创建的 var listenerPrimary = new ListenerPrimary(ServiceContext); listeners.Add(listenerPrimary); //启动监听 listenerPrimary.StartAsync(pipeName, pipeMessage, listenOptions, Threads[0]).Wait(); //为剩余的每个服务线程关联一个ListenerSecondary对象，这个对象使用命名Pipe与主监听对象通信，在主监听对象接收到请求后，通过pipe把接受的socket对象发送给特定的线程处理 foreach (var thread in Threads.Skip(1)) { var listenerSecondary = new ListenerSecondary(ServiceContext); listeners.Add(listenerSecondary); listenerSecondary.StartAsync(pipeName, pipeMessage, listenOptions, thread).Wait(); } } return new Disposable(() => { DisposeListeners(listeners); }); } catch { DisposeListeners(listeners); throw; } }</iasyncdisposable> |
这个时候服务就开始接受http请求了，我们前面说到了，监听socket在listener类中创建（ListenerPrimary也是一个Listener），下面是listener的start方法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
public Task StartAsync( ListenOptions listenOptions, KestrelThread thread) { ListenOptions = listenOptions; Thread = thread; var tcs = new TaskCompletionSource<int>(this); Thread.Post(state => { var tcs2 = (TaskCompletionSource<int>) state; try { var listener = ((Listener) tcs2.Task.AsyncState); //创建监听socket listener.ListenSocket = listener.CreateListenSocket(); //开始监听,当有连接请求过来后，触发ConnectionCallback方法 ListenSocket.Listen(Constants.ListenBacklog, ConnectionCallback, this); tcs2.SetResult(0); } catch (Exception ex) { tcs2.SetException(ex); } }, tcs); return tcs.Task; }</int></int> |
ConnectionCallback：当连接请求过来后被触发，在回调方法里，进行连接处理分发，连接分发代码如下：
|
1
2
3
4
5
|
protected virtual void DispatchConnection(UvStreamHandle socket) { var connection = new Connection(this, socket); connection.Start(); } |
这个是listener类中的实现，我们前面看到，只有在线程数为1的情况下，才创建Listener对象进行监听，否则创建ListenerPrimary监听，ListenerPrimay里重写了方法，它的实现如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
protected override void DispatchConnection(UvStreamHandle socket) { //这里采用轮询的方式，把连接请求依次分发给不同的线程进行处理 var index = _dispatchIndex++ % (_dispatchPipes.Count + 1); if (index == _dispatchPipes.Count) { // base.DispatchConnection(socket); } else { DetachFromIOCP(socket); var dispatchPipe = _dispatchPipes[index]; //这里就是通过命名pipe，传递socket给特定的线程 var write = new UvWriteReq(Log); write.Init(Thread.Loop); write.Write2( dispatchPipe, _dummyMessage, socket, (write2, status, error, state) => { write2.Dispose(); ((UvStreamHandle)state).Dispose(); }, socket); } } |
好了，连接请求找到处理线程后，后面就可以开始处理工作了。ListenerSecondary里的代码比较复杂，其实最终都会调用下面的代码完成Connection对象的创建
|
1
2
|
var connection = new Connection(this, socket);connection.Start(); |
Connection表示的就是当前连接，下面是它的构造方法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
public Connection(ListenerContext context, UvStreamHandle socket) : base(context) { _socket = socket; _connectionAdapters = context.ListenOptions.ConnectionAdapters; socket.Connection = this; ConnectionControl = this; ConnectionId = GenerateConnectionId(Interlocked.Increment(ref _lastConnectionId)); if (ServerOptions.Limits.MaxRequestBufferSize.HasValue) { _bufferSizeControl = new BufferSizeControl(ServerOptions.Limits.MaxRequestBufferSize.Value,this); } //创建输入输出socket流 Input = new SocketInput(Thread.Memory, ThreadPool, _bufferSizeControl); Output = new SocketOutput(Thread, _socket, this, ConnectionId, Log, ThreadPool); var tcpHandle = _socket as UvTcpHandle; if (tcpHandle != null) { RemoteEndPoint = tcpHandle.GetPeerIPEndPoint(); LocalEndPoint = tcpHandle.GetSockIPEndPoint(); } //创建处理frame，这里的framefactory就是前面创建KestrelEngine时创建的工厂 _frame = FrameFactory(this); _lastTimestamp = Thread.Loop.Now(); } |
然后调用Connection的Start方法开始进行处理，这里面直接把处理任务交给Frame处理，Start方法实现：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public void Start() { Reset(); //启动了异步处理任务开始进行处理 _requestProcessingTask = Task.Factory.StartNew( (o) => ((Frame)o).RequestProcessingAsync(),//具体的处理方法 this, default(CancellationToken), TaskCreationOptions.DenyChildAttach, TaskScheduler.Default).Unwrap(); _frameStartedTcs.SetResult(null); } |
| 1 | RequestProcessingAsync方法里不再详细介绍了，把主要的代码拿出来看一下： |
|
1
2
3
4
5
|
。。。。。//_application就是上一篇文章提到的HostApplication，首先调用CreateContext创建HttpContext对象var context = _application.CreateContext(this);。。。。。。//进入处理管道await _application.ProcessRequestAsync(context).ConfigureAwait(false);。。。。。。 |
| 1 | ProcessRequestAsync完成处理后，把结果输出给客户端，好到此介绍完毕。如果有问题，欢迎大家指点。 |