/// <summary>
/// 终止任务
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public async Task <object> HandleKill(HttpContext context)
{
var res = ReturnT.Failed("job has been executed or is executing");//This feature is not supported
try
{
var info = await context.Request.FromBody <JobKillRequest>();
_logger.LogInformation($"--------------终止任务{info?.jobId}--------------");
if (info != null)
{
var success = _xxlJobExecutor.KillJob(info.jobId, "终止任务[调度中心主动停止任务]");
if (success)
{
return(ReturnT.Success());
}
}
await Task.CompletedTask;
}
catch (Exception ex)
{
res = ReturnT.Failed(ex.StackTrace + "————" + ex.Message);
_logger.LogError(ex, "xxljob终止任务错误");
}
return(res);
}
/// <summary>
/// 查看执行日志
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public async Task <object> HandleLog(HttpContext context)
{
var res = ReturnT.Success();
try
{
var info = await context.Request.FromBody <JobGetLogRequest>();
_logger.LogInformation($"--------------查看执行日志{info?.logId}--------------");
res.Content = new
{
fromLineNum = 0, // 本次请求，日志开始行数
toLineNum = 100, // 本次请求，日志结束行号
logContent = "暂无日志", // 本次请求日志内容
isEnd = true // 日志是否全部加载完
};
await Task.CompletedTask;
}
catch (Exception ex)
{
res = ReturnT.Failed(ex.StackTrace + "————" + ex.Message);
_logger.LogError(ex, "xxljob查看执行日志错误");
}
return(res);
}
/// <summary>
/// 忙碌检测 路由策略选择忙碌转移时触发
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public async Task <object> HandleIdleBeat(HttpContext context)
{
var res = ReturnT.Success();
try
{
var info = await context.Request.FromBody <JobIdleBeatRequest>();
//_logger.LogInformation("--------------忙碌检测--------------");
if (info != null)
{
var isRunning = _xxlJobExecutor.IsRunningOrHasQueue(info.jobId);
if (isRunning)
{
return(ReturnT.Failed("任务执行中"));
}
}
await Task.CompletedTask;
}
catch (Exception ex)
{
res = ReturnT.Failed(ex.StackTrace + "————" + ex.Message);
_logger.LogError(ex, "xxljob忙碌检测错误");
}
return(res);
}
/// <summary>
/// 说明：触发任务执行
///------
///地址格式：{执行器内嵌服务跟地址}/run
///Header：
/// XXL-JOB-ACCESS-TOKEN : {请求令牌}
///请求数据格式如下，放置在 RequestBody 中，JSON格式：
/// {
/// "jobId":1, // 任务ID
/// "executorHandler":"demoJobHandler", // 任务标识
/// "executorParams":"demoJobHandler", // 任务参数
/// "executorBlockStrategy":"COVER_EARLY", // 任务阻塞策略，可选值参考 com.xxl.job.core.enums.ExecutorBlockStrategyEnum
/// "executorTimeout":0, // 任务超时时间，单位秒，大于零时生效
/// "logId":1, // 本次调度日志ID
/// "logDateTime":1586629003729, // 本次调度日志时间
/// "glueType":"BEAN", // 任务模式，可选值参考 com.xxl.job.core.glue.GlueTypeEnum
/// "glueSource":"xxx", // GLUE脚本代码
/// "glueUpdatetime":1586629003727, // GLUE脚本更新时间，用于判定脚本是否变更以及是否需要刷新
/// "broadcastIndex":0, // 分片参数：当前分片
/// "broadcastTotal":0 // 分片参数：总分片
/// }
///响应数据格式：
/// {
/// "code": 200, // 200 表示正常、其他失败
/// "msg": null // 错误提示消息
/// }
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public async Task <IActionResponse> ActionAsync(HttpContext context)
{
var jobInfo = await context.Request.FromBody <JobRunRequest>();
// 如果有积压任务，丢弃当前任务
if (jobInfo.ExecutorBlockStrategy == XxlJobConstant.EXECUTORBLOCKSTRATEGY_DISCARD_LATER)
{
if (await _dispatcher.Exist(jobInfo.JobId))
{
return(await context.JsonAsync(ReturnT.Failed("终止任务[执行策略: DISCARD_LATER]")));
}
}
// 覆盖之前调度负载之前积压的任务
else if (jobInfo.ExecutorBlockStrategy == XxlJobConstant.EXECUTORBLOCKSTRATEGY_COVER_EARLY)
{
if (await _dispatcher.Exist(jobInfo.JobId))
{
await _dispatcher.Kill(jobInfo.JobId, "终止任务[执行策略: COVER_EARLY]");
}
}
await _dispatcher.Enqueue(new JobMessage(jobInfo));
// action
return(await context.JsonAsync(ReturnT.Success()));
}
public async Task <ReturnT> Execute(JobExecuteContext context)
{
await Task.Delay(500);
_logger.LogInformation("defaultJobHandler执行了-------------------------");
await Task.CompletedTask;
return(ReturnT.Success());
// return ReturnT.Failed("失败原因");
}
public async Task <IActionResponse> ActionAsync(HttpContext context)
{
var info = await context.Request.FromBody <JobBaseRequest>();
if (info == null || info.JobId <= 0)
{
return(await context.JsonAsync(ReturnT.Failed("参数错误")));
}
if (await _dispatcher.Kill(info.JobId, "终止任务[调度中心主动停止任务]"))
{
return(await context.JsonAsync(ReturnT.Success()));
}
return(await context.JsonAsync(ReturnT.Failed("终止任务失败")));
}
/// <summary>
/// 心跳检测 路由策略选择故障转移时触发
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public async Task <object> HandleBeat(HttpContext context)
{
var res = ReturnT.Success();
try
{
//_logger.LogInformation("--------------心跳检测--------------");
await Task.CompletedTask;
}
catch (Exception ex)
{
res = ReturnT.Failed(ex.StackTrace + "————" + ex.Message);
_logger.LogError(ex, "xxljob心跳检测错误");
}
return(res);
}
public async Task <IActionResponse> ActionAsync(HttpContext context)
{
var info = await context.Request.FromBody <JobBaseRequest>();
if (info == null || info.JobId <= 0)
{
return(await context.JsonAsync(ReturnT.Failed("参数错误")));
}
var isRunning = await _dispatcher.Exist(info.JobId);
if (isRunning)
{
return(await context.JsonAsync(ReturnT.Failed("任务执行中")));
}
return(await context.JsonAsync(ReturnT.Success()));
}
/// <summary>
/// 触发任务
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public async Task <object> HandleRun(HttpContext context)
{
var res = ReturnT.Success();
try
{
var jobInfo = await context.Request.FromBody <JobRunRequest>();
//_logger.LogInformation($"--------------触发任务{JsonUtils.ToJson(jobInfo)}--------------");
//获取jobhandler并执行
var jobHandler = _jobHandlerManage.GetJobHandler(jobInfo.executorHandler);
if (jobHandler == null)
{
throw new Exception($"没有对应的JobHandler,{jobInfo.executorHandler}");
}
//处理执行器策略 默认是串行执行
Enum.TryParse(jobInfo.executorBlockStrategy, out ExecutorBlockStrategy blockStrategy);
if (blockStrategy == ExecutorBlockStrategy.DISCARD_LATER) //如果有积压任务，丢弃当前任务
{
if (_xxlJobExecutor.IsRunningOrHasQueue(jobInfo.jobId))
{
return(ReturnT.Failed("终止任务[执行策略: DISCARD_LATER]"));
}
}
else if (blockStrategy == ExecutorBlockStrategy.COVER_EARLY) //覆盖之前调度 负载之前积压的任务
{
if (_xxlJobExecutor.IsRunningOrHasQueue(jobInfo.jobId))
{
_xxlJobExecutor.KillJob(jobInfo.jobId, "终止任务[执行策略：COVER_EARLY]"); //停止该jogid对应的所有积压的任务(已经在执行中的就停止不了)
}
}
await AsyncExecuteJob(jobInfo, jobHandler);
}
catch (Exception ex)
{
res = ReturnT.Failed(ex.StackTrace + "————" + ex.Message);
_logger.LogError(ex, "xxljob触发任务错误");
}
return(res);
}
public async Task <ReturnT> Execute(JobExecuteContext context)
{
var result = ReturnT.Success();
try
{
//await Task.Delay(30000);
//这里执行业务逻辑
_logger.LogInformation("SecondJobHandler执行了-------------------------");
await Task.CompletedTask;
}
catch (BizException) //业务异常
{
}
catch (Exception ex)
{
//只有系统异常返回错误，便于重试
result = ReturnT.Failed(ex.Message);
}
return(result);
}
public async Task <ReturnT> Execute(JobExecuteContext context)
{
var result = ReturnT.Success();
try
{
var url = _xxlJobOption.HttpJobhandlerUrl;
if (string.IsNullOrEmpty(url))
{
return(ReturnT.Failed("httpJobHandler任务请配置url"));
}
JObject jobParameter = JObject.Parse(context.JobParameter);
string path = GetPathAndRemovePath(jobParameter);
if (string.IsNullOrEmpty(path))
{
return(ReturnT.Failed("httpJobHandler任务请配置path"));
}
// jobParameter.Add("logId", context.LogId);
var header = CreateHeader();
var param = new { logId = context.LogId, jobParameter = jobParameter };
var res = await _httpClientFactory.CreateClient().PostJsonAsync <HttpJobHandlerResponse>(StringUtils.AppendUrlPath(url, path), param, header);
if (res == null || res.code != HttpJobHandler.SuccessCode)
{
result = ReturnT.Failed(res?.msg ?? "执行http任务异常");
}
}
catch (Exception ex)
{
_logger.LogError(ex, "执行httpJobHandler异常");
result = ReturnT.Failed($"{ex.StackTrace},{ex.Message}");
}
return(result);
}
public async Task <IActionResponse> ActionAsync(HttpContext context)
{
var info = await context.Request.FromBody <JobLogRequest>();
if (info == null || info.JobLogId <= 0)
{
return(await context.JsonAsync(ReturnT.Failed("参数错误")));
}
(var logs, var totalCount) = await _store.FilterJobList(info.FromLineNum - 1, Default_Limit, info.JobLogId);
StringBuilder sb = new StringBuilder();
foreach (var log in logs)
{
sb.AppendLine($"[{log.InData.ToString("yyyy-MM-dd HH:mm:ss")}],{log.Message}");
}
// 从1开始
var endLineNum = info.FromLineNum + logs.Count;
var res = ReturnT.Success();
res.Content = new
{
// 本次请求，日志开始行数
fromLineNum = info.FromLineNum,
// 本次请求，日志结束行号
toLineNum = endLineNum,
// 本次请求日志内容
logContent = sb.ToString(),
// 日志是否全部加载完
isEnd = totalCount <= endLineNum
};
return(await context.JsonAsync(res));
}
public async Task <ReturnT> Execute(JobExecuteContext context)
{
var result = ReturnT.Success();
try
{
// await Task.Delay(30000);
//这里执行业务逻辑
//_logger.LogInformation("firstJobHandler执行了{0}, {1}", "1", 2);
_logger.LogInformation("firstJobHandler执行了{a}, {b}", "1", 2); //只占位符
//throw new Exception(" 系统异常了，要重试了吧");
await Task.CompletedTask;
}
catch (BizException) //业务异常
{
}
catch (Exception ex)
{
//只有系统异常返回错误，便于重试
result = ReturnT.Failed($"{ex.StackTrace},{ex.Message}");
}
return(result);
}
public Task <ReturnT> Execute(JobExecuteContext context)
{
_logger.LogInformation($"Hello, {context.LogId}, {context.JobParameter}");
return(Task.FromResult(ReturnT.Success()));
}
public async Task <IActionResponse> ActionAsync(HttpContext context)
{
return(await context.JsonAsync(ReturnT.Success()));
}