从源码角度分析ScheduleMaster的节点管理流程

ScheduleMaster是一个开源的分布式任务调度系统，它基于.NET Core 3.1平台构建，支持跨平台多节点部署运行。

项目主页：https://github.com/hey-hoho/ScheduleMasterCore

本篇从源码角度分析一下节点控制的核心流程。

生命周期事件

生命周期事件增强了整个应用进程的控制能力，由于节点状态与之关系密切，所以必须要首先了解下生命周期事件具体干了什么活。

借助于ASP.NET Core框架的HostedService模型，我们把生命周期管理器封装在一个后台托管服务AppLifetimeHostedService中，在它的StartAsync方法中注册了我们需要的事件：

public Task StartAsync(CancellationToken cancellationToken)
{
    _appLifetime.ApplicationStarted.Register(OnStarted);
    _appLifetime.ApplicationStopping.Register(OnStopping);
    _appLifetime.ApplicationStopped.Register(OnStopped);

    return Task.CompletedTask;
}

这里主要涉及的事件就是应用启动和停止时所需要处理的逻辑，分别对应节点状态的变更，下面重点说一下启动事件。

ScheduleMaster采用了典型的中心化结构搭建，基于1个master节点和N和worker节点提供服务，其中master扮演了整个系统资源调度的角色，worker则是实际执行任务的角色。这样的话，master就必须要感知到它所能调度的资源清单，所以系统引入了节点注册概念。

根据注册发起者的不同，可以分为如下两种模式：

• 自动注册模式

• 手动注册模式

自动注册模式

接触过微服务架构的朋友应该会对服务注册发现这一过程比较熟悉，借鉴了相似的设计，节点自动注册就类似服务注册的样子，在节点启动时自动把自身的配置信息注册到控制中心，默认的方式就是从配置文件读取节点信息，同时也支持使用命令行参数覆盖配置文件中的字段：

private void OnStarted()
{
	// ....

    //判断是否要自动根据配置文件注册节点信息
    if (AppCommandResolver.IsAutoRegister())
    {
        _logger.LogInformation("enabled auto register...");
        // 设置节点信息
        ConfigurationCache.SetNode(_configuration);

        // ....
    }
}

public static void SetNode(IConfiguration configuration)
{
    NodeSetting = configuration.GetSection("NodeSetting").Get<NodeSetting>();
    string identity = AppCommandResolver.GetCommandLineArgsValue("identity");
    if (!string.IsNullOrEmpty(identity))
    {
        NodeSetting.IdentityName = identity;
    }
    string protocol = AppCommandResolver.GetCommandLineArgsValue("protocol");
    if (!string.IsNullOrEmpty(protocol))
    {
        NodeSetting.Protocol = protocol;
    }
    string ip = AppCommandResolver.GetCommandLineArgsValue("ip");
    if (!string.IsNullOrEmpty(ip))
    {
        NodeSetting.IP = ip;
    }
    string port = AppCommandResolver.GetCommandLineArgsValue("port");
    if (!string.IsNullOrEmpty(port))
    {
        NodeSetting.Port = Convert.ToInt32(port);
    }
    string priority = AppCommandResolver.GetCommandLineArgsValue("priority");
    if (!string.IsNullOrEmpty(priority))
    {
        NodeSetting.Priority = Convert.ToInt32(priority);
    }
    NodeSetting.MachineName = Environment.MachineName;
}

再看一下如何判断节点是否开启了自动注册模式：

public static bool IsAutoRegister()
{
    //优先读取环境参数
    string option = Environment.GetEnvironmentVariable("SMCORE_AUTOR");
    //再看命令行参数中是否也有设置
    string cmdArg = GetCommandLineArgsValue("autor");
    if (!string.IsNullOrEmpty(cmdArg))
    {
        option = cmdArg;
    }
    return option != "false";
}

很明显，在节点启动时如果指定了特定的环境变量SMCORE_AUTOR或命令行参数autor并且值为false即表示关闭自动注册模式，否则默认开启。

