ewide/number_zj
22
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

init commit

Browse Source
This commit is contained in:
路 范
2022-03-30 17:54:33 +08:00
parent df01841625
commit 904bdd16cd
500 changed files with 217251 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

230
20220330_Vote/Ewide.Core/Service/Timer/Dto/JobInput.cs Normal file
View File

@@ -0,0 +1,230 @@
using Furion.DataValidation;
using Furion.TaskScheduler;
using System;
using System.ComponentModel.DataAnnotations;
namespace Ewide.Core.Service
{
/// <summary>
/// 任务调度参数
/// </summary>
public class JobPageInput : PageInputBase
{
/// <summary>
/// 任务名称
/// </summary>
public string JobName { get; set; }
/// <summary>
/// 只执行一次
/// </summary>
public bool DoOnce { get; set; } = false;
/// <summary>
/// 立即执行（默认等待启动）
/// </summary>
public bool StartNow { get; set; } = false;
/// <summary>
/// 执行类型(并行、列队)
/// </summary>
public SpareTimeExecuteTypes ExecuteType { get; set; }
/// <summary>
/// 执行间隔时间（单位秒）
/// </summary>
/// <example>5</example>
public int Interval { get; set; }
/// <summary>
/// Cron表达式
/// </summary>
public string Cron { get; set; }
/// <summary>
/// 定时器类型
/// </summary>
public SpareTimeTypes TimerType { get; set; }
/// <summary>
/// 请求url
/// </summary>
public string RequestUrl { get; set; }
/// <summary>
/// 请求参数（Post，Put请求用）
/// </summary>
public string RequestParameters { get; set; }
/// <summary>
/// Headers(可以包含如：Authorization授权认证)
/// 格式：{"Authorization":"userpassword.."}
/// </summary>
public string Headers { get; set; }
/// <summary>
/// 请求类型
/// </summary>
public RequestTypeEnum RequestType { get; set; }
/// <summary>
/// 备注
/// </summary>
public string Remark { get; set; }
}
public class AddJobInput
{
/// <summary>
/// 任务名称
/// </summary>
public string JobName { get; set; }
/// <summary>
/// 只执行一次
/// </summary>
public bool DoOnce { get; set; } = false;
/// <summary>
/// 立即执行（默认等待启动）
/// </summary>
public bool StartNow { get; set; } = false;
/// <summary>
/// 执行类型(并行、列队)
/// </summary>
public SpareTimeExecuteTypes ExecuteType { get; set; }
/// <summary>
/// 执行间隔时间（单位秒）
/// </summary>
/// <example>5</example>
public int Interval { get; set; }
/// <summary>
/// Cron表达式
/// </summary>
public string Cron { get; set; }
/// <summary>
/// 定时器类型
/// </summary>
public SpareTimeTypes TimerType { get; set; }
/// <summary>
/// 请求url
/// </summary>
public string RequestUrl { get; set; }
/// <summary>
/// 请求参数（Post，Put请求用）
/// </summary>
public string RequestParameters { get; set; }
/// <summary>
/// Headers(可以包含如：Authorization授权认证)
/// 格式：{"Authorization":"userpassword.."}
/// </summary>
public string Headers { get; set; }
/// <summary>
/// 请求类型
/// </summary>
public RequestTypeEnum RequestType { get; set; }
/// <summary>
/// 备注
/// </summary>
public string Remark { get; set; }
}
public class StopJobInput
{
public string JobName { get; set; }
}
public class DeleteJobInput : QueryJobInput
{
}
public class UpdateJobInput : QueryJobInput
{
/// <summary>
/// 任务名称
/// </summary>
/// <example>dilon</example>
[Required, MaxLength(20)]
public string JobName { get; set; }
/// <summary>
/// 只执行一次
/// </summary>
public bool DoOnce { get; set; } = false;
/// <summary>
/// 立即执行（默认等待启动）
/// </summary>
public bool StartNow { get; set; } = false;
/// <summary>
/// 执行类型(并行、列队)
/// </summary>
public SpareTimeExecuteTypes ExecuteType { get; set; } = SpareTimeExecuteTypes.Parallel;
/// <summary>
/// 执行间隔时间（单位秒）
/// </summary>
/// <example>5</example>
public int? Interval { get; set; } = 5;
/// <summary>
/// Cron表达式
/// </summary>
/// <example></example>
[MaxLength(20)]
public string Cron { get; set; }
/// <summary>
/// 定时器类型
/// </summary>
public SpareTimeTypes TimerType { get; set; } = SpareTimeTypes.Interval;
/// <summary>
/// 请求url
/// </summary>
[MaxLength(200)]
public string RequestUrl { get; set; }
/// <summary>
/// 请求参数（Post，Put请求用）
/// </summary>
public string RequestParameters { get; set; }
/// <summary>
/// Headers(可以包含如：Authorization授权认证)
/// 格式：{"Authorization":"userpassword.."}
/// </summary>
public string Headers { get; set; }
/// <summary>
/// 请求类型
/// </summary>
/// <example>2</example>
public RequestTypeEnum RequestType { get; set; } = RequestTypeEnum.Post;
/// <summary>
/// 备注
/// </summary>
[MaxLength(100)]
public string Remark { get; set; }
}
public class QueryJobInput
{
[Required(ErrorMessage = "Id不能为空")]
public string Id { get; set; }
}
}

