Datax的执行流程源码分析

DataX的框架的核心部分
1、配置贯穿DataX,all in configuration,将配置的json用到了极致
2、另一块是通过URLClassLoader实现插件的热加载。

Job&Task概念
 在DataX的逻辑模型中包括job、task两个维度,通过将job进行task拆分,然后将task合并到taskGroup进行运行。

job实例运行在jobContainer容器中,它是所有任务的master,负责初始化、拆分、调度、运行、回收、监控和汇报,但它并不做实际的数据同步操作。

Job: Job是DataX用以描述从一个源头到一个目的端的同步作业,是DataX数据同步的最小业务单元。比如:从一张mysql的表同步到odps的一个表的特定分区。

Task: Task是为最大化而把Job拆分得到的最小执行单元。比如:读一张有1024个分表的mysql分库分表的Job,拆分成1024个读Task,用若干个并发执行。

TaskGroup: 描述的是一组Task集合。在同一个TaskGroupContainer执行下的Task集合称之为TaskGroup。

JobContainer: Job执行器,负责Job全局拆分、调度、前置语句和后置语句等工作的工作单元

TaskGroupContainer: TaskGroup执行器,负责执行一组Task的工作单元。

简而言之, Job拆分成Task,分别在框架提供的容器中执行,插件只需要实现Job和Task两部分逻辑。

启动过程
在这里插入图片描述
datax开启本地debug模式
1、github上下载DataX的源码并通过以下命令进行编译,github官网有编译命令,如果遇到依赖包无法下载可以省去部分writer或reader插件,不影响debug。
进到本地项目下,执行打包命令:
mvn -U clean package assembly:assembly -Dmaven.test.skip=true
可能遇到的依赖包问题:

2、启动类:Engine类 需要的配置的启动参数:
VM options:
-server -Xms1g -Xmx1g -XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=E:\workspace\DataX\target\datax\datax\log
-Dloglevel=info -Dfile.encoding=UTF-8
-Dlogback.statusListenerClass=ch.qos.logback.core.status.NopStatusListener
-Djava.security.egd=file:///dev/urandom -Ddatax.home=E:\workspace\DataX\target\datax\datax
-Dlogback.configurationFile=E:\workspace\DataX\target\datax\datax\conf\logback.xml
-classpath E:\workspace\DataX\target\datax\datax\lib*
-Dlog.file.name=s_datax_job_job_json

Program arguments:
-mode standalone -jobid -1
-job E:\workspace\DataX\target\datax\datax\job\job.json

启动步骤解析
1、解析配置,包括job.json、core.json、plugin.json三个配置

2、设置jobId到configuration当中

3、启动Engine,通过Engine.start()进入启动程序

4、设置RUNTIME_MODEconfiguration当中

5、通过JobContainer的start()方法启动

6、依次执行job的preHandler()、init()、prepare()、split()、schedule()、- post()、postHandle()等方法。

7、init()方法涉及到根据configuration来初始化reader和writer插件,这里涉及到jar包热加载以及调用插件init()操作方法,同时设置reader和writer的configuration信息

8、prepare()方法涉及到初始化reader和writer插件的初始化,通过调用插件的prepare()方法实现,每个插件都有自己的jarLoader,通过集成URLClassloader实现而来

9、split()方法通过adjustChannelNumber()方法调整channel个数,同时执行reader和writer最细粒度的切分,需要注意的是,writer的切分结果要参照reader的切分结果,达到切分后数目相等,才能满足1:1的通道模型

10、channel的计数主要是根据byte和record的限速来实现的,在split()的函数中第一步就是计算channel的大小

11、split()方法reader插件会根据channel的值进行拆分,但是有些reader插件可能不会参考channel的值,writer插件会完全根据reader的插件1:1进行返回

12、split()方法内部的mergeReaderAndWriterTaskConfigs()负责合并reader、writer、以及transformer三者关系,生成task的配置,并且重写job.content的配置

13、schedule()方法根据split()拆分生成的task配置分配生成taskGroup对象,根据task的数量和单个taskGroup支持的task数量进行配置,两者相除就可以得出taskGroup的数量

14、schdule()内部通过AbstractScheduler的schedule()执行,继续执行startAllTaskGroup()方法创建所有的TaskGroupContainer组织相关的task,TaskGroupContainerRunner负责运行TaskGroupContainer执行分配的task。scheduler的具体实现类为ProcessInnerScheduler。

15、taskGroupContainerExecutorService启动固定的线程池用以执行TaskGroupContainerRunner对象,TaskGroupContainerRunner的run()方法调用taskGroupContainer.start()方法,针对每个channel创建一个TaskExecutor,通过taskExecutor.doStart()启动任务

