private async Task DequeueMessagesAsync()
{
while (!_stopTokenSource.IsCancellationRequested)
{
try
{
PushQueueItem queueItem = await _messagesQueue.DequeueAsync(_stopTokenSource.Token);
if (!_stopTokenSource.IsCancellationRequested)
{
var recipientProvider = GetRecipientProvider(queueItem.RecipientProviderName);
if (recipientProvider != null)
{
var subscriptions = await recipientProvider.GetRecipients(queueItem, _stopTokenSource.Token);
foreach (var subscription in subscriptions)
{
var pushMessage = FromModel(queueItem.Message);
await _notificationService.SendNotificationAsync(subscription, pushMessage, _stopTokenSource.Token);
}
}
else
{
_log.LogWarning($"failed to send notification because IPushNotificationRecipientProvider with name {queueItem.RecipientProviderName} was not found");
}
}
}
catch (Exception ex)
{
_log.LogError($"{ex.Message}:{ex.StackTrace}");
}
}
}
public async Task Handle(string projectId, string pageId, CancellationToken cancellationToken = default(CancellationToken))
{
var page = await _pageQueries.GetPage(projectId, pageId, cancellationToken);
var url = await _pageUrlResolver.ResolvePageUrl(page);
var message = new PushMessageModel()
{
MessageType = "contentdelete",
Body = "Content deleted",
Data = url
};
if (page.Slug == "home")
{
message.Data = "/";
}
var queueItem = new PushQueueItem(
message,
BuiltInRecipientProviderNames.AllButCurrentUserPushNotificationRecipientProvider);
queueItem.TenantId = page.ProjectId;
queueItem.RecipientProviderCustom1 = _userIdResolver.GetCurrentUserId();
_pushNotificationsQueue.Enqueue(queueItem);
}
public async Task Handle(
string projectId,
IPage page,
CancellationToken cancellationToken = default(CancellationToken)
)
{
var url = await _pageUrlResolver.ResolvePageUrl(page);
var message = new PushMessageModel()
{
MessageType = "contentupdate",
Body = "Content updated",
Data = url
};
if (page.Slug == "home")
{
message.Data = "/";
}
var queueItem = new PushQueueItem(
message,
BuiltInRecipientProviderNames.AllButCurrentUserPushNotificationRecipientProvider);
queueItem.TenantId = page.ProjectId;
queueItem.RecipientProviderCustom1 = _userIdResolver.GetCurrentUserId();
_pushNotificationsQueue.Enqueue(queueItem);
//TODO: need to extract all image urls and sned message to sw to add to cache if not in there already
// or maybe need an event for file system when files added or deleted
}
public void PushQueueItemTest()
{
using (var InnerEyeQueue = GetTestMessageQueue())
{
var expected =
new PushQueueItem(
new GatewayApplicationEntity("Test1", 160, "127.0.0.1"),
"Test2",
"Test2",
Guid.NewGuid(),
DateTime.UtcNow,
"Test3",
"Test4",
"Test5");
TransactionalEnqueue(InnerEyeQueue, expected);
var actual = TransactionalDequeue <PushQueueItem>(InnerEyeQueue);
Assert.AreEqual(expected.AssociationGuid, actual.AssociationGuid);
Assert.AreEqual(expected.CalledApplicationEntityTitle, actual.CalledApplicationEntityTitle);
Assert.AreEqual(expected.CallingApplicationEntityTitle, actual.CallingApplicationEntityTitle);
Assert.AreEqual(expected.AssociationDateTime, actual.AssociationDateTime);
Assert.AreEqual(expected.DestinationApplicationEntity.IpAddress, actual.DestinationApplicationEntity.IpAddress);
Assert.AreEqual(expected.DestinationApplicationEntity.Port, actual.DestinationApplicationEntity.Port);
Assert.AreEqual(expected.DestinationApplicationEntity.Title, actual.DestinationApplicationEntity.Title);
Assert.AreEqual(expected.FilePaths.ElementAt(0), actual.FilePaths.ElementAt(0));
Assert.AreEqual(expected.FilePaths.ElementAt(1), actual.FilePaths.ElementAt(1));
Assert.AreEqual(expected.FilePaths.ElementAt(2), actual.FilePaths.ElementAt(2));
}
}
public void TestPushQueueItem()
{
// Get the receive queue
using (var queue = GetUniqueMessageQueue())
{
var queueItem = new PushQueueItem(
destinationApplicationEntity: new GatewayApplicationEntity("Test3", 105, "Test4"),
calledApplicationEntityTitle: "TestAet",
callingApplicationEntityTitle: "Test6",
associationGuid: Guid.NewGuid(),
associationDateTime: DateTime.UtcNow,
filePaths: new[] {
@"c:\sdgfsd",
@"arandompath",
@"d:\temp\dicomfile.dcm"
})
{
DequeueCount = 3
};
TransactionalEnqueue(queue, queueItem);
var item = TransactionalDequeue <PushQueueItem>(queue);
Assert.IsNotNull(item);
AssertAllProperties(queueItem, item);
}
}
public async Task Handle(string projectId, IPost post, CancellationToken cancellationToken = default(CancellationToken))
{
var project = await _projectSettingsResolver.GetCurrentProjectSettings(cancellationToken);
var url = await _blogUrlResolver.ResolvePostUrl(post, project);
var message = new PushMessageModel()
{
MessageType = "newcontent",
Body = "New content",
Data = url
};
var queueItem = new PushQueueItem(
message,
BuiltInRecipientProviderNames.AllButCurrentUserPushNotificationRecipientProvider);
queueItem.TenantId = post.BlogId;
queueItem.RecipientProviderCustom1 = _userIdResolver.GetCurrentUserId();
_pushNotificationsQueue.Enqueue(queueItem);
//TODO: need to extract all image urls and sned message to sw to add to cache if not in there already
// or maybe need an event for file system when files added or deleted
}
private static void Enqueue(PushQueueItem queueItem, string messageQueuePath)
{
using (var messageQueue = new SqliteMessageQueue(messageQueuePath))
{
Enqueue(queueItem, messageQueue);
}
}
private static void Enqueue(PushQueueItem queueItem, SqliteMessageQueue messageQueue)
{
using (var queueTransaction = messageQueue.CreateQueueTransaction())
{
queueTransaction.Begin();
messageQueue.Enqueue(queueItem, queueTransaction);
queueTransaction.Commit();
}
}
public void Enqueue(PushQueueItem item)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
_queue.Enqueue(item);
_messageEnqueuedSignal.Release();
}
public IActionResult BroadcastNotification([FromBody] PushMessageModel message)
{
var queueItem = new PushQueueItem(
message,
BuiltInRecipientProviderNames.AllSubscribersPushNotificationRecipientProvider);
queueItem.TenantId = _tenantIdResolver.GetTenantId();
_pushNotificationsQueue.Enqueue(queueItem);
return(NoContent());
}
public void SqliteTestConcurrentReadWrite4()
{
var messageQueuePath = $@".\Private$\{Guid.NewGuid()}";
const int numberMessages = 10;
using (var messageQueue = new SqliteMessageQueue(messageQueuePath))
{
messageQueue.Clear();
}
var expectedResults = new PushQueueItem[numberMessages];
var actualResults = new PushQueueItem[numberMessages];
for (var i = 0; i < numberMessages; i++)
{
expectedResults[i] = CreateRandomQueueItem(i);
}
using (var messageQueue = new SqliteMessageQueue(messageQueuePath))
{
using (var messageQueueTransaction = messageQueue.CreateQueueTransaction())
{
messageQueueTransaction.Begin();
Parallel.For(0, numberMessages * 2, i =>
{
if (i % 2 == 0)
{
messageQueue.Enqueue(expectedResults[i / 2], messageQueueTransaction);
}
else
{
var dequeueResult = TryDequeue <PushQueueItem>(messageQueue, messageQueueTransaction, timeoutMs: 120 * 1000);
if (actualResults[dequeueResult.DequeueCount] != null)
{
throw new ArgumentException("This item has already been dequeued. Something is wrong.");
}
actualResults[dequeueResult.DequeueCount] = dequeueResult;
}
});
messageQueueTransaction.Commit();
}
}
for (var i = 0; i < numberMessages; i++)
{
AssertCompare(expectedResults[i], actualResults[i]);
}
}
/// <summary>
/// Shorthand for creating an association status log entry.
/// </summary>
/// <param name="associationStatus">Association status.</param>
/// <param name="information">Freeform information about log item.</param>
/// <param name="queueItemBase">Queue item base.</param>
/// <param name="deleteQueueItem">Delete queue item.</param>
/// <param name="downloadQueueItem">Download queue item.</param>
/// <param name="downloadProgress">Download progress.</param>
/// <param name="downloadError">Download error.</param>
/// <param name="pushQueueItem">Push queue item.</param>
/// <param name="uploadQueueItem">Upload queue item.</param>
/// <param name="segmentationId">Segmentation id.</param>
/// <param name="modelId">Model id.</param>
/// <param name="destination">Destination.</param>
/// <param name="path">Path.</param>
/// <param name="failedDicomTags">String formatted list of failed DICOM tags.</param>
/// <param name="dicomDataReceiverProgress">Receiver progress.</param>
/// <returns>New LogEntry of type SegmentationStatus.</returns>
public static LogEntry Create(
AssociationStatus associationStatus,
string information = null,
QueueItemBase queueItemBase = null,
DeleteQueueItem deleteQueueItem = null,
DownloadQueueItem downloadQueueItem = null,
int?downloadProgress = null,
string downloadError = null,
PushQueueItem pushQueueItem = null,
UploadQueueItem uploadQueueItem = null,
string segmentationId = null,
string modelId = null,
(string ipAddress, string title, int port)?destination = null,
public IActionResult SendNotificationToSelf([FromBody] PushMessageModel message)
{
var queueItem = new PushQueueItem(
message,
BuiltInRecipientProviderNames.SingleUserPushNotificationRecipientProvider);
queueItem.TenantId = _tenantIdResolver.GetTenantId();
queueItem.RecipientProviderCustom1 = _userIdResolver.GetCurrentUserId();
_pushNotificationsQueue.Enqueue(queueItem);
return(NoContent());
}
public void SqliteTestConcurrentReadWrite3()
{
var messageQueuePath = $@".\Private$\{Guid.NewGuid()}";
const int numberThreads = 4;
const int numberMessagesPerThread = 10;
const int numberMessages = numberThreads * numberMessagesPerThread;
using (var messageQueue = new SqliteMessageQueue(messageQueuePath))
{
messageQueue.Clear();
}
var expectedResults = new PushQueueItem[numberMessages];
var actualResults = new PushQueueItem[numberMessages];
for (var i = 0; i < numberMessages; i++)
{
expectedResults[i] = CreateRandomQueueItem(i);
}
Parallel.For(0, numberThreads, i =>
{
for (var ii = 0; ii < numberMessagesPerThread * 2; ii++)
{
// Switch between reading and writing
if (ii % 2 == 0)
{
Enqueue(expectedResults[(i * numberMessagesPerThread) + (ii / 2)], messageQueuePath);
}
else
{
var dequeueResult = Dequeue(messageQueuePath);
if (actualResults[dequeueResult.DequeueCount] != null)
{
throw new ArgumentException("This item has already been dequeued. Something is wrong.");
}
actualResults[dequeueResult.DequeueCount] = dequeueResult;
}
}
});
for (var i = 0; i < numberMessages; i++)
{
AssertCompare(expectedResults[i], actualResults[i]);
}
}
private static void AssertCompare(PushQueueItem expected, PushQueueItem actual)
{
Assert.AreEqual(expected.AssociationGuid, actual.AssociationGuid);
Assert.AreEqual(expected.CalledApplicationEntityTitle, actual.CalledApplicationEntityTitle);
Assert.AreEqual(expected.CallingApplicationEntityTitle, actual.CallingApplicationEntityTitle);
Assert.AreEqual(expected.AssociationDateTime, actual.AssociationDateTime);
Assert.AreEqual(expected.DequeueCount, actual.DequeueCount);
Assert.AreEqual(expected.DestinationApplicationEntity.IpAddress, actual.DestinationApplicationEntity.IpAddress);
Assert.AreEqual(expected.DestinationApplicationEntity.Port, actual.DestinationApplicationEntity.Port);
Assert.AreEqual(expected.DestinationApplicationEntity.Title, actual.DestinationApplicationEntity.Title);
for (var i = 0; i < expected.FilePaths.Count(); i++)
{
Assert.AreEqual(expected.FilePaths.ElementAt(i), actual.FilePaths.ElementAt(i));
}
}
private void SendNewContentNotification(string url)
{
var message = new PushMessageModel()
{
MessageType = "newcontent",
Body = "New content",
Data = url
};
var queueItem = new PushQueueItem(
message,
BuiltInRecipientProviderNames.AllButCurrentUserPushNotificationRecipientProvider);
queueItem.TenantId = _tenantIdResolver.GetTenantId();
queueItem.RecipientProviderCustom1 = _userIdResolver.GetCurrentUserId();
_pushNotificationsQueue.Enqueue(queueItem);
}
public void SqliteTestConcurrentReadWrite2()
{
var messageQueuePath = $@".\Private$\{Guid.NewGuid()}";
const int numberMessages = 100;
using (var messageQueue = new SqliteMessageQueue(messageQueuePath))
{
messageQueue.Clear();
}
var expectedResults = new PushQueueItem[numberMessages];
var actualResults = new PushQueueItem[numberMessages];
for (var i = 0; i < numberMessages; i++)
{
expectedResults[i] = CreateRandomQueueItem(i);
}
Parallel.For(0, numberMessages * 2, i =>
{
if (i >= numberMessages)
{
var dequeueResult = Dequeue(messageQueuePath);
if (actualResults[dequeueResult.DequeueCount] != null)
{
throw new ArgumentException("This item has already been dequeued. Something is wrong.");
}
actualResults[dequeueResult.DequeueCount] = dequeueResult;
}
else
{
Enqueue(expectedResults[i], messageQueuePath);
}
});
for (var i = 0; i < numberMessages; i++)
{
AssertCompare(expectedResults[i], actualResults[i]);
}
}
public async Task Handle(string projectId, string postId, CancellationToken cancellationToken = default(CancellationToken))
{
var post = await _postQueries.GetPost(projectId, postId, cancellationToken);
var project = await _projectSettingsResolver.GetCurrentProjectSettings(cancellationToken);
var url = await _blogUrlResolver.ResolvePostUrl(post, project);
var message = new PushMessageModel()
{
MessageType = "contentdelete",
Body = "Content deleted",
Data = url
};
var queueItem = new PushQueueItem(
message,
BuiltInRecipientProviderNames.AllButCurrentUserPushNotificationRecipientProvider);
queueItem.TenantId = post.BlogId;
queueItem.RecipientProviderCustom1 = _userIdResolver.GetCurrentUserId();
_pushNotificationsQueue.Enqueue(queueItem);
}
public async Task <IEnumerable <PushDeviceSubscription> > GetRecipients(PushQueueItem pushQueueItem, CancellationToken cancellationToken)
{
return(await _pushSubscriptionStore.GetSubscriptionsForUser(pushQueueItem.TenantId, pushQueueItem.RecipientProviderCustom1, cancellationToken));
}
public async Task <IEnumerable <PushDeviceSubscription> > GetRecipients(PushQueueItem pushQueueItem, CancellationToken cancellationToken)
{
return(await _pushSubscriptionStore.GetAllSubscriptions(pushQueueItem.TenantId, cancellationToken));
}