要注意的是，master节点只提供了自动注册模式。

手动注册模式

自动注册模式虽然流程简单，但是需要提前配置好节点信息，这对于节点弹性部署并不友好，因此为了增加系统灵活性，系统也提供了手动注册节点的模式，这时候对worker注册的主动权转移到master手里，需要先在master控制台中创建好要注册的节点，然后执行连接操作，最后启动服务即可。

这个过程中比较核心的是连接验证过程，设计这个流程的原因是为了保障创建连接的双方是可信状态，实现数据匹配，其核心过程为：

• worker节点在启动时通过环境变量SMCORE_WORKEROF或者命令行参数workerof指定归属的master名称

• 在控制台中对节点执行[连接]操作，master携带验证信息对worker发起连接请求

• 如果验证通过，则使用指定的节点名称去数据库查询完整的节点配置信息，并为worker节点缓存配置数据，worker生成一个新的访问秘钥返回

• 标记节点状态为空闲中，此时worker并不运行任何调度服务，处于空跑状态

• 对节点执行[启用]操作，开启调度功能

验证连接过程的核心代码为：

 public async Task<(bool success, string content)> Connect()
 {
    HttpClient client = CreateClient();
    client.DefaultRequestHeaders.Add("sm_connection", SecurityHelper.MD5(ConfigurationCache.NodeSetting.IdentityName));
    client.DefaultRequestHeaders.Add("sm_nameto", _server.NodeName);

    var response = await client.PostAsync("/api/server/connect", null);
    return (response.IsSuccessStatusCode, await response.Content.ReadAsStringAsync());
 }

 [HttpPost, AllowAnonymous]
 public IActionResult Connect()
 {
     string workerof = AppCommandResolver.GetTargetMasterName();
     string encodeKey = Request.Headers["sm_connection"].FirstOrDefault();
     if (string.IsNullOrEmpty(workerof) || string.IsNullOrEmpty(encodeKey))
     {
         _logger.LogWarning("connect failed! workerof or encodekey is null...");
         return BadRequest("Unauthorized Connection.");
     }
     if (!Core.Common.SecurityHelper.MD5(workerof).Equals(encodeKey))
     {
         _logger.LogWarning("connect failed! encodekey is unvalid, wokerof:{0}, encodekey:{1}", workerof, encodeKey);
         return BadRequest("Unauthorized Connection.");
     }
     string workerName = Request.Headers["sm_nameto"].FirstOrDefault();
     var node = _db.ServerNodes.FirstOrDefault(x => x.NodeName == workerName);
     if (node == null)
     {
         _logger.LogWarning("connect failed! unkown worker name:{0}...", workerName);
         return BadRequest("Unkown Worker Name.");
     }
     Core.ConfigurationCache.SetNode(node);
     string secret = Guid.NewGuid().ToString("n");
     QuartzManager.AccessSecret = secret;
     _logger.LogInformation("successfully connected to {0}!", workerof);
     LogHelper.Info($"与{workerof}连接成功~");
     return Ok(secret);
 }

健康检查

健康检查是为了保障不可用的worker节点及时被发现并剔除调度，其验证方式使用了ASP.NET Core框架自带的健康检查机制中间件，通过访问一个指定的路由地址获取节点的健康情况，如果连续N次检查失败就把该节点强制剔除下线，多次检查目的是为了避免因短暂的网络抖动导致出现误判情况，这个次数N可以根据实际情况进行配置，默认是3次。

