public async Task AddRecurrentJob(JobDb job)
{
var collection = _mongoClientProvider.GetCollection <JobMongoModel>();
var update = Builders <JobMongoModel> .Update
.Set(x => x.Cron, job.Cron)
.Set(x => x.StartAt, job.StartAt);
var needsProperties =
_jobDbProperties.Where(x => x.Name != nameof(JobMongoModel.Cron) &&
x.Name != nameof(JobMongoModel.StartAt));
//Если джоб уже существет апдейтем только 2 поля
//Если нужно создать, то устанавливаем все остальные поля
foreach (var jobDbProperty in needsProperties)
{
update = update.SetOnInsert(jobDbProperty.Name, jobDbProperty.GetValue(job));
}
await IMongoCollectionExtensions.UpdateOneAsync(collection, x => x.JobKey == job.JobKey &&
(x.Status == JobStatus.Executing || x.Status == JobStatus.Ready),
update,
new UpdateOptions
{
IsUpsert = true
});
}
public void CreateJobMongoModel_AllFieldsSuccessMap()
{
var jobDb = new JobDb
{
JobType = "Horarium.TestJob, Horarium",
JobParamType = "System.Int32, System.Private.CoreLib",
JobParam = "437",
Status = JobStatus.Ready,
CountStarted = 0,
NextJob = null,
Cron = "* * * * * *",
Delay = TimeSpan.FromSeconds(5)
};
var jobMongoModel = JobMongoModel.CreateJobMongoModel(jobDb);
Assert.Equal("Horarium.TestJob, Horarium", jobMongoModel.JobType);
Assert.Equal("System.Int32, System.Private.CoreLib", jobMongoModel.JobParamType);
Assert.Equal("437", jobMongoModel.JobParam);
Assert.Equal(JobStatus.Ready, jobMongoModel.Status);
Assert.Equal(0, jobMongoModel.CountStarted);
Assert.Null(jobMongoModel.NextJob);
Assert.Equal("* * * * * *", jobMongoModel.Cron);
Assert.Equal(TimeSpan.FromSeconds(5), jobMongoModel.Delay);
}
public void Add(JobDb job)
{
if (job.Status != JobStatus.RepeatJob)
{
return;
}
_startAtIndex.Add(job);
}
public void Add(JobDb job)
{
if (job.Status != JobStatus.Failed)
{
return;
}
_index.Add(job.JobId, job);
}
// GET: Profiles/Create
public ActionResult Create()
{
ProfileMoviesJobsViewModel model = new ProfileMoviesJobsViewModel
{
AllMovies = MovieDb.GetAllMovies(db),
AllJobs = JobDb.GetAllJobs(db)
};
return(View(model));
}
public void Add(JobDb job)
{
if (job.Status != JobStatus.Executing)
{
return;
}
_startedExecutingIndex.Add(job);
_jobKeyIndex.Add(job);
}
public void Add(JobDb job)
{
if (job.Status != JobStatus.Ready)
{
return;
}
_startAtIndex.Add(job);
_jobKeyIndex.Add(job);
}
public async Task <JobDb> RemoveJob(JobDb job)
{
var jobToRemove = await _context.Jobs.FirstAsync(u => u.Id == job.Id);
_context.Jobs.Attach(jobToRemove);
_context.Remove(jobToRemove);
await _context.SaveChangesAsync();
return(job);
}
public static async Task <bool> Schedule(Expression <Action> action, DateTime scheduledTime, string name)
{
var job = new JobDb {
Name = name,
};
job.Action = ExpressionHelper.ToString(action);
job.StateUpdates.Add(new StateUpdate(JobState.SCHEDULED, ""));
await _jobContext.GetCollection().InsertOneAsync(job);
return(true);
}
public void Remove(JobDb job)
{
if (string.IsNullOrEmpty(job.JobKey))
{
return;
}
if (!_index.TryGetValue(job.JobKey, out var set))
{
return;
}
set.Remove(job);
}
public void ToJob()
{
var job = new JobDb
{
JobType = _strJobType,
JobParamType = _strJobParamType,
JobParam = _strJobParam
};
var jobDb = job.ToJob(new JsonSerializerSettings());
Assert.Equal(typeof(TestJob), jobDb.JobType);
Assert.Equal("test", jobDb.JobParam);
}
public Task AddRecurrentJob(JobDb job)
{
return(_processor.Execute(() =>
{
var foundJob = _storage.FindRecurrentJobToUpdate(job.JobKey) ?? job.Copy();
_storage.Remove(foundJob);
foundJob.Cron = job.Cron;
foundJob.StartAt = job.StartAt;
_storage.Add(foundJob);
}));
}
public void ToJobDb()
{
var job = new JobMetadata()
{
JobType = typeof(TestJob),
JobParam = "test"
};
var jobDb = JobDb.CreatedJobDb(job, new JsonSerializerSettings());
Assert.Equal(jobDb.JobType, _strJobType);
Assert.Equal(jobDb.JobParamType, _strJobParamType);
Assert.Equal(jobDb.JobParam, _strJobParam);
}
public async Task <JobDb> AddJob(JobDb job)
{
job.Id = 0;
var newJob = new JobDb {
Id = 0,
Name = job.Name,
UserId = job.UserId,
ClientId = job.ClientId,
HoursReported = job.HoursReported
};
await _context.Jobs.AddAsync(newJob);
await _context.SaveChangesAsync();
return(job);
}
public override async Task <bool> DoWork()
{
JobDb job = null;
while (_cancelToken.IsCancellationRequested == false)
{
long processScore = (DateTime.UtcNow - TimeSpan.FromSeconds(60)).Ticks;
var filter = Builders <JobDb> .Filter.Eq(_ => _.State, JobState.PROCESSING) &
Builders <JobDb> .Filter.Eq(_ => _.IsLocked, true) &
Builders <JobDb> .Filter.Lte(_ => _.ProcessScore, processScore);
var updateDefinition = Builders <JobDb> .Update.Set(_ => _.IsLocked, false)
.Set(_ => _.LastFetchedTime, processScore).Set(_ => _.State, JobState.FAILED)
.AddToSet(_ => _.StateUpdates, new StateUpdate(JobState.PROCESSING));
try
{
job = await _jobContext.GetCollection().FindOneAndUpdateAsync(filter, updateDefinition);
if (job == null)
{
await Task.Delay(1000);
continue;
}
_logger.LogError($"Job({job.Id}) timed out and failed");
}
catch (Exception e)
{
if (job != null)
{
await _jobContext.GetCollection().UpdateOneAsync(Builders <JobDb> .Filter.Eq(_ => _.Id, job.Id),
Builders <JobDb> .Update.Set(_ => _.IsLocked, false)
.Set(_ => _.State, JobState.FAILED)
.AddToSet(_ => _.StateUpdates, new StateUpdate(JobState.FAILED, e.Message)));
}
_logger.LogError(e.Message);
}
await Task.Delay(_timeBetweenJobs);
}
return(true);
}
private async Task ExecuteJob(JobMetadata jobMetadata)
{
dynamic jobImplementation = null;
try
{
using (var scope = _settings.JobScopeFactory.Create())
{
try
{
jobImplementation = scope.CreateJob(jobMetadata.JobType);
}
catch (Exception ex)
{
//Дополнительное логирование ошибки, когда джоб не может быть создан
_settings.Logger.Error($"Ошибка создания джоба {jobMetadata.JobType}", ex);
throw;
}
_settings.Logger.Debug("got jobImplementation -" + jobImplementation.GetType());
_settings.Logger.Debug("got JobParam -" + jobMetadata.JobParam.GetType());
await jobImplementation.Execute((dynamic)jobMetadata.JobParam);
_settings.Logger.Debug("jobMetadata excecuted");
if (jobMetadata.NextJob != null)
{
jobMetadata.NextJob.StartAt = DateTime.UtcNow + jobMetadata.NextJob.Delay.GetValueOrDefault();
await _jobRepository.AddJob(JobDb.CreatedJobDb(jobMetadata.NextJob,
_settings.JsonSerializerSettings));
_settings.Logger.Debug("next jobMetadata added");
}
await _jobRepository.RemoveJob(jobMetadata.JobId);
_settings.Logger.Debug("jobMetadata saved success");
}
}
catch (Exception ex)
{
await HandleFailed(jobMetadata, ex, jobImplementation);
}
}
public void Add(JobDb job)
{
if (string.IsNullOrEmpty(job.JobKey))
{
return;
}
if (!_index.TryGetValue(job.JobKey, out var set))
{
_index[job.JobKey] = new SortedSet <JobDb>(new JobIdComparer())
{
job
}
}
;
else
{
set.Add(job);
}
}
// GET: Profiles/Edit/5
public ActionResult Edit(int?id)
{
if (!id.HasValue)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Profile profile = ProfileDb.FindProfile(db, id.Value);
if (profile == null)
{
return(HttpNotFound());
}
ProfileMoviesJobsViewModel model = new ProfileMoviesJobsViewModel
{
Profile = profile,
AllMovies = MovieDb.GetAllMovies(db),
AllJobs = JobDb.GetAllJobs(db)
};
return(View(model));
}
public static JobMongoModel CreateJobMongoModel(JobDb jobDb)
{
return(new JobMongoModel
{
JobId = jobDb.JobId,
JobKey = jobDb.JobKey,
Status = jobDb.Status,
CountStarted = jobDb.CountStarted,
StartedExecuting = jobDb.StartedExecuting,
ExecutedMachine = jobDb.ExecutedMachine,
JobType = jobDb.JobType,
JobParam = jobDb.JobParam,
JobParamType = jobDb.JobParamType,
StartAt = jobDb.StartAt,
NextJob = jobDb.NextJob != null?CreateJobMongoModel(jobDb.NextJob) : null,
Cron = jobDb.Cron,
Delay = jobDb.Delay,
ObsoleteInterval = jobDb.ObsoleteInterval,
RepeatStrategy = jobDb.RepeatStrategy,
MaxRepeatCount = jobDb.MaxRepeatCount
});
}
public static JobDb Copy(this JobDb source)
{
return(new JobDb
{
JobKey = source.JobKey,
JobId = source.JobId,
Status = source.Status,
JobType = source.JobType,
JobParamType = source.JobParamType,
JobParam = source.JobParam,
CountStarted = source.CountStarted,
StartedExecuting = source.StartedExecuting,
ExecutedMachine = source.ExecutedMachine,
StartAt = source.StartAt,
NextJob = source.NextJob?.Copy(),
Cron = source.Cron,
Delay = source.Delay,
ObsoleteInterval = source.ObsoleteInterval,
RepeatStrategy = source.RepeatStrategy,
MaxRepeatCount = source.MaxRepeatCount
});
}
public void Remove(JobDb job)
{
_startAtIndex.Remove(job);
_jobKeyIndex.Remove(job);
}
public async Task AddJob(JobDb job)
{
var collection = _mongoClientProvider.GetCollection <JobMongoModel>();
await collection.InsertOneAsync(JobMongoModel.CreateJobMongoModel(job));
}
public void Remove(JobDb job)
{
_startedExecutingIndex.Remove(job);
_jobKeyIndex.Remove(job);
}
public void Remove(JobDb job)
{
_jobs.Remove(job.JobId);
_indexes.ForEach(x => x.Remove(job));
}
public static int Compare(JobDb x, JobDb y)
{
return(string.Compare(x.JobId, y.JobId, StringComparison.Ordinal));
}
public async Task AddRecurrentJob(JobMetadata jobMetadata)
{
await _recurrentJobSettingsAdder.Add(jobMetadata.Cron, jobMetadata.JobType, jobMetadata.JobKey);
await _jobRepository.AddRecurrentJob(JobDb.CreatedJobDb(jobMetadata, _jsonSerializerSettings));
}
public Task AddEnqueueJob(JobMetadata jobMetadata)
{
var job = JobDb.CreatedJobDb(jobMetadata, _jsonSerializerSettings);
return(_jobRepository.AddJob(job));
}
public Task AddJob(JobDb job)
{
return(_processor.Execute(() => _storage.Add(job.Copy())));
}
public void Add(JobDb job)
{
_jobs.Add(job.JobId, job);
_indexes.ForEach(x => x.Add(job));
}
public void Remove(JobDb job)
{
_index.Remove(job.JobId);
}