/// <summary>
/// Job新增
/// </summary>
/// <param name="backgroundJobInfo">BackgroundJobInfo实体</param>
/// <returns></returns>
public bool InsertBackgroundJob(BackgroundJobInfo backgroundJobInfo)
{
backgroundJobInfo.CreatedDateTime = DateTime.Now;
backgroundJobInfo.LastUpdatedDateTime = DateTime.Now;
return(db.Insertable(backgroundJobInfo).ExecuteCommand() > 0);
}
public Task InsertAsync(BackgroundJobInfo jobInfo)
{
jobInfo.Id = Interlocked.Increment(ref _lastId);
_jobs.Add(jobInfo);
return Task.FromResult(0);
}
/// <summary>
/// Job删除
/// </summary>
/// <param name="idList">ID集合</param>
/// <returns></returns>
public bool DeleteBackgroundJob(List <System.Guid> idList, out string rtMsg)
{
bool result = false;
rtMsg = string.Empty;
int i = 0;
if (idList != null && idList.Count > 0)
{
foreach (System.Guid BackgroundJobId in idList)
{
BackgroundJobInfo backgroundJobInfo = GetBackgroundJobInfo(BackgroundJobId);
if (backgroundJobInfo.State != 0)
{
rtMsg = string.Format("{0}状态不为 停止状态,无法进行删除！", backgroundJobInfo.Name);
return(false);
}
}
foreach (System.Guid BackgroundJobId in idList)
{
DeleteBackgroundJob(BackgroundJobId);
i++;
}
}
result = i > 0;
return(result);
}
protected override async Task <Guid> EnqueueAsync(string jobName, object args, BackgroundJobPriority priority = BackgroundJobPriority.Normal, TimeSpan?delay = null)
{
var id = GuidGenerator.Create();
if (args is BackgroundJobArgs)
{
(args as BackgroundJobArgs).Id = id;
}
var jobInfo = new BackgroundJobInfo
{
Id = id,
JobName = jobName,
JobArgs = Serializer.Serialize(args),
Priority = priority,
CreationTime = Clock.Now,
NextTryTime = Clock.Now
};
if (delay.HasValue)
{
jobInfo.NextTryTime = Clock.Now.Add(delay.Value);
}
await Store.InsertAsync(jobInfo);
return(jobInfo.Id);
}
/// <summary>
/// Job调度
/// </summary>
/// <param name="scheduler"></param>
/// <param name="jobInfo"></param>
public void ScheduleJob(IScheduler scheduler, BackgroundJobInfo jobInfo)
{
if (ValidExpression(jobInfo.CronExpression))
{
Type type = GetClassInfo(jobInfo.AssemblyName, jobInfo.ClassName);
if (type != null)
{
IJobDetail job = new JobDetailImpl(jobInfo.BackgroundJobId.ToString(), jobInfo.BackgroundJobId.ToString() + "Group", type);
job.JobDataMap.Add("Parameters", jobInfo.JobArgs);
job.JobDataMap.Add("JobName", jobInfo.Name);
CronTriggerImpl trigger = new CronTriggerImpl();
trigger.CronExpressionString = jobInfo.CronExpression;
trigger.Name = jobInfo.BackgroundJobId.ToString();
trigger.Description = jobInfo.Description;
trigger.StartTimeUtc = DateTime.UtcNow;
trigger.Group = jobInfo.BackgroundJobId + "TriggerGroup";
scheduler.ScheduleJob(job, trigger);
}
else
{
new BackgroundJobService().WriteBackgroundJoLog(jobInfo.BackgroundJobId, jobInfo.Name, DateTime.Now, jobInfo.AssemblyName + jobInfo.ClassName + "无效，无法启动该任务");
}
}
else
{
new BackgroundJobService().WriteBackgroundJoLog(jobInfo.BackgroundJobId, jobInfo.Name, DateTime.Now, jobInfo.CronExpression + "不是正确的Cron表达式,无法启动该任务");
}
}
public async Task UpdateAsync(BackgroundJobInfo jobInfo)
{
var appEnv = Environment.MachineName + "_" + _configuration.AppName;
var entity = jobInfo.ToJob();
entity.AppEnv = appEnv;
await _backJobRepository.UpdateAsync(entity);
}
public ActionResult UpdatePost(BackgroundJobInfo Info)
{
var result = new ResponseResult();
BackgroundJobService _BackgroundJobService = new BackgroundJobService();
result.success = _BackgroundJobService.UpdateBackgroundJob(Info);
return(Json(result));
}
/// <summary>
/// Job修改
/// </summary>
/// <param name="backgroundJobInfo">BackgroundJobInfo实体</param>
/// <returns></returns>
public bool UpdateBackgroundJob(BackgroundJobInfo backgroundJobInfo)
{
System.Guid BackgroundJobId = backgroundJobInfo.BackgroundJobId;
backgroundJobInfo.LastUpdatedDateTime = DateTime.Now;
db.Updateable(backgroundJobInfo).IgnoreColumns(it => new { it.LastRunTime, it.NextRunTime, it.RunCount, it.CreatedByUserId, it.CreatedByUserName, it.CreatedDateTime, it.IsDelete }).Where(it => it.BackgroundJobId == BackgroundJobId).ExecuteCommand();
return(true);
}
public async Task DeleteAsync(BackgroundJobInfo jobInfo)
{
if (jobInfo == null)
{
return;
}
var appEnv = Environment.MachineName + "_" + _configuration.AppName;
await _backJobRepository.DeleteAsync(x => x.Id == jobInfo.Id && x.AppEnv == appEnv);
}
public virtual Task UpdateAsync(BackgroundJobInfo jobInfo)
{
if (jobInfo.IsAbandoned)
{
return(DeleteAsync(jobInfo.Id));
}
return(Task.CompletedTask);
}
public virtual Task UpdateAsync(BackgroundJobInfo jobInfo)
{
if (jobInfo.IsAbandoned)
{
return(DeleteAsync(jobInfo.Id));
}
return(Task.FromResult(0));
}
/// <summary>
/// 更新Job状态
/// </summary>
/// <param name="BackgroundJobId">Job ID</param>
/// <param name="State">状态</param>
/// <returns></returns>
public bool UpdateBackgroundJobState(System.Guid BackgroundJobId, int State)
{
BackgroundJobInfo backgroundJobInfo = new BackgroundJobInfo();
backgroundJobInfo.BackgroundJobId = BackgroundJobId;
backgroundJobInfo.State = State;
db.Updateable(backgroundJobInfo).UpdateColumns(it => new { it.State }).Where(it => it.BackgroundJobId == BackgroundJobId).ExecuteCommand();
return(true);
}
/// <summary>
/// 更新工作-异步
/// </summary>
/// <param name="jobInfo">后台工作信息</param>
/// <returns></returns>
public Task UpdateAsync(BackgroundJobInfo jobInfo)
{
if (jobInfo.IsAbandoned)
{
return DeleteAsync(jobInfo);
}
return Task.FromResult(0);
}
public ActionResult AddPost(BackgroundJobInfo Info)
{
var result = new ResponseResult();
BackgroundJobService _BackgroundJobService = new BackgroundJobService();
Info.BackgroundJobId = System.Guid.NewGuid();
result.success = _BackgroundJobService.InsertBackgroundJob(Info);
return(Json(result));
}
/// <summary>
/// Job删除
/// </summary>
/// <param name="BackgroundJobId">Job ID</param>
/// <returns></returns>
public bool DeleteBackgroundJob(System.Guid BackgroundJobId)
{
BackgroundJobInfo backgroundJobInfo = new BackgroundJobInfo();
backgroundJobInfo.BackgroundJobId = BackgroundJobId;
backgroundJobInfo.IsDelete = 1;
backgroundJobInfo.LastUpdatedDateTime = DateTime.Now;
db.Updateable(backgroundJobInfo).UpdateColumns(it => new { it.IsDelete, it.LastUpdatedDateTime }).Where(it => it.BackgroundJobId == BackgroundJobId).ExecuteCommand();
return(true);
}
public async Task InsertAsync(BackgroundJobInfo jobInfo)
{
var appEnv = Environment.MachineName + "_" + _configuration.AppName;
var entity = jobInfo.ToJob();
entity.AppEnv = appEnv;
var id = await _backJobRepository.InsertAndGetIdAsync(entity);
jobInfo.Id = id;
}
/// <summary>
/// 删除工作-异步
/// </summary>
/// <param name="jobInfo">后台工作信息</param>
/// <returns></returns>
public Task DeleteAsync(BackgroundJobInfo jobInfo)
{
if (!_jobs.ContainsKey(jobInfo.Id))
{
return Task.FromResult(0);
}
_jobs.Remove(jobInfo.Id);
return Task.FromResult(0);
}
private async Task TryUpdateAsync(BackgroundJobInfo jobInfo)
{
try
{
await _store.UpdateAsync(jobInfo);
}
catch (Exception updateEx)
{
Logger.Warn(updateEx.ToString(), updateEx);
}
}
protected virtual async Task TryUpdateAsync(IBackgroundJobStore store, BackgroundJobInfo jobInfo)
{
try
{
await store.UpdateAsync(jobInfo);
}
catch (Exception updateEx)
{
Logger.LogException(updateEx);
}
}
public virtual async Task UpdateAsync(BackgroundJobInfo jobInfo)
{
var backgroundJobRecord = await BackgroundJobRepository.FindAsync(jobInfo.Id);
if (backgroundJobRecord == null)
{
return;
}
ObjectMapper.Map(jobInfo, backgroundJobRecord);
await BackgroundJobRepository.UpdateAsync(backgroundJobRecord);
}
public async Task Test_All()
{
var jobInfo = new BackgroundJobInfo
{
JobType = "TestType",
JobArgs = "{}"
};
await _store.InsertAsync(jobInfo);
(await _store.GetWaitingJobsAsync(1000)).Count.ShouldBe(1);
await _store.DeleteAsync(jobInfo);
(await _store.GetWaitingJobsAsync(1000)).Count.ShouldBe(0);
}
public async Task Test_All()
{
var jobInfo = new BackgroundJobInfo
{
JobType = "TestType",
JobArgs = "{}"
};
await _store.InsertAsync(jobInfo);
(await _store.GetWaitingJobsAsync(1000)).Count.ShouldBe(1);
await _store.DeleteAsync(jobInfo);
(await _store.GetWaitingJobsAsync(1000)).Count.ShouldBe(0);
}
protected virtual DateTime?CalculateNextTryTime(BackgroundJobInfo jobInfo, IClock clock)
{
var nextWaitDuration = WorkerOptions.DefaultFirstWaitDuration *
(Math.Pow(WorkerOptions.DefaultWaitFactor, jobInfo.TryCount - 1));
var nextTryDate = jobInfo.LastTryTime?.AddSeconds(nextWaitDuration) ??
clock.Now.AddSeconds(nextWaitDuration);
if (nextTryDate.Subtract(jobInfo.CreationTime).TotalSeconds > WorkerOptions.DefaultTimeout)
{
return(null);
}
return(nextTryDate);
}
/// <summary>
/// 更新Job状态
/// </summary>
/// <param name="backgroundJobId">Job ID</param>
/// <param name="state">状态：0停止，1运行，3正在启动中，5停止中</param>
/// <returns></returns>
public bool UpdateBackgroundJobState(Guid backgroundJobId, int state)
{
var backgroundJobInfo = new BackgroundJobInfo()
{
BackgroundJobId = backgroundJobId,
State = state
};
db.Updateable(backgroundJobInfo)
.UpdateColumns(it => new { it.State })
.Where(it => it.BackgroundJobId == backgroundJobId)
.ExecuteCommand();
return(true);
}
public static BackJob ToJob(this BackgroundJobInfo info)
{
return(new BackJob
{
CreationTime = info.CreationTime,
CreatorUserId = info.CreatorUserId,
Id = info.Id,
IsAbandoned = info.IsAbandoned,
JobArgs = info.JobArgs,
JobType = info.JobType,
LastTryTime = info.LastTryTime,
NextTryTime = info.NextTryTime,
Priority = info.Priority,
TryCount = info.TryCount,
});
}
public async Task InsertAsync()
{
var jobInfo = new BackgroundJobInfo
{
Id = Guid.NewGuid(),
JobArgs = "args1",
JobName = "name1"
};
await _backgroundJobStore.InsertAsync(
jobInfo
);
var jobInfo2 = await _backgroundJobStore.FindAsync(jobInfo.Id);
jobInfo2.ShouldNotBeNull();
jobInfo2.Id.ShouldBe(jobInfo.Id);
jobInfo2.JobArgs.ShouldBe(jobInfo.JobArgs);
jobInfo2.JobName.ShouldBe(jobInfo.JobName);
}
public static string Serialize(BackgroundJobInfo info)
{
MySurrogate mySurrogate = new MySurrogate();
DataContractSerializer dataContractSerializer =
new DataContractSerializer(
typeof(BackgroundJobInfo),
null,
64 * 1024,
true,
true,
mySurrogate);
var stringBuilder = new StringBuilder();
using (var stringWriter = new StringWriter(stringBuilder, CultureInfo.InvariantCulture))
{
var writer = new XmlTextWriter(stringWriter);
dataContractSerializer.WriteObject(writer, info);
}
return(stringBuilder.ToString());
}
public virtual string Enqueue <TJob, TArgs>(TArgs args,
BackgroundJobPriority priority = BackgroundJobPriority.Normal, TimeSpan?delay = null)
where TJob : IBackgroundJobBase <TArgs>
{
var jobInfo = new BackgroundJobInfo
{
JobType = typeof(TJob).AssemblyQualifiedName,
JobArgs = args.ToJsonString(),
Priority = priority
};
if (delay.HasValue)
{
jobInfo.NextTryTime = Clock.Now.Add(delay.Value);
}
_store.Insert(jobInfo);
CurrentUnitOfWork.SaveChanges();
return(jobInfo.Id.ToString());
}
public async Task Test_All()
{
var jobInfo = new BackgroundJobInfo
{
JobType = "TestType",
JobArgs = "{}"
};
await _store.InsertAsync(jobInfo);
(await _store.GetWaitingJobsAsync(1000)).Count.ShouldBe(1);
var jobInfoFromStore = await _store.GetAsync(1);
jobInfoFromStore.ShouldNotBeNull();
jobInfoFromStore.JobType.ShouldBeSameAs(jobInfo.JobType);
jobInfoFromStore.JobArgs.ShouldBeSameAs(jobInfo.JobArgs);
await _store.DeleteAsync(jobInfo);
(await _store.GetWaitingJobsAsync(1000)).Count.ShouldBe(0);
}
public async Task Test_All()
{
var jobInfo = new BackgroundJobInfo
{
JobType = "TestType",
JobArgs = "{}",
NextTryTime = Clock.Now.AddMinutes(-1) // to be sure NextTryTime will not be same when _store.InsertAsync and _store.GetWaitingJobsAsync are executed.
};
await _store.InsertAsync(jobInfo);
(await _store.GetWaitingJobsAsync(1000)).Count.ShouldBe(1);
var jobInfoFromStore = await _store.GetAsync(1);
jobInfoFromStore.ShouldNotBeNull();
jobInfoFromStore.JobType.ShouldBeSameAs(jobInfo.JobType);
jobInfoFromStore.JobArgs.ShouldBeSameAs(jobInfo.JobArgs);
await _store.DeleteAsync(jobInfo);
(await _store.GetWaitingJobsAsync(1000)).Count.ShouldBe(0);
}
public Task UpdateAsync(BackgroundJobInfo jobInfo)
{
return(_unitOfWorkManager.PerformAsyncUow <Task>(() => _backgroundJobRepository.UpdateAsync(jobInfo)));
}
public Task InsertAsync(BackgroundJobInfo jobInfo)
{
return _backgroundJobRepository.InsertAsync(jobInfo);
}
public Task DeleteAsync(BackgroundJobInfo jobInfo)
{
return _backgroundJobRepository.DeleteAsync(jobInfo);
}
public Task UpdateAsync(BackgroundJobInfo jobInfo)
{
return _backgroundJobRepository.UpdateAsync(jobInfo);
}
public Task InsertAsync(BackgroundJobInfo jobInfo)
{
return Task.FromResult(0);
}
/// <summary>
/// Job修改
/// </summary>
/// <param name="backgroundJobInfo">BackgroundJobInfo实体</param>
/// <returns></returns>
public bool UpdateBackgroundJob(BackgroundJobInfo backgroundJobInfo)
{
return(new BackgroundJobManager().UpdateBackgroundJob(backgroundJobInfo));
}
/// <summary>
/// Job新增
/// </summary>
/// <param name="backgroundJobInfo">BackgroundJobInfo实体</param>
/// <returns></returns>
public bool InsertBackgroundJob(BackgroundJobInfo backgroundJobInfo)
{
return(new BackgroundJobManager().InsertBackgroundJob(backgroundJobInfo));
}
public Task DeleteAsync(BackgroundJobInfo jobInfo)
{
_jobs.Remove(jobInfo);
return Task.FromResult(0);
}
public Task UpdateAsync(BackgroundJobInfo jobInfo)
{
return Task.FromResult(0);
}
private async Task TryProcessJobAsync(BackgroundJobInfo jobInfo)
{
try
{
jobInfo.TryCount++;
jobInfo.LastTryTime = Clock.Now;
var jobType = Type.GetType(jobInfo.JobType);
using (var job = _iocResolver.ResolveAsDisposable(jobType))
{
try
{
var jobExecuteMethod = job.Object.GetType().GetTypeInfo()
.GetMethod(nameof(IBackgroundJob <object> .Execute)) ??
job.Object.GetType().GetTypeInfo()
.GetMethod(nameof(IAsyncBackgroundJob <object> .ExecuteAsync));
if (jobExecuteMethod == null)
{
throw new AbpException(
$"Given job type does not implement {typeof(IBackgroundJob<>).Name} or {typeof(IAsyncBackgroundJob<>).Name}. " +
"The job type was: " + job.Object.GetType());
}
var argsType = jobExecuteMethod.GetParameters()[0].ParameterType;
var argsObj = JsonConvert.DeserializeObject(jobInfo.JobArgs, argsType);
if (jobExecuteMethod.Name == nameof(IAsyncBackgroundJob <object> .ExecuteAsync))
{
Task result = (Task)jobExecuteMethod.Invoke(job.Object, new[] { argsObj });
await result;
}
else
{
jobExecuteMethod.Invoke(job.Object, new[] { argsObj });
}
await _store.DeleteAsync(jobInfo);
}
catch (Exception ex)
{
Logger.Warn(ex.Message, ex);
var nextTryTime = jobInfo.CalculateNextTryTime();
if (nextTryTime.HasValue)
{
jobInfo.NextTryTime = nextTryTime.Value;
}
else
{
jobInfo.IsAbandoned = true;
}
await TryUpdateAsync(jobInfo);
await EventBus.TriggerAsync(
this,
new AbpHandledExceptionData(
new BackgroundJobException(
"A background job execution is failed. See inner exception for details. See BackgroundJob property to get information on the background job.",
ex
)
{
BackgroundJob = jobInfo,
JobObject = job.Object
}
)
);
}
}
}
catch (Exception ex)
{
Logger.Warn(ex.ToString(), ex);
jobInfo.IsAbandoned = true;
await TryUpdateAsync(jobInfo);
}
}
