DolphinScheduler 1.2.0 源码解析之 MasterServer
这一篇主要讲解的是dolphinscheduler 1.2.0 的master部分的源码,从主类MasterServer开始,从启动到运行,master主要做了以下三件事情
Zookeeper 节点初始化
构建并提交工作流实例,跟踪运行状态
监控其他MasterServer和WorkerServer的健康状态并容错
维系心跳
@PostConstruct
public void run(){
//详情见1.zookeeper初始化
zkMasterClient.init();
//详情见2.MasterSchedulerThread线程
masterSchedulerService = ThreadUtils.newDaemonSingleThreadExecutor("Master-Scheduler-Thread");
//详情见3.heartBeatThread线程
heartbeatMasterService = ThreadUtils.newDaemonThreadScheduledExecutor("Master-Main-Thread",Constants.DEFAULT_MASTER_HEARTBEAT_THREAD_NUM);
}
1. zookeeper初始化
创建DS在zookeeper的相关节点,并判断是否对系统做failover,恢复异常的工作流实例和任务实例。
用于master的failover /dolphinscheduler/lock/failover/master
系统节点,保存master和worker的心跳信息 /dolphinscheduler/masters; /dolphinscheduler/workers;/dolphinscheduler/dead-servers
public void init(){
logger.info("initialize master client...");
this.initDao();
InterProcessMutex mutex = null;
try {
// 创建分布式锁节点,用于master节点的failover
String znodeLock = getMasterStartUpLockPath();
mutex = new InterProcessMutex(zkClient, znodeLock);
mutex.acquire();
// 在ZK中初始化系统节点,
this.initSystemZNode();
// 向ZK的/masters节点注册当前的master信息
this.registerMaster();
// 通过监听Zookeeper临时节点变化来进行容错处理(如果活跃的master只有自身一个,则进行failover)
if (getActiveMasterNum() == 1) {
failoverWorker(null, true); // 恢复任务实例 详情见1.1.
failoverMaster(null); // 恢复工作流实例 详情见1.2.
}
}catch (Exception e){
logger.error("master start up exception",e);
}finally {
releaseMutex(mutex);
}
}
1.1. failoverWorker 恢复任务实例
private void failoverWorker(String workerHost, boolean needCheckWorkerAlive) throws Exception {
logger.info("start worker[{}] failover ...", workerHost);
List<TaskInstance> needFailoverTaskInstanceList = processService.queryNeedFailoverTaskInstances(workerHost);
for(TaskInstance taskInstance : needFailoverTaskInstanceList){
if(needCheckWorkerAlive){
if(!checkTaskInstanceNeedFailover(taskInstance)){
// 不需要failover的两种情况
// 1.任务详情中不存在host信息
// 2.任务在ZK中存在,则判断启动时间是否小于worker启动时间,小于则不用failover
continue;
}
}
ProcessInstance instance = processService.findProcessInstanceDetailById(taskInstance.getProcessInstanceId());
if(instance!=null){
taskInstance.setProcessInstance(instance);
}
// 如果任务中有yarn的任务则杀掉,kill的方式,日志中用正则匹配containId的格式,获取containID,用yarn命令kill。
ProcessUtils.killYarnJob(taskInstance);
// 把任务的状态从“running”改为“need failover”
taskInstance.setState(ExecutionStatus.NEED_FAULT_TOLERANCE);
processService.saveTaskInstance(taskInstance);
}
logger.info("end worker[{}] failover ...", workerHost);
}
1.2. failoverMaster 恢复工作流实例
private void failoverMaster(String masterHost) {
logger.info("start master failover ...");
// 获取需要failover的工作流实例
List<ProcessInstance> needFailoverProcessInstanceList = processService.queryNeedFailoverProcessInstances(masterHost);
for(ProcessInstance processInstance : needFailoverProcessInstanceList){
// 1.更新工作流实例的host为null
// 2.写入 t_ds_commond 表一条恢复工作流实例的命令
processService.processNeedFailoverProcessInstances(processInstance);
}
logger.info("master failover end");
}
2. MasterSchedulerThread 线程
该线程主要对command进行解析生成工作流实例
public void run() {
logger.info("master scheduler start successfully...");
while (Stopper.isRunning()){
// process instance
ProcessInstance processInstance = null;
InterProcessMutex mutex = null;
try {
boolean runCheckFlag = OSUtils.checkResource(masterConfig.getMasterMaxCpuloadAvg(), masterConfig.getMasterReservedMemory());
if(!runCheckFlag) {
Thread.sleep(Constants.SLEEP_TIME_MILLIS);
continue;
}
if (zkMasterClient.getZkClient().getState() == CuratorFrameworkState.STARTED) {
// 创建分布式锁 /dolphinscheduler/lock/masters
String znodeLock = zkMasterClient.getMasterLockPath();
mutex = new InterProcessMutex(zkMasterClient.getZkClient(), znodeLock);
mutex.acquire();
ThreadPoolExecutor poolExecutor = (ThreadPoolExecutor) masterExecService;
int activeCount = poolExecutor.getActiveCount();
// 需要确保实例构建存储过程和command数据从表中删除的过程在一个事务中
Command command = processService.findOneCommand();
if (command != null) {
logger.info("find one command: id: {}, type: {}", command.getId(),command.getCommandType());
try{
// handleCommand将commond解析成processInstance 详情见2.1
processInstance = processService.handleCommand(logger, OSUtils.getHost(), this.masterExecThreadNum - activeCount, command);
if (processInstance != null) {
logger.info("start master exec thread , split DAG ...");
// masterExecService,master执行线程 详情见 2.2
masterExecService.execute(new MasterExecThread(processInstance, processService));
}
}catch (Exception e){
logger.error("scan command error ", e);
processService.moveToErrorCommand(command, e.toString());
}
} else{
//indicate that no command ,sleep for 1s
Thread.sleep(Constants.SLEEP_TIME_MILLIS);
}
}
}catch (Exception e){
logger.error("master scheduler thread exception",e);
}finally{
AbstractZKClient.releaseMutex(mutex);
}
}
logger.info("master server stopped...");
}
2.1. handleCommand
根据command对象构建工作流实例,构建后把该条command从t_ds_command表中删除,需要确保的是实例构建存储过程和command数据从表中删除的过程在一个事务中。
command所有类型如下
0 start a new process
1 start a new process from current nodes
2 recover tolerance fault process
3 recover suspended process
4 start process from failure task nodes
5 complement data
6 start a new process from scheduler
7 repeat running a process
8 pause a process
9 stop a process
10 recover waiting thread
@Transactional(rollbackFor = Exception.class)
public ProcessInstance handleCommand(Logger logger, String host, int validThreadNum, Command command) {
//根据command命令生成新的工作流程实例
ProcessInstance processInstance = constructProcessInstance(command, host);
//cannot construct process instance, return null;
if(processInstance == null){
logger.error("scan command, command parameter is error: %s", command.toString());
moveToErrorCommand(command, "process instance is null");
return null;
}
if(!checkThreadNum(command, validThreadNum)){
logger.info("there is not enough thread for this command: {}",command.toString() );
return setWaitingThreadProcess(command, processInstance);
}
processInstance.setCommandType(command.getCommandType());
processInstance.addHistoryCmd(command.getCommandType());
saveProcessInstance(processInstance);
this.setSubProcessParam(processInstance);
//保存了任务流实例后将该命令删除
delCommandByid(command.getId());
return processInstance;
}
2.2. MasterExecThread 执行线程
public void run() {
......
try {
//检查此过程是否是补数 且 流程实例是否为子流程
if (processInstance.isComplementData() && Flag.NO == processInstance.getIsSubProcess()){
// 详情见2.2.2. 执行补数
executeComplementProcess();
}else{
//详情见2.2.1. 执行流程实例
executeProcess();
}
......
}
2.2.1. executeProcess() 执行流程实例
private void executeProcess() throws Exception {
//1.根据流程实例id查找有效的任务列表 initTaskQueue()
//2.构建DAG处理流程 buildFlowDag() 返回DAG对象,主要包括两个信息:vertex 点,即任务执行节点;edge 边,即任务之间的依赖关系
prepareProcess();
//提交并监控任务,直到工作流停止 详情见2.2.1.1
runProcess();
//当线程池不足以供流程实例使用时,创建恢复等待线程命令。
//子工作流程实例无需创建恢复命令。
//创建恢复等待线程命令并同时删除origin命令。
//如果存在recovery命令,则仅更新字段update_time
endProcess();
}
2.2.1.1. runProcess()提交并监控任务
submitPostNode方法传入父任务节点的名字,通过节点名,DAG,获取任务节点列表,并生成任务实例列表readyToSubmitTaskList
private void runProcess(){
submitPostNode(null);
submitStandByTask()方法里面会遍历任务实例列表readyToSubmitTaskList,判断任务实例的依赖关系,依赖项运行成功则会提交任务执行线程,失败则把当前节点状态改为失败。
if(canSubmitTaskToQueue()){
submitStandByTask();
}
try {
Thread.sleep(Constants.SLEEP_TIME_MILLIS);
} catch (InterruptedException e) {
logger.error(e.getMessage(),e);
}
updateProcessInstanceState();
}
logger.info("process:{} end, state :{}", processInstance.getId(), processInstance.getState());
}
submitStandByTask()最终会调用submitTaskExec,这里有个MasterBaseTaskExecThread线程 MasterBaseTaskExecThread线程有两个主要作用
用于把任务实例信息提交到数据库中submitTask()
把任务信息写进zookeeper队列 submitTaskToQueue(),后续worker会来认领任务。(节点命名方式:${processInstancePriority}_${processInstanceId}_${taskInstancePriority}_${taskInstanceId}_${task executed by ip1},${ip2}...)
另外MasterBaseTaskExecThread有两个子类,除了上面的两个作用外:
MasterTaskExecThread 任务执行完成后会把需要kill的任务信息写入zk队列中等待worker来kill任务。
SubProcessTaskExecThread 在当前工作流运行结束后会继续运行子工作流并做相关状态更新,子工作流完全完成才同步状态为子工作流的状态。
MasterBaseTaskExecThread线程异步提交,会把结果写入activeTaskNode。
private TaskInstance submitTaskExec(TaskInstance taskInstance) {
MasterBaseTaskExecThread abstractExecThread = null;
if(taskInstance.isSubProcess()){
abstractExecThread = new SubProcessTaskExecThread(taskInstance, processInstance);
}else {
abstractExecThread = new MasterTaskExecThread(taskInstance, processInstance);
}
Future<Boolean> future = taskExecService.submit(abstractExecThread);
activeTaskNode.putIfAbsent(abstractExecThread, future);
return abstractExecThread.getTaskInstance();
}
然后会遍历activeTaskNode,判断线程是否执行完成,若完成则移除该线程信息,再判断节点是否执行成功
for(Map.Entry<MasterBaseTaskExecThread,Future<Boolean>> entry: activeTaskNode.entrySet()) {
Future<Boolean> future = entry.getValue();
TaskInstance task = entry.getKey().getTaskInstance();
if(!future.isDone()){
continue;
}
// node monitor thread complete
activeTaskNode.remove(entry.getKey());
if(task == null){
this.taskFailedSubmit = true;
continue;
}
logger.info("task :{}, id:{} complete, state is {} ",
task.getName(), task.getId(), task.getState().toString());
// 如果节点成功,则继续提交任务节点
if(task.getState() == ExecutionStatus.SUCCESS){
completeTaskList.put(task.getName(), task);
submitPostNode(task.getName());
continue;
}
// 如果节点失败,先重试,然后再继续执行失败流程
if(task.getState().typeIsFailure()){
if(task.getState() == ExecutionStatus.NEED_FAULT_TOLERANCE){
this.recoverToleranceFaultTaskList.add(task);
}
if(task.taskCanRetry()){
addTaskToStandByList(task);
}else{
completeTaskList.put(task.getName(), task);
if( task.getTaskType().equals(TaskType.CONDITIONS.toString()) ||
haveConditionsAfterNode(task.getName())) {
submitPostNode(task.getName());
}else{
errorTaskList.put(task.getName(), task);
if(processInstance.getFailureStrategy() == FailureStrategy.END){
killTheOtherTasks();
}
}
}
continue;
}
// other status stop/pause
completeTaskList.put(task.getName(), task);
}
// send alert
2.2.2. executeComplementProcess() 执行补数流程实例
private void executeComplementProcess() throws Exception {
....
//根据调度的时间规则和补数的时间范围计算出需要补数的日期列表
int processDefinitionId = processInstance.getProcessDefinitionId();
List<Schedule> schedules = processService.queryReleaseSchedulerListByProcessDefinitionId(processDefinitionId);
List<Date> listDate = Lists.newLinkedList();
if(!CollectionUtils.isEmpty(schedules)){
for (Schedule schedule : schedules) {
listDate.addAll(CronUtils.getSelfFireDateList(startDate, endDate, schedule.getCrontab()));
}
}
//接下来是一个循环,用日期列表的每个日期执行一次
//以下三个方法同 2.2.1
....
prepareProcess();
....
runProcess();
....
endProcess();
3. heartBeatThread线程
每30秒上报一次心跳信息, 同时判断host是否在dead-servers节点下,即判断进程是否已经挂了。 进程正常则更新zookeeper的/dolphinscheduler/masters/${host}/ 下的节点名称,包括以下信息 ip, port ,cpUsage, memoryUsage, loadAverage, registerTIme, currentTime
private Runnable heartBeatThread(){
logger.info("start master heart beat thread...");
Runnable heartBeatThread = new Runnable() {
@Override
public void run() {
if(Stopper.isRunning()) {
// send heartbeat to zk
if (StringUtils.isBlank(zkMasterClient.getMasterZNode())) {
logger.error("master send heartbeat to zk failed: can't find zookeeper path of master server");
return;
}
zkMasterClient.heartBeatForZk(zkMasterClient.getMasterZNode(), Constants.MASTER_PREFIX);
}
}
};
return heartBeatThread;
}
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· [.NET]调用本地 Deepseek 模型
· 一个费力不讨好的项目,让我损失了近一半的绩效!
· .NET Core 托管堆内存泄露/CPU异常的常见思路
· PostgreSQL 和 SQL Server 在统计信息维护中的关键差异
· C++代码改造为UTF-8编码问题的总结
· CSnakes vs Python.NET:高效嵌入与灵活互通的跨语言方案对比
· 【.NET】调用本地 Deepseek 模型
· Plotly.NET 一个为 .NET 打造的强大开源交互式图表库
· 上周热点回顾(2.17-2.23)
· 如何使用 Uni-app 实现视频聊天(源码,支持安卓、iOS)