uw.task.mq.TaskConsumer Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of uw-task Show documentation
uw-task包是一个分布式任务框架，通过uw-task可以快速构建基于docker的分布式任务体系，同时支持基于influx的任务运维监控。
The newest version!
package uw.task.mq;

import java.util.Date;
import java.util.concurrent.TimeUnit;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import uw.task.TaskData;
import uw.task.TaskException;
import uw.task.TaskRunner;
import uw.task.TaskScheduler;
import uw.task.api.TaskAPI;
import uw.task.conf.TaskServerConfig;
import uw.task.entity.TaskRunnerConfig;
import uw.task.util.GlobalRateLimiter;
import uw.task.util.LeaderVote;
import uw.task.util.LocalRateLimiter;
import uw.task.util.Utils;

/**
 * 在此处接受MQ信息，并进行处理。
 * 
 * @author axeon
 *
 */
@Component
public class TaskConsumer {

	private static final Logger log = LoggerFactory.getLogger(TaskConsumer.class);

	/**
	 * rabbitmq
	 */
	@Autowired
	private TaskScheduler taskScheduler;

	/**
	 * 服务端任务API
	 */
	@Autowired
	private TaskAPI taskAPI;

	/**
	 * 服务器端配置
	 */
	@Autowired
	TaskServerConfig serverConfig;

	/**
	 * 全局流量限制服务
	 */
	@Autowired
	private GlobalRateLimiter globalRateLimiter;

	/**
	 * 本地流量限制服务
	 */
	@Autowired
	private LocalRateLimiter localRateLimiter;

	/**
	 * 执行任务
	 * 
	 * @param taskData
	 */
	@SuppressWarnings("rawtypes")
	public TaskData process(TaskData taskData) {
		// 设置开始消费时间
		taskData.setConsumeDate(new Date());
		// 获得任务实例
		TaskRunner taskRunner = serverConfig.getRunner(taskData.getTaskClass());
		// 获得任务设置数据
		TaskRunnerConfig taskConfig = taskRunner.getConfig();
		// 尝试重新造型taskData。
		if (taskData.getRunType() != TaskData.RUN_TYPE_LOCAL) {
			taskData = serverConfig.convertTaskData(taskData);
		}
		// 设置运行标记
		taskData.setHostIp(taskAPI.getHostIp());
		// 设置主机ID
		taskData.setHostId(LeaderVote.UUID);
		// 增加执行信息
		taskData.setRanTimes(taskData.getRanTimes() + 1);
		// 限制标记，0时说明无限制
		long nolimitFlag = 0;
		if (taskConfig != null) {

			if (taskConfig.getRateLimitType() == 1) {
				// 本地流量限制
				boolean flag = localRateLimiter.tryAcquire(taskData.getTaskClass(), taskConfig.getRateLimitWait(),
						TimeUnit.SECONDS);
				nolimitFlag = flag ? 0 : -1;
			} else if (taskConfig.getRateLimitType() == 2 || taskConfig.getRateLimitType() == 3) {
				String locker = taskData.getTaskClass();
				if (taskConfig.getRateLimitType() == 2)
					locker += "$" + taskAPI.getHostIp();
				// 全局流量限制
				// 检查是否超过流量限制
				globalRateLimiter.initLimiter(locker, taskConfig.getRateLimitValue(), TimeUnit.SECONDS,
						taskConfig.getRateLimitTime());
				// 开始进行延时等待
				long end = System.currentTimeMillis() + taskConfig.getRateLimitWait() * 1000;
				while (System.currentTimeMillis() <= end) {
					nolimitFlag = globalRateLimiter.tryAcquire(locker);
					if (nolimitFlag == 0)
						break;
					if (nolimitFlag < 1) {
						nolimitFlag = 1;
					}
					try {
						Thread.sleep(nolimitFlag * 1000);
					} catch (InterruptedException e) {
						log.error(e.getMessage(), e);
					}
				}
			}
		}
		// 设置开始执行时间
		taskData.setRunDate(new Date());

		// 如果允许，则开始执行。
		if (nolimitFlag == 0) {
			try {
				// 执行任务
				taskData.setResultData(taskRunner.runTask(taskData));
				taskData.setStatus(TaskData.STATUS_SUCCESS);
			} catch (TaskException e) {
				// 出现TaskException，说明是合作方的错误。
				taskData.setStatus(TaskData.STATUS_FAIL_PARTNER);
				taskData.setResultData(Utils.exceptionToString(e));
				log.error(e.getMessage(), e);
			} catch (Exception e) {
				// 设置异常状态
				taskData.setStatus(TaskData.STATUS_FAIL_PROGRAM);
				// 设置异常信息，自动屏蔽spring自己的输出。
				taskData.setResultData(Utils.exceptionToString(e));
				log.error(e.getMessage(), e);
			}
		} else {
			taskData.setResultData("RateLimit!!!");
			taskData.setStatus(TaskData.STATUS_FAIL_CONFIG);
		}
		// 如果异常，根据任务设置，重新跑
		if (taskData.getStatus() > TaskData.STATUS_SUCCESS) {
			if (taskData.getStatus() == TaskData.STATUS_FAIL_CONFIG) {
				if (taskData.getRanTimes() <= taskConfig.getRetryTimesByOverrated()) {
					taskScheduler.sendToQueue(taskData);
				}
			} else if (taskData.getStatus() == TaskData.STATUS_FAIL_PARTNER) {
				if (taskData.getRanTimes() <= taskConfig.getRetryTimesByPartner()) {
					taskScheduler.sendToQueue(taskData);
				}
			}
		}
		// 不管如何，都给设定结束日期。
		taskData.setFinishDate(new Date());
		// 保存日志与统计信息
		taskAPI.sendTaskRunnerLog(taskData);
		if (taskData.getRunType() == TaskData.RUN_TYPE_GLOBAL_RPC || taskData.getRunType() == TaskData.RUN_TYPE_LOCAL) {
			return taskData;
		} else {
			return null;
		}
	}

}