public async Task RescheduleOnStart()
{
// Schedule = every 0.1 second
// Run for 1 second
// Execution takes 1.1 seconds
// Total runs should be 1
var count = 0;
int workerThreads, portThreads;
ThreadPool.GetMaxThreads(out workerThreads, out portThreads);
ThreadPool.SetMaxThreads(100, 100);
var runTimes = new List <DateTime>();
Action action = () => {
runTimes.Add(DateTime.Now);
count++;
Thread.Sleep(10000);
};
var job = JobBuilder.For(action).Repeat.OnInterval(DateTime.Now, TimeSpan.FromSeconds(1), ReschedulePolicy.OnStart).Build();
var scheduler = new Scheduler.Scheduler();
scheduler.AddJob(job);
scheduler.Start();
await Task.Delay(TimeSpan.FromSeconds(3.8));
scheduler.Stop();
ThreadPool.SetMaxThreads(workerThreads, portThreads);
Assert.AreEqual(3, count); // Starts straight away
}
/// <summary>
/// Updates the square rectangle of the media.
/// </summary>
public async Task UpdateThumbnailAsync(string key, RectVM vm)
{
Validate(vm, "thumbnail rectangle");
var media = await _db.Media
.Include(x => x.Tags)
.FirstOrDefaultAsync(x => x.Key == key);
if (media == null)
{
throw new OperationException($"Media '{key}' does not exist.");
}
var rect = _mapper.Map <Rect>(vm);
if (media.ThumbnailRect.Equals(rect))
{
return;
}
media.ThumbnailRect = rect;
await _db.SaveChangesAsync();
await _jobSvc.RunAsync(JobBuilder.For <UpdateThumbnailJob>().WithArgs(media.Key));
}
private void _job1Button_Click(object sender, EventArgs e)
{
var textWriter = new TextBoxWriter(textBox1);
var logger = new MulticastLogger(
new TextWriterLogger(textWriter),
new ConsoleLogger()
);
var job1 =
JobBuilder.For(() => logger.Info("Executed Job 1"))
.Called("Job1")
.RunOnce(DateTime.Now)
.RunAsyncronously()
.Repeat
.OnInterval(TimeSpan.FromSeconds(1))
.Build();
var job2 =
JobBuilder.For(() => logger.Info("Executed Job 2"))
.Called("Job2")
.RunOnce(DateTime.Now)
.RunAsyncronously()
.Repeat
.OnInterval(TimeSpan.FromSeconds(2))
.Build();
Sphere10.Framework.Scheduler.Scheduler.Global.JobStatusChanged +=
(job, fromStatus, toStatus) => textWriter.WriteLine("{0}: {1} -> {2}", job.Name, fromStatus, toStatus);
Sphere10.Framework.Scheduler.Scheduler.Global.AddJob(job1);
Sphere10.Framework.Scheduler.Scheduler.Global.AddJob(job2);
}
public SessionCache(TimeSpan sessionTimeoutInterval) : base(CacheReapPolicy.None, ExpirationPolicy.SinceLastAccessedTime, expirationDuration: sessionTimeoutInterval)
{
_cleaner = new Scheduler <IJob>(SchedulerPolicy.DisposeWhenFinished | SchedulerPolicy.RemoveJobOnError | SchedulerPolicy.DontThrow);
var job = JobBuilder.For(Cleanup).RunAsyncronously().RunOnce(DateTime.Now.Add(sessionTimeoutInterval)).Repeat.OnInterval(sessionTimeoutInterval).Build();
_cleaner.AddJob(job);
_cleaner.Start();
}
public async Task AwaitsCorrectly_Complex()
{
var count1 = 0;
var count2 = 0;
var count3 = 0;
var count4 = 0;
var count5 = 0;
var count6 = 0;
var count7 = 0;
var count8 = 0;
var count9 = 0;
Action action1 = () => count1++;
Action action2 = () => count2++;
Action action3 = () => count3++;
Action action4 = () => count4++;
Action action5 = () => count5++;
Action action6 = () => count6++;
Action action7 = () => count7++;
Action action8 = () => count8++;
Action action9 = () => count9++;
var job1 = JobBuilder.For(action1).Repeat.OnInterval(TimeSpan.FromSeconds(1)).Build();
var job2 = JobBuilder.For(action2).Repeat.OnInterval(TimeSpan.FromSeconds(2)).Build();
var job3 = JobBuilder.For(action3).Repeat.OnInterval(TimeSpan.FromSeconds(3)).Build();
var job4 = JobBuilder.For(action4).Repeat.OnInterval(TimeSpan.FromSeconds(4)).Build();
var job5 = JobBuilder.For(action5).Repeat.OnInterval(TimeSpan.FromSeconds(5)).Build();
var job6 = JobBuilder.For(action6).Repeat.OnInterval(TimeSpan.FromSeconds(6)).Build();
var job7 = JobBuilder.For(action7).Repeat.OnInterval(TimeSpan.FromSeconds(7)).Build();
var job8 = JobBuilder.For(action8).Repeat.OnInterval(TimeSpan.FromSeconds(8)).Build();
var job9 = JobBuilder.For(action9).Repeat.OnInterval(TimeSpan.FromSeconds(9)).Build();
var scheduler = new Scheduler.Scheduler();
scheduler.AddJob(job1);
scheduler.AddJob(job2);
scheduler.AddJob(job3);
scheduler.AddJob(job4);
scheduler.AddJob(job5);
scheduler.AddJob(job6);
scheduler.AddJob(job7);
scheduler.AddJob(job8);
scheduler.AddJob(job9);
scheduler.Start();
var secondsToTest = 20;
await Task.Delay(TimeSpan.FromSeconds(secondsToTest).Add(TimeSpan.FromMilliseconds(800)));
scheduler.Stop();
Assert.AreEqual(secondsToTest / 1, count1);
Assert.AreEqual(secondsToTest / 2, count2);
Assert.AreEqual(secondsToTest / 3, count3);
Assert.AreEqual(secondsToTest / 4, count4);
Assert.AreEqual(secondsToTest / 5, count5);
Assert.AreEqual(secondsToTest / 6, count6);
Assert.AreEqual(secondsToTest / 7, count7);
Assert.AreEqual(secondsToTest / 8, count8);
Assert.AreEqual(secondsToTest / 9, count9);
}
public async Task AwaitsCorrectly_Simple()
{
var count = 0;
Action action = () => count++;
var job = JobBuilder.For(action).Repeat.OnInterval(DateTime.Now, TimeSpan.FromSeconds(1)).Build();
var scheduler = new Scheduler.Scheduler();
scheduler.AddJob(job);
scheduler.Start();
await Task.Delay(TimeSpan.FromSeconds(5.8));
scheduler.Stop();
Assert.AreEqual(1 + 5, count); // Starts straight away
}
public async Task RepeatWithoutStartTime()
{
var count = 0;
Action action = () => count++;
var job = JobBuilder.For(action).Repeat.OnInterval(TimeSpan.FromSeconds(1)).Build();
var scheduler = new Scheduler.Scheduler();
scheduler.AddJob(job);
scheduler.Start();
await Task.Delay(TimeSpan.FromSeconds(1.1));
scheduler.Stop();
Assert.AreEqual(1, count); // does not start straight away
}
public async Task StartOn_UtcTime()
{
var count = 0;
Action action = () => count++;
var job = JobBuilder.For(action).RunOnce(DateTime.UtcNow.Add(TimeSpan.FromSeconds(1))).Build();
var scheduler = new Scheduler.Scheduler();
scheduler.AddJob(job);
scheduler.Start();
await Task.Delay(TimeSpan.FromSeconds(1.1));
scheduler.Stop();
Assert.AreEqual(1, count);
}
/// <summary>
/// Moves the folder to be a child of another folder.
/// </summary>
public async Task MoveAsync(string folderKey, string targetKey)
{
var folder = await _db.Folders.AsNoTracking().FirstOrDefaultAsync(x => x.Key == folderKey);
if (folder == null)
{
throw new OperationException($"Folder '{folderKey}' does not exist.");
}
var target = string.IsNullOrEmpty(targetKey)
? await _db.Folders.AsNoTracking().FirstOrDefaultAsync(x => x.Depth == 0)
: await _db.Folders.AsNoTracking().FirstOrDefaultAsync(x => x.Key == targetKey);
if (target == null)
{
throw new OperationException($"Folder '{targetKey}' does not exist.");
}
if (target.Path.StartsWith(folder.Path))
{
throw new OperationException("Folder cannot be moved inside itself.");
}
var oldPath = folder.Path;
var newPath = PathHelper.Combine(target.Path, folder.Slug);
var depthDiff = target.Depth - folder.Depth + 1;
var allFolders = await _db.Folders
.Where(x => x.Key == folderKey || x.Path.StartsWith(oldPath + "/"))
.ToListAsync();
var newPaths = allFolders.Select(x => x.Path.Replace(oldPath, newPath)).ToList();
var conflict = await _db.Folders.FirstOrDefaultAsync(x => newPaths.Contains(x.Path));
if (conflict != null)
{
throw new OperationException($"Folder name conflict: path '{conflict.Path}' already exists at destination.");
}
foreach (var f in allFolders)
{
f.Path = f.Path.Replace(oldPath, newPath);
f.Depth += depthDiff;
}
await _db.SaveChangesAsync();
await _jobSvc.RunAsync(JobBuilder.For <RebuildInheritedTagsJob>().SupersedeAll());
}
/// <summary>
/// Updates the existing folder.
/// </summary>
public async Task <FolderTitleVM> UpdateAsync(string key, FolderVM vm)
{
await ValidateAsync(vm, key);
var folder = await _db.Folders
.Include(x => x.Tags)
.FirstOrDefaultAsync(x => x.Key == key);
if (folder.Slug != vm.Slug)
{
// update paths in subfolders
var oldPath = folder.Path;
var newPath = PathHelper.Combine(PathHelper.GetParentPath(folder.Path), vm.Slug);
folder.Path = newPath;
var subfolders = await _db.Folders
.Where(x => x.Path.StartsWith(oldPath) && x.Depth > folder.Depth)
.ToListAsync();
foreach (var subfolder in subfolders)
{
subfolder.Path = newPath + subfolder.Path.Substring(oldPath.Length);
}
}
_mapper.Map(vm, folder);
var oldTags = folder.Tags?.Select(x => x.TagId).OrderBy(x => x).ToList() ?? new List <int>();
var newTags = vm.Tags?.OrderBy(x => x).ToList() ?? new List <int>();
folder.Tags = vm.Tags?.Select(x => new FolderTagBinding {
TagId = x
}).ToList();
await _db.SaveChangesAsync();
if (!oldTags.SequenceEqual(newTags))
{
await _jobSvc.RunAsync(JobBuilder.For <RebuildInheritedTagsJob>().SupersedeAll()); // sic! run in background
}
return(_mapper.Map <FolderTitleVM>(folder));
}
public async Task RescheduleOnFinish()
{
// Schedule = every 0.1 second
// Run for 1 second
// Execution takes 1.1 seconds
// Total runs should be 1
var runTimes = new List <DateTime>();
var count = 0;
Action action = () => {
runTimes.Add(DateTime.Now);
count++;
Thread.Sleep(1100);
};
var job = JobBuilder.For(action).Repeat.OnInterval(TimeSpan.FromSeconds(0.1)).Build();
var scheduler = new Scheduler.Scheduler();
scheduler.AddJob(job);
scheduler.Start();
await Task.Delay(TimeSpan.FromSeconds(1));
scheduler.Stop();
Assert.AreEqual(1, count); // Starts straight away
}