150
20220330_Vote/Ewide.Core/Service/Timer/Dto/JobOutput.cs Normal file
View File

@@ -0,0 +1,150 @@
using Furion.TaskScheduler;
using Quartz;
using System;
namespace Ewide.Core.Service
{
/// <summary>
/// 任务信息---任务详情
/// </summary>
public class JobOutput
{
/// <summary>
/// Id
/// </summary>
public string Id { get; set; }
/// <summary>
/// 已执行次数
/// </summary>
public long? RunNumber { get; set; }
/// <summary>
/// 定时器状态
/// </summary>
public SpareTimeStatus TimerStatus { get; set; } = SpareTimeStatus.Stopped;
/// <summary>
/// 异常信息
/// </summary>
public string Exception { get; set; }
/// <summary>
/// 任务名称
/// </summary>
public string JobName { get; set; }
/// <summary>
/// 只执行一次
/// </summary>
public bool DoOnce { get; set; } = false;
/// <summary>
/// 立即执行（默认等待启动）
/// </summary>
public bool StartNow { get; set; } = false;
/// <summary>
/// 执行类型(并行、列队)
/// </summary>
public SpareTimeExecuteTypes ExecuteType { get; set; }
/// <summary>
/// 执行间隔时间（单位秒）
/// </summary>
public int Interval { get; set; }
/// <summary>
/// Cron表达式
/// </summary>
public string Cron { get; set; }
/// <summary>
/// 定时器类型
/// </summary>
public SpareTimeTypes TimerType { get; set; }
/// <summary>
/// 请求url
/// </summary>
public string RequestUrl { get; set; }
/// <summary>
/// 请求类型
/// </summary>
/// <example>2</example>
public RequestTypeEnum RequestType { get; set; }
/// <summary>
/// 备注
/// </summary>
public string Remark { get; set; }
}
/// <summary>
/// 任务方法信息
/// </summary>
public class TaskMethodInfo
{
/// <summary>
/// 方法名
/// </summary>
public string MethodName { get; set; }
/// <summary>
/// 方法所属类的Type对象
/// </summary>
public Type DeclaringType { get; set; }
/// <summary>
/// 任务名称
/// </summary>
public string JobName { get; set; }
/// <summary>
/// 只执行一次
/// </summary>
public bool DoOnce { get; set; } = false;
/// <summary>
/// 立即执行（默认等待启动）
/// </summary>
public bool StartNow { get; set; } = false;
/// <summary>
/// 执行类型(并行、列队)
/// </summary>
public SpareTimeExecuteTypes ExecuteType { get; set; }
/// <summary>
/// 执行间隔时间（单位秒）
/// </summary>
public int Interval { get; set; }
/// <summary>
/// Cron表达式
/// </summary>
public string Cron { get; set; }
/// <summary>
/// 定时器类型
/// </summary>
public SpareTimeTypes TimerType { get; set; }
/// <summary>
/// 请求url
/// </summary>
public string RequestUrl { get; set; }
/// <summary>
/// 请求类型
/// </summary>
/// <example>2</example>
public RequestTypeEnum RequestType { get; set; }
/// <summary>
/// 备注
/// </summary>
public string Remark { get; set; }
}
}

68
20220330_Vote/Ewide.Core/Service/Timer/HttpJob.cs Normal file
View File