启动过程源码分析
Engine入口main函数

public class Engine {

	//main函数主要做两件事情,分别是:
	//1、解析job相关配置生成configuration。
	//2、依据配置启动Engine。
    public static void main(String[] args) throws Exception {
        int exitCode = 0;
        try {
            Engine.entry(args);
        } catch (Throwable e) {
            System.exit(exitCode);
        }
    }

    public static void entry(final String[] args) throws Throwable {

        // 省略相关参数的解析代码
        
        // 获取job的配置路径信息
        String jobPath = cl.getOptionValue("job");

        // 如果用户没有明确指定jobid, 则 datax.py 会指定 jobid 默认值为-1
        String jobIdString = cl.getOptionValue("jobid");
        RUNTIME_MODE = cl.getOptionValue("mode");

        // configuration解析包括三部分的配置解析合并解析结果并返回,分别是:
		//1、解析job的配置信息,由启动参数指定job.json文件。
		//2、解析DataX自带配置信息,由默认指定的core.json文件。
		//3、解析读写插件配置信息,由job.json指定的reader和writer插件信息

        Configuration configuration = ConfigParser.parse(jobPath);

        // 省略相关代码
        boolean isStandAloneMode = "standalone".equalsIgnoreCase(RUNTIME_MODE);
        configuration.set(CoreConstant.DATAX_CORE_CONTAINER_JOB_ID, jobId);

        // 根据配置启动参数
        Engine engine = new Engine();
        engine.start(configuration);
    }
}

Engine的start过程

public class Engine {
    private static final Logger LOG = LoggerFactory.getLogger(Engine.class);

    private static String RUNTIME_MODE;

    /* check job model (job/task) first */
    //start过程中做了两件事:
	//1、创建JobContainer对象
	//2、启动JobContainer对象
    public void start(Configuration allConf) {

        // 省略相关代码

        boolean isJob = !("taskGroup".equalsIgnoreCase(allConf
                .getString(CoreConstant.DATAX_CORE_CONTAINER_MODEL)));
        AbstractContainer container;
        if (isJob) {
            allConf.set(CoreConstant.DATAX_CORE_CONTAINER_JOB_MODE, RUNTIME_MODE);
            // 核心点在于JobContainer的对象
            container = new JobContainer(allConf);
            instanceId = allConf.getLong(
                    CoreConstant.DATAX_CORE_CONTAINER_JOB_ID, 0);

        } 

        Configuration jobInfoConfig = allConf.getConfiguration(CoreConstant.DATAX_JOB_JOBINFO);

        // 核心容器的启动
        container.start();

    }

JobContainer的启动过程

public class JobContainer extends AbstractContainer {
    /**
     * jobContainer主要负责的工作全部在start()里面,包括init、prepare、split、scheduler、
     * post以及destroy和statistics
     */
    @Override
    public void start() {
        try {
            isDryRun = configuration.getBool(CoreConstant.DATAX_JOB_SETTING_DRYRUN, false);
            if(isDryRun) {
                // 省略相关代码
            } else {

                //拷贝一份新的配置,保证线程安全
                userConf = configuration.clone();

                // 执行preHandle()操作
                LOG.debug("jobContainer starts to do preHandle ...");
                this.preHandle();

                // 执行reader、transform、writer等初始化
                //1、创建reader的job对象,通过URLClassLoader实现类加载。
				//2、创建writer的job对象,通过URLClassLoader实现类加载	
                LOG.debug("jobContainer starts to do init ...");
                this.init();

                // 执行plugin的prepare
                LOG.info("jobContainer starts to do prepare ...");
                this.prepare();

                // 执行任务切分
                //主要是根据限流配置计算channel的个数,进而计算task的个数,主要过程如下:
				//1、adjustChannelNumber的过程根据按照字节限流和record限流计算channel的个数。
				//2、reader的个数根据channel的个数进行计算。
				//3、writer的个数根据reader的个数进行计算,writer和reader实现1:1绑定。
				//4、通过mergeReaderAndWriterTaskConfigs()方法生成reader+writer的task的configuration,至此我们生成了task的配置信息。
                LOG.info("jobContainer starts to do split ...");
                this.totalStage = this.split();

                // 执行任务调度
                //1、将task拆分成taskGroup,生成List<Configuration> taskGroupConfigs。
                //2、启动taskgroup的对象, scheduler.schedule(taskGroupConfigs)
                LOG.info("jobContainer starts to do schedule ...");
                this.schedule();

                // 执行后置操作
                LOG.debug("jobContainer starts to do post ...");
                this.post();

                // 执行postHandle操作
                LOG.debug("jobContainer starts to do postHandle ...");
                this.postHandle();

                LOG.info("DataX jobId [{}] completed successfully.", this.jobId);

                this.invokeHooks();
            }
        } catch (Throwable e) {
            // 省略相关代码
        } finally {
             // 省略相关代码
        }
    }
}

TaskGroup的schedule过程
TaskGroup的Schedule方法做的事情如下:

1、为所有的TaskGroup创建TaskGroupContainerRunner。
2、通过线程池提交TaskGroupContainerRunner任务,执行TaskGroupContainerRunner的run()方法。
3、在run()方法内部执行this.taskGroupContainer.start()方法。

public abstract class AbstractScheduler {
   