首先master启动的时候会注册一个每分钟执行一次的后台定时任务，这个任务会拉取所有状态是非[下线]的worker节点，然后对其发起健康检查请求：

    public class SystemSchedulerRegistry : Registry
    {
        public SystemSchedulerRegistry()
        {
            NonReentrantAsDefault();

            //对运行节点每分钟一次心跳监测
            Schedule<WorkerCheckJob>().ToRunEvery(1).Minutes();
        }
    }

    internal class WorkerCheckJob : IJob
    {
        /// <summary>
        /// 执行计划
        /// </summary>
        public void Execute()
        {
            using (var scope = ConfigurationCache.RootServiceProvider.CreateScope())
            {
                Core.Interface.INodeService service = scope.ServiceProvider.GetService<Core.Interface.INodeService>();
                AutowiredServiceProvider provider = new AutowiredServiceProvider();
                provider.PropertyActivate(service, scope.ServiceProvider);
                service.WorkerHealthCheck();
            }
        }
    }

具体判断节点无效的流程为：

• 读取系统配置的最大允许无响应次数

• 给节点维护一个失败计数器，本质是一个字典，key是节点名称，value是连续失败的次数

• 对节点发起健康检查请求，如果请求成功就更新节点的最后刷新时间，并把计数器归0

• 如果请求失败但没有达到最大失败次数，把计数器加1，等待下次检查

• 如果已经达到最大失败次数，则把节点标记下线，释放该节点占据的锁，同时把计数器归0

worker的中间件注册过程为：

public void ConfigureServices(IServiceCollection services)
{
	// ....

	services.AddHealthChecks();

	// ....
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
	// ....

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
        endpoints.MapHealthChecks("/health");
    });

	// ....
}

访问控制

为了保证worker接口访问的安全性，系统加入了动态秘钥验证机制，每次节点启动或者被连接的时候都会生成一个新的秘钥，持有合法秘钥的请求才会被节点正常处理，否则直接返回401 Unauthorized。

public void OnActionExecuting(ActionExecutingContext context)
{
    var anonymous = (context.ActionDescriptor as ControllerActionDescriptor).MethodInfo.GetCustomAttributes(typeof(AllowAnonymousAttribute), false);
    if (anonymous.Any())
    {
        return;
    }
    var secret = context.HttpContext.Request.Headers["sm_secret"].FirstOrDefault();
    if (string.Compare(Common.QuartzManager.AccessSecret, secret, StringComparison.CurrentCultureIgnoreCase) != 0)
    {
        context.Result = new UnauthorizedObjectResult($"w:{Common.QuartzManager.AccessSecret} m:{secret}");
    }
}

节点访问

在master控制台中对任务的操作最终都被分发到关联的worker节点上，通过worker提供的webapi接口实现远程调用。以启动任务为例，我们看一下具体分发和远程调用过程：

private async Task<bool> DispatcherHandler(Guid sid, RequestDelegate func)
{
    var nodeList = _nodeService.GetAvaliableWorkerForSchedule(sid);
    if (nodeList.Any())
    {
        foreach (var item in nodeList)
        {
            if (!await func(item))
            {
                return false;
            }
        }
        return true;
    }
    throw new InvalidOperationException("running worker not found.");
}

public async Task<bool> ScheduleStart(Guid sid)
{
    return await DispatcherHandler(sid, async (ServerNodeEntity node) =>
     {
         _scheduleClient.Server = node;
         return await _scheduleClient.Start(sid);
     });
}

可以看到，启动操作会首先查询任务的执行节点，然后依次遍历执行远程调用，只要其中一个节点执行命令失败那么整个操作就会失败。

最终的httpclient请求被封装在Hos.ScheduleMaster.Core.Services.RemoteCaller.ServerClient类中，它的CreateClient方法从IHttpClientFactory获取了一个客户端实例，并把节点的访问秘钥放入请求头中，以此完成安全性验证：

protected HttpClient CreateClient()
{
    if (_server == null)
    {
        throw new ArgumentException("no target worker that can send the request.");
    }
    HttpClient client = _httpClientFactory.CreateClient("workercaller");
    client.DefaultRequestHeaders.Add("sm_secret", _server.AccessSecret);
    client.BaseAddress = new Uri($"{_server.AccessProtocol}://{_server.Host}");
    return client;
}

写在最后

到这里基本把节点的核心操作都分析完毕了，希望能对关注这个项目的朋友带来帮助~