@@ -0,0 +1,68 @@
using Furion.JsonSerialization;
using Furion.RemoteRequest.Extensions;
using Quartz;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace Ewide.Core.Service
{
[DisallowConcurrentExecution]
public class HttpJob : IJob
{
//protected readonly int _maxLogCount = 20; //最多保存日志数量
//protected Stopwatch _stopwatch = new();
public async Task Execute(IJobExecutionContext context)
{
// 获取相关参数
var requestUrl = context.JobDetail.JobDataMap.GetString(SchedulerDef.REQUESTURL)?.Trim();
requestUrl = requestUrl?.IndexOf("http") == 0 ? requestUrl : "http://" + requestUrl;
var requestParameters = context.JobDetail.JobDataMap.GetString(SchedulerDef.REQUESTPARAMETERS);
var headersString = context.JobDetail.JobDataMap.GetString(SchedulerDef.HEADERS);
var headers = !string.IsNullOrWhiteSpace(headersString) ? JSON.GetJsonSerializer().Deserialize<Dictionary<string, string>>(headersString.Trim()) : null;
var requestType = (RequestTypeEnum)int.Parse(context.JobDetail.JobDataMap.GetString(SchedulerDef.REQUESTTYPE));
// var response = new HttpResponseMessage();
switch (requestType)
{
case RequestTypeEnum.Get:
await requestUrl.SetHeaders(headers).GetAsync();
break;
case RequestTypeEnum.Post:
await requestUrl.SetHeaders(headers).SetQueries(requestParameters).PostAsync();
break;
case RequestTypeEnum.Put:
await requestUrl.SetHeaders(headers).SetQueries(requestParameters).PutAsync();
break;
case RequestTypeEnum.Delete:
await requestUrl.SetHeaders(headers).DeleteAsync();
break;
}
//_stopwatch.Restart(); // 开始监视代码运行时间
//// var beginTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
//Debug.WriteLine(DateTimeOffset.Now.ToString());
//// var endTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
//_stopwatch.Stop(); // 停止监视
////// 执行次数
////var runNumber = context.JobDetail.JobDataMap.GetString(SchedulerDef.RUNNUMBER);
////context.JobDetail.JobDataMap[SchedulerDef.RUNNUMBER] = runNumber;
//// 耗时
//var seconds = _stopwatch.Elapsed.TotalSeconds; // 总秒数
//var executeTime = seconds >= 1 ? seconds + "秒" : _stopwatch.Elapsed.TotalMilliseconds + "毫秒";
////// 只保留20条记录
////var logs = context.JobDetail.JobDataMap[SchedulerDef.LOGLIST] as List<string> ?? new List<string>();
////if (logs.Count >= _maxLogCount)
//// logs.RemoveRange(0, logs.Count - _maxLogCount);
////logs.Add($"<p class='msgList'><span class='time'>{beginTime} 至 {endTime} 【耗时】{executeTime}</span></p>");
////context.JobDetail.JobDataMap[SchedulerDef.LOGLIST] = logs;
}
}
}

17
20220330_Vote/Ewide.Core/Service/Timer/ISysTimerService.cs Normal file
View File

@@ -0,0 +1,17 @@
using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace Ewide.Core.Service
{
public interface ISysTimerService
{
Task<dynamic> GetTimerPageList([FromQuery] JobPageInput input);
Task<dynamic> GetLocalJobList();
Task AddTimer(AddJobInput input);
Task DeleteTimer(DeleteJobInput input);
Task UpdateTimber(UpdateJobInput input);
Task<dynamic> GetTimer([FromQuery] QueryJobInput input);
Task<IEnumerable<TaskMethodInfo>> GetTaskMethods();
}
}

336
20220330_Vote/Ewide.Core/Service/Timer/SchedulerCenter.cs Normal file
View File