    public void schedule(List<Configuration> configurations) {
        
        int totalTasks = calculateTaskCount(configurations);
        
        // 启动所有的TaskGroup
        startAllTaskGroup(configurations);
        try {
            while (true) {
                // 省略相关代码
            }
        } catch (InterruptedException e) {
        }
    }
}



public abstract class ProcessInnerScheduler extends AbstractScheduler {

    private ExecutorService taskGroupContainerExecutorService;

    @Override
    public void startAllTaskGroup(List<Configuration> configurations) {

        //todo 根据taskGroup的数量启动固定的线程数
        this.taskGroupContainerExecutorService = Executors
                .newFixedThreadPool(configurations.size());

        //todo 每个TaskGroup启动一个TaskGroupContainerRunner
        for (Configuration taskGroupConfiguration : configurations) {
            //todo 创建TaskGroupContainerRunner并提交线程池运行
            TaskGroupContainerRunner taskGroupContainerRunner = newTaskGroupContainerRunner(taskGroupConfiguration);
            this.taskGroupContainerExecutorService.execute(taskGroupContainerRunner);
        }

        // 等待所有任务执行完后会关闭,执行该方法后不会再接收新任务
        this.taskGroupContainerExecutorService.shutdown();
    }
}



public class TaskGroupContainerRunner implements Runnable {

    private TaskGroupContainer taskGroupContainer;

    private State state;

    public TaskGroupContainerRunner(TaskGroupContainer taskGroup) {
        this.taskGroupContainer = taskGroup;
        this.state = State.SUCCEEDED;
    }

    @Override
    public void run() {
        try {
            Thread.currentThread().setName(
                    String.format("taskGroup-%d", this.taskGroupContainer.getTaskGroupId()));
            this.taskGroupContainer.start();
            this.state = State.SUCCEEDED;
        } catch (Throwable e) {
        }
    }
}

TaskGroupContainer的启动
TaskGroupContainer的内部主要做的事情如下:

1、根据TaskGroupContainer分配的Task任务列表,创建TaskExecutor对象。
2、创建TaskExecutor对象,用以启动分配该TaskGroup的task。
3、至此,已经成功的启动了Job当中的Task任务。

public class TaskGroupContainer extends AbstractContainer {

    @Override
    public void start() {
        try {
             // 省略相关代码

            int taskCountInThisTaskGroup = taskConfigs.size();
            Map<Integer, Configuration> taskConfigMap = buildTaskConfigMap(taskConfigs); //taskId与task配置
            List<Configuration> taskQueue = buildRemainTasks(taskConfigs); //待运行task列表
            Map<Integer, TaskExecutor> taskFailedExecutorMap = new HashMap<Integer, TaskExecutor>(); //taskId与上次失败实例
            List<TaskExecutor> runTasks = new ArrayList<TaskExecutor>(channelNumber); //正在运行task
            Map<Integer, Long> taskStartTimeMap = new HashMap<Integer, Long>(); //任务开始时间

            while (true) {
                // 省略相关代码
                
                // 新增任务会在这里被启动
                Iterator<Configuration> iterator = taskQueue.iterator();
                while(iterator.hasNext() && runTasks.size() < channelNumber){
                    Configuration taskConfig = iterator.next();
                    Integer taskId = taskConfig.getInt(CoreConstant.TASK_ID);
                    int attemptCount = 1;
                    TaskExecutor lastExecutor = taskFailedExecutorMap.get(taskId);

                    // todo 需要新建任务的配置信息
                    Configuration taskConfigForRun = taskMaxRetryTimes > 1 ? taskConfig.clone() : taskConfig;

                    // todo taskExecutor应该就需要新建的任务
                    TaskExecutor taskExecutor = new TaskExecutor(taskConfigForRun, attemptCount);
                    taskStartTimeMap.put(taskId, System.currentTimeMillis());
                    taskExecutor.doStart();

                    iterator.remove();
                    runTasks.add(taskExecutor);
                   
                }
        } catch (Throwable e) {
        }finally {
        }
    }
}

Task的启动
TaskExecutor的启动过程主要做了以下事情:

1、创建了reader和writer的线程任务,reader和writer公用一个channel。
2、先启动writer线程后,再启动reader线程。
3、至此,同步数据的Task任务已经启动了。

class TaskExecutor {
        
