public void Update(BackgroundJobInfo jobInfo)
{
if (jobInfo.IsAbandoned)
{
Delete(jobInfo);
}
}
public void Delete(BackgroundJobInfo jobInfo)
{
_unitOfWorkManager.WithUnitOfWork(() =>
{
_backgroundJobRepository.Delete(jobInfo);
});
}
public virtual string Enqueue <TJob, TArgs>(TArgs args,
BackgroundJobPriority priority = BackgroundJobPriority.Normal, TimeSpan?delay = null)
where TJob : IBackgroundJobBase <TArgs>
{
string jobInfoId;
using (var uow = UnitOfWorkManager.Begin())
{
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();
jobInfoId = jobInfo.Id.ToString();
uow.Complete();
}
return(jobInfoId);
}
public void Insert(BackgroundJobInfo jobInfo)
{
_unitOfWorkManager.WithUnitOfWork(() =>
{
_backgroundJobRepository.Insert(jobInfo);
});
}
public Task InsertAsync(BackgroundJobInfo jobInfo)
{
jobInfo.Id = Interlocked.Increment(ref _lastId);
_jobs.Add(jobInfo);
return(Task.FromResult(0));
}
private void TryProcessJob(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().GetMethod("Execute");
var argsType = jobExecuteMethod.GetParameters()[0].ParameterType;
var argsObj = JsonConvert.DeserializeObject(jobInfo.JobArgs, argsType);
jobExecuteMethod.Invoke(job.Object, new[] { argsObj });
AsyncHelper.RunSync(() => _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;
}
TryUpdate(jobInfo);
EventBus.Trigger(
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
}
)
);
}
}
}
catch (Exception ex)
{
Logger.Warn(ex.ToString(), ex);
jobInfo.IsAbandoned = true;
TryUpdate(jobInfo);
}
}
public Task DeleteAsync(BackgroundJobInfo jobInfo)
{
BackgroundJobInfo _;
_jobs.TryRemove(jobInfo.Id, out _);
return(Task.FromResult(0));
}
public Task UpdateAsync(BackgroundJobInfo jobInfo)
{
if (jobInfo.IsAbandoned)
{
return(DeleteAsync(jobInfo));
}
return(Task.FromResult(0));
}
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);
}
}
private void TryUpdate(BackgroundJobInfo jobInfo)
{
try
{
_store.UpdateAsync(jobInfo);
}
catch (Exception updateEx)
{
Logger.Warn(updateEx.ToString(), updateEx);
}
}
public bool Delete(string jobId)
{
if (long.TryParse(jobId, out long finalJobId) == false)
{
throw new ArgumentException($"The jobId '{jobId}' should be a number.", nameof(jobId));
}
BackgroundJobInfo jobInfo = _store.Get(finalJobId);
_store.Delete(jobInfo);
return(true);
}
public async Task <bool> DeleteAsync(string jobId)
{
if (long.TryParse(jobId, out long finalJobId) == false)
{
throw new ArgumentException($"The jobId '{jobId}' should be a number.", nameof(jobId));
}
BackgroundJobInfo jobInfo = await _store.GetAsync(finalJobId);
await _store.DeleteAsync(jobInfo);
return(true);
}
private void TryProcessJob(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().GetMethod("Execute");
var argsType = jobExecuteMethod.GetParameters()[0].ParameterType;
var argsObj = JsonConvert.DeserializeObject(jobInfo.JobArgs, argsType);
jobExecuteMethod.Invoke(job.Object, new[] { argsObj });
AsyncHelper.RunSync(() => _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;
}
TryUpdate(jobInfo);
}
}
}
catch (Exception ex)
{
Logger.Warn(ex.ToString(), ex);
jobInfo.IsAbandoned = true;
TryUpdate(jobInfo);
}
}
/// <summary>
/// 将工作插入到队列中
/// </summary>
/// <typeparam name="TJob"></typeparam>
/// <typeparam name="TArgs"></typeparam>
/// <param name="args"></param>
/// <param name="priority"></param>
/// <param name="delay"></param>
/// <returns></returns>
public async Task EnqueueAsync <TJob, TArgs>(TArgs args, BackgroundJobPriority priority = BackgroundJobPriority.Normal, TimeSpan?delay = null)
where TJob : IBackgroundJob <TArgs>
{
var jobInfo = new BackgroundJobInfo
{
JobType = typeof(TJob).AssemblyQualifiedName,
JobArgs = args.ToJsonString(),
Priority = priority
};
if (delay.HasValue)
{
jobInfo.NextTryTime = Clock.Now.Add(delay.Value);
}
await _store.InsertAsync(jobInfo);
}
public virtual async Task <string> EnqueueAsync <TJob, TArgs>(TArgs args, BackgroundJobPriority priority = BackgroundJobPriority.Normal, TimeSpan?delay = null)
where TJob : IBackgroundJob <TArgs>
{
var jobInfo = new BackgroundJobInfo
{
JobType = typeof(TJob).AssemblyQualifiedName,
JobArgs = args.ToJsonString(),
Priority = priority
};
if (delay.HasValue)
{
jobInfo.NextTryTime = Clock.Now.Add(delay.Value);
}
await _store.InsertAsync(jobInfo);
await CurrentUnitOfWork.SaveChangesAsync();
return(jobInfo.Id.ToString());
}
public Task DeleteAsync(BackgroundJobInfo jobInfo)
{
_jobs.Remove(jobInfo);
return(Task.FromResult(0));
}
public async Task DeleteAsync(BackgroundJobInfo jobInfo)
{
await _unitOfWorkManager.WithUnitOfWorkAsync(async() =>
await _backgroundJobRepository.DeleteAsync(jobInfo)
);
}
public void Insert(BackgroundJobInfo jobInfo)
{
_backgroundJobRepository.Insert(jobInfo);
}
public Task UpdateAsync(BackgroundJobInfo jobInfo)
{
return(_backgroundJobRepository.UpdateAsync(jobInfo));
}
public Task DeleteAsync(BackgroundJobInfo jobInfo)
{
return(_backgroundJobRepository.DeleteAsync(jobInfo));
}
public Task InsertAsync(BackgroundJobInfo jobInfo)
{
return(_backgroundJobRepository.InsertAsync(jobInfo));
}
public void Delete(BackgroundJobInfo jobInfo)
{
_backgroundJobRepository.Delete(jobInfo);
}
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))
{
await((Task)jobExecuteMethod.Invoke(job.Object, new[] { argsObj }));
}
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);
}
}
public void Update(BackgroundJobInfo jobInfo)
{
_backgroundJobRepository.Update(jobInfo);
}
public void Insert(BackgroundJobInfo jobInfo)
{
}
/// <summary>
/// 更新一个作业
/// </summary>
/// <param name="jobInfo">作业信息</param>
/// <returns></returns>
public Task UpdateAsync(BackgroundJobInfo jobInfo)
{
return(Task.FromResult(0));
}
/// <summary>
/// 异步插入一个后台作业
/// </summary>
/// <param name="jobInfo">作业信息</param>
/// <returns></returns>
public Task InsertAsync(BackgroundJobInfo jobInfo)
{
return(Task.FromResult(0));
}
public void Delete(BackgroundJobInfo jobInfo)
{
}
public void Update(BackgroundJobInfo jobInfo)
{
}