@@ -0,0 +1,336 @@
using Furion.DatabaseAccessor;
using Furion.DependencyInjection;
using Furion.FriendlyException;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using Quartz;
using Quartz.Impl;
using Quartz.Impl.Matchers;
using Quartz.Impl.Triggers;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace Ewide.Core.Service
{
/// <summary>
/// 任务调度中心
/// </summary>
public class SchedulerCenter : ISingleton
{
private IScheduler _scheduler = null;
public SchedulerCenter()
{
_ = StartScheduleAsync();
InitAllJob().GetAwaiter();
}
/// <summary>
/// 开启调度器
/// </summary>
/// <returns></returns>
private async Task<bool> StartScheduleAsync()
{
if (_scheduler == null)
{
// 初始化Scheduler
var schedulerFactory = new StdSchedulerFactory();
_scheduler = await schedulerFactory.GetScheduler();
// 开启调度器
if (_scheduler.InStandbyMode)
await _scheduler.Start();
}
return _scheduler.InStandbyMode;
}
/// <summary>
/// 停止调度器
/// </summary>
private async Task<bool> StopScheduleAsync()
{
//判断调度是否已经关闭
if (!_scheduler.InStandbyMode)
{
//等待任务运行完成
await _scheduler.Standby(); // 注意：Shutdown后Start会报错，所以这里使用暂停。
}
return !_scheduler.InStandbyMode;
}
/// <summary>
/// 添加一个工作任务
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task<dynamic> AddScheduleJobAsync(JobInput input)
{
// 检查任务是否已存在
var jobKey = new JobKey(input.JobName, input.JobGroup);
if (await _scheduler.CheckExists(jobKey))
throw Oops.Oh("任务已存在");
// http请求配置
var httpDir = new Dictionary<string, string>()
{
{ SchedulerDef.ENDAT, input.EndTime.ToString()},
{ SchedulerDef.REQUESTURL, input.RequestUrl},
{ SchedulerDef.HEADERS, input.Headers },
{ SchedulerDef.REQUESTPARAMETERS, input.RequestParameters},
{ SchedulerDef.REQUESTTYPE, ((int)input.RequestType).ToString()},
{ SchedulerDef.RUNNUMBER, input.RunNumber.ToString()}
};
// 定义这个工作，并将其绑定到我们的IJob实现类
IJobDetail job = JobBuilder.Create<HttpJob>()
.SetJobData(new JobDataMap(httpDir))
.WithDescription(input.Remark)
.WithIdentity(input.JobName, input.JobGroup)
.Build();
// 创建触发器
ITrigger trigger = input.TriggerType == TriggerTypeEnum.Cron // && CronExpression.IsValidExpression(entity.Cron)
? CreateCronTrigger(input)
: CreateSimpleTrigger(input);
return await _scheduler.ScheduleJob(job, trigger);
}
/// <summary>
/// 暂停任务
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task StopScheduleJobAsync(JobInput input)
{
var jobKey = new JobKey(input.JobName, input.JobGroup);
await _scheduler.PauseJob(jobKey);
}
/// <summary>
/// 删除任务
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task DeleteScheduleJobAsync(DeleteJobInput input)
{
var jobKey = new JobKey(input.JobName, input.JobGroup);
await _scheduler.PauseJob(jobKey);
await _scheduler.DeleteJob(jobKey);
}
/// <summary>
/// 恢复运行暂停的任务
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost("/sysTimer/resumeJob")]
public async Task<dynamic> ResumeJobAsync(JobInput input)
{
//检查任务是否存在
var jobKey = new JobKey(input.JobName, input.JobGroup);
if (await _scheduler.CheckExists(jobKey))
{
var jobDetail = await _scheduler.GetJobDetail(jobKey);
var endTime = jobDetail.JobDataMap.GetString(SchedulerDef.ENDAT);
if (!string.IsNullOrWhiteSpace(endTime) && DateTime.Parse(endTime) <= DateTime.Now)
{
throw Oops.Oh("Job的结束时间已过期");
}
else
{
await _scheduler.ResumeJob(jobKey); // 任务已经存在则暂停任务
}
}
return Task.CompletedTask;
}
/// <summary>
/// 查询任务
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task<JobInput> QueryJobAsync(JobInput input)
{
var jobKey = new JobKey(input.JobName, input.JobGroup);
var jobDetail = await _scheduler.GetJobDetail(jobKey);
var triggersList = await _scheduler.GetTriggersOfJob(jobKey);
var triggers = triggersList.AsEnumerable().FirstOrDefault();
var intervalSeconds = (triggers as SimpleTriggerImpl)?.RepeatInterval.TotalSeconds;
var endTime = jobDetail.JobDataMap.GetString(SchedulerDef.ENDAT);
return new JobInput
{
BeginTime = triggers.StartTimeUtc.LocalDateTime,
EndTime = !string.IsNullOrWhiteSpace(endTime) ? DateTime.Parse(endTime) : null,
Interval = intervalSeconds.HasValue ? Convert.ToInt32(intervalSeconds.Value) : null,
JobGroup = input.JobGroup,
JobName = input.JobName,
Cron = (triggers as CronTriggerImpl)?.CronExpressionString,
RunNumber = (triggers as SimpleTriggerImpl)?.RepeatCount,
TriggerType = triggers is SimpleTriggerImpl ? TriggerTypeEnum.Simple : TriggerTypeEnum.Cron,
Remark = jobDetail.Description,
RequestUrl = jobDetail.JobDataMap.GetString(SchedulerDef.REQUESTURL),
RequestType = (RequestTypeEnum)int.Parse(jobDetail.JobDataMap.GetString(SchedulerDef.REQUESTTYPE)),
RequestParameters = jobDetail.JobDataMap.GetString(SchedulerDef.REQUESTPARAMETERS),
Headers = jobDetail.JobDataMap.GetString(SchedulerDef.HEADERS)
};
}
/// <summary>
/// 立即执行
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task TriggerJobAsync(JobInput input)
{
var jobKey = new JobKey(input.JobName, input.JobGroup);
await _scheduler.ResumeJob(jobKey);
}
/// <summary>
/// 获取任务日志
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task<List<string>> GetJobLogsAsync(JobInput input)
{
var jobKey = new JobKey(input.JobName, input.JobGroup);
var jobDetail = await _scheduler.GetJobDetail(jobKey);
return jobDetail.JobDataMap[SchedulerDef.LOGLIST] as List<string>;
}
/// <summary>
/// 获取任务运行次数
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task<long> GetRunNumberAsync(JobInput input)
{
var jobKey = new JobKey(input.JobName, input.JobGroup);
var jobDetail = await _scheduler.GetJobDetail(jobKey);
return jobDetail.JobDataMap.GetLong(SchedulerDef.RUNNUMBER);
}
/// <summary>
/// 获取所有任务详情
/// </summary>
/// <returns></returns>
public async Task<List<JobOutput>> GetJobList()
{
var jobInfoList = new List<JobOutput>();
var groupNames = await _scheduler.GetJobGroupNames();
var jboKeyList = new List<JobKey>();
foreach (var groupName in groupNames.OrderBy(t => t))
{
jboKeyList.AddRange(await _scheduler.GetJobKeys(GroupMatcher<JobKey>.GroupEquals(groupName)));
//jobInfoList.Add(new JobOutput() { JobGroup = groupName });
}
foreach (var jobKey in jboKeyList.OrderBy(t => t.Name))
{
var jobDetail = await _scheduler.GetJobDetail(jobKey);
var triggersList = await _scheduler.GetTriggersOfJob(jobKey);
var triggers = triggersList.AsEnumerable().FirstOrDefault();
var interval = triggers is SimpleTriggerImpl
? ((triggers as SimpleTriggerImpl)?.RepeatInterval.ToString())
: ((triggers as CronTriggerImpl)?.CronExpressionString);
jobInfoList.Add(new JobOutput
{
JobName = jobKey.Name,
JobGroup = jobKey.Group,
LastErrMsg = jobDetail.JobDataMap.GetString(SchedulerDef.EXCEPTION),
RequestUrl = jobDetail.JobDataMap.GetString(SchedulerDef.REQUESTURL),
TriggerState = await _scheduler.GetTriggerState(triggers.Key),
PreviousFireTime = triggers.GetPreviousFireTimeUtc()?.LocalDateTime,
NextFireTime = triggers.GetNextFireTimeUtc()?.LocalDateTime,
BeginTime = triggers.StartTimeUtc.LocalDateTime,
Interval = interval,
EndTime = triggers.EndTimeUtc?.LocalDateTime,
Remark = jobDetail.Description,
RequestType = jobDetail.JobDataMap.GetString(SchedulerDef.REQUESTTYPE),
RunNumber = jobDetail.JobDataMap.GetString(SchedulerDef.RUNNUMBER)
});
}
return jobInfoList;
}
/// <summary>
/// 从数据库里面获取所有任务并初始化
/// </summary>
private async Task InitAllJob()
{
var jobList = Db.GetRepository<SysTimer>().DetachedEntities.Select(u => u.Adapt<JobInput>()).ToList();
var jobTasks = new List<Task<dynamic>>();
jobList.ForEach(u =>
{
jobTasks.Add(AddScheduleJobAsync(u));
});
await Task.WhenAll(jobTasks);
}
/// <summary>
/// 创建类型Simple的触发器
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
private static ITrigger CreateSimpleTrigger(JobInput input)
{
//作业触发器
if (input.RunNumber.HasValue && input.RunNumber > 0)
{
return TriggerBuilder.Create()
.WithIdentity(input.JobName, input.JobGroup)
.StartAt(input.BeginTime)//开始时间
//.EndAt(entity.EndTime)//结束数据
.WithSimpleSchedule(x =>
{
x.WithIntervalInSeconds(input.Interval.Value)//执行时间间隔，单位秒
.WithRepeatCount(input.RunNumber.Value)//执行次数、默认从0开始
.WithMisfireHandlingInstructionFireNow();
})
.ForJob(input.JobName, input.JobGroup)//作业名称
.Build();
}
else
{
return TriggerBuilder.Create()
.WithIdentity(input.JobName, input.JobGroup)
.StartAt(input.BeginTime)//开始时间
//.EndAt(entity.EndTime)//结束数据
.WithSimpleSchedule(x =>
{
x.WithIntervalInSeconds(input.Interval.Value)//执行时间间隔，单位秒
.RepeatForever()//无限循环
.WithMisfireHandlingInstructionFireNow();
})
.ForJob(input.JobName, input.JobGroup)//作业名称
.Build();
}
}
/// <summary>
/// 创建类型Cron的触发器
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
private static ITrigger CreateCronTrigger(JobInput input)
{
if (!CronExpression.IsValidExpression(input.Cron))
throw Oops.Oh("Cron表达式错误");
// 作业触发器
return TriggerBuilder.Create()
.WithIdentity(input.JobName, input.JobGroup)
.StartAt(input.BeginTime) //开始时间
//.EndAt(entity.EndTime) //结束时间
.WithCronSchedule(input.Cron, cronScheduleBuilder => cronScheduleBuilder.WithMisfireHandlingInstructionFireAndProceed())//指定cron表达式
.ForJob(input.JobName, input.JobGroup)//作业名称
.Build();
}
}
}