        private Channel channel;
        private Thread readerThread;
        private Thread writerThread;
        private ReaderRunner readerRunner;
        private WriterRunner writerRunner;

        /**
         * 该处的taskCommunication在多处用到:
         * 1. channel
         * 2. readerRunner和writerRunner
         * 3. reader和writer的taskPluginCollector
         */
        public TaskExecutor(Configuration taskConf, int attemptCount) {
            // 获取该taskExecutor的配置
            this.taskConfig = taskConf;

            // 得到taskId
            this.taskId = this.taskConfig.getInt(CoreConstant.TASK_ID);
            this.attemptCount = attemptCount;

            /**
             * 由taskId得到该taskExecutor的Communication
             * 要传给readerRunner和writerRunner,同时要传给channel作统计用
             */
            this.channel = ClassUtil.instantiate(channelClazz,
                    Channel.class, configuration);
            // channel在这里生成,每个taskGroup生成一个channel,在generateRunner方法当中生成writer或reader并注入channel
            this.channel.setCommunication(this.taskCommunication);

            /**
             * 获取transformer的参数
             */

            List<TransformerExecution> transformerInfoExecs = TransformerUtil.buildTransformerInfo(taskConfig);

            /**
             * 生成writerThread
             */
            writerRunner = (WriterRunner) generateRunner(PluginType.WRITER);
            this.writerThread = new Thread(writerRunner,
                    String.format("%d-%d-%d-writer",
                            jobId, taskGroupId, this.taskId));
            //通过设置thread的contextClassLoader,即可实现同步和主程序不通的加载器
            this.writerThread.setContextClassLoader(LoadUtil.getJarLoader(
                    PluginType.WRITER, this.taskConfig.getString(
                            CoreConstant.JOB_WRITER_NAME)));

            /**
             * 生成readerThread
             */
            readerRunner = (ReaderRunner) generateRunner(PluginType.READER,transformerInfoExecs);
            this.readerThread = new Thread(readerRunner,
                    String.format("%d-%d-%d-reader",
                            jobId, taskGroupId, this.taskId));
            /**
             * 通过设置thread的contextClassLoader,即可实现同步和主程序不通的加载器
             */
            this.readerThread.setContextClassLoader(LoadUtil.getJarLoader(
                    PluginType.READER, this.taskConfig.getString(
                            CoreConstant.JOB_READER_NAME)));
        }

        public void doStart() {
            this.writerThread.start();
            this.readerThread.start();
        }
}

代码流程关键步骤总结如下:

  • Engine:main->entry:生成Configuration,调用start() -> 创建JobConstainer对象,启动JobContainer对象

  • JobContainer:start():preHandle,init,prepare,split,schedule,post,postHandle

     init:分别创建reader和writer的job对象(创建reader的job对象)
     split:根据限流配置计算channel的个数,进而计算task的个数,生成reader+writer的task的configuration
     schedule:将task拆分成taskGroup,生成List\<Configuration> taskGroupConfigs
     		  AbstractScheduler.schedule(taskGroupConfigs)->startAllTaskGroup(configurations);
     		  ->TaskGroupContainerRunner taskGroupContainerRunner=newTaskGroupContainerRunner(taskGroupConfiguration);
                this.taskGroupContainerExecutorService.execute(taskGroupContainerRunner)
     		  ->taskGroupContainerRunner:this.taskGroupContainer.start();
     		  ->TaskGroupContainer :List<TaskExecutor> runTasks = new ArrayList<TaskExecutor>(channelNumber); //正在运行task
     		     TaskExecutor taskExecutor = new TaskExecutor(taskConfigForRun, attemptCount);
     		     taskExecutor.doStart();
     		  ->taskExecutor:this.writerThread.start(); 	 this.readerThread.start();
    

参考文章:https://yq.aliyun.com/articles/666277?spm=a2c4e.11153940.0.0.1505b9ceQg3JBz

©️2020 CSDN 皮肤主题: 大白 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值