/// <summary>
/// Publishes the valid event bus message asynchronously.
/// </summary>
/// <param name="message">The message to publish.</param>
/// <returns>A task that represents the asynchronous operation.</returns>
protected override async Task PublishValidMessageAsync(IEventBusMessage message)
{
await Task.Run(() =>
{
this.PublishValidMessage(message);
});
}
/// <summary>
/// Publishes the valid event bus message.
/// </summary>
/// <param name="message">The message to publish.</param>
protected override void PublishValidMessage(IEventBusMessage message)
{
using (var channel = publisherConnection.CreateModel())
{
string queueName = message.MessageTagInfo.MessageTagString;
channel.ExchangeDeclare(this.BusId, ExchangeType.Direct);
channel.QueueDeclare(queueName, true, false, true, new Dictionary <string, object>()
{
{ "x-queue-mode", "lazy" }
});
channel.QueueBind(queueName, this.BusId, message.MessageEventId);
var properties = channel.CreateBasicProperties();
properties.DeliveryMode = 2;
properties.AppId = this.ApplicationId;
channel.BasicPublish(this.BusId,
queueName,
true,
properties,
this.MessageSerializer.SerializeToBytes(message));
}
}
/// <summary>
/// Validates the specified message.
/// </summary>
/// <param name="message">The message.</param>
private void ValidateMessage(IEventBusMessage message)
{
if (!message.IsValid())
{
string logMessage = $"Can't publish invalid message {message}";
throw new EventBusException(logMessage);
}
}
public async Task <string> Publish(IEventBusMessage message)
{
using (await SyncLock.Lock())
await Task.Delay(5.Milliseconds()); // Ensure the file names are unique.
var path = Folder.GetFile(DateTime.UtcNow.Ticks.ToString());
await path.WriteAllTextAsync(JsonConvert.SerializeObject(message));
return(path.Name);
}
public void Publish(IEventBusMessage message)
{
_topicClient
.SendAsync(new BrokeredMessage(Newtonsoft.Json.JsonConvert.SerializeObject(message, new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
})))
.GetAwaiter()
.GetResult();
}
/// <summary>
/// Publishes the specified event bus message asynchronously.
/// </summary>
/// <param name="message">The message to publish.</param>
public async Task PublishMessageAsync(IEventBusMessage message)
{
this.ValidateMessage(message);
if (!this.Connect())
{
throw new EventBusException($"Can't establish connection to publish message {message}");
}
await this.PublishValidMessageAsync(message);
}
/// <summary>
/// Publishes the specified event bus message.
/// </summary>
/// <param name="message">The message to publish.</param>
public void PublishMessage(IEventBusMessage message)
{
this.ValidateMessage(message);
if (!this.Connect())
{
throw new EventBusException($"Can't establish connection to publish message {message}");
}
this.PublishValidMessage(message);
}
async Task <IEventBusMessage> GetMessage(IEntity item)
{
IEventBusMessage result = null;
try { result = await ToMessage(item); }
catch (Exception ex)
{
Log.For(this).Error(ex, $"Failed to create an event bus message for {item.GetType().FullName} with ID of {item.GetId()}");
}
return(result);
}
public async Task <string> Publish(IEventBusMessage message)
{
FileInfo path;
using (await SyncLock.Lock())
{
path = Folder.GetFile(DateTime.UtcNow.Ticks.ToString());
}
await path.WriteAllTextAsync(JsonConvert.SerializeObject(message));
return(path.Name);
}
public async Task PublishAsync(IEventBusMessage eventMessage)
{
await RetryPolicy.Handle <BrokerUnreachableException>()
.Or <SocketException>()
.Or <InvalidOperationException>()
.WaitAndRetryForeverAsync(retryAttempt => TimeSpan.FromSeconds(5), (ex, time) =>
{
Log.Error(ex, ex.Message);
}).ExecuteAsync(async() =>
{
await ExecuteAsync(eventMessage);
});
}
public async Task <string> Publish(IEventBusMessage message)
{
var request = new SendMessageRequest
{
QueueUrl = QueueUrl,
MessageBody = JsonConvert.SerializeObject(message)
};
if (QueueUrl.EndsWith(".fifo"))
{
request.MessageDeduplicationId = message.DeduplicationId;
request.MessageGroupId = "Default";
}
var response = await Client.SendMessageAsync(request);
return(response.MessageId);
}
public override async Task ExecuteAsync(IEventBusMessage eventMessage)
{
using (var channel = await _rabbitMqClient.CreateModel())
{
channel.QueueDeclare(queue: _rabbitMqConfiguration.QueueName, durable: false, exclusive: false, autoDelete: false, arguments: null);
JsonSerializerSettings settings = new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Objects,
Formatting = Formatting.None
};
var json = JsonConvert.SerializeObject(eventMessage, settings);
var body = Encoding.UTF8.GetBytes(json);
Log.Information($"publishing event on queue: { _rabbitMqConfiguration.QueueName} with id: {eventMessage.Id}");
channel.BasicPublish(exchange: "", routingKey: _rabbitMqConfiguration.QueueName, basicProperties: null, body: body);
}
}
/// <summary>
/// Publishes the valid event bus message asynchronously.
/// </summary>
/// <param name="message">The message to publish.</param>
/// <returns>A task that represents the asynchronous operation.</returns>
protected override async Task PublishValidMessageAsync(IEventBusMessage message)
{
await this.pubSubClient.PublishAsync(message.MessageEventId, this.MessageSerializer.SerializeToString(message));
}
/// <summary>
/// Publishes the valid event bus message.
/// </summary>
/// <param name="message">The message to publish.</param>
protected override void PublishValidMessage(IEventBusMessage message)
{
this.pubSubClient.Publish(message.MessageEventId, this.MessageSerializer.SerializeToString(message));
}
/// <summary>
/// Publishes the specified event to the current event bus provider.
/// </summary>
/// <returns>The unique id of the queue item.</returns>
public static Task <string> Publish(this IEventBusQueue queue, IEventBusMessage message)
{
var textMessage = JsonConvert.SerializeObject(message);
return(queue.Publish(textMessage));
}
public abstract Task ExecuteAsync(IEventBusMessage eventMessage);
/// <summary> /// Publishes the valid event bus message asynchronously. /// </summary> /// <param name="message">The message to publish.</param> protected abstract Task PublishValidMessageAsync(IEventBusMessage message);
/// <summary> /// Publishes the valid event bus message. /// </summary> /// <param name="message">The message to publish.</param> protected abstract void PublishValidMessage(IEventBusMessage message);
/// <summary>
/// Publishes the valid event bus message.
/// </summary>
/// <param name="message">The message to publish.</param>
protected override void PublishValidMessage(IEventBusMessage message)
{
this.PublishValidMessageAsync(message).RunSynchronously();
}
/// <summary>
/// Publishes the valid event bus message asynchronously.
/// </summary>
/// <param name="message">The message to publish.</param>
/// <returns>A task that represents the asynchronous operation.</returns>
protected override async Task PublishValidMessageAsync(IEventBusMessage message)
{
await this.producer.ProduceAsync(message.MessageTagInfo.MessageTagString,
Encoding.Unicode.GetBytes(message.MessageEventId), this.MessageSerializer.SerializeToBytes(message));
}