63
20220330_Vote/Ewide.Core/Service/Timer/SchedulerDef.cs Normal file
View File

@@ -0,0 +1,63 @@
namespace Ewide.Core.Service
{
/// <summary>
/// 任务调度相关常量
/// </summary>
public class SchedulerDef
{
/// <summary>
/// 请求url RequestUrl
/// </summary>
public const string REQUESTURL = "RequestUrl";
/// <summary>
/// 请求参数 RequestParameters
/// </summary>
public const string REQUESTPARAMETERS = "RequestParameters";
/// <summary>
/// Headers（可以包含：Authorization授权认证）
/// </summary>
public const string HEADERS = "Headers";
/// <summary>
/// 请求类型 RequestType
/// </summary>
public const string REQUESTTYPE = "RequestType";
/// <summary>
/// 日志 LogList
/// </summary>
public const string LOGLIST = "LogList";
/// <summary>
/// 异常 Exception
/// </summary>
public const string EXCEPTION = "Exception";
/// <summary>
/// 执行次数
/// </summary>
public const string RUNNUMBER = "RunNumber";
/// <summary>
/// 任务结束时间
/// </summary>
public const string ENDAT = "EndAt";
}
/// <summary>
/// http请求类型
/// </summary>
public enum RequestTypeEnum
{
None = 0,
Get = 1,
Post = 2,
Put = 3,
Delete = 4
}
/// <summary>
/// 触发器类型
/// </summary>
public enum TriggerTypeEnum
{
None = 0,
Simple = 1,
Cron = 2
}
}

