.net core 源码解析-web app是如何启动并接收处理请求(二) kestrel的启动

2023-11-06 19:18

本文主要是介绍.net core 源码解析-web app是如何启动并接收处理请求(二) kestrel的启动,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

上篇讲到.net core web app是如何启动并接受请求的,下面接着探索kestrel server是如何完成此任务的。

1.kestrel server的入口KestrelServer.Start (Microsoft.AspNetCore.Hosting.Server.IHttpApplication )

FrameFactory创建的frame实例最终会交给libuv的loop回调接收请求。但是在这过程中还是有很多的初始化工作需要做的。后面我们就管中窥豹来看一看。

public void Start<TContext>(IHttpApplication<TContext> application)
{  
   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});    //启动引擎。完成libuv的配置和启动engine.Start(threadCount);  
   //针对绑定的多个地址创建server来接收请求。也就是针对ip:port来启动tcp监听foreach (var address in _serverAddresses.Addresses.ToArray()){engine.CreateServer(ipv4Address);} }

2.启动kestrel engine。engine.Start(threadCount);

启动绑定的端口*最大处理线程的thread。并初始化libuv组件。
每一个线程初始化libuv,注册loop回调等,并启动libuv。

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();} }

private
void ThreadStart(object parameter)
{
   lock (_startSync){    
       var tcs = (TaskCompletionSource<int>) parameter;    
        try{            //初始化loop_loop.Init(_engine.Libuv);        
            //注册loop回调//EnqueueCloseHandle:持有的资源释放后的回调方法,回调往queue内增加一个item,事件循环该queue完成资源的最终释放_post.Init(_loop, OnPost, EnqueueCloseHandle);    
                //注册心跳定时器_heartbeatTimer.Init(_loop, EnqueueCloseHandle);      
            //启动心跳定时器_heartbeatTimer.Start(OnHeartbeat, timeout: HeartbeatMilliseconds, repeat: HeartbeatMilliseconds);_initCompleted = true;tcs.SetResult(0);}      
        catch (Exception ex){tcs.SetException(ex);    
               return;}}  
    try{      
         //当前线程执行到Run()这里会挂起_loop.Run();      
      //应用程序stop,shutdown之类的情况,libuv唤醒当前线程,完成资源清理if (_stopImmediate){            // thread-abort form of exit, resources will be leaked//线程中止形式的退出,资源会被泄露。return;}        // run the loop one more time to delete the open handles//再次运行循环以删除打开的句柄_post.Reference();_post.Dispose();_heartbeatTimer.Dispose();        // Ensure the Dispose operations complete in the event loop.//确保事件循环中的Dispose操作完成。_loop.Run();_loop.Dispose();}  
    catch (Exception ex){_closeError = ExceptionDispatchInfo.Capture(ex);      
      // Request shutdown so we can rethrow this exception// in Stop which should be observable.//请求关闭,以便我们可以重新抛出此异常在停止应该是可观察的。_appLifetime.StopApplication();}  
    finally{_threadTcs.SetResult(null);} }

3.libuv启动完成之后,接着就是处理订阅注册tcp了。

回到1的kestrel的start中。接着执行engine.CreateServer(ipv4Address);,这里和.net 里面的tcplistener不太一样。.net里面就是listener bind,start,accept就好了。而libuv涉及到一个多路io复用的概念,这也是为什么使用他能高并发的原因。

public IDisposable CreateServer(ServerAddress address){ 
   var usingPipes = address.IsUnixPipe;  
    var pipeName = (Libuv.IsWindows ? @"\\.\pipe\kestrel_" : "/tmp/kestrel_") + Guid.NewGuid().ToString("n");  
    var single = Threads.Count == 1;  
     var first = true;  
    foreach (var thread in Threads){        if(single){}//single就不考虑,这种情况真是环境是不会这样玩的else if (first)      
       
{            //根据当前平台创建tcp listenervar listener = usingPipes? (ListenerPrimary)new PipeListenerPrimary(ServiceContext): new TcpListenerPrimary(ServiceContext);listener.StartAsync(pipeName, address, thread).Wait();}    
       else{            //如果是多次对同一个ip:port做监听var listener = usingPipes? (ListenerSecondary)new PipeListenerSecondary(ServiceContext): new TcpListenerSecondary(ServiceContext);listener.StartAsync(pipeName, address, thread).Wait();}first = false;} }

tcplistener启动细节,这里就只看TcpListenerPrimary了。

首先说明一下TcpListenerPrimary这个类的继承关系:TcpListenerPrimary -->ListenerPrimary -->Listener。这样才有助于后续代码的理解。
后续代码到处都能看到thread.post/postaysnc的代码。这玩意的意思是把传入的action放到libuv loop中,并激活异步完成回调。libuv另一个重要的概念各种回调。
1.接着上面的代码,我们进入TcpListenerPrimary.StartAsync()方法。方法在ListenerPrimary中。

public async Task StartAsync(string pipeName, ServerAddress address, KestrelThread thread){_pipeName = pipeName;  
   await StartAsync(address, thread).ConfigureAwait(false);  
   await Thread.PostAsync(state => ((ListenerPrimary)state).PostCallback(), this).ConfigureAwait(false); }

2.接着上面的代码进入StartAsync(address, thread)。他是父类Listener的方法。

public Task StartAsync(ServerAddress address, KestrelThread thread){ServerAddress = address; Thread = thread;  
  var tcs = new TaskCompletionSource<int>(this);Thread.Post(state =>{        var tcs2 = (TaskCompletionSource<int>)state;      
        var listener = ((Listener)tcs2.Task.AsyncState);        //创建socketlistener.ListenSocket = listener.CreateListenSocket();        ////socket监听,libu注册监听并设置回调函数,最大队列。ListenSocket.Listen(Constants.ListenBacklog, ConnectionCallback, this);tcs2.SetResult(0);}, tcs);  
    return tcs.Task; }

protected
override UvStreamHandle CreateListenSocket()
{    //初始化socket并bind到addressvar socket = new UvTcpHandle(Log);socket.Init(Thread.Loop, Thread.QueueCloseHandle);    //是否使用Nagle's algorithm算法。socket.NoDelay(ServerOptions.NoDelay);socket.Bind(ServerAddress);  
 // If requested port was "0", replace with assigned dynamic port.ServerAddress.Port = socket.GetSockIPEndPoint().Port;  
   return socket; }

在接着上面的代码ListenSocket.Listen成功之后,libuv回调ConnectionCallback函数。

进入ConnectionCallback函数,完成重要的listen Accept.

step1:listen成功libuv回调ConnectionCallback方法。
step2:初始化接收请求socket,并将之关联到监听socket
step3:适配接收请求socket,如果是第一次适配的话则创建connection
step4:创建connection并启动
step5:new connection 关联 Frame 对象。
step6:启动frame
step7:由Connection类调用一次以开始RequestProcessingAsync循环。
step8:循环接收请求,接收请求到之后交给上层程序处理

private static void ConnectionCallback(UvStreamHandle stream, int status, Exception error, object state){    
   var listener = (Listener)state;listener.OnConnection(stream, status);//step 1}

protected override void OnConnection(UvStreamHandle listenSocket, int status)//step 2{    var acceptSocket = new UvTcpHandle(Log);acceptSocket.Init(Thread.Loop, Thread.QueueCloseHandle);acceptSocket.NoDelay(ServerOptions.NoDelay);listenSocket.Accept(acceptSocket);DispatchConnection(acceptSocket); }

protected override void DispatchConnection(UvStreamHandle socket)// step 3
{  
   var index = _dispatchIndex++ % (_dispatchPipes.Count + 1);  
   if (index == _dispatchPipes.Count){    
      base.DispatchConnection(socket);}    
   else{DetachFromIOCP(socket);  
       var dispatchPipe = _dispatchPipes[index];    
       var write = new UvWriteReq(Log);write.Init(Thread.Loop);write.Write2(dispatchPipe, _dummyMessage, socket,(write2, status, error, state) =>{write2.Dispose();((UvStreamHandle)state).Dispose();},socket);} }
    
protected virtual void DispatchConnection(UvStreamHandle socket)//step 4
{  
  var connection = new Connection(this, socket);connection.Start(); }

private
Func<ConnectionContext, Frame> FrameFactory => ListenerContext.ServiceContext.FrameFactory;public Connection(ListenerContext context, UvStreamHandle socket) : base(context)//step 5
{SocketInput = new SocketInput(Thread.Memory, ThreadPool, _bufferSizeControl);SocketOutput = new SocketOutput(Thread, _socket, this, ConnectionId, Log, ThreadPool);  
 //重点代码在这里,FrameFactory是一个委托,是KestrelServer.Start中注册的action_frame = FrameFactory(this); }
 
public void Start()//step 6
{Log.ConnectionStart(ConnectionId);    
 // Start socket prior to applying the ConnectionFilter_socket.ReadStart(_allocCallback, _readCallback, this);_frame.Start(); }

/// <summary>
/// Called once by Connection class to begin the RequestProcessingAsync loop.
/// </summary>
public void Start()//step 7
{Reset();_requestProcessingTask =Task.Factory.StartNew((o) => ((Frame)o).RequestProcessingAsync(),            this,            default(CancellationToken),TaskCreationOptions.DenyChildAttach,TaskScheduler.Default).Unwrap(); }

/// <summary>
/// 主循环消耗套接字输入,将其解析为协议帧,并调用应用程序委托,只要套接字打算保持打开。
/// 从此循环得到的任务将保留在服务器需要时使用的字段中以排除和关闭所有当前活动的连接。/// </summary>
public override async Task RequestProcessingAsync(){
   while (!_requestProcessingStopping){InitializeHeaders();      
     var context = _application.CreateContext(this);  
      await application.ProcessRequestAsync(context).ConfigureAwait(false);} }

相关文章:

  • .net core 源码解析-web app是如何启动并接收处理请求

原文地址:http://www.cnblogs.com/calvinK/p/6126020.html


.NET社区新闻,深度好文,微信中搜索dotNET跨平台或扫描二维码关注

这篇关于.net core 源码解析-web app是如何启动并接收处理请求(二) kestrel的启动的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!


原文地址:
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.chinasem.cn/article/358534

相关文章

Java docx4j高效处理Word文档的实战指南

《Javadocx4j高效处理Word文档的实战指南》对于需要在Java应用程序中生成、修改或处理Word文档的开发者来说,docx4j是一个强大而专业的选择,下面我们就来看看docx4j的具体使用... 目录引言一、环境准备与基础配置1.1 Maven依赖配置1.2 初始化测试类二、增强版文档操作示例2.

MyBatis-Plus通用中等、大量数据分批查询和处理方法

《MyBatis-Plus通用中等、大量数据分批查询和处理方法》文章介绍MyBatis-Plus分页查询处理,通过函数式接口与Lambda表达式实现通用逻辑,方法抽象但功能强大,建议扩展分批处理及流式... 目录函数式接口获取分页数据接口数据处理接口通用逻辑工具类使用方法简单查询自定义查询方法总结函数式接口

nginx -t、nginx -s stop 和 nginx -s reload 命令的详细解析(结合应用场景)

《nginx-t、nginx-sstop和nginx-sreload命令的详细解析(结合应用场景)》本文解析Nginx的-t、-sstop、-sreload命令,分别用于配置语法检... 以下是关于 nginx -t、nginx -s stop 和 nginx -s reload 命令的详细解析,结合实际应

MyBatis中$与#的区别解析

《MyBatis中$与#的区别解析》文章浏览阅读314次,点赞4次,收藏6次。MyBatis使用#{}作为参数占位符时,会创建预处理语句(PreparedStatement),并将参数值作为预处理语句... 目录一、介绍二、sql注入风险实例一、介绍#(井号):MyBATis使用#{}作为参数占位符时,会

SpringBoot结合Docker进行容器化处理指南

《SpringBoot结合Docker进行容器化处理指南》在当今快速发展的软件工程领域,SpringBoot和Docker已经成为现代Java开发者的必备工具,本文将深入讲解如何将一个SpringBo... 目录前言一、为什么选择 Spring Bootjavascript + docker1. 快速部署与

Python使用vllm处理多模态数据的预处理技巧

《Python使用vllm处理多模态数据的预处理技巧》本文深入探讨了在Python环境下使用vLLM处理多模态数据的预处理技巧,我们将从基础概念出发,详细讲解文本、图像、音频等多模态数据的预处理方法,... 目录1. 背景介绍1.1 目的和范围1.2 预期读者1.3 文档结构概述1.4 术语表1.4.1 核

PostgreSQL的扩展dict_int应用案例解析

《PostgreSQL的扩展dict_int应用案例解析》dict_int扩展为PostgreSQL提供了专业的整数文本处理能力,特别适合需要精确处理数字内容的搜索场景,本文给大家介绍PostgreS... 目录PostgreSQL的扩展dict_int一、扩展概述二、核心功能三、安装与启用四、字典配置方法

Spring Boot @RestControllerAdvice全局异常处理最佳实践

《SpringBoot@RestControllerAdvice全局异常处理最佳实践》本文详解SpringBoot中通过@RestControllerAdvice实现全局异常处理,强调代码复用、统... 目录前言一、为什么要使用全局异常处理?二、核心注解解析1. @RestControllerAdvice2

深度解析Java DTO(最新推荐)

《深度解析JavaDTO(最新推荐)》DTO(DataTransferObject)是一种用于在不同层(如Controller层、Service层)之间传输数据的对象设计模式,其核心目的是封装数据,... 目录一、什么是DTO?DTO的核心特点:二、为什么需要DTO?(对比Entity)三、实际应用场景解析

深度解析Java项目中包和包之间的联系

《深度解析Java项目中包和包之间的联系》文章浏览阅读850次,点赞13次,收藏8次。本文详细介绍了Java分层架构中的几个关键包:DTO、Controller、Service和Mapper。_jav... 目录前言一、各大包1.DTO1.1、DTO的核心用途1.2. DTO与实体类(Entity)的区别1