/// <inheritdoc cref="SendAsync{TQueue, TMessage}(TMessage)"/>
public static Task SendAsync <TQueue>(ICommandMessage <TQueue> message, Type messageType)
where TQueue : ISendCommandQueue, new()
{
RockLogger.Log.Debug(RockLogDomains.Core, "Send Message Async: {@message} Message Type: {1}", message, messageType);
if (!IsReady())
{
ExceptionLogService.LogException($"A message was sent before the message bus was ready: {RockMessage.GetLogString( message )}");
return(Task.CompletedTask);
}
var queue = RockQueue.Get <TQueue>();
var endpoint = _transportComponent.GetSendEndpoint(_bus, queue.NameForConfiguration);
message.SenderNodeName = NodeName;
// NOTE: Use Task.Run to wrap an async instead of directly using async, otherwise async will get an exception if it isn't done before the HttpContext is disposed.
return(Task.Run(async() =>
{
await endpoint.Send(message, messageType, context =>
{
context.TimeToLive = RockQueue.GetTimeToLive(queue);
});
}));
}
/// <summary>
/// Synchronizes the rebuild status.
/// </summary>
private void SyncRebuildStatus()
{
if (RockQueue.IsExecuting <StreakTypeRebuildTransaction>())
{
var progress = RockQueue.CurrentlyExecutingTransactionProgress;
if (progress.HasValue)
{
ShowBlockNotification(nbEditModeMessage, string.Format(
"A streak type rebuild is running and is {0}% complete. Please check back later.",
progress.Value));
}
else
{
ShowBlockNotification(nbEditModeMessage, "A streak type rebuild is currently running. Please check back later.");
}
btnRebuild.Enabled = false;
}
else if (RockQueue.IsInQueue <StreakTypeRebuildTransaction>())
{
ShowBlockNotification(nbEditModeMessage, "A streak type rebuild is currently queued. Please check back later.");
btnRebuild.Enabled = false;
}
else
{
btnRebuild.Enabled = true;
}
}
/// <summary>
/// Gets the log string.
/// </summary>
/// <typeparam name="TQueue">The type of the queue.</typeparam>
/// <param name="message">The message.</param>
/// <returns></returns>
public static string GetLogString <TQueue>(IRockMessage <TQueue> message)
where TQueue : IRockQueue, new()
{
var messageJson = message.ToJson();
var queueName = RockQueue.Get <TQueue>().Name;
var messageType = message.GetType().FullName;
return($"Queue: {queueName}\nMessageType: {messageType}\n{messageJson}");
}
/// <summary>
/// Drains the transaction queue.
/// </summary>
public static void DrainTransactionQueue()
{
// process the transaction queue
if (!Global.QueueInUse)
{
Global.QueueInUse = true;
RockQueue.Drain((ex) => LogError(ex, null));
Global.QueueInUse = false;
}
}
/// <summary>
/// Publishes the message.
/// </summary>
/// <typeparam name="TQueue">The type of the queue.</typeparam>
/// <param name="message">The message.</param>
/// <param name="messageType">Type of the message.</param>
public static async Task PublishAsync <TQueue>(IEventMessage <TQueue> message, Type messageType)
where TQueue : IPublishEventQueue, new()
{
if (!IsReady())
{
ExceptionLogService.LogException(new BusException($"A message was published before the message bus was ready: {RockMessage.GetLogString( message )}"));
return;
}
message.SenderNodeName = NodeName;
await _bus.Publish(message, messageType, context =>
{
context.TimeToLive = RockQueue.GetTimeToLive <TQueue>();
});
}
/// <summary>
/// Binds the grid.
/// </summary>
private void BindGrid()
{
var queueKey = PageParameter(PageParameterKey.QueueKey);
var queue = RockQueue.Get(queueKey);
if (queue == null)
{
SetVisible(false);
return;
}
var viewModels = RockConsumer.GetConsumerTypes()
.Where(ct => RockConsumer.GetQueue(ct) == queue)
.Select(ct =>
{
var messageType = RockConsumer.GetMessageType(ct);
return(new ConsumerViewModel
{
ConsumerName = Reflection.GetFriendlyName(ct),
QueueName = queue == null ? null : queue.Name,
MessageName = Reflection.GetFriendlyName(messageType)
});
})
.AsQueryable();
// Sort the query based on the column that was selected to be sorted
var sortProperty = gList.SortProperty;
if (gList.AllowSorting && sortProperty != null)
{
viewModels = viewModels.Sort(sortProperty);
}
else
{
viewModels = viewModels
.OrderBy(vm => vm.QueueName)
.ThenBy(vm => vm.ConsumerName);
}
gList.DataSource = viewModels.ToList();
gList.DataBind();
}
/// <summary>
/// Binds the grid.
/// </summary>
private void BindGrid()
{
gList.DataKeyNames = new string[] { "QueueTypeName" };
var viewModels = RockQueue.GetQueueTypes()
.Select(qt =>
{
var queue = RockQueue.Get(qt);
var queueType =
queue is ISendCommandQueue ? "Command" :
queue is IPublishEventQueue ? "Event" :
"Unknown";
return(new QueueViewModel
{
TimeToLiveSeconds = queue.TimeToLiveSeconds,
QueueTypeName = qt.FullName,
QueueName = queue.Name,
QueueType = queueType,
RatePerDay = queue.StatLog.MessagesConsumedLastDay,
RatePerHour = queue.StatLog.MessagesConsumedLastHour,
RatePerMinute = queue.StatLog.MessagesConsumedLastMinute
});
})
.AsQueryable();
// Sort the query based on the column that was selected to be sorted
var sortProperty = gList.SortProperty;
if (gList.AllowSorting && sortProperty != null)
{
viewModels = viewModels.Sort(sortProperty);
}
else
{
viewModels = viewModels.OrderBy(vm => vm.QueueName);
}
gList.DataSource = viewModels.ToList();
gList.DataBind();
}
/// <inheritdoc cref="PublishAsync{TQueue, TMessage}(TMessage)"/>
public static Task PublishAsync <TQueue>(IEventMessage <TQueue> message, Type messageType)
where TQueue : IPublishEventQueue, new()
{
if (!IsReady())
{
ExceptionLogService.LogException(new BusException($"A message was published before the message bus was ready: {RockMessage.GetLogString( message )}"));
return(Task.CompletedTask);
}
message.SenderNodeName = NodeName;
// NOTE: Use Task.Run to wrap an async instead of directly using async, otherwise async will get an exception if it isn't done before the HttpContext is disposed.
return(Task.Run(async() =>
{
await _bus.Publish(message, messageType, context =>
{
context.TimeToLive = RockQueue.GetTimeToLive <TQueue>();
});
}));
}
/// <summary>
/// Sends the command message.
/// </summary>
/// <typeparam name="TQueue">The type of the queue.</typeparam>
/// <param name="message">The message.</param>
/// <param name="messageType">Type of the message.</param>
public static async Task SendAsync <TQueue>(ICommandMessage <TQueue> message, Type messageType)
where TQueue : ISendCommandQueue, new()
{
RockLogger.Log.Debug(RockLogDomains.Core, "Send Message Async: {@message} Message Type: {1}", message, messageType);
if (!IsReady())
{
ExceptionLogService.LogException($"A message was sent before the message bus was ready: {RockMessage.GetLogString( message )}");
return;
}
var queue = RockQueue.Get <TQueue>();
var endpoint = _transportComponent.GetSendEndpoint(_bus, queue.NameForConfiguration);
message.SenderNodeName = NodeName;
await endpoint.Send(message, messageType, context =>
{
context.TimeToLive = RockQueue.GetTimeToLive(queue);
});
}
/// <summary>
/// Gets an instance of the queue.
/// </summary>
/// <returns></returns>
public static IRockQueue GetQueue()
{
return RockQueue.Get<TQueue>();
}
/// <summary>
/// Gets the queue for the message type.
/// </summary>
/// <param name="messageType">Type of the message.</param>
/// <returns></returns>
public static IRockQueue GetQueue(Type messageType)
{
var queueType = GetQueueType(messageType);
return(RockQueue.Get(queueType));
}