323
20220330_Vote/Ewide.Core/Service/Timer/SysTimerService.cs Normal file
View File

@@ -0,0 +1,323 @@
using Ewide.Core.Extension;
using Furion;
using Furion.DatabaseAccessor;
using Furion.DatabaseAccessor.Extensions;
using Furion.DependencyInjection;
using Furion.DynamicApiController;
using Furion.FriendlyException;
using Furion.JsonSerialization;
using Furion.RemoteRequest.Extensions;
using Furion.TaskScheduler;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
namespace Ewide.Core.Service
{
/// <summary>
/// 任务调度服务
/// </summary>
[ApiDescriptionSettings(Name = "Timer", Order = 100)]
public class SysTimerService : ISysTimerService, IDynamicApiController, IScoped
{
private readonly IRepository<SysTimer> _sysTimerRep; // 任务表仓储
private readonly ISysCacheService _cache;
//private readonly SchedulerCenter _schedulerCenter; //随框架更新已弃用
public SysTimerService(IRepository<SysTimer> sysTimerRep, ISysCacheService cache)
{
_sysTimerRep = sysTimerRep;
_cache = cache;
}
/// <summary>
/// 分页获取任务列表
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost("/sysTimers/page")]
public async Task<dynamic> GetTimerPageList([FromBody] JobPageInput input)
{
var workers = SpareTime.GetWorkers().ToList();
var timers = await _sysTimerRep.DetachedEntities
.Where(!string.IsNullOrEmpty(input.JobName?.Trim()), u => EF.Functions.Like(u.JobName, $"%{input.JobName.Trim()}%"))
.Select(u => u.Adapt<JobOutput>())
.ToPagedListAsync(input.PageIndex, input.PageSize);
timers.Items.ToList().ForEach(u =>
{
var timer = workers.FirstOrDefault(m => m.WorkerName == u.JobName);
if (timer != null)
{
u.TimerStatus = timer.Status;
u.RunNumber = timer.Tally;
u.Exception = Newtonsoft.Json.JsonConvert.SerializeObject(timer.Exception);
}
});
return PageDataResult<JobOutput>.PageResult(timers);
}
/// <summary>
/// 获取所有本地任务
/// </summary>
/// <returns></returns>
[HttpGet("/sysTimers/localJobList")]
public async Task<dynamic> GetLocalJobList()
{
// 获取本地所有任务方法
return await GetTaskMethods();
}
/// <summary>
/// 增加任务
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost("/sysTimers/add")]
public async Task AddTimer(AddJobInput input)
{
var isExist = await _sysTimerRep.AnyAsync(u => u.JobName == input.JobName, false);
if (isExist)
throw Oops.Oh(ErrorCode.D1100);
var timer = input.Adapt<SysTimer>();
await _sysTimerRep.InsertAsync(timer);
// 添加到任务调度里
AddTimerJob(input);
}
/// <summary>
/// 删除任务
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost("/sysTimers/delete")]
public async Task DeleteTimer(DeleteJobInput input)
{
var timer = await _sysTimerRep.FirstOrDefaultAsync(u => u.Id == input.Id);
if (timer == null)
throw Oops.Oh(ErrorCode.D1101);
await timer.DeleteAsync();
// 从调度器里取消
SpareTime.Cancel(timer.JobName);
}
/// <summary>
/// 修改任务
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost("/sysTimers/edit")]
public async Task UpdateTimber(UpdateJobInput input)
{
// 排除自己并且判断与其他是否相同
var isExist = await _sysTimerRep.AnyAsync(u => u.JobName == input.JobName && u.Id != input.Id, false);
if (isExist) throw Oops.Oh(ErrorCode.D1100);
// 先从调度器里取消
var oldTimer = await _sysTimerRep.FirstOrDefaultAsync(u => u.Id == input.Id, false);
SpareTime.Cancel(oldTimer.JobName);
var timer = input.Adapt<SysTimer>();
await timer.UpdateAsync(ignoreNullValues: true);
var addJobInput = input.Adapt<AddJobInput>();
// 再添加到任务调度里
AddTimerJob(addJobInput);
}
/// <summary>
/// 查看任务
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpGet("/sysTimers/detail")]
public async Task<dynamic> GetTimer([FromQuery] QueryJobInput input)
{
return await _sysTimerRep.DetachedEntities.FirstOrDefaultAsync(u => u.Id == input.Id);
}
/// <summary>
/// 停止任务
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost("/sysTimers/stop")]
public void StopTimerJob(StopJobInput input)
{
SpareTime.Stop(input.JobName);
}
/// <summary>
/// 启动任务
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost("/sysTimers/start")]
public void StartTimerJob(AddJobInput input)
{
var timer = SpareTime.GetWorkers().ToList().Find(u => u.WorkerName == input.JobName);
if (timer == null)
//AddTimerJob(input);
throw Oops.Oh("启动失败：任务不存在");
// 如果 StartNow 为 flase , 执行 AddTimerJob 并不会启动任务
SpareTime.Start(input.JobName);
}
/// <summary>
/// 新增定时任务
/// </summary>
/// <param name="input"></param>
[NonAction]
public void AddTimerJob(AddJobInput input)
{
Action<SpareTimer, long> action = null;
switch (input.RequestType)
{
// 创建本地方法委托
case RequestTypeEnum.Run:
{
// 查询符合条件的任务方法
var taskMethod = GetTaskMethods()?.Result.FirstOrDefault(m => m.RequestUrl == input.RequestUrl);
if (taskMethod == null) break;
// 创建任务对象
var typeInstance = Activator.CreateInstance(taskMethod.DeclaringType);
// 创建委托
action = (Action<SpareTimer, long>)Delegate.CreateDelegate(typeof(Action<SpareTimer, long>), typeInstance, taskMethod.MethodName);
break;
}
// 创建网络任务委托
default:
{
action = async (_, _) =>
{
var requestUrl = input.RequestUrl.Trim();
requestUrl = requestUrl?.IndexOf("http") == 0 ? requestUrl : "http://" + requestUrl;
var requestParameters = input.RequestParameters;
var headersString = input.Headers;
var headers = string.IsNullOrEmpty(headersString)
? null
: JSON.Deserialize<Dictionary<string, string>>(headersString);
switch (input.RequestType)
{
case RequestTypeEnum.Get:
await requestUrl.SetHeaders(headers).GetAsync();
break;
case RequestTypeEnum.Post:
await requestUrl.SetHeaders(headers).SetQueries(requestParameters).PostAsync();
break;
case RequestTypeEnum.Put:
await requestUrl.SetHeaders(headers).SetQueries(requestParameters).PutAsync();
break;
case RequestTypeEnum.Delete:
await requestUrl.SetHeaders(headers).DeleteAsync();
break;
}
};
break;
}
}
if (action == null) return;
// 缓存任务配置参数，以供任务运行时读取
if (input.RequestType == RequestTypeEnum.Run)
{
var jobParametersName = $"{input.JobName}_Parameters";
var jobParameters = _cache.Exists(jobParametersName);
var requestParametersIsNull = string.IsNullOrEmpty(input.RequestParameters);
// 如果没有任务配置却又存在缓存，则删除缓存
if (requestParametersIsNull && jobParameters)
_cache.DelAsync(jobParametersName);
else if (!requestParametersIsNull)
_cache.SetAsync(jobParametersName, JSON.Deserialize<Dictionary<string, string>>(input.RequestParameters));
}
// 创建定时任务
switch (input.TimerType)
{
case SpareTimeTypes.Interval:
if (input.DoOnce)
SpareTime.DoOnce(input.Interval * 1000, action, input.JobName, input.Remark, input.StartNow, executeType: input.ExecuteType);
else
SpareTime.Do(input.Interval * 1000, action, input.JobName, input.Remark, input.StartNow, executeType: input.ExecuteType);
break;
case SpareTimeTypes.Cron:
SpareTime.Do(input.Cron, action, input.JobName, input.Remark, input.StartNow, executeType: input.ExecuteType);
break;
}
}
/// <summary>
/// 启动自启动任务
/// </summary>
[NonAction]
public void StartTimerJob()
{
var sysTimerList = _sysTimerRep.DetachedEntities.Where(t => t.StartNow).Select(u => u.Adapt<AddJobInput>()).ToList();
sysTimerList.ForEach(AddTimerJob);
}
/// <summary>
/// 获取所有本地任务
/// </summary>
/// <returns></returns>
[NonAction]
public async Task<IEnumerable<TaskMethodInfo>> GetTaskMethods()
{
// 有缓存就返回缓存
var taskMethods = await _cache.GetAsync<IEnumerable<TaskMethodInfo>>(CommonConst.CACHE_KEY_TIMER_JOB);
if (taskMethods != null) return taskMethods;
// 获取所有本地任务方法，必须有spareTimeAttribute特性
taskMethods = App.EffectiveTypes
.Where(u => u.IsClass && !u.IsInterface && !u.IsAbstract && typeof(ISpareTimeWorker).IsAssignableFrom(u))
.SelectMany(u => u.GetMethods(BindingFlags.Public | BindingFlags.Instance)
.Where(m => m.IsDefined(typeof(SpareTimeAttribute), false) &&
m.GetParameters().Length == 2 &&
m.GetParameters()[0].ParameterType == typeof(SpareTimer) &&
m.GetParameters()[1].ParameterType == typeof(long) && m.ReturnType == typeof(void))
.Select(m =>
{
// 默认获取第一条任务特性
var spareTimeAttribute = m.GetCustomAttribute<SpareTimeAttribute>();
return new TaskMethodInfo
{
JobName = spareTimeAttribute.WorkerName,
RequestUrl = $"{m.DeclaringType.Name}/{m.Name}",
Cron = spareTimeAttribute.CronExpression,
DoOnce = spareTimeAttribute.DoOnce,
ExecuteType = spareTimeAttribute.ExecuteType,
Interval = (int)spareTimeAttribute.Interval / 1000,
StartNow = spareTimeAttribute.StartNow,
RequestType = RequestTypeEnum.Run,
Remark = spareTimeAttribute.Description,
TimerType = string.IsNullOrEmpty(spareTimeAttribute.CronExpression) ? SpareTimeTypes.Interval : SpareTimeTypes.Cron,
MethodName = m.Name,
DeclaringType = m.DeclaringType
};
}));
await _cache.SetAsync(CommonConst.CACHE_KEY_TIMER_JOB, taskMethods);
return taskMethods;
}
}
}