public async Task DeletePhotoCacheEventFired()
{
var completeInfo = new TaskCompleteInfo(TaskType.ClearCache, "wdavidsen", true);
_photoData.Setup(m => m.DeletePhotos());
_fileSystemService.Setup(m => m.DeleteDirectoryFiles(It.IsAny <string>(), It.IsAny <bool>()));
await _photoService.DeletePhotoCache(completeInfo.ContextUserName);
var queueEvents = new Mock <IQueueEvents>();
queueEvents.SetupGet(m => m.ItemProcessed).Returns((info) =>
{
Assert.Equal(completeInfo.Type, info.Type);
Assert.Equal(completeInfo.Success, info.Success);
Assert.Equal(completeInfo.ContextUserName, info.ContextUserName);
});
try
{
var token = new CancellationTokenSource().Token;
var workItem = await _backgroundQueue.DequeueAsync(token);
await workItem(token, queueEvents.Object);
}
catch (TaskCanceledException) { }
}
public async Task QueueMobileResizeEventFired()
{
var filePath = Path.Combine("MobileUploads", DateTime.Now.ToString("yyyy-MM"), "birthday.jpg");
var cacheDir = Path.Combine("homePhotos", "cache");
var checksum = "abc123";
var completeInfo = new TaskCompleteInfo(TaskType.ProcessMobilePhoto, "wdavidsen", true);
_fileSystemService.Setup(m => m.GetChecksum(It.IsAny <string>())).Returns(checksum);
_fileSystemService.Setup(m => m.GetDirectoryTags(It.IsAny <string>())).Returns(new List <string> {
"Tag1", "Tag2"
});
_photoService.Setup(m => m.GetPhotoByChecksum(It.IsAny <string>())).ReturnsAsync(default(Photo));
_dynamicConfig.SetupGet(o => o.CacheFolder).Returns(cacheDir);
_dynamicConfig.SetupGet(o => o.LargeImageSize).Returns(800);
_dynamicConfig.SetupGet(o => o.ThumbnailSize).Returns(200);
_dynamicConfig.SetupGet(o => o.MobileUploadsFolder).Returns("MobileUploads");
var cachePath = await _imageService.QueueMobileResize(completeInfo.ContextUserName, filePath);
var queueEvents = new Mock <IQueueEvents>();
queueEvents.SetupGet(m => m.ItemProcessed).Returns((info) =>
{
Assert.Equal(completeInfo.Type, info.Type);
Assert.Equal(completeInfo.Success, info.Success);
Assert.Equal(completeInfo.ContextUserName, info.ContextUserName);
Assert.NotNull(info.Data);
Assert.Equal(filePath, info.Data.ToString());
});
try
{
var token = new CancellationTokenSource().Token;
var workItem = await _backgroundQueue.DequeueAsync(token);
await workItem(token, queueEvents.Object);
}
catch (TaskCanceledException) { }
}
public async Task DeletePhotoCache()
{
var completeInfo = new TaskCompleteInfo(TaskType.ClearCache, "wdavidsen", true);
_photoData.Setup(m => m.DeletePhotos());
_fileSystemService.Setup(m => m.DeleteDirectoryFiles(It.IsAny <string>(), It.IsAny <bool>()));
await _photoService.DeletePhotoCache(completeInfo.ContextUserName);
try
{
var token = new CancellationTokenSource().Token;
var workItem = await _backgroundQueue.DequeueAsync(token);
await workItem(token, new QueueEvents { ItemProcessed = (info) => { } });
}
catch (TaskCanceledException) { }
_photoData.Verify(m => m.DeletePhotos(),
Times.Once);
_fileSystemService.Verify(m => m.DeleteDirectoryFiles(It.IsAny <string>(), It.IsAny <bool>()),
Times.Once);
}
public async Task DeletePhotoCacheHandlesException()
{
var completeInfo = new TaskCompleteInfo(TaskType.ClearCache, "wdavidsen", false);
_photoData.Setup(m => m.DeletePhotos());
_fileSystemService.Setup(m => m.DeleteDirectoryFiles(It.IsAny <string>(), It.IsAny <bool>()))
.Throws(new Exception("Some error"));
/* _logger.Setup(m => m.Log<FormattedLogValues>(LogLevel.Error, 0, It.IsAny<string>(), It.IsAny<Exception>(), It.IsAny<Func<FormattedLogValues, Exception, string>>())); */
await _photoService.DeletePhotoCache(completeInfo.ContextUserName);
var queueEvents = new Mock <IQueueEvents>();
queueEvents.SetupGet(m => m.ItemProcessed).Returns((info) =>
{
Assert.Equal(completeInfo.Type, info.Type);
Assert.Equal(completeInfo.Success, info.Success);
Assert.Equal(completeInfo.ContextUserName, info.ContextUserName);
});
try
{
var token = new CancellationTokenSource().Token;
var workItem = await _backgroundQueue.DequeueAsync(token);
await workItem(token, queueEvents.Object);
}
catch (TaskCanceledException) { }
_photoData.Verify(m => m.DeletePhotos(),
Times.Once);
_fileSystemService.Verify(m => m.DeleteDirectoryFiles(It.IsAny <string>(), It.IsAny <bool>()),
Times.Once);
/* _logger.Verify(m => m.Log(It.IsAny<LogLevel>(), 0, It.IsAny<PhotoService>(), It.IsAny<Exception>(), It.IsAny<Func<PhotoService, Exception, string>>()),
* Times.Once); */
}
public void OnItemProcessed(TaskCompleteInfo info)
{
switch (info.Type)
{
case TaskType.ClearCache:
_notificationHub.Clients.All.SendAdminsMessage(
info.Success.Value ? "success" : "error",
info.Success.Value ? "Photo cache cleared" : "Failed to clear photo cache");
break;
case TaskType.ProcessMobilePhoto:
_uploadTracker.RemoveUpload((string)info.Data);
var timer = new Timer((state) => {
if (_uploadTracker.IsProcessingDone(info.ContextUserName))
{
var uploadCount = _uploadTracker.GetUploadCount(info.ContextUserName);
_notificationHub.Clients.All.SendEveryoneMessage("info", $"{info.ContextUserName} uploaded {uploadCount} photos");
}
}, null, 1000 * 2, 0);
break;
}
}
public void ProcessThread(object state)
{
while (!_cancel.IsCancellationRequested)
{
TaskInfo task = null;
lock (_queue)
{
if (_queue.Count > 0)
{
task = _queue.Dequeue();
}
}
if (task == null)
{
WaitHandle.WaitAny(new WaitHandle[] { _taskAdded, _cancel.Token.WaitHandle });
continue;
}
if (_cancel.IsCancellationRequested)
{
return;
}
_runningCount++;
try
{
DateTime?runAgainOnError = DateTime.Now.AddHours(1);
SchedulerItem item = _repository.GetSchedulerItem(task.SchedulerItemGuid);
TaskCompleteInfo completeInfo = new TaskCompleteInfo();
completeInfo.Id = task.Id;
completeInfo.StartDateTime = DateTime.Now;
if (item != null)
{
SchedulerItemActionContext context = new SchedulerItemActionContext(
item, completeInfo.StartDateTime, task.DataXml, (ex) => _logger.LogError(ex, sourceId: task.SchedulerItemGuid));
Stopwatch stopwatch = Stopwatch.StartNew();
try
{
#if DEBUG
//System.Windows.MessageBox.Show("TaskExecutor. Attach Debugger Now.");
#endif
StringBuilder result = new StringBuilder();
foreach (SchedulerItemAction action in item.Actions)
{
string text = action.Execute(context);
if (!string.IsNullOrEmpty(text))
{
if (result.Length > 0)
{
result.AppendLine();
}
result.Append(text);
}
}
foreach (SchedulerItemEvent @event in item.Events)
{
@event.OnExecuted(context);
}
completeInfo.Result = result.ToString();
completeInfo.NextExecuteDateTime = context.NextExecuteDateTime;
completeInfo.NextExecuteDataXml = context.NextExecuteDataXml;
completeInfo.DeleteSchedulerItem = context.DeleteSchedulerItem;
}
catch (Exception e)
{
_logger.LogError(e, sourceId: task.SchedulerItemGuid);
completeInfo.Result = e.Message;
completeInfo.IsError = true;
completeInfo.NextExecuteDateTime = runAgainOnError;
completeInfo.NextExecuteDataXml = task.DataXml;
}
finally
{
stopwatch.Stop();
completeInfo.Duration = stopwatch.Elapsed;
}
}
if (_cancel.IsCancellationRequested)
{
return;
}
_repository.OnTaskComplete(completeInfo);
}
catch (Exception e)
{
_logger.LogError(e, sourceId: task.SchedulerItemGuid);
}
finally
{
_runningCount--;
}
}
}